From c7c567c45f361f539c3822b3679b911c75e3ac2f Mon Sep 17 00:00:00 2001 From: Oscar Franco Date: Tue, 12 Mar 2024 05:21:37 +0100 Subject: [PATCH 1/7] Roll sqlcipher into the iOS project --- .github/workflows/ci.yml | 55 + .yarn/install-state.gz | Bin 1395976 -> 1391812 bytes cpp/bindings.cpp | 48 +- cpp/bridge.cpp | 29 +- cpp/bridge.h | 5 + cpp/sqlcipher/sqlite3.c | 253047 ++++++++++++++++ cpp/sqlcipher/sqlite3.h | 13029 + example/ios/Podfile.lock | 24 +- example/package.json | 1 - example/src/App.tsx | 26 +- example/src/tests/blob.spec.ts | 1 + example/src/tests/dbsetup.spec.ts | 3 + example/src/tests/hooks.spec.ts | 1 + example/src/tests/preparedStatements.spec.ts | 1 + example/src/tests/queries.spec.ts | 1 + gen-sqlcipher.sh | 20 + op-sqlite.podspec | 28 +- src/index.ts | 19 +- yarn.lock | 11 - 19 files changed, 266254 insertions(+), 95 deletions(-) create mode 100644 cpp/sqlcipher/sqlite3.c create mode 100644 cpp/sqlcipher/sqlite3.h create mode 100755 gen-sqlcipher.sh diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 8adcdf85..716bcb2e 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -136,3 +136,58 @@ jobs: - name: Build example for iOS run: | yarn turbo run build:ios --cache-dir="${{ env.TURBO_CACHE_DIR }}" + + build-ios-sqlcipher: + runs-on: self-hosted + env: + TURBO_CACHE_DIR: .turbo/ios + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Setup + uses: ./.github/actions/setup + + - name: install bundler dependencies + run: | + cd example + bundle install + + - name: Cache turborepo for iOS + uses: actions/cache@v3 + with: + path: ${{ env.TURBO_CACHE_DIR }} + key: ${{ runner.os }}-turborepo-ios-${{ hashFiles('yarn.lock') }} + restore-keys: | + ${{ runner.os }}-turborepo-ios- + + - name: Check turborepo cache for iOS + run: | + TURBO_CACHE_STATUS=$(node -p "($(yarn turbo run build:ios --cache-dir="${{ env.TURBO_CACHE_DIR }}" --dry=json)).tasks.find(t => t.task === 'build:ios').cache.status") + + if [[ $TURBO_CACHE_STATUS == "HIT" ]]; then + echo "turbo_cache_hit=1" >> $GITHUB_ENV + fi + + - name: Cache cocoapods + if: env.turbo_cache_hit != 1 + id: cocoapods-cache + uses: actions/cache@v3 + with: + path: | + **/ios/Pods + key: ${{ runner.os }}-cocoapods-${{ hashFiles('example/ios/Podfile.lock') }} + restore-keys: | + ${{ runner.os }}-cocoapods- + + - name: Install cocoapods + # if: env.turbo_cache_hit != 1 && steps.cocoapods-cache.outputs.cache-hit != 'true' + run: | + cd example/ios + OP_SQLITE_USE_SQLCIPHER=1 bundle exec pod install + env: + NO_FLIPPER: 1 + + - name: Build example for iOS + run: | + yarn turbo run build:ios --cache-dir="${{ env.TURBO_CACHE_DIR }}" diff --git a/.yarn/install-state.gz b/.yarn/install-state.gz index c803e361b4222c2e7c59e454f5217356184c0a76..e7886808f74873d88382e35bb6ad4d0e6b057c42 100644 GIT binary patch delta 1230684 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πTwa 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%0AFfg(@ajhYm~6&K$)CN?X-D4edCD`j9Oe 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�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

@=1quq3WwmMw7r*uS&Zq68H!xmBT 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

=`Hv$1a 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�qF8L^u0>J!fM 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 z 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�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≺IQDHFRZFnY6_BM>+l{x*KzI)kRXKUho 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�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 WlHFv#{1w0btNs@q!{q2rOF{r`tY>Hd delta 1234813 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

!oM&)a2Aa&0~JhfeR_`0$+ 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%0Dj*Hi3D7rqlI@JxMwmny0UgtLcmqQS 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

2aXbwSg?89r#to-SYuAOYE=O$m(hA5 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˧iG|A!;>$qV>aY}e+IHeCxasLZtPBJY@+ zxLwh$)fTO;yVlh9)pT2#n^lsFEtw4X% z-c5=yk21Rsp<^j-6X(oiK$jy_B6Mgr$}YF*&OiUrzI^=GN8qw&uiIPmPOW>NB9!^u z48iEKGzNuxKTR}Dmh=Fr6s3E>XKWqlo70c4w6m?&(+*4;^T;~dJPbN(%X0zpN=GL7 z99!08*A}z$S0__@OOH%)`PXD*UZ{V*`lcM&t9P)AZ7HHPwmZ)fLxD_JNyE;ZnfZqz zCsW5vqo1{#W(i>BBeqcXuR?xocGxyym-0h$s1&lFZrNh@bs1Yx40tJ{)zPN4$aXtN{HGfddGSLAK7!rTo9p6(aBp_^=lGGe~AvZgg-PY)~C)3qTYoBZG zL%{|)uJag!P7QO+rRC_?a$y>r?Ba)T9k?7IMve-2r%ne%u^-(ToHd|IAc2ZzNM=FdHmZO(`?UP zw_gYD^ZY0MnZ@EMX6=8A$y_@JVS-7^2s~?oXD!SbIYe9tZ-fmyaI_XQ?Mmu3$~t|| z(MBQ-tTQVzr-Tv4rq_fHiPJ@;H>%8Zb!LTk9s71e|HKSY&tART$FzMH%|ljI`fI6G zDlw%GwUi>JLcS(}G&hjH&7?-@-8`@_5i?peYz60-6vx{ML#%%{T%dz&_%XCNQu{c0 zL@KE<3ILA{ve?#s?haBLeCAkqmI9DG(gHBdUNQ)e!_f*fIXC*WYAGp|8E2L(a}Vv; z+c{lhBxZdm_r!9#t(C~|oQavI=#sNLqvUCJNMV;6vBoVf>A!!y>%9EyyZ!aY7yp-s z#lt7B;P;*VM|OYqKmNS`e5p0Rb^B}G6(Xq{KS3!O*75KY1D--k+Tm%WzNO5#ik4u+ zY*n}niGzuCR?gE*;k&MyH)6uRQr+5tPwWL?H@Cv6KA*wU$T--rb9=06vuxEqQmL&B zwVk-mmUgk~nD1Q7iwWe@eAYQMyrQR7QM=F$s4A|<_(*@1P0KjJJEwx4xi1(6Dtz@=N)WTXIWSIHZkbenB- zMmSo=bxGpH5y=9MKAy5C7>`54XU@9nXsWHA#MA-3DiUH`&NE^}nC9x+g1N!5X-?+b zPTwerhpB&?wX^C}d=bK_2ytv?+J^+9Rm9}Aw9Uq3hmx#`WJXW6W@p zv3uv*+KI!JZo&{cHA9O>A`tX$QqSS(_WdkKv&d9sPDeckr$qQR-C~bZwq(x1(z9Q~ zAUZ}*ZlZ~?e=P*wQiyU&DQL7ti<*ZRPrq1pr7d(uVOyk6nldgB(^p^GZXevg`eo4` zva)}kyLR{O+SfhR-ikmWQXmOc)N(Epl47f*SdEOSTiMXRb0NHs^}PWc(33MH_!Uc; zs;5_)d-YQ$)qJDdQkm4E=e$f+As zl~@1G1=If{Pwlgp@B6m?1KaxZ5Btymp&#Fo2WN=5vU|xh4XZk8-r5V!f+zsck(_y7 zGwP^g93SYhH1%j2(ki#O;tApt&{{Wzv62>b?3~7;(U{jj^~FVl`%8x%G}~>TXRUvo zEn?+D(bV})9m{j~oR7^sc|`fx9tSj3jYDITUN>@aMi(zEp6q0;0_EiB3h<9rPup7E zy_DG)*H_+bi;wNG!f#5Caoe~1%b(Zm5s321OZV$%cKlQN9;%7PIK`0--*gj6HIOBs zRx2h7<$a%gYOc_#eA~kEdRp!@OeB99xT7*~59?glN1{gsMZ6S%=2#Gy=V~WG;+_4} zv)U#?;dhz2RcjJ88DrQ%al9e-i5_OfH*L#`?qU?ejtr#|h2-jkx_dFkwsa5Q3=nA1 zz6xF{tn(&2%4kbVX{w?pmYQYdG^MzM=)v7?>EHY|Ahd9b`tr^nl^dVDeD{Csop05s zNUmEs6k;gdV>U1u+%XdKjr*Krxd53aVbHD+VH&5^o$TaMvlmDy0zU@7=yCLV8%5~_ zgv9H*qsHK7Y1H zsH|r%+FdKA6)v{8S`(Yk!L)Tkf3 z?UgcGfVI30l!moBqqPOb62H{R5NyfzF4d5|Wj(Z0+AL_HHMA7ifn+3X1+d+^7%bf* z-S%Yv=3f{z+aLWJLV7eE{N&|(v-)JEVa-#dReMw<>P2@4Jz+WL3~MzQ0Lp*>8T*PQ zazK)evad@up!iCsEV_SXn~8b%k;9VviR=XcQVOL^uy>`j&~nDRlXt&;P&X5W(g68o z>&pFo=TdybaI8ZCbM)1A+ZYU^k`4wudQ@wzE3{Bz+^J53`pc@0Ueo3JFrFt*bz)fS z-cQY|0}%Ft1$hkD+vvpKU;Fw#>~}9azJ@>U`8<0K-`w1yy3c>slG6gqy2?2@cDstx znc`0sZqap>=GplYwKiK1$)k;R>ZEZ&g?=$5qI8^cB_>{FM{=sV6W+`oyG`owW3DI_ z&j;&$dtTy-x|+#0vWP$$@@Q@CylfHlD#CSCi0r$qZCIikuxgQJ4?S~_Cf?oaN}ciJK3X0|7p#B_BUQUNS?*nWmXppz zkKWPYOlI$=aGx$mX_B8MSRO zPLP`rWMb0X_U;6SkeT+@BLG|eYYrL&Jfn>w&3xe%;;S? zFw7I*MX-=t2RUoWcm4$L!;+h~gyIEowe~cD@9^N={alUBrvEb zQMGdMVIhD2GK*5;fa@JHg$p6C!|jpohn|wSl*-F%K6CZJ|gu~3`g!Yv7s%6)GO!$8!iL83B>lE#z!vyAN2>qV~A1TpR z-DzCk+cVGR#{bW^w(a`;Z_m4bd--C=KEHc;w|_nR`{Ezpzkhelj=lTvOZ@zok+Mfagil`m z2d00yR|;1@$5Wa7_P6LvHn=o{CfONt6H}2PbO#64ws8*bA9OHt5|U_Deu!jmE>SH8{GaGW_J-;*d^8iMutAVl_vLbWU|@#UroUPo2FIlpWm) zV^fIPiY^^EFrk^NX5O{w@W(<>CT<3w#pFma!$=D z)v}rnn`f_jTCS^jkv%$sAF#OEChuG=Dce|&L0xwszSj-M0`ksZ-YUL4du89;a?vH* zMjZ!D5nny#U<&Tj32r~^ zi3_F5xdccd$~<3Y0wXgBU2gl#S1u8K#ymZbGYeDDwqr(sb86cFdHb0tQKClPnBvwc z?z8RWr<@qcko1UOan!ZtbM~M~QzgKX3W|_Yd~d zJAZli(;GMTXRqp;+wCD8iuW9IFj(;aa`$$nKb6gsXsdv8ARoz(Zq_1|uV`FLOcfJPe0nj{#TO zqKRP$qR)qTCy;&Oc=pA8f;Agk2P5^O1q@0aWZO5S%%6$m$boPRFw>N5qtQ^b2$e~|Y1C$h zLiT)?#+n_oyrEEc*u;ddq#;yx^1^bLkju&lzK`MGK<(6CPvf zQn7Z7$AJA4oy&hg;9!F!(UHZqN2x7t2oi=0H^v^RSeexwzQ5&$z-~6$W)9yWUPhzJ z??2}M-R-VlSnMbD(A|Xa2e0XipLlhL2wexdg-{J5%>ek(;pNI}*pWhx?%aqX!mBb; zz$hK?bAUy%6U&dLA<&ipp>1n|49Dg)SNGk+y(0^`U_pNxD-b`nAfUgsu7Nbm=y)W7 zaH9vENQ-qr=ro&Rk}QdDK|8_LXHYmdC0X!umLkCt-n}+Qb?>xVZ)Ql5*|n=W#@I)u zV3G{t!d?e+v6>^5?tkL{+wEq*egFNNebw!s-hBV#yZZ6-YZP#(-S6@t9=ygce(Bui zhGQ9dbsc}EhL!;7_mDnlgznx!bKNv}xFsAw7W5QvS4kV9_+|!qMK^eC5o&jJ3LKdV zensCg8%SM(qBGIMnyX@uT7K(tb1>Q3;MEJ#eXJOUZy9aK}l2qAu&$*wMFQ{HZk{|A2pS8{}yuu2=S;xV!oP>+RYGjdK9$N~c_#oeZ*qXZ{*xg@!&3BA;4> zFKvH{)QQ%R6;nR@Zq<31BU=xyaRhwLHnzb3D7gq}z|rNjHq`;3A2wE7!I=Rs@1dHy zk$W7ap#Mc{!3l%t{fGMBJ>UCx_3_Pq{i)Ehd11#Nys$67*Ju)J%fc{u1yGOBPU}@- zAYg?t#sOJtAlF@_&ECD8fdT|x2QYV#$v}UMb~puQKeJCHaGywM^RzdRqw6G)R#uRS z)g(+5xF5hql+}(kYlkFI z`s`3g{d0}6kdQgaG3Y!yU8)5Epn!qCPI9=~2+NIs90{nx;6p#lwLWao8#M)Xp{Rdd z4OKkP5c7a|9vEx@|NF{*az?EThmOJU$ZoWwz3!F@}Gj{e2~n&)ymn{^a;EHi)qm{CkKucXjH!P1ur| zK$N~6qtC$zbmSak7?}rh$6I4%Z#wjxuEo5@A}G2~^Qc^!#({r+6pH(mXhOPh8qNhs zfhywg04RS?R0};2M9|F)@dX>exUoIHjq1F!?Ju|8AHA?IR&q#GgK`m66Y+m}HjD8< zzH`cG6Rkn1Af6ZuBf0vlE2~mqWvs=6ptqdRVKb!gyM~BNo*g}sj+clSvNYj)81tdXYgeO09p#;)?+59f)6OU2Lc; zBfdPk+ZdpRZ&!lJna)0A7ydmM~p*AeQv~TOr(Lhj2*_xweGCD(Tpep_k|{8{#cGorU7q z_hb?@l8+G@9czE#3N5(D5nE#&moNZYK}Z(YlXX#%Z*{Iw`{-y5MqC(X=iWVIst(}Y zB3kF(_ZDVE)VG|9CL0&L1L=c6yA^MmJ{*bIn_!hk1SGU-1PSb=W5x`2FX=P39+9>H z!tj2-3;XZy?e`y9y|f6oiKZf+Zlgx4JJJ{(Y8zl(ED`a-B1^s zcL^VYNO|h%O-jv8#`2_)>}N$|=s-*WZQ%~6s)C(+PM-sK7V8wq?eg2_dF&3KV{bZ& zceU2C!Bx?Bcsp9fPYvej-t|DJ46iG)HdjGQvN&_JNoYu_>_FzD1_1ohWlWZguG}Jh zyRWvV@j8D5q20;qa{qb$?|!-Ae{{0;=rz4H{;e-&`?(>7huPE$zyis03?GQeMIqnP zf#}+0)D&}qZn^bRCqnB18!dj2Koy*ws5+9Qt=gD|xmD1{FEi@WtZc-og72q?w1vp6 zN(Q`2!oa9^51h-E2cQqkz?LA0(MRjBdTq$lr@?=Nc^o750IGPY>soU(S{P8v6%dCR z9nUodcF^l4j6^RJMA*Gc(99ojy0`m#{rA7z>pyj@_UNU3Y0Dd18bT|!jooEY=ZRRM z@@gIz&VQi_kTs$33`q&(u=cSsM6q;G+^?B!^SE-@3Qm~p64Yl)KxVck5f6a_b+tvk z&E|i(LCJkqww*OOX%7yrmfqSbB<(Wr<77y53)r&ADj73mq@9&bR|F<$LoiHUhR8_+ zXF-?9ail~LIb>v3a>CRL9E!r#+2%yn*;#qN*Z#M^-14W-8dDbB-}mKEk6zXnb+QLJ z@coR$lxpq?MgQpt)xqv;na)Cz6mso)Vj^b+>P;HWy1(E5@t6DkUpRkO zd-MuFyUFQ0eLCGwC6TSoity%52a0XL+ZDMMvA1I&Gy>i&oRt$jKAzd9Nl`;xk$i!r z#4**EEjUE^Dbw_ih z4T2;PprgD(gS?~{XcrrH+u$(ifB%fK?;k(D|J@%+J$vlBzW5TK$!0ZXTUWzlrAZU? zrrXrBD-i+OF_}t(t^jFNNW_2DdE5cbLlf(|c{YTYf&l<%@Li{2c;7ap9c^6P=>d)$ zX+YT-a4gJu`x5U1QkF?S?aO-( z1_VBr@?3j#>DkUu^sB9U3@tT~e|o6*2FLPPwqsDn<(+_xdL%&{4#via9$RMN7l;F< zl}H#qR2Sf~o6wBV$G)LGV%oNduSwf%R0gt9YCh6O2p{ zaAfYRXo}TJbyy65ZAE_wE8?;{Bfx^9^#jeO&+R+W>1xf4(}!WAJ%OE1giCZ(G`A16 z?7*o)>L@B^1M1y?Z}ZA#uX8+s9Xj4@Ox+C81H)KNu=Ft>Ye3g;kOI@35Sg*}#tpdF zoV`_bM>ti>NLX0`bSLO3lFzdHhx_x0!$0i%{W033SM|ktIYNIas`r>}t4$t8AETXnzczH;RI1VoHVmXxJt-rsWy6cLa_E4FqQ~%)bX?oTvoIT=h~7@ zy>kv>C*DP2`;cRmYeL=ak@df7yW3uU^m@L$(I|F$O#)!C ztPjAuI;54S4{(~V*>p#AvWE^cz67BY?ojljkzNDE2T)`!R&go>c+f2L8VLU$otX+A z64nWX_3(!DP_NaW*_2{r@7bo5Ydec88U_$v(^{~Ewt|0TEtgRn{gQy>W(*}vPRxz; zR(#vgtvAr8(1RA}T>?#-}`c)_Ku%F-nEA`po*u~7uhMx2vj`OVTEi8XMv%VFgjD4 zHb5LKIRJlVCjJp3#0l5u60NX9@5YCjheV z0sG6?U|4m7ogcab`1G$l<$3JN+$$$ky32;=L>?U)g0?OOOP?%fw#%d4yC21G_aue# zu-n7D@s2p#HFrlF3aNIkR?Az}S*}p5W=}?L5MY1QC}t#kca_G?c>BNVPVOc!J(G$3?yt(^_1Dg0Iqfw>c*R0Vp`oL4m4YP2CV zwXT1BLZ}G(t!75k*R!iz=V)VN${?~=X%P-8-U@Rue!p@K_0_Y(dZ!5V1zJv*$7D=f zaJpT+i5}g1vN@&cvd#i1<_?GmOY-O}D-XocV{Q$S)_rTz-#*{%pFX^OvmuK3P5u7v zVgBG{eOd9;^^85lZP^xTMu=Ymt7Ou_l>vVt4TG>dNOHpBjo_Hx+Qq#g-)uZUZa3?s z$5hv}4lLwcBr6YcB5fd1msm4)3C5Nf6z1Ny`elJm4asEycXeohFKO`-Q-ha&5AGOt zY=`9p!8?biiu9@pE7kzyl2s<}BW09*j?wY{rVa!J!(9yNz|?kJp?Jil$u`Qp=>C6x z|1Zz>8&i}Y>&MS;p7;~r5UxLZeP0$gc0=mZY{U*wJ4l{V8$H`zEZqk3KdsM@V|;AR zH;Mr7Zhl!>kS86=#uKxc%miocV zd1s&3(>{j}b|E++{a{kN=*$Iqjfj6Io)Q?x#q8Q)|1i^jHuKIifNffBEb68{Jk-z5 zbqzm6=ghT&+S*QL;&b@|*rjb)>GuRLvDxjwtfeEVw>5QXS6?ZRio!OVudJm|sc;~* z-4We!$R|$Y8HxLEvMHqNTiCPC60d{Ay97oA6ZEFYE~J!GA_8?EvSX5VuS1Lp_% z8qfvTW1};_?eFfnj~>0I&oY<3T5w^uJ2K0plSAV;pbkI>*N&>h8Y0NF72S!XOqt()Tn zC+|e(=c2+k-(EEIcrQRt_SRXA;gXcowJ$USfw+KYhBQ#8+yZ|>8h4BbMV{QmhZ~`F zTGeVD6hJGf@ZSwDW$dFSd{%=pcLzv;4)0*vlVyUcG(wB{Sy#`S9xPtDjzd|LV=FA78zG_4(DuSN`h9SD#*; zSMOhaeD&_t>sNp8UcG;nuYP*<_Eo+5^y>Ai{p$Uzch~>=q(l7!Ve^F=qad2(ftW)>{30SZbh#&ks1 zke=09ARoU-DvjX#M6@M>qi>&X03}rm2v*=OU9Be6%MpLAx_j#den#(O0-f1N`UGPO zG1h(46jB88T+<5R=kXgOLC+gTU%cDWY{Tx2;X0~e__o2%#a9W5**EP;&kuo5zyI{P z-rWV_KYC$b-f`m*usIhJa2nVgAq`pB!fMDFjGojlCLLWV3^wp~K2wkmZ`xt<8O6SU zbf`T?dT@V7v?;P)ccJ49)`PAgaS6dxwm`R2WVhqf0V__+y<^Q87u2&&&avux1;H}D zpm4)Paw2a;7xjS|<BUcaH)#YQO(}@|>0zFf8_Gv}I z_s3{2ANxPuJ@y~HrZ3ORaUulEu^`!reg^L{)S7==SI`dKENB2_WwzlBO|M0BFkqyZ z=%XP3vsEQj;AouojKN*|QN4({6Bf}1B-X{%B^%y&I0mG*n|qm2M@cV|Xrj zv5|kY!np13X1{*6+4!IH_4W^6;E>;ceE-vjPcQaiAHB$TKJ_OI9Axq>7DTZ)ApIaz z_&BnT5RR$<)mNM<5OPh&m6r#k(Qc#oz{Kf#VD(4@zho8eV;xNe8nXh(!6xV?69vy2 zczGg>eFh>NpUK$C8lgq)ahZhWG=p=j=~RC&#j6`d%M#(taw6E*XT@9e}x*t+#~)c~Erk?*6}hzWepNFEH49J@*GM>C2uZ z$ojR7MD}3QzO*658;U&9mcC)*9KABvF*FPgA@rpvcHrtmV^Bd4cgQh^`8lz=6$*c; z!0c0VHRyh>zNq#?u$kpt4JGuxE%3aUfl5%{1t|%)O`(WaHYi?&jFHZU?5O3N6Hx0j zk&w((V^NDb3dzZ&eRBFZ4u{7CYz8iU@`XR$m0+N7D%ELVNQ}XwwR!&~_k6U%GQw{tu81T8nSh)d+?IJ2=i<(BQNbRvZ2UpZZgXbP-wCC4x%<;m~g}d?{TW_5i6!l zLz{anT5S_Ne`nkBk~T50wvJ-TB>Eoclz?=Ia2`2nv*kudxaYiepCJL+#FIQH0C0%5 z9Xv;$XiyMNuj7~_LSKTAnCpLWBXXoc$_Bg!O_boU;Em0JORZHx3VNy%2(=5&GF6@6 z7Xs^9K-6NoT$$fsh5VDf{^~CMMr-ELEBoT--McnM<9C&4(v^reV8Vv5`)Ux?9^f*} zq9-`+QBfc;43qy3)XjkAc%LbK+X>6&XgN2W ztHLm#O+nD8=gLG?l&}^r_H2J*jgI>48{z5?UegyhyP*XoPhk8cJZw{2blnad)<~S2 z6i0|~$^s+im>L8V~_Kr3pEBBN(=75JYIDIX{bl}99Z6u?q#f)1RYeD zx0{U@^dhAF0Fp9zSfD4@bs@S9JgDo_RH$S;L$=aIZnkwrd#;iLQhy&;Zu4q3vrdkA z&IHG{3Vo{$xHBILFF!3M_#||7=l;$8d|LjoKGnzHR=)n-`;UKjc@d9Z)))61e3iM{ zXyBtH<`_aJY%EI_x3N|jtZcA&v>iBJ`MIYID=^(UHpA0ZkA}(t$)MFj(m*YTboO z4oe7kF>1Vmpxu9qX8GEnZ5;A_+Bt>%tm!+~33Gtjb?z=ly585q{KK>T{`AB9kDq_= zAODEp?a_<-;;x7F-qu`N5C%0fXl|NdZ4REn{TjyCObq$^=zJPPcAF4V1H;skZS90K z1+oAGOg?hXP=+611TrES0j6i;Z%&;yAiP(6SNc7zNQSi9$Z?=tu(273$6Nz%zUj^C z{!9G%sQg9D*Q1y7&YSydCKkx$*6}4MQl@45>I8oxLXct38=AHZ}=uLC~1`L4$2mqbz$LJn2%+m3iQKDl`HNABpUU}eqW(VFiHH;e}CGBd^?&b!}3MuV|F&)+qdG`+2 zZqI&Iyno_5?9=Br`!_F>KpwrQFDu>lQka{!iCurn0yK4iu%>FJ7da70*~x*QJs)X` zTMxu|1{m^m)5Ch47g9A{oe@*J2=0L+dWP~5Iq9uYB0LZbBvTt43bvM9-GC55I1GblL|qNSZ-S#xkIfE`B0Zr z0djvX76*J4>2>^!`(O3*+Wd39`|uV*w{O(uk6zhth~1Doy=0|ZLN>%0JdIsP7U7`? zH-zKBfM#|}QO(Q5fiGponF-vW=sXEDe509T^Jv7auLWnm23ZHUWJbfEch}KXeNAAH zZn^7%{4h8|9227k2xIdjJW{#?Jw8kpp4fkg1m?)S!X}Twg+#{zqpd`FOSn~L&Dptg zuz;MIt#w3JvT7XHj$A<)6Om@pThn>!PgO2|{{4q~e_nt3{kwSo_O8V3v8(#xc6YGZ z*^$CZXwOkr@bQBtY>Pp3l4<0D{vcw^XbDMatF~5y-K&7rK&k;uno1W3TtKOj3}1gK z*`VZTlb6F*k}ce5Alb2iLAZ4oE}KU&Eg(3t0N0*K4AQ_m45@f1MWJfMULs7&6j{Qp zY?HMiSX>49u6YT!Ey{gFD%cN97(5@8cDdx5tR|>RBhj4AGW&Lv#viu(E90p?ZU1n$ zP8yDyX^yP%#N zU54>=1xS^^y!N&7?8qGgu0;=meQ)m#YWk=SMqA=ox)r+(Lu6$yAnqKt(%JLU_L7Un zCIJX-O`F~XnnA{qxC0^#-Wgi_;Lit4|7OCR}&DeXC8k=wCTYJ z6#}|H*_!Zm$6va_AHAwCUf~Of+mUS3@zu;}!&U(cPLqu$&k97D-~^g`3e9Cp_gJfX zIgnfZ99&NDI$2F_zR#I1fL$;W4Yba}D_3^k-JA)xrG}jvlDAw|#B{0@^bw${16 zLnGtqX^=-7dIkV)K#{+#lB8;&DKVW#9WhC%mAjPIvQe?MWYNq;0VmfYun_QnUp$cH zf!QUbIk!Xroum*iqzbx--4NsH*Dt+#jsuG?(hJvs4;-Dvk=+7XxWx%47xV-$Q^(lt zEWl#coNVq`zp~X@0U~0@sb76A;IiDBuKdI9eoZm`AFoaRIspCf{_XG2o40RY@An_; z*Pr-aA^zayyxnH`Li8C6+TV?TpzS{4Y$343Cr$XV@Tzm+JshbsZ322syXPEiEEndQ zXe<&R#*x&)mpWB*f<3Y(az~I^k0b~{!zV&|cm3EUY$+twzl`_W}yTVHP_D z*@0(L?mEEyAnNSsw%wg;v=d-AL5C8AzfLIBa=UA_MDXF>vRyQl5ZCN~33W2^PTdSj zNL8)eoBxZpS?(3z4_?mOZ6049*V-ID7oRXQ^n~jIf}R5o(1bM9Am=Uc#``YX6x9-M zL5BuFV0zQQcd@OHqX;Yt-MCI2AubEKtBmv)pb%l{S-lxz%X9(R@hrDiX2ih%W0+#r znQ%)y>G{ZJ1k}cY%(gRs!MExmc#fxqv4hLj)ojrU$kq_05+`=6c64e7pO?xDEy@jf zPaq4?XsVI%g7)KPoB!_qHh;S<{^%vW-D>?Z^;&))Y2O&oP*zS?SkUBvE50D*n%7;> z$LxH%Q7dcv)RsZnw6%ek{m9zYk2_+6knsQ{Fu5wYsPpJLwiUd8U~&Z25&}J@!{D$C zZ=rc1so0mK1j2=Ge|m{ivjL1Aph%`OBvyE?jgWXHqvhp@?k;Bk}-GxqI;1bM1oVcQx(0@ah6~ znq4sYa>>cY2tNo?he#hIZyca9N$9}wF9$56o;)u=IV{zGl76$X|K?+zx3xci_kDf- z@bUfU_fHS!yG)+PuH!F1-1gm9;#Oaq2K6H&mQ0`~gG&qy6toW8pn_fo##`-5Hn|8` z2s@0baG=gq1CvuU@{4MD)Y+HTu1E}YgI4p0Pc0$z;xWLWlOF+YQ)_E-gI11rXR z@L^c1i>9Q16*z2Dhw|zB1j22sP5cLnckvD?Cao=DZ6;(r$eM4ZC*{l@4LA%$B1j%! z#|O7`*3(+tH-9jwnsE|7L2UQnYhsYZHHWhwmEI%G9+g87Luy$#y&p5eW|B zp<@oPO#m3;69K6Iwy`L)+9~%4o#|()9rqo7+s5d(V}1YYPv6(QFz`pO z+-(^(zudO)Fne!>8d6A4M;#z2Awd+|f>70pmRr}UF-4vj(9OxEMwU9HsM-*ZC9J!4 zqQr*|YVJ;QITt1IxCgEb5vT@qQ23huoMh})5R+WV$1?k+vDxH)vUx=XN=ZhZlEScm z-P!^FX4X*1_6Lq@?@(Pa!gyj|6M@>7|2{0I4v7x+l_R{w@Zwk*n@PGgZj)|y^j}>& z`oTYbx-0*C^y1xa>Q`NFuh}362lc+R6(N3)Z4n=bKnYRU)FG%QgY^kvW_v)RQJ7J) zU*(IUWdqP0t*BOqc|{=^PiNae(ltbX&UY#p>VO0b?Mdho-||cgWII8$`9#T4n&3(( zJ7_8fx?c(JVi1tX%WGbZ0Z`2M;52lwV_t$9^mmJwJD60)7})1hMbkFda3rh2#5~}3 z*WIRw>FqP<>%IE!$_)Bh2v+-@KW*^6YxcoQ`pd26@4ljIkqaDyijh?W{Q~2EHY?m` z(&FUWQezECu+z7L)HJR(V8M!3(-B9%c3T~m66Uc-U~r=}WiI5XU}^@bb(^xY2^)$R znCBUA!P~}0xk-3Gc?OyS%&P0O*<#nVB@1#%PUlMCC$hM_)gBVfp$xp@69Xy?;V$KT zLVZKhJNj9~90h4?Aa-Ut4ahHl9kC<`@%q`I`E{%R!wXyeTYvjgeS5;iI2Y}ST$Olvx>#4OyKPXU=WOjm75iY`55Sr5E7Ro)#&pF{p z^`I@7mei53K}l!U=x3upoAC^(08#q{tCJhJqJUC+$Lw^Bm;gv!2DF8LFfplxD=8It z_hZJ$0EM>?-rTmviR_c9L{0-Y?)pz8WXaip&ANP@L>_v36-yX??J)v2vh=-bo;HCq*+nDEtlu$ zi7EQp);mJcu~f@Al=PrKY72U5sFJq_g7yILm@x%BS!5{OPL5KJ7`X1aCiJ!qVRwr_ zfMY1gr)fmJHdly0&)x>g%+mc3J{5s?-OZ6%iA}sD%tA-lgzbVD$vN z88kdb-fZY!X8rhoKI_f-{k@O$!Ap0$rTn$)NJvsC9t%Vm?z_`Q=zJA{wS0C%EN=#E8f)>ux@$o{m}n00(D(PFn%nDTM3#%YZjDzQ{f%2hc&dE@UdRiOas(+kgE-eSBA+Uf$M6FW)b= zmHuFI)Wb30$U~uB(I-sw2)LshA(7j4yVi0jeUbHl*bDevu?f2M%43wZpn0r)MmwkN zZoN~Xd3LtF=fKJ49ufv1J+x*D*>mj z2w_7!#!RB-yn!yEJ*!$=nnkAG9DSl?-6Y}wZ{uiBS!jmf#d&LQ<8`#*g7F0}&tAwT zS&IugsXF+Qn~q_<;bo6nWgN*ND|JmE8OIoZRLu*YE1x|X@m3ZsZOEDk?epyjs9cU1 zvxLD$65LSCgr9XSevJg=-@X6%o4X(CqZjX&1u)xpU|AwAzrSGQSrRl)xZArr~UeqpL+e%$9oFNN3Y&(Gm5`{ ztLR5!A=lbS@5!-YHZS-A!n_SD!z= zfBiI>|5+_}|GRzgLf%}k>ucQVajye(a3LyUF9NxZ{F z(E>yq@R-mTe!^bY*OB-8atc_yZ1uOyfTwM!9 zEsfUtYG*ol^#cqNGrTb&9hM%(TncJ>g&4yMTx+AFx6be+#E5p>i-sD10I7~^U2~A< z#zXWY>?r}ScS98cKUxRokrF2?Lg_*4$=GNvwlX1jIebRM6?q8rIiF2yo+nc4vM$r6 zF-$Q1Si=Z3YU}P0f?r)G;FE4Er@#KPvG0F8Z|;rlh2ur7iZ9@#OpH>=Y4(YrW#Xw%g^s@re z($%`XsK{JWi?0(kswgXsG(_uKwz2SI?WbXc~WixHrjr@cO;9uUQ+B zj=ZVWf(5G~VXvQ6;k4HE%`9hLEe~e`Xu2Vt4HHWB#L79`GSw}W{CBMu}kAo*ozCm0Fgz+~!t`+WVcp7!vy>e;6G zIN&C2V)Z@_Cvq8LETnf|G9~sgTS8vI$kerGmO)yRWdl!tWOMXnrG;5L8VU$<0gzVL zT4U`I!%&R));i;sS9eD~lbeDR8{F?y?s;u?9UYaqs_a9S`XV&;1d1i*lDNW66TIC=T) zk28#>+IO3O2BXj5=A%`C#$I&bM~8Kpx~_BP=>R2JDWfas1CNt-+fT%+6ak^x%Xc2N zg<3KNTjTSJUPe>AH0cbKFzO=#8#<+5SZ>|(=ZkBZzq|%*N&#qvzT)F1L zBYZ<%HH2x-hQYsY0ild&!KD%%(K(3-Js7;U*BmM1M0K;O!&bam7g8c^LkrHg<2pIH zKxf$wX870)fue&dmAt4h9B9G?0v&p%=pmY>*lJ3%FStN*LCq{c5c7&j^9n1n5qR_- zg}!-zXIJ4^3_40-uyYOYoNni{|K@gsUu;@DdL3WdUqn^a2t5b|+Uf=coeo#rXhRzG zpRFs8t}0QoSyp1?H&XpU4860orvg^VbtQP<(tq2dhj1G^6#3XHaT zgFdo#jh&hbZPh?KQJmCReV*+oac|YCfA#LoySluccM+HmUb~w{)OYPWej3~n-tu&xgTo~bE_T0<~zV^>W1Kp>xIq3?cMO8w2J`uN7*zWK*` zea(CBg~mO20bdeNjLS@lxE&_j)EA(C04>+bi@`G+4s}`To>OCVYTfthb0(n9fpGGLd_z)5v<-_8Oie%NT95p_YGlcNmaETu`+ z@CQsiiwa%=(uu}^5i;Q*&_zt{=}iui=xE&5*>LY=G>Ct#pgsmdah6E|ScS}g3pC=F zA=OE5zt(^8`G=41@0tZ3y>7qU&;GOeX&Ltk#d#jI+gpTR70`>l zdn+R}2y+fiMhl&3abB7+(3!)3YCtaG21i931x5Haq_R*Fl8xsHglf{zO$_dicAj}Q z{8T=m2#q;c+lj_gt;6lB9(Di4uP^fS=daA_Uw!}T?W^~%z_NaOpFjQRg?u&>m|u2y zXP;N!5-G5gbjNrRf2gcLL+kU z0CoaFEK=%|8U|vAFph($585J;=<`6Jh!JVSNp2WyBeXYBC^u(+6@(zV`0^7QhLpSK zyI|6;S}P68?-j6r;T*Q;YxF>CA8`p8Lx4B%Zl~$eO;1D9ExQv?%dK*d&w1tn>+!5k z^YU)XB=Q*v{X(APXA_^l{Pg+bn-8z!{k!`KPY+$XUv8=XL1sJ?qDh2+y4lPOMg&nO zMQ{b!G67pU;!pc--r!f=a~_E{h7cpQ)zE?6jx!VNw?Zv<;4<_^)QXJMXGa|KcmQ=w5r`!Rz-j&E)7tu!>6* z%RIaYuD=C;JTE+dgrQk(s8?+?b(enNG~z=PIUJ)kvItZnS6GoY-183p28bSeE;-h# zWo?v41K1_qyXmMUZQZtwcNc}9RnIzooRz)~d-92z>fCjgBskg75(OPh0P?M6Id)ZiY$=nHU~{~Z zb@nX5+M%B$W8oLP8ZRT!R-H4SCFq9r6E^ z3pd(-6Rix)OAHn#5H@ua7<_9PIN+G$9cvPkECpK$P`FJW4L^)#be~)D&tGayJbLk7 z+*OPz$J#k;sRhidGAvL&qHKo@iCTMnKD~y_ z7Rl8E_#m_5qsZ9E4KI`iW+_NB(ALpcKc`7wvrKU#Is)sa%q^n47N(>9RwVu}_7CrW z_v5`<>Cx-Lbcf&-isi6v~=`Pk$8oasNK#!9aDcL%RMt?UJaHa&faW) zKD~?_e`%dbH!fT&k2xoea=(Ig< z_w!$!Pp{v-`SHyM|8&>;{NTlVX;T+}LX(?LTBR$xa2uUqLqs==`ov?xx=&pH7jO{9 zvb4@!kmBStB4Lz~DZ5WDM@mF(=}5Jd9kfDW2HiL+)(S?iXKY|t$DDO5PfXceJMW<+ zZ6f(QpoO=t&`?8)XpHD%N=(~a49^5YfSh?N9fM4)0ICsC?_-UbhXzk){1j6wlR<;F|L=)NwaFRts*3Uim%o~F*QHRiMT*o-u8B%r>U?e;~ZZJch_@L(skxj@4?bDGO6yuv$#eX>SuS}{=FuVGvkn+iX0YnW^y(X`yI zNDRDe$m&FsWhc=~omx=>9|S&Cl7LX(=Q!u~B7OIpeDm>MKk3oy_PpsJU$7!NQC{M+ z-#)FK;%0lUb3*f+o}7Ds4+!D7v92t%zf3avjv8}<_<+~Mm;s&a6_zWFkSv-T)t>8^ zb|KYZY25;it>=yb@ZK{@zK^qa6?*MZPy&DxP6baOMl=Ug_8=OECYpzkA;N`T3#o3y z2NAwFynhy;P}Pu!vo`23;GIdr1vOm|jIj91KLUJc9f(o=J~jP+zx|=!eyESHKh}r0 zzUwL0<~~&9v5Wa4j4{Om!@NYof*gnoVEb9JkOzV6Hv!;z^KN7iQTr(tO@TW#8)inU zA(mu8#3KD*R)$pX=CIHojH z&%vK!`Q)>-3r6C9LKuS#W_;4*b3m(kx+HHjk1kCVOC3$jO^jlM6CH(O@v2FzMA0V@ zTQ((|sZq8woP~I&MIL+`|@hoOQ199|Elf0z4ue zk0yc$nsh|Hlk{iqx>cvZ@*cv1{4O|IyLGYC8PF6-1jGwL%nyxAU`;UYT4QT(#_e1n zPJ+h{Q=Ks(_s3v#D{XHRA_HeWYqUNYHssT-!|=6#>y}CJH*epkfBNCOta$&^kNbY3 z>9Gs=yfwV8jb$b%{v19$Kyli<<_@&ShCFAiVn`x;ZrB3n8K`u2gD@5zFkjS;_^RD& z2x}Y`l@6-Un5hwh3J|znP~wy3e90V9&o*`l9)O)Ta#jk8`a^*C^iloNO5nI= zzM6-Bz;L>Pn9Qq(Ff^SDqRw%NC6FP91`fixbB%^53|(*=`k*trl$sUdp9t1C)UR@D zTmM*}-oO3ry$yZz!hPM)|MUTHjQ``yAN2qF@x!}+kpKJtZQnKhj{pAs2izb2_V41S zH*Y_``SCwJ0R{i}FMsv_`84nuBg8tyUe5i0B+WibTG!J^W+IW5W5Spc#RMbgA+xcr zn+*B8df?=?+PpW&uTTvD5^I2vbwxvW>BOjegZqpk_AoNDuQ0CLR$~i%3sFOJRF_To z4kAKNjV&PJ@e&XXqaC}L@j;$=LZZN2Fp2Ddl5ip@k`olDv;)4M4oEX}qfQgAq5v9y z1e_U!x%KV9{M^2d-u(DOeSCBG_I>oqef{-KUArxw;(6CP26Dh9h;;G1J zzAdJalFpcABIX*%W9hw!`pllE&fqhDS8E9N$&ta(Rl6Efit#lGe zN6*J*pOAI8ZgN&K7acI)gjpAIrVH_6x2nZoefneU#YeB-FSZr*f-ke4*=;uNW(Oe- z5NCtODF7@q-P2H?tpd~^q%4JoQYtZHZWD(h`hL76_Bli(V?_=`=SoxCb2c1*nPL;! zjO>#QAb>zmsO`Ll=3N_lw&%pa zFxOYn_GM>)rn(A>`%AyTf!-EoYsSZO8Umv=|3B{Dut&2bxy~C{Bt@<%+7v}tFklF# z3>%P9i;T#O%#1(a{}B-xv0G$+Pj{=jXUWwE{dVKruAcS0^%iM=dbR$v!0b$SRpz}n zBO}gv&H$p)mmaxwYW?NcPuEZPT+jE%?GIkPn@#;5|9IrERN|GMG0f{#YRo54a-TOdn+GD;+zA3_~4 z#XoXv!K0V&7F+Ng%-4}HxIoSZhmwmfbHUPuZvyZ;!Oh`r>sOAkM9Kvl&3<4>ZEKDm z6IpiFJPJ6b4R-B0(#(_HQPHPDLK#asM$f79XyL=TZZ)WXytdg#FXUV0__qyagk!QJ zz@EWG>Rx)?CAij937W8fX%93qb#*HY&}@;dwYg-BeIR6aY7HiBL~LF9-Ysh{>`8$R$B;vN!jZd#@5OO;@r4GwFDB%gjMl`92|;U7)`i>R0L#q1T=`Tw3)c^ z%g8*4Ge<<-t%1h{@&rG<5w+qN+u;A#M9dLM*M?3G2A}8}k}L?{CKnV<+xJQBt{2T? zT7h}J#{zAyFZLxiQnfWe-!S6kL!jZshN!BuRTrd*K`HL;Gy=V%B0n_&{ogPv#30**|f7u1P36Nm@ZXgLt?OEbX@ z{Qrx+^3m(~-u^1)X9VgQPHU3ukB98455(deX$O9z(UFvcSZ;X3kS-HW144sNo1tkb z0?xFzqv5>w1l$RdV7!O(WG9SX;FLotD7M{Gy563Dx@)07+#sf(eKOMMVMoLKQZXRv z*L<`sIi1)@&P+&EY^R{EvEt2`XQL}OSGS4Re=SXec$DGq84IQxF@yf9=E7BoE7XgB zZZ7}bpLl%A?;5G!?Wg$kyL_?V-0LzwdIjHNp}x)Q7f$%SFT5Do^$u(-Qp=7JW*R(+ zmW;N4*__WBx)|75U>A6&3+|3v)^Wy=x-QI$Ul+R~UqNfQ46!*5VS)*S-fS|@I&C1r z~Lnb&#v{q!`jXw;8zRuzKu3Qz^3}EyZESS{*~} zsoJbDG-$1t4sF4V@~bT{4tEr?8QE^_AAkFQ{N<~C^q)RFeR%eNZhIfSjKAF8{Q`D?P7>Eszh%`B8=V_Ua^smXv1`fmNSWvORmq_#ZVVvS}4c}hF`bzxn7D=pZ6 zd}Pkn2w7ER9a>++v^7KbTm#Xlx~|YzCqC#N_=sp}i;x+FxHDK?{pf93^*{Y$d!Ijk z`TFwHkNNSQ_43gR`O6KSKX0(NCAJ`*1bk}kIJ7BJjxJpM{aie;xxEmb9-K;$t5r`( z%a%6eOz!2wJGX&6sf~H-JYsuR+tW3FF@szP&uJ6H!7)S#?sKkrD@1NCg@n(3qR!dK zjyp$)F|r0mNFm&g{g;E^g)MCCx;`K_e5_V1xiiEj#{G*28}gz z0;2UX##wW%HRN`l`!~PX;FtXT>E+($K6(+~dwUO+q%iK%-Nj_Lsph+=O-XKl(NV2K znP45%G6;dL+gmD}y#v+U5!bc?4-^JgHi;^MeT;(%B}X| zFvamsMpF(#T-um+MTREwdjP^S12Yu2hCZz6zS`=`1IZiUM_)pPF~?5yu5uXHLDH`R zz*GZ*r@nGbY^GqOI@X5eU~<2It(*V-FE;lN?#sLKng_4sdxow$j*+*GiF^tH5*mTv zNRu_;q%7%sz9K*E&PO@<*Ywhe>VCN9RXwo}ea&gvRF-sBP$tFe}6L~8z zQvi+A*;czPoJ|yJ24I2tTWErKcM95l>~Rrpm3#zRhM9IDT{0l~hBB0Ymd(x4mB;QP zI_a3&JbWZWOD#H2&Axc>x>(lzC~RK^^ErNpTleM9JN)g{y|=TEUcuXUm%jUIeKtDU z;RO^_ku+pVWBw9ya9Q-;&k=xzdy+R#+$n=Lp}*I8dezxu$H=MP zr~BN}#TLi|$2I^g0})GqZ=}jc;G{4FgkL5rT1KGk%S@QSRsfN&p^V2gpl|Z1Mpg4l9BOEgEgFcMb@B4di zUmv`FzuZ^-dCmv+#SW9h?8j(!G*wa<(`A#9jLR4Tra+tpK|pbTf9niKwW>TjSVe>6IqM=#t>Lf)mT`F6^dXonGs z*kefH_6@xLN|wDVYA{2)SrxJVED2`g+pBT>)Ucoib2* zl^|CoSFG(a(W0d5BfYo5xG9$-h(Nk-efJ!gq7fCCiRVrB*01d2m*;om;vc7*{OZsolGO*+p@+YSUn3@B^rOTz!T- zh>x7ei<)+g*zoNzumrbE>$L0es(H(>o<|b%=Q>xAdrYJ*dt@J^f<6V3BYCmA&~;pa zkk`6)D#cO^sq!v`JBY}Lxn?&DIl#+K*o}Qj9+`=7sF1=dr)_6ycCG+_5IlC6}G>nSHy<<#&4VuAlX0<(zDXK}E8&sy#WDYrr z9>0(-q=DQOp8w6O@ccDk`lqkYAMO=Sk6y}OZt?o{el463%8USOjw~TFxQK~@x6TFA zHW4A{IJ(k6nB!QuM!_i&& z&RBGR+p;hkTW3@B3AuE|NXR~i!%U;TMrkIj=od~x|gq5Irypq9xVvFk7CuV2ijtKU#NyySj(08Z47l(Fl z3@@?dT2MN*wFgAuBU_1~f1pOyC`LE!dv=67HhJrh7xCWG#y$k+jBUVSFx(|1!;d6E zm}JRBN$I8r`zBuObLpp|b+>k!(P$D^QE9lwhQch=+@m6EfquXj;{wCoT}$Bx?YGW< z+duvLFZm_zsV*M8Y`@sf|Jr^n-*fRcB0V?lzO65VBiWSV5V3k)-H(Hu)S0GGHn`Xh z*dGB~J}uXhbMPNrd4Da5FI*X=>|tot>r&&4>U&M^wQS)hm4rox-oy;_9)<8p<%y9l zA8DoFy=nMtyt$AuyWsijP>sRAIY1468`No5z^O(fmqSNPf;e^a+ z&yGC@6tFqMKpq~!>kr;GtDidf_Y6XI`y-TCh&p^Bu^+7Pf+W>2;U%*0fKUZiP zT7R%{=!6gc=tTKEbm<}jmeVbaN3C(Ix%e(^%r9SG@-B4d!OQnvB2(g9B&tz`)MhzK zb2FsxQaT_So5mni_Q|GgE>ISKqPru_BJkJtE;v&R|2YfiLUaQ4#Q1DyTVq&2N*l-t zr7^{0%tP0&Temma4ecoHnMn&7E!&nYuMLkycx!FZh%5zNR?lX4c;0G=ZWcvrN4$EI z4&CdtDRSu>Y429ZqN7#20e>gU7%63=WN1GfM9wvDyNiGNpMT1q?r!IQgO}|W`s4X? z7Srr4YYtwh(`=wmE4Z&$O~%9!c-?jw)T4F|H1D7n&A_o9tu16+q335RQ^BUXCQx86 zSf8;iz*;%H*K*M|IDtw6_t0u5>2290tv9`p;!vbmL!v6E;))>qlpI6P*{$pDhap7< zdfXABx7p-aB&KwyT{lI4D_Kp~DVx87TFtG$E8R2Z5CFSv1MDb1x2xKs{k7&%MZ z3~gfE*w-!a;9rMb%G7%U*#|G&O}AGS8dnH$ll5p;0M$`C&xyphDJ2c!<(k@l!hvCR3~VU z_Bb6lj5g51LGX>OF68TWBKz-t`}OPRSGn<*{LwyseU7_-fRYEV;(PYm3||;k#RaQ0 z5pN_AlF*qhHf2!*{RFrT*fS(Vm$A=|2w2h6nnPSTU8{xi%CRR65Dkwwk_r1{L5k4U zT1E!M`>-Z6tUo@k@Jh{<9jm<9MGz77D7SrU#T5SQ)wJZX>Tubwx%8=dm|~oS5hmbjOu{fC+6C8Ai}7CY&AwYRBC0)OnOi zsVv8aRrL-DiA)&nsHiQH^4=71_KRHF7oSx~nuW1MJ#&rLk7Lbp&oR%NE&Z$S6rrce zukqWvOykF{-+QgZv>md!<9jdK8o<1e*SBbk8qB1Z=$9Aac7<0#XkNIKosfdW2JrE8 z1mIAA@9+Z)Vtd1pj5<+-9CQR54DQ_Y#q0T=(eQJrIopV zrq}Q=7qT^WoV4`Yan4`=ysw|1Kj%B$|3@$3+t}}KjR;iyt;$#5JDc}ut47X|Wx8P< z-|Tx@BOjb+Gg5pRWBMrUz#P7LUn!`Z)|3r?@4m07uN|^%AI4jE6lrhMppqSFyUURN zR_ydg1ay1!%H1~mzu#Jc(rG+^E|DpJ1N5o6a!N-tT+or+iV+eo?hZ>?Pu1;t4g)BQ z&lrWoE(qUKSG%YRCtMe^swp%0m&ArUNUN4Z7EZwKQzpM@_OGFWzbsQ3G$rK91p}N& zY9zIQ_3*`e17B!+)b3Iz6vCh}m-HempVH>t0@zJ5)22%R?72ciY_*BIe^T#%1WMk@ zMkHsATlw0rKIU&eeSNmCchfx{y>_=9{qID1kmDd@HN#9f){28H>_M9inR0}udWi+x zF}U>at|MYGfTL$D=>`Q+DmdSHbQvyaBJ1>Cw!~VTz$MOm>qltQLK{8B8a_q02kUZV z0t;qYr>%5mA`qT4pm-P^b_oK1bU*<5SU8PZ(iIHdW`_#Js9mm7-w3>EIu*^l9l9Yl zUf19*lw!I-Oa}EX$U_jX>^B9|zxn*~>Br|U`Sg-sU+(!SAH95UTM@6qm!>x6MC&^T zZw&MT&eW2og1>(t(T&FzDKcc=6lCm~){!rNsq0ARB*lDWN}JkPWCyx`)Gm6)^-b}U zg8_&TMYbxu+rTOEtp}h1R?yo5&}|zOM_>$~6%0+a05eXSs}MiMCL5u5Gfvi^-sQhd3nAY2mRPpyXix; zKa{_%HDZ7hIE#?HhY2u$dgr|ltp(63XaIOlbg24dLWp>ajf2DuN^6)vw}XP&q4140 zw)TBoTPO30*y~LI5+1O>V;}ZDVgY6KCR}M7!g9eIFtiuOLVscJ5xX1WRpFIuU7+y7 z@LPM1wPYbwDbS`vQYRuUk+KD+ETPca15J(7+Aeg^FJnzP_c3~Z+Y73D-bm89KS`(8 zF)N@u2mky0(O!Q4WM95K|K=lv;!mGG=L{%I1-v@&<_|E3aa@!8DD74zO=N=I9 zVI+~(dg8u%!rtJ2agTeQOniy!%&8%&r`xHi1y})b=Vb_bKT%iTy#phR!iu0R0}*ri zF2w}B15&d$&4$xCjsgP6JgL{A-O!&p%Rn4%zTDQ&DNMh70{;E$6Yv@V^0S5OJ_h-* z>-p|RLkw$k;-+S#12LdF8wi+oAo^MtkqPu{kLs60<(rUy8&hv>zO^B0l_yInSk88~ zb|ZH61$8I-sK>Lh267oN_|(A3LTxU;ebwD9kqrk<#Rjb%JZn-q!IB^cBL?JDAZU!m zhdVr$aA3i4+xhx42hkwhX{-8$EhU|F30h%Nu8?!)0o;08Zs1vuv@Wo_-41&G7TUIt zudngX8+^}yocG{m{N?_(Uz5C^%)`NFG4Q4Iz*57JabQmvZctmxT;4&Wf^!vA$S6id z%cFTCR`yizd=6V)sW^xa3P)6f<8jN;rjAwP3OVnXMtZ%+GUjA!zb^MgC3R*9FN0)tEu;1Xv)gk&KcQaLbrg^emJ(67#~tGI<{dSdbX56GThcl8+oGTMjb(UWntN4zGgI;S3;zrzEUb zt|Q)mBK`2R&eb+KD&Zl54*NvcZUbOB&H}N}Ng1p(0{7C>O_KmAX`8379-C-RmyKrq z?2*z?ffWryMwfw%#_C&Ra8>QT&?~(3G`CRt{PEM@|8vUJ$1dKjew<%#yt;tnQAqi= zToTSb6A|MZ6ino~jhZ=iH+bAG;{R-uJZUa}p13T^T=+NF0W}XLrA|a#)HPdV=25*} zq=_2S)gnAc`w@3aya+hSkHSwk=qfmU9QdbOc5o0CEGQ)~Urre12}FJFKE;eJ%-mEXLupNjb> zLcTU5vR;)os0-28wvB%}E^(nEKV`uQx?#V_BZZ@A;i0`PkVBW`j_h-w^>bo>@L^w5 z(;zhv_5(CTvL!+*V`@p)4IZT|%M#YcD${$%FgYG<7_ zx>F@AH8;EZfBy9GIX<0y3j6r!<8#<0KmD99Uw{9Ef8onh#*g-GtM3UIAH2BlDJ~jp zLG5e{E}3KK6TWG5U|j)q0N{PN*(Su&fa?iGo+~{IioP-S+Ovk$ zI-1fhk&qp__P<>~p|plMclgeEoh*Hk53tlKn_;IR+*NXfPl_i*VL* z!KbFg2Rf)4>BffwbES!oI1Pw*m6z)w7z&j4?0A#+v4ws$5`Uxl?WX^K$M2i|^H$r3 zXZ!LmZT6!V^}Wpoy<_gSTkjYdAJ}^b;wRarR<8)p-rz2-f%)24QS9Ncnk^(;M0x|; zTOh})(QAfERIG1yV4;&|ppE+@tk3;^RM_fx@F#?p=e3S5A<(RZlJ3 zn>W}@F*I^8#hc02#LJ9ouxlH@b&LA}h>vWl|r@7q^RY zwl1v*Ri2U8A#{c?%>I}g<{OOB*c=}G4 zev04P^T+3p_keJZUf4TPZ0pr%>jkDuOXzbjpCUcrBE>k!|HD(y9*wK{zRsM`j+0TK zr=}K)$gGKIUC$9$hJftEwjHwFc~K!c1fZ;M=I4_(ko#_D(76><5sbyv`zfl?TlzUB zXI)*oKi4mN0{LHroK+~bIB)R(mj~hJE9^+--+J7 z4Au#Ju?{4ZW*c{R{J;N(3x7KH^`7+R(M$NIbG2Ug_6VpbF&E*Z@4KhLBGr~o*MVL_ zJ8_N-6(lV+sg=#d>4I5YlEGpp$H0M$4K7rZt42W15Y^=XeqAQI1$8M6%`J@Bq|gE)|i478!)< zeYj#3W)F}h&m5?`5dBafZnt?byV$ok;P}fgKjaTT{_wjW@`smuY2uGwy|=feZ*_H; z2*SECm69QUuoov22~9mCT*(v+%yWG@=M_*S$HhShMkghvoRvHG80)e-o+_{G@K0pr z7Nnn&{ZIOAfs&!emq*4y3y(Zg&LP`S0!c)%&w%bnsXg_~30 z-Y6S3-I<}7&>jfrLgCuN9(UOCvb-9&OppkF=l2c$yFdB+{POktuI4{|&baF+c<|!= za#vY@y}l!7=9$rl_BDFp)EQeUfweo_Vd`y5$L1<{z0W)h2yt~f9AZ6YSWTU1?E&r) z*pRK5PjfG!Ces5fJwf4P27n>p&H>^PqzAWW>XEgzMc)IWi6dqJ1osV?ck?x_7fZ^2 z%qQF-146-JZNM0?-62xf0(Xf|pBBU6L!Sh@PjmciNFTOv+8yWg06dY_=|I1*$}Ow$ zzl%@z3Zw_G*{$4s{%nT_3(uCvg{NF&#Q*O+)B@icW? zBaq>^dD=`^AtyklvLw+@pe|=2RnQwqDWi=gf3(KnK{E>jE{CF1ZZQWb48$|g1_fa< z(jJh40`O$Vc(x&-sl4VUwPNr*0+Aw_hpGb-v9(=clj60`(bh_E6c4%{tKarB8iMYT&56mi%v0bZDSTyT#DxPPkzGTB ze>*~eW#japi2#I+>Z?IFxz2hTXy#0S9i@Z+*u>TMaMQsay*gA&c|h3j>mSmH)_*H z3mOEfi$lwVq!6MrM+oS=EpMAo|HJc_f2Ti;YU|^@+UUUx_+F!lAoA%W@Of}Z$t0S% zUxUDE$8;j}buo)6?VT^(RKX%)dwNm@?Yw)R%$ZNoIVVT9P ztf6HT-VNU#^4WIXjt3eYqUlt#e+!10>WO?giS1i9p@j5F10gOFHzOGVK~)K6P2T{!HfvTfe+!`%DWbY< zb2OkoUAnC)kVP+yEe`;68sFv|7=7m(6x7Z+4Djaz9ICeoU6ByM38G?6+dPx!?m&im zqoTF@E_4}k`2_;kKB0d?Xy|NBv%s=+^rxyhLe_XA_dxp#hFYTTF;WxjCR&BDi9f$u__P1Yu{P2`t!am=#fWJeYOgL~9P_T*RuX zX`EsX12JrCz)y}0d}!IwzXzQUqe^Y_%`AY!y~4mI@D9HSUTMv3lvx|X@Qx@!Nd1n? zy@r9`2LW6sCgm{9QD$xj?VwsykfQ(~j=qo%6NEAgWvEKG-H`bVh!^{&c|U#pe|g>Y zKg1E7PhaiBe}{KB`_YT~-ey}rCpKdW)x%j;D;8|u=NK;d0@zqU7rl_KVl}&;p}j?i z4iB76-p~jfYOS}xrDKe(e%-{ASKopT5d7bWF}yY|{^-P9u+6n*4RVI1Q-C=pZL=Q(==o+G)Fc|XH^Z)?F z)`Ati4LM_wHoCjne~N6(d-K~zFW!5bS{^dhcQ54p?Fu{>xT{kl$I*3*62pC-!y2?} zko*@b(jPK-t#+a#hPC0kzFm8vxvU zC9?Gx&?S{FWL*clDn#msW{ue^>U2Mm6KDyyjxb7x_!Ot~$uZ$!K5Dv;8qZE*w_c(@ zfB(_`A)n6k-5A9OuiSee^9Vx@j;rK$U)ysfwHe4mqsAPgIr;0YA2gJiJDF0p`v z2Pl5Qv50%jj^S(ua9!piZ$mUspUAj05UPv!M0%F{;^i~)wi9_6`mm!d0wwW?LEE6} z<%Wm_jh?H}oe}`slW4?%`CLHu77FB=f5K~L(GhXHxCMT(i5qmF{+in7^j!l1Z=kVV zIQegAaYGlr@wa_e(>78HFCZtD01gGIv~xV?23_-uLG|QE)K2M63DnBs0yQ$ z#Tx(?(xpPYw0DQ;od-scs#_=!2w5xe#zwz{tv1fUc!6f+ul_kw6@nz|>V zpRFc&+rr}7NA{^3=G>nf9Dnz#zkhi?zsY~h58qGOfAjUlzU}Vk`{J2LujH+Dr2m?} zsnJ2+MWW+^aJn=FsQ2R34P6I3e=04E3vEsptyT-ol-Yp~^f6~ZB+rUT>O!Faqc9>{ zN}yj0+8Dtd01MUC=9QMhc4jFC)9qF+g~)*|APZQa4eN*@u%!;RZ|L z|1kvU(Tn+>b9eSBrU5iaTkx&(KynaqBlG5#6PdwjeN`!WjhL5K%Q>M zhk%M#y=LrOF&LJFn5S*;$0^$aCgCXRqt%tCZXkZI4NLc(g

&4btQc5lBY!bp=g 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%0D4=4=tItpO>iPp-Y|YA%Y20W;V_hmG<8 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 U;q* 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 )WyMHuMoAm;^d#PMa$@8Ck*8?944w~A_SvTt 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%0A=QiAV?3pftL6#a=9IX3oIQRz(Kt}$4m}y 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�iNi9moJDdn2PO#$D~RK#b05%vvQ znNw8Irypv1^#2c&;SY8mJ)tsSaGH?Z?E}(ui!1HxG-&71qdaBcjB922NQWr{G@1lg z7miC+1jOQSQ10-0%#?;BVT1ThapZK<**lJxy%55ceVx91)=9p7n^s>YF%!dyfikhr ztpgv;8WZ9s=84`~ZV(&SL9ASV3$uU>>q;k^klPJ7KK*ixW0(s-3et5DD{J0+TZ_4n zFxsJ?j4Mr zCpG05@Zhh#)>v>mnMK1ScR)hexWrj}l(tqoeIu8+wP~x>q|A;0ty+6>I#On8*4&#o zj5Bkls?Ei-@5#N@YMRG?4Qd;qV{^`V+vE79S9LzAc=O`ZdgJMDo`_oSy?oEqll&3u zJN4xCgZF6i`vZ1KV%HQzqJimtGA$&Hw@n0{w6TL4!ZH<9m(C6BZ+0j&2s3zI=rXIA za~s7xJ6u08k_(3pRB&=)R@;gVDZG(Z3qmd!&?cNRWfUa}Iw>?mS12WSp*3fQaq zooeN)^wPifhtNyE_};5};h%l>`5V7J&L@DAJFo4%xcqc>-`X>vj^8xE67sorY+gAw zX9N9B*+h?dY&nyEEIME1$7pA+IDU%2laaoc=^RO;z6 zlY4*s?|%|fZ9k*~{J7Hre$*tpdn0f^5P3fkc|Q<&-v=Tu4j{tHKBZDW#$vrW)y+BW(S6{1ts*}>~?A-!`$kRd34YFp--3dlvSK3g+TJ9j^= zfXOgq)!x2N>T4f(GTf|MB{>NSdyz%C{FXH?8q}I9f$~_~^Y&Tlr z_I_%GTRCBW>piey@!F#eoW-~;XNW-QZNmrIvKj@?&EYvwBigD^Ao7-IDWhAoy&TS* z5)dV_2XWtZT2&%Z0qo|!l?M;j?gQw++wK#Xe-v`0i`km}ECbj_s4+TdGCc&>y(^>B z>mY0`mhKjPS)$i!Xbg9$zVl#EeU`RHq$mxm57{JtItrbszEa^&$HaLM3gvn8PX6&9 zypu0Kd;Rh$WANUK_hUjC-2biI&>*#D%P~4qaL2MIQfoUflR1HIZr!=4&9$}lNE4b1 z3BK0g6^mVpgyV$C2Jt4vB4wjuA4UmTJn&v@--K>-?uF$&4G5P1kG=Q&88tbw`vgJc zu4M^-0%SurWWx~F-we!bbyanB7Xb_U>_6fas;jzITyQzW%&d21>4S4NoO8}O!a09+ z&Pj5Pa?SzHIL{q&$@gCGQoFNrx$7ZFg7flX=6Rpc-BoqY@4S91s~mYJ4n4vi+8T^P zf3KzYOjHQdaptDL@+9oKr-LyRw{c9V3e^LDD23U`+UvldIQN(kRou3W&>WI8t6@uD z7yL|&(a=PG^;Ul6lW)Y^(DL_v&))em(yN#8m*g6`-GNy&c$P(C#WEFA#K%lQg776q zP;|9vuNKxc>t~U&dvqPOrk*RD9wxHh1T-6LM;KJaz$$mk%+RvI1@wPM_hGhqk-eEoAJwVU566^|} ze#PRt&)Lz#nEH;@%0Z!G(d2oH7F| zpM2DeQ?)D_T;_HMP0U6ORrSaBU9N8D8Xr2RNb}j>}QGif?t9|y% zKlLO$wB?K;4vgM8%-U70dv#n>dVJW2osFvpUtL?zib9>@fx2(p1saoS; z&4ulm*BNm%Nl}7exQ7-NfbZD=>8+Q4nxC`_w0#ez344NtqU($kHbJMt205!j*2sM@ zH!H2Z1pM-WE))Ylg%@-?sZ42qRNE1GRv-moX$1`gSltF3t}bE2ydiU@a+BuEKZC0% zYH^!n)dvljyA1EG z+=;!t9Ukj05O8FtNlgpel}MgQgyX_X5A7?UBuc3hU7wVDoM3t4Iix_P^)6tcL62NW zZ3o(74Y}9L4gD^o3V!*2=lKx_$g!>qV>YH$a`urVw>nfUis%cjv2y9|+Ye%FGoV4p z2E#EAsp-J%%tU1Sg7@nUSkIE~G?zl)32|`U=^_|9-+MedEBDL4fUAh}hB@9FA$R4Y zVZ$O?TcTQFJH%&fqM@oF{S{i_EV2~QE#53KTWc4k^}d7^SfhP^;z{A%nm`}v>;yXB zD#^FpJ;I?`c=;EfCo-Mq24QWk%ZwlunNik7>9-PWIbc}zLGRCQx0s;8h>zV6RjuiA zU}6{YdmNz~>mWw$79!b~oEfQ>gA*gbW3!r>kM-`c+|3<(VtAkn|b*j9c4xWD;#|_Ci|35Xoq?Pr;Zaq$eY9ruVKr z`5yNWE%aDh-~lA-iMcvqyO^nRe2O{z)<)=>t(Sl0xfck3xM%aBOV0v%Ok>3!TDX*)>J!rvflVVT4o1mqgwjO8JsiMR3gJ~8F4rcCsFsg(;M zQ0jLv*7st6-v)3$FF%7+@dSZ>J6E+MU;Z^*#lF5y)^v+v@<_kl__S&0im?^UpQ z^=7(bQQD!s$G(7ONcHr4=Uut>nO4vP-W+r69SFFdNQyk5fCR~wt8H9kbc<&#dimF% z6L1GQjw|=ES(^5ZeZyGYCL%(mMlr zCq9<*=@VFhD?lPSmiH#l#P(pjU;d5fy>RW~h+U@A)Na!pD`M=k6q(_Mf=;)y5?!3I zkG8F|g(WUsPIZZaF!D%nPkAa-lj?!p|DawRu`Yz5l5!)jsrnfDpr2pO%f&3gnMLAL%Muced1m$Yia1zd)t4jQk8wYJDF!4oP4E74EYb_8S3F^VqMT-`6 zgDV_;lym1kqGi~s#QeVeTeyl7iMvb05{vhQqSN3wC~_cyy8v8us@n)y*C4xl0&gl1 zEwHyw9~*d&agiQ|;$Owt#1Tay%$iuTmt^mM%YDwm#)yC^3X_-L^}L;Co5e|{I;MwY zD`>LH7%^wMpD7YC{Ln;&y*-E;uvXPOW-~O9O}$3vF}hFiBwprb_kE{N+l=6q2|hd? z8gdV=((J|E`SQD;CvrrPpcywy=D zEyH(a!@?YKQwn~MhIXcPq2m=Z2Lw>@NG^w6H59cxo=SV_jN#~f3ziV*%?funeWv4~k_3nPjC zT;229%fIuSI}z`sm5FVN?zN*DT6V{OT6bQkn-N_*15mOImoXB^3ggSaj@ptDanF=7`CNNB}$Zy6wez1m%& zFaO@Nn@xu#3qwJX3&{eQ+h@zXE@?vN#=!W*#Gh{t>=?qzH1yCp+p+fK=F4~Pu^vq4 z_OlVFgz-;j@sgfUE%rx*m_MczdBmcSScgJu8x9XGMU`@bVw< zo8U9J88>^~0hnW62Vs(H){ zXD(>!Yh>d?(dCl`8AB68bCx?cz5IvId(jcMPG{~M(SEV=#SY7YC}r?}-iXB8wJTGU zk73z69?GTzseMioRz_$yjpYzgQaRnbo9l={0!2^oaxliqb3Txab#kn$eebHInYUDi_rx*FWcpLQ znKu{qh>TVXcL{KwCFF=h@YBsN`Lr&2@qe6*r}*$(ogt}=wGkgjHW4`z)f=^2Up)69u)j z4CDlPv0>?lRyCZ^MOta=_?~bPK;s|^kRcXT0Eb)j(ZTZ$|~ntVazCcx?-Eyvo}(1qVPEw-3#dxGM`ft zFaOnZF9hA1y`}}xXh8C|tv%vMYa{W2=$?y$4*N3Z$HbgjtvFJ@2xQC`&IgXmlo(}bF_Rlzwz~-L1Mw! zP&G#I4#XfOQO}NrUN_{vY3kg!cAhy24Oz%mQ=bga3Dh!<0B7ofKx4d9V){cL|KvA6{rXS5 zHQ{;R_wF6yXx8tZJAU=EAAG(Op7(xE`)~Mbzw!&2e$ug(!gIe-BM*|21CeJKjxV`? zYGGWo&SJh-7Fy&%gO1#DZ8?t!Os-7xqDmY##zZ%<)xjt<#ZY8gFH-O>ecp?MQp`bU zGrm^cF0v<{WNru+DbOJgLBPY+MqsK?s$VB0QE_1gay(%#SyXz=;Ug>FgN%71yWEyv zXLLFSl2hl^(ax9_NEFy{3jIdcg{t>|oecNi@68PK)BDM%AAF2E`tjS)!}on3-v(&! z59!12HdBB0gU{JT@V*Z|FaPZq^`)Fy6aM(rNocG!Dc_L68~xwgn$^KpXst1^tnfKl zU2CSF%r&-`jRUr!B?Aio^wr7x@#h(p4U{f4v2~+IyZ1PKv@XYd&GF`Q7~pPym${K~ zw$9Z;0fpggVdDPuA8A_feS$SmTui^}Ss1V(xZUFMR`=}fak0wN#H*-g26|u784vcli#`mi;#|#R6{E_G}+7x7ZTuz%%fe<<; z8{ad$bJtG`t>D4hjf^^+uAEv9j_^HgV<#Gk&LM?BMnvD?ANQ= z6}z#Z^tlM!!{APedrl1e54HJ4425IBxS#?U!aRL=7TrB_kza_B(rqAr5|s257s2cW zhajwRW-GTEh*fWSGT!&)yz^B2!=HW}SOxAop67uanfDmrOK`@KbJnE5srAfZMGVhW z`V;AUpY&8Xa-7e;{J3!WhTU9<>teKz=P|xdz*(7xBk|j<(q|i zU&>O?|W(la=!gqJqta%3yEZO)& zCCJ9uz6W;ManN&r0=S?FwrXer?tNm}Ap+#r>4;V$tLKihY+3PzPAvnQcO!oWVTTB? z?w!!WA$!)vfI6sheW+9j)Iw7N^SPEQ2m!^}R}0geyRip#FU-j)wp2jyF#0G$316Lq zfAy1j{K1cZ^3hva-0%Cwy@UP8uh@@2AM@4E(MeIuLP*blvOW{K2Pa?t z`)Ag4fMqMRZQ)7JHCL{ktQRf)oB&Bz0iw)qrjK(WTS%N$< zUpEv@@aY{y-f2;-55O}zZsRnR!LvWyfg3##k9_)3C);@NkF2us+^vtVC zoH0j5`uE z>s%V3+Kq+?)1x*QL`Mlp-JFR|9UM9Xe^A;+Gvuq~cp^S+mG8XD3mQb#QByhFsV@Y|tDv_fAeK+Mj0p##x45h_&pOceEAJc*s zxZpTBsU#C6=t}g3rlB7(kJyQb+r}6~%$f*7lIyu@03zY&Qt8?jb=K0?p1`3L+ylLT z(tt=19#FAaaPsF$0inMvp_w1eD1iktuK416Mb6_bE3Z#!Z>M$7B ztf0lQMQjTmxy&1yvIztbig7@TupVQ7FYC!$mm&R8u&;)0R$dcCiZ(-Kj-8g{T*?XC z%9yxA4Gt>29skQ0^-XXd2zCu=ae#B@-bY$8p&?J1=o%sS-423+i9H^Hy=Wkv`qrY^ zFdnlcBrPamMx%yDWn#xp*Ic{U<(-e#^D}o^RSaEs6ZflK6S|ZAU!ln@aej&Q;ke?YAzZi4!WcmEAgc z5tKfWlsx?A!5`ybFr<1YvLudw79w%^%)(&7=2C+^i6JWKn}7r-Q$f=>_^gerq}PfYg(-4@aL-hK48y_nwuq&% z00)@0p;8=cvY(}hDXj%%l~i-MY$&~4kiF=L@$+6eCyM(59!1CU7yaIzy6%}6T!Kc zeR+Y~yQlGey7LS}Le_wPy(5T_+Mo=5DK!jx3RCIAs$C^-ZBS>m4fA|M_BKH(Td4+nDiQsGZ+)B zBPx49t9D5bPssCIQUs_16L^!dj$@>N2r_itW$pnn`rx2(M;q{eS}(urH-CRjtY7f1 zh8$n0s|RmTSu0mh<-Mh(Q8FrGN8zqG?hte7N#}S3S}~T~v~$U)){*itp#5~{+Ho)w zQ$7fkJe`vOZ#Xh9tUc74Jb&-)?;ux7FHna<>fzY%&iXQ6Xw zAr136lsCAI=Vzh4-p|XlS-Albl1txk~nggZysV*Y~`!(5$1dxVLFqO?*x|2Yk$!Wxq~q{N&S* zZ~Vju=i`rl>XZBN*Za4>RhPZz`}ZEG82CPr(+~$8%_lm7tj{{S9Y z!AR>6V9%oCVI?&*pexQ^B#S{~jZ@xmPN^v^()5de!OXn`ZRpMcXpO$EGSf~WRYw6LzNtCmO9qm7IO~Bgqnb? z)^4ZSw%Bc;kU^+Z0a%rE&)zTp*BAAb3c6KjfA+<;5TuVz1Mjyl%7{&UHfBn+l!qp* zS#?%_EyVz$F&~V)jPjUeE#ln3Iz&GPx(V7!L-xxO-tY+BC|F>ux1Rf2`7_xJ*7ad* zRj}(cb{Ezjf0j4?b7!YZCjRnEBOxVos8+-*2g@!nA3Sy4}< z+!e&5pfy}N808_L;dRF(zwz~-{Q6sHkoSCl&))hnp?>==GRRln{PpLphI1)!jfd!z zy`n}gV?l$b=I(?WV-Sr^#(lc|jByR_bIClVtSJ0DAWo3Fpkp24!83HsW6Qm@(co9f zTx%TdHO_^TWH{e``M>#%7IEV&?TpRY?jDAqw8Iv+c1sbPEhXaz_kpZ=gDM&76Nj#U zHNjS+6(U3E-rDmjZwmY>2#Q%YHG7NL9fSsRAU#dy;|ZMo^8Y+uCq%5>dsybvl^X^b zmzUv{bXe0z;#M@)@YHa(0~K>&XV=qPmNo_uG4)&)GDEy>v%n7)Q_DnrT7hJ7%noiv zhxA(0?xvSNTE6zxFQ|LOFyVj}jVQK%YIh!J_H{xrkaH~`ximZgcA&#^L9)GLLEd^A zdQWIW42B`pft~8`x!V#xf+pPPx`x7btC$g{U5@Z}{Ok4l@Sb17*94(YKK=OX-~6!; ze(LM>>07Y1_kHW$(OBhI!v_9*$$vOzZAb57j{}saP8|Bl{K;6F6i56|}Z^Y1uSUmR{8@d(STQRNyRr<)#VQO7#WzD$hb0IHYWp4@N zWIqPxn92;~9Nx3>dZvlJ{IT+X1F%-T`gY#;<-ArC;M@7u2l35MzWxq5ixi!cMFf1) zM!|&`+K0rmA%a(%YYe?bx^2L7Qs|=GH*ltoLtLEbJ_NW!v4Sd_!(J(3M%I_#hWY zslql$N?w9&iX*g;zoN{4W7ikTTK%ZKjHs zzx;9XgP@1`<8c*(1at{_H6h7EK1)n^Ps{*%K5KiXqV4T+_k!$LX>2fTSkAd16dmsz z+xpbwmlr`X4U|KL(&?RUe3@=+0ICRjK>WrN5~r6x0apRo(a6YuiIAz?$R2WVRk7lB zC&L@Q;1HQoQ$+{}L+m>cyTmd(NWyt^h>P@rZ7}%v<-N%X@)RNvo4~4}tqwTJ0D7C% zuilqG5m!+d&ey%gJiE+1r+a}9X5M1~5+IOftUW7x&+;K?30eq6a zG#4B!v;qjOq|)0s*fKaKJ2tliL|5V$N8(1q2>uGWwg{U%pVm599-8;dpDI59iu9L1 z?YS2RQKATclIQYc<0_=GEiqxrS=$a!UyWL;Yp*rqXZ%_AgIpB3Kbv zz>6Uzv9u34i@XH?+@OSE*#>?K9Ft%E^k>ydb4_oWybF?s>0Er^LIL^_D7kr~`jpMh z*t+&D1XdG-@HkRj5cr_JbWjYS4L?T`BtT#tVUC-B`#uq4QHJy5J&)3EMM%iYpCQlu zNcSqA)i;+O*)*?-4xE>xW-ziV@y;U+YTLa%mIDEWZnmx!7~1%}jkC2E75wiP97Tvk z_Q4vz6y2|9fksRXE08v01T3&GezBr-6nV7PD*z!3ia9Fc%9aI3hx(ox# zRJ)3f%&mbOkqN-zEgn0@%b)$M7oaQ6gB&q`T504_LGu}Rr#stMp?E?o|mww4PwpK7?nR$&fPW`c0A^YVNC@UQ(LU&whg z_S%^S-*3lSGWg6@?xk#Gt8Cghmh*{Y%b-9N z9q_a^`d`}-0-OnX1^YN}l81qnt_utToS%(%ZW&-CtTH)n*g~_#`@$g0=t*un47Af_ z=%#zUPPtmIIEB zY2l!1o-<1^EeVI`H@EQup9i4rVOZTDREO@(=SHX>KqNGqn=Fm;jEOnyS>tdXq1RK# z0NHFJzY!Xcj&)Rt&eKRb6T-S6D#fQ2Dh6RR!GIzSJB-q91&0vpF%}FfuCaye0E+B| zvJ(eOZrgQ0Vjgf|N!WhA>erfo)L;Frujfbk(KkN&_^m+C_kH8unkkG|qJZ)95(T{f zqzsJku0n~m4n_x;p0>4KT5z1BFFY7DNQ@@}!tm&lCk3Zlds%@(4ZbfpV&Fs$_iNLx z59i2JvE~lETh1Hs+tDDv;~2Z{dhPsk*_o7zVe-Qps%_`4V~G@Dbb_{j9ieRxk6hg) z4%Y>r__l~Qu)kvz#3M8EsRIp_H9F@k2gqK-4yMQ}s0o3;z_a?~xY29p-&cR??*YE_@xB*P#+K&N$bIh2NgKy7Sv5^JUjR=f|MySCQ>L+K{dVQuA0Z4@#6Bij{ z%H-oG#C#nBR5(Ha!eX@Q=ECY!2sI#HP#qijM1mAVj^H()1tu;E7mQ?UZ55FF=LOPh zGHBQ%X^Ipfggsubk4OQG^T|iw_{mS-j$3=rckUNyf&94~UT`sgsyc5ZV9bo3LTj#8 zM=$P2JzR=o4i8RV!D=SAQ3}pLR2pJo|DlWQu`RV3gQOr>piIEH?D~wVI z^4)OW1)aoY1 z2sa77Tki)@jSk*));Ct#wGc5=YaJg2XH*KQ_^fCnh zSVwX0eO>7Q>}~?*%SO^A!1yX{*L5*HIXQ-GV}FxN0APH7aStQrF()JM!~!rOGZ6gg zs0HqO30i?haoOPpw9DRaTE?WkFg7PtChx3yf8%Gx?zcYv=vyCs65sfsZhrJJKGnBQ zHSha&z9$mjhH*P=$Sg<+57|-(z(@FST&|OqA@(8M_|WLFwgAp48?Xm3-yI38S>zf< zu=^u7z`%}wYs~fz3VesLgCH4MxpGHR@tAkL{CV;N&@g%V^PevKzPP57$kys}VIveQ zwDXzVFJY&l(~(hu0S%&e@}G^;88Rp=whx z6Z9c41>cvy;QLfm{Qxu;zU*^++2{DO&+$v4&(Q^cfPMluF>-(?zu0nt8i__PEcJ<; z4-Q4_^|>cUisDq$z_Citv8b}~Upf|PAb$ue9NctSO%rC=qE!cvG6!EK9?9IRalBMOj0Y*xL2^C3y!h14() zMAUT`O_gv5g#}ZtPF-`X8f^?m@jd&DwE_8mc=?N-sW^aut8@)USZg4v3GyXw_*70a zu%MXu62h{<>&gk`G%FM=ObRsz?3IfsS-~7>lNE=C--VnbGEn<%%iJ@h-5-He3eKA( zFMshDrLzX6o+fgUz{^H|aW~|rIKJ+jAT1aRqH~<)u8o;Cl+0@ZuT5~`!REy`d%^mD zgOf4R?+__EpX8&ufT)}~2uKoSbix~?rXV=KuJ|`V6PyA)5rq>y@s>kVXcJF7E2vVe z$Pzh{K}hW6TBNHlwp?hfM4l+}Cn5+dyVK5YhE&8c&??P|kf=Pp%$1-j0gsIGRmK1P zP>SF89efw1_3Jaijk>TxnayjyZ+PdynMf^+!9$HO689s|1r{B3UNpd5SoOXLS2gXXO?_V;@^ zuioF^@aFyfJ8DD%m4+QEFdm}7=aU-BR zu+1U9i+9W&`837Ob zaLfyr`AwdtD}#9uf%92y(y#VA^#Svt%~Kw5*pJHiJ2HcY7ANEdgdHv zfsj|EeUwt~jnz*%r>`IeK_2b#e*WZG)U4+&)Z}ZQgJ8hd=c@PI@_T20r}hv1Or4Y; z-}v-?kl%<;KKY<;eEO3g-%mc%EWJK$z3=<_Zn4{ZEq43dIWN>_9-Rn>5j;LjO=J7X z1IW`E5bWQhV?7Dbd8D!V&atn|YX~IIj=tdZi_8PZJr2>Bv8+PxLlYFwh0_>W>sqkO zojakWj+ifh*`tsxhu_$L3v9JK%ODZs++4r{B6){~mV zXE&1D)@4M2MgsHMtbP4SD9Oj;YR{In4@TGk&y7GtvyzT8w+P> zp!yUUFMkED0^SP1XQl}}w94>UABHThcsd0%(Q@Y1t$PbU5vizs_YP0Y%xecF?wf6= z9)%wp4Vh;FbG(rSOGJ$r)-eVWZ#gDTD7II>{FTpD%qVKuj;csH(YRX^>8&|dZbOc_ zl#tZeXCou`$l<+z9lOR>M5e=@Uf~F5PwBk0mZU88fqh{(E@Q~WL1D8Ax@m8GZ-~YvCq;^rDAu#?Q}#jB!b-OXp? z86T-jf;IipgIQ16qnE9*ETcBO#^;cNHNr>7y$KW)lE<-E4uf$SH1AlVO#a|;&$3e^ z1Bp;`-1v@$_p5K_8edK|zMN`&-ct=6Rh7LJdUQ8`A7jGv)jnnOQc#hk=D6-8cOm4K z4Alz_*cJplT)hbi8`tDBJg(QCfdwACI>ay19jICm%LfGug)XPVXk5Lf?D7PWNhw3I z3Os|}XtbLr%Ys})2-V4+@U9v2aa)DJr2u9;a?64FZ}iq&GG`naUJ5pEY{boji3W@l z4Rd0D{4%06RzBp3cl$+t<6CJ_Z(2Y<{>e|jt)hFsxAR>`>F?l?jBTAIAVC+TQYx zjQycKn-9PxI-VBKofCts1;`DNue){8m<2I%h+u-R7x9@|VesHL8l5E4gm5UE;q4On z2w45es$di-Bkl!27J1ZQxKBsxn$fXmefjHu5L7O|j9f}piZIk_rZaNJ;>bDIT)g3b z(vJ<@c}N_*^#pX}T}b=BV@k*tf;b+vDG-ai$wg6`j2hCqw066soW*f@hd%lZw!o?S zxDR>Dr9>a{nm90~ z%WzU4T(>4Koe%>FX7m6YKE?}PRCQ1&qHs*W2bfLNAtpcNPgtBDf=Pa#bN70Z8VnG& zE#}2Jg%h3Yk#{^6dBs>mJ?I_p*7_Y^`P#4kvV!_j8TMrj^<@q9xz$jaw&p>9lPhi_ zM&mA|$PiC+?jY`)qP_%LAnj+fS)u6EE+Py?8HymB-)XGQ1`^tl|Q^RzSK zqQI4bBT1fkN9@^LN#zRwzDi?%bc}1B_a)0{fTVcBI`<}f6s5f3E zm5g76q>>%M(1P_G8%g)BK80>I7UQmk022mTX zPd62ok7=;L51T;KV_=X1CEvcykB0-#W3QLL<(WA2 zxRDqaU~;nn-D65rODEJfrXt!5VkAS`0DwS$zj!b)DDpMwCeXFF3+<6*e~f`7>!o-E zdzjSULU%kGP9jT$3n}-di|`+R`sjLI{?_MS$n^noMW`-K)_ok>naP*I7@)PUEa@$# zBg8HkHxLvkOkZMt)MHFqXx$g;f}>XZIkjeRbT9Wj%uj;blL}Vkq-6LY?7aMK&)dlZ z9$X|`-YTXXrlb z43}GT%z=->=&qY&4A08u0CW1~Z-4GZg2p2UF$z5+7b!MiG0RxCylJ06Vh6%v7D}`m zN8?;aju;cp+Fr^Au-KNAoJUr{1LKI>I#nE}!CjIi1DSO=m-8{le{|%${2g!Dm$l%z zTOi@df)b=}axK-3gA-t33DxE9+TD!fUrd7X;IV7Q478aCEuDC)9+AVt8BOAejNY?i zHG{Om15rD6=n#^j)?K+@{?6}n;_wT1NsbN^_J&M#)!`Uce&8IGi=73+R2WFHCW6|u za-Kec3g$FY<2OPYe;A{y`;0_o=W%dEZ>Px7{Ujk{K|tJrCK@Ef*4v5ubxn`3v$X>q z6P@eL5Ye0j`9u~c)@h`5A*2PlvKa>%Sbhl^i7*v1;Cc>JltEJ>g``;3u}4hwKY)YB zih0TzU|_k93jxGz$Fg@;T7Tg8a%+Ajvi>dO}dJTsS_>E%L%34x8? zI1COw3@GFxgB# zXpE6iJiey3e|$gr=o^3J{h&Yo=qKJX9=+#V_lp#V`Tm&}z|FD^YY&;c^APhRi#@3( z=al-`fz;`h$O1lObp))xjZ+bgJR8bDLG=dU2=kdwf9~k*2uA2a`90KY(^JPG@TbBD z^P$|YGxj0{`JN5JDN=5Ila2ZC(X|%@YkMCM9PJ8ZLscht;xS=oLi`U0sF1CiFi043 zw{KI9Njc6OSrb*5Vdh5W41~cbp1}0e9IxKVUw1x^ydT`3{uY4fZwIWu@4NTbYss%N zNB9>be{%%rb{N_!GATCVpn(F$b=_47Z0?MUP-C;jb0lBzlhMU8jMQ_km=IO3op;6X zoOmdc98sJ;`)1v>Q`gR3Q*yA3tvfI>;(K2H?(g$-_6sLU=nguB3x{`NE{%pSr8gs^ zf-%qZd${lb%gHVRj{w@isYxC4Wy=g^YJy~tf7RCXniFvvebs>e4d4h`if~{qa@b(JB9$?+%>&_VWD`_tTF*`XE30W`F(1-a<*d zf9L!7RvAMduJ6?)fA)jV`Af0sJoh;2b6sZaj{;F?7kWsQ&dKK#AA|k!96Db9-beWfu64m3?1BojAlwz^gA}kG$Iwy*j2MJpSW{RZVf{gT#H7U2 z-42e9-;SdTbIsv)fjY9)8(H+d+2MjsS}`34tTm8Tzd~RBzQ++q5~KWj&9NibfAEeq zA(;j!xHj&R41|V;C?nvFkdms3>Kl22miRp(M4cJb7~;a7$Ke-=Qqa?;)2MvxmUq-M zIiG%8rdq%J?%({iAO1qtE`-sNPmt|4bI;N;K!#Ax)vzb*8DQj#tfM`#nbMte!2YCF zYY;?C53n<8W8aVZcp<_^x(!cqgtq!)DZQ=K zXFwLdIv=V{BXceFIqh55Gkr|mY&kC zZ0uWNzou2aGllbg-?F!sDfSQ7_jFr6`@!d&FulPnKajS~@{3502G`E;f5L)+O?>36 z>oAsiBe@A-Nn*8>Y1lINrk-L0I*r!k3l2TF$xr+x`1I!jcI#|NOMdkDhNuYJ`@a1B z&-$=x4Fro*cOG??Ctg4hGPm5$?NY?ZY`Y^W#)Yk1NBLN;yM4nLanK`}gy0QG=-XHC zb1^InW3az5*;1^l-^2(nCH1y11S(#>+n>-`^_r1Zr&sLG!|%GE02H5m7xE@g!DbLADpj zpA|6F(~pc)mx6zaO(zqz4B3e~t?1O{UHeU7`?+XL1OkEt76}DXh--<$*W12d&rIL< z<-C)o@oVvge(=qYe?I+sfBl^XW5$|rz@49ji?UI;Sl0=}-+rW_cu Qb`>!IA+xX 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ÞGISuh+dKBL(65Ewi?nM9MOW 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

y8iJ!+1|DU4@T;2l{Rh%wK9=-20Scpeasp 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 z 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

    $IfGrs3Veb7B)9>EGWvrIh18blr8{T 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 diff --git a/cpp/bindings.cpp b/cpp/bindings.cpp index 0fb2cc86..62cd1069 100644 --- a/cpp/bindings.cpp +++ b/cpp/bindings.cpp @@ -55,32 +55,48 @@ void install(jsi::Runtime &rt, throw std::runtime_error("[op-sqlite][open] database name is required"); } - if (!args[0].isString()) { - throw std::runtime_error( - "[op-sqlite][open] database name must be a string"); - } - - std::string dbName = args[0].asString(rt).utf8(rt); + jsi::Object options = args[0].asObject(rt); + std::string dbName = options.getProperty(rt, "name").asString(rt).utf8(rt); std::string path = std::string(basePath); + std::string location; + std::string encryptionKey; - if (count > 1 && !args[1].isUndefined() && !args[1].isNull()) { - if (!args[1].isString()) { - throw std::runtime_error( - "[op-sqlite][open] database location must be a string"); - } + if (options.hasProperty(rt, "location")) { + location = options.getProperty(rt, "location").asString(rt).utf8(rt); + } + + if (options.hasProperty(rt, "encryptionKey")) { + encryptionKey = + options.getProperty(rt, "encryptionKey").asString(rt).utf8(rt); + } - std::string lastPath = args[1].asString(rt).utf8(rt); +#ifdef OP_SQLITE_USE_SQLCIPHER + if (encryptionKey.empty()) { + throw std::runtime_error( + "[OP SQLite] using SQLCipher encryption key is required"); + } +#else + if (!encryptionKey.empty()) { + throw std::runtime_error("[OP SQLite] SQLCipher is not enabled, " + "encryption key is not allowed"); + } +#endif - if (lastPath == ":memory:") { + if (!location.empty()) { + if (location == ":memory:") { path = ":memory:"; - } else if (lastPath.rfind("/", 0) == 0) { - path = lastPath; + } else if (location.rfind("/", 0) == 0) { + path = location; } else { - path = path + "/" + lastPath; + path = path + "/" + location; } } +#ifdef OP_SQLITE_USE_SQLCIPHER + BridgeResult result = opsqlite_open(dbName, path, encryptionKey); +#else BridgeResult result = opsqlite_open(dbName, path); +#endif if (result.type == SQLiteError) { throw std::runtime_error(result.message); diff --git a/cpp/bridge.cpp b/cpp/bridge.cpp index 225b6209..3caf21c4 100644 --- a/cpp/bridge.cpp +++ b/cpp/bridge.cpp @@ -41,9 +41,15 @@ std::string get_db_path(std::string const &db_name, return location + "/" + db_name; } +#ifdef OP_SQLITE_USE_SQLCIPHER +BridgeResult opsqlite_open(std::string const &dbName, + std::string const &last_path, + std::string const &encryptionKey) { +#else BridgeResult opsqlite_open(std::string const &dbName, std::string const &lastPath) { - std::string dbPath = get_db_path(dbName, lastPath); +#endif + std::string dbPath = get_db_path(dbName, last_path); int sqlOpenFlags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX; @@ -57,7 +63,10 @@ BridgeResult opsqlite_open(std::string const &dbName, } dbMap[dbName] = db; - +#ifdef OP_SQLITE_USE_SQLCIPHER + opsqlite_execute(dbName, "PRAGMA key = '" + encryptionKey + "'", nullptr, + nullptr, nullptr); +#endif return BridgeResult{.type = SQLiteOk, .affectedRows = 0}; } @@ -366,8 +375,8 @@ opsqlite_execute(std::string const &dbName, std::string const &query, }; } - // The statement did not fail to parse but there is nothing to do, just skip - // to the end + // The statement did not fail to parse but there is nothing to do, just + // skip to the end if (statement == NULL) { continue; } @@ -502,8 +511,8 @@ opsqlite_execute(std::string const &dbName, std::string const &query, .insertId = static_cast(latestInsertRowId)}; } -/// Executes returning data in raw arrays, a small performance optimization for -/// certain use cases +/// Executes returning data in raw arrays, a small performance optimization +/// for certain use cases BridgeResult opsqlite_execute_raw(std::string const &dbName, std::string const &query, const std::vector *params, @@ -540,8 +549,8 @@ opsqlite_execute_raw(std::string const &dbName, std::string const &query, }; } - // The statement did not fail to parse but there is nothing to do, just skip - // to the end + // The statement did not fail to parse but there is nothing to do, just + // skip to the end if (statement == NULL) { continue; } @@ -661,8 +670,8 @@ opsqlite_execute_raw(std::string const &dbName, std::string const &query, void opsqlite_close_all() { for (auto const &x : dbMap) { - // Interrupt will make all pending operations to fail with SQLITE_INTERRUPT - // The ongoing work from threads will then fail ASAP + // Interrupt will make all pending operations to fail with + // SQLITE_INTERRUPT The ongoing work from threads will then fail ASAP sqlite3_interrupt(x.second); // Each DB connection can then be safely interrupted sqlite3_close_v2(x.second); diff --git a/cpp/bridge.h b/cpp/bridge.h index a311bdb6..016e78d1 100644 --- a/cpp/bridge.h +++ b/cpp/bridge.h @@ -19,8 +19,13 @@ typedef std::function CommitCallback; typedef std::function RollbackCallback; +#ifdef OP_SQLITE_USE_SQLCIPHER +BridgeResult opsqlite_open(std::string const &dbName, std::string const &dbPath, + std::string const &encryptionKey); +#else BridgeResult opsqlite_open(std::string const &dbName, std::string const &dbPath); +#endif BridgeResult opsqlite_close(std::string const &dbName); diff --git a/cpp/sqlcipher/sqlite3.c b/cpp/sqlcipher/sqlite3.c new file mode 100644 index 00000000..1d51bac7 --- /dev/null +++ b/cpp/sqlcipher/sqlite3.c @@ -0,0 +1,253047 @@ +/****************************************************************************** +** This file is an amalgamation of many separate C source files from SQLite +** version 3.42.0. By combining all the individual C code files into this +** single large file, the entire code can be compiled as a single translation +** unit. This allows many compilers to do optimizations that would not be +** possible if the files were compiled separately. Performance improvements +** of 5% or more are commonly seen when SQLite is compiled as a single +** translation unit. +** +** This file is all you need to compile SQLite. To use SQLite in other +** programs, you need this file and the "sqlite3.h" header file that defines +** the programming interface to the SQLite library. (If you do not have +** the "sqlite3.h" header file at hand, you will find a copy embedded within +** the text of this file. Search for "Begin file sqlite3.h" to find the start +** of the embedded sqlite3.h header file.) Additional code files may be needed +** if you want a wrapper to interface SQLite with your choice of programming +** language. The code for the "sqlite3" command-line shell is also in a +** separate file. This file contains only code for the core SQLite library. +*/ +#define SQLITE_CORE 1 +#define SQLITE_AMALGAMATION 1 +#ifndef SQLITE_PRIVATE +# define SQLITE_PRIVATE static +#endif +/************** Begin file sqliteInt.h ***************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** Internal interface definitions for SQLite. +** +*/ +#ifndef SQLITEINT_H +#define SQLITEINT_H + +/* Special Comments: +** +** Some comments have special meaning to the tools that measure test +** coverage: +** +** NO_TEST - The branches on this line are not +** measured by branch coverage. This is +** used on lines of code that actually +** implement parts of coverage testing. +** +** OPTIMIZATION-IF-TRUE - This branch is allowed to alway be false +** and the correct answer is still obtained, +** though perhaps more slowly. +** +** OPTIMIZATION-IF-FALSE - This branch is allowed to alway be true +** and the correct answer is still obtained, +** though perhaps more slowly. +** +** PREVENTS-HARMLESS-OVERREAD - This branch prevents a buffer overread +** that would be harmless and undetectable +** if it did occur. +** +** In all cases, the special comment must be enclosed in the usual +** slash-asterisk...asterisk-slash comment marks, with no spaces between the +** asterisks and the comment text. +*/ + +/* +** Make sure the Tcl calling convention macro is defined. This macro is +** only used by test code and Tcl integration code. +*/ +#ifndef SQLITE_TCLAPI +# define SQLITE_TCLAPI +#endif + +/* +** Include the header file used to customize the compiler options for MSVC. +** This should be done first so that it can successfully prevent spurious +** compiler warnings due to subsequent content in this file and other files +** that are included by this file. +*/ +/************** Include msvc.h in the middle of sqliteInt.h ******************/ +/************** Begin file msvc.h ********************************************/ +/* +** 2015 January 12 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains code that is specific to MSVC. +*/ +#ifndef SQLITE_MSVC_H +#define SQLITE_MSVC_H + +#if defined(_MSC_VER) +#pragma warning(disable : 4054) +#pragma warning(disable : 4055) +#pragma warning(disable : 4100) +#pragma warning(disable : 4127) +#pragma warning(disable : 4130) +#pragma warning(disable : 4152) +#pragma warning(disable : 4189) +#pragma warning(disable : 4206) +#pragma warning(disable : 4210) +#pragma warning(disable : 4232) +#pragma warning(disable : 4244) +#pragma warning(disable : 4305) +#pragma warning(disable : 4306) +#pragma warning(disable : 4702) +#pragma warning(disable : 4706) +#endif /* defined(_MSC_VER) */ + +#if defined(_MSC_VER) && !defined(_WIN64) +#undef SQLITE_4_BYTE_ALIGNED_MALLOC +#define SQLITE_4_BYTE_ALIGNED_MALLOC +#endif /* defined(_MSC_VER) && !defined(_WIN64) */ + +#if !defined(HAVE_LOG2) && defined(_MSC_VER) && _MSC_VER<1800 +#define HAVE_LOG2 0 +#endif /* !defined(HAVE_LOG2) && defined(_MSC_VER) && _MSC_VER<1800 */ + +#endif /* SQLITE_MSVC_H */ + +/************** End of msvc.h ************************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ + +/* +** Special setup for VxWorks +*/ +/************** Include vxworks.h in the middle of sqliteInt.h ***************/ +/************** Begin file vxworks.h *****************************************/ +/* +** 2015-03-02 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains code that is specific to Wind River's VxWorks +*/ +#if defined(__RTP__) || defined(_WRS_KERNEL) +/* This is VxWorks. Set up things specially for that OS +*/ +#include +#include /* amalgamator: dontcache */ +#define OS_VXWORKS 1 +#define SQLITE_OS_OTHER 0 +#define SQLITE_HOMEGROWN_RECURSIVE_MUTEX 1 +#define SQLITE_OMIT_LOAD_EXTENSION 1 +#define SQLITE_ENABLE_LOCKING_STYLE 0 +#define HAVE_UTIME 1 +#else +/* This is not VxWorks. */ +#define OS_VXWORKS 0 +#define HAVE_FCHOWN 1 +#define HAVE_READLINK 1 +#define HAVE_LSTAT 1 +#endif /* defined(_WRS_KERNEL) */ + +/************** End of vxworks.h *********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ + +/* +** These #defines should enable >2GB file support on POSIX if the +** underlying operating system supports it. If the OS lacks +** large file support, or if the OS is windows, these should be no-ops. +** +** Ticket #2739: The _LARGEFILE_SOURCE macro must appear before any +** system #includes. Hence, this block of code must be the very first +** code in all source files. +** +** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch +** on the compiler command line. This is necessary if you are compiling +** on a recent machine (ex: Red Hat 7.2) but you want your code to work +** on an older machine (ex: Red Hat 6.0). If you compile on Red Hat 7.2 +** without this option, LFS is enable. But LFS does not exist in the kernel +** in Red Hat 6.0, so the code won't work. Hence, for maximum binary +** portability you should omit LFS. +** +** The previous paragraph was written in 2005. (This paragraph is written +** on 2008-11-28.) These days, all Linux kernels support large files, so +** you should probably leave LFS enabled. But some embedded platforms might +** lack LFS in which case the SQLITE_DISABLE_LFS macro might still be useful. +** +** Similar is true for Mac OS X. LFS is only supported on Mac OS X 9 and later. +*/ +#ifndef SQLITE_DISABLE_LFS +# define _LARGE_FILE 1 +# ifndef _FILE_OFFSET_BITS +# define _FILE_OFFSET_BITS 64 +# endif +# define _LARGEFILE_SOURCE 1 +#endif + +/* The GCC_VERSION and MSVC_VERSION macros are used to +** conditionally include optimizations for each of these compilers. A +** value of 0 means that compiler is not being used. The +** SQLITE_DISABLE_INTRINSIC macro means do not use any compiler-specific +** optimizations, and hence set all compiler macros to 0 +** +** There was once also a CLANG_VERSION macro. However, we learn that the +** version numbers in clang are for "marketing" only and are inconsistent +** and unreliable. Fortunately, all versions of clang also recognize the +** gcc version numbers and have reasonable settings for gcc version numbers, +** so the GCC_VERSION macro will be set to a correct non-zero value even +** when compiling with clang. +*/ +#if defined(__GNUC__) && !defined(SQLITE_DISABLE_INTRINSIC) +# define GCC_VERSION (__GNUC__*1000000+__GNUC_MINOR__*1000+__GNUC_PATCHLEVEL__) +#else +# define GCC_VERSION 0 +#endif +#if defined(_MSC_VER) && !defined(SQLITE_DISABLE_INTRINSIC) +# define MSVC_VERSION _MSC_VER +#else +# define MSVC_VERSION 0 +#endif + +/* +** Some C99 functions in "math.h" are only present for MSVC when its version +** is associated with Visual Studio 2013 or higher. +*/ +#ifndef SQLITE_HAVE_C99_MATH_FUNCS +# if MSVC_VERSION==0 || MSVC_VERSION>=1800 +# define SQLITE_HAVE_C99_MATH_FUNCS (1) +# else +# define SQLITE_HAVE_C99_MATH_FUNCS (0) +# endif +#endif + +/* Needed for various definitions... */ +#if defined(__GNUC__) && !defined(_GNU_SOURCE) +# define _GNU_SOURCE +#endif + +#if defined(__OpenBSD__) && !defined(_BSD_SOURCE) +# define _BSD_SOURCE +#endif + +/* +** Macro to disable warnings about missing "break" at the end of a "case". +*/ +#if GCC_VERSION>=7000000 +# define deliberate_fall_through __attribute__((fallthrough)); +#else +# define deliberate_fall_through +#endif + +/* +** For MinGW, check to see if we can include the header file containing its +** version information, among other things. Normally, this internal MinGW +** header file would [only] be included automatically by other MinGW header +** files; however, the contained version information is now required by this +** header file to work around binary compatibility issues (see below) and +** this is the only known way to reliably obtain it. This entire #if block +** would be completely unnecessary if there was any other way of detecting +** MinGW via their preprocessor (e.g. if they customized their GCC to define +** some MinGW-specific macros). When compiling for MinGW, either the +** _HAVE_MINGW_H or _HAVE__MINGW_H (note the extra underscore) macro must be +** defined; otherwise, detection of conditions specific to MinGW will be +** disabled. +*/ +#if defined(_HAVE_MINGW_H) +# include "mingw.h" +#elif defined(_HAVE__MINGW_H) +# include "_mingw.h" +#endif + +/* +** For MinGW version 4.x (and higher), check to see if the _USE_32BIT_TIME_T +** define is required to maintain binary compatibility with the MSVC runtime +** library in use (e.g. for Windows XP). +*/ +#if !defined(_USE_32BIT_TIME_T) && !defined(_USE_64BIT_TIME_T) && \ + defined(_WIN32) && !defined(_WIN64) && \ + defined(__MINGW_MAJOR_VERSION) && __MINGW_MAJOR_VERSION >= 4 && \ + defined(__MSVCRT__) +# define _USE_32BIT_TIME_T +#endif + +/* Optionally #include a user-defined header, whereby compilation options +** may be set prior to where they take effect, but after platform setup. +** If SQLITE_CUSTOM_INCLUDE=? is defined, its value names the #include +** file. +*/ +#ifdef SQLITE_CUSTOM_INCLUDE +# define INC_STRINGIFY_(f) #f +# define INC_STRINGIFY(f) INC_STRINGIFY_(f) +# include INC_STRINGIFY(SQLITE_CUSTOM_INCLUDE) +#endif + +/* The public SQLite interface. The _FILE_OFFSET_BITS macro must appear +** first in QNX. Also, the _USE_32BIT_TIME_T macro must appear first for +** MinGW. +*/ +/************** Include sqlite3.h in the middle of sqliteInt.h ***************/ +/************** Begin file sqlite3.h *****************************************/ +/* +** 2001-09-15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This header file defines the interface that the SQLite library +** presents to client programs. If a C-function, structure, datatype, +** or constant definition does not appear in this file, then it is +** not a published API of SQLite, is subject to change without +** notice, and should not be referenced by programs that use SQLite. +** +** Some of the definitions that are in this file are marked as +** "experimental". Experimental interfaces are normally new +** features recently added to SQLite. We do not anticipate changes +** to experimental interfaces but reserve the right to make minor changes +** if experience from use "in the wild" suggest such changes are prudent. +** +** The official C-language API documentation for SQLite is derived +** from comments in this file. This file is the authoritative source +** on how SQLite interfaces are supposed to operate. +** +** The name of this file under configuration management is "sqlite.h.in". +** The makefile makes some minor changes to this file (such as inserting +** the version number) and changes its name to "sqlite3.h" as +** part of the build process. +*/ +#ifndef SQLITE3_H +#define SQLITE3_H +#include /* Needed for the definition of va_list */ + +/* +** Make sure we can call this stuff from C++. +*/ +#if 0 +extern "C" { +#endif + + +/* +** Facilitate override of interface linkage and calling conventions. +** Be aware that these macros may not be used within this particular +** translation of the amalgamation and its associated header file. +** +** The SQLITE_EXTERN and SQLITE_API macros are used to instruct the +** compiler that the target identifier should have external linkage. +** +** The SQLITE_CDECL macro is used to set the calling convention for +** public functions that accept a variable number of arguments. +** +** The SQLITE_APICALL macro is used to set the calling convention for +** public functions that accept a fixed number of arguments. +** +** The SQLITE_STDCALL macro is no longer used and is now deprecated. +** +** The SQLITE_CALLBACK macro is used to set the calling convention for +** function pointers. +** +** The SQLITE_SYSAPI macro is used to set the calling convention for +** functions provided by the operating system. +** +** Currently, the SQLITE_CDECL, SQLITE_APICALL, SQLITE_CALLBACK, and +** SQLITE_SYSAPI macros are used only when building for environments +** that require non-default calling conventions. +*/ +#ifndef SQLITE_EXTERN +# define SQLITE_EXTERN extern +#endif +#ifndef SQLITE_API +# define SQLITE_API +#endif +#ifndef SQLITE_CDECL +# define SQLITE_CDECL +#endif +#ifndef SQLITE_APICALL +# define SQLITE_APICALL +#endif +#ifndef SQLITE_STDCALL +# define SQLITE_STDCALL SQLITE_APICALL +#endif +#ifndef SQLITE_CALLBACK +# define SQLITE_CALLBACK +#endif +#ifndef SQLITE_SYSAPI +# define SQLITE_SYSAPI +#endif + +/* +** These no-op macros are used in front of interfaces to mark those +** interfaces as either deprecated or experimental. New applications +** should not use deprecated interfaces - they are supported for backwards +** compatibility only. Application writers should be aware that +** experimental interfaces are subject to change in point releases. +** +** These macros used to resolve to various kinds of compiler magic that +** would generate warning messages when they were used. But that +** compiler magic ended up generating such a flurry of bug reports +** that we have taken it all out and gone back to using simple +** noop macros. +*/ +#define SQLITE_DEPRECATED +#define SQLITE_EXPERIMENTAL + +/* +** Ensure these symbols were not defined by some previous header file. +*/ +#ifdef SQLITE_VERSION +# undef SQLITE_VERSION +#endif +#ifdef SQLITE_VERSION_NUMBER +# undef SQLITE_VERSION_NUMBER +#endif + +/* +** CAPI3REF: Compile-Time Library Version Numbers +** +** ^(The [SQLITE_VERSION] C preprocessor macro in the sqlite3.h header +** evaluates to a string literal that is the SQLite version in the +** format "X.Y.Z" where X is the major version number (always 3 for +** SQLite3) and Y is the minor version number and Z is the release number.)^ +** ^(The [SQLITE_VERSION_NUMBER] C preprocessor macro resolves to an integer +** with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same +** numbers used in [SQLITE_VERSION].)^ +** The SQLITE_VERSION_NUMBER for any given release of SQLite will also +** be larger than the release from which it is derived. Either Y will +** be held constant and Z will be incremented or else Y will be incremented +** and Z will be reset to zero. +** +** Since [version 3.6.18] ([dateof:3.6.18]), +** SQLite source code has been stored in the +** Fossil configuration management +** system. ^The SQLITE_SOURCE_ID macro evaluates to +** a string which identifies a particular check-in of SQLite +** within its configuration management system. ^The SQLITE_SOURCE_ID +** string contains the date and time of the check-in (UTC) and a SHA1 +** or SHA3-256 hash of the entire source tree. If the source code has +** been edited in any way since it was last checked in, then the last +** four hexadecimal digits of the hash may be modified. +** +** See also: [sqlite3_libversion()], +** [sqlite3_libversion_number()], [sqlite3_sourceid()], +** [sqlite_version()] and [sqlite_source_id()]. +*/ +#define SQLITE_VERSION "3.42.0" +#define SQLITE_VERSION_NUMBER 3042000 +#define SQLITE_SOURCE_ID "2023-05-16 12:36:15 831d0fb2836b71c9bc51067c49fee4b8f18047814f2ff22d817d25195cf3alt1" + +/* +** CAPI3REF: Run-Time Library Version Numbers +** KEYWORDS: sqlite3_version sqlite3_sourceid +** +** These interfaces provide the same information as the [SQLITE_VERSION], +** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros +** but are associated with the library instead of the header file. ^(Cautious +** programmers might include assert() statements in their application to +** verify that values returned by these interfaces match the macros in +** the header, and thus ensure that the application is +** compiled with matching library and header files. +** +** 
    +** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );
+** assert( strncmp(sqlite3_sourceid(),SQLITE_SOURCE_ID,80)==0 );
+** assert( strcmp(sqlite3_libversion(),SQLITE_VERSION)==0 );
+**
    )^ +** +** ^The sqlite3_version[] string constant contains the text of [SQLITE_VERSION] +** macro. ^The sqlite3_libversion() function returns a pointer to the +** to the sqlite3_version[] string constant. The sqlite3_libversion() +** function is provided for use in DLLs since DLL users usually do not have +** direct access to string constants within the DLL. ^The +** sqlite3_libversion_number() function returns an integer equal to +** [SQLITE_VERSION_NUMBER]. ^(The sqlite3_sourceid() function returns +** a pointer to a string constant whose value is the same as the +** [SQLITE_SOURCE_ID] C preprocessor macro. Except if SQLite is built +** using an edited copy of [the amalgamation], then the last four characters +** of the hash might be different from [SQLITE_SOURCE_ID].)^ +** +** See also: [sqlite_version()] and [sqlite_source_id()]. +*/ +SQLITE_API const char sqlite3_version[] = SQLITE_VERSION; +SQLITE_API const char *sqlite3_libversion(void); +SQLITE_API const char *sqlite3_sourceid(void); +SQLITE_API int sqlite3_libversion_number(void); + +/* +** CAPI3REF: Run-Time Library Compilation Options Diagnostics +** +** ^The sqlite3_compileoption_used() function returns 0 or 1 +** indicating whether the specified option was defined at +** compile time. ^The SQLITE_ prefix may be omitted from the +** option name passed to sqlite3_compileoption_used(). +** +** ^The sqlite3_compileoption_get() function allows iterating +** over the list of options that were defined at compile time by +** returning the N-th compile time option string. ^If N is out of range, +** sqlite3_compileoption_get() returns a NULL pointer. ^The SQLITE_ +** prefix is omitted from any strings returned by +** sqlite3_compileoption_get(). +** +** ^Support for the diagnostic functions sqlite3_compileoption_used() +** and sqlite3_compileoption_get() may be omitted by specifying the +** [SQLITE_OMIT_COMPILEOPTION_DIAGS] option at compile time. +** +** See also: SQL functions [sqlite_compileoption_used()] and +** [sqlite_compileoption_get()] and the [compile_options pragma]. +*/ +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS +SQLITE_API int sqlite3_compileoption_used(const char *zOptName); +SQLITE_API const char *sqlite3_compileoption_get(int N); +#else +# define sqlite3_compileoption_used(X) 0 +# define sqlite3_compileoption_get(X) ((void*)0) +#endif + +/* +** CAPI3REF: Test To See If The Library Is Threadsafe +** +** ^The sqlite3_threadsafe() function returns zero if and only if +** SQLite was compiled with mutexing code omitted due to the +** [SQLITE_THREADSAFE] compile-time option being set to 0. +** +** SQLite can be compiled with or without mutexes. When +** the [SQLITE_THREADSAFE] C preprocessor macro is 1 or 2, mutexes +** are enabled and SQLite is threadsafe. When the +** [SQLITE_THREADSAFE] macro is 0, +** the mutexes are omitted. Without the mutexes, it is not safe +** to use SQLite concurrently from more than one thread. +** +** Enabling mutexes incurs a measurable performance penalty. +** So if speed is of utmost importance, it makes sense to disable +** the mutexes. But for maximum safety, mutexes should be enabled. +** ^The default behavior is for mutexes to be enabled. +** +** This interface can be used by an application to make sure that the +** version of SQLite that it is linking against was compiled with +** the desired setting of the [SQLITE_THREADSAFE] macro. +** +** This interface only reports on the compile-time mutex setting +** of the [SQLITE_THREADSAFE] flag. If SQLite is compiled with +** SQLITE_THREADSAFE=1 or =2 then mutexes are enabled by default but +** can be fully or partially disabled using a call to [sqlite3_config()] +** with the verbs [SQLITE_CONFIG_SINGLETHREAD], [SQLITE_CONFIG_MULTITHREAD], +** or [SQLITE_CONFIG_SERIALIZED]. ^(The return value of the +** sqlite3_threadsafe() function shows only the compile-time setting of +** thread safety, not any run-time changes to that setting made by +** sqlite3_config(). In other words, the return value from sqlite3_threadsafe() +** is unchanged by calls to sqlite3_config().)^ +** +** See the [threading mode] documentation for additional information. +*/ +SQLITE_API int sqlite3_threadsafe(void); + +/* +** CAPI3REF: Database Connection Handle +** KEYWORDS: {database connection} {database connections} +** +** Each open SQLite database is represented by a pointer to an instance of +** the opaque structure named "sqlite3". It is useful to think of an sqlite3 +** pointer as an object. The [sqlite3_open()], [sqlite3_open16()], and +** [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()] +** and [sqlite3_close_v2()] are its destructors. There are many other +** interfaces (such as +** [sqlite3_prepare_v2()], [sqlite3_create_function()], and +** [sqlite3_busy_timeout()] to name but three) that are methods on an +** sqlite3 object. +*/ +typedef struct sqlite3 sqlite3; + +/* +** CAPI3REF: 64-Bit Integer Types +** KEYWORDS: sqlite_int64 sqlite_uint64 +** +** Because there is no cross-platform way to specify 64-bit integer types +** SQLite includes typedefs for 64-bit signed and unsigned integers. +** +** The sqlite3_int64 and sqlite3_uint64 are the preferred type definitions. +** The sqlite_int64 and sqlite_uint64 types are supported for backwards +** compatibility only. +** +** ^The sqlite3_int64 and sqlite_int64 types can store integer values +** between -9223372036854775808 and +9223372036854775807 inclusive. ^The +** sqlite3_uint64 and sqlite_uint64 types can store integer values +** between 0 and +18446744073709551615 inclusive. +*/ +#ifdef SQLITE_INT64_TYPE + typedef SQLITE_INT64_TYPE sqlite_int64; +# ifdef SQLITE_UINT64_TYPE + typedef SQLITE_UINT64_TYPE sqlite_uint64; +# else + typedef unsigned SQLITE_INT64_TYPE sqlite_uint64; +# endif +#elif defined(_MSC_VER) || defined(__BORLANDC__) + typedef __int64 sqlite_int64; + typedef unsigned __int64 sqlite_uint64; +#else + typedef long long int sqlite_int64; + typedef unsigned long long int sqlite_uint64; +#endif +typedef sqlite_int64 sqlite3_int64; +typedef sqlite_uint64 sqlite3_uint64; + +/* +** If compiling for a processor that lacks floating point support, +** substitute integer for floating-point. +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# define double sqlite3_int64 +#endif + +/* +** CAPI3REF: Closing A Database Connection +** DESTRUCTOR: sqlite3 +** +** ^The sqlite3_close() and sqlite3_close_v2() routines are destructors +** for the [sqlite3] object. +** ^Calls to sqlite3_close() and sqlite3_close_v2() return [SQLITE_OK] if +** the [sqlite3] object is successfully destroyed and all associated +** resources are deallocated. +** +** Ideally, applications should [sqlite3_finalize | finalize] all +** [prepared statements], [sqlite3_blob_close | close] all [BLOB handles], and +** [sqlite3_backup_finish | finish] all [sqlite3_backup] objects associated +** with the [sqlite3] object prior to attempting to close the object. +** ^If the database connection is associated with unfinalized prepared +** statements, BLOB handlers, and/or unfinished sqlite3_backup objects then +** sqlite3_close() will leave the database connection open and return +** [SQLITE_BUSY]. ^If sqlite3_close_v2() is called with unfinalized prepared +** statements, unclosed BLOB handlers, and/or unfinished sqlite3_backups, +** it returns [SQLITE_OK] regardless, but instead of deallocating the database +** connection immediately, it marks the database connection as an unusable +** "zombie" and makes arrangements to automatically deallocate the database +** connection after all prepared statements are finalized, all BLOB handles +** are closed, and all backups have finished. The sqlite3_close_v2() interface +** is intended for use with host languages that are garbage collected, and +** where the order in which destructors are called is arbitrary. +** +** ^If an [sqlite3] object is destroyed while a transaction is open, +** the transaction is automatically rolled back. +** +** The C parameter to [sqlite3_close(C)] and [sqlite3_close_v2(C)] +** must be either a NULL +** pointer or an [sqlite3] object pointer obtained +** from [sqlite3_open()], [sqlite3_open16()], or +** [sqlite3_open_v2()], and not previously closed. +** ^Calling sqlite3_close() or sqlite3_close_v2() with a NULL pointer +** argument is a harmless no-op. +*/ +SQLITE_API int sqlite3_close(sqlite3*); +SQLITE_API int sqlite3_close_v2(sqlite3*); + +/* +** The type for a callback function. +** This is legacy and deprecated. It is included for historical +** compatibility and is not documented. +*/ +typedef int (*sqlite3_callback)(void*,int,char**, char**); + +/* +** CAPI3REF: One-Step Query Execution Interface +** METHOD: sqlite3 +** +** The sqlite3_exec() interface is a convenience wrapper around +** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()], +** that allows an application to run multiple statements of SQL +** without having to use a lot of C code. +** +** ^The sqlite3_exec() interface runs zero or more UTF-8 encoded, +** semicolon-separate SQL statements passed into its 2nd argument, +** in the context of the [database connection] passed in as its 1st +** argument. ^If the callback function of the 3rd argument to +** sqlite3_exec() is not NULL, then it is invoked for each result row +** coming out of the evaluated SQL statements. ^The 4th argument to +** sqlite3_exec() is relayed through to the 1st argument of each +** callback invocation. ^If the callback pointer to sqlite3_exec() +** is NULL, then no callback is ever invoked and result rows are +** ignored. +** +** ^If an error occurs while evaluating the SQL statements passed into +** sqlite3_exec(), then execution of the current statement stops and +** subsequent statements are skipped. ^If the 5th parameter to sqlite3_exec() +** is not NULL then any error message is written into memory obtained +** from [sqlite3_malloc()] and passed back through the 5th parameter. +** To avoid memory leaks, the application should invoke [sqlite3_free()] +** on error message strings returned through the 5th parameter of +** sqlite3_exec() after the error message string is no longer needed. +** ^If the 5th parameter to sqlite3_exec() is not NULL and no errors +** occur, then sqlite3_exec() sets the pointer in its 5th parameter to +** NULL before returning. +** +** ^If an sqlite3_exec() callback returns non-zero, the sqlite3_exec() +** routine returns SQLITE_ABORT without invoking the callback again and +** without running any subsequent SQL statements. +** +** ^The 2nd argument to the sqlite3_exec() callback function is the +** number of columns in the result. ^The 3rd argument to the sqlite3_exec() +** callback is an array of pointers to strings obtained as if from +** [sqlite3_column_text()], one for each column. ^If an element of a +** result row is NULL then the corresponding string pointer for the +** sqlite3_exec() callback is a NULL pointer. ^The 4th argument to the +** sqlite3_exec() callback is an array of pointers to strings where each +** entry represents the name of corresponding result column as obtained +** from [sqlite3_column_name()]. +** +** ^If the 2nd parameter to sqlite3_exec() is a NULL pointer, a pointer +** to an empty string, or a pointer that contains only whitespace and/or +** SQL comments, then no SQL statements are evaluated and the database +** is not changed. +** +** Restrictions: +** +**
      +**
    • The application must ensure that the 1st parameter to sqlite3_exec() +** is a valid and open [database connection]. +**
    • The application must not close the [database connection] specified by +** the 1st parameter to sqlite3_exec() while sqlite3_exec() is running. +**
    • The application must not modify the SQL statement text passed into +** the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running. +**
    +*/ +SQLITE_API int sqlite3_exec( + sqlite3*, /* An open database */ + const char *sql, /* SQL to be evaluated */ + int (*callback)(void*,int,char**,char**), /* Callback function */ + void *, /* 1st argument to callback */ + char **errmsg /* Error msg written here */ +); + +/* +** CAPI3REF: Result Codes +** KEYWORDS: {result code definitions} +** +** Many SQLite functions return an integer result code from the set shown +** here in order to indicate success or failure. +** +** New error codes may be added in future versions of SQLite. +** +** See also: [extended result code definitions] +*/ +#define SQLITE_OK 0 /* Successful result */ +/* beginning-of-error-codes */ +#define SQLITE_ERROR 1 /* Generic error */ +#define SQLITE_INTERNAL 2 /* Internal logic error in SQLite */ +#define SQLITE_PERM 3 /* Access permission denied */ +#define SQLITE_ABORT 4 /* Callback routine requested an abort */ +#define SQLITE_BUSY 5 /* The database file is locked */ +#define SQLITE_LOCKED 6 /* A table in the database is locked */ +#define SQLITE_NOMEM 7 /* A malloc() failed */ +#define SQLITE_READONLY 8 /* Attempt to write a readonly database */ +#define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/ +#define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */ +#define SQLITE_CORRUPT 11 /* The database disk image is malformed */ +#define SQLITE_NOTFOUND 12 /* Unknown opcode in sqlite3_file_control() */ +#define SQLITE_FULL 13 /* Insertion failed because database is full */ +#define SQLITE_CANTOPEN 14 /* Unable to open the database file */ +#define SQLITE_PROTOCOL 15 /* Database lock protocol error */ +#define SQLITE_EMPTY 16 /* Internal use only */ +#define SQLITE_SCHEMA 17 /* The database schema changed */ +#define SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */ +#define SQLITE_CONSTRAINT 19 /* Abort due to constraint violation */ +#define SQLITE_MISMATCH 20 /* Data type mismatch */ +#define SQLITE_MISUSE 21 /* Library used incorrectly */ +#define SQLITE_NOLFS 22 /* Uses OS features not supported on host */ +#define SQLITE_AUTH 23 /* Authorization denied */ +#define SQLITE_FORMAT 24 /* Not used */ +#define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */ +#define SQLITE_NOTADB 26 /* File opened that is not a database file */ +#define SQLITE_NOTICE 27 /* Notifications from sqlite3_log() */ +#define SQLITE_WARNING 28 /* Warnings from sqlite3_log() */ +#define SQLITE_ROW 100 /* sqlite3_step() has another row ready */ +#define SQLITE_DONE 101 /* sqlite3_step() has finished executing */ +/* end-of-error-codes */ + +/* +** CAPI3REF: Extended Result Codes +** KEYWORDS: {extended result code definitions} +** +** In its default configuration, SQLite API routines return one of 30 integer +** [result codes]. However, experience has shown that many of +** these result codes are too coarse-grained. They do not provide as +** much information about problems as programmers might like. In an effort to +** address this, newer versions of SQLite (version 3.3.8 [dateof:3.3.8] +** and later) include +** support for additional result codes that provide more detailed information +** about errors. These [extended result codes] are enabled or disabled +** on a per database connection basis using the +** [sqlite3_extended_result_codes()] API. Or, the extended code for +** the most recent error can be obtained using +** [sqlite3_extended_errcode()]. +*/ +#define SQLITE_ERROR_MISSING_COLLSEQ (SQLITE_ERROR | (1<<8)) +#define SQLITE_ERROR_RETRY (SQLITE_ERROR | (2<<8)) +#define SQLITE_ERROR_SNAPSHOT (SQLITE_ERROR | (3<<8)) +#define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8)) +#define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8)) +#define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8)) +#define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8)) +#define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8)) +#define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8)) +#define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8)) +#define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8)) +#define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8)) +#define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8)) +#define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8)) +#define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8)) +#define SQLITE_IOERR_ACCESS (SQLITE_IOERR | (13<<8)) +#define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8)) +#define SQLITE_IOERR_LOCK (SQLITE_IOERR | (15<<8)) +#define SQLITE_IOERR_CLOSE (SQLITE_IOERR | (16<<8)) +#define SQLITE_IOERR_DIR_CLOSE (SQLITE_IOERR | (17<<8)) +#define SQLITE_IOERR_SHMOPEN (SQLITE_IOERR | (18<<8)) +#define SQLITE_IOERR_SHMSIZE (SQLITE_IOERR | (19<<8)) +#define SQLITE_IOERR_SHMLOCK (SQLITE_IOERR | (20<<8)) +#define SQLITE_IOERR_SHMMAP (SQLITE_IOERR | (21<<8)) +#define SQLITE_IOERR_SEEK (SQLITE_IOERR | (22<<8)) +#define SQLITE_IOERR_DELETE_NOENT (SQLITE_IOERR | (23<<8)) +#define SQLITE_IOERR_MMAP (SQLITE_IOERR | (24<<8)) +#define SQLITE_IOERR_GETTEMPPATH (SQLITE_IOERR | (25<<8)) +#define SQLITE_IOERR_CONVPATH (SQLITE_IOERR | (26<<8)) +#define SQLITE_IOERR_VNODE (SQLITE_IOERR | (27<<8)) +#define SQLITE_IOERR_AUTH (SQLITE_IOERR | (28<<8)) +#define SQLITE_IOERR_BEGIN_ATOMIC (SQLITE_IOERR | (29<<8)) +#define SQLITE_IOERR_COMMIT_ATOMIC (SQLITE_IOERR | (30<<8)) +#define SQLITE_IOERR_ROLLBACK_ATOMIC (SQLITE_IOERR | (31<<8)) +#define SQLITE_IOERR_DATA (SQLITE_IOERR | (32<<8)) +#define SQLITE_IOERR_CORRUPTFS (SQLITE_IOERR | (33<<8)) +#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8)) +#define SQLITE_LOCKED_VTAB (SQLITE_LOCKED | (2<<8)) +#define SQLITE_BUSY_RECOVERY (SQLITE_BUSY | (1<<8)) +#define SQLITE_BUSY_SNAPSHOT (SQLITE_BUSY | (2<<8)) +#define SQLITE_BUSY_TIMEOUT (SQLITE_BUSY | (3<<8)) +#define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN | (1<<8)) +#define SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN | (2<<8)) +#define SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN | (3<<8)) +#define SQLITE_CANTOPEN_CONVPATH (SQLITE_CANTOPEN | (4<<8)) +#define SQLITE_CANTOPEN_DIRTYWAL (SQLITE_CANTOPEN | (5<<8)) /* Not Used */ +#define SQLITE_CANTOPEN_SYMLINK (SQLITE_CANTOPEN | (6<<8)) +#define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT | (1<<8)) +#define SQLITE_CORRUPT_SEQUENCE (SQLITE_CORRUPT | (2<<8)) +#define SQLITE_CORRUPT_INDEX (SQLITE_CORRUPT | (3<<8)) +#define SQLITE_READONLY_RECOVERY (SQLITE_READONLY | (1<<8)) +#define SQLITE_READONLY_CANTLOCK (SQLITE_READONLY | (2<<8)) +#define SQLITE_READONLY_ROLLBACK (SQLITE_READONLY | (3<<8)) +#define SQLITE_READONLY_DBMOVED (SQLITE_READONLY | (4<<8)) +#define SQLITE_READONLY_CANTINIT (SQLITE_READONLY | (5<<8)) +#define SQLITE_READONLY_DIRECTORY (SQLITE_READONLY | (6<<8)) +#define SQLITE_ABORT_ROLLBACK (SQLITE_ABORT | (2<<8)) +#define SQLITE_CONSTRAINT_CHECK (SQLITE_CONSTRAINT | (1<<8)) +#define SQLITE_CONSTRAINT_COMMITHOOK (SQLITE_CONSTRAINT | (2<<8)) +#define SQLITE_CONSTRAINT_FOREIGNKEY (SQLITE_CONSTRAINT | (3<<8)) +#define SQLITE_CONSTRAINT_FUNCTION (SQLITE_CONSTRAINT | (4<<8)) +#define SQLITE_CONSTRAINT_NOTNULL (SQLITE_CONSTRAINT | (5<<8)) +#define SQLITE_CONSTRAINT_PRIMARYKEY (SQLITE_CONSTRAINT | (6<<8)) +#define SQLITE_CONSTRAINT_TRIGGER (SQLITE_CONSTRAINT | (7<<8)) +#define SQLITE_CONSTRAINT_UNIQUE (SQLITE_CONSTRAINT | (8<<8)) +#define SQLITE_CONSTRAINT_VTAB (SQLITE_CONSTRAINT | (9<<8)) +#define SQLITE_CONSTRAINT_ROWID (SQLITE_CONSTRAINT |(10<<8)) +#define SQLITE_CONSTRAINT_PINNED (SQLITE_CONSTRAINT |(11<<8)) +#define SQLITE_CONSTRAINT_DATATYPE (SQLITE_CONSTRAINT |(12<<8)) +#define SQLITE_NOTICE_RECOVER_WAL (SQLITE_NOTICE | (1<<8)) +#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8)) +#define SQLITE_NOTICE_RBU (SQLITE_NOTICE | (3<<8)) +#define SQLITE_WARNING_AUTOINDEX (SQLITE_WARNING | (1<<8)) +#define SQLITE_AUTH_USER (SQLITE_AUTH | (1<<8)) +#define SQLITE_OK_LOAD_PERMANENTLY (SQLITE_OK | (1<<8)) +#define SQLITE_OK_SYMLINK (SQLITE_OK | (2<<8)) /* internal use only */ + +/* +** CAPI3REF: Flags For File Open Operations +** +** These bit values are intended for use in the +** 3rd parameter to the [sqlite3_open_v2()] interface and +** in the 4th parameter to the [sqlite3_vfs.xOpen] method. +** +** Only those flags marked as "Ok for sqlite3_open_v2()" may be +** used as the third argument to the [sqlite3_open_v2()] interface. +** The other flags have historically been ignored by sqlite3_open_v2(), +** though future versions of SQLite might change so that an error is +** raised if any of the disallowed bits are passed into sqlite3_open_v2(). +** Applications should not depend on the historical behavior. +** +** Note in particular that passing the SQLITE_OPEN_EXCLUSIVE flag into +** [sqlite3_open_v2()] does *not* cause the underlying database file +** to be opened using O_EXCL. Passing SQLITE_OPEN_EXCLUSIVE into +** [sqlite3_open_v2()] has historically be a no-op and might become an +** error in future versions of SQLite. +*/ +#define SQLITE_OPEN_READONLY 0x00000001 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_READWRITE 0x00000002 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_CREATE 0x00000004 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_DELETEONCLOSE 0x00000008 /* VFS only */ +#define SQLITE_OPEN_EXCLUSIVE 0x00000010 /* VFS only */ +#define SQLITE_OPEN_AUTOPROXY 0x00000020 /* VFS only */ +#define SQLITE_OPEN_URI 0x00000040 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_MEMORY 0x00000080 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_MAIN_DB 0x00000100 /* VFS only */ +#define SQLITE_OPEN_TEMP_DB 0x00000200 /* VFS only */ +#define SQLITE_OPEN_TRANSIENT_DB 0x00000400 /* VFS only */ +#define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 /* VFS only */ +#define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 /* VFS only */ +#define SQLITE_OPEN_SUBJOURNAL 0x00002000 /* VFS only */ +#define SQLITE_OPEN_SUPER_JOURNAL 0x00004000 /* VFS only */ +#define SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_WAL 0x00080000 /* VFS only */ +#define SQLITE_OPEN_NOFOLLOW 0x01000000 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_EXRESCODE 0x02000000 /* Extended result codes */ + +/* Reserved: 0x00F00000 */ +/* Legacy compatibility: */ +#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */ + + +/* +** CAPI3REF: Device Characteristics +** +** The xDeviceCharacteristics method of the [sqlite3_io_methods] +** object returns an integer which is a vector of these +** bit values expressing I/O characteristics of the mass storage +** device that holds the file that the [sqlite3_io_methods] +** refers to. +** +** The SQLITE_IOCAP_ATOMIC property means that all writes of +** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values +** mean that writes of blocks that are nnn bytes in size and +** are aligned to an address which is an integer multiple of +** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means +** that when data is appended to a file, the data is appended +** first then the size of the file is extended, never the other +** way around. The SQLITE_IOCAP_SEQUENTIAL property means that +** information is written to disk in the same order as calls +** to xWrite(). The SQLITE_IOCAP_POWERSAFE_OVERWRITE property means that +** after reboot following a crash or power loss, the only bytes in a +** file that were written at the application level might have changed +** and that adjacent bytes, even bytes within the same sector are +** guaranteed to be unchanged. The SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN +** flag indicates that a file cannot be deleted when open. The +** SQLITE_IOCAP_IMMUTABLE flag indicates that the file is on +** read-only media and cannot be changed even by processes with +** elevated privileges. +** +** The SQLITE_IOCAP_BATCH_ATOMIC property means that the underlying +** filesystem supports doing multiple write operations atomically when those +** write operations are bracketed by [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE] and +** [SQLITE_FCNTL_COMMIT_ATOMIC_WRITE]. +*/ +#define SQLITE_IOCAP_ATOMIC 0x00000001 +#define SQLITE_IOCAP_ATOMIC512 0x00000002 +#define SQLITE_IOCAP_ATOMIC1K 0x00000004 +#define SQLITE_IOCAP_ATOMIC2K 0x00000008 +#define SQLITE_IOCAP_ATOMIC4K 0x00000010 +#define SQLITE_IOCAP_ATOMIC8K 0x00000020 +#define SQLITE_IOCAP_ATOMIC16K 0x00000040 +#define SQLITE_IOCAP_ATOMIC32K 0x00000080 +#define SQLITE_IOCAP_ATOMIC64K 0x00000100 +#define SQLITE_IOCAP_SAFE_APPEND 0x00000200 +#define SQLITE_IOCAP_SEQUENTIAL 0x00000400 +#define SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN 0x00000800 +#define SQLITE_IOCAP_POWERSAFE_OVERWRITE 0x00001000 +#define SQLITE_IOCAP_IMMUTABLE 0x00002000 +#define SQLITE_IOCAP_BATCH_ATOMIC 0x00004000 + +/* +** CAPI3REF: File Locking Levels +** +** SQLite uses one of these integer values as the second +** argument to calls it makes to the xLock() and xUnlock() methods +** of an [sqlite3_io_methods] object. These values are ordered from +** lest restrictive to most restrictive. +** +** The argument to xLock() is always SHARED or higher. The argument to +** xUnlock is either SHARED or NONE. +*/ +#define SQLITE_LOCK_NONE 0 /* xUnlock() only */ +#define SQLITE_LOCK_SHARED 1 /* xLock() or xUnlock() */ +#define SQLITE_LOCK_RESERVED 2 /* xLock() only */ +#define SQLITE_LOCK_PENDING 3 /* xLock() only */ +#define SQLITE_LOCK_EXCLUSIVE 4 /* xLock() only */ + +/* +** CAPI3REF: Synchronization Type Flags +** +** When SQLite invokes the xSync() method of an +** [sqlite3_io_methods] object it uses a combination of +** these integer values as the second argument. +** +** When the SQLITE_SYNC_DATAONLY flag is used, it means that the +** sync operation only needs to flush data to mass storage. Inode +** information need not be flushed. If the lower four bits of the flag +** equal SQLITE_SYNC_NORMAL, that means to use normal fsync() semantics. +** If the lower four bits equal SQLITE_SYNC_FULL, that means +** to use Mac OS X style fullsync instead of fsync(). +** +** Do not confuse the SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags +** with the [PRAGMA synchronous]=NORMAL and [PRAGMA synchronous]=FULL +** settings. The [synchronous pragma] determines when calls to the +** xSync VFS method occur and applies uniformly across all platforms. +** The SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags determine how +** energetic or rigorous or forceful the sync operations are and +** only make a difference on Mac OSX for the default SQLite code. +** (Third-party VFS implementations might also make the distinction +** between SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL, but among the +** operating systems natively supported by SQLite, only Mac OSX +** cares about the difference.) +*/ +#define SQLITE_SYNC_NORMAL 0x00002 +#define SQLITE_SYNC_FULL 0x00003 +#define SQLITE_SYNC_DATAONLY 0x00010 + +/* +** CAPI3REF: OS Interface Open File Handle +** +** An [sqlite3_file] object represents an open file in the +** [sqlite3_vfs | OS interface layer]. Individual OS interface +** implementations will +** want to subclass this object by appending additional fields +** for their own use. The pMethods entry is a pointer to an +** [sqlite3_io_methods] object that defines methods for performing +** I/O operations on the open file. +*/ +typedef struct sqlite3_file sqlite3_file; +struct sqlite3_file { + const struct sqlite3_io_methods *pMethods; /* Methods for an open file */ +}; + +/* +** CAPI3REF: OS Interface File Virtual Methods Object +** +** Every file opened by the [sqlite3_vfs.xOpen] method populates an +** [sqlite3_file] object (or, more commonly, a subclass of the +** [sqlite3_file] object) with a pointer to an instance of this object. +** This object defines the methods used to perform various operations +** against the open file represented by the [sqlite3_file] object. +** +** If the [sqlite3_vfs.xOpen] method sets the sqlite3_file.pMethods element +** to a non-NULL pointer, then the sqlite3_io_methods.xClose method +** may be invoked even if the [sqlite3_vfs.xOpen] reported that it failed. The +** only way to prevent a call to xClose following a failed [sqlite3_vfs.xOpen] +** is for the [sqlite3_vfs.xOpen] to set the sqlite3_file.pMethods element +** to NULL. +** +** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or +** [SQLITE_SYNC_FULL]. The first choice is the normal fsync(). +** The second choice is a Mac OS X style fullsync. The [SQLITE_SYNC_DATAONLY] +** flag may be ORed in to indicate that only the data of the file +** and not its inode needs to be synced. +** +** The integer values to xLock() and xUnlock() are one of +**
      +**
    • [SQLITE_LOCK_NONE], +**
    • [SQLITE_LOCK_SHARED], +**
    • [SQLITE_LOCK_RESERVED], +**
    • [SQLITE_LOCK_PENDING], or +**
    • [SQLITE_LOCK_EXCLUSIVE]. +**
    +** xLock() upgrades the database file lock. In other words, xLock() moves the +** database file lock in the direction NONE toward EXCLUSIVE. The argument to +** xLock() is always on of SHARED, RESERVED, PENDING, or EXCLUSIVE, never +** SQLITE_LOCK_NONE. If the database file lock is already at or above the +** requested lock, then the call to xLock() is a no-op. +** xUnlock() downgrades the database file lock to either SHARED or NONE. +* If the lock is already at or below the requested lock state, then the call +** to xUnlock() is a no-op. +** The xCheckReservedLock() method checks whether any database connection, +** either in this process or in some other process, is holding a RESERVED, +** PENDING, or EXCLUSIVE lock on the file. It returns true +** if such a lock exists and false otherwise. +** +** The xFileControl() method is a generic interface that allows custom +** VFS implementations to directly control an open file using the +** [sqlite3_file_control()] interface. The second "op" argument is an +** integer opcode. The third argument is a generic pointer intended to +** point to a structure that may contain arguments or space in which to +** write return values. Potential uses for xFileControl() might be +** functions to enable blocking locks with timeouts, to change the +** locking strategy (for example to use dot-file locks), to inquire +** about the status of a lock, or to break stale locks. The SQLite +** core reserves all opcodes less than 100 for its own use. +** A [file control opcodes | list of opcodes] less than 100 is available. +** Applications that define a custom xFileControl method should use opcodes +** greater than 100 to avoid conflicts. VFS implementations should +** return [SQLITE_NOTFOUND] for file control opcodes that they do not +** recognize. +** +** The xSectorSize() method returns the sector size of the +** device that underlies the file. The sector size is the +** minimum write that can be performed without disturbing +** other bytes in the file. The xDeviceCharacteristics() +** method returns a bit vector describing behaviors of the +** underlying device: +** +**
      +**
    • [SQLITE_IOCAP_ATOMIC] +**
    • [SQLITE_IOCAP_ATOMIC512] +**
    • [SQLITE_IOCAP_ATOMIC1K] +**
    • [SQLITE_IOCAP_ATOMIC2K] +**
    • [SQLITE_IOCAP_ATOMIC4K] +**
    • [SQLITE_IOCAP_ATOMIC8K] +**
    • [SQLITE_IOCAP_ATOMIC16K] +**
    • [SQLITE_IOCAP_ATOMIC32K] +**
    • [SQLITE_IOCAP_ATOMIC64K] +**
    • [SQLITE_IOCAP_SAFE_APPEND] +**
    • [SQLITE_IOCAP_SEQUENTIAL] +**
    • [SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN] +**
    • [SQLITE_IOCAP_POWERSAFE_OVERWRITE] +**
    • [SQLITE_IOCAP_IMMUTABLE] +**
    • [SQLITE_IOCAP_BATCH_ATOMIC] +**
    +** +** The SQLITE_IOCAP_ATOMIC property means that all writes of +** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values +** mean that writes of blocks that are nnn bytes in size and +** are aligned to an address which is an integer multiple of +** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means +** that when data is appended to a file, the data is appended +** first then the size of the file is extended, never the other +** way around. The SQLITE_IOCAP_SEQUENTIAL property means that +** information is written to disk in the same order as calls +** to xWrite(). +** +** If xRead() returns SQLITE_IOERR_SHORT_READ it must also fill +** in the unread portions of the buffer with zeros. A VFS that +** fails to zero-fill short reads might seem to work. However, +** failure to zero-fill short reads will eventually lead to +** database corruption. +*/ +typedef struct sqlite3_io_methods sqlite3_io_methods; +struct sqlite3_io_methods { + int iVersion; + int (*xClose)(sqlite3_file*); + int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); + int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst); + int (*xTruncate)(sqlite3_file*, sqlite3_int64 size); + int (*xSync)(sqlite3_file*, int flags); + int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize); + int (*xLock)(sqlite3_file*, int); + int (*xUnlock)(sqlite3_file*, int); + int (*xCheckReservedLock)(sqlite3_file*, int *pResOut); + int (*xFileControl)(sqlite3_file*, int op, void *pArg); + int (*xSectorSize)(sqlite3_file*); + int (*xDeviceCharacteristics)(sqlite3_file*); + /* Methods above are valid for version 1 */ + int (*xShmMap)(sqlite3_file*, int iPg, int pgsz, int, void volatile**); + int (*xShmLock)(sqlite3_file*, int offset, int n, int flags); + void (*xShmBarrier)(sqlite3_file*); + int (*xShmUnmap)(sqlite3_file*, int deleteFlag); + /* Methods above are valid for version 2 */ + int (*xFetch)(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp); + int (*xUnfetch)(sqlite3_file*, sqlite3_int64 iOfst, void *p); + /* Methods above are valid for version 3 */ + /* Additional methods may be added in future releases */ +}; + +/* +** CAPI3REF: Standard File Control Opcodes +** KEYWORDS: {file control opcodes} {file control opcode} +** +** These integer constants are opcodes for the xFileControl method +** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()] +** interface. +** +**
      +**
    • [[SQLITE_FCNTL_LOCKSTATE]] +** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging. This +** opcode causes the xFileControl method to write the current state of +** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED], +** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE]) +** into an integer that the pArg argument points to. +** This capability is only available if SQLite is compiled with [SQLITE_DEBUG]. +** +**
    • [[SQLITE_FCNTL_SIZE_HINT]] +** The [SQLITE_FCNTL_SIZE_HINT] opcode is used by SQLite to give the VFS +** layer a hint of how large the database file will grow to be during the +** current transaction. This hint is not guaranteed to be accurate but it +** is often close. The underlying VFS might choose to preallocate database +** file space based on this hint in order to help writes to the database +** file run faster. +** +**
    • [[SQLITE_FCNTL_SIZE_LIMIT]] +** The [SQLITE_FCNTL_SIZE_LIMIT] opcode is used by in-memory VFS that +** implements [sqlite3_deserialize()] to set an upper bound on the size +** of the in-memory database. The argument is a pointer to a [sqlite3_int64]. +** If the integer pointed to is negative, then it is filled in with the +** current limit. Otherwise the limit is set to the larger of the value +** of the integer pointed to and the current database size. The integer +** pointed to is set to the new limit. +** +**
    • [[SQLITE_FCNTL_CHUNK_SIZE]] +** The [SQLITE_FCNTL_CHUNK_SIZE] opcode is used to request that the VFS +** extends and truncates the database file in chunks of a size specified +** by the user. The fourth argument to [sqlite3_file_control()] should +** point to an integer (type int) containing the new chunk-size to use +** for the nominated database. Allocating database file space in large +** chunks (say 1MB at a time), may reduce file-system fragmentation and +** improve performance on some systems. +** +**
    • [[SQLITE_FCNTL_FILE_POINTER]] +** The [SQLITE_FCNTL_FILE_POINTER] opcode is used to obtain a pointer +** to the [sqlite3_file] object associated with a particular database +** connection. See also [SQLITE_FCNTL_JOURNAL_POINTER]. +** +**
    • [[SQLITE_FCNTL_JOURNAL_POINTER]] +** The [SQLITE_FCNTL_JOURNAL_POINTER] opcode is used to obtain a pointer +** to the [sqlite3_file] object associated with the journal file (either +** the [rollback journal] or the [write-ahead log]) for a particular database +** connection. See also [SQLITE_FCNTL_FILE_POINTER]. +** +**
    • [[SQLITE_FCNTL_SYNC_OMITTED]] +** No longer in use. +** +**
    • [[SQLITE_FCNTL_SYNC]] +** The [SQLITE_FCNTL_SYNC] opcode is generated internally by SQLite and +** sent to the VFS immediately before the xSync method is invoked on a +** database file descriptor. Or, if the xSync method is not invoked +** because the user has configured SQLite with +** [PRAGMA synchronous | PRAGMA synchronous=OFF] it is invoked in place +** of the xSync method. In most cases, the pointer argument passed with +** this file-control is NULL. However, if the database file is being synced +** as part of a multi-database commit, the argument points to a nul-terminated +** string containing the transactions super-journal file name. VFSes that +** do not need this signal should silently ignore this opcode. Applications +** should not call [sqlite3_file_control()] with this opcode as doing so may +** disrupt the operation of the specialized VFSes that do require it. +** +**
    • [[SQLITE_FCNTL_COMMIT_PHASETWO]] +** The [SQLITE_FCNTL_COMMIT_PHASETWO] opcode is generated internally by SQLite +** and sent to the VFS after a transaction has been committed immediately +** but before the database is unlocked. VFSes that do not need this signal +** should silently ignore this opcode. Applications should not call +** [sqlite3_file_control()] with this opcode as doing so may disrupt the +** operation of the specialized VFSes that do require it. +** +**
    • [[SQLITE_FCNTL_WIN32_AV_RETRY]] +** ^The [SQLITE_FCNTL_WIN32_AV_RETRY] opcode is used to configure automatic +** retry counts and intervals for certain disk I/O operations for the +** windows [VFS] in order to provide robustness in the presence of +** anti-virus programs. By default, the windows VFS will retry file read, +** file write, and file delete operations up to 10 times, with a delay +** of 25 milliseconds before the first retry and with the delay increasing +** by an additional 25 milliseconds with each subsequent retry. This +** opcode allows these two values (10 retries and 25 milliseconds of delay) +** to be adjusted. The values are changed for all database connections +** within the same process. The argument is a pointer to an array of two +** integers where the first integer is the new retry count and the second +** integer is the delay. If either integer is negative, then the setting +** is not changed but instead the prior value of that setting is written +** into the array entry, allowing the current retry settings to be +** interrogated. The zDbName parameter is ignored. +** +**
    • [[SQLITE_FCNTL_PERSIST_WAL]] +** ^The [SQLITE_FCNTL_PERSIST_WAL] opcode is used to set or query the +** persistent [WAL | Write Ahead Log] setting. By default, the auxiliary +** write ahead log ([WAL file]) and shared memory +** files used for transaction control +** are automatically deleted when the latest connection to the database +** closes. Setting persistent WAL mode causes those files to persist after +** close. Persisting the files is useful when other processes that do not +** have write permission on the directory containing the database file want +** to read the database file, as the WAL and shared memory files must exist +** in order for the database to be readable. The fourth parameter to +** [sqlite3_file_control()] for this opcode should be a pointer to an integer. +** That integer is 0 to disable persistent WAL mode or 1 to enable persistent +** WAL mode. If the integer is -1, then it is overwritten with the current +** WAL persistence setting. +** +**
    • [[SQLITE_FCNTL_POWERSAFE_OVERWRITE]] +** ^The [SQLITE_FCNTL_POWERSAFE_OVERWRITE] opcode is used to set or query the +** persistent "powersafe-overwrite" or "PSOW" setting. The PSOW setting +** determines the [SQLITE_IOCAP_POWERSAFE_OVERWRITE] bit of the +** xDeviceCharacteristics methods. The fourth parameter to +** [sqlite3_file_control()] for this opcode should be a pointer to an integer. +** That integer is 0 to disable zero-damage mode or 1 to enable zero-damage +** mode. If the integer is -1, then it is overwritten with the current +** zero-damage mode setting. +** +**
    • [[SQLITE_FCNTL_OVERWRITE]] +** ^The [SQLITE_FCNTL_OVERWRITE] opcode is invoked by SQLite after opening +** a write transaction to indicate that, unless it is rolled back for some +** reason, the entire database file will be overwritten by the current +** transaction. This is used by VACUUM operations. +** +**
    • [[SQLITE_FCNTL_VFSNAME]] +** ^The [SQLITE_FCNTL_VFSNAME] opcode can be used to obtain the names of +** all [VFSes] in the VFS stack. The names are of all VFS shims and the +** final bottom-level VFS are written into memory obtained from +** [sqlite3_malloc()] and the result is stored in the char* variable +** that the fourth parameter of [sqlite3_file_control()] points to. +** The caller is responsible for freeing the memory when done. As with +** all file-control actions, there is no guarantee that this will actually +** do anything. Callers should initialize the char* variable to a NULL +** pointer in case this file-control is not implemented. This file-control +** is intended for diagnostic use only. +** +**
    • [[SQLITE_FCNTL_VFS_POINTER]] +** ^The [SQLITE_FCNTL_VFS_POINTER] opcode finds a pointer to the top-level +** [VFSes] currently in use. ^(The argument X in +** sqlite3_file_control(db,SQLITE_FCNTL_VFS_POINTER,X) must be +** of type "[sqlite3_vfs] **". This opcodes will set *X +** to a pointer to the top-level VFS.)^ +** ^When there are multiple VFS shims in the stack, this opcode finds the +** upper-most shim only. +** +**
    • [[SQLITE_FCNTL_PRAGMA]] +** ^Whenever a [PRAGMA] statement is parsed, an [SQLITE_FCNTL_PRAGMA] +** file control is sent to the open [sqlite3_file] object corresponding +** to the database file to which the pragma statement refers. ^The argument +** to the [SQLITE_FCNTL_PRAGMA] file control is an array of +** pointers to strings (char**) in which the second element of the array +** is the name of the pragma and the third element is the argument to the +** pragma or NULL if the pragma has no argument. ^The handler for an +** [SQLITE_FCNTL_PRAGMA] file control can optionally make the first element +** of the char** argument point to a string obtained from [sqlite3_mprintf()] +** or the equivalent and that string will become the result of the pragma or +** the error message if the pragma fails. ^If the +** [SQLITE_FCNTL_PRAGMA] file control returns [SQLITE_NOTFOUND], then normal +** [PRAGMA] processing continues. ^If the [SQLITE_FCNTL_PRAGMA] +** file control returns [SQLITE_OK], then the parser assumes that the +** VFS has handled the PRAGMA itself and the parser generates a no-op +** prepared statement if result string is NULL, or that returns a copy +** of the result string if the string is non-NULL. +** ^If the [SQLITE_FCNTL_PRAGMA] file control returns +** any result code other than [SQLITE_OK] or [SQLITE_NOTFOUND], that means +** that the VFS encountered an error while handling the [PRAGMA] and the +** compilation of the PRAGMA fails with an error. ^The [SQLITE_FCNTL_PRAGMA] +** file control occurs at the beginning of pragma statement analysis and so +** it is able to override built-in [PRAGMA] statements. +** +**
    • [[SQLITE_FCNTL_BUSYHANDLER]] +** ^The [SQLITE_FCNTL_BUSYHANDLER] +** file-control may be invoked by SQLite on the database file handle +** shortly after it is opened in order to provide a custom VFS with access +** to the connection's busy-handler callback. The argument is of type (void**) +** - an array of two (void *) values. The first (void *) actually points +** to a function of type (int (*)(void *)). In order to invoke the connection's +** busy-handler, this function should be invoked with the second (void *) in +** the array as the only argument. If it returns non-zero, then the operation +** should be retried. If it returns zero, the custom VFS should abandon the +** current operation. +** +**
    • [[SQLITE_FCNTL_TEMPFILENAME]] +** ^Applications can invoke the [SQLITE_FCNTL_TEMPFILENAME] file-control +** to have SQLite generate a +** temporary filename using the same algorithm that is followed to generate +** temporary filenames for TEMP tables and other internal uses. The +** argument should be a char** which will be filled with the filename +** written into memory obtained from [sqlite3_malloc()]. The caller should +** invoke [sqlite3_free()] on the result to avoid a memory leak. +** +**
    • [[SQLITE_FCNTL_MMAP_SIZE]] +** The [SQLITE_FCNTL_MMAP_SIZE] file control is used to query or set the +** maximum number of bytes that will be used for memory-mapped I/O. +** The argument is a pointer to a value of type sqlite3_int64 that +** is an advisory maximum number of bytes in the file to memory map. The +** pointer is overwritten with the old value. The limit is not changed if +** the value originally pointed to is negative, and so the current limit +** can be queried by passing in a pointer to a negative number. This +** file-control is used internally to implement [PRAGMA mmap_size]. +** +**
    • [[SQLITE_FCNTL_TRACE]] +** The [SQLITE_FCNTL_TRACE] file control provides advisory information +** to the VFS about what the higher layers of the SQLite stack are doing. +** This file control is used by some VFS activity tracing [shims]. +** The argument is a zero-terminated string. Higher layers in the +** SQLite stack may generate instances of this file control if +** the [SQLITE_USE_FCNTL_TRACE] compile-time option is enabled. +** +**
    • [[SQLITE_FCNTL_HAS_MOVED]] +** The [SQLITE_FCNTL_HAS_MOVED] file control interprets its argument as a +** pointer to an integer and it writes a boolean into that integer depending +** on whether or not the file has been renamed, moved, or deleted since it +** was first opened. +** +**
    • [[SQLITE_FCNTL_WIN32_GET_HANDLE]] +** The [SQLITE_FCNTL_WIN32_GET_HANDLE] opcode can be used to obtain the +** underlying native file handle associated with a file handle. This file +** control interprets its argument as a pointer to a native file handle and +** writes the resulting value there. +** +**
    • [[SQLITE_FCNTL_WIN32_SET_HANDLE]] +** The [SQLITE_FCNTL_WIN32_SET_HANDLE] opcode is used for debugging. This +** opcode causes the xFileControl method to swap the file handle with the one +** pointed to by the pArg argument. This capability is used during testing +** and only needs to be supported when SQLITE_TEST is defined. +** +**
    • [[SQLITE_FCNTL_WAL_BLOCK]] +** The [SQLITE_FCNTL_WAL_BLOCK] is a signal to the VFS layer that it might +** be advantageous to block on the next WAL lock if the lock is not immediately +** available. The WAL subsystem issues this signal during rare +** circumstances in order to fix a problem with priority inversion. +** Applications should not use this file-control. +** +**
    • [[SQLITE_FCNTL_ZIPVFS]] +** The [SQLITE_FCNTL_ZIPVFS] opcode is implemented by zipvfs only. All other +** VFS should return SQLITE_NOTFOUND for this opcode. +** +**
    • [[SQLITE_FCNTL_RBU]] +** The [SQLITE_FCNTL_RBU] opcode is implemented by the special VFS used by +** the RBU extension only. All other VFS should return SQLITE_NOTFOUND for +** this opcode. +** +**
    • [[SQLITE_FCNTL_BEGIN_ATOMIC_WRITE]] +** If the [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE] opcode returns SQLITE_OK, then +** the file descriptor is placed in "batch write mode", which +** means all subsequent write operations will be deferred and done +** atomically at the next [SQLITE_FCNTL_COMMIT_ATOMIC_WRITE]. Systems +** that do not support batch atomic writes will return SQLITE_NOTFOUND. +** ^Following a successful SQLITE_FCNTL_BEGIN_ATOMIC_WRITE and prior to +** the closing [SQLITE_FCNTL_COMMIT_ATOMIC_WRITE] or +** [SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE], SQLite will make +** no VFS interface calls on the same [sqlite3_file] file descriptor +** except for calls to the xWrite method and the xFileControl method +** with [SQLITE_FCNTL_SIZE_HINT]. +** +**
    • [[SQLITE_FCNTL_COMMIT_ATOMIC_WRITE]] +** The [SQLITE_FCNTL_COMMIT_ATOMIC_WRITE] opcode causes all write +** operations since the previous successful call to +** [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE] to be performed atomically. +** This file control returns [SQLITE_OK] if and only if the writes were +** all performed successfully and have been committed to persistent storage. +** ^Regardless of whether or not it is successful, this file control takes +** the file descriptor out of batch write mode so that all subsequent +** write operations are independent. +** ^SQLite will never invoke SQLITE_FCNTL_COMMIT_ATOMIC_WRITE without +** a prior successful call to [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE]. +** +**
    • [[SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE]] +** The [SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE] opcode causes all write +** operations since the previous successful call to +** [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE] to be rolled back. +** ^This file control takes the file descriptor out of batch write mode +** so that all subsequent write operations are independent. +** ^SQLite will never invoke SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE without +** a prior successful call to [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE]. +** +**
    • [[SQLITE_FCNTL_LOCK_TIMEOUT]] +** The [SQLITE_FCNTL_LOCK_TIMEOUT] opcode is used to configure a VFS +** to block for up to M milliseconds before failing when attempting to +** obtain a file lock using the xLock or xShmLock methods of the VFS. +** The parameter is a pointer to a 32-bit signed integer that contains +** the value that M is to be set to. Before returning, the 32-bit signed +** integer is overwritten with the previous value of M. +** +**
    • [[SQLITE_FCNTL_DATA_VERSION]] +** The [SQLITE_FCNTL_DATA_VERSION] opcode is used to detect changes to +** a database file. The argument is a pointer to a 32-bit unsigned integer. +** The "data version" for the pager is written into the pointer. The +** "data version" changes whenever any change occurs to the corresponding +** database file, either through SQL statements on the same database +** connection or through transactions committed by separate database +** connections possibly in other processes. The [sqlite3_total_changes()] +** interface can be used to find if any database on the connection has changed, +** but that interface responds to changes on TEMP as well as MAIN and does +** not provide a mechanism to detect changes to MAIN only. Also, the +** [sqlite3_total_changes()] interface responds to internal changes only and +** omits changes made by other database connections. The +** [PRAGMA data_version] command provides a mechanism to detect changes to +** a single attached database that occur due to other database connections, +** but omits changes implemented by the database connection on which it is +** called. This file control is the only mechanism to detect changes that +** happen either internally or externally and that are associated with +** a particular attached database. +** +**
    • [[SQLITE_FCNTL_CKPT_START]] +** The [SQLITE_FCNTL_CKPT_START] opcode is invoked from within a checkpoint +** in wal mode before the client starts to copy pages from the wal +** file to the database file. +** +**
    • [[SQLITE_FCNTL_CKPT_DONE]] +** The [SQLITE_FCNTL_CKPT_DONE] opcode is invoked from within a checkpoint +** in wal mode after the client has finished copying pages from the wal +** file to the database file, but before the *-shm file is updated to +** record the fact that the pages have been checkpointed. +** +**
    • [[SQLITE_FCNTL_EXTERNAL_READER]] +** The EXPERIMENTAL [SQLITE_FCNTL_EXTERNAL_READER] opcode is used to detect +** whether or not there is a database client in another process with a wal-mode +** transaction open on the database or not. It is only available on unix.The +** (void*) argument passed with this file-control should be a pointer to a +** value of type (int). The integer value is set to 1 if the database is a wal +** mode database and there exists at least one client in another process that +** currently has an SQL transaction open on the database. It is set to 0 if +** the database is not a wal-mode db, or if there is no such connection in any +** other process. This opcode cannot be used to detect transactions opened +** by clients within the current process, only within other processes. +** +**
    • [[SQLITE_FCNTL_CKSM_FILE]] +** The [SQLITE_FCNTL_CKSM_FILE] opcode is for use interally by the +** [checksum VFS shim] only. +** +**
    • [[SQLITE_FCNTL_RESET_CACHE]] +** If there is currently no transaction open on the database, and the +** database is not a temp db, then the [SQLITE_FCNTL_RESET_CACHE] file-control +** purges the contents of the in-memory page cache. If there is an open +** transaction, or if the db is a temp-db, this opcode is a no-op, not an error. +**
    +*/ +#define SQLITE_FCNTL_LOCKSTATE 1 +#define SQLITE_FCNTL_GET_LOCKPROXYFILE 2 +#define SQLITE_FCNTL_SET_LOCKPROXYFILE 3 +#define SQLITE_FCNTL_LAST_ERRNO 4 +#define SQLITE_FCNTL_SIZE_HINT 5 +#define SQLITE_FCNTL_CHUNK_SIZE 6 +#define SQLITE_FCNTL_FILE_POINTER 7 +#define SQLITE_FCNTL_SYNC_OMITTED 8 +#define SQLITE_FCNTL_WIN32_AV_RETRY 9 +#define SQLITE_FCNTL_PERSIST_WAL 10 +#define SQLITE_FCNTL_OVERWRITE 11 +#define SQLITE_FCNTL_VFSNAME 12 +#define SQLITE_FCNTL_POWERSAFE_OVERWRITE 13 +#define SQLITE_FCNTL_PRAGMA 14 +#define SQLITE_FCNTL_BUSYHANDLER 15 +#define SQLITE_FCNTL_TEMPFILENAME 16 +#define SQLITE_FCNTL_MMAP_SIZE 18 +#define SQLITE_FCNTL_TRACE 19 +#define SQLITE_FCNTL_HAS_MOVED 20 +#define SQLITE_FCNTL_SYNC 21 +#define SQLITE_FCNTL_COMMIT_PHASETWO 22 +#define SQLITE_FCNTL_WIN32_SET_HANDLE 23 +#define SQLITE_FCNTL_WAL_BLOCK 24 +#define SQLITE_FCNTL_ZIPVFS 25 +#define SQLITE_FCNTL_RBU 26 +#define SQLITE_FCNTL_VFS_POINTER 27 +#define SQLITE_FCNTL_JOURNAL_POINTER 28 +#define SQLITE_FCNTL_WIN32_GET_HANDLE 29 +#define SQLITE_FCNTL_PDB 30 +#define SQLITE_FCNTL_BEGIN_ATOMIC_WRITE 31 +#define SQLITE_FCNTL_COMMIT_ATOMIC_WRITE 32 +#define SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE 33 +#define SQLITE_FCNTL_LOCK_TIMEOUT 34 +#define SQLITE_FCNTL_DATA_VERSION 35 +#define SQLITE_FCNTL_SIZE_LIMIT 36 +#define SQLITE_FCNTL_CKPT_DONE 37 +#define SQLITE_FCNTL_RESERVE_BYTES 38 +#define SQLITE_FCNTL_CKPT_START 39 +#define SQLITE_FCNTL_EXTERNAL_READER 40 +#define SQLITE_FCNTL_CKSM_FILE 41 +#define SQLITE_FCNTL_RESET_CACHE 42 + +/* deprecated names */ +#define SQLITE_GET_LOCKPROXYFILE SQLITE_FCNTL_GET_LOCKPROXYFILE +#define SQLITE_SET_LOCKPROXYFILE SQLITE_FCNTL_SET_LOCKPROXYFILE +#define SQLITE_LAST_ERRNO SQLITE_FCNTL_LAST_ERRNO + + +/* +** CAPI3REF: Mutex Handle +** +** The mutex module within SQLite defines [sqlite3_mutex] to be an +** abstract type for a mutex object. The SQLite core never looks +** at the internal representation of an [sqlite3_mutex]. It only +** deals with pointers to the [sqlite3_mutex] object. +** +** Mutexes are created using [sqlite3_mutex_alloc()]. +*/ +typedef struct sqlite3_mutex sqlite3_mutex; + +/* +** CAPI3REF: Loadable Extension Thunk +** +** A pointer to the opaque sqlite3_api_routines structure is passed as +** the third parameter to entry points of [loadable extensions]. This +** structure must be typedefed in order to work around compiler warnings +** on some platforms. +*/ +typedef struct sqlite3_api_routines sqlite3_api_routines; + +/* +** CAPI3REF: File Name +** +** Type [sqlite3_filename] is used by SQLite to pass filenames to the +** xOpen method of a [VFS]. It may be cast to (const char*) and treated +** as a normal, nul-terminated, UTF-8 buffer containing the filename, but +** may also be passed to special APIs such as: +** +**
      +**
    • sqlite3_filename_database() +**
    • sqlite3_filename_journal() +**
    • sqlite3_filename_wal() +**
    • sqlite3_uri_parameter() +**
    • sqlite3_uri_boolean() +**
    • sqlite3_uri_int64() +**
    • sqlite3_uri_key() +**
    +*/ +typedef const char *sqlite3_filename; + +/* +** CAPI3REF: OS Interface Object +** +** An instance of the sqlite3_vfs object defines the interface between +** the SQLite core and the underlying operating system. The "vfs" +** in the name of the object stands for "virtual file system". See +** the [VFS | VFS documentation] for further information. +** +** The VFS interface is sometimes extended by adding new methods onto +** the end. Each time such an extension occurs, the iVersion field +** is incremented. The iVersion value started out as 1 in +** SQLite [version 3.5.0] on [dateof:3.5.0], then increased to 2 +** with SQLite [version 3.7.0] on [dateof:3.7.0], and then increased +** to 3 with SQLite [version 3.7.6] on [dateof:3.7.6]. Additional fields +** may be appended to the sqlite3_vfs object and the iVersion value +** may increase again in future versions of SQLite. +** Note that due to an oversight, the structure +** of the sqlite3_vfs object changed in the transition from +** SQLite [version 3.5.9] to [version 3.6.0] on [dateof:3.6.0] +** and yet the iVersion field was not increased. +** +** The szOsFile field is the size of the subclassed [sqlite3_file] +** structure used by this VFS. mxPathname is the maximum length of +** a pathname in this VFS. +** +** Registered sqlite3_vfs objects are kept on a linked list formed by +** the pNext pointer. The [sqlite3_vfs_register()] +** and [sqlite3_vfs_unregister()] interfaces manage this list +** in a thread-safe way. The [sqlite3_vfs_find()] interface +** searches the list. Neither the application code nor the VFS +** implementation should use the pNext pointer. +** +** The pNext field is the only field in the sqlite3_vfs +** structure that SQLite will ever modify. SQLite will only access +** or modify this field while holding a particular static mutex. +** The application should never modify anything within the sqlite3_vfs +** object once the object has been registered. +** +** The zName field holds the name of the VFS module. The name must +** be unique across all VFS modules. +** +** [[sqlite3_vfs.xOpen]] +** ^SQLite guarantees that the zFilename parameter to xOpen +** is either a NULL pointer or string obtained +** from xFullPathname() with an optional suffix added. +** ^If a suffix is added to the zFilename parameter, it will +** consist of a single "-" character followed by no more than +** 11 alphanumeric and/or "-" characters. +** ^SQLite further guarantees that +** the string will be valid and unchanged until xClose() is +** called. Because of the previous sentence, +** the [sqlite3_file] can safely store a pointer to the +** filename if it needs to remember the filename for some reason. +** If the zFilename parameter to xOpen is a NULL pointer then xOpen +** must invent its own temporary name for the file. ^Whenever the +** xFilename parameter is NULL it will also be the case that the +** flags parameter will include [SQLITE_OPEN_DELETEONCLOSE]. +** +** The flags argument to xOpen() includes all bits set in +** the flags argument to [sqlite3_open_v2()]. Or if [sqlite3_open()] +** or [sqlite3_open16()] is used, then flags includes at least +** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]. +** If xOpen() opens a file read-only then it sets *pOutFlags to +** include [SQLITE_OPEN_READONLY]. Other bits in *pOutFlags may be set. +** +** ^(SQLite will also add one of the following flags to the xOpen() +** call, depending on the object being opened: +** +**
      +**
    • [SQLITE_OPEN_MAIN_DB] +**
    • [SQLITE_OPEN_MAIN_JOURNAL] +**
    • [SQLITE_OPEN_TEMP_DB] +**
    • [SQLITE_OPEN_TEMP_JOURNAL] +**
    • [SQLITE_OPEN_TRANSIENT_DB] +**
    • [SQLITE_OPEN_SUBJOURNAL] +**
    • [SQLITE_OPEN_SUPER_JOURNAL] +**
    • [SQLITE_OPEN_WAL] +**
    )^ +** +** The file I/O implementation can use the object type flags to +** change the way it deals with files. For example, an application +** that does not care about crash recovery or rollback might make +** the open of a journal file a no-op. Writes to this journal would +** also be no-ops, and any attempt to read the journal would return +** SQLITE_IOERR. Or the implementation might recognize that a database +** file will be doing page-aligned sector reads and writes in a random +** order and set up its I/O subsystem accordingly. +** +** SQLite might also add one of the following flags to the xOpen method: +** +**
      +**
    • [SQLITE_OPEN_DELETEONCLOSE] +**
    • [SQLITE_OPEN_EXCLUSIVE] +**
    +** +** The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be +** deleted when it is closed. ^The [SQLITE_OPEN_DELETEONCLOSE] +** will be set for TEMP databases and their journals, transient +** databases, and subjournals. +** +** ^The [SQLITE_OPEN_EXCLUSIVE] flag is always used in conjunction +** with the [SQLITE_OPEN_CREATE] flag, which are both directly +** analogous to the O_EXCL and O_CREAT flags of the POSIX open() +** API. The SQLITE_OPEN_EXCLUSIVE flag, when paired with the +** SQLITE_OPEN_CREATE, is used to indicate that file should always +** be created, and that it is an error if it already exists. +** It is not used to indicate the file should be opened +** for exclusive access. +** +** ^At least szOsFile bytes of memory are allocated by SQLite +** to hold the [sqlite3_file] structure passed as the third +** argument to xOpen. The xOpen method does not have to +** allocate the structure; it should just fill it in. Note that +** the xOpen method must set the sqlite3_file.pMethods to either +** a valid [sqlite3_io_methods] object or to NULL. xOpen must do +** this even if the open fails. SQLite expects that the sqlite3_file.pMethods +** element will be valid after xOpen returns regardless of the success +** or failure of the xOpen call. +** +** [[sqlite3_vfs.xAccess]] +** ^The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS] +** to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to +** test whether a file is readable and writable, or [SQLITE_ACCESS_READ] +** to test whether a file is at least readable. The SQLITE_ACCESS_READ +** flag is never actually used and is not implemented in the built-in +** VFSes of SQLite. The file is named by the second argument and can be a +** directory. The xAccess method returns [SQLITE_OK] on success or some +** non-zero error code if there is an I/O error or if the name of +** the file given in the second argument is illegal. If SQLITE_OK +** is returned, then non-zero or zero is written into *pResOut to indicate +** whether or not the file is accessible. +** +** ^SQLite will always allocate at least mxPathname+1 bytes for the +** output buffer xFullPathname. The exact size of the output buffer +** is also passed as a parameter to both methods. If the output buffer +** is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is +** handled as a fatal error by SQLite, vfs implementations should endeavor +** to prevent this by setting mxPathname to a sufficiently large value. +** +** The xRandomness(), xSleep(), xCurrentTime(), and xCurrentTimeInt64() +** interfaces are not strictly a part of the filesystem, but they are +** included in the VFS structure for completeness. +** The xRandomness() function attempts to return nBytes bytes +** of good-quality randomness into zOut. The return value is +** the actual number of bytes of randomness obtained. +** The xSleep() method causes the calling thread to sleep for at +** least the number of microseconds given. ^The xCurrentTime() +** method returns a Julian Day Number for the current date and time as +** a floating point value. +** ^The xCurrentTimeInt64() method returns, as an integer, the Julian +** Day Number multiplied by 86400000 (the number of milliseconds in +** a 24-hour day). +** ^SQLite will use the xCurrentTimeInt64() method to get the current +** date and time if that method is available (if iVersion is 2 or +** greater and the function pointer is not NULL) and will fall back +** to xCurrentTime() if xCurrentTimeInt64() is unavailable. +** +** ^The xSetSystemCall(), xGetSystemCall(), and xNestSystemCall() interfaces +** are not used by the SQLite core. These optional interfaces are provided +** by some VFSes to facilitate testing of the VFS code. By overriding +** system calls with functions under its control, a test program can +** simulate faults and error conditions that would otherwise be difficult +** or impossible to induce. The set of system calls that can be overridden +** varies from one VFS to another, and from one version of the same VFS to the +** next. Applications that use these interfaces must be prepared for any +** or all of these interfaces to be NULL or for their behavior to change +** from one release to the next. Applications must not attempt to access +** any of these methods if the iVersion of the VFS is less than 3. +*/ +typedef struct sqlite3_vfs sqlite3_vfs; +typedef void (*sqlite3_syscall_ptr)(void); +struct sqlite3_vfs { + int iVersion; /* Structure version number (currently 3) */ + int szOsFile; /* Size of subclassed sqlite3_file */ + int mxPathname; /* Maximum file pathname length */ + sqlite3_vfs *pNext; /* Next registered VFS */ + const char *zName; /* Name of this virtual file system */ + void *pAppData; /* Pointer to application-specific data */ + int (*xOpen)(sqlite3_vfs*, sqlite3_filename zName, sqlite3_file*, + int flags, int *pOutFlags); + int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir); + int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut); + int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut); + void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename); + void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg); + void (*(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol))(void); + void (*xDlClose)(sqlite3_vfs*, void*); + int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut); + int (*xSleep)(sqlite3_vfs*, int microseconds); + int (*xCurrentTime)(sqlite3_vfs*, double*); + int (*xGetLastError)(sqlite3_vfs*, int, char *); + /* + ** The methods above are in version 1 of the sqlite_vfs object + ** definition. Those that follow are added in version 2 or later + */ + int (*xCurrentTimeInt64)(sqlite3_vfs*, sqlite3_int64*); + /* + ** The methods above are in versions 1 and 2 of the sqlite_vfs object. + ** Those below are for version 3 and greater. + */ + int (*xSetSystemCall)(sqlite3_vfs*, const char *zName, sqlite3_syscall_ptr); + sqlite3_syscall_ptr (*xGetSystemCall)(sqlite3_vfs*, const char *zName); + const char *(*xNextSystemCall)(sqlite3_vfs*, const char *zName); + /* + ** The methods above are in versions 1 through 3 of the sqlite_vfs object. + ** New fields may be appended in future versions. The iVersion + ** value will increment whenever this happens. + */ +}; + +/* +** CAPI3REF: Flags for the xAccess VFS method +** +** These integer constants can be used as the third parameter to +** the xAccess method of an [sqlite3_vfs] object. They determine +** what kind of permissions the xAccess method is looking for. +** With SQLITE_ACCESS_EXISTS, the xAccess method +** simply checks whether the file exists. +** With SQLITE_ACCESS_READWRITE, the xAccess method +** checks whether the named directory is both readable and writable +** (in other words, if files can be added, removed, and renamed within +** the directory). +** The SQLITE_ACCESS_READWRITE constant is currently used only by the +** [temp_store_directory pragma], though this could change in a future +** release of SQLite. +** With SQLITE_ACCESS_READ, the xAccess method +** checks whether the file is readable. The SQLITE_ACCESS_READ constant is +** currently unused, though it might be used in a future release of +** SQLite. +*/ +#define SQLITE_ACCESS_EXISTS 0 +#define SQLITE_ACCESS_READWRITE 1 /* Used by PRAGMA temp_store_directory */ +#define SQLITE_ACCESS_READ 2 /* Unused */ + +/* +** CAPI3REF: Flags for the xShmLock VFS method +** +** These integer constants define the various locking operations +** allowed by the xShmLock method of [sqlite3_io_methods]. The +** following are the only legal combinations of flags to the +** xShmLock method: +** +**
      +**
    • SQLITE_SHM_LOCK | SQLITE_SHM_SHARED +**
    • SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE +**
    • SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED +**
    • SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE +**
    +** +** When unlocking, the same SHARED or EXCLUSIVE flag must be supplied as +** was given on the corresponding lock. +** +** The xShmLock method can transition between unlocked and SHARED or +** between unlocked and EXCLUSIVE. It cannot transition between SHARED +** and EXCLUSIVE. +*/ +#define SQLITE_SHM_UNLOCK 1 +#define SQLITE_SHM_LOCK 2 +#define SQLITE_SHM_SHARED 4 +#define SQLITE_SHM_EXCLUSIVE 8 + +/* +** CAPI3REF: Maximum xShmLock index +** +** The xShmLock method on [sqlite3_io_methods] may use values +** between 0 and this upper bound as its "offset" argument. +** The SQLite core will never attempt to acquire or release a +** lock outside of this range +*/ +#define SQLITE_SHM_NLOCK 8 + + +/* +** CAPI3REF: Initialize The SQLite Library +** +** ^The sqlite3_initialize() routine initializes the +** SQLite library. ^The sqlite3_shutdown() routine +** deallocates any resources that were allocated by sqlite3_initialize(). +** These routines are designed to aid in process initialization and +** shutdown on embedded systems. Workstation applications using +** SQLite normally do not need to invoke either of these routines. +** +** A call to sqlite3_initialize() is an "effective" call if it is +** the first time sqlite3_initialize() is invoked during the lifetime of +** the process, or if it is the first time sqlite3_initialize() is invoked +** following a call to sqlite3_shutdown(). ^(Only an effective call +** of sqlite3_initialize() does any initialization. All other calls +** are harmless no-ops.)^ +** +** A call to sqlite3_shutdown() is an "effective" call if it is the first +** call to sqlite3_shutdown() since the last sqlite3_initialize(). ^(Only +** an effective call to sqlite3_shutdown() does any deinitialization. +** All other valid calls to sqlite3_shutdown() are harmless no-ops.)^ +** +** The sqlite3_initialize() interface is threadsafe, but sqlite3_shutdown() +** is not. The sqlite3_shutdown() interface must only be called from a +** single thread. All open [database connections] must be closed and all +** other SQLite resources must be deallocated prior to invoking +** sqlite3_shutdown(). +** +** Among other things, ^sqlite3_initialize() will invoke +** sqlite3_os_init(). Similarly, ^sqlite3_shutdown() +** will invoke sqlite3_os_end(). +** +** ^The sqlite3_initialize() routine returns [SQLITE_OK] on success. +** ^If for some reason, sqlite3_initialize() is unable to initialize +** the library (perhaps it is unable to allocate a needed resource such +** as a mutex) it returns an [error code] other than [SQLITE_OK]. +** +** ^The sqlite3_initialize() routine is called internally by many other +** SQLite interfaces so that an application usually does not need to +** invoke sqlite3_initialize() directly. For example, [sqlite3_open()] +** calls sqlite3_initialize() so the SQLite library will be automatically +** initialized when [sqlite3_open()] is called if it has not be initialized +** already. ^However, if SQLite is compiled with the [SQLITE_OMIT_AUTOINIT] +** compile-time option, then the automatic calls to sqlite3_initialize() +** are omitted and the application must call sqlite3_initialize() directly +** prior to using any other SQLite interface. For maximum portability, +** it is recommended that applications always invoke sqlite3_initialize() +** directly prior to using any other SQLite interface. Future releases +** of SQLite may require this. In other words, the behavior exhibited +** when SQLite is compiled with [SQLITE_OMIT_AUTOINIT] might become the +** default behavior in some future release of SQLite. +** +** The sqlite3_os_init() routine does operating-system specific +** initialization of the SQLite library. The sqlite3_os_end() +** routine undoes the effect of sqlite3_os_init(). Typical tasks +** performed by these routines include allocation or deallocation +** of static resources, initialization of global variables, +** setting up a default [sqlite3_vfs] module, or setting up +** a default configuration using [sqlite3_config()]. +** +** The application should never invoke either sqlite3_os_init() +** or sqlite3_os_end() directly. The application should only invoke +** sqlite3_initialize() and sqlite3_shutdown(). The sqlite3_os_init() +** interface is called automatically by sqlite3_initialize() and +** sqlite3_os_end() is called by sqlite3_shutdown(). Appropriate +** implementations for sqlite3_os_init() and sqlite3_os_end() +** are built into SQLite when it is compiled for Unix, Windows, or OS/2. +** When [custom builds | built for other platforms] +** (using the [SQLITE_OS_OTHER=1] compile-time +** option) the application must supply a suitable implementation for +** sqlite3_os_init() and sqlite3_os_end(). An application-supplied +** implementation of sqlite3_os_init() or sqlite3_os_end() +** must return [SQLITE_OK] on success and some other [error code] upon +** failure. +*/ +SQLITE_API int sqlite3_initialize(void); +SQLITE_API int sqlite3_shutdown(void); +SQLITE_API int sqlite3_os_init(void); +SQLITE_API int sqlite3_os_end(void); + +/* +** CAPI3REF: Configuring The SQLite Library +** +** The sqlite3_config() interface is used to make global configuration +** changes to SQLite in order to tune SQLite to the specific needs of +** the application. The default configuration is recommended for most +** applications and so this routine is usually not necessary. It is +** provided to support rare applications with unusual needs. +** +** The sqlite3_config() interface is not threadsafe. The application +** must ensure that no other SQLite interfaces are invoked by other +** threads while sqlite3_config() is running. +** +** The first argument to sqlite3_config() is an integer +** [configuration option] that determines +** what property of SQLite is to be configured. Subsequent arguments +** vary depending on the [configuration option] +** in the first argument. +** +** For most configuration options, the sqlite3_config() interface +** may only be invoked prior to library initialization using +** [sqlite3_initialize()] or after shutdown by [sqlite3_shutdown()]. +** The exceptional configuration options that may be invoked at any time +** are called "anytime configuration options". +** ^If sqlite3_config() is called after [sqlite3_initialize()] and before +** [sqlite3_shutdown()] with a first argument that is not an anytime +** configuration option, then the sqlite3_config() call will return SQLITE_MISUSE. +** Note, however, that ^sqlite3_config() can be called as part of the +** implementation of an application-defined [sqlite3_os_init()]. +** +** ^When a configuration option is set, sqlite3_config() returns [SQLITE_OK]. +** ^If the option is unknown or SQLite is unable to set the option +** then this routine returns a non-zero [error code]. +*/ +SQLITE_API int sqlite3_config(int, ...); + +/* +** CAPI3REF: Configure database connections +** METHOD: sqlite3 +** +** The sqlite3_db_config() interface is used to make configuration +** changes to a [database connection]. The interface is similar to +** [sqlite3_config()] except that the changes apply to a single +** [database connection] (specified in the first argument). +** +** The second argument to sqlite3_db_config(D,V,...) is the +** [SQLITE_DBCONFIG_LOOKASIDE | configuration verb] - an integer code +** that indicates what aspect of the [database connection] is being configured. +** Subsequent arguments vary depending on the configuration verb. +** +** ^Calls to sqlite3_db_config() return SQLITE_OK if and only if +** the call is considered successful. +*/ +SQLITE_API int sqlite3_db_config(sqlite3*, int op, ...); + +/* +** CAPI3REF: Memory Allocation Routines +** +** An instance of this object defines the interface between SQLite +** and low-level memory allocation routines. +** +** This object is used in only one place in the SQLite interface. +** A pointer to an instance of this object is the argument to +** [sqlite3_config()] when the configuration option is +** [SQLITE_CONFIG_MALLOC] or [SQLITE_CONFIG_GETMALLOC]. +** By creating an instance of this object +** and passing it to [sqlite3_config]([SQLITE_CONFIG_MALLOC]) +** during configuration, an application can specify an alternative +** memory allocation subsystem for SQLite to use for all of its +** dynamic memory needs. +** +** Note that SQLite comes with several [built-in memory allocators] +** that are perfectly adequate for the overwhelming majority of applications +** and that this object is only useful to a tiny minority of applications +** with specialized memory allocation requirements. This object is +** also used during testing of SQLite in order to specify an alternative +** memory allocator that simulates memory out-of-memory conditions in +** order to verify that SQLite recovers gracefully from such +** conditions. +** +** The xMalloc, xRealloc, and xFree methods must work like the +** malloc(), realloc() and free() functions from the standard C library. +** ^SQLite guarantees that the second argument to +** xRealloc is always a value returned by a prior call to xRoundup. +** +** xSize should return the allocated size of a memory allocation +** previously obtained from xMalloc or xRealloc. The allocated size +** is always at least as big as the requested size but may be larger. +** +** The xRoundup method returns what would be the allocated size of +** a memory allocation given a particular requested size. Most memory +** allocators round up memory allocations at least to the next multiple +** of 8. Some allocators round up to a larger multiple or to a power of 2. +** Every memory allocation request coming in through [sqlite3_malloc()] +** or [sqlite3_realloc()] first calls xRoundup. If xRoundup returns 0, +** that causes the corresponding memory allocation to fail. +** +** The xInit method initializes the memory allocator. For example, +** it might allocate any required mutexes or initialize internal data +** structures. The xShutdown method is invoked (indirectly) by +** [sqlite3_shutdown()] and should deallocate any resources acquired +** by xInit. The pAppData pointer is used as the only parameter to +** xInit and xShutdown. +** +** SQLite holds the [SQLITE_MUTEX_STATIC_MAIN] mutex when it invokes +** the xInit method, so the xInit method need not be threadsafe. The +** xShutdown method is only called from [sqlite3_shutdown()] so it does +** not need to be threadsafe either. For all other methods, SQLite +** holds the [SQLITE_MUTEX_STATIC_MEM] mutex as long as the +** [SQLITE_CONFIG_MEMSTATUS] configuration option is turned on (which +** it is by default) and so the methods are automatically serialized. +** However, if [SQLITE_CONFIG_MEMSTATUS] is disabled, then the other +** methods must be threadsafe or else make their own arrangements for +** serialization. +** +** SQLite will never invoke xInit() more than once without an intervening +** call to xShutdown(). +*/ +typedef struct sqlite3_mem_methods sqlite3_mem_methods; +struct sqlite3_mem_methods { + void *(*xMalloc)(int); /* Memory allocation function */ + void (*xFree)(void*); /* Free a prior allocation */ + void *(*xRealloc)(void*,int); /* Resize an allocation */ + int (*xSize)(void*); /* Return the size of an allocation */ + int (*xRoundup)(int); /* Round up request size to allocation size */ + int (*xInit)(void*); /* Initialize the memory allocator */ + void (*xShutdown)(void*); /* Deinitialize the memory allocator */ + void *pAppData; /* Argument to xInit() and xShutdown() */ +}; + +/* +** CAPI3REF: Configuration Options +** KEYWORDS: {configuration option} +** +** These constants are the available integer configuration options that +** can be passed as the first argument to the [sqlite3_config()] interface. +** +** Most of the configuration options for sqlite3_config() +** will only work if invoked prior to [sqlite3_initialize()] or after +** [sqlite3_shutdown()]. The few exceptions to this rule are called +** "anytime configuration options". +** ^Calling [sqlite3_config()] with a first argument that is not an +** anytime configuration option in between calls to [sqlite3_initialize()] and +** [sqlite3_shutdown()] is a no-op that returns SQLITE_MISUSE. +** +** The set of anytime configuration options can change (by insertions +** and/or deletions) from one release of SQLite to the next. +** As of SQLite version 3.42.0, the complete set of anytime configuration +** options is: +**
      +**
    • SQLITE_CONFIG_LOG +**
    • SQLITE_CONFIG_PCACHE_HDRSZ +**
    +** +** New configuration options may be added in future releases of SQLite. +** Existing configuration options might be discontinued. Applications +** should check the return code from [sqlite3_config()] to make sure that +** the call worked. The [sqlite3_config()] interface will return a +** non-zero [error code] if a discontinued or unsupported configuration option +** is invoked. +** +**
    +** [[SQLITE_CONFIG_SINGLETHREAD]]
    SQLITE_CONFIG_SINGLETHREAD
    +**
    There are no arguments to this option. ^This option sets the +** [threading mode] to Single-thread. In other words, it disables +** all mutexing and puts SQLite into a mode where it can only be used +** by a single thread. ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** it is not possible to change the [threading mode] from its default +** value of Single-thread and so [sqlite3_config()] will return +** [SQLITE_ERROR] if called with the SQLITE_CONFIG_SINGLETHREAD +** configuration option.
    +** +** [[SQLITE_CONFIG_MULTITHREAD]]
    SQLITE_CONFIG_MULTITHREAD
    +**
    There are no arguments to this option. ^This option sets the +** [threading mode] to Multi-thread. In other words, it disables +** mutexing on [database connection] and [prepared statement] objects. +** The application is responsible for serializing access to +** [database connections] and [prepared statements]. But other mutexes +** are enabled so that SQLite will be safe to use in a multi-threaded +** environment as long as no two threads attempt to use the same +** [database connection] at the same time. ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** it is not possible to set the Multi-thread [threading mode] and +** [sqlite3_config()] will return [SQLITE_ERROR] if called with the +** SQLITE_CONFIG_MULTITHREAD configuration option.
    +** +** [[SQLITE_CONFIG_SERIALIZED]]
    SQLITE_CONFIG_SERIALIZED
    +**
    There are no arguments to this option. ^This option sets the +** [threading mode] to Serialized. In other words, this option enables +** all mutexes including the recursive +** mutexes on [database connection] and [prepared statement] objects. +** In this mode (which is the default when SQLite is compiled with +** [SQLITE_THREADSAFE=1]) the SQLite library will itself serialize access +** to [database connections] and [prepared statements] so that the +** application is free to use the same [database connection] or the +** same [prepared statement] in different threads at the same time. +** ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** it is not possible to set the Serialized [threading mode] and +** [sqlite3_config()] will return [SQLITE_ERROR] if called with the +** SQLITE_CONFIG_SERIALIZED configuration option.
    +** +** [[SQLITE_CONFIG_MALLOC]]
    SQLITE_CONFIG_MALLOC
    +**
    ^(The SQLITE_CONFIG_MALLOC option takes a single argument which is +** a pointer to an instance of the [sqlite3_mem_methods] structure. +** The argument specifies +** alternative low-level memory allocation routines to be used in place of +** the memory allocation routines built into SQLite.)^ ^SQLite makes +** its own private copy of the content of the [sqlite3_mem_methods] structure +** before the [sqlite3_config()] call returns.
    +** +** [[SQLITE_CONFIG_GETMALLOC]]
    SQLITE_CONFIG_GETMALLOC
    +**
    ^(The SQLITE_CONFIG_GETMALLOC option takes a single argument which +** is a pointer to an instance of the [sqlite3_mem_methods] structure. +** The [sqlite3_mem_methods] +** structure is filled with the currently defined memory allocation routines.)^ +** This option can be used to overload the default memory allocation +** routines with a wrapper that simulations memory allocation failure or +** tracks memory usage, for example.
    +** +** [[SQLITE_CONFIG_SMALL_MALLOC]]
    SQLITE_CONFIG_SMALL_MALLOC
    +**
    ^The SQLITE_CONFIG_SMALL_MALLOC option takes single argument of +** type int, interpreted as a boolean, which if true provides a hint to +** SQLite that it should avoid large memory allocations if possible. +** SQLite will run faster if it is free to make large memory allocations, +** but some application might prefer to run slower in exchange for +** guarantees about memory fragmentation that are possible if large +** allocations are avoided. This hint is normally off. +**
    +** +** [[SQLITE_CONFIG_MEMSTATUS]]
    SQLITE_CONFIG_MEMSTATUS
    +**
    ^The SQLITE_CONFIG_MEMSTATUS option takes single argument of type int, +** interpreted as a boolean, which enables or disables the collection of +** memory allocation statistics. ^(When memory allocation statistics are +** disabled, the following SQLite interfaces become non-operational: +**
      +**
    • [sqlite3_hard_heap_limit64()] +**
    • [sqlite3_memory_used()] +**
    • [sqlite3_memory_highwater()] +**
    • [sqlite3_soft_heap_limit64()] +**
    • [sqlite3_status64()] +**
    )^ +** ^Memory allocation statistics are enabled by default unless SQLite is +** compiled with [SQLITE_DEFAULT_MEMSTATUS]=0 in which case memory +** allocation statistics are disabled by default. +**
    +** +** [[SQLITE_CONFIG_SCRATCH]]
    SQLITE_CONFIG_SCRATCH
    +**
    The SQLITE_CONFIG_SCRATCH option is no longer used. +**
    +** +** [[SQLITE_CONFIG_PAGECACHE]]
    SQLITE_CONFIG_PAGECACHE
    +**
    ^The SQLITE_CONFIG_PAGECACHE option specifies a memory pool +** that SQLite can use for the database page cache with the default page +** cache implementation. +** This configuration option is a no-op if an application-defined page +** cache implementation is loaded using the [SQLITE_CONFIG_PCACHE2]. +** ^There are three arguments to SQLITE_CONFIG_PAGECACHE: A pointer to +** 8-byte aligned memory (pMem), the size of each page cache line (sz), +** and the number of cache lines (N). +** The sz argument should be the size of the largest database page +** (a power of two between 512 and 65536) plus some extra bytes for each +** page header. ^The number of extra bytes needed by the page header +** can be determined using [SQLITE_CONFIG_PCACHE_HDRSZ]. +** ^It is harmless, apart from the wasted memory, +** for the sz parameter to be larger than necessary. The pMem +** argument must be either a NULL pointer or a pointer to an 8-byte +** aligned block of memory of at least sz*N bytes, otherwise +** subsequent behavior is undefined. +** ^When pMem is not NULL, SQLite will strive to use the memory provided +** to satisfy page cache needs, falling back to [sqlite3_malloc()] if +** a page cache line is larger than sz bytes or if all of the pMem buffer +** is exhausted. +** ^If pMem is NULL and N is non-zero, then each database connection +** does an initial bulk allocation for page cache memory +** from [sqlite3_malloc()] sufficient for N cache lines if N is positive or +** of -1024*N bytes if N is negative, . ^If additional +** page cache memory is needed beyond what is provided by the initial +** allocation, then SQLite goes to [sqlite3_malloc()] separately for each +** additional cache line.
    +** +** [[SQLITE_CONFIG_HEAP]]
    SQLITE_CONFIG_HEAP
    +**
    ^The SQLITE_CONFIG_HEAP option specifies a static memory buffer +** that SQLite will use for all of its dynamic memory allocation needs +** beyond those provided for by [SQLITE_CONFIG_PAGECACHE]. +** ^The SQLITE_CONFIG_HEAP option is only available if SQLite is compiled +** with either [SQLITE_ENABLE_MEMSYS3] or [SQLITE_ENABLE_MEMSYS5] and returns +** [SQLITE_ERROR] if invoked otherwise. +** ^There are three arguments to SQLITE_CONFIG_HEAP: +** An 8-byte aligned pointer to the memory, +** the number of bytes in the memory buffer, and the minimum allocation size. +** ^If the first pointer (the memory pointer) is NULL, then SQLite reverts +** to using its default memory allocator (the system malloc() implementation), +** undoing any prior invocation of [SQLITE_CONFIG_MALLOC]. ^If the +** memory pointer is not NULL then the alternative memory +** allocator is engaged to handle all of SQLites memory allocation needs. +** The first pointer (the memory pointer) must be aligned to an 8-byte +** boundary or subsequent behavior of SQLite will be undefined. +** The minimum allocation size is capped at 2**12. Reasonable values +** for the minimum allocation size are 2**5 through 2**8.
    +** +** [[SQLITE_CONFIG_MUTEX]]
    SQLITE_CONFIG_MUTEX
    +**
    ^(The SQLITE_CONFIG_MUTEX option takes a single argument which is a +** pointer to an instance of the [sqlite3_mutex_methods] structure. +** The argument specifies alternative low-level mutex routines to be used +** in place the mutex routines built into SQLite.)^ ^SQLite makes a copy of +** the content of the [sqlite3_mutex_methods] structure before the call to +** [sqlite3_config()] returns. ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** the entire mutexing subsystem is omitted from the build and hence calls to +** [sqlite3_config()] with the SQLITE_CONFIG_MUTEX configuration option will +** return [SQLITE_ERROR].
    +** +** [[SQLITE_CONFIG_GETMUTEX]]
    SQLITE_CONFIG_GETMUTEX
    +**
    ^(The SQLITE_CONFIG_GETMUTEX option takes a single argument which +** is a pointer to an instance of the [sqlite3_mutex_methods] structure. The +** [sqlite3_mutex_methods] +** structure is filled with the currently defined mutex routines.)^ +** This option can be used to overload the default mutex allocation +** routines with a wrapper used to track mutex usage for performance +** profiling or testing, for example. ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** the entire mutexing subsystem is omitted from the build and hence calls to +** [sqlite3_config()] with the SQLITE_CONFIG_GETMUTEX configuration option will +** return [SQLITE_ERROR].
    +** +** [[SQLITE_CONFIG_LOOKASIDE]]
    SQLITE_CONFIG_LOOKASIDE
    +**
    ^(The SQLITE_CONFIG_LOOKASIDE option takes two arguments that determine +** the default size of lookaside memory on each [database connection]. +** The first argument is the +** size of each lookaside buffer slot and the second is the number of +** slots allocated to each database connection.)^ ^(SQLITE_CONFIG_LOOKASIDE +** sets the default lookaside size. The [SQLITE_DBCONFIG_LOOKASIDE] +** option to [sqlite3_db_config()] can be used to change the lookaside +** configuration on individual connections.)^
    +** +** [[SQLITE_CONFIG_PCACHE2]]
    SQLITE_CONFIG_PCACHE2
    +**
    ^(The SQLITE_CONFIG_PCACHE2 option takes a single argument which is +** a pointer to an [sqlite3_pcache_methods2] object. This object specifies +** the interface to a custom page cache implementation.)^ +** ^SQLite makes a copy of the [sqlite3_pcache_methods2] object.
    +** +** [[SQLITE_CONFIG_GETPCACHE2]]
    SQLITE_CONFIG_GETPCACHE2
    +**
    ^(The SQLITE_CONFIG_GETPCACHE2 option takes a single argument which +** is a pointer to an [sqlite3_pcache_methods2] object. SQLite copies of +** the current page cache implementation into that object.)^
    +** +** [[SQLITE_CONFIG_LOG]]
    SQLITE_CONFIG_LOG
    +**
    The SQLITE_CONFIG_LOG option is used to configure the SQLite +** global [error log]. +** (^The SQLITE_CONFIG_LOG option takes two arguments: a pointer to a +** function with a call signature of void(*)(void*,int,const char*), +** and a pointer to void. ^If the function pointer is not NULL, it is +** invoked by [sqlite3_log()] to process each logging event. ^If the +** function pointer is NULL, the [sqlite3_log()] interface becomes a no-op. +** ^The void pointer that is the second argument to SQLITE_CONFIG_LOG is +** passed through as the first parameter to the application-defined logger +** function whenever that function is invoked. ^The second parameter to +** the logger function is a copy of the first parameter to the corresponding +** [sqlite3_log()] call and is intended to be a [result code] or an +** [extended result code]. ^The third parameter passed to the logger is +** log message after formatting via [sqlite3_snprintf()]. +** The SQLite logging interface is not reentrant; the logger function +** supplied by the application must not invoke any SQLite interface. +** In a multi-threaded application, the application-defined logger +** function must be threadsafe.
    +** +** [[SQLITE_CONFIG_URI]]
    SQLITE_CONFIG_URI +**
    ^(The SQLITE_CONFIG_URI option takes a single argument of type int. +** If non-zero, then URI handling is globally enabled. If the parameter is zero, +** then URI handling is globally disabled.)^ ^If URI handling is globally +** enabled, all filenames passed to [sqlite3_open()], [sqlite3_open_v2()], +** [sqlite3_open16()] or +** specified as part of [ATTACH] commands are interpreted as URIs, regardless +** of whether or not the [SQLITE_OPEN_URI] flag is set when the database +** connection is opened. ^If it is globally disabled, filenames are +** only interpreted as URIs if the SQLITE_OPEN_URI flag is set when the +** database connection is opened. ^(By default, URI handling is globally +** disabled. The default value may be changed by compiling with the +** [SQLITE_USE_URI] symbol defined.)^ +** +** [[SQLITE_CONFIG_COVERING_INDEX_SCAN]]
    SQLITE_CONFIG_COVERING_INDEX_SCAN +**
    ^The SQLITE_CONFIG_COVERING_INDEX_SCAN option takes a single integer +** argument which is interpreted as a boolean in order to enable or disable +** the use of covering indices for full table scans in the query optimizer. +** ^The default setting is determined +** by the [SQLITE_ALLOW_COVERING_INDEX_SCAN] compile-time option, or is "on" +** if that compile-time option is omitted. +** The ability to disable the use of covering indices for full table scans +** is because some incorrectly coded legacy applications might malfunction +** when the optimization is enabled. Providing the ability to +** disable the optimization allows the older, buggy application code to work +** without change even with newer versions of SQLite. +** +** [[SQLITE_CONFIG_PCACHE]] [[SQLITE_CONFIG_GETPCACHE]] +**
    SQLITE_CONFIG_PCACHE and SQLITE_CONFIG_GETPCACHE +**
    These options are obsolete and should not be used by new code. +** They are retained for backwards compatibility but are now no-ops. +**
    +** +** [[SQLITE_CONFIG_SQLLOG]] +**
    SQLITE_CONFIG_SQLLOG +**
    This option is only available if sqlite is compiled with the +** [SQLITE_ENABLE_SQLLOG] pre-processor macro defined. The first argument should +** be a pointer to a function of type void(*)(void*,sqlite3*,const char*, int). +** The second should be of type (void*). The callback is invoked by the library +** in three separate circumstances, identified by the value passed as the +** fourth parameter. If the fourth parameter is 0, then the database connection +** passed as the second argument has just been opened. The third argument +** points to a buffer containing the name of the main database file. If the +** fourth parameter is 1, then the SQL statement that the third parameter +** points to has just been executed. Or, if the fourth parameter is 2, then +** the connection being passed as the second parameter is being closed. The +** third parameter is passed NULL In this case. An example of using this +** configuration option can be seen in the "test_sqllog.c" source file in +** the canonical SQLite source tree.
    +** +** [[SQLITE_CONFIG_MMAP_SIZE]] +**
    SQLITE_CONFIG_MMAP_SIZE +**
    ^SQLITE_CONFIG_MMAP_SIZE takes two 64-bit integer (sqlite3_int64) values +** that are the default mmap size limit (the default setting for +** [PRAGMA mmap_size]) and the maximum allowed mmap size limit. +** ^The default setting can be overridden by each database connection using +** either the [PRAGMA mmap_size] command, or by using the +** [SQLITE_FCNTL_MMAP_SIZE] file control. ^(The maximum allowed mmap size +** will be silently truncated if necessary so that it does not exceed the +** compile-time maximum mmap size set by the +** [SQLITE_MAX_MMAP_SIZE] compile-time option.)^ +** ^If either argument to this option is negative, then that argument is +** changed to its compile-time default. +** +** [[SQLITE_CONFIG_WIN32_HEAPSIZE]] +**
    SQLITE_CONFIG_WIN32_HEAPSIZE +**
    ^The SQLITE_CONFIG_WIN32_HEAPSIZE option is only available if SQLite is +** compiled for Windows with the [SQLITE_WIN32_MALLOC] pre-processor macro +** defined. ^SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit unsigned integer value +** that specifies the maximum size of the created heap. +** +** [[SQLITE_CONFIG_PCACHE_HDRSZ]] +**
    SQLITE_CONFIG_PCACHE_HDRSZ +**
    ^The SQLITE_CONFIG_PCACHE_HDRSZ option takes a single parameter which +** is a pointer to an integer and writes into that integer the number of extra +** bytes per page required for each page in [SQLITE_CONFIG_PAGECACHE]. +** The amount of extra space required can change depending on the compiler, +** target platform, and SQLite version. +** +** [[SQLITE_CONFIG_PMASZ]] +**
    SQLITE_CONFIG_PMASZ +**
    ^The SQLITE_CONFIG_PMASZ option takes a single parameter which +** is an unsigned integer and sets the "Minimum PMA Size" for the multithreaded +** sorter to that integer. The default minimum PMA Size is set by the +** [SQLITE_SORTER_PMASZ] compile-time option. New threads are launched +** to help with sort operations when multithreaded sorting +** is enabled (using the [PRAGMA threads] command) and the amount of content +** to be sorted exceeds the page size times the minimum of the +** [PRAGMA cache_size] setting and this value. +** +** [[SQLITE_CONFIG_STMTJRNL_SPILL]] +**
    SQLITE_CONFIG_STMTJRNL_SPILL +**
    ^The SQLITE_CONFIG_STMTJRNL_SPILL option takes a single parameter which +** becomes the [statement journal] spill-to-disk threshold. +** [Statement journals] are held in memory until their size (in bytes) +** exceeds this threshold, at which point they are written to disk. +** Or if the threshold is -1, statement journals are always held +** exclusively in memory. +** Since many statement journals never become large, setting the spill +** threshold to a value such as 64KiB can greatly reduce the amount of +** I/O required to support statement rollback. +** The default value for this setting is controlled by the +** [SQLITE_STMTJRNL_SPILL] compile-time option. +** +** [[SQLITE_CONFIG_SORTERREF_SIZE]] +**
    SQLITE_CONFIG_SORTERREF_SIZE +**
    The SQLITE_CONFIG_SORTERREF_SIZE option accepts a single parameter +** of type (int) - the new value of the sorter-reference size threshold. +** Usually, when SQLite uses an external sort to order records according +** to an ORDER BY clause, all fields required by the caller are present in the +** sorted records. However, if SQLite determines based on the declared type +** of a table column that its values are likely to be very large - larger +** than the configured sorter-reference size threshold - then a reference +** is stored in each sorted record and the required column values loaded +** from the database as records are returned in sorted order. The default +** value for this option is to never use this optimization. Specifying a +** negative value for this option restores the default behaviour. +** This option is only available if SQLite is compiled with the +** [SQLITE_ENABLE_SORTER_REFERENCES] compile-time option. +** +** [[SQLITE_CONFIG_MEMDB_MAXSIZE]] +**
    SQLITE_CONFIG_MEMDB_MAXSIZE +**
    The SQLITE_CONFIG_MEMDB_MAXSIZE option accepts a single parameter +** [sqlite3_int64] parameter which is the default maximum size for an in-memory +** database created using [sqlite3_deserialize()]. This default maximum +** size can be adjusted up or down for individual databases using the +** [SQLITE_FCNTL_SIZE_LIMIT] [sqlite3_file_control|file-control]. If this +** configuration setting is never used, then the default maximum is determined +** by the [SQLITE_MEMDB_DEFAULT_MAXSIZE] compile-time option. If that +** compile-time option is not set, then the default maximum is 1073741824. +**
    +*/ +#define SQLITE_CONFIG_SINGLETHREAD 1 /* nil */ +#define SQLITE_CONFIG_MULTITHREAD 2 /* nil */ +#define SQLITE_CONFIG_SERIALIZED 3 /* nil */ +#define SQLITE_CONFIG_MALLOC 4 /* sqlite3_mem_methods* */ +#define SQLITE_CONFIG_GETMALLOC 5 /* sqlite3_mem_methods* */ +#define SQLITE_CONFIG_SCRATCH 6 /* No longer used */ +#define SQLITE_CONFIG_PAGECACHE 7 /* void*, int sz, int N */ +#define SQLITE_CONFIG_HEAP 8 /* void*, int nByte, int min */ +#define SQLITE_CONFIG_MEMSTATUS 9 /* boolean */ +#define SQLITE_CONFIG_MUTEX 10 /* sqlite3_mutex_methods* */ +#define SQLITE_CONFIG_GETMUTEX 11 /* sqlite3_mutex_methods* */ +/* previously SQLITE_CONFIG_CHUNKALLOC 12 which is now unused. */ +#define SQLITE_CONFIG_LOOKASIDE 13 /* int int */ +#define SQLITE_CONFIG_PCACHE 14 /* no-op */ +#define SQLITE_CONFIG_GETPCACHE 15 /* no-op */ +#define SQLITE_CONFIG_LOG 16 /* xFunc, void* */ +#define SQLITE_CONFIG_URI 17 /* int */ +#define SQLITE_CONFIG_PCACHE2 18 /* sqlite3_pcache_methods2* */ +#define SQLITE_CONFIG_GETPCACHE2 19 /* sqlite3_pcache_methods2* */ +#define SQLITE_CONFIG_COVERING_INDEX_SCAN 20 /* int */ +#define SQLITE_CONFIG_SQLLOG 21 /* xSqllog, void* */ +#define SQLITE_CONFIG_MMAP_SIZE 22 /* sqlite3_int64, sqlite3_int64 */ +#define SQLITE_CONFIG_WIN32_HEAPSIZE 23 /* int nByte */ +#define SQLITE_CONFIG_PCACHE_HDRSZ 24 /* int *psz */ +#define SQLITE_CONFIG_PMASZ 25 /* unsigned int szPma */ +#define SQLITE_CONFIG_STMTJRNL_SPILL 26 /* int nByte */ +#define SQLITE_CONFIG_SMALL_MALLOC 27 /* boolean */ +#define SQLITE_CONFIG_SORTERREF_SIZE 28 /* int nByte */ +#define SQLITE_CONFIG_MEMDB_MAXSIZE 29 /* sqlite3_int64 */ + +/* +** CAPI3REF: Database Connection Configuration Options +** +** These constants are the available integer configuration options that +** can be passed as the second argument to the [sqlite3_db_config()] interface. +** +** New configuration options may be added in future releases of SQLite. +** Existing configuration options might be discontinued. Applications +** should check the return code from [sqlite3_db_config()] to make sure that +** the call worked. ^The [sqlite3_db_config()] interface will return a +** non-zero [error code] if a discontinued or unsupported configuration option +** is invoked. +** +**
    +** [[SQLITE_DBCONFIG_LOOKASIDE]] +**
    SQLITE_DBCONFIG_LOOKASIDE
    +**
    ^This option takes three additional arguments that determine the +** [lookaside memory allocator] configuration for the [database connection]. +** ^The first argument (the third parameter to [sqlite3_db_config()] is a +** pointer to a memory buffer to use for lookaside memory. +** ^The first argument after the SQLITE_DBCONFIG_LOOKASIDE verb +** may be NULL in which case SQLite will allocate the +** lookaside buffer itself using [sqlite3_malloc()]. ^The second argument is the +** size of each lookaside buffer slot. ^The third argument is the number of +** slots. The size of the buffer in the first argument must be greater than +** or equal to the product of the second and third arguments. The buffer +** must be aligned to an 8-byte boundary. ^If the second argument to +** SQLITE_DBCONFIG_LOOKASIDE is not a multiple of 8, it is internally +** rounded down to the next smaller multiple of 8. ^(The lookaside memory +** configuration for a database connection can only be changed when that +** connection is not currently using lookaside memory, or in other words +** when the "current value" returned by +** [sqlite3_db_status](D,[SQLITE_DBSTATUS_LOOKASIDE_USED],...) is zero. +** Any attempt to change the lookaside memory configuration when lookaside +** memory is in use leaves the configuration unchanged and returns +** [SQLITE_BUSY].)^
    +** +** [[SQLITE_DBCONFIG_ENABLE_FKEY]] +**
    SQLITE_DBCONFIG_ENABLE_FKEY
    +**
    ^This option is used to enable or disable the enforcement of +** [foreign key constraints]. There should be two additional arguments. +** The first argument is an integer which is 0 to disable FK enforcement, +** positive to enable FK enforcement or negative to leave FK enforcement +** unchanged. The second parameter is a pointer to an integer into which +** is written 0 or 1 to indicate whether FK enforcement is off or on +** following this call. The second parameter may be a NULL pointer, in +** which case the FK enforcement setting is not reported back.
    +** +** [[SQLITE_DBCONFIG_ENABLE_TRIGGER]] +**
    SQLITE_DBCONFIG_ENABLE_TRIGGER
    +**
    ^This option is used to enable or disable [CREATE TRIGGER | triggers]. +** There should be two additional arguments. +** The first argument is an integer which is 0 to disable triggers, +** positive to enable triggers or negative to leave the setting unchanged. +** The second parameter is a pointer to an integer into which +** is written 0 or 1 to indicate whether triggers are disabled or enabled +** following this call. The second parameter may be a NULL pointer, in +** which case the trigger setting is not reported back. +** +**

    Originally this option disabled all triggers. ^(However, since +** SQLite version 3.35.0, TEMP triggers are still allowed even if +** this option is off. So, in other words, this option now only disables +** triggers in the main database schema or in the schemas of ATTACH-ed +** databases.)^

    +** +** [[SQLITE_DBCONFIG_ENABLE_VIEW]] +**
    SQLITE_DBCONFIG_ENABLE_VIEW
    +**
    ^This option is used to enable or disable [CREATE VIEW | views]. +** There should be two additional arguments. +** The first argument is an integer which is 0 to disable views, +** positive to enable views or negative to leave the setting unchanged. +** The second parameter is a pointer to an integer into which +** is written 0 or 1 to indicate whether views are disabled or enabled +** following this call. The second parameter may be a NULL pointer, in +** which case the view setting is not reported back. +** +**

    Originally this option disabled all views. ^(However, since +** SQLite version 3.35.0, TEMP views are still allowed even if +** this option is off. So, in other words, this option now only disables +** views in the main database schema or in the schemas of ATTACH-ed +** databases.)^

    +** +** [[SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER]] +**
    SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER
    +**
    ^This option is used to enable or disable the +** [fts3_tokenizer()] function which is part of the +** [FTS3] full-text search engine extension. +** There should be two additional arguments. +** The first argument is an integer which is 0 to disable fts3_tokenizer() or +** positive to enable fts3_tokenizer() or negative to leave the setting +** unchanged. +** The second parameter is a pointer to an integer into which +** is written 0 or 1 to indicate whether fts3_tokenizer is disabled or enabled +** following this call. The second parameter may be a NULL pointer, in +** which case the new setting is not reported back.
    +** +** [[SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION]] +**
    SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION
    +**
    ^This option is used to enable or disable the [sqlite3_load_extension()] +** interface independently of the [load_extension()] SQL function. +** The [sqlite3_enable_load_extension()] API enables or disables both the +** C-API [sqlite3_load_extension()] and the SQL function [load_extension()]. +** There should be two additional arguments. +** When the first argument to this interface is 1, then only the C-API is +** enabled and the SQL function remains disabled. If the first argument to +** this interface is 0, then both the C-API and the SQL function are disabled. +** If the first argument is -1, then no changes are made to state of either the +** C-API or the SQL function. +** The second parameter is a pointer to an integer into which +** is written 0 or 1 to indicate whether [sqlite3_load_extension()] interface +** is disabled or enabled following this call. The second parameter may +** be a NULL pointer, in which case the new setting is not reported back. +**
    +** +** [[SQLITE_DBCONFIG_MAINDBNAME]]
    SQLITE_DBCONFIG_MAINDBNAME
    +**
    ^This option is used to change the name of the "main" database +** schema. ^The sole argument is a pointer to a constant UTF8 string +** which will become the new schema name in place of "main". ^SQLite +** does not make a copy of the new main schema name string, so the application +** must ensure that the argument passed into this DBCONFIG option is unchanged +** until after the database connection closes. +**
    +** +** [[SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE]] +**
    SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE
    +**
    Usually, when a database in wal mode is closed or detached from a +** database handle, SQLite checks if this will mean that there are now no +** connections at all to the database. If so, it performs a checkpoint +** operation before closing the connection. This option may be used to +** override this behaviour. The first parameter passed to this operation +** is an integer - positive to disable checkpoints-on-close, or zero (the +** default) to enable them, and negative to leave the setting unchanged. +** The second parameter is a pointer to an integer +** into which is written 0 or 1 to indicate whether checkpoints-on-close +** have been disabled - 0 if they are not disabled, 1 if they are. +**
    +** +** [[SQLITE_DBCONFIG_ENABLE_QPSG]]
    SQLITE_DBCONFIG_ENABLE_QPSG
    +**
    ^(The SQLITE_DBCONFIG_ENABLE_QPSG option activates or deactivates +** the [query planner stability guarantee] (QPSG). When the QPSG is active, +** a single SQL query statement will always use the same algorithm regardless +** of values of [bound parameters].)^ The QPSG disables some query optimizations +** that look at the values of bound parameters, which can make some queries +** slower. But the QPSG has the advantage of more predictable behavior. With +** the QPSG active, SQLite will always use the same query plan in the field as +** was used during testing in the lab. +** The first argument to this setting is an integer which is 0 to disable +** the QPSG, positive to enable QPSG, or negative to leave the setting +** unchanged. The second parameter is a pointer to an integer into which +** is written 0 or 1 to indicate whether the QPSG is disabled or enabled +** following this call. +**
    +** +** [[SQLITE_DBCONFIG_TRIGGER_EQP]]
    SQLITE_DBCONFIG_TRIGGER_EQP
    +**
    By default, the output of EXPLAIN QUERY PLAN commands does not +** include output for any operations performed by trigger programs. This +** option is used to set or clear (the default) a flag that governs this +** behavior. The first parameter passed to this operation is an integer - +** positive to enable output for trigger programs, or zero to disable it, +** or negative to leave the setting unchanged. +** The second parameter is a pointer to an integer into which is written +** 0 or 1 to indicate whether output-for-triggers has been disabled - 0 if +** it is not disabled, 1 if it is. +**
    +** +** [[SQLITE_DBCONFIG_RESET_DATABASE]]
    SQLITE_DBCONFIG_RESET_DATABASE
    +**
    Set the SQLITE_DBCONFIG_RESET_DATABASE flag and then run +** [VACUUM] in order to reset a database back to an empty database +** with no schema and no content. The following process works even for +** a badly corrupted database file: +**
      +**
    1. If the database connection is newly opened, make sure it has read the +** database schema by preparing then discarding some query against the +** database, or calling sqlite3_table_column_metadata(), ignoring any +** errors. This step is only necessary if the application desires to keep +** the database in WAL mode after the reset if it was in WAL mode before +** the reset. +**
    2. sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 1, 0); +**
    3. [sqlite3_exec](db, "[VACUUM]", 0, 0, 0); +**
    4. sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 0, 0); +**
    +** Because resetting a database is destructive and irreversible, the +** process requires the use of this obscure API and multiple steps to +** help ensure that it does not happen by accident. Because this +** feature must be capable of resetting corrupt databases, and +** shutting down virtual tables may require access to that corrupt +** storage, the library must abandon any installed virtual tables +** without calling their xDestroy() methods. +** +** [[SQLITE_DBCONFIG_DEFENSIVE]]
    SQLITE_DBCONFIG_DEFENSIVE
    +**
    The SQLITE_DBCONFIG_DEFENSIVE option activates or deactivates the +** "defensive" flag for a database connection. When the defensive +** flag is enabled, language features that allow ordinary SQL to +** deliberately corrupt the database file are disabled. The disabled +** features include but are not limited to the following: +**
      +**
    • The [PRAGMA writable_schema=ON] statement. +**
    • The [PRAGMA journal_mode=OFF] statement. +**
    • The [PRAGMA schema_version=N] statement. +**
    • Writes to the [sqlite_dbpage] virtual table. +**
    • Direct writes to [shadow tables]. +**
    +**
    +** +** [[SQLITE_DBCONFIG_WRITABLE_SCHEMA]]
    SQLITE_DBCONFIG_WRITABLE_SCHEMA
    +**
    The SQLITE_DBCONFIG_WRITABLE_SCHEMA option activates or deactivates the +** "writable_schema" flag. This has the same effect and is logically equivalent +** to setting [PRAGMA writable_schema=ON] or [PRAGMA writable_schema=OFF]. +** The first argument to this setting is an integer which is 0 to disable +** the writable_schema, positive to enable writable_schema, or negative to +** leave the setting unchanged. The second parameter is a pointer to an +** integer into which is written 0 or 1 to indicate whether the writable_schema +** is enabled or disabled following this call. +**
    +** +** [[SQLITE_DBCONFIG_LEGACY_ALTER_TABLE]] +**
    SQLITE_DBCONFIG_LEGACY_ALTER_TABLE
    +**
    The SQLITE_DBCONFIG_LEGACY_ALTER_TABLE option activates or deactivates +** the legacy behavior of the [ALTER TABLE RENAME] command such it +** behaves as it did prior to [version 3.24.0] (2018-06-04). See the +** "Compatibility Notice" on the [ALTER TABLE RENAME documentation] for +** additional information. This feature can also be turned on and off +** using the [PRAGMA legacy_alter_table] statement. +**
    +** +** [[SQLITE_DBCONFIG_DQS_DML]] +**
    SQLITE_DBCONFIG_DQS_DML
    +**
    The SQLITE_DBCONFIG_DQS_DML option activates or deactivates +** the legacy [double-quoted string literal] misfeature for DML statements +** only, that is DELETE, INSERT, SELECT, and UPDATE statements. The +** default value of this setting is determined by the [-DSQLITE_DQS] +** compile-time option. +**
    +** +** [[SQLITE_DBCONFIG_DQS_DDL]] +**
    SQLITE_DBCONFIG_DQS_DDL
    +**
    The SQLITE_DBCONFIG_DQS option activates or deactivates +** the legacy [double-quoted string literal] misfeature for DDL statements, +** such as CREATE TABLE and CREATE INDEX. The +** default value of this setting is determined by the [-DSQLITE_DQS] +** compile-time option. +**
    +** +** [[SQLITE_DBCONFIG_TRUSTED_SCHEMA]] +**
    SQLITE_DBCONFIG_TRUSTED_SCHEMA
    +**
    The SQLITE_DBCONFIG_TRUSTED_SCHEMA option tells SQLite to +** assume that database schemas are untainted by malicious content. +** When the SQLITE_DBCONFIG_TRUSTED_SCHEMA option is disabled, SQLite +** takes additional defensive steps to protect the application from harm +** including: +**
      +**
    • Prohibit the use of SQL functions inside triggers, views, +** CHECK constraints, DEFAULT clauses, expression indexes, +** partial indexes, or generated columns +** unless those functions are tagged with [SQLITE_INNOCUOUS]. +**
    • Prohibit the use of virtual tables inside of triggers or views +** unless those virtual tables are tagged with [SQLITE_VTAB_INNOCUOUS]. +**
    +** This setting defaults to "on" for legacy compatibility, however +** all applications are advised to turn it off if possible. This setting +** can also be controlled using the [PRAGMA trusted_schema] statement. +**
    +** +** [[SQLITE_DBCONFIG_LEGACY_FILE_FORMAT]] +**
    SQLITE_DBCONFIG_LEGACY_FILE_FORMAT
    +**
    The SQLITE_DBCONFIG_LEGACY_FILE_FORMAT option activates or deactivates +** the legacy file format flag. When activated, this flag causes all newly +** created database file to have a schema format version number (the 4-byte +** integer found at offset 44 into the database header) of 1. This in turn +** means that the resulting database file will be readable and writable by +** any SQLite version back to 3.0.0 ([dateof:3.0.0]). Without this setting, +** newly created databases are generally not understandable by SQLite versions +** prior to 3.3.0 ([dateof:3.3.0]). As these words are written, there +** is now scarcely any need to generate database files that are compatible +** all the way back to version 3.0.0, and so this setting is of little +** practical use, but is provided so that SQLite can continue to claim the +** ability to generate new database files that are compatible with version +** 3.0.0. +**

    Note that when the SQLITE_DBCONFIG_LEGACY_FILE_FORMAT setting is on, +** the [VACUUM] command will fail with an obscure error when attempting to +** process a table with generated columns and a descending index. This is +** not considered a bug since SQLite versions 3.3.0 and earlier do not support +** either generated columns or decending indexes. +**

    +** +** [[SQLITE_DBCONFIG_STMT_SCANSTATUS]] +**
    SQLITE_DBCONFIG_STMT_SCANSTATUS
    +**
    The SQLITE_DBCONFIG_STMT_SCANSTATUS option is only useful in +** SQLITE_ENABLE_STMT_SCANSTATUS builds. In this case, it sets or clears +** a flag that enables collection of the sqlite3_stmt_scanstatus_v2() +** statistics. For statistics to be collected, the flag must be set on +** the database handle both when the SQL statement is prepared and when it +** is stepped. The flag is set (collection of statistics is enabled) +** by default. This option takes two arguments: an integer and a pointer to +** an integer.. The first argument is 1, 0, or -1 to enable, disable, or +** leave unchanged the statement scanstatus option. If the second argument +** is not NULL, then the value of the statement scanstatus setting after +** processing the first argument is written into the integer that the second +** argument points to. +**
    +** +** [[SQLITE_DBCONFIG_REVERSE_SCANORDER]] +**
    SQLITE_DBCONFIG_REVERSE_SCANORDER
    +**
    The SQLITE_DBCONFIG_REVERSE_SCANORDER option changes the default order +** in which tables and indexes are scanned so that the scans start at the end +** and work toward the beginning rather than starting at the beginning and +** working toward the end. Setting SQLITE_DBCONFIG_REVERSE_SCANORDER is the +** same as setting [PRAGMA reverse_unordered_selects]. This option takes +** two arguments which are an integer and a pointer to an integer. The first +** argument is 1, 0, or -1 to enable, disable, or leave unchanged the +** reverse scan order flag, respectively. If the second argument is not NULL, +** then 0 or 1 is written into the integer that the second argument points to +** depending on if the reverse scan order flag is set after processing the +** first argument. +**
    +** +**
    +*/ +#define SQLITE_DBCONFIG_MAINDBNAME 1000 /* const char* */ +#define SQLITE_DBCONFIG_LOOKASIDE 1001 /* void* int int */ +#define SQLITE_DBCONFIG_ENABLE_FKEY 1002 /* int int* */ +#define SQLITE_DBCONFIG_ENABLE_TRIGGER 1003 /* int int* */ +#define SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER 1004 /* int int* */ +#define SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION 1005 /* int int* */ +#define SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE 1006 /* int int* */ +#define SQLITE_DBCONFIG_ENABLE_QPSG 1007 /* int int* */ +#define SQLITE_DBCONFIG_TRIGGER_EQP 1008 /* int int* */ +#define SQLITE_DBCONFIG_RESET_DATABASE 1009 /* int int* */ +#define SQLITE_DBCONFIG_DEFENSIVE 1010 /* int int* */ +#define SQLITE_DBCONFIG_WRITABLE_SCHEMA 1011 /* int int* */ +#define SQLITE_DBCONFIG_LEGACY_ALTER_TABLE 1012 /* int int* */ +#define SQLITE_DBCONFIG_DQS_DML 1013 /* int int* */ +#define SQLITE_DBCONFIG_DQS_DDL 1014 /* int int* */ +#define SQLITE_DBCONFIG_ENABLE_VIEW 1015 /* int int* */ +#define SQLITE_DBCONFIG_LEGACY_FILE_FORMAT 1016 /* int int* */ +#define SQLITE_DBCONFIG_TRUSTED_SCHEMA 1017 /* int int* */ +#define SQLITE_DBCONFIG_STMT_SCANSTATUS 1018 /* int int* */ +#define SQLITE_DBCONFIG_REVERSE_SCANORDER 1019 /* int int* */ +#define SQLITE_DBCONFIG_MAX 1019 /* Largest DBCONFIG */ + +/* +** CAPI3REF: Enable Or Disable Extended Result Codes +** METHOD: sqlite3 +** +** ^The sqlite3_extended_result_codes() routine enables or disables the +** [extended result codes] feature of SQLite. ^The extended result +** codes are disabled by default for historical compatibility. +*/ +SQLITE_API int sqlite3_extended_result_codes(sqlite3*, int onoff); + +/* +** CAPI3REF: Last Insert Rowid +** METHOD: sqlite3 +** +** ^Each entry in most SQLite tables (except for [WITHOUT ROWID] tables) +** has a unique 64-bit signed +** integer key called the [ROWID | "rowid"]. ^The rowid is always available +** as an undeclared column named ROWID, OID, or _ROWID_ as long as those +** names are not also used by explicitly declared columns. ^If +** the table has a column of type [INTEGER PRIMARY KEY] then that column +** is another alias for the rowid. +** +** ^The sqlite3_last_insert_rowid(D) interface usually returns the [rowid] of +** the most recent successful [INSERT] into a rowid table or [virtual table] +** on database connection D. ^Inserts into [WITHOUT ROWID] tables are not +** recorded. ^If no successful [INSERT]s into rowid tables have ever occurred +** on the database connection D, then sqlite3_last_insert_rowid(D) returns +** zero. +** +** As well as being set automatically as rows are inserted into database +** tables, the value returned by this function may be set explicitly by +** [sqlite3_set_last_insert_rowid()] +** +** Some virtual table implementations may INSERT rows into rowid tables as +** part of committing a transaction (e.g. to flush data accumulated in memory +** to disk). In this case subsequent calls to this function return the rowid +** associated with these internal INSERT operations, which leads to +** unintuitive results. Virtual table implementations that do write to rowid +** tables in this way can avoid this problem by restoring the original +** rowid value using [sqlite3_set_last_insert_rowid()] before returning +** control to the user. +** +** ^(If an [INSERT] occurs within a trigger then this routine will +** return the [rowid] of the inserted row as long as the trigger is +** running. Once the trigger program ends, the value returned +** by this routine reverts to what it was before the trigger was fired.)^ +** +** ^An [INSERT] that fails due to a constraint violation is not a +** successful [INSERT] and does not change the value returned by this +** routine. ^Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK, +** and INSERT OR ABORT make no changes to the return value of this +** routine when their insertion fails. ^(When INSERT OR REPLACE +** encounters a constraint violation, it does not fail. The +** INSERT continues to completion after deleting rows that caused +** the constraint problem so INSERT OR REPLACE will always change +** the return value of this interface.)^ +** +** ^For the purposes of this routine, an [INSERT] is considered to +** be successful even if it is subsequently rolled back. +** +** This function is accessible to SQL statements via the +** [last_insert_rowid() SQL function]. +** +** If a separate thread performs a new [INSERT] on the same +** database connection while the [sqlite3_last_insert_rowid()] +** function is running and thus changes the last insert [rowid], +** then the value returned by [sqlite3_last_insert_rowid()] is +** unpredictable and might not equal either the old or the new +** last insert [rowid]. +*/ +SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*); + +/* +** CAPI3REF: Set the Last Insert Rowid value. +** METHOD: sqlite3 +** +** The sqlite3_set_last_insert_rowid(D, R) method allows the application to +** set the value returned by calling sqlite3_last_insert_rowid(D) to R +** without inserting a row into the database. +*/ +SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3*,sqlite3_int64); + +/* +** CAPI3REF: Count The Number Of Rows Modified +** METHOD: sqlite3 +** +** ^These functions return the number of rows modified, inserted or +** deleted by the most recently completed INSERT, UPDATE or DELETE +** statement on the database connection specified by the only parameter. +** The two functions are identical except for the type of the return value +** and that if the number of rows modified by the most recent INSERT, UPDATE +** or DELETE is greater than the maximum value supported by type "int", then +** the return value of sqlite3_changes() is undefined. ^Executing any other +** type of SQL statement does not modify the value returned by these functions. +** +** ^Only changes made directly by the INSERT, UPDATE or DELETE statement are +** considered - auxiliary changes caused by [CREATE TRIGGER | triggers], +** [foreign key actions] or [REPLACE] constraint resolution are not counted. +** +** Changes to a view that are intercepted by +** [INSTEAD OF trigger | INSTEAD OF triggers] are not counted. ^The value +** returned by sqlite3_changes() immediately after an INSERT, UPDATE or +** DELETE statement run on a view is always zero. Only changes made to real +** tables are counted. +** +** Things are more complicated if the sqlite3_changes() function is +** executed while a trigger program is running. This may happen if the +** program uses the [changes() SQL function], or if some other callback +** function invokes sqlite3_changes() directly. Essentially: +** +**
      +**
    • ^(Before entering a trigger program the value returned by +** sqlite3_changes() function is saved. After the trigger program +** has finished, the original value is restored.)^ +** +**
    • ^(Within a trigger program each INSERT, UPDATE and DELETE +** statement sets the value returned by sqlite3_changes() +** upon completion as normal. Of course, this value will not include +** any changes performed by sub-triggers, as the sqlite3_changes() +** value will be saved and restored after each sub-trigger has run.)^ +**
    +** +** ^This means that if the changes() SQL function (or similar) is used +** by the first INSERT, UPDATE or DELETE statement within a trigger, it +** returns the value as set when the calling statement began executing. +** ^If it is used by the second or subsequent such statement within a trigger +** program, the value returned reflects the number of rows modified by the +** previous INSERT, UPDATE or DELETE statement within the same trigger. +** +** If a separate thread makes changes on the same database connection +** while [sqlite3_changes()] is running then the value returned +** is unpredictable and not meaningful. +** +** See also: +**
      +**
    • the [sqlite3_total_changes()] interface +**
    • the [count_changes pragma] +**
    • the [changes() SQL function] +**
    • the [data_version pragma] +**
    +*/ +SQLITE_API int sqlite3_changes(sqlite3*); +SQLITE_API sqlite3_int64 sqlite3_changes64(sqlite3*); + +/* +** CAPI3REF: Total Number Of Rows Modified +** METHOD: sqlite3 +** +** ^These functions return the total number of rows inserted, modified or +** deleted by all [INSERT], [UPDATE] or [DELETE] statements completed +** since the database connection was opened, including those executed as +** part of trigger programs. The two functions are identical except for the +** type of the return value and that if the number of rows modified by the +** connection exceeds the maximum value supported by type "int", then +** the return value of sqlite3_total_changes() is undefined. ^Executing +** any other type of SQL statement does not affect the value returned by +** sqlite3_total_changes(). +** +** ^Changes made as part of [foreign key actions] are included in the +** count, but those made as part of REPLACE constraint resolution are +** not. ^Changes to a view that are intercepted by INSTEAD OF triggers +** are not counted. +** +** The [sqlite3_total_changes(D)] interface only reports the number +** of rows that changed due to SQL statement run against database +** connection D. Any changes by other database connections are ignored. +** To detect changes against a database file from other database +** connections use the [PRAGMA data_version] command or the +** [SQLITE_FCNTL_DATA_VERSION] [file control]. +** +** If a separate thread makes changes on the same database connection +** while [sqlite3_total_changes()] is running then the value +** returned is unpredictable and not meaningful. +** +** See also: +**
      +**
    • the [sqlite3_changes()] interface +**
    • the [count_changes pragma] +**
    • the [changes() SQL function] +**
    • the [data_version pragma] +**
    • the [SQLITE_FCNTL_DATA_VERSION] [file control] +**
    +*/ +SQLITE_API int sqlite3_total_changes(sqlite3*); +SQLITE_API sqlite3_int64 sqlite3_total_changes64(sqlite3*); + +/* +** CAPI3REF: Interrupt A Long-Running Query +** METHOD: sqlite3 +** +** ^This function causes any pending database operation to abort and +** return at its earliest opportunity. This routine is typically +** called in response to a user action such as pressing "Cancel" +** or Ctrl-C where the user wants a long query operation to halt +** immediately. +** +** ^It is safe to call this routine from a thread different from the +** thread that is currently running the database operation. But it +** is not safe to call this routine with a [database connection] that +** is closed or might close before sqlite3_interrupt() returns. +** +** ^If an SQL operation is very nearly finished at the time when +** sqlite3_interrupt() is called, then it might not have an opportunity +** to be interrupted and might continue to completion. +** +** ^An SQL operation that is interrupted will return [SQLITE_INTERRUPT]. +** ^If the interrupted SQL operation is an INSERT, UPDATE, or DELETE +** that is inside an explicit transaction, then the entire transaction +** will be rolled back automatically. +** +** ^The sqlite3_interrupt(D) call is in effect until all currently running +** SQL statements on [database connection] D complete. ^Any new SQL statements +** that are started after the sqlite3_interrupt() call and before the +** running statement count reaches zero are interrupted as if they had been +** running prior to the sqlite3_interrupt() call. ^New SQL statements +** that are started after the running statement count reaches zero are +** not effected by the sqlite3_interrupt(). +** ^A call to sqlite3_interrupt(D) that occurs when there are no running +** SQL statements is a no-op and has no effect on SQL statements +** that are started after the sqlite3_interrupt() call returns. +** +** ^The [sqlite3_is_interrupted(D)] interface can be used to determine whether +** or not an interrupt is currently in effect for [database connection] D. +*/ +SQLITE_API void sqlite3_interrupt(sqlite3*); +SQLITE_API int sqlite3_is_interrupted(sqlite3*); + +/* +** CAPI3REF: Determine If An SQL Statement Is Complete +** +** These routines are useful during command-line input to determine if the +** currently entered text seems to form a complete SQL statement or +** if additional input is needed before sending the text into +** SQLite for parsing. ^These routines return 1 if the input string +** appears to be a complete SQL statement. ^A statement is judged to be +** complete if it ends with a semicolon token and is not a prefix of a +** well-formed CREATE TRIGGER statement. ^Semicolons that are embedded within +** string literals or quoted identifier names or comments are not +** independent tokens (they are part of the token in which they are +** embedded) and thus do not count as a statement terminator. ^Whitespace +** and comments that follow the final semicolon are ignored. +** +** ^These routines return 0 if the statement is incomplete. ^If a +** memory allocation fails, then SQLITE_NOMEM is returned. +** +** ^These routines do not parse the SQL statements thus +** will not detect syntactically incorrect SQL. +** +** ^(If SQLite has not been initialized using [sqlite3_initialize()] prior +** to invoking sqlite3_complete16() then sqlite3_initialize() is invoked +** automatically by sqlite3_complete16(). If that initialization fails, +** then the return value from sqlite3_complete16() will be non-zero +** regardless of whether or not the input SQL is complete.)^ +** +** The input to [sqlite3_complete()] must be a zero-terminated +** UTF-8 string. +** +** The input to [sqlite3_complete16()] must be a zero-terminated +** UTF-16 string in native byte order. +*/ +SQLITE_API int sqlite3_complete(const char *sql); +SQLITE_API int sqlite3_complete16(const void *sql); + +/* +** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors +** KEYWORDS: {busy-handler callback} {busy handler} +** METHOD: sqlite3 +** +** ^The sqlite3_busy_handler(D,X,P) routine sets a callback function X +** that might be invoked with argument P whenever +** an attempt is made to access a database table associated with +** [database connection] D when another thread +** or process has the table locked. +** The sqlite3_busy_handler() interface is used to implement +** [sqlite3_busy_timeout()] and [PRAGMA busy_timeout]. +** +** ^If the busy callback is NULL, then [SQLITE_BUSY] +** is returned immediately upon encountering the lock. ^If the busy callback +** is not NULL, then the callback might be invoked with two arguments. +** +** ^The first argument to the busy handler is a copy of the void* pointer which +** is the third argument to sqlite3_busy_handler(). ^The second argument to +** the busy handler callback is the number of times that the busy handler has +** been invoked previously for the same locking event. ^If the +** busy callback returns 0, then no additional attempts are made to +** access the database and [SQLITE_BUSY] is returned +** to the application. +** ^If the callback returns non-zero, then another attempt +** is made to access the database and the cycle repeats. +** +** The presence of a busy handler does not guarantee that it will be invoked +** when there is lock contention. ^If SQLite determines that invoking the busy +** handler could result in a deadlock, it will go ahead and return [SQLITE_BUSY] +** to the application instead of invoking the +** busy handler. +** Consider a scenario where one process is holding a read lock that +** it is trying to promote to a reserved lock and +** a second process is holding a reserved lock that it is trying +** to promote to an exclusive lock. The first process cannot proceed +** because it is blocked by the second and the second process cannot +** proceed because it is blocked by the first. If both processes +** invoke the busy handlers, neither will make any progress. Therefore, +** SQLite returns [SQLITE_BUSY] for the first process, hoping that this +** will induce the first process to release its read lock and allow +** the second process to proceed. +** +** ^The default busy callback is NULL. +** +** ^(There can only be a single busy handler defined for each +** [database connection]. Setting a new busy handler clears any +** previously set handler.)^ ^Note that calling [sqlite3_busy_timeout()] +** or evaluating [PRAGMA busy_timeout=N] will change the +** busy handler and thus clear any previously set busy handler. +** +** The busy callback should not take any actions which modify the +** database connection that invoked the busy handler. In other words, +** the busy handler is not reentrant. Any such actions +** result in undefined behavior. +** +** A busy handler must not close the database connection +** or [prepared statement] that invoked the busy handler. +*/ +SQLITE_API int sqlite3_busy_handler(sqlite3*,int(*)(void*,int),void*); + +/* +** CAPI3REF: Set A Busy Timeout +** METHOD: sqlite3 +** +** ^This routine sets a [sqlite3_busy_handler | busy handler] that sleeps +** for a specified amount of time when a table is locked. ^The handler +** will sleep multiple times until at least "ms" milliseconds of sleeping +** have accumulated. ^After at least "ms" milliseconds of sleeping, +** the handler returns 0 which causes [sqlite3_step()] to return +** [SQLITE_BUSY]. +** +** ^Calling this routine with an argument less than or equal to zero +** turns off all busy handlers. +** +** ^(There can only be a single busy handler for a particular +** [database connection] at any given moment. If another busy handler +** was defined (using [sqlite3_busy_handler()]) prior to calling +** this routine, that other busy handler is cleared.)^ +** +** See also: [PRAGMA busy_timeout] +*/ +SQLITE_API int sqlite3_busy_timeout(sqlite3*, int ms); + +/* +** CAPI3REF: Convenience Routines For Running Queries +** METHOD: sqlite3 +** +** This is a legacy interface that is preserved for backwards compatibility. +** Use of this interface is not recommended. +** +** Definition: A result table is memory data structure created by the +** [sqlite3_get_table()] interface. A result table records the +** complete query results from one or more queries. +** +** The table conceptually has a number of rows and columns. But +** these numbers are not part of the result table itself. These +** numbers are obtained separately. Let N be the number of rows +** and M be the number of columns. +** +** A result table is an array of pointers to zero-terminated UTF-8 strings. +** There are (N+1)*M elements in the array. The first M pointers point +** to zero-terminated strings that contain the names of the columns. +** The remaining entries all point to query results. NULL values result +** in NULL pointers. All other values are in their UTF-8 zero-terminated +** string representation as returned by [sqlite3_column_text()]. +** +** A result table might consist of one or more memory allocations. +** It is not safe to pass a result table directly to [sqlite3_free()]. +** A result table should be deallocated using [sqlite3_free_table()]. +** +** ^(As an example of the result table format, suppose a query result +** is as follows: +** +** 
    +**        Name        | Age
+**        -----------------------
+**        Alice       | 43
+**        Bob         | 28
+**        Cindy       | 21
+**
    +** +** There are two columns (M==2) and three rows (N==3). Thus the +** result table has 8 entries. Suppose the result table is stored +** in an array named azResult. Then azResult holds this content: +** +** 
    +**        azResult[0] = "Name";
+**        azResult[1] = "Age";
+**        azResult[2] = "Alice";
+**        azResult[3] = "43";
+**        azResult[4] = "Bob";
+**        azResult[5] = "28";
+**        azResult[6] = "Cindy";
+**        azResult[7] = "21";
+**
    )^ +** +** ^The sqlite3_get_table() function evaluates one or more +** semicolon-separated SQL statements in the zero-terminated UTF-8 +** string of its 2nd parameter and returns a result table to the +** pointer given in its 3rd parameter. +** +** After the application has finished with the result from sqlite3_get_table(), +** it must pass the result table pointer to sqlite3_free_table() in order to +** release the memory that was malloced. Because of the way the +** [sqlite3_malloc()] happens within sqlite3_get_table(), the calling +** function must not try to call [sqlite3_free()] directly. Only +** [sqlite3_free_table()] is able to release the memory properly and safely. +** +** The sqlite3_get_table() interface is implemented as a wrapper around +** [sqlite3_exec()]. The sqlite3_get_table() routine does not have access +** to any internal data structures of SQLite. It uses only the public +** interface defined here. As a consequence, errors that occur in the +** wrapper layer outside of the internal [sqlite3_exec()] call are not +** reflected in subsequent calls to [sqlite3_errcode()] or +** [sqlite3_errmsg()]. +*/ +SQLITE_API int sqlite3_get_table( + sqlite3 *db, /* An open database */ + const char *zSql, /* SQL to be evaluated */ + char ***pazResult, /* Results of the query */ + int *pnRow, /* Number of result rows written here */ + int *pnColumn, /* Number of result columns written here */ + char **pzErrmsg /* Error msg written here */ +); +SQLITE_API void sqlite3_free_table(char **result); + +/* +** CAPI3REF: Formatted String Printing Functions +** +** These routines are work-alikes of the "printf()" family of functions +** from the standard C library. +** These routines understand most of the common formatting options from +** the standard library printf() +** plus some additional non-standard formats ([%q], [%Q], [%w], and [%z]). +** See the [built-in printf()] documentation for details. +** +** ^The sqlite3_mprintf() and sqlite3_vmprintf() routines write their +** results into memory obtained from [sqlite3_malloc64()]. +** The strings returned by these two routines should be +** released by [sqlite3_free()]. ^Both routines return a +** NULL pointer if [sqlite3_malloc64()] is unable to allocate enough +** memory to hold the resulting string. +** +** ^(The sqlite3_snprintf() routine is similar to "snprintf()" from +** the standard C library. The result is written into the +** buffer supplied as the second parameter whose size is given by +** the first parameter. Note that the order of the +** first two parameters is reversed from snprintf().)^ This is an +** historical accident that cannot be fixed without breaking +** backwards compatibility. ^(Note also that sqlite3_snprintf() +** returns a pointer to its buffer instead of the number of +** characters actually written into the buffer.)^ We admit that +** the number of characters written would be a more useful return +** value but we cannot change the implementation of sqlite3_snprintf() +** now without breaking compatibility. +** +** ^As long as the buffer size is greater than zero, sqlite3_snprintf() +** guarantees that the buffer is always zero-terminated. ^The first +** parameter "n" is the total size of the buffer, including space for +** the zero terminator. So the longest string that can be completely +** written will be n-1 characters. +** +** ^The sqlite3_vsnprintf() routine is a varargs version of sqlite3_snprintf(). +** +** See also: [built-in printf()], [printf() SQL function] +*/ +SQLITE_API char *sqlite3_mprintf(const char*,...); +SQLITE_API char *sqlite3_vmprintf(const char*, va_list); +SQLITE_API char *sqlite3_snprintf(int,char*,const char*, ...); +SQLITE_API char *sqlite3_vsnprintf(int,char*,const char*, va_list); + +/* +** CAPI3REF: Memory Allocation Subsystem +** +** The SQLite core uses these three routines for all of its own +** internal memory allocation needs. "Core" in the previous sentence +** does not include operating-system specific [VFS] implementation. The +** Windows VFS uses native malloc() and free() for some operations. +** +** ^The sqlite3_malloc() routine returns a pointer to a block +** of memory at least N bytes in length, where N is the parameter. +** ^If sqlite3_malloc() is unable to obtain sufficient free +** memory, it returns a NULL pointer. ^If the parameter N to +** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns +** a NULL pointer. +** +** ^The sqlite3_malloc64(N) routine works just like +** sqlite3_malloc(N) except that N is an unsigned 64-bit integer instead +** of a signed 32-bit integer. +** +** ^Calling sqlite3_free() with a pointer previously returned +** by sqlite3_malloc() or sqlite3_realloc() releases that memory so +** that it might be reused. ^The sqlite3_free() routine is +** a no-op if is called with a NULL pointer. Passing a NULL pointer +** to sqlite3_free() is harmless. After being freed, memory +** should neither be read nor written. Even reading previously freed +** memory might result in a segmentation fault or other severe error. +** Memory corruption, a segmentation fault, or other severe error +** might result if sqlite3_free() is called with a non-NULL pointer that +** was not obtained from sqlite3_malloc() or sqlite3_realloc(). +** +** ^The sqlite3_realloc(X,N) interface attempts to resize a +** prior memory allocation X to be at least N bytes. +** ^If the X parameter to sqlite3_realloc(X,N) +** is a NULL pointer then its behavior is identical to calling +** sqlite3_malloc(N). +** ^If the N parameter to sqlite3_realloc(X,N) is zero or +** negative then the behavior is exactly the same as calling +** sqlite3_free(X). +** ^sqlite3_realloc(X,N) returns a pointer to a memory allocation +** of at least N bytes in size or NULL if insufficient memory is available. +** ^If M is the size of the prior allocation, then min(N,M) bytes +** of the prior allocation are copied into the beginning of buffer returned +** by sqlite3_realloc(X,N) and the prior allocation is freed. +** ^If sqlite3_realloc(X,N) returns NULL and N is positive, then the +** prior allocation is not freed. +** +** ^The sqlite3_realloc64(X,N) interfaces works the same as +** sqlite3_realloc(X,N) except that N is a 64-bit unsigned integer instead +** of a 32-bit signed integer. +** +** ^If X is a memory allocation previously obtained from sqlite3_malloc(), +** sqlite3_malloc64(), sqlite3_realloc(), or sqlite3_realloc64(), then +** sqlite3_msize(X) returns the size of that memory allocation in bytes. +** ^The value returned by sqlite3_msize(X) might be larger than the number +** of bytes requested when X was allocated. ^If X is a NULL pointer then +** sqlite3_msize(X) returns zero. If X points to something that is not +** the beginning of memory allocation, or if it points to a formerly +** valid memory allocation that has now been freed, then the behavior +** of sqlite3_msize(X) is undefined and possibly harmful. +** +** ^The memory returned by sqlite3_malloc(), sqlite3_realloc(), +** sqlite3_malloc64(), and sqlite3_realloc64() +** is always aligned to at least an 8 byte boundary, or to a +** 4 byte boundary if the [SQLITE_4_BYTE_ALIGNED_MALLOC] compile-time +** option is used. +** +** The pointer arguments to [sqlite3_free()] and [sqlite3_realloc()] +** must be either NULL or else pointers obtained from a prior +** invocation of [sqlite3_malloc()] or [sqlite3_realloc()] that have +** not yet been released. +** +** The application must not read or write any part of +** a block of memory after it has been released using +** [sqlite3_free()] or [sqlite3_realloc()]. +*/ +SQLITE_API void *sqlite3_malloc(int); +SQLITE_API void *sqlite3_malloc64(sqlite3_uint64); +SQLITE_API void *sqlite3_realloc(void*, int); +SQLITE_API void *sqlite3_realloc64(void*, sqlite3_uint64); +SQLITE_API void sqlite3_free(void*); +SQLITE_API sqlite3_uint64 sqlite3_msize(void*); + +/* +** CAPI3REF: Memory Allocator Statistics +** +** SQLite provides these two interfaces for reporting on the status +** of the [sqlite3_malloc()], [sqlite3_free()], and [sqlite3_realloc()] +** routines, which form the built-in memory allocation subsystem. +** +** ^The [sqlite3_memory_used()] routine returns the number of bytes +** of memory currently outstanding (malloced but not freed). +** ^The [sqlite3_memory_highwater()] routine returns the maximum +** value of [sqlite3_memory_used()] since the high-water mark +** was last reset. ^The values returned by [sqlite3_memory_used()] and +** [sqlite3_memory_highwater()] include any overhead +** added by SQLite in its implementation of [sqlite3_malloc()], +** but not overhead added by the any underlying system library +** routines that [sqlite3_malloc()] may call. +** +** ^The memory high-water mark is reset to the current value of +** [sqlite3_memory_used()] if and only if the parameter to +** [sqlite3_memory_highwater()] is true. ^The value returned +** by [sqlite3_memory_highwater(1)] is the high-water mark +** prior to the reset. +*/ +SQLITE_API sqlite3_int64 sqlite3_memory_used(void); +SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag); + +/* +** CAPI3REF: Pseudo-Random Number Generator +** +** SQLite contains a high-quality pseudo-random number generator (PRNG) used to +** select random [ROWID | ROWIDs] when inserting new records into a table that +** already uses the largest possible [ROWID]. The PRNG is also used for +** the built-in random() and randomblob() SQL functions. This interface allows +** applications to access the same PRNG for other purposes. +** +** ^A call to this routine stores N bytes of randomness into buffer P. +** ^The P parameter can be a NULL pointer. +** +** ^If this routine has not been previously called or if the previous +** call had N less than one or a NULL pointer for P, then the PRNG is +** seeded using randomness obtained from the xRandomness method of +** the default [sqlite3_vfs] object. +** ^If the previous call to this routine had an N of 1 or more and a +** non-NULL P then the pseudo-randomness is generated +** internally and without recourse to the [sqlite3_vfs] xRandomness +** method. +*/ +SQLITE_API void sqlite3_randomness(int N, void *P); + +/* +** CAPI3REF: Compile-Time Authorization Callbacks +** METHOD: sqlite3 +** KEYWORDS: {authorizer callback} +** +** ^This routine registers an authorizer callback with a particular +** [database connection], supplied in the first argument. +** ^The authorizer callback is invoked as SQL statements are being compiled +** by [sqlite3_prepare()] or its variants [sqlite3_prepare_v2()], +** [sqlite3_prepare_v3()], [sqlite3_prepare16()], [sqlite3_prepare16_v2()], +** and [sqlite3_prepare16_v3()]. ^At various +** points during the compilation process, as logic is being created +** to perform various actions, the authorizer callback is invoked to +** see if those actions are allowed. ^The authorizer callback should +** return [SQLITE_OK] to allow the action, [SQLITE_IGNORE] to disallow the +** specific action but allow the SQL statement to continue to be +** compiled, or [SQLITE_DENY] to cause the entire SQL statement to be +** rejected with an error. ^If the authorizer callback returns +** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY] +** then the [sqlite3_prepare_v2()] or equivalent call that triggered +** the authorizer will fail with an error message. +** +** When the callback returns [SQLITE_OK], that means the operation +** requested is ok. ^When the callback returns [SQLITE_DENY], the +** [sqlite3_prepare_v2()] or equivalent call that triggered the +** authorizer will fail with an error message explaining that +** access is denied. +** +** ^The first parameter to the authorizer callback is a copy of the third +** parameter to the sqlite3_set_authorizer() interface. ^The second parameter +** to the callback is an integer [SQLITE_COPY | action code] that specifies +** the particular action to be authorized. ^The third through sixth parameters +** to the callback are either NULL pointers or zero-terminated strings +** that contain additional details about the action to be authorized. +** Applications must always be prepared to encounter a NULL pointer in any +** of the third through the sixth parameters of the authorization callback. +** +** ^If the action code is [SQLITE_READ] +** and the callback returns [SQLITE_IGNORE] then the +** [prepared statement] statement is constructed to substitute +** a NULL value in place of the table column that would have +** been read if [SQLITE_OK] had been returned. The [SQLITE_IGNORE] +** return can be used to deny an untrusted user access to individual +** columns of a table. +** ^When a table is referenced by a [SELECT] but no column values are +** extracted from that table (for example in a query like +** "SELECT count(*) FROM tab") then the [SQLITE_READ] authorizer callback +** is invoked once for that table with a column name that is an empty string. +** ^If the action code is [SQLITE_DELETE] and the callback returns +** [SQLITE_IGNORE] then the [DELETE] operation proceeds but the +** [truncate optimization] is disabled and all rows are deleted individually. +** +** An authorizer is used when [sqlite3_prepare | preparing] +** SQL statements from an untrusted source, to ensure that the SQL statements +** do not try to access data they are not allowed to see, or that they do not +** try to execute malicious statements that damage the database. For +** example, an application may allow a user to enter arbitrary +** SQL queries for evaluation by a database. But the application does +** not want the user to be able to make arbitrary changes to the +** database. An authorizer could then be put in place while the +** user-entered SQL is being [sqlite3_prepare | prepared] that +** disallows everything except [SELECT] statements. +** +** Applications that need to process SQL from untrusted sources +** might also consider lowering resource limits using [sqlite3_limit()] +** and limiting database size using the [max_page_count] [PRAGMA] +** in addition to using an authorizer. +** +** ^(Only a single authorizer can be in place on a database connection +** at a time. Each call to sqlite3_set_authorizer overrides the +** previous call.)^ ^Disable the authorizer by installing a NULL callback. +** The authorizer is disabled by default. +** +** The authorizer callback must not do anything that will modify +** the database connection that invoked the authorizer callback. +** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their +** database connections for the meaning of "modify" in this paragraph. +** +** ^When [sqlite3_prepare_v2()] is used to prepare a statement, the +** statement might be re-prepared during [sqlite3_step()] due to a +** schema change. Hence, the application should ensure that the +** correct authorizer callback remains in place during the [sqlite3_step()]. +** +** ^Note that the authorizer callback is invoked only during +** [sqlite3_prepare()] or its variants. Authorization is not +** performed during statement evaluation in [sqlite3_step()], unless +** as stated in the previous paragraph, sqlite3_step() invokes +** sqlite3_prepare_v2() to reprepare a statement after a schema change. +*/ +SQLITE_API int sqlite3_set_authorizer( + sqlite3*, + int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), + void *pUserData +); + +/* +** CAPI3REF: Authorizer Return Codes +** +** The [sqlite3_set_authorizer | authorizer callback function] must +** return either [SQLITE_OK] or one of these two constants in order +** to signal SQLite whether or not the action is permitted. See the +** [sqlite3_set_authorizer | authorizer documentation] for additional +** information. +** +** Note that SQLITE_IGNORE is also used as a [conflict resolution mode] +** returned from the [sqlite3_vtab_on_conflict()] interface. +*/ +#define SQLITE_DENY 1 /* Abort the SQL statement with an error */ +#define SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */ + +/* +** CAPI3REF: Authorizer Action Codes +** +** The [sqlite3_set_authorizer()] interface registers a callback function +** that is invoked to authorize certain SQL statement actions. The +** second parameter to the callback is an integer code that specifies +** what action is being authorized. These are the integer action codes that +** the authorizer callback may be passed. +** +** These action code values signify what kind of operation is to be +** authorized. The 3rd and 4th parameters to the authorization +** callback function will be parameters or NULL depending on which of these +** codes is used as the second parameter. ^(The 5th parameter to the +** authorizer callback is the name of the database ("main", "temp", +** etc.) if applicable.)^ ^The 6th parameter to the authorizer callback +** is the name of the inner-most trigger or view that is responsible for +** the access attempt or NULL if this access attempt is directly from +** top-level SQL code. +*/ +/******************************************* 3rd ************ 4th ***********/ +#define SQLITE_CREATE_INDEX 1 /* Index Name Table Name */ +#define SQLITE_CREATE_TABLE 2 /* Table Name NULL */ +#define SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */ +#define SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */ +#define SQLITE_CREATE_TEMP_TRIGGER 5 /* Trigger Name Table Name */ +#define SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */ +#define SQLITE_CREATE_TRIGGER 7 /* Trigger Name Table Name */ +#define SQLITE_CREATE_VIEW 8 /* View Name NULL */ +#define SQLITE_DELETE 9 /* Table Name NULL */ +#define SQLITE_DROP_INDEX 10 /* Index Name Table Name */ +#define SQLITE_DROP_TABLE 11 /* Table Name NULL */ +#define SQLITE_DROP_TEMP_INDEX 12 /* Index Name Table Name */ +#define SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */ +#define SQLITE_DROP_TEMP_TRIGGER 14 /* Trigger Name Table Name */ +#define SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */ +#define SQLITE_DROP_TRIGGER 16 /* Trigger Name Table Name */ +#define SQLITE_DROP_VIEW 17 /* View Name NULL */ +#define SQLITE_INSERT 18 /* Table Name NULL */ +#define SQLITE_PRAGMA 19 /* Pragma Name 1st arg or NULL */ +#define SQLITE_READ 20 /* Table Name Column Name */ +#define SQLITE_SELECT 21 /* NULL NULL */ +#define SQLITE_TRANSACTION 22 /* Operation NULL */ +#define SQLITE_UPDATE 23 /* Table Name Column Name */ +#define SQLITE_ATTACH 24 /* Filename NULL */ +#define SQLITE_DETACH 25 /* Database Name NULL */ +#define SQLITE_ALTER_TABLE 26 /* Database Name Table Name */ +#define SQLITE_REINDEX 27 /* Index Name NULL */ +#define SQLITE_ANALYZE 28 /* Table Name NULL */ +#define SQLITE_CREATE_VTABLE 29 /* Table Name Module Name */ +#define SQLITE_DROP_VTABLE 30 /* Table Name Module Name */ +#define SQLITE_FUNCTION 31 /* NULL Function Name */ +#define SQLITE_SAVEPOINT 32 /* Operation Savepoint Name */ +#define SQLITE_COPY 0 /* No longer used */ +#define SQLITE_RECURSIVE 33 /* NULL NULL */ + +/* +** CAPI3REF: Tracing And Profiling Functions +** METHOD: sqlite3 +** +** These routines are deprecated. Use the [sqlite3_trace_v2()] interface +** instead of the routines described here. +** +** These routines register callback functions that can be used for +** tracing and profiling the execution of SQL statements. +** +** ^The callback function registered by sqlite3_trace() is invoked at +** various times when an SQL statement is being run by [sqlite3_step()]. +** ^The sqlite3_trace() callback is invoked with a UTF-8 rendering of the +** SQL statement text as the statement first begins executing. +** ^(Additional sqlite3_trace() callbacks might occur +** as each triggered subprogram is entered. The callbacks for triggers +** contain a UTF-8 SQL comment that identifies the trigger.)^ +** +** The [SQLITE_TRACE_SIZE_LIMIT] compile-time option can be used to limit +** the length of [bound parameter] expansion in the output of sqlite3_trace(). +** +** ^The callback function registered by sqlite3_profile() is invoked +** as each SQL statement finishes. ^The profile callback contains +** the original statement text and an estimate of wall-clock time +** of how long that statement took to run. ^The profile callback +** time is in units of nanoseconds, however the current implementation +** is only capable of millisecond resolution so the six least significant +** digits in the time are meaningless. Future versions of SQLite +** might provide greater resolution on the profiler callback. Invoking +** either [sqlite3_trace()] or [sqlite3_trace_v2()] will cancel the +** profile callback. +*/ +SQLITE_API SQLITE_DEPRECATED void *sqlite3_trace(sqlite3*, + void(*xTrace)(void*,const char*), void*); +SQLITE_API SQLITE_DEPRECATED void *sqlite3_profile(sqlite3*, + void(*xProfile)(void*,const char*,sqlite3_uint64), void*); + +/* +** CAPI3REF: SQL Trace Event Codes +** KEYWORDS: SQLITE_TRACE +** +** These constants identify classes of events that can be monitored +** using the [sqlite3_trace_v2()] tracing logic. The M argument +** to [sqlite3_trace_v2(D,M,X,P)] is an OR-ed combination of one or more of +** the following constants. ^The first argument to the trace callback +** is one of the following constants. +** +** New tracing constants may be added in future releases. +** +** ^A trace callback has four arguments: xCallback(T,C,P,X). +** ^The T argument is one of the integer type codes above. +** ^The C argument is a copy of the context pointer passed in as the +** fourth argument to [sqlite3_trace_v2()]. +** The P and X arguments are pointers whose meanings depend on T. +** +**
    +** [[SQLITE_TRACE_STMT]]
    SQLITE_TRACE_STMT
    +**
    ^An SQLITE_TRACE_STMT callback is invoked when a prepared statement +** first begins running and possibly at other times during the +** execution of the prepared statement, such as at the start of each +** trigger subprogram. ^The P argument is a pointer to the +** [prepared statement]. ^The X argument is a pointer to a string which +** is the unexpanded SQL text of the prepared statement or an SQL comment +** that indicates the invocation of a trigger. ^The callback can compute +** the same text that would have been returned by the legacy [sqlite3_trace()] +** interface by using the X argument when X begins with "--" and invoking +** [sqlite3_expanded_sql(P)] otherwise. +** +** [[SQLITE_TRACE_PROFILE]]
    SQLITE_TRACE_PROFILE
    +**
    ^An SQLITE_TRACE_PROFILE callback provides approximately the same +** information as is provided by the [sqlite3_profile()] callback. +** ^The P argument is a pointer to the [prepared statement] and the +** X argument points to a 64-bit integer which is approximately +** the number of nanoseconds that the prepared statement took to run. +** ^The SQLITE_TRACE_PROFILE callback is invoked when the statement finishes. +** +** [[SQLITE_TRACE_ROW]]
    SQLITE_TRACE_ROW
    +**
    ^An SQLITE_TRACE_ROW callback is invoked whenever a prepared +** statement generates a single row of result. +** ^The P argument is a pointer to the [prepared statement] and the +** X argument is unused. +** +** [[SQLITE_TRACE_CLOSE]]
    SQLITE_TRACE_CLOSE
    +**
    ^An SQLITE_TRACE_CLOSE callback is invoked when a database +** connection closes. +** ^The P argument is a pointer to the [database connection] object +** and the X argument is unused. +**
    +*/ +#define SQLITE_TRACE_STMT 0x01 +#define SQLITE_TRACE_PROFILE 0x02 +#define SQLITE_TRACE_ROW 0x04 +#define SQLITE_TRACE_CLOSE 0x08 + +/* +** CAPI3REF: SQL Trace Hook +** METHOD: sqlite3 +** +** ^The sqlite3_trace_v2(D,M,X,P) interface registers a trace callback +** function X against [database connection] D, using property mask M +** and context pointer P. ^If the X callback is +** NULL or if the M mask is zero, then tracing is disabled. The +** M argument should be the bitwise OR-ed combination of +** zero or more [SQLITE_TRACE] constants. +** +** ^Each call to either sqlite3_trace() or sqlite3_trace_v2() overrides +** (cancels) any prior calls to sqlite3_trace() or sqlite3_trace_v2(). +** +** ^The X callback is invoked whenever any of the events identified by +** mask M occur. ^The integer return value from the callback is currently +** ignored, though this may change in future releases. Callback +** implementations should return zero to ensure future compatibility. +** +** ^A trace callback is invoked with four arguments: callback(T,C,P,X). +** ^The T argument is one of the [SQLITE_TRACE] +** constants to indicate why the callback was invoked. +** ^The C argument is a copy of the context pointer. +** The P and X arguments are pointers whose meanings depend on T. +** +** The sqlite3_trace_v2() interface is intended to replace the legacy +** interfaces [sqlite3_trace()] and [sqlite3_profile()], both of which +** are deprecated. +*/ +SQLITE_API int sqlite3_trace_v2( + sqlite3*, + unsigned uMask, + int(*xCallback)(unsigned,void*,void*,void*), + void *pCtx +); + +/* +** CAPI3REF: Query Progress Callbacks +** METHOD: sqlite3 +** +** ^The sqlite3_progress_handler(D,N,X,P) interface causes the callback +** function X to be invoked periodically during long running calls to +** [sqlite3_step()] and [sqlite3_prepare()] and similar for +** database connection D. An example use for this +** interface is to keep a GUI updated during a large query. +** +** ^The parameter P is passed through as the only parameter to the +** callback function X. ^The parameter N is the approximate number of +** [virtual machine instructions] that are evaluated between successive +** invocations of the callback X. ^If N is less than one then the progress +** handler is disabled. +** +** ^Only a single progress handler may be defined at one time per +** [database connection]; setting a new progress handler cancels the +** old one. ^Setting parameter X to NULL disables the progress handler. +** ^The progress handler is also disabled by setting N to a value less +** than 1. +** +** ^If the progress callback returns non-zero, the operation is +** interrupted. This feature can be used to implement a +** "Cancel" button on a GUI progress dialog box. +** +** The progress handler callback must not do anything that will modify +** the database connection that invoked the progress handler. +** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their +** database connections for the meaning of "modify" in this paragraph. +** +** The progress handler callback would originally only be invoked from the +** bytecode engine. It still might be invoked during [sqlite3_prepare()] +** and similar because those routines might force a reparse of the schema +** which involves running the bytecode engine. However, beginning with +** SQLite version 3.41.0, the progress handler callback might also be +** invoked directly from [sqlite3_prepare()] while analyzing and generating +** code for complex queries. +*/ +SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*); + +/* +** CAPI3REF: Opening A New Database Connection +** CONSTRUCTOR: sqlite3 +** +** ^These routines open an SQLite database file as specified by the +** filename argument. ^The filename argument is interpreted as UTF-8 for +** sqlite3_open() and sqlite3_open_v2() and as UTF-16 in the native byte +** order for sqlite3_open16(). ^(A [database connection] handle is usually +** returned in *ppDb, even if an error occurs. The only exception is that +** if SQLite is unable to allocate memory to hold the [sqlite3] object, +** a NULL will be written into *ppDb instead of a pointer to the [sqlite3] +** object.)^ ^(If the database is opened (and/or created) successfully, then +** [SQLITE_OK] is returned. Otherwise an [error code] is returned.)^ ^The +** [sqlite3_errmsg()] or [sqlite3_errmsg16()] routines can be used to obtain +** an English language description of the error following a failure of any +** of the sqlite3_open() routines. +** +** ^The default encoding will be UTF-8 for databases created using +** sqlite3_open() or sqlite3_open_v2(). ^The default encoding for databases +** created using sqlite3_open16() will be UTF-16 in the native byte order. +** +** Whether or not an error occurs when it is opened, resources +** associated with the [database connection] handle should be released by +** passing it to [sqlite3_close()] when it is no longer required. +** +** The sqlite3_open_v2() interface works like sqlite3_open() +** except that it accepts two additional parameters for additional control +** over the new database connection. ^(The flags parameter to +** sqlite3_open_v2() must include, at a minimum, one of the following +** three flag combinations:)^ +** +**
    +** ^(
    [SQLITE_OPEN_READONLY]
    +**
    The database is opened in read-only mode. If the database does +** not already exist, an error is returned.
    )^ +** +** ^(
    [SQLITE_OPEN_READWRITE]
    +**
    The database is opened for reading and writing if possible, or +** reading only if the file is write protected by the operating +** system. In either case the database must already exist, otherwise +** an error is returned. For historical reasons, if opening in +** read-write mode fails due to OS-level permissions, an attempt is +** made to open it in read-only mode. [sqlite3_db_readonly()] can be +** used to determine whether the database is actually +** read-write.
    )^ +** +** ^(
    [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]
    +**
    The database is opened for reading and writing, and is created if +** it does not already exist. This is the behavior that is always used for +** sqlite3_open() and sqlite3_open16().
    )^ +**
    +** +** In addition to the required flags, the following optional flags are +** also supported: +** +**
    +** ^(
    [SQLITE_OPEN_URI]
    +**
    The filename can be interpreted as a URI if this flag is set.
    )^ +** +** ^(
    [SQLITE_OPEN_MEMORY]
    +**
    The database will be opened as an in-memory database. The database +** is named by the "filename" argument for the purposes of cache-sharing, +** if shared cache mode is enabled, but the "filename" is otherwise ignored. +**
    )^ +** +** ^(
    [SQLITE_OPEN_NOMUTEX]
    +**
    The new database connection will use the "multi-thread" +** [threading mode].)^ This means that separate threads are allowed +** to use SQLite at the same time, as long as each thread is using +** a different [database connection]. +** +** ^(
    [SQLITE_OPEN_FULLMUTEX]
    +**
    The new database connection will use the "serialized" +** [threading mode].)^ This means the multiple threads can safely +** attempt to use the same database connection at the same time. +** (Mutexes will block any actual concurrency, but in this mode +** there is no harm in trying.) +** +** ^(
    [SQLITE_OPEN_SHAREDCACHE]
    +**
    The database is opened [shared cache] enabled, overriding +** the default shared cache setting provided by +** [sqlite3_enable_shared_cache()].)^ +** The [use of shared cache mode is discouraged] and hence shared cache +** capabilities may be omitted from many builds of SQLite. In such cases, +** this option is a no-op. +** +** ^(
    [SQLITE_OPEN_PRIVATECACHE]
    +**
    The database is opened [shared cache] disabled, overriding +** the default shared cache setting provided by +** [sqlite3_enable_shared_cache()].)^ +** +** [[OPEN_EXRESCODE]] ^(
    [SQLITE_OPEN_EXRESCODE]
    +**
    The database connection comes up in "extended result code mode". +** In other words, the database behaves has if +** [sqlite3_extended_result_codes(db,1)] where called on the database +** connection as soon as the connection is created. In addition to setting +** the extended result code mode, this flag also causes [sqlite3_open_v2()] +** to return an extended result code.
    +** +** [[OPEN_NOFOLLOW]] ^(
    [SQLITE_OPEN_NOFOLLOW]
    +**
    The database filename is not allowed to contain a symbolic link
    +**
    )^ +** +** If the 3rd parameter to sqlite3_open_v2() is not one of the +** required combinations shown above optionally combined with other +** [SQLITE_OPEN_READONLY | SQLITE_OPEN_* bits] +** then the behavior is undefined. Historic versions of SQLite +** have silently ignored surplus bits in the flags parameter to +** sqlite3_open_v2(), however that behavior might not be carried through +** into future versions of SQLite and so applications should not rely +** upon it. Note in particular that the SQLITE_OPEN_EXCLUSIVE flag is a no-op +** for sqlite3_open_v2(). The SQLITE_OPEN_EXCLUSIVE does *not* cause +** the open to fail if the database already exists. The SQLITE_OPEN_EXCLUSIVE +** flag is intended for use by the [sqlite3_vfs|VFS interface] only, and not +** by sqlite3_open_v2(). +** +** ^The fourth parameter to sqlite3_open_v2() is the name of the +** [sqlite3_vfs] object that defines the operating system interface that +** the new database connection should use. ^If the fourth parameter is +** a NULL pointer then the default [sqlite3_vfs] object is used. +** +** ^If the filename is ":memory:", then a private, temporary in-memory database +** is created for the connection. ^This in-memory database will vanish when +** the database connection is closed. Future versions of SQLite might +** make use of additional special filenames that begin with the ":" character. +** It is recommended that when a database filename actually does begin with +** a ":" character you should prefix the filename with a pathname such as +** "./" to avoid ambiguity. +** +** ^If the filename is an empty string, then a private, temporary +** on-disk database will be created. ^This private database will be +** automatically deleted as soon as the database connection is closed. +** +** [[URI filenames in sqlite3_open()]]

    URI Filenames

    +** +** ^If [URI filename] interpretation is enabled, and the filename argument +** begins with "file:", then the filename is interpreted as a URI. ^URI +** filename interpretation is enabled if the [SQLITE_OPEN_URI] flag is +** set in the third argument to sqlite3_open_v2(), or if it has +** been enabled globally using the [SQLITE_CONFIG_URI] option with the +** [sqlite3_config()] method or by the [SQLITE_USE_URI] compile-time option. +** URI filename interpretation is turned off +** by default, but future releases of SQLite might enable URI filename +** interpretation by default. See "[URI filenames]" for additional +** information. +** +** URI filenames are parsed according to RFC 3986. ^If the URI contains an +** authority, then it must be either an empty string or the string +** "localhost". ^If the authority is not an empty string or "localhost", an +** error is returned to the caller. ^The fragment component of a URI, if +** present, is ignored. +** +** ^SQLite uses the path component of the URI as the name of the disk file +** which contains the database. ^If the path begins with a '/' character, +** then it is interpreted as an absolute path. ^If the path does not begin +** with a '/' (meaning that the authority section is omitted from the URI) +** then the path is interpreted as a relative path. +** ^(On windows, the first component of an absolute path +** is a drive specification (e.g. "C:").)^ +** +** [[core URI query parameters]] +** The query component of a URI may contain parameters that are interpreted +** either by SQLite itself, or by a [VFS | custom VFS implementation]. +** SQLite and its built-in [VFSes] interpret the +** following query parameters: +** +**
      +**
    • vfs: ^The "vfs" parameter may be used to specify the name of +** a VFS object that provides the operating system interface that should +** be used to access the database file on disk. ^If this option is set to +** an empty string the default VFS object is used. ^Specifying an unknown +** VFS is an error. ^If sqlite3_open_v2() is used and the vfs option is +** present, then the VFS specified by the option takes precedence over +** the value passed as the fourth parameter to sqlite3_open_v2(). +** +**
    • mode: ^(The mode parameter may be set to either "ro", "rw", +** "rwc", or "memory". Attempting to set it to any other value is +** an error)^. +** ^If "ro" is specified, then the database is opened for read-only +** access, just as if the [SQLITE_OPEN_READONLY] flag had been set in the +** third argument to sqlite3_open_v2(). ^If the mode option is set to +** "rw", then the database is opened for read-write (but not create) +** access, as if SQLITE_OPEN_READWRITE (but not SQLITE_OPEN_CREATE) had +** been set. ^Value "rwc" is equivalent to setting both +** SQLITE_OPEN_READWRITE and SQLITE_OPEN_CREATE. ^If the mode option is +** set to "memory" then a pure [in-memory database] that never reads +** or writes from disk is used. ^It is an error to specify a value for +** the mode parameter that is less restrictive than that specified by +** the flags passed in the third parameter to sqlite3_open_v2(). +** +**
    • cache: ^The cache parameter may be set to either "shared" or +** "private". ^Setting it to "shared" is equivalent to setting the +** SQLITE_OPEN_SHAREDCACHE bit in the flags argument passed to +** sqlite3_open_v2(). ^Setting the cache parameter to "private" is +** equivalent to setting the SQLITE_OPEN_PRIVATECACHE bit. +** ^If sqlite3_open_v2() is used and the "cache" parameter is present in +** a URI filename, its value overrides any behavior requested by setting +** SQLITE_OPEN_PRIVATECACHE or SQLITE_OPEN_SHAREDCACHE flag. +** +**
    • psow: ^The psow parameter indicates whether or not the +** [powersafe overwrite] property does or does not apply to the +** storage media on which the database file resides. +** +**
    • nolock: ^The nolock parameter is a boolean query parameter +** which if set disables file locking in rollback journal modes. This +** is useful for accessing a database on a filesystem that does not +** support locking. Caution: Database corruption might result if two +** or more processes write to the same database and any one of those +** processes uses nolock=1. +** +**
    • immutable: ^The immutable parameter is a boolean query +** parameter that indicates that the database file is stored on +** read-only media. ^When immutable is set, SQLite assumes that the +** database file cannot be changed, even by a process with higher +** privilege, and so the database is opened read-only and all locking +** and change detection is disabled. Caution: Setting the immutable +** property on a database file that does in fact change can result +** in incorrect query results and/or [SQLITE_CORRUPT] errors. +** See also: [SQLITE_IOCAP_IMMUTABLE]. +** +**
    +** +** ^Specifying an unknown parameter in the query component of a URI is not an +** error. Future versions of SQLite might understand additional query +** parameters. See "[query parameters with special meaning to SQLite]" for +** additional information. +** +** [[URI filename examples]]

    URI filename examples

    +** +** +**
    URI filenames Results +**
    file:data.db +** Open the file "data.db" in the current directory. +**
    file:/home/fred/data.db
    +** file:///home/fred/data.db
    +** file://localhost/home/fred/data.db
    		+** Open the database file "/home/fred/data.db". +**
    file://darkstar/home/fred/data.db +** An error. "darkstar" is not a recognized authority. +**
    +** file:///C:/Documents%20and%20Settings/fred/Desktop/data.db +** Windows only: Open the file "data.db" on fred's desktop on drive +** C:. Note that the %20 escaping in this example is not strictly +** necessary - space characters can be used literally +** in URI filenames. +**
    file:data.db?mode=ro&cache=private +** Open file "data.db" in the current directory for read-only access. +** Regardless of whether or not shared-cache mode is enabled by +** default, use a private cache. +**
    file:/home/fred/data.db?vfs=unix-dotfile +** Open file "/home/fred/data.db". Use the special VFS "unix-dotfile" +** that uses dot-files in place of posix advisory locking. +**
    file:data.db?mode=readonly +** An error. "readonly" is not a valid option for the "mode" parameter. +** Use "ro" instead: "file:data.db?mode=ro". +**
    +** +** ^URI hexadecimal escape sequences (%HH) are supported within the path and +** query components of a URI. A hexadecimal escape sequence consists of a +** percent sign - "%" - followed by exactly two hexadecimal digits +** specifying an octet value. ^Before the path or query components of a +** URI filename are interpreted, they are encoded using UTF-8 and all +** hexadecimal escape sequences replaced by a single byte containing the +** corresponding octet. If this process generates an invalid UTF-8 encoding, +** the results are undefined. +** +** Note to Windows users: The encoding used for the filename argument +** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever +** codepage is currently defined. Filenames containing international +** characters must be converted to UTF-8 prior to passing them into +** sqlite3_open() or sqlite3_open_v2(). +** +** Note to Windows Runtime users: The temporary directory must be set +** prior to calling sqlite3_open() or sqlite3_open_v2(). Otherwise, various +** features that require the use of temporary files may fail. +** +** See also: [sqlite3_temp_directory] +*/ +SQLITE_API int sqlite3_open( + const char *filename, /* Database filename (UTF-8) */ + sqlite3 **ppDb /* OUT: SQLite db handle */ +); +SQLITE_API int sqlite3_open16( + const void *filename, /* Database filename (UTF-16) */ + sqlite3 **ppDb /* OUT: SQLite db handle */ +); +SQLITE_API int sqlite3_open_v2( + const char *filename, /* Database filename (UTF-8) */ + sqlite3 **ppDb, /* OUT: SQLite db handle */ + int flags, /* Flags */ + const char *zVfs /* Name of VFS module to use */ +); + +/* +** CAPI3REF: Obtain Values For URI Parameters +** +** These are utility routines, useful to [VFS|custom VFS implementations], +** that check if a database file was a URI that contained a specific query +** parameter, and if so obtains the value of that query parameter. +** +** The first parameter to these interfaces (hereafter referred to +** as F) must be one of: +**
      +**
    • A database filename pointer created by the SQLite core and +** passed into the xOpen() method of a VFS implemention, or +**
    • A filename obtained from [sqlite3_db_filename()], or +**
    • A new filename constructed using [sqlite3_create_filename()]. +**
    +** If the F parameter is not one of the above, then the behavior is +** undefined and probably undesirable. Older versions of SQLite were +** more tolerant of invalid F parameters than newer versions. +** +** If F is a suitable filename (as described in the previous paragraph) +** and if P is the name of the query parameter, then +** sqlite3_uri_parameter(F,P) returns the value of the P +** parameter if it exists or a NULL pointer if P does not appear as a +** query parameter on F. If P is a query parameter of F and it +** has no explicit value, then sqlite3_uri_parameter(F,P) returns +** a pointer to an empty string. +** +** The sqlite3_uri_boolean(F,P,B) routine assumes that P is a boolean +** parameter and returns true (1) or false (0) according to the value +** of P. The sqlite3_uri_boolean(F,P,B) routine returns true (1) if the +** value of query parameter P is one of "yes", "true", or "on" in any +** case or if the value begins with a non-zero number. The +** sqlite3_uri_boolean(F,P,B) routines returns false (0) if the value of +** query parameter P is one of "no", "false", or "off" in any case or +** if the value begins with a numeric zero. If P is not a query +** parameter on F or if the value of P does not match any of the +** above, then sqlite3_uri_boolean(F,P,B) returns (B!=0). +** +** The sqlite3_uri_int64(F,P,D) routine converts the value of P into a +** 64-bit signed integer and returns that integer, or D if P does not +** exist. If the value of P is something other than an integer, then +** zero is returned. +** +** The sqlite3_uri_key(F,N) returns a pointer to the name (not +** the value) of the N-th query parameter for filename F, or a NULL +** pointer if N is less than zero or greater than the number of query +** parameters minus 1. The N value is zero-based so N should be 0 to obtain +** the name of the first query parameter, 1 for the second parameter, and +** so forth. +** +** If F is a NULL pointer, then sqlite3_uri_parameter(F,P) returns NULL and +** sqlite3_uri_boolean(F,P,B) returns B. If F is not a NULL pointer and +** is not a database file pathname pointer that the SQLite core passed +** into the xOpen VFS method, then the behavior of this routine is undefined +** and probably undesirable. +** +** Beginning with SQLite [version 3.31.0] ([dateof:3.31.0]) the input F +** parameter can also be the name of a rollback journal file or WAL file +** in addition to the main database file. Prior to version 3.31.0, these +** routines would only work if F was the name of the main database file. +** When the F parameter is the name of the rollback journal or WAL file, +** it has access to all the same query parameters as were found on the +** main database file. +** +** See the [URI filename] documentation for additional information. +*/ +SQLITE_API const char *sqlite3_uri_parameter(sqlite3_filename z, const char *zParam); +SQLITE_API int sqlite3_uri_boolean(sqlite3_filename z, const char *zParam, int bDefault); +SQLITE_API sqlite3_int64 sqlite3_uri_int64(sqlite3_filename, const char*, sqlite3_int64); +SQLITE_API const char *sqlite3_uri_key(sqlite3_filename z, int N); + +/* +** CAPI3REF: Translate filenames +** +** These routines are available to [VFS|custom VFS implementations] for +** translating filenames between the main database file, the journal file, +** and the WAL file. +** +** If F is the name of an sqlite database file, journal file, or WAL file +** passed by the SQLite core into the VFS, then sqlite3_filename_database(F) +** returns the name of the corresponding database file. +** +** If F is the name of an sqlite database file, journal file, or WAL file +** passed by the SQLite core into the VFS, or if F is a database filename +** obtained from [sqlite3_db_filename()], then sqlite3_filename_journal(F) +** returns the name of the corresponding rollback journal file. +** +** If F is the name of an sqlite database file, journal file, or WAL file +** that was passed by the SQLite core into the VFS, or if F is a database +** filename obtained from [sqlite3_db_filename()], then +** sqlite3_filename_wal(F) returns the name of the corresponding +** WAL file. +** +** In all of the above, if F is not the name of a database, journal or WAL +** filename passed into the VFS from the SQLite core and F is not the +** return value from [sqlite3_db_filename()], then the result is +** undefined and is likely a memory access violation. +*/ +SQLITE_API const char *sqlite3_filename_database(sqlite3_filename); +SQLITE_API const char *sqlite3_filename_journal(sqlite3_filename); +SQLITE_API const char *sqlite3_filename_wal(sqlite3_filename); + +/* +** CAPI3REF: Database File Corresponding To A Journal +** +** ^If X is the name of a rollback or WAL-mode journal file that is +** passed into the xOpen method of [sqlite3_vfs], then +** sqlite3_database_file_object(X) returns a pointer to the [sqlite3_file] +** object that represents the main database file. +** +** This routine is intended for use in custom [VFS] implementations +** only. It is not a general-purpose interface. +** The argument sqlite3_file_object(X) must be a filename pointer that +** has been passed into [sqlite3_vfs].xOpen method where the +** flags parameter to xOpen contains one of the bits +** [SQLITE_OPEN_MAIN_JOURNAL] or [SQLITE_OPEN_WAL]. Any other use +** of this routine results in undefined and probably undesirable +** behavior. +*/ +SQLITE_API sqlite3_file *sqlite3_database_file_object(const char*); + +/* +** CAPI3REF: Create and Destroy VFS Filenames +** +** These interfces are provided for use by [VFS shim] implementations and +** are not useful outside of that context. +** +** The sqlite3_create_filename(D,J,W,N,P) allocates memory to hold a version of +** database filename D with corresponding journal file J and WAL file W and +** with N URI parameters key/values pairs in the array P. The result from +** sqlite3_create_filename(D,J,W,N,P) is a pointer to a database filename that +** is safe to pass to routines like: +**
      +**
    • [sqlite3_uri_parameter()], +**
    • [sqlite3_uri_boolean()], +**
    • [sqlite3_uri_int64()], +**
    • [sqlite3_uri_key()], +**
    • [sqlite3_filename_database()], +**
    • [sqlite3_filename_journal()], or +**
    • [sqlite3_filename_wal()]. +**
    +** If a memory allocation error occurs, sqlite3_create_filename() might +** return a NULL pointer. The memory obtained from sqlite3_create_filename(X) +** must be released by a corresponding call to sqlite3_free_filename(Y). +** +** The P parameter in sqlite3_create_filename(D,J,W,N,P) should be an array +** of 2*N pointers to strings. Each pair of pointers in this array corresponds +** to a key and value for a query parameter. The P parameter may be a NULL +** pointer if N is zero. None of the 2*N pointers in the P array may be +** NULL pointers and key pointers should not be empty strings. +** None of the D, J, or W parameters to sqlite3_create_filename(D,J,W,N,P) may +** be NULL pointers, though they can be empty strings. +** +** The sqlite3_free_filename(Y) routine releases a memory allocation +** previously obtained from sqlite3_create_filename(). Invoking +** sqlite3_free_filename(Y) where Y is a NULL pointer is a harmless no-op. +** +** If the Y parameter to sqlite3_free_filename(Y) is anything other +** than a NULL pointer or a pointer previously acquired from +** sqlite3_create_filename(), then bad things such as heap +** corruption or segfaults may occur. The value Y should not be +** used again after sqlite3_free_filename(Y) has been called. This means +** that if the [sqlite3_vfs.xOpen()] method of a VFS has been called using Y, +** then the corresponding [sqlite3_module.xClose() method should also be +** invoked prior to calling sqlite3_free_filename(Y). +*/ +SQLITE_API sqlite3_filename sqlite3_create_filename( + const char *zDatabase, + const char *zJournal, + const char *zWal, + int nParam, + const char **azParam +); +SQLITE_API void sqlite3_free_filename(sqlite3_filename); + +/* +** CAPI3REF: Error Codes And Messages +** METHOD: sqlite3 +** +** ^If the most recent sqlite3_* API call associated with +** [database connection] D failed, then the sqlite3_errcode(D) interface +** returns the numeric [result code] or [extended result code] for that +** API call. +** ^The sqlite3_extended_errcode() +** interface is the same except that it always returns the +** [extended result code] even when extended result codes are +** disabled. +** +** The values returned by sqlite3_errcode() and/or +** sqlite3_extended_errcode() might change with each API call. +** Except, there are some interfaces that are guaranteed to never +** change the value of the error code. The error-code preserving +** interfaces include the following: +** +**
      +**
    • sqlite3_errcode() +**
    • sqlite3_extended_errcode() +**
    • sqlite3_errmsg() +**
    • sqlite3_errmsg16() +**
    • sqlite3_error_offset() +**
    +** +** ^The sqlite3_errmsg() and sqlite3_errmsg16() return English-language +** text that describes the error, as either UTF-8 or UTF-16 respectively. +** ^(Memory to hold the error message string is managed internally. +** The application does not need to worry about freeing the result. +** However, the error string might be overwritten or deallocated by +** subsequent calls to other SQLite interface functions.)^ +** +** ^The sqlite3_errstr() interface returns the English-language text +** that describes the [result code], as UTF-8. +** ^(Memory to hold the error message string is managed internally +** and must not be freed by the application)^. +** +** ^If the most recent error references a specific token in the input +** SQL, the sqlite3_error_offset() interface returns the byte offset +** of the start of that token. ^The byte offset returned by +** sqlite3_error_offset() assumes that the input SQL is UTF8. +** ^If the most recent error does not reference a specific token in the input +** SQL, then the sqlite3_error_offset() function returns -1. +** +** When the serialized [threading mode] is in use, it might be the +** case that a second error occurs on a separate thread in between +** the time of the first error and the call to these interfaces. +** When that happens, the second error will be reported since these +** interfaces always report the most recent result. To avoid +** this, each thread can obtain exclusive use of the [database connection] D +** by invoking [sqlite3_mutex_enter]([sqlite3_db_mutex](D)) before beginning +** to use D and invoking [sqlite3_mutex_leave]([sqlite3_db_mutex](D)) after +** all calls to the interfaces listed here are completed. +** +** If an interface fails with SQLITE_MISUSE, that means the interface +** was invoked incorrectly by the application. In that case, the +** error code and message may or may not be set. +*/ +SQLITE_API int sqlite3_errcode(sqlite3 *db); +SQLITE_API int sqlite3_extended_errcode(sqlite3 *db); +SQLITE_API const char *sqlite3_errmsg(sqlite3*); +SQLITE_API const void *sqlite3_errmsg16(sqlite3*); +SQLITE_API const char *sqlite3_errstr(int); +SQLITE_API int sqlite3_error_offset(sqlite3 *db); + +/* +** CAPI3REF: Prepared Statement Object +** KEYWORDS: {prepared statement} {prepared statements} +** +** An instance of this object represents a single SQL statement that +** has been compiled into binary form and is ready to be evaluated. +** +** Think of each SQL statement as a separate computer program. The +** original SQL text is source code. A prepared statement object +** is the compiled object code. All SQL must be converted into a +** prepared statement before it can be run. +** +** The life-cycle of a prepared statement object usually goes like this: +** +**
      +**
    1. Create the prepared statement object using [sqlite3_prepare_v2()]. +**
    2. Bind values to [parameters] using the sqlite3_bind_*() +** interfaces. +**
    3. Run the SQL by calling [sqlite3_step()] one or more times. +**
    4. Reset the prepared statement using [sqlite3_reset()] then go back +** to step 2. Do this zero or more times. +**
    5. Destroy the object using [sqlite3_finalize()]. +**
    +*/ +typedef struct sqlite3_stmt sqlite3_stmt; + +/* +** CAPI3REF: Run-time Limits +** METHOD: sqlite3 +** +** ^(This interface allows the size of various constructs to be limited +** on a connection by connection basis. The first parameter is the +** [database connection] whose limit is to be set or queried. The +** second parameter is one of the [limit categories] that define a +** class of constructs to be size limited. The third parameter is the +** new limit for that construct.)^ +** +** ^If the new limit is a negative number, the limit is unchanged. +** ^(For each limit category SQLITE_LIMIT_NAME there is a +** [limits | hard upper bound] +** set at compile-time by a C preprocessor macro called +** [limits | SQLITE_MAX_NAME]. +** (The "_LIMIT_" in the name is changed to "_MAX_".))^ +** ^Attempts to increase a limit above its hard upper bound are +** silently truncated to the hard upper bound. +** +** ^Regardless of whether or not the limit was changed, the +** [sqlite3_limit()] interface returns the prior value of the limit. +** ^Hence, to find the current value of a limit without changing it, +** simply invoke this interface with the third parameter set to -1. +** +** Run-time limits are intended for use in applications that manage +** both their own internal database and also databases that are controlled +** by untrusted external sources. An example application might be a +** web browser that has its own databases for storing history and +** separate databases controlled by JavaScript applications downloaded +** off the Internet. The internal databases can be given the +** large, default limits. Databases managed by external sources can +** be given much smaller limits designed to prevent a denial of service +** attack. Developers might also want to use the [sqlite3_set_authorizer()] +** interface to further control untrusted SQL. The size of the database +** created by an untrusted script can be contained using the +** [max_page_count] [PRAGMA]. +** +** New run-time limit categories may be added in future releases. +*/ +SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal); + +/* +** CAPI3REF: Run-Time Limit Categories +** KEYWORDS: {limit category} {*limit categories} +** +** These constants define various performance limits +** that can be lowered at run-time using [sqlite3_limit()]. +** The synopsis of the meanings of the various limits is shown below. +** Additional information is available at [limits | Limits in SQLite]. +** +**
    +** [[SQLITE_LIMIT_LENGTH]] ^(
    SQLITE_LIMIT_LENGTH
    +**
    The maximum size of any string or BLOB or table row, in bytes.
    )^ +** +** [[SQLITE_LIMIT_SQL_LENGTH]] ^(
    SQLITE_LIMIT_SQL_LENGTH
    +**
    The maximum length of an SQL statement, in bytes.
    )^ +** +** [[SQLITE_LIMIT_COLUMN]] ^(
    SQLITE_LIMIT_COLUMN
    +**
    The maximum number of columns in a table definition or in the +** result set of a [SELECT] or the maximum number of columns in an index +** or in an ORDER BY or GROUP BY clause.
    )^ +** +** [[SQLITE_LIMIT_EXPR_DEPTH]] ^(
    SQLITE_LIMIT_EXPR_DEPTH
    +**
    The maximum depth of the parse tree on any expression.
    )^ +** +** [[SQLITE_LIMIT_COMPOUND_SELECT]] ^(
    SQLITE_LIMIT_COMPOUND_SELECT
    +**
    The maximum number of terms in a compound SELECT statement.
    )^ +** +** [[SQLITE_LIMIT_VDBE_OP]] ^(
    SQLITE_LIMIT_VDBE_OP
    +**
    The maximum number of instructions in a virtual machine program +** used to implement an SQL statement. If [sqlite3_prepare_v2()] or +** the equivalent tries to allocate space for more than this many opcodes +** in a single prepared statement, an SQLITE_NOMEM error is returned.
    )^ +** +** [[SQLITE_LIMIT_FUNCTION_ARG]] ^(
    SQLITE_LIMIT_FUNCTION_ARG
    +**
    The maximum number of arguments on a function.
    )^ +** +** [[SQLITE_LIMIT_ATTACHED]] ^(
    SQLITE_LIMIT_ATTACHED
    +**
    The maximum number of [ATTACH | attached databases].)^
    +** +** [[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]] +** ^(
    SQLITE_LIMIT_LIKE_PATTERN_LENGTH
    +**
    The maximum length of the pattern argument to the [LIKE] or +** [GLOB] operators.
    )^ +** +** [[SQLITE_LIMIT_VARIABLE_NUMBER]] +** ^(
    SQLITE_LIMIT_VARIABLE_NUMBER
    +**
    The maximum index number of any [parameter] in an SQL statement.)^ +** +** [[SQLITE_LIMIT_TRIGGER_DEPTH]] ^(
    SQLITE_LIMIT_TRIGGER_DEPTH
    +**
    The maximum depth of recursion for triggers.
    )^ +** +** [[SQLITE_LIMIT_WORKER_THREADS]] ^(
    SQLITE_LIMIT_WORKER_THREADS
    +**
    The maximum number of auxiliary worker threads that a single +** [prepared statement] may start.
    )^ +**
    +*/ +#define SQLITE_LIMIT_LENGTH 0 +#define SQLITE_LIMIT_SQL_LENGTH 1 +#define SQLITE_LIMIT_COLUMN 2 +#define SQLITE_LIMIT_EXPR_DEPTH 3 +#define SQLITE_LIMIT_COMPOUND_SELECT 4 +#define SQLITE_LIMIT_VDBE_OP 5 +#define SQLITE_LIMIT_FUNCTION_ARG 6 +#define SQLITE_LIMIT_ATTACHED 7 +#define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8 +#define SQLITE_LIMIT_VARIABLE_NUMBER 9 +#define SQLITE_LIMIT_TRIGGER_DEPTH 10 +#define SQLITE_LIMIT_WORKER_THREADS 11 + +/* +** CAPI3REF: Prepare Flags +** +** These constants define various flags that can be passed into +** "prepFlags" parameter of the [sqlite3_prepare_v3()] and +** [sqlite3_prepare16_v3()] interfaces. +** +** New flags may be added in future releases of SQLite. +** +**
    +** [[SQLITE_PREPARE_PERSISTENT]] ^(
    SQLITE_PREPARE_PERSISTENT
    +**
    The SQLITE_PREPARE_PERSISTENT flag is a hint to the query planner +** that the prepared statement will be retained for a long time and +** probably reused many times.)^ ^Without this flag, [sqlite3_prepare_v3()] +** and [sqlite3_prepare16_v3()] assume that the prepared statement will +** be used just once or at most a few times and then destroyed using +** [sqlite3_finalize()] relatively soon. The current implementation acts +** on this hint by avoiding the use of [lookaside memory] so as not to +** deplete the limited store of lookaside memory. Future versions of +** SQLite may act on this hint differently. +** +** [[SQLITE_PREPARE_NORMALIZE]]
    SQLITE_PREPARE_NORMALIZE
    +**
    The SQLITE_PREPARE_NORMALIZE flag is a no-op. This flag used +** to be required for any prepared statement that wanted to use the +** [sqlite3_normalized_sql()] interface. However, the +** [sqlite3_normalized_sql()] interface is now available to all +** prepared statements, regardless of whether or not they use this +** flag. +** +** [[SQLITE_PREPARE_NO_VTAB]]
    SQLITE_PREPARE_NO_VTAB
    +**
    The SQLITE_PREPARE_NO_VTAB flag causes the SQL compiler +** to return an error (error code SQLITE_ERROR) if the statement uses +** any virtual tables. +**
    +*/ +#define SQLITE_PREPARE_PERSISTENT 0x01 +#define SQLITE_PREPARE_NORMALIZE 0x02 +#define SQLITE_PREPARE_NO_VTAB 0x04 + +/* +** CAPI3REF: Compiling An SQL Statement +** KEYWORDS: {SQL statement compiler} +** METHOD: sqlite3 +** CONSTRUCTOR: sqlite3_stmt +** +** To execute an SQL statement, it must first be compiled into a byte-code +** program using one of these routines. Or, in other words, these routines +** are constructors for the [prepared statement] object. +** +** The preferred routine to use is [sqlite3_prepare_v2()]. The +** [sqlite3_prepare()] interface is legacy and should be avoided. +** [sqlite3_prepare_v3()] has an extra "prepFlags" option that is used +** for special purposes. +** +** The use of the UTF-8 interfaces is preferred, as SQLite currently +** does all parsing using UTF-8. The UTF-16 interfaces are provided +** as a convenience. The UTF-16 interfaces work by converting the +** input text into UTF-8, then invoking the corresponding UTF-8 interface. +** +** The first argument, "db", is a [database connection] obtained from a +** prior successful call to [sqlite3_open()], [sqlite3_open_v2()] or +** [sqlite3_open16()]. The database connection must not have been closed. +** +** The second argument, "zSql", is the statement to be compiled, encoded +** as either UTF-8 or UTF-16. The sqlite3_prepare(), sqlite3_prepare_v2(), +** and sqlite3_prepare_v3() +** interfaces use UTF-8, and sqlite3_prepare16(), sqlite3_prepare16_v2(), +** and sqlite3_prepare16_v3() use UTF-16. +** +** ^If the nByte argument is negative, then zSql is read up to the +** first zero terminator. ^If nByte is positive, then it is the +** number of bytes read from zSql. ^If nByte is zero, then no prepared +** statement is generated. +** If the caller knows that the supplied string is nul-terminated, then +** there is a small performance advantage to passing an nByte parameter that +** is the number of bytes in the input string including +** the nul-terminator. +** +** ^If pzTail is not NULL then *pzTail is made to point to the first byte +** past the end of the first SQL statement in zSql. These routines only +** compile the first statement in zSql, so *pzTail is left pointing to +** what remains uncompiled. +** +** ^*ppStmt is left pointing to a compiled [prepared statement] that can be +** executed using [sqlite3_step()]. ^If there is an error, *ppStmt is set +** to NULL. ^If the input text contains no SQL (if the input is an empty +** string or a comment) then *ppStmt is set to NULL. +** The calling procedure is responsible for deleting the compiled +** SQL statement using [sqlite3_finalize()] after it has finished with it. +** ppStmt may not be NULL. +** +** ^On success, the sqlite3_prepare() family of routines return [SQLITE_OK]; +** otherwise an [error code] is returned. +** +** The sqlite3_prepare_v2(), sqlite3_prepare_v3(), sqlite3_prepare16_v2(), +** and sqlite3_prepare16_v3() interfaces are recommended for all new programs. +** The older interfaces (sqlite3_prepare() and sqlite3_prepare16()) +** are retained for backwards compatibility, but their use is discouraged. +** ^In the "vX" interfaces, the prepared statement +** that is returned (the [sqlite3_stmt] object) contains a copy of the +** original SQL text. This causes the [sqlite3_step()] interface to +** behave differently in three ways: +** +**
      +**
    1. +** ^If the database schema changes, instead of returning [SQLITE_SCHEMA] as it +** always used to do, [sqlite3_step()] will automatically recompile the SQL +** statement and try to run it again. As many as [SQLITE_MAX_SCHEMA_RETRY] +** retries will occur before sqlite3_step() gives up and returns an error. +**
      2. +** +**
    2. +** ^When an error occurs, [sqlite3_step()] will return one of the detailed +** [error codes] or [extended error codes]. ^The legacy behavior was that +** [sqlite3_step()] would only return a generic [SQLITE_ERROR] result code +** and the application would have to make a second call to [sqlite3_reset()] +** in order to find the underlying cause of the problem. With the "v2" prepare +** interfaces, the underlying reason for the error is returned immediately. +**
      3. +** +**
    3. +** ^If the specific value bound to a [parameter | host parameter] in the +** WHERE clause might influence the choice of query plan for a statement, +** then the statement will be automatically recompiled, as if there had been +** a schema change, on the first [sqlite3_step()] call following any change +** to the [sqlite3_bind_text | bindings] of that [parameter]. +** ^The specific value of a WHERE-clause [parameter] might influence the +** choice of query plan if the parameter is the left-hand side of a [LIKE] +** or [GLOB] operator or if the parameter is compared to an indexed column +** and the [SQLITE_ENABLE_STAT4] compile-time option is enabled. +**
      4. +**
    +** +**

    ^sqlite3_prepare_v3() differs from sqlite3_prepare_v2() only in having +** the extra prepFlags parameter, which is a bit array consisting of zero or +** more of the [SQLITE_PREPARE_PERSISTENT|SQLITE_PREPARE_*] flags. ^The +** sqlite3_prepare_v2() interface works exactly the same as +** sqlite3_prepare_v3() with a zero prepFlags parameter. +*/ +SQLITE_API int sqlite3_prepare( + sqlite3 *db, /* Database handle */ + const char *zSql, /* SQL statement, UTF-8 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const char **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int sqlite3_prepare_v2( + sqlite3 *db, /* Database handle */ + const char *zSql, /* SQL statement, UTF-8 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const char **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int sqlite3_prepare_v3( + sqlite3 *db, /* Database handle */ + const char *zSql, /* SQL statement, UTF-8 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_ flags */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const char **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int sqlite3_prepare16( + sqlite3 *db, /* Database handle */ + const void *zSql, /* SQL statement, UTF-16 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const void **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int sqlite3_prepare16_v2( + sqlite3 *db, /* Database handle */ + const void *zSql, /* SQL statement, UTF-16 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const void **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int sqlite3_prepare16_v3( + sqlite3 *db, /* Database handle */ + const void *zSql, /* SQL statement, UTF-16 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_ flags */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const void **pzTail /* OUT: Pointer to unused portion of zSql */ +); + +/* +** CAPI3REF: Retrieving Statement SQL +** METHOD: sqlite3_stmt +** +** ^The sqlite3_sql(P) interface returns a pointer to a copy of the UTF-8 +** SQL text used to create [prepared statement] P if P was +** created by [sqlite3_prepare_v2()], [sqlite3_prepare_v3()], +** [sqlite3_prepare16_v2()], or [sqlite3_prepare16_v3()]. +** ^The sqlite3_expanded_sql(P) interface returns a pointer to a UTF-8 +** string containing the SQL text of prepared statement P with +** [bound parameters] expanded. +** ^The sqlite3_normalized_sql(P) interface returns a pointer to a UTF-8 +** string containing the normalized SQL text of prepared statement P. The +** semantics used to normalize a SQL statement are unspecified and subject +** to change. At a minimum, literal values will be replaced with suitable +** placeholders. +** +** ^(For example, if a prepared statement is created using the SQL +** text "SELECT $abc,:xyz" and if parameter $abc is bound to integer 2345 +** and parameter :xyz is unbound, then sqlite3_sql() will return +** the original string, "SELECT $abc,:xyz" but sqlite3_expanded_sql() +** will return "SELECT 2345,NULL".)^ +** +** ^The sqlite3_expanded_sql() interface returns NULL if insufficient memory +** is available to hold the result, or if the result would exceed the +** the maximum string length determined by the [SQLITE_LIMIT_LENGTH]. +** +** ^The [SQLITE_TRACE_SIZE_LIMIT] compile-time option limits the size of +** bound parameter expansions. ^The [SQLITE_OMIT_TRACE] compile-time +** option causes sqlite3_expanded_sql() to always return NULL. +** +** ^The strings returned by sqlite3_sql(P) and sqlite3_normalized_sql(P) +** are managed by SQLite and are automatically freed when the prepared +** statement is finalized. +** ^The string returned by sqlite3_expanded_sql(P), on the other hand, +** is obtained from [sqlite3_malloc()] and must be freed by the application +** by passing it to [sqlite3_free()]. +** +** ^The sqlite3_normalized_sql() interface is only available if +** the [SQLITE_ENABLE_NORMALIZE] compile-time option is defined. +*/ +SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt); +SQLITE_API char *sqlite3_expanded_sql(sqlite3_stmt *pStmt); +#ifdef SQLITE_ENABLE_NORMALIZE +SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt); +#endif + +/* +** CAPI3REF: Determine If An SQL Statement Writes The Database +** METHOD: sqlite3_stmt +** +** ^The sqlite3_stmt_readonly(X) interface returns true (non-zero) if +** and only if the [prepared statement] X makes no direct changes to +** the content of the database file. +** +** Note that [application-defined SQL functions] or +** [virtual tables] might change the database indirectly as a side effect. +** ^(For example, if an application defines a function "eval()" that +** calls [sqlite3_exec()], then the following SQL statement would +** change the database file through side-effects: +** +** 

    +**    SELECT eval('DELETE FROM t1') FROM t2;
+**
    +** +** But because the [SELECT] statement does not change the database file +** directly, sqlite3_stmt_readonly() would still return true.)^ +** +** ^Transaction control statements such as [BEGIN], [COMMIT], [ROLLBACK], +** [SAVEPOINT], and [RELEASE] cause sqlite3_stmt_readonly() to return true, +** since the statements themselves do not actually modify the database but +** rather they control the timing of when other statements modify the +** database. ^The [ATTACH] and [DETACH] statements also cause +** sqlite3_stmt_readonly() to return true since, while those statements +** change the configuration of a database connection, they do not make +** changes to the content of the database files on disk. +** ^The sqlite3_stmt_readonly() interface returns true for [BEGIN] since +** [BEGIN] merely sets internal flags, but the [BEGIN|BEGIN IMMEDIATE] and +** [BEGIN|BEGIN EXCLUSIVE] commands do touch the database and so +** sqlite3_stmt_readonly() returns false for those commands. +** +** ^This routine returns false if there is any possibility that the +** statement might change the database file. ^A false return does +** not guarantee that the statement will change the database file. +** ^For example, an UPDATE statement might have a WHERE clause that +** makes it a no-op, but the sqlite3_stmt_readonly() result would still +** be false. ^Similarly, a CREATE TABLE IF NOT EXISTS statement is a +** read-only no-op if the table already exists, but +** sqlite3_stmt_readonly() still returns false for such a statement. +** +** ^If prepared statement X is an [EXPLAIN] or [EXPLAIN QUERY PLAN] +** statement, then sqlite3_stmt_readonly(X) returns the same value as +** if the EXPLAIN or EXPLAIN QUERY PLAN prefix were omitted. +*/ +SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Query The EXPLAIN Setting For A Prepared Statement +** METHOD: sqlite3_stmt +** +** ^The sqlite3_stmt_isexplain(S) interface returns 1 if the +** prepared statement S is an EXPLAIN statement, or 2 if the +** statement S is an EXPLAIN QUERY PLAN. +** ^The sqlite3_stmt_isexplain(S) interface returns 0 if S is +** an ordinary statement or a NULL pointer. +*/ +SQLITE_API int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Determine If A Prepared Statement Has Been Reset +** METHOD: sqlite3_stmt +** +** ^The sqlite3_stmt_busy(S) interface returns true (non-zero) if the +** [prepared statement] S has been stepped at least once using +** [sqlite3_step(S)] but has neither run to completion (returned +** [SQLITE_DONE] from [sqlite3_step(S)]) nor +** been reset using [sqlite3_reset(S)]. ^The sqlite3_stmt_busy(S) +** interface returns false if S is a NULL pointer. If S is not a +** NULL pointer and is not a pointer to a valid [prepared statement] +** object, then the behavior is undefined and probably undesirable. +** +** This interface can be used in combination [sqlite3_next_stmt()] +** to locate all prepared statements associated with a database +** connection that are in need of being reset. This can be used, +** for example, in diagnostic routines to search for prepared +** statements that are holding a transaction open. +*/ +SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt*); + +/* +** CAPI3REF: Dynamically Typed Value Object +** KEYWORDS: {protected sqlite3_value} {unprotected sqlite3_value} +** +** SQLite uses the sqlite3_value object to represent all values +** that can be stored in a database table. SQLite uses dynamic typing +** for the values it stores. ^Values stored in sqlite3_value objects +** can be integers, floating point values, strings, BLOBs, or NULL. +** +** An sqlite3_value object may be either "protected" or "unprotected". +** Some interfaces require a protected sqlite3_value. Other interfaces +** will accept either a protected or an unprotected sqlite3_value. +** Every interface that accepts sqlite3_value arguments specifies +** whether or not it requires a protected sqlite3_value. The +** [sqlite3_value_dup()] interface can be used to construct a new +** protected sqlite3_value from an unprotected sqlite3_value. +** +** The terms "protected" and "unprotected" refer to whether or not +** a mutex is held. An internal mutex is held for a protected +** sqlite3_value object but no mutex is held for an unprotected +** sqlite3_value object. If SQLite is compiled to be single-threaded +** (with [SQLITE_THREADSAFE=0] and with [sqlite3_threadsafe()] returning 0) +** or if SQLite is run in one of reduced mutex modes +** [SQLITE_CONFIG_SINGLETHREAD] or [SQLITE_CONFIG_MULTITHREAD] +** then there is no distinction between protected and unprotected +** sqlite3_value objects and they can be used interchangeably. However, +** for maximum code portability it is recommended that applications +** still make the distinction between protected and unprotected +** sqlite3_value objects even when not strictly required. +** +** ^The sqlite3_value objects that are passed as parameters into the +** implementation of [application-defined SQL functions] are protected. +** ^The sqlite3_value objects returned by [sqlite3_vtab_rhs_value()] +** are protected. +** ^The sqlite3_value object returned by +** [sqlite3_column_value()] is unprotected. +** Unprotected sqlite3_value objects may only be used as arguments +** to [sqlite3_result_value()], [sqlite3_bind_value()], and +** [sqlite3_value_dup()]. +** The [sqlite3_value_blob | sqlite3_value_type()] family of +** interfaces require protected sqlite3_value objects. +*/ +typedef struct sqlite3_value sqlite3_value; + +/* +** CAPI3REF: SQL Function Context Object +** +** The context in which an SQL function executes is stored in an +** sqlite3_context object. ^A pointer to an sqlite3_context object +** is always first parameter to [application-defined SQL functions]. +** The application-defined SQL function implementation will pass this +** pointer through into calls to [sqlite3_result_int | sqlite3_result()], +** [sqlite3_aggregate_context()], [sqlite3_user_data()], +** [sqlite3_context_db_handle()], [sqlite3_get_auxdata()], +** and/or [sqlite3_set_auxdata()]. +*/ +typedef struct sqlite3_context sqlite3_context; + +/* +** CAPI3REF: Binding Values To Prepared Statements +** KEYWORDS: {host parameter} {host parameters} {host parameter name} +** KEYWORDS: {SQL parameter} {SQL parameters} {parameter binding} +** METHOD: sqlite3_stmt +** +** ^(In the SQL statement text input to [sqlite3_prepare_v2()] and its variants, +** literals may be replaced by a [parameter] that matches one of following +** templates: +** +**
      +**
    • ? +**
    • ?NNN +**
    • :VVV +**
    • @VVV +**
    • $VVV +**
    +** +** In the templates above, NNN represents an integer literal, +** and VVV represents an alphanumeric identifier.)^ ^The values of these +** parameters (also called "host parameter names" or "SQL parameters") +** can be set using the sqlite3_bind_*() routines defined here. +** +** ^The first argument to the sqlite3_bind_*() routines is always +** a pointer to the [sqlite3_stmt] object returned from +** [sqlite3_prepare_v2()] or its variants. +** +** ^The second argument is the index of the SQL parameter to be set. +** ^The leftmost SQL parameter has an index of 1. ^When the same named +** SQL parameter is used more than once, second and subsequent +** occurrences have the same index as the first occurrence. +** ^The index for named parameters can be looked up using the +** [sqlite3_bind_parameter_index()] API if desired. ^The index +** for "?NNN" parameters is the value of NNN. +** ^The NNN value must be between 1 and the [sqlite3_limit()] +** parameter [SQLITE_LIMIT_VARIABLE_NUMBER] (default value: 32766). +** +** ^The third argument is the value to bind to the parameter. +** ^If the third parameter to sqlite3_bind_text() or sqlite3_bind_text16() +** or sqlite3_bind_blob() is a NULL pointer then the fourth parameter +** is ignored and the end result is the same as sqlite3_bind_null(). +** ^If the third parameter to sqlite3_bind_text() is not NULL, then +** it should be a pointer to well-formed UTF8 text. +** ^If the third parameter to sqlite3_bind_text16() is not NULL, then +** it should be a pointer to well-formed UTF16 text. +** ^If the third parameter to sqlite3_bind_text64() is not NULL, then +** it should be a pointer to a well-formed unicode string that is +** either UTF8 if the sixth parameter is SQLITE_UTF8, or UTF16 +** otherwise. +** +** [[byte-order determination rules]] ^The byte-order of +** UTF16 input text is determined by the byte-order mark (BOM, U+FEFF) +** found in first character, which is removed, or in the absence of a BOM +** the byte order is the native byte order of the host +** machine for sqlite3_bind_text16() or the byte order specified in +** the 6th parameter for sqlite3_bind_text64().)^ +** ^If UTF16 input text contains invalid unicode +** characters, then SQLite might change those invalid characters +** into the unicode replacement character: U+FFFD. +** +** ^(In those routines that have a fourth argument, its value is the +** number of bytes in the parameter. To be clear: the value is the +** number of bytes in the value, not the number of characters.)^ +** ^If the fourth parameter to sqlite3_bind_text() or sqlite3_bind_text16() +** is negative, then the length of the string is +** the number of bytes up to the first zero terminator. +** If the fourth parameter to sqlite3_bind_blob() is negative, then +** the behavior is undefined. +** If a non-negative fourth parameter is provided to sqlite3_bind_text() +** or sqlite3_bind_text16() or sqlite3_bind_text64() then +** that parameter must be the byte offset +** where the NUL terminator would occur assuming the string were NUL +** terminated. If any NUL characters occurs at byte offsets less than +** the value of the fourth parameter then the resulting string value will +** contain embedded NULs. The result of expressions involving strings +** with embedded NULs is undefined. +** +** ^The fifth argument to the BLOB and string binding interfaces controls +** or indicates the lifetime of the object referenced by the third parameter. +** These three options exist: +** ^ (1) A destructor to dispose of the BLOB or string after SQLite has finished +** with it may be passed. ^It is called to dispose of the BLOB or string even +** if the call to the bind API fails, except the destructor is not called if +** the third parameter is a NULL pointer or the fourth parameter is negative. +** ^ (2) The special constant, [SQLITE_STATIC], may be passsed to indicate that +** the application remains responsible for disposing of the object. ^In this +** case, the object and the provided pointer to it must remain valid until +** either the prepared statement is finalized or the same SQL parameter is +** bound to something else, whichever occurs sooner. +** ^ (3) The constant, [SQLITE_TRANSIENT], may be passed to indicate that the +** object is to be copied prior to the return from sqlite3_bind_*(). ^The +** object and pointer to it must remain valid until then. ^SQLite will then +** manage the lifetime of its private copy. +** +** ^The sixth argument to sqlite3_bind_text64() must be one of +** [SQLITE_UTF8], [SQLITE_UTF16], [SQLITE_UTF16BE], or [SQLITE_UTF16LE] +** to specify the encoding of the text in the third parameter. If +** the sixth argument to sqlite3_bind_text64() is not one of the +** allowed values shown above, or if the text encoding is different +** from the encoding specified by the sixth parameter, then the behavior +** is undefined. +** +** ^The sqlite3_bind_zeroblob() routine binds a BLOB of length N that +** is filled with zeroes. ^A zeroblob uses a fixed amount of memory +** (just an integer to hold its size) while it is being processed. +** Zeroblobs are intended to serve as placeholders for BLOBs whose +** content is later written using +** [sqlite3_blob_open | incremental BLOB I/O] routines. +** ^A negative value for the zeroblob results in a zero-length BLOB. +** +** ^The sqlite3_bind_pointer(S,I,P,T,D) routine causes the I-th parameter in +** [prepared statement] S to have an SQL value of NULL, but to also be +** associated with the pointer P of type T. ^D is either a NULL pointer or +** a pointer to a destructor function for P. ^SQLite will invoke the +** destructor D with a single argument of P when it is finished using +** P. The T parameter should be a static string, preferably a string +** literal. The sqlite3_bind_pointer() routine is part of the +** [pointer passing interface] added for SQLite 3.20.0. +** +** ^If any of the sqlite3_bind_*() routines are called with a NULL pointer +** for the [prepared statement] or with a prepared statement for which +** [sqlite3_step()] has been called more recently than [sqlite3_reset()], +** then the call will return [SQLITE_MISUSE]. If any sqlite3_bind_() +** routine is passed a [prepared statement] that has been finalized, the +** result is undefined and probably harmful. +** +** ^Bindings are not cleared by the [sqlite3_reset()] routine. +** ^Unbound parameters are interpreted as NULL. +** +** ^The sqlite3_bind_* routines return [SQLITE_OK] on success or an +** [error code] if anything goes wrong. +** ^[SQLITE_TOOBIG] might be returned if the size of a string or BLOB +** exceeds limits imposed by [sqlite3_limit]([SQLITE_LIMIT_LENGTH]) or +** [SQLITE_MAX_LENGTH]. +** ^[SQLITE_RANGE] is returned if the parameter +** index is out of range. ^[SQLITE_NOMEM] is returned if malloc() fails. +** +** See also: [sqlite3_bind_parameter_count()], +** [sqlite3_bind_parameter_name()], and [sqlite3_bind_parameter_index()]. +*/ +SQLITE_API int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*)); +SQLITE_API int sqlite3_bind_blob64(sqlite3_stmt*, int, const void*, sqlite3_uint64, + void(*)(void*)); +SQLITE_API int sqlite3_bind_double(sqlite3_stmt*, int, double); +SQLITE_API int sqlite3_bind_int(sqlite3_stmt*, int, int); +SQLITE_API int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64); +SQLITE_API int sqlite3_bind_null(sqlite3_stmt*, int); +SQLITE_API int sqlite3_bind_text(sqlite3_stmt*,int,const char*,int,void(*)(void*)); +SQLITE_API int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*)); +SQLITE_API int sqlite3_bind_text64(sqlite3_stmt*, int, const char*, sqlite3_uint64, + void(*)(void*), unsigned char encoding); +SQLITE_API int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*); +SQLITE_API int sqlite3_bind_pointer(sqlite3_stmt*, int, void*, const char*,void(*)(void*)); +SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n); +SQLITE_API int sqlite3_bind_zeroblob64(sqlite3_stmt*, int, sqlite3_uint64); + +/* +** CAPI3REF: Number Of SQL Parameters +** METHOD: sqlite3_stmt +** +** ^This routine can be used to find the number of [SQL parameters] +** in a [prepared statement]. SQL parameters are tokens of the +** form "?", "?NNN", ":AAA", "$AAA", or "@AAA" that serve as +** placeholders for values that are [sqlite3_bind_blob | bound] +** to the parameters at a later time. +** +** ^(This routine actually returns the index of the largest (rightmost) +** parameter. For all forms except ?NNN, this will correspond to the +** number of unique parameters. If parameters of the ?NNN form are used, +** there may be gaps in the list.)^ +** +** See also: [sqlite3_bind_blob|sqlite3_bind()], +** [sqlite3_bind_parameter_name()], and +** [sqlite3_bind_parameter_index()]. +*/ +SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt*); + +/* +** CAPI3REF: Name Of A Host Parameter +** METHOD: sqlite3_stmt +** +** ^The sqlite3_bind_parameter_name(P,N) interface returns +** the name of the N-th [SQL parameter] in the [prepared statement] P. +** ^(SQL parameters of the form "?NNN" or ":AAA" or "@AAA" or "$AAA" +** have a name which is the string "?NNN" or ":AAA" or "@AAA" or "$AAA" +** respectively. +** In other words, the initial ":" or "$" or "@" or "?" +** is included as part of the name.)^ +** ^Parameters of the form "?" without a following integer have no name +** and are referred to as "nameless" or "anonymous parameters". +** +** ^The first host parameter has an index of 1, not 0. +** +** ^If the value N is out of range or if the N-th parameter is +** nameless, then NULL is returned. ^The returned string is +** always in UTF-8 encoding even if the named parameter was +** originally specified as UTF-16 in [sqlite3_prepare16()], +** [sqlite3_prepare16_v2()], or [sqlite3_prepare16_v3()]. +** +** See also: [sqlite3_bind_blob|sqlite3_bind()], +** [sqlite3_bind_parameter_count()], and +** [sqlite3_bind_parameter_index()]. +*/ +SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int); + +/* +** CAPI3REF: Index Of A Parameter With A Given Name +** METHOD: sqlite3_stmt +** +** ^Return the index of an SQL parameter given its name. ^The +** index value returned is suitable for use as the second +** parameter to [sqlite3_bind_blob|sqlite3_bind()]. ^A zero +** is returned if no matching parameter is found. ^The parameter +** name must be given in UTF-8 even if the original statement +** was prepared from UTF-16 text using [sqlite3_prepare16_v2()] or +** [sqlite3_prepare16_v3()]. +** +** See also: [sqlite3_bind_blob|sqlite3_bind()], +** [sqlite3_bind_parameter_count()], and +** [sqlite3_bind_parameter_name()]. +*/ +SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName); + +/* +** CAPI3REF: Reset All Bindings On A Prepared Statement +** METHOD: sqlite3_stmt +** +** ^Contrary to the intuition of many, [sqlite3_reset()] does not reset +** the [sqlite3_bind_blob | bindings] on a [prepared statement]. +** ^Use this routine to reset all host parameters to NULL. +*/ +SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt*); + +/* +** CAPI3REF: Number Of Columns In A Result Set +** METHOD: sqlite3_stmt +** +** ^Return the number of columns in the result set returned by the +** [prepared statement]. ^If this routine returns 0, that means the +** [prepared statement] returns no data (for example an [UPDATE]). +** ^However, just because this routine returns a positive number does not +** mean that one or more rows of data will be returned. ^A SELECT statement +** will always have a positive sqlite3_column_count() but depending on the +** WHERE clause constraints and the table content, it might return no rows. +** +** See also: [sqlite3_data_count()] +*/ +SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Column Names In A Result Set +** METHOD: sqlite3_stmt +** +** ^These routines return the name assigned to a particular column +** in the result set of a [SELECT] statement. ^The sqlite3_column_name() +** interface returns a pointer to a zero-terminated UTF-8 string +** and sqlite3_column_name16() returns a pointer to a zero-terminated +** UTF-16 string. ^The first parameter is the [prepared statement] +** that implements the [SELECT] statement. ^The second parameter is the +** column number. ^The leftmost column is number 0. +** +** ^The returned string pointer is valid until either the [prepared statement] +** is destroyed by [sqlite3_finalize()] or until the statement is automatically +** reprepared by the first call to [sqlite3_step()] for a particular run +** or until the next call to +** sqlite3_column_name() or sqlite3_column_name16() on the same column. +** +** ^If sqlite3_malloc() fails during the processing of either routine +** (for example during a conversion from UTF-8 to UTF-16) then a +** NULL pointer is returned. +** +** ^The name of a result column is the value of the "AS" clause for +** that column, if there is an AS clause. If there is no AS clause +** then the name of the column is unspecified and may change from +** one release of SQLite to the next. +*/ +SQLITE_API const char *sqlite3_column_name(sqlite3_stmt*, int N); +SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt*, int N); + +/* +** CAPI3REF: Source Of Data In A Query Result +** METHOD: sqlite3_stmt +** +** ^These routines provide a means to determine the database, table, and +** table column that is the origin of a particular result column in +** [SELECT] statement. +** ^The name of the database or table or column can be returned as +** either a UTF-8 or UTF-16 string. ^The _database_ routines return +** the database name, the _table_ routines return the table name, and +** the origin_ routines return the column name. +** ^The returned string is valid until the [prepared statement] is destroyed +** using [sqlite3_finalize()] or until the statement is automatically +** reprepared by the first call to [sqlite3_step()] for a particular run +** or until the same information is requested +** again in a different encoding. +** +** ^The names returned are the original un-aliased names of the +** database, table, and column. +** +** ^The first argument to these interfaces is a [prepared statement]. +** ^These functions return information about the Nth result column returned by +** the statement, where N is the second function argument. +** ^The left-most column is column 0 for these routines. +** +** ^If the Nth column returned by the statement is an expression or +** subquery and is not a column value, then all of these functions return +** NULL. ^These routines might also return NULL if a memory allocation error +** occurs. ^Otherwise, they return the name of the attached database, table, +** or column that query result column was extracted from. +** +** ^As with all other SQLite APIs, those whose names end with "16" return +** UTF-16 encoded strings and the other functions return UTF-8. +** +** ^These APIs are only available if the library was compiled with the +** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol. +** +** If two or more threads call one or more +** [sqlite3_column_database_name | column metadata interfaces] +** for the same [prepared statement] and result column +** at the same time then the results are undefined. +*/ +SQLITE_API const char *sqlite3_column_database_name(sqlite3_stmt*,int); +SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt*,int); +SQLITE_API const char *sqlite3_column_table_name(sqlite3_stmt*,int); +SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt*,int); +SQLITE_API const char *sqlite3_column_origin_name(sqlite3_stmt*,int); +SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt*,int); + +/* +** CAPI3REF: Declared Datatype Of A Query Result +** METHOD: sqlite3_stmt +** +** ^(The first parameter is a [prepared statement]. +** If this statement is a [SELECT] statement and the Nth column of the +** returned result set of that [SELECT] is a table column (not an +** expression or subquery) then the declared type of the table +** column is returned.)^ ^If the Nth column of the result set is an +** expression or subquery, then a NULL pointer is returned. +** ^The returned string is always UTF-8 encoded. +** +** ^(For example, given the database schema: +** +** CREATE TABLE t1(c1 VARIANT); +** +** and the following statement to be compiled: +** +** SELECT c1 + 1, c1 FROM t1; +** +** this routine would return the string "VARIANT" for the second result +** column (i==1), and a NULL pointer for the first result column (i==0).)^ +** +** ^SQLite uses dynamic run-time typing. ^So just because a column +** is declared to contain a particular type does not mean that the +** data stored in that column is of the declared type. SQLite is +** strongly typed, but the typing is dynamic not static. ^Type +** is associated with individual values, not with the containers +** used to hold those values. +*/ +SQLITE_API const char *sqlite3_column_decltype(sqlite3_stmt*,int); +SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt*,int); + +/* +** CAPI3REF: Evaluate An SQL Statement +** METHOD: sqlite3_stmt +** +** After a [prepared statement] has been prepared using any of +** [sqlite3_prepare_v2()], [sqlite3_prepare_v3()], [sqlite3_prepare16_v2()], +** or [sqlite3_prepare16_v3()] or one of the legacy +** interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], this function +** must be called one or more times to evaluate the statement. +** +** The details of the behavior of the sqlite3_step() interface depend +** on whether the statement was prepared using the newer "vX" interfaces +** [sqlite3_prepare_v3()], [sqlite3_prepare_v2()], [sqlite3_prepare16_v3()], +** [sqlite3_prepare16_v2()] or the older legacy +** interfaces [sqlite3_prepare()] and [sqlite3_prepare16()]. The use of the +** new "vX" interface is recommended for new applications but the legacy +** interface will continue to be supported. +** +** ^In the legacy interface, the return value will be either [SQLITE_BUSY], +** [SQLITE_DONE], [SQLITE_ROW], [SQLITE_ERROR], or [SQLITE_MISUSE]. +** ^With the "v2" interface, any of the other [result codes] or +** [extended result codes] might be returned as well. +** +** ^[SQLITE_BUSY] means that the database engine was unable to acquire the +** database locks it needs to do its job. ^If the statement is a [COMMIT] +** or occurs outside of an explicit transaction, then you can retry the +** statement. If the statement is not a [COMMIT] and occurs within an +** explicit transaction then you should rollback the transaction before +** continuing. +** +** ^[SQLITE_DONE] means that the statement has finished executing +** successfully. sqlite3_step() should not be called again on this virtual +** machine without first calling [sqlite3_reset()] to reset the virtual +** machine back to its initial state. +** +** ^If the SQL statement being executed returns any data, then [SQLITE_ROW] +** is returned each time a new row of data is ready for processing by the +** caller. The values may be accessed using the [column access functions]. +** sqlite3_step() is called again to retrieve the next row of data. +** +** ^[SQLITE_ERROR] means that a run-time error (such as a constraint +** violation) has occurred. sqlite3_step() should not be called again on +** the VM. More information may be found by calling [sqlite3_errmsg()]. +** ^With the legacy interface, a more specific error code (for example, +** [SQLITE_INTERRUPT], [SQLITE_SCHEMA], [SQLITE_CORRUPT], and so forth) +** can be obtained by calling [sqlite3_reset()] on the +** [prepared statement]. ^In the "v2" interface, +** the more specific error code is returned directly by sqlite3_step(). +** +** [SQLITE_MISUSE] means that the this routine was called inappropriately. +** Perhaps it was called on a [prepared statement] that has +** already been [sqlite3_finalize | finalized] or on one that had +** previously returned [SQLITE_ERROR] or [SQLITE_DONE]. Or it could +** be the case that the same database connection is being used by two or +** more threads at the same moment in time. +** +** For all versions of SQLite up to and including 3.6.23.1, a call to +** [sqlite3_reset()] was required after sqlite3_step() returned anything +** other than [SQLITE_ROW] before any subsequent invocation of +** sqlite3_step(). Failure to reset the prepared statement using +** [sqlite3_reset()] would result in an [SQLITE_MISUSE] return from +** sqlite3_step(). But after [version 3.6.23.1] ([dateof:3.6.23.1], +** sqlite3_step() began +** calling [sqlite3_reset()] automatically in this circumstance rather +** than returning [SQLITE_MISUSE]. This is not considered a compatibility +** break because any application that ever receives an SQLITE_MISUSE error +** is broken by definition. The [SQLITE_OMIT_AUTORESET] compile-time option +** can be used to restore the legacy behavior. +** +** Goofy Interface Alert: In the legacy interface, the sqlite3_step() +** API always returns a generic error code, [SQLITE_ERROR], following any +** error other than [SQLITE_BUSY] and [SQLITE_MISUSE]. You must call +** [sqlite3_reset()] or [sqlite3_finalize()] in order to find one of the +** specific [error codes] that better describes the error. +** We admit that this is a goofy design. The problem has been fixed +** with the "v2" interface. If you prepare all of your SQL statements +** using [sqlite3_prepare_v3()] or [sqlite3_prepare_v2()] +** or [sqlite3_prepare16_v2()] or [sqlite3_prepare16_v3()] instead +** of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()] interfaces, +** then the more specific [error codes] are returned directly +** by sqlite3_step(). The use of the "vX" interfaces is recommended. +*/ +SQLITE_API int sqlite3_step(sqlite3_stmt*); + +/* +** CAPI3REF: Number of columns in a result set +** METHOD: sqlite3_stmt +** +** ^The sqlite3_data_count(P) interface returns the number of columns in the +** current row of the result set of [prepared statement] P. +** ^If prepared statement P does not have results ready to return +** (via calls to the [sqlite3_column_int | sqlite3_column()] family of +** interfaces) then sqlite3_data_count(P) returns 0. +** ^The sqlite3_data_count(P) routine also returns 0 if P is a NULL pointer. +** ^The sqlite3_data_count(P) routine returns 0 if the previous call to +** [sqlite3_step](P) returned [SQLITE_DONE]. ^The sqlite3_data_count(P) +** will return non-zero if previous call to [sqlite3_step](P) returned +** [SQLITE_ROW], except in the case of the [PRAGMA incremental_vacuum] +** where it always returns zero since each step of that multi-step +** pragma returns 0 columns of data. +** +** See also: [sqlite3_column_count()] +*/ +SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Fundamental Datatypes +** KEYWORDS: SQLITE_TEXT +** +** ^(Every value in SQLite has one of five fundamental datatypes: +** +**
      +**
    • 64-bit signed integer +**
    • 64-bit IEEE floating point number +**
    • string +**
    • BLOB +**
    • NULL +**
    )^ +** +** These constants are codes for each of those types. +** +** Note that the SQLITE_TEXT constant was also used in SQLite version 2 +** for a completely different meaning. Software that links against both +** SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT, not +** SQLITE_TEXT. +*/ +#define SQLITE_INTEGER 1 +#define SQLITE_FLOAT 2 +#define SQLITE_BLOB 4 +#define SQLITE_NULL 5 +#ifdef SQLITE_TEXT +# undef SQLITE_TEXT +#else +# define SQLITE_TEXT 3 +#endif +#define SQLITE3_TEXT 3 + +/* +** CAPI3REF: Result Values From A Query +** KEYWORDS: {column access functions} +** METHOD: sqlite3_stmt +** +** Summary: +**
    +**
    sqlite3_column_blob→BLOB result +**
    sqlite3_column_double→REAL result +**
    sqlite3_column_int→32-bit INTEGER result +**
    sqlite3_column_int64→64-bit INTEGER result +**
    sqlite3_column_text→UTF-8 TEXT result +**
    sqlite3_column_text16→UTF-16 TEXT result +**
    sqlite3_column_value→The result as an +** [sqlite3_value|unprotected sqlite3_value] object. +**
        +**
    sqlite3_column_bytes→Size of a BLOB +** or a UTF-8 TEXT result in bytes +**
    sqlite3_column_bytes16   +** →  Size of UTF-16 +** TEXT in bytes +**
    sqlite3_column_type→Default +** datatype of the result +**
    +** +** Details: +** +** ^These routines return information about a single column of the current +** result row of a query. ^In every case the first argument is a pointer +** to the [prepared statement] that is being evaluated (the [sqlite3_stmt*] +** that was returned from [sqlite3_prepare_v2()] or one of its variants) +** and the second argument is the index of the column for which information +** should be returned. ^The leftmost column of the result set has the index 0. +** ^The number of columns in the result can be determined using +** [sqlite3_column_count()]. +** +** If the SQL statement does not currently point to a valid row, or if the +** column index is out of range, the result is undefined. +** These routines may only be called when the most recent call to +** [sqlite3_step()] has returned [SQLITE_ROW] and neither +** [sqlite3_reset()] nor [sqlite3_finalize()] have been called subsequently. +** If any of these routines are called after [sqlite3_reset()] or +** [sqlite3_finalize()] or after [sqlite3_step()] has returned +** something other than [SQLITE_ROW], the results are undefined. +** If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()] +** are called from a different thread while any of these routines +** are pending, then the results are undefined. +** +** The first six interfaces (_blob, _double, _int, _int64, _text, and _text16) +** each return the value of a result column in a specific data format. If +** the result column is not initially in the requested format (for example, +** if the query returns an integer but the sqlite3_column_text() interface +** is used to extract the value) then an automatic type conversion is performed. +** +** ^The sqlite3_column_type() routine returns the +** [SQLITE_INTEGER | datatype code] for the initial data type +** of the result column. ^The returned value is one of [SQLITE_INTEGER], +** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL]. +** The return value of sqlite3_column_type() can be used to decide which +** of the first six interface should be used to extract the column value. +** The value returned by sqlite3_column_type() is only meaningful if no +** automatic type conversions have occurred for the value in question. +** After a type conversion, the result of calling sqlite3_column_type() +** is undefined, though harmless. Future +** versions of SQLite may change the behavior of sqlite3_column_type() +** following a type conversion. +** +** If the result is a BLOB or a TEXT string, then the sqlite3_column_bytes() +** or sqlite3_column_bytes16() interfaces can be used to determine the size +** of that BLOB or string. +** +** ^If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes() +** routine returns the number of bytes in that BLOB or string. +** ^If the result is a UTF-16 string, then sqlite3_column_bytes() converts +** the string to UTF-8 and then returns the number of bytes. +** ^If the result is a numeric value then sqlite3_column_bytes() uses +** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns +** the number of bytes in that string. +** ^If the result is NULL, then sqlite3_column_bytes() returns zero. +** +** ^If the result is a BLOB or UTF-16 string then the sqlite3_column_bytes16() +** routine returns the number of bytes in that BLOB or string. +** ^If the result is a UTF-8 string, then sqlite3_column_bytes16() converts +** the string to UTF-16 and then returns the number of bytes. +** ^If the result is a numeric value then sqlite3_column_bytes16() uses +** [sqlite3_snprintf()] to convert that value to a UTF-16 string and returns +** the number of bytes in that string. +** ^If the result is NULL, then sqlite3_column_bytes16() returns zero. +** +** ^The values returned by [sqlite3_column_bytes()] and +** [sqlite3_column_bytes16()] do not include the zero terminators at the end +** of the string. ^For clarity: the values returned by +** [sqlite3_column_bytes()] and [sqlite3_column_bytes16()] are the number of +** bytes in the string, not the number of characters. +** +** ^Strings returned by sqlite3_column_text() and sqlite3_column_text16(), +** even empty strings, are always zero-terminated. ^The return +** value from sqlite3_column_blob() for a zero-length BLOB is a NULL pointer. +** +** ^Strings returned by sqlite3_column_text16() always have the endianness +** which is native to the platform, regardless of the text encoding set +** for the database. +** +** Warning: ^The object returned by [sqlite3_column_value()] is an +** [unprotected sqlite3_value] object. In a multithreaded environment, +** an unprotected sqlite3_value object may only be used safely with +** [sqlite3_bind_value()] and [sqlite3_result_value()]. +** If the [unprotected sqlite3_value] object returned by +** [sqlite3_column_value()] is used in any other way, including calls +** to routines like [sqlite3_value_int()], [sqlite3_value_text()], +** or [sqlite3_value_bytes()], the behavior is not threadsafe. +** Hence, the sqlite3_column_value() interface +** is normally only useful within the implementation of +** [application-defined SQL functions] or [virtual tables], not within +** top-level application code. +** +** These routines may attempt to convert the datatype of the result. +** ^For example, if the internal representation is FLOAT and a text result +** is requested, [sqlite3_snprintf()] is used internally to perform the +** conversion automatically. ^(The following table details the conversions +** that are applied: +** +**
    +** +**
    Internal
    Type     		Requested
    Type     		Conversion +** +**
    NULL INTEGER Result is 0 +**
    NULL FLOAT Result is 0.0 +**
    NULL TEXT Result is a NULL pointer +**
    NULL BLOB Result is a NULL pointer +**
    INTEGER FLOAT Convert from integer to float +**
    INTEGER TEXT ASCII rendering of the integer +**
    INTEGER BLOB Same as INTEGER->TEXT +**
    FLOAT INTEGER [CAST] to INTEGER +**
    FLOAT TEXT ASCII rendering of the float +**
    FLOAT BLOB [CAST] to BLOB +**
    TEXT INTEGER [CAST] to INTEGER +**
    TEXT FLOAT [CAST] to REAL +**
    TEXT BLOB No change +**
    BLOB INTEGER [CAST] to INTEGER +**
    BLOB FLOAT [CAST] to REAL +**
    BLOB TEXT [CAST] to TEXT, ensure zero terminator +**
    +**
    )^ +** +** Note that when type conversions occur, pointers returned by prior +** calls to sqlite3_column_blob(), sqlite3_column_text(), and/or +** sqlite3_column_text16() may be invalidated. +** Type conversions and pointer invalidations might occur +** in the following cases: +** +**
      +**
    • The initial content is a BLOB and sqlite3_column_text() or +** sqlite3_column_text16() is called. A zero-terminator might +** need to be added to the string.
      • +**
    • The initial content is UTF-8 text and sqlite3_column_bytes16() or +** sqlite3_column_text16() is called. The content must be converted +** to UTF-16.
      • +**
    • The initial content is UTF-16 text and sqlite3_column_bytes() or +** sqlite3_column_text() is called. The content must be converted +** to UTF-8.
      • +**
    +** +** ^Conversions between UTF-16be and UTF-16le are always done in place and do +** not invalidate a prior pointer, though of course the content of the buffer +** that the prior pointer references will have been modified. Other kinds +** of conversion are done in place when it is possible, but sometimes they +** are not possible and in those cases prior pointers are invalidated. +** +** The safest policy is to invoke these routines +** in one of the following ways: +** +**
      +**
    • sqlite3_column_text() followed by sqlite3_column_bytes()
      • +**
    • sqlite3_column_blob() followed by sqlite3_column_bytes()
      • +**
    • sqlite3_column_text16() followed by sqlite3_column_bytes16()
      • +**
    +** +** In other words, you should call sqlite3_column_text(), +** sqlite3_column_blob(), or sqlite3_column_text16() first to force the result +** into the desired format, then invoke sqlite3_column_bytes() or +** sqlite3_column_bytes16() to find the size of the result. Do not mix calls +** to sqlite3_column_text() or sqlite3_column_blob() with calls to +** sqlite3_column_bytes16(), and do not mix calls to sqlite3_column_text16() +** with calls to sqlite3_column_bytes(). +** +** ^The pointers returned are valid until a type conversion occurs as +** described above, or until [sqlite3_step()] or [sqlite3_reset()] or +** [sqlite3_finalize()] is called. ^The memory space used to hold strings +** and BLOBs is freed automatically. Do not pass the pointers returned +** from [sqlite3_column_blob()], [sqlite3_column_text()], etc. into +** [sqlite3_free()]. +** +** As long as the input parameters are correct, these routines will only +** fail if an out-of-memory error occurs during a format conversion. +** Only the following subset of interfaces are subject to out-of-memory +** errors: +** +**
      +**
    • sqlite3_column_blob() +**
    • sqlite3_column_text() +**
    • sqlite3_column_text16() +**
    • sqlite3_column_bytes() +**
    • sqlite3_column_bytes16() +**
    +** +** If an out-of-memory error occurs, then the return value from these +** routines is the same as if the column had contained an SQL NULL value. +** Valid SQL NULL returns can be distinguished from out-of-memory errors +** by invoking the [sqlite3_errcode()] immediately after the suspect +** return value is obtained and before any +** other SQLite interface is called on the same [database connection]. +*/ +SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol); +SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol); +SQLITE_API int sqlite3_column_int(sqlite3_stmt*, int iCol); +SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol); +SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol); +SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol); +SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol); +SQLITE_API int sqlite3_column_bytes(sqlite3_stmt*, int iCol); +SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt*, int iCol); +SQLITE_API int sqlite3_column_type(sqlite3_stmt*, int iCol); + +/* +** CAPI3REF: Destroy A Prepared Statement Object +** DESTRUCTOR: sqlite3_stmt +** +** ^The sqlite3_finalize() function is called to delete a [prepared statement]. +** ^If the most recent evaluation of the statement encountered no errors +** or if the statement is never been evaluated, then sqlite3_finalize() returns +** SQLITE_OK. ^If the most recent evaluation of statement S failed, then +** sqlite3_finalize(S) returns the appropriate [error code] or +** [extended error code]. +** +** ^The sqlite3_finalize(S) routine can be called at any point during +** the life cycle of [prepared statement] S: +** before statement S is ever evaluated, after +** one or more calls to [sqlite3_reset()], or after any call +** to [sqlite3_step()] regardless of whether or not the statement has +** completed execution. +** +** ^Invoking sqlite3_finalize() on a NULL pointer is a harmless no-op. +** +** The application must finalize every [prepared statement] in order to avoid +** resource leaks. It is a grievous error for the application to try to use +** a prepared statement after it has been finalized. Any use of a prepared +** statement after it has been finalized can result in undefined and +** undesirable behavior such as segfaults and heap corruption. +*/ +SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Reset A Prepared Statement Object +** METHOD: sqlite3_stmt +** +** The sqlite3_reset() function is called to reset a [prepared statement] +** object back to its initial state, ready to be re-executed. +** ^Any SQL statement variables that had values bound to them using +** the [sqlite3_bind_blob | sqlite3_bind_*() API] retain their values. +** Use [sqlite3_clear_bindings()] to reset the bindings. +** +** ^The [sqlite3_reset(S)] interface resets the [prepared statement] S +** back to the beginning of its program. +** +** ^If the most recent call to [sqlite3_step(S)] for the +** [prepared statement] S returned [SQLITE_ROW] or [SQLITE_DONE], +** or if [sqlite3_step(S)] has never before been called on S, +** then [sqlite3_reset(S)] returns [SQLITE_OK]. +** +** ^If the most recent call to [sqlite3_step(S)] for the +** [prepared statement] S indicated an error, then +** [sqlite3_reset(S)] returns an appropriate [error code]. +** +** ^The [sqlite3_reset(S)] interface does not change the values +** of any [sqlite3_bind_blob|bindings] on the [prepared statement] S. +*/ +SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Create Or Redefine SQL Functions +** KEYWORDS: {function creation routines} +** METHOD: sqlite3 +** +** ^These functions (collectively known as "function creation routines") +** are used to add SQL functions or aggregates or to redefine the behavior +** of existing SQL functions or aggregates. The only differences between +** the three "sqlite3_create_function*" routines are the text encoding +** expected for the second parameter (the name of the function being +** created) and the presence or absence of a destructor callback for +** the application data pointer. Function sqlite3_create_window_function() +** is similar, but allows the user to supply the extra callback functions +** needed by [aggregate window functions]. +** +** ^The first parameter is the [database connection] to which the SQL +** function is to be added. ^If an application uses more than one database +** connection then application-defined SQL functions must be added +** to each database connection separately. +** +** ^The second parameter is the name of the SQL function to be created or +** redefined. ^The length of the name is limited to 255 bytes in a UTF-8 +** representation, exclusive of the zero-terminator. ^Note that the name +** length limit is in UTF-8 bytes, not characters nor UTF-16 bytes. +** ^Any attempt to create a function with a longer name +** will result in [SQLITE_MISUSE] being returned. +** +** ^The third parameter (nArg) +** is the number of arguments that the SQL function or +** aggregate takes. ^If this parameter is -1, then the SQL function or +** aggregate may take any number of arguments between 0 and the limit +** set by [sqlite3_limit]([SQLITE_LIMIT_FUNCTION_ARG]). If the third +** parameter is less than -1 or greater than 127 then the behavior is +** undefined. +** +** ^The fourth parameter, eTextRep, specifies what +** [SQLITE_UTF8 | text encoding] this SQL function prefers for +** its parameters. The application should set this parameter to +** [SQLITE_UTF16LE] if the function implementation invokes +** [sqlite3_value_text16le()] on an input, or [SQLITE_UTF16BE] if the +** implementation invokes [sqlite3_value_text16be()] on an input, or +** [SQLITE_UTF16] if [sqlite3_value_text16()] is used, or [SQLITE_UTF8] +** otherwise. ^The same SQL function may be registered multiple times using +** different preferred text encodings, with different implementations for +** each encoding. +** ^When multiple implementations of the same function are available, SQLite +** will pick the one that involves the least amount of data conversion. +** +** ^The fourth parameter may optionally be ORed with [SQLITE_DETERMINISTIC] +** to signal that the function will always return the same result given +** the same inputs within a single SQL statement. Most SQL functions are +** deterministic. The built-in [random()] SQL function is an example of a +** function that is not deterministic. The SQLite query planner is able to +** perform additional optimizations on deterministic functions, so use +** of the [SQLITE_DETERMINISTIC] flag is recommended where possible. +** +** ^The fourth parameter may also optionally include the [SQLITE_DIRECTONLY] +** flag, which if present prevents the function from being invoked from +** within VIEWs, TRIGGERs, CHECK constraints, generated column expressions, +** index expressions, or the WHERE clause of partial indexes. +** +** For best security, the [SQLITE_DIRECTONLY] flag is recommended for +** all application-defined SQL functions that do not need to be +** used inside of triggers, view, CHECK constraints, or other elements of +** the database schema. This flags is especially recommended for SQL +** functions that have side effects or reveal internal application state. +** Without this flag, an attacker might be able to modify the schema of +** a database file to include invocations of the function with parameters +** chosen by the attacker, which the application will then execute when +** the database file is opened and read. +** +** ^(The fifth parameter is an arbitrary pointer. The implementation of the +** function can gain access to this pointer using [sqlite3_user_data()].)^ +** +** ^The sixth, seventh and eighth parameters passed to the three +** "sqlite3_create_function*" functions, xFunc, xStep and xFinal, are +** pointers to C-language functions that implement the SQL function or +** aggregate. ^A scalar SQL function requires an implementation of the xFunc +** callback only; NULL pointers must be passed as the xStep and xFinal +** parameters. ^An aggregate SQL function requires an implementation of xStep +** and xFinal and NULL pointer must be passed for xFunc. ^To delete an existing +** SQL function or aggregate, pass NULL pointers for all three function +** callbacks. +** +** ^The sixth, seventh, eighth and ninth parameters (xStep, xFinal, xValue +** and xInverse) passed to sqlite3_create_window_function are pointers to +** C-language callbacks that implement the new function. xStep and xFinal +** must both be non-NULL. xValue and xInverse may either both be NULL, in +** which case a regular aggregate function is created, or must both be +** non-NULL, in which case the new function may be used as either an aggregate +** or aggregate window function. More details regarding the implementation +** of aggregate window functions are +** [user-defined window functions|available here]. +** +** ^(If the final parameter to sqlite3_create_function_v2() or +** sqlite3_create_window_function() is not NULL, then it is destructor for +** the application data pointer. The destructor is invoked when the function +** is deleted, either by being overloaded or when the database connection +** closes.)^ ^The destructor is also invoked if the call to +** sqlite3_create_function_v2() fails. ^When the destructor callback is +** invoked, it is passed a single argument which is a copy of the application +** data pointer which was the fifth parameter to sqlite3_create_function_v2(). +** +** ^It is permitted to register multiple implementations of the same +** functions with the same name but with either differing numbers of +** arguments or differing preferred text encodings. ^SQLite will use +** the implementation that most closely matches the way in which the +** SQL function is used. ^A function implementation with a non-negative +** nArg parameter is a better match than a function implementation with +** a negative nArg. ^A function where the preferred text encoding +** matches the database encoding is a better +** match than a function where the encoding is different. +** ^A function where the encoding difference is between UTF16le and UTF16be +** is a closer match than a function where the encoding difference is +** between UTF8 and UTF16. +** +** ^Built-in functions may be overloaded by new application-defined functions. +** +** ^An application-defined function is permitted to call other +** SQLite interfaces. However, such calls must not +** close the database connection nor finalize or reset the prepared +** statement in which the function is running. +*/ +SQLITE_API int sqlite3_create_function( + sqlite3 *db, + const char *zFunctionName, + int nArg, + int eTextRep, + void *pApp, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +); +SQLITE_API int sqlite3_create_function16( + sqlite3 *db, + const void *zFunctionName, + int nArg, + int eTextRep, + void *pApp, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +); +SQLITE_API int sqlite3_create_function_v2( + sqlite3 *db, + const char *zFunctionName, + int nArg, + int eTextRep, + void *pApp, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*), + void(*xDestroy)(void*) +); +SQLITE_API int sqlite3_create_window_function( + sqlite3 *db, + const char *zFunctionName, + int nArg, + int eTextRep, + void *pApp, + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*), + void (*xValue)(sqlite3_context*), + void (*xInverse)(sqlite3_context*,int,sqlite3_value**), + void(*xDestroy)(void*) +); + +/* +** CAPI3REF: Text Encodings +** +** These constant define integer codes that represent the various +** text encodings supported by SQLite. +*/ +#define SQLITE_UTF8 1 /* IMP: R-37514-35566 */ +#define SQLITE_UTF16LE 2 /* IMP: R-03371-37637 */ +#define SQLITE_UTF16BE 3 /* IMP: R-51971-34154 */ +#define SQLITE_UTF16 4 /* Use native byte order */ +#define SQLITE_ANY 5 /* Deprecated */ +#define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */ + +/* +** CAPI3REF: Function Flags +** +** These constants may be ORed together with the +** [SQLITE_UTF8 | preferred text encoding] as the fourth argument +** to [sqlite3_create_function()], [sqlite3_create_function16()], or +** [sqlite3_create_function_v2()]. +** +**
    +** [[SQLITE_DETERMINISTIC]]
    SQLITE_DETERMINISTIC
    +** The SQLITE_DETERMINISTIC flag means that the new function always gives +** the same output when the input parameters are the same. +** The [abs|abs() function] is deterministic, for example, but +** [randomblob|randomblob()] is not. Functions must +** be deterministic in order to be used in certain contexts such as +** with the WHERE clause of [partial indexes] or in [generated columns]. +** SQLite might also optimize deterministic functions by factoring them +** out of inner loops. +**
    +** +** [[SQLITE_DIRECTONLY]]
    SQLITE_DIRECTONLY
    +** The SQLITE_DIRECTONLY flag means that the function may only be invoked +** from top-level SQL, and cannot be used in VIEWs or TRIGGERs nor in +** schema structures such as [CHECK constraints], [DEFAULT clauses], +** [expression indexes], [partial indexes], or [generated columns]. +**

    +** The SQLITE_DIRECTONLY flag is recommended for any +** [application-defined SQL function] +** that has side-effects or that could potentially leak sensitive information. +** This will prevent attacks in which an application is tricked +** into using a database file that has had its schema surreptiously +** modified to invoke the application-defined function in ways that are +** harmful. +**

    +** Some people say it is good practice to set SQLITE_DIRECTONLY on all +** [application-defined SQL functions], regardless of whether or not they +** are security sensitive, as doing so prevents those functions from being used +** inside of the database schema, and thus ensures that the database +** can be inspected and modified using generic tools (such as the [CLI]) +** that do not have access to the application-defined functions. +**

    +** +** [[SQLITE_INNOCUOUS]]
    SQLITE_INNOCUOUS
    +** The SQLITE_INNOCUOUS flag means that the function is unlikely +** to cause problems even if misused. An innocuous function should have +** no side effects and should not depend on any values other than its +** input parameters. The [abs|abs() function] is an example of an +** innocuous function. +** The [load_extension() SQL function] is not innocuous because of its +** side effects. +**

    SQLITE_INNOCUOUS is similar to SQLITE_DETERMINISTIC, but is not +** exactly the same. The [random|random() function] is an example of a +** function that is innocuous but not deterministic. +**

    Some heightened security settings +** ([SQLITE_DBCONFIG_TRUSTED_SCHEMA] and [PRAGMA trusted_schema=OFF]) +** disable the use of SQL functions inside views and triggers and in +** schema structures such as [CHECK constraints], [DEFAULT clauses], +** [expression indexes], [partial indexes], and [generated columns] unless +** the function is tagged with SQLITE_INNOCUOUS. Most built-in functions +** are innocuous. Developers are advised to avoid using the +** SQLITE_INNOCUOUS flag for application-defined functions unless the +** function has been carefully audited and found to be free of potentially +** security-adverse side-effects and information-leaks. +**

    +** +** [[SQLITE_SUBTYPE]]
    SQLITE_SUBTYPE
    +** The SQLITE_SUBTYPE flag indicates to SQLite that a function may call +** [sqlite3_value_subtype()] to inspect the sub-types of its arguments. +** Specifying this flag makes no difference for scalar or aggregate user +** functions. However, if it is not specified for a user-defined window +** function, then any sub-types belonging to arguments passed to the window +** function may be discarded before the window function is called (i.e. +** sqlite3_value_subtype() will always return 0). +**
    +**
    +*/ +#define SQLITE_DETERMINISTIC 0x000000800 +#define SQLITE_DIRECTONLY 0x000080000 +#define SQLITE_SUBTYPE 0x000100000 +#define SQLITE_INNOCUOUS 0x000200000 + +/* +** CAPI3REF: Deprecated Functions +** DEPRECATED +** +** These functions are [deprecated]. In order to maintain +** backwards compatibility with older code, these functions continue +** to be supported. However, new applications should avoid +** the use of these functions. To encourage programmers to avoid +** these functions, we will not explain what they do. +*/ +#ifndef SQLITE_OMIT_DEPRECATED +SQLITE_API SQLITE_DEPRECATED int sqlite3_aggregate_count(sqlite3_context*); +SQLITE_API SQLITE_DEPRECATED int sqlite3_expired(sqlite3_stmt*); +SQLITE_API SQLITE_DEPRECATED int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*); +SQLITE_API SQLITE_DEPRECATED int sqlite3_global_recover(void); +SQLITE_API SQLITE_DEPRECATED void sqlite3_thread_cleanup(void); +SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int), + void*,sqlite3_int64); +#endif + +/* +** CAPI3REF: Obtaining SQL Values +** METHOD: sqlite3_value +** +** Summary: +**
    +**
    sqlite3_value_blob→BLOB value +**
    sqlite3_value_double→REAL value +**
    sqlite3_value_int→32-bit INTEGER value +**
    sqlite3_value_int64→64-bit INTEGER value +**
    sqlite3_value_pointer→Pointer value +**
    sqlite3_value_text→UTF-8 TEXT value +**
    sqlite3_value_text16→UTF-16 TEXT value in +** the native byteorder +**
    sqlite3_value_text16be→UTF-16be TEXT value +**
    sqlite3_value_text16le→UTF-16le TEXT value +**
        +**
    sqlite3_value_bytes→Size of a BLOB +** or a UTF-8 TEXT in bytes +**
    sqlite3_value_bytes16   +** →  Size of UTF-16 +** TEXT in bytes +**
    sqlite3_value_type→Default +** datatype of the value +**
    sqlite3_value_numeric_type   +** →  Best numeric datatype of the value +**
    sqlite3_value_nochange   +** →  True if the column is unchanged in an UPDATE +** against a virtual table. +**
    sqlite3_value_frombind   +** →  True if value originated from a [bound parameter] +**
    +** +** Details: +** +** These routines extract type, size, and content information from +** [protected sqlite3_value] objects. Protected sqlite3_value objects +** are used to pass parameter information into the functions that +** implement [application-defined SQL functions] and [virtual tables]. +** +** These routines work only with [protected sqlite3_value] objects. +** Any attempt to use these routines on an [unprotected sqlite3_value] +** is not threadsafe. +** +** ^These routines work just like the corresponding [column access functions] +** except that these routines take a single [protected sqlite3_value] object +** pointer instead of a [sqlite3_stmt*] pointer and an integer column number. +** +** ^The sqlite3_value_text16() interface extracts a UTF-16 string +** in the native byte-order of the host machine. ^The +** sqlite3_value_text16be() and sqlite3_value_text16le() interfaces +** extract UTF-16 strings as big-endian and little-endian respectively. +** +** ^If [sqlite3_value] object V was initialized +** using [sqlite3_bind_pointer(S,I,P,X,D)] or [sqlite3_result_pointer(C,P,X,D)] +** and if X and Y are strings that compare equal according to strcmp(X,Y), +** then sqlite3_value_pointer(V,Y) will return the pointer P. ^Otherwise, +** sqlite3_value_pointer(V,Y) returns a NULL. The sqlite3_bind_pointer() +** routine is part of the [pointer passing interface] added for SQLite 3.20.0. +** +** ^(The sqlite3_value_type(V) interface returns the +** [SQLITE_INTEGER | datatype code] for the initial datatype of the +** [sqlite3_value] object V. The returned value is one of [SQLITE_INTEGER], +** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL].)^ +** Other interfaces might change the datatype for an sqlite3_value object. +** For example, if the datatype is initially SQLITE_INTEGER and +** sqlite3_value_text(V) is called to extract a text value for that +** integer, then subsequent calls to sqlite3_value_type(V) might return +** SQLITE_TEXT. Whether or not a persistent internal datatype conversion +** occurs is undefined and may change from one release of SQLite to the next. +** +** ^(The sqlite3_value_numeric_type() interface attempts to apply +** numeric affinity to the value. This means that an attempt is +** made to convert the value to an integer or floating point. If +** such a conversion is possible without loss of information (in other +** words, if the value is a string that looks like a number) +** then the conversion is performed. Otherwise no conversion occurs. +** The [SQLITE_INTEGER | datatype] after conversion is returned.)^ +** +** ^Within the [xUpdate] method of a [virtual table], the +** sqlite3_value_nochange(X) interface returns true if and only if +** the column corresponding to X is unchanged by the UPDATE operation +** that the xUpdate method call was invoked to implement and if +** and the prior [xColumn] method call that was invoked to extracted +** the value for that column returned without setting a result (probably +** because it queried [sqlite3_vtab_nochange()] and found that the column +** was unchanging). ^Within an [xUpdate] method, any value for which +** sqlite3_value_nochange(X) is true will in all other respects appear +** to be a NULL value. If sqlite3_value_nochange(X) is invoked anywhere other +** than within an [xUpdate] method call for an UPDATE statement, then +** the return value is arbitrary and meaningless. +** +** ^The sqlite3_value_frombind(X) interface returns non-zero if the +** value X originated from one of the [sqlite3_bind_int|sqlite3_bind()] +** interfaces. ^If X comes from an SQL literal value, or a table column, +** or an expression, then sqlite3_value_frombind(X) returns zero. +** +** Please pay particular attention to the fact that the pointer returned +** from [sqlite3_value_blob()], [sqlite3_value_text()], or +** [sqlite3_value_text16()] can be invalidated by a subsequent call to +** [sqlite3_value_bytes()], [sqlite3_value_bytes16()], [sqlite3_value_text()], +** or [sqlite3_value_text16()]. +** +** These routines must be called from the same thread as +** the SQL function that supplied the [sqlite3_value*] parameters. +** +** As long as the input parameter is correct, these routines can only +** fail if an out-of-memory error occurs during a format conversion. +** Only the following subset of interfaces are subject to out-of-memory +** errors: +** +**
      +**
    • sqlite3_value_blob() +**
    • sqlite3_value_text() +**
    • sqlite3_value_text16() +**
    • sqlite3_value_text16le() +**
    • sqlite3_value_text16be() +**
    • sqlite3_value_bytes() +**
    • sqlite3_value_bytes16() +**
    +** +** If an out-of-memory error occurs, then the return value from these +** routines is the same as if the column had contained an SQL NULL value. +** Valid SQL NULL returns can be distinguished from out-of-memory errors +** by invoking the [sqlite3_errcode()] immediately after the suspect +** return value is obtained and before any +** other SQLite interface is called on the same [database connection]. +*/ +SQLITE_API const void *sqlite3_value_blob(sqlite3_value*); +SQLITE_API double sqlite3_value_double(sqlite3_value*); +SQLITE_API int sqlite3_value_int(sqlite3_value*); +SQLITE_API sqlite3_int64 sqlite3_value_int64(sqlite3_value*); +SQLITE_API void *sqlite3_value_pointer(sqlite3_value*, const char*); +SQLITE_API const unsigned char *sqlite3_value_text(sqlite3_value*); +SQLITE_API const void *sqlite3_value_text16(sqlite3_value*); +SQLITE_API const void *sqlite3_value_text16le(sqlite3_value*); +SQLITE_API const void *sqlite3_value_text16be(sqlite3_value*); +SQLITE_API int sqlite3_value_bytes(sqlite3_value*); +SQLITE_API int sqlite3_value_bytes16(sqlite3_value*); +SQLITE_API int sqlite3_value_type(sqlite3_value*); +SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*); +SQLITE_API int sqlite3_value_nochange(sqlite3_value*); +SQLITE_API int sqlite3_value_frombind(sqlite3_value*); + +/* +** CAPI3REF: Report the internal text encoding state of an sqlite3_value object +** METHOD: sqlite3_value +** +** ^(The sqlite3_value_encoding(X) interface returns one of [SQLITE_UTF8], +** [SQLITE_UTF16BE], or [SQLITE_UTF16LE] according to the current text encoding +** of the value X, assuming that X has type TEXT.)^ If sqlite3_value_type(X) +** returns something other than SQLITE_TEXT, then the return value from +** sqlite3_value_encoding(X) is meaningless. ^Calls to +** [sqlite3_value_text(X)], [sqlite3_value_text16(X)], [sqlite3_value_text16be(X)], +** [sqlite3_value_text16le(X)], [sqlite3_value_bytes(X)], or +** [sqlite3_value_bytes16(X)] might change the encoding of the value X and +** thus change the return from subsequent calls to sqlite3_value_encoding(X). +** +** This routine is intended for used by applications that test and validate +** the SQLite implementation. This routine is inquiring about the opaque +** internal state of an [sqlite3_value] object. Ordinary applications should +** not need to know what the internal state of an sqlite3_value object is and +** hence should not need to use this interface. +*/ +SQLITE_API int sqlite3_value_encoding(sqlite3_value*); + +/* +** CAPI3REF: Finding The Subtype Of SQL Values +** METHOD: sqlite3_value +** +** The sqlite3_value_subtype(V) function returns the subtype for +** an [application-defined SQL function] argument V. The subtype +** information can be used to pass a limited amount of context from +** one SQL function to another. Use the [sqlite3_result_subtype()] +** routine to set the subtype for the return value of an SQL function. +*/ +SQLITE_API unsigned int sqlite3_value_subtype(sqlite3_value*); + +/* +** CAPI3REF: Copy And Free SQL Values +** METHOD: sqlite3_value +** +** ^The sqlite3_value_dup(V) interface makes a copy of the [sqlite3_value] +** object D and returns a pointer to that copy. ^The [sqlite3_value] returned +** is a [protected sqlite3_value] object even if the input is not. +** ^The sqlite3_value_dup(V) interface returns NULL if V is NULL or if a +** memory allocation fails. ^If V is a [pointer value], then the result +** of sqlite3_value_dup(V) is a NULL value. +** +** ^The sqlite3_value_free(V) interface frees an [sqlite3_value] object +** previously obtained from [sqlite3_value_dup()]. ^If V is a NULL pointer +** then sqlite3_value_free(V) is a harmless no-op. +*/ +SQLITE_API sqlite3_value *sqlite3_value_dup(const sqlite3_value*); +SQLITE_API void sqlite3_value_free(sqlite3_value*); + +/* +** CAPI3REF: Obtain Aggregate Function Context +** METHOD: sqlite3_context +** +** Implementations of aggregate SQL functions use this +** routine to allocate memory for storing their state. +** +** ^The first time the sqlite3_aggregate_context(C,N) routine is called +** for a particular aggregate function, SQLite allocates +** N bytes of memory, zeroes out that memory, and returns a pointer +** to the new memory. ^On second and subsequent calls to +** sqlite3_aggregate_context() for the same aggregate function instance, +** the same buffer is returned. Sqlite3_aggregate_context() is normally +** called once for each invocation of the xStep callback and then one +** last time when the xFinal callback is invoked. ^(When no rows match +** an aggregate query, the xStep() callback of the aggregate function +** implementation is never called and xFinal() is called exactly once. +** In those cases, sqlite3_aggregate_context() might be called for the +** first time from within xFinal().)^ +** +** ^The sqlite3_aggregate_context(C,N) routine returns a NULL pointer +** when first called if N is less than or equal to zero or if a memory +** allocation error occurs. +** +** ^(The amount of space allocated by sqlite3_aggregate_context(C,N) is +** determined by the N parameter on first successful call. Changing the +** value of N in any subsequent call to sqlite3_aggregate_context() within +** the same aggregate function instance will not resize the memory +** allocation.)^ Within the xFinal callback, it is customary to set +** N=0 in calls to sqlite3_aggregate_context(C,N) so that no +** pointless memory allocations occur. +** +** ^SQLite automatically frees the memory allocated by +** sqlite3_aggregate_context() when the aggregate query concludes. +** +** The first parameter must be a copy of the +** [sqlite3_context | SQL function context] that is the first parameter +** to the xStep or xFinal callback routine that implements the aggregate +** function. +** +** This routine must be called from the same thread in which +** the aggregate SQL function is running. +*/ +SQLITE_API void *sqlite3_aggregate_context(sqlite3_context*, int nBytes); + +/* +** CAPI3REF: User Data For Functions +** METHOD: sqlite3_context +** +** ^The sqlite3_user_data() interface returns a copy of +** the pointer that was the pUserData parameter (the 5th parameter) +** of the [sqlite3_create_function()] +** and [sqlite3_create_function16()] routines that originally +** registered the application defined function. +** +** This routine must be called from the same thread in which +** the application-defined function is running. +*/ +SQLITE_API void *sqlite3_user_data(sqlite3_context*); + +/* +** CAPI3REF: Database Connection For Functions +** METHOD: sqlite3_context +** +** ^The sqlite3_context_db_handle() interface returns a copy of +** the pointer to the [database connection] (the 1st parameter) +** of the [sqlite3_create_function()] +** and [sqlite3_create_function16()] routines that originally +** registered the application defined function. +*/ +SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context*); + +/* +** CAPI3REF: Function Auxiliary Data +** METHOD: sqlite3_context +** +** These functions may be used by (non-aggregate) SQL functions to +** associate metadata with argument values. If the same value is passed to +** multiple invocations of the same SQL function during query execution, under +** some circumstances the associated metadata may be preserved. An example +** of where this might be useful is in a regular-expression matching +** function. The compiled version of the regular expression can be stored as +** metadata associated with the pattern string. +** Then as long as the pattern string remains the same, +** the compiled regular expression can be reused on multiple +** invocations of the same function. +** +** ^The sqlite3_get_auxdata(C,N) interface returns a pointer to the metadata +** associated by the sqlite3_set_auxdata(C,N,P,X) function with the Nth argument +** value to the application-defined function. ^N is zero for the left-most +** function argument. ^If there is no metadata +** associated with the function argument, the sqlite3_get_auxdata(C,N) interface +** returns a NULL pointer. +** +** ^The sqlite3_set_auxdata(C,N,P,X) interface saves P as metadata for the N-th +** argument of the application-defined function. ^Subsequent +** calls to sqlite3_get_auxdata(C,N) return P from the most recent +** sqlite3_set_auxdata(C,N,P,X) call if the metadata is still valid or +** NULL if the metadata has been discarded. +** ^After each call to sqlite3_set_auxdata(C,N,P,X) where X is not NULL, +** SQLite will invoke the destructor function X with parameter P exactly +** once, when the metadata is discarded. +** SQLite is free to discard the metadata at any time, including:
      +**
    • ^(when the corresponding function parameter changes)^, or +**
    • ^(when [sqlite3_reset()] or [sqlite3_finalize()] is called for the +** SQL statement)^, or +**
    • ^(when sqlite3_set_auxdata() is invoked again on the same +** parameter)^, or +**
    • ^(during the original sqlite3_set_auxdata() call when a memory +** allocation error occurs.)^
    +** +** Note the last bullet in particular. The destructor X in +** sqlite3_set_auxdata(C,N,P,X) might be called immediately, before the +** sqlite3_set_auxdata() interface even returns. Hence sqlite3_set_auxdata() +** should be called near the end of the function implementation and the +** function implementation should not make any use of P after +** sqlite3_set_auxdata() has been called. +** +** ^(In practice, metadata is preserved between function calls for +** function parameters that are compile-time constants, including literal +** values and [parameters] and expressions composed from the same.)^ +** +** The value of the N parameter to these interfaces should be non-negative. +** Future enhancements may make use of negative N values to define new +** kinds of function caching behavior. +** +** These routines must be called from the same thread in which +** the SQL function is running. +*/ +SQLITE_API void *sqlite3_get_auxdata(sqlite3_context*, int N); +SQLITE_API void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*)); + + +/* +** CAPI3REF: Constants Defining Special Destructor Behavior +** +** These are special values for the destructor that is passed in as the +** final argument to routines like [sqlite3_result_blob()]. ^If the destructor +** argument is SQLITE_STATIC, it means that the content pointer is constant +** and will never change. It does not need to be destroyed. ^The +** SQLITE_TRANSIENT value means that the content will likely change in +** the near future and that SQLite should make its own private copy of +** the content before returning. +** +** The typedef is necessary to work around problems in certain +** C++ compilers. +*/ +typedef void (*sqlite3_destructor_type)(void*); +#define SQLITE_STATIC ((sqlite3_destructor_type)0) +#define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1) + +/* +** CAPI3REF: Setting The Result Of An SQL Function +** METHOD: sqlite3_context +** +** These routines are used by the xFunc or xFinal callbacks that +** implement SQL functions and aggregates. See +** [sqlite3_create_function()] and [sqlite3_create_function16()] +** for additional information. +** +** These functions work very much like the [parameter binding] family of +** functions used to bind values to host parameters in prepared statements. +** Refer to the [SQL parameter] documentation for additional information. +** +** ^The sqlite3_result_blob() interface sets the result from +** an application-defined function to be the BLOB whose content is pointed +** to by the second parameter and which is N bytes long where N is the +** third parameter. +** +** ^The sqlite3_result_zeroblob(C,N) and sqlite3_result_zeroblob64(C,N) +** interfaces set the result of the application-defined function to be +** a BLOB containing all zero bytes and N bytes in size. +** +** ^The sqlite3_result_double() interface sets the result from +** an application-defined function to be a floating point value specified +** by its 2nd argument. +** +** ^The sqlite3_result_error() and sqlite3_result_error16() functions +** cause the implemented SQL function to throw an exception. +** ^SQLite uses the string pointed to by the +** 2nd parameter of sqlite3_result_error() or sqlite3_result_error16() +** as the text of an error message. ^SQLite interprets the error +** message string from sqlite3_result_error() as UTF-8. ^SQLite +** interprets the string from sqlite3_result_error16() as UTF-16 using +** the same [byte-order determination rules] as [sqlite3_bind_text16()]. +** ^If the third parameter to sqlite3_result_error() +** or sqlite3_result_error16() is negative then SQLite takes as the error +** message all text up through the first zero character. +** ^If the third parameter to sqlite3_result_error() or +** sqlite3_result_error16() is non-negative then SQLite takes that many +** bytes (not characters) from the 2nd parameter as the error message. +** ^The sqlite3_result_error() and sqlite3_result_error16() +** routines make a private copy of the error message text before +** they return. Hence, the calling function can deallocate or +** modify the text after they return without harm. +** ^The sqlite3_result_error_code() function changes the error code +** returned by SQLite as a result of an error in a function. ^By default, +** the error code is SQLITE_ERROR. ^A subsequent call to sqlite3_result_error() +** or sqlite3_result_error16() resets the error code to SQLITE_ERROR. +** +** ^The sqlite3_result_error_toobig() interface causes SQLite to throw an +** error indicating that a string or BLOB is too long to represent. +** +** ^The sqlite3_result_error_nomem() interface causes SQLite to throw an +** error indicating that a memory allocation failed. +** +** ^The sqlite3_result_int() interface sets the return value +** of the application-defined function to be the 32-bit signed integer +** value given in the 2nd argument. +** ^The sqlite3_result_int64() interface sets the return value +** of the application-defined function to be the 64-bit signed integer +** value given in the 2nd argument. +** +** ^The sqlite3_result_null() interface sets the return value +** of the application-defined function to be NULL. +** +** ^The sqlite3_result_text(), sqlite3_result_text16(), +** sqlite3_result_text16le(), and sqlite3_result_text16be() interfaces +** set the return value of the application-defined function to be +** a text string which is represented as UTF-8, UTF-16 native byte order, +** UTF-16 little endian, or UTF-16 big endian, respectively. +** ^The sqlite3_result_text64() interface sets the return value of an +** application-defined function to be a text string in an encoding +** specified by the fifth (and last) parameter, which must be one +** of [SQLITE_UTF8], [SQLITE_UTF16], [SQLITE_UTF16BE], or [SQLITE_UTF16LE]. +** ^SQLite takes the text result from the application from +** the 2nd parameter of the sqlite3_result_text* interfaces. +** ^If the 3rd parameter to any of the sqlite3_result_text* interfaces +** other than sqlite3_result_text64() is negative, then SQLite computes +** the string length itself by searching the 2nd parameter for the first +** zero character. +** ^If the 3rd parameter to the sqlite3_result_text* interfaces +** is non-negative, then as many bytes (not characters) of the text +** pointed to by the 2nd parameter are taken as the application-defined +** function result. If the 3rd parameter is non-negative, then it +** must be the byte offset into the string where the NUL terminator would +** appear if the string where NUL terminated. If any NUL characters occur +** in the string at a byte offset that is less than the value of the 3rd +** parameter, then the resulting string will contain embedded NULs and the +** result of expressions operating on strings with embedded NULs is undefined. +** ^If the 4th parameter to the sqlite3_result_text* interfaces +** or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that +** function as the destructor on the text or BLOB result when it has +** finished using that result. +** ^If the 4th parameter to the sqlite3_result_text* interfaces or to +** sqlite3_result_blob is the special constant SQLITE_STATIC, then SQLite +** assumes that the text or BLOB result is in constant space and does not +** copy the content of the parameter nor call a destructor on the content +** when it has finished using that result. +** ^If the 4th parameter to the sqlite3_result_text* interfaces +** or sqlite3_result_blob is the special constant SQLITE_TRANSIENT +** then SQLite makes a copy of the result into space obtained +** from [sqlite3_malloc()] before it returns. +** +** ^For the sqlite3_result_text16(), sqlite3_result_text16le(), and +** sqlite3_result_text16be() routines, and for sqlite3_result_text64() +** when the encoding is not UTF8, if the input UTF16 begins with a +** byte-order mark (BOM, U+FEFF) then the BOM is removed from the +** string and the rest of the string is interpreted according to the +** byte-order specified by the BOM. ^The byte-order specified by +** the BOM at the beginning of the text overrides the byte-order +** specified by the interface procedure. ^So, for example, if +** sqlite3_result_text16le() is invoked with text that begins +** with bytes 0xfe, 0xff (a big-endian byte-order mark) then the +** first two bytes of input are skipped and the remaining input +** is interpreted as UTF16BE text. +** +** ^For UTF16 input text to the sqlite3_result_text16(), +** sqlite3_result_text16be(), sqlite3_result_text16le(), and +** sqlite3_result_text64() routines, if the text contains invalid +** UTF16 characters, the invalid characters might be converted +** into the unicode replacement character, U+FFFD. +** +** ^The sqlite3_result_value() interface sets the result of +** the application-defined function to be a copy of the +** [unprotected sqlite3_value] object specified by the 2nd parameter. ^The +** sqlite3_result_value() interface makes a copy of the [sqlite3_value] +** so that the [sqlite3_value] specified in the parameter may change or +** be deallocated after sqlite3_result_value() returns without harm. +** ^A [protected sqlite3_value] object may always be used where an +** [unprotected sqlite3_value] object is required, so either +** kind of [sqlite3_value] object can be used with this interface. +** +** ^The sqlite3_result_pointer(C,P,T,D) interface sets the result to an +** SQL NULL value, just like [sqlite3_result_null(C)], except that it +** also associates the host-language pointer P or type T with that +** NULL value such that the pointer can be retrieved within an +** [application-defined SQL function] using [sqlite3_value_pointer()]. +** ^If the D parameter is not NULL, then it is a pointer to a destructor +** for the P parameter. ^SQLite invokes D with P as its only argument +** when SQLite is finished with P. The T parameter should be a static +** string and preferably a string literal. The sqlite3_result_pointer() +** routine is part of the [pointer passing interface] added for SQLite 3.20.0. +** +** If these routines are called from within the different thread +** than the one containing the application-defined function that received +** the [sqlite3_context] pointer, the results are undefined. +*/ +SQLITE_API void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*)); +SQLITE_API void sqlite3_result_blob64(sqlite3_context*,const void*, + sqlite3_uint64,void(*)(void*)); +SQLITE_API void sqlite3_result_double(sqlite3_context*, double); +SQLITE_API void sqlite3_result_error(sqlite3_context*, const char*, int); +SQLITE_API void sqlite3_result_error16(sqlite3_context*, const void*, int); +SQLITE_API void sqlite3_result_error_toobig(sqlite3_context*); +SQLITE_API void sqlite3_result_error_nomem(sqlite3_context*); +SQLITE_API void sqlite3_result_error_code(sqlite3_context*, int); +SQLITE_API void sqlite3_result_int(sqlite3_context*, int); +SQLITE_API void sqlite3_result_int64(sqlite3_context*, sqlite3_int64); +SQLITE_API void sqlite3_result_null(sqlite3_context*); +SQLITE_API void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*)); +SQLITE_API void sqlite3_result_text64(sqlite3_context*, const char*,sqlite3_uint64, + void(*)(void*), unsigned char encoding); +SQLITE_API void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*)); +SQLITE_API void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*)); +SQLITE_API void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*)); +SQLITE_API void sqlite3_result_value(sqlite3_context*, sqlite3_value*); +SQLITE_API void sqlite3_result_pointer(sqlite3_context*, void*,const char*,void(*)(void*)); +SQLITE_API void sqlite3_result_zeroblob(sqlite3_context*, int n); +SQLITE_API int sqlite3_result_zeroblob64(sqlite3_context*, sqlite3_uint64 n); + + +/* +** CAPI3REF: Setting The Subtype Of An SQL Function +** METHOD: sqlite3_context +** +** The sqlite3_result_subtype(C,T) function causes the subtype of +** the result from the [application-defined SQL function] with +** [sqlite3_context] C to be the value T. Only the lower 8 bits +** of the subtype T are preserved in current versions of SQLite; +** higher order bits are discarded. +** The number of subtype bytes preserved by SQLite might increase +** in future releases of SQLite. +*/ +SQLITE_API void sqlite3_result_subtype(sqlite3_context*,unsigned int); + +/* +** CAPI3REF: Define New Collating Sequences +** METHOD: sqlite3 +** +** ^These functions add, remove, or modify a [collation] associated +** with the [database connection] specified as the first argument. +** +** ^The name of the collation is a UTF-8 string +** for sqlite3_create_collation() and sqlite3_create_collation_v2() +** and a UTF-16 string in native byte order for sqlite3_create_collation16(). +** ^Collation names that compare equal according to [sqlite3_strnicmp()] are +** considered to be the same name. +** +** ^(The third argument (eTextRep) must be one of the constants: +**
      +**
    • [SQLITE_UTF8], +**
    • [SQLITE_UTF16LE], +**
    • [SQLITE_UTF16BE], +**
    • [SQLITE_UTF16], or +**
    • [SQLITE_UTF16_ALIGNED]. +**
    )^ +** ^The eTextRep argument determines the encoding of strings passed +** to the collating function callback, xCompare. +** ^The [SQLITE_UTF16] and [SQLITE_UTF16_ALIGNED] values for eTextRep +** force strings to be UTF16 with native byte order. +** ^The [SQLITE_UTF16_ALIGNED] value for eTextRep forces strings to begin +** on an even byte address. +** +** ^The fourth argument, pArg, is an application data pointer that is passed +** through as the first argument to the collating function callback. +** +** ^The fifth argument, xCompare, is a pointer to the collating function. +** ^Multiple collating functions can be registered using the same name but +** with different eTextRep parameters and SQLite will use whichever +** function requires the least amount of data transformation. +** ^If the xCompare argument is NULL then the collating function is +** deleted. ^When all collating functions having the same name are deleted, +** that collation is no longer usable. +** +** ^The collating function callback is invoked with a copy of the pArg +** application data pointer and with two strings in the encoding specified +** by the eTextRep argument. The two integer parameters to the collating +** function callback are the length of the two strings, in bytes. The collating +** function must return an integer that is negative, zero, or positive +** if the first string is less than, equal to, or greater than the second, +** respectively. A collating function must always return the same answer +** given the same inputs. If two or more collating functions are registered +** to the same collation name (using different eTextRep values) then all +** must give an equivalent answer when invoked with equivalent strings. +** The collating function must obey the following properties for all +** strings A, B, and C: +** +**
      +**
    1. If A==B then B==A. +**
    2. If A==B and B==C then A==C. +**
    3. If A<B THEN B>A. +**
    4. If A<B and B<C then A<C. +**
    +** +** If a collating function fails any of the above constraints and that +** collating function is registered and used, then the behavior of SQLite +** is undefined. +** +** ^The sqlite3_create_collation_v2() works like sqlite3_create_collation() +** with the addition that the xDestroy callback is invoked on pArg when +** the collating function is deleted. +** ^Collating functions are deleted when they are overridden by later +** calls to the collation creation functions or when the +** [database connection] is closed using [sqlite3_close()]. +** +** ^The xDestroy callback is not called if the +** sqlite3_create_collation_v2() function fails. Applications that invoke +** sqlite3_create_collation_v2() with a non-NULL xDestroy argument should +** check the return code and dispose of the application data pointer +** themselves rather than expecting SQLite to deal with it for them. +** This is different from every other SQLite interface. The inconsistency +** is unfortunate but cannot be changed without breaking backwards +** compatibility. +** +** See also: [sqlite3_collation_needed()] and [sqlite3_collation_needed16()]. +*/ +SQLITE_API int sqlite3_create_collation( + sqlite3*, + const char *zName, + int eTextRep, + void *pArg, + int(*xCompare)(void*,int,const void*,int,const void*) +); +SQLITE_API int sqlite3_create_collation_v2( + sqlite3*, + const char *zName, + int eTextRep, + void *pArg, + int(*xCompare)(void*,int,const void*,int,const void*), + void(*xDestroy)(void*) +); +SQLITE_API int sqlite3_create_collation16( + sqlite3*, + const void *zName, + int eTextRep, + void *pArg, + int(*xCompare)(void*,int,const void*,int,const void*) +); + +/* +** CAPI3REF: Collation Needed Callbacks +** METHOD: sqlite3 +** +** ^To avoid having to register all collation sequences before a database +** can be used, a single callback function may be registered with the +** [database connection] to be invoked whenever an undefined collation +** sequence is required. +** +** ^If the function is registered using the sqlite3_collation_needed() API, +** then it is passed the names of undefined collation sequences as strings +** encoded in UTF-8. ^If sqlite3_collation_needed16() is used, +** the names are passed as UTF-16 in machine native byte order. +** ^A call to either function replaces the existing collation-needed callback. +** +** ^(When the callback is invoked, the first argument passed is a copy +** of the second argument to sqlite3_collation_needed() or +** sqlite3_collation_needed16(). The second argument is the database +** connection. The third argument is one of [SQLITE_UTF8], [SQLITE_UTF16BE], +** or [SQLITE_UTF16LE], indicating the most desirable form of the collation +** sequence function required. The fourth parameter is the name of the +** required collation sequence.)^ +** +** The callback function should register the desired collation using +** [sqlite3_create_collation()], [sqlite3_create_collation16()], or +** [sqlite3_create_collation_v2()]. +*/ +SQLITE_API int sqlite3_collation_needed( + sqlite3*, + void*, + void(*)(void*,sqlite3*,int eTextRep,const char*) +); +SQLITE_API int sqlite3_collation_needed16( + sqlite3*, + void*, + void(*)(void*,sqlite3*,int eTextRep,const void*) +); + +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC +/* +** Specify the key for an encrypted database. This routine should be +** called right after sqlite3_open(). +** +** The code to implement this API is not available in the public release +** of SQLite. +*/ +SQLITE_API int sqlite3_key( + sqlite3 *db, /* Database to be rekeyed */ + const void *pKey, int nKey /* The key */ +); +SQLITE_API int sqlite3_key_v2( + sqlite3 *db, /* Database to be rekeyed */ + const char *zDbName, /* Name of the database */ + const void *pKey, int nKey /* The key */ +); + +/* +** Change the key on an open database. If the current database is not +** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the +** database is decrypted. +** +** The code to implement this API is not available in the public release +** of SQLite. +*/ +/* SQLCipher usage note: + + If the current database is plaintext SQLCipher will NOT encrypt it. + If the current database is encrypted and pNew==0 or nNew==0, SQLCipher + will NOT decrypt it. + + This routine will ONLY work on an already encrypted database in order + to change the key. + + Conversion from plaintext-to-encrypted or encrypted-to-plaintext should + use an ATTACHed database and the sqlcipher_export() convenience function + as per the SQLCipher Documentation. +*/ +SQLITE_API int sqlite3_rekey( + sqlite3 *db, /* Database to be rekeyed */ + const void *pKey, int nKey /* The new key */ +); +SQLITE_API int sqlite3_rekey_v2( + sqlite3 *db, /* Database to be rekeyed */ + const char *zDbName, /* Name of the database */ + const void *pKey, int nKey /* The new key */ +); + +/* +** Specify the activation key for a SEE database. Unless +** activated, none of the SEE routines will work. +*/ +SQLITE_API void sqlite3_activate_see( + const char *zPassPhrase /* Activation phrase */ +); +#endif +/* END SQLCIPHER */ + +#ifdef SQLITE_ENABLE_CEROD +/* +** Specify the activation key for a CEROD database. Unless +** activated, none of the CEROD routines will work. +*/ +SQLITE_API void sqlite3_activate_cerod( + const char *zPassPhrase /* Activation phrase */ +); +#endif + +/* +** CAPI3REF: Suspend Execution For A Short Time +** +** The sqlite3_sleep() function causes the current thread to suspend execution +** for at least a number of milliseconds specified in its parameter. +** +** If the operating system does not support sleep requests with +** millisecond time resolution, then the time will be rounded up to +** the nearest second. The number of milliseconds of sleep actually +** requested from the operating system is returned. +** +** ^SQLite implements this interface by calling the xSleep() +** method of the default [sqlite3_vfs] object. If the xSleep() method +** of the default VFS is not implemented correctly, or not implemented at +** all, then the behavior of sqlite3_sleep() may deviate from the description +** in the previous paragraphs. +** +** If a negative argument is passed to sqlite3_sleep() the results vary by +** VFS and operating system. Some system treat a negative argument as an +** instruction to sleep forever. Others understand it to mean do not sleep +** at all. ^In SQLite version 3.42.0 and later, a negative +** argument passed into sqlite3_sleep() is changed to zero before it is relayed +** down into the xSleep method of the VFS. +*/ +SQLITE_API int sqlite3_sleep(int); + +/* +** CAPI3REF: Name Of The Folder Holding Temporary Files +** +** ^(If this global variable is made to point to a string which is +** the name of a folder (a.k.a. directory), then all temporary files +** created by SQLite when using a built-in [sqlite3_vfs | VFS] +** will be placed in that directory.)^ ^If this variable +** is a NULL pointer, then SQLite performs a search for an appropriate +** temporary file directory. +** +** Applications are strongly discouraged from using this global variable. +** It is required to set a temporary folder on Windows Runtime (WinRT). +** But for all other platforms, it is highly recommended that applications +** neither read nor write this variable. This global variable is a relic +** that exists for backwards compatibility of legacy applications and should +** be avoided in new projects. +** +** It is not safe to read or modify this variable in more than one +** thread at a time. It is not safe to read or modify this variable +** if a [database connection] is being used at the same time in a separate +** thread. +** It is intended that this variable be set once +** as part of process initialization and before any SQLite interface +** routines have been called and that this variable remain unchanged +** thereafter. +** +** ^The [temp_store_directory pragma] may modify this variable and cause +** it to point to memory obtained from [sqlite3_malloc]. ^Furthermore, +** the [temp_store_directory pragma] always assumes that any string +** that this variable points to is held in memory obtained from +** [sqlite3_malloc] and the pragma may attempt to free that memory +** using [sqlite3_free]. +** Hence, if this variable is modified directly, either it should be +** made NULL or made to point to memory obtained from [sqlite3_malloc] +** or else the use of the [temp_store_directory pragma] should be avoided. +** Except when requested by the [temp_store_directory pragma], SQLite +** does not free the memory that sqlite3_temp_directory points to. If +** the application wants that memory to be freed, it must do +** so itself, taking care to only do so after all [database connection] +** objects have been destroyed. +** +** Note to Windows Runtime users: The temporary directory must be set +** prior to calling [sqlite3_open] or [sqlite3_open_v2]. Otherwise, various +** features that require the use of temporary files may fail. Here is an +** example of how to do this using C++ with the Windows Runtime: +** +** 
    +** LPCWSTR zPath = Windows::Storage::ApplicationData::Current->
+**       TemporaryFolder->Path->Data();
+** char zPathBuf[MAX_PATH + 1];
+** memset(zPathBuf, 0, sizeof(zPathBuf));
+** WideCharToMultiByte(CP_UTF8, 0, zPath, -1, zPathBuf, sizeof(zPathBuf),
+**       NULL, NULL);
+** sqlite3_temp_directory = sqlite3_mprintf("%s", zPathBuf);
+**
    +*/ +SQLITE_API char *sqlite3_temp_directory; + +/* +** CAPI3REF: Name Of The Folder Holding Database Files +** +** ^(If this global variable is made to point to a string which is +** the name of a folder (a.k.a. directory), then all database files +** specified with a relative pathname and created or accessed by +** SQLite when using a built-in windows [sqlite3_vfs | VFS] will be assumed +** to be relative to that directory.)^ ^If this variable is a NULL +** pointer, then SQLite assumes that all database files specified +** with a relative pathname are relative to the current directory +** for the process. Only the windows VFS makes use of this global +** variable; it is ignored by the unix VFS. +** +** Changing the value of this variable while a database connection is +** open can result in a corrupt database. +** +** It is not safe to read or modify this variable in more than one +** thread at a time. It is not safe to read or modify this variable +** if a [database connection] is being used at the same time in a separate +** thread. +** It is intended that this variable be set once +** as part of process initialization and before any SQLite interface +** routines have been called and that this variable remain unchanged +** thereafter. +** +** ^The [data_store_directory pragma] may modify this variable and cause +** it to point to memory obtained from [sqlite3_malloc]. ^Furthermore, +** the [data_store_directory pragma] always assumes that any string +** that this variable points to is held in memory obtained from +** [sqlite3_malloc] and the pragma may attempt to free that memory +** using [sqlite3_free]. +** Hence, if this variable is modified directly, either it should be +** made NULL or made to point to memory obtained from [sqlite3_malloc] +** or else the use of the [data_store_directory pragma] should be avoided. +*/ +SQLITE_API char *sqlite3_data_directory; + +/* +** CAPI3REF: Win32 Specific Interface +** +** These interfaces are available only on Windows. The +** [sqlite3_win32_set_directory] interface is used to set the value associated +** with the [sqlite3_temp_directory] or [sqlite3_data_directory] variable, to +** zValue, depending on the value of the type parameter. The zValue parameter +** should be NULL to cause the previous value to be freed via [sqlite3_free]; +** a non-NULL value will be copied into memory obtained from [sqlite3_malloc] +** prior to being used. The [sqlite3_win32_set_directory] interface returns +** [SQLITE_OK] to indicate success, [SQLITE_ERROR] if the type is unsupported, +** or [SQLITE_NOMEM] if memory could not be allocated. The value of the +** [sqlite3_data_directory] variable is intended to act as a replacement for +** the current directory on the sub-platforms of Win32 where that concept is +** not present, e.g. WinRT and UWP. The [sqlite3_win32_set_directory8] and +** [sqlite3_win32_set_directory16] interfaces behave exactly the same as the +** sqlite3_win32_set_directory interface except the string parameter must be +** UTF-8 or UTF-16, respectively. +*/ +SQLITE_API int sqlite3_win32_set_directory( + unsigned long type, /* Identifier for directory being set or reset */ + void *zValue /* New value for directory being set or reset */ +); +SQLITE_API int sqlite3_win32_set_directory8(unsigned long type, const char *zValue); +SQLITE_API int sqlite3_win32_set_directory16(unsigned long type, const void *zValue); + +/* +** CAPI3REF: Win32 Directory Types +** +** These macros are only available on Windows. They define the allowed values +** for the type argument to the [sqlite3_win32_set_directory] interface. +*/ +#define SQLITE_WIN32_DATA_DIRECTORY_TYPE 1 +#define SQLITE_WIN32_TEMP_DIRECTORY_TYPE 2 + +/* +** CAPI3REF: Test For Auto-Commit Mode +** KEYWORDS: {autocommit mode} +** METHOD: sqlite3 +** +** ^The sqlite3_get_autocommit() interface returns non-zero or +** zero if the given database connection is or is not in autocommit mode, +** respectively. ^Autocommit mode is on by default. +** ^Autocommit mode is disabled by a [BEGIN] statement. +** ^Autocommit mode is re-enabled by a [COMMIT] or [ROLLBACK]. +** +** If certain kinds of errors occur on a statement within a multi-statement +** transaction (errors including [SQLITE_FULL], [SQLITE_IOERR], +** [SQLITE_NOMEM], [SQLITE_BUSY], and [SQLITE_INTERRUPT]) then the +** transaction might be rolled back automatically. The only way to +** find out whether SQLite automatically rolled back the transaction after +** an error is to use this function. +** +** If another thread changes the autocommit status of the database +** connection while this routine is running, then the return value +** is undefined. +*/ +SQLITE_API int sqlite3_get_autocommit(sqlite3*); + +/* +** CAPI3REF: Find The Database Handle Of A Prepared Statement +** METHOD: sqlite3_stmt +** +** ^The sqlite3_db_handle interface returns the [database connection] handle +** to which a [prepared statement] belongs. ^The [database connection] +** returned by sqlite3_db_handle is the same [database connection] +** that was the first argument +** to the [sqlite3_prepare_v2()] call (or its variants) that was used to +** create the statement in the first place. +*/ +SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt*); + +/* +** CAPI3REF: Return The Schema Name For A Database Connection +** METHOD: sqlite3 +** +** ^The sqlite3_db_name(D,N) interface returns a pointer to the schema name +** for the N-th database on database connection D, or a NULL pointer of N is +** out of range. An N value of 0 means the main database file. An N of 1 is +** the "temp" schema. Larger values of N correspond to various ATTACH-ed +** databases. +** +** Space to hold the string that is returned by sqlite3_db_name() is managed +** by SQLite itself. The string might be deallocated by any operation that +** changes the schema, including [ATTACH] or [DETACH] or calls to +** [sqlite3_serialize()] or [sqlite3_deserialize()], even operations that +** occur on a different thread. Applications that need to +** remember the string long-term should make their own copy. Applications that +** are accessing the same database connection simultaneously on multiple +** threads should mutex-protect calls to this API and should make their own +** private copy of the result prior to releasing the mutex. +*/ +SQLITE_API const char *sqlite3_db_name(sqlite3 *db, int N); + +/* +** CAPI3REF: Return The Filename For A Database Connection +** METHOD: sqlite3 +** +** ^The sqlite3_db_filename(D,N) interface returns a pointer to the filename +** associated with database N of connection D. +** ^If there is no attached database N on the database +** connection D, or if database N is a temporary or in-memory database, then +** this function will return either a NULL pointer or an empty string. +** +** ^The string value returned by this routine is owned and managed by +** the database connection. ^The value will be valid until the database N +** is [DETACH]-ed or until the database connection closes. +** +** ^The filename returned by this function is the output of the +** xFullPathname method of the [VFS]. ^In other words, the filename +** will be an absolute pathname, even if the filename used +** to open the database originally was a URI or relative pathname. +** +** If the filename pointer returned by this routine is not NULL, then it +** can be used as the filename input parameter to these routines: +**
      +**
    • [sqlite3_uri_parameter()] +**
    • [sqlite3_uri_boolean()] +**
    • [sqlite3_uri_int64()] +**
    • [sqlite3_filename_database()] +**
    • [sqlite3_filename_journal()] +**
    • [sqlite3_filename_wal()] +**
    +*/ +SQLITE_API sqlite3_filename sqlite3_db_filename(sqlite3 *db, const char *zDbName); + +/* +** CAPI3REF: Determine if a database is read-only +** METHOD: sqlite3 +** +** ^The sqlite3_db_readonly(D,N) interface returns 1 if the database N +** of connection D is read-only, 0 if it is read/write, or -1 if N is not +** the name of a database on connection D. +*/ +SQLITE_API int sqlite3_db_readonly(sqlite3 *db, const char *zDbName); + +/* +** CAPI3REF: Determine the transaction state of a database +** METHOD: sqlite3 +** +** ^The sqlite3_txn_state(D,S) interface returns the current +** [transaction state] of schema S in database connection D. ^If S is NULL, +** then the highest transaction state of any schema on database connection D +** is returned. Transaction states are (in order of lowest to highest): +**
      +**
    1. SQLITE_TXN_NONE +**
    2. SQLITE_TXN_READ +**
    3. SQLITE_TXN_WRITE +**
    +** ^If the S argument to sqlite3_txn_state(D,S) is not the name of +** a valid schema, then -1 is returned. +*/ +SQLITE_API int sqlite3_txn_state(sqlite3*,const char *zSchema); + +/* +** CAPI3REF: Allowed return values from [sqlite3_txn_state()] +** KEYWORDS: {transaction state} +** +** These constants define the current transaction state of a database file. +** ^The [sqlite3_txn_state(D,S)] interface returns one of these +** constants in order to describe the transaction state of schema S +** in [database connection] D. +** +**
    +** [[SQLITE_TXN_NONE]]
    SQLITE_TXN_NONE
    +**
    The SQLITE_TXN_NONE state means that no transaction is currently +** pending.
    +** +** [[SQLITE_TXN_READ]]
    SQLITE_TXN_READ
    +**
    The SQLITE_TXN_READ state means that the database is currently +** in a read transaction. Content has been read from the database file +** but nothing in the database file has changed. The transaction state +** will advanced to SQLITE_TXN_WRITE if any changes occur and there are +** no other conflicting concurrent write transactions. The transaction +** state will revert to SQLITE_TXN_NONE following a [ROLLBACK] or +** [COMMIT].
    +** +** [[SQLITE_TXN_WRITE]]
    SQLITE_TXN_WRITE
    +**
    The SQLITE_TXN_WRITE state means that the database is currently +** in a write transaction. Content has been written to the database file +** but has not yet committed. The transaction state will change to +** to SQLITE_TXN_NONE at the next [ROLLBACK] or [COMMIT].
    +*/ +#define SQLITE_TXN_NONE 0 +#define SQLITE_TXN_READ 1 +#define SQLITE_TXN_WRITE 2 + +/* +** CAPI3REF: Find the next prepared statement +** METHOD: sqlite3 +** +** ^This interface returns a pointer to the next [prepared statement] after +** pStmt associated with the [database connection] pDb. ^If pStmt is NULL +** then this interface returns a pointer to the first prepared statement +** associated with the database connection pDb. ^If no prepared statement +** satisfies the conditions of this routine, it returns NULL. +** +** The [database connection] pointer D in a call to +** [sqlite3_next_stmt(D,S)] must refer to an open database +** connection and in particular must not be a NULL pointer. +*/ +SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Commit And Rollback Notification Callbacks +** METHOD: sqlite3 +** +** ^The sqlite3_commit_hook() interface registers a callback +** function to be invoked whenever a transaction is [COMMIT | committed]. +** ^Any callback set by a previous call to sqlite3_commit_hook() +** for the same database connection is overridden. +** ^The sqlite3_rollback_hook() interface registers a callback +** function to be invoked whenever a transaction is [ROLLBACK | rolled back]. +** ^Any callback set by a previous call to sqlite3_rollback_hook() +** for the same database connection is overridden. +** ^The pArg argument is passed through to the callback. +** ^If the callback on a commit hook function returns non-zero, +** then the commit is converted into a rollback. +** +** ^The sqlite3_commit_hook(D,C,P) and sqlite3_rollback_hook(D,C,P) functions +** return the P argument from the previous call of the same function +** on the same [database connection] D, or NULL for +** the first call for each function on D. +** +** The commit and rollback hook callbacks are not reentrant. +** The callback implementation must not do anything that will modify +** the database connection that invoked the callback. Any actions +** to modify the database connection must be deferred until after the +** completion of the [sqlite3_step()] call that triggered the commit +** or rollback hook in the first place. +** Note that running any other SQL statements, including SELECT statements, +** or merely calling [sqlite3_prepare_v2()] and [sqlite3_step()] will modify +** the database connections for the meaning of "modify" in this paragraph. +** +** ^Registering a NULL function disables the callback. +** +** ^When the commit hook callback routine returns zero, the [COMMIT] +** operation is allowed to continue normally. ^If the commit hook +** returns non-zero, then the [COMMIT] is converted into a [ROLLBACK]. +** ^The rollback hook is invoked on a rollback that results from a commit +** hook returning non-zero, just as it would be with any other rollback. +** +** ^For the purposes of this API, a transaction is said to have been +** rolled back if an explicit "ROLLBACK" statement is executed, or +** an error or constraint causes an implicit rollback to occur. +** ^The rollback callback is not invoked if a transaction is +** automatically rolled back because the database connection is closed. +** +** See also the [sqlite3_update_hook()] interface. +*/ +SQLITE_API void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*); +SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*); + +/* +** CAPI3REF: Autovacuum Compaction Amount Callback +** METHOD: sqlite3 +** +** ^The sqlite3_autovacuum_pages(D,C,P,X) interface registers a callback +** function C that is invoked prior to each autovacuum of the database +** file. ^The callback is passed a copy of the generic data pointer (P), +** the schema-name of the attached database that is being autovacuumed, +** the size of the database file in pages, the number of free pages, +** and the number of bytes per page, respectively. The callback should +** return the number of free pages that should be removed by the +** autovacuum. ^If the callback returns zero, then no autovacuum happens. +** ^If the value returned is greater than or equal to the number of +** free pages, then a complete autovacuum happens. +** +**

    ^If there are multiple ATTACH-ed database files that are being +** modified as part of a transaction commit, then the autovacuum pages +** callback is invoked separately for each file. +** +**

    The callback is not reentrant. The callback function should +** not attempt to invoke any other SQLite interface. If it does, bad +** things may happen, including segmentation faults and corrupt database +** files. The callback function should be a simple function that +** does some arithmetic on its input parameters and returns a result. +** +** ^The X parameter to sqlite3_autovacuum_pages(D,C,P,X) is an optional +** destructor for the P parameter. ^If X is not NULL, then X(P) is +** invoked whenever the database connection closes or when the callback +** is overwritten by another invocation of sqlite3_autovacuum_pages(). +** +**

    ^There is only one autovacuum pages callback per database connection. +** ^Each call to the sqlite3_autovacuum_pages() interface overrides all +** previous invocations for that database connection. ^If the callback +** argument (C) to sqlite3_autovacuum_pages(D,C,P,X) is a NULL pointer, +** then the autovacuum steps callback is cancelled. The return value +** from sqlite3_autovacuum_pages() is normally SQLITE_OK, but might +** be some other error code if something goes wrong. The current +** implementation will only return SQLITE_OK or SQLITE_MISUSE, but other +** return codes might be added in future releases. +** +**

    If no autovacuum pages callback is specified (the usual case) or +** a NULL pointer is provided for the callback, +** then the default behavior is to vacuum all free pages. So, in other +** words, the default behavior is the same as if the callback function +** were something like this: +** +** 

    +**     unsigned int demonstration_autovac_pages_callback(
+**       void *pClientData,
+**       const char *zSchema,
+**       unsigned int nDbPage,
+**       unsigned int nFreePage,
+**       unsigned int nBytePerPage
+**     ){
+**       return nFreePage;
+**     }
+**
    +*/ +SQLITE_API int sqlite3_autovacuum_pages( + sqlite3 *db, + unsigned int(*)(void*,const char*,unsigned int,unsigned int,unsigned int), + void*, + void(*)(void*) +); + + +/* +** CAPI3REF: Data Change Notification Callbacks +** METHOD: sqlite3 +** +** ^The sqlite3_update_hook() interface registers a callback function +** with the [database connection] identified by the first argument +** to be invoked whenever a row is updated, inserted or deleted in +** a [rowid table]. +** ^Any callback set by a previous call to this function +** for the same database connection is overridden. +** +** ^The second argument is a pointer to the function to invoke when a +** row is updated, inserted or deleted in a rowid table. +** ^The first argument to the callback is a copy of the third argument +** to sqlite3_update_hook(). +** ^The second callback argument is one of [SQLITE_INSERT], [SQLITE_DELETE], +** or [SQLITE_UPDATE], depending on the operation that caused the callback +** to be invoked. +** ^The third and fourth arguments to the callback contain pointers to the +** database and table name containing the affected row. +** ^The final callback parameter is the [rowid] of the row. +** ^In the case of an update, this is the [rowid] after the update takes place. +** +** ^(The update hook is not invoked when internal system tables are +** modified (i.e. sqlite_sequence).)^ +** ^The update hook is not invoked when [WITHOUT ROWID] tables are modified. +** +** ^In the current implementation, the update hook +** is not invoked when conflicting rows are deleted because of an +** [ON CONFLICT | ON CONFLICT REPLACE] clause. ^Nor is the update hook +** invoked when rows are deleted using the [truncate optimization]. +** The exceptions defined in this paragraph might change in a future +** release of SQLite. +** +** The update hook implementation must not do anything that will modify +** the database connection that invoked the update hook. Any actions +** to modify the database connection must be deferred until after the +** completion of the [sqlite3_step()] call that triggered the update hook. +** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their +** database connections for the meaning of "modify" in this paragraph. +** +** ^The sqlite3_update_hook(D,C,P) function +** returns the P argument from the previous call +** on the same [database connection] D, or NULL for +** the first call on D. +** +** See also the [sqlite3_commit_hook()], [sqlite3_rollback_hook()], +** and [sqlite3_preupdate_hook()] interfaces. +*/ +SQLITE_API void *sqlite3_update_hook( + sqlite3*, + void(*)(void *,int ,char const *,char const *,sqlite3_int64), + void* +); + +/* +** CAPI3REF: Enable Or Disable Shared Pager Cache +** +** ^(This routine enables or disables the sharing of the database cache +** and schema data structures between [database connection | connections] +** to the same database. Sharing is enabled if the argument is true +** and disabled if the argument is false.)^ +** +** This interface is omitted if SQLite is compiled with +** [-DSQLITE_OMIT_SHARED_CACHE]. The [-DSQLITE_OMIT_SHARED_CACHE] +** compile-time option is recommended because the +** [use of shared cache mode is discouraged]. +** +** ^Cache sharing is enabled and disabled for an entire process. +** This is a change as of SQLite [version 3.5.0] ([dateof:3.5.0]). +** In prior versions of SQLite, +** sharing was enabled or disabled for each thread separately. +** +** ^(The cache sharing mode set by this interface effects all subsequent +** calls to [sqlite3_open()], [sqlite3_open_v2()], and [sqlite3_open16()]. +** Existing database connections continue to use the sharing mode +** that was in effect at the time they were opened.)^ +** +** ^(This routine returns [SQLITE_OK] if shared cache was enabled or disabled +** successfully. An [error code] is returned otherwise.)^ +** +** ^Shared cache is disabled by default. It is recommended that it stay +** that way. In other words, do not use this routine. This interface +** continues to be provided for historical compatibility, but its use is +** discouraged. Any use of shared cache is discouraged. If shared cache +** must be used, it is recommended that shared cache only be enabled for +** individual database connections using the [sqlite3_open_v2()] interface +** with the [SQLITE_OPEN_SHAREDCACHE] flag. +** +** Note: This method is disabled on MacOS X 10.7 and iOS version 5.0 +** and will always return SQLITE_MISUSE. On those systems, +** shared cache mode should be enabled per-database connection via +** [sqlite3_open_v2()] with [SQLITE_OPEN_SHAREDCACHE]. +** +** This interface is threadsafe on processors where writing a +** 32-bit integer is atomic. +** +** See Also: [SQLite Shared-Cache Mode] +*/ +SQLITE_API int sqlite3_enable_shared_cache(int); + +/* +** CAPI3REF: Attempt To Free Heap Memory +** +** ^The sqlite3_release_memory() interface attempts to free N bytes +** of heap memory by deallocating non-essential memory allocations +** held by the database library. Memory used to cache database +** pages to improve performance is an example of non-essential memory. +** ^sqlite3_release_memory() returns the number of bytes actually freed, +** which might be more or less than the amount requested. +** ^The sqlite3_release_memory() routine is a no-op returning zero +** if SQLite is not compiled with [SQLITE_ENABLE_MEMORY_MANAGEMENT]. +** +** See also: [sqlite3_db_release_memory()] +*/ +SQLITE_API int sqlite3_release_memory(int); + +/* +** CAPI3REF: Free Memory Used By A Database Connection +** METHOD: sqlite3 +** +** ^The sqlite3_db_release_memory(D) interface attempts to free as much heap +** memory as possible from database connection D. Unlike the +** [sqlite3_release_memory()] interface, this interface is in effect even +** when the [SQLITE_ENABLE_MEMORY_MANAGEMENT] compile-time option is +** omitted. +** +** See also: [sqlite3_release_memory()] +*/ +SQLITE_API int sqlite3_db_release_memory(sqlite3*); + +/* +** CAPI3REF: Impose A Limit On Heap Size +** +** These interfaces impose limits on the amount of heap memory that will be +** by all database connections within a single process. +** +** ^The sqlite3_soft_heap_limit64() interface sets and/or queries the +** soft limit on the amount of heap memory that may be allocated by SQLite. +** ^SQLite strives to keep heap memory utilization below the soft heap +** limit by reducing the number of pages held in the page cache +** as heap memory usages approaches the limit. +** ^The soft heap limit is "soft" because even though SQLite strives to stay +** below the limit, it will exceed the limit rather than generate +** an [SQLITE_NOMEM] error. In other words, the soft heap limit +** is advisory only. +** +** ^The sqlite3_hard_heap_limit64(N) interface sets a hard upper bound of +** N bytes on the amount of memory that will be allocated. ^The +** sqlite3_hard_heap_limit64(N) interface is similar to +** sqlite3_soft_heap_limit64(N) except that memory allocations will fail +** when the hard heap limit is reached. +** +** ^The return value from both sqlite3_soft_heap_limit64() and +** sqlite3_hard_heap_limit64() is the size of +** the heap limit prior to the call, or negative in the case of an +** error. ^If the argument N is negative +** then no change is made to the heap limit. Hence, the current +** size of heap limits can be determined by invoking +** sqlite3_soft_heap_limit64(-1) or sqlite3_hard_heap_limit(-1). +** +** ^Setting the heap limits to zero disables the heap limiter mechanism. +** +** ^The soft heap limit may not be greater than the hard heap limit. +** ^If the hard heap limit is enabled and if sqlite3_soft_heap_limit(N) +** is invoked with a value of N that is greater than the hard heap limit, +** the soft heap limit is set to the value of the hard heap limit. +** ^The soft heap limit is automatically enabled whenever the hard heap +** limit is enabled. ^When sqlite3_hard_heap_limit64(N) is invoked and +** the soft heap limit is outside the range of 1..N, then the soft heap +** limit is set to N. ^Invoking sqlite3_soft_heap_limit64(0) when the +** hard heap limit is enabled makes the soft heap limit equal to the +** hard heap limit. +** +** The memory allocation limits can also be adjusted using +** [PRAGMA soft_heap_limit] and [PRAGMA hard_heap_limit]. +** +** ^(The heap limits are not enforced in the current implementation +** if one or more of following conditions are true: +** +**
      +**
    • The limit value is set to zero. +**
    • Memory accounting is disabled using a combination of the +** [sqlite3_config]([SQLITE_CONFIG_MEMSTATUS],...) start-time option and +** the [SQLITE_DEFAULT_MEMSTATUS] compile-time option. +**
    • An alternative page cache implementation is specified using +** [sqlite3_config]([SQLITE_CONFIG_PCACHE2],...). +**
    • The page cache allocates from its own memory pool supplied +** by [sqlite3_config]([SQLITE_CONFIG_PAGECACHE],...) rather than +** from the heap. +**
    )^ +** +** The circumstances under which SQLite will enforce the heap limits may +** changes in future releases of SQLite. +*/ +SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 N); +SQLITE_API sqlite3_int64 sqlite3_hard_heap_limit64(sqlite3_int64 N); + +/* +** CAPI3REF: Deprecated Soft Heap Limit Interface +** DEPRECATED +** +** This is a deprecated version of the [sqlite3_soft_heap_limit64()] +** interface. This routine is provided for historical compatibility +** only. All new applications should use the +** [sqlite3_soft_heap_limit64()] interface rather than this one. +*/ +SQLITE_API SQLITE_DEPRECATED void sqlite3_soft_heap_limit(int N); + + +/* +** CAPI3REF: Extract Metadata About A Column Of A Table +** METHOD: sqlite3 +** +** ^(The sqlite3_table_column_metadata(X,D,T,C,....) routine returns +** information about column C of table T in database D +** on [database connection] X.)^ ^The sqlite3_table_column_metadata() +** interface returns SQLITE_OK and fills in the non-NULL pointers in +** the final five arguments with appropriate values if the specified +** column exists. ^The sqlite3_table_column_metadata() interface returns +** SQLITE_ERROR if the specified column does not exist. +** ^If the column-name parameter to sqlite3_table_column_metadata() is a +** NULL pointer, then this routine simply checks for the existence of the +** table and returns SQLITE_OK if the table exists and SQLITE_ERROR if it +** does not. If the table name parameter T in a call to +** sqlite3_table_column_metadata(X,D,T,C,...) is NULL then the result is +** undefined behavior. +** +** ^The column is identified by the second, third and fourth parameters to +** this function. ^(The second parameter is either the name of the database +** (i.e. "main", "temp", or an attached database) containing the specified +** table or NULL.)^ ^If it is NULL, then all attached databases are searched +** for the table using the same algorithm used by the database engine to +** resolve unqualified table references. +** +** ^The third and fourth parameters to this function are the table and column +** name of the desired column, respectively. +** +** ^Metadata is returned by writing to the memory locations passed as the 5th +** and subsequent parameters to this function. ^Any of these arguments may be +** NULL, in which case the corresponding element of metadata is omitted. +** +** ^(
    +** +**
    Parameter Output
    Type     		Description +** +**
    5th const char* Data type +**
    6th const char* Name of default collation sequence +**
    7th int True if column has a NOT NULL constraint +**
    8th int True if column is part of the PRIMARY KEY +**
    9th int True if column is [AUTOINCREMENT] +**
    +**
    )^ +** +** ^The memory pointed to by the character pointers returned for the +** declaration type and collation sequence is valid until the next +** call to any SQLite API function. +** +** ^If the specified table is actually a view, an [error code] is returned. +** +** ^If the specified column is "rowid", "oid" or "_rowid_" and the table +** is not a [WITHOUT ROWID] table and an +** [INTEGER PRIMARY KEY] column has been explicitly declared, then the output +** parameters are set for the explicitly declared column. ^(If there is no +** [INTEGER PRIMARY KEY] column, then the outputs +** for the [rowid] are set as follows: +** +** 
    +**     data type: "INTEGER"
+**     collation sequence: "BINARY"
+**     not null: 0
+**     primary key: 1
+**     auto increment: 0
+**
    )^ +** +** ^This function causes all database schemas to be read from disk and +** parsed, if that has not already been done, and returns an error if +** any errors are encountered while loading the schema. +*/ +SQLITE_API int sqlite3_table_column_metadata( + sqlite3 *db, /* Connection handle */ + const char *zDbName, /* Database name or NULL */ + const char *zTableName, /* Table name */ + const char *zColumnName, /* Column name */ + char const **pzDataType, /* OUTPUT: Declared data type */ + char const **pzCollSeq, /* OUTPUT: Collation sequence name */ + int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */ + int *pPrimaryKey, /* OUTPUT: True if column part of PK */ + int *pAutoinc /* OUTPUT: True if column is auto-increment */ +); + +/* +** CAPI3REF: Load An Extension +** METHOD: sqlite3 +** +** ^This interface loads an SQLite extension library from the named file. +** +** ^The sqlite3_load_extension() interface attempts to load an +** [SQLite extension] library contained in the file zFile. If +** the file cannot be loaded directly, attempts are made to load +** with various operating-system specific extensions added. +** So for example, if "samplelib" cannot be loaded, then names like +** "samplelib.so" or "samplelib.dylib" or "samplelib.dll" might +** be tried also. +** +** ^The entry point is zProc. +** ^(zProc may be 0, in which case SQLite will try to come up with an +** entry point name on its own. It first tries "sqlite3_extension_init". +** If that does not work, it constructs a name "sqlite3_X_init" where the +** X is consists of the lower-case equivalent of all ASCII alphabetic +** characters in the filename from the last "/" to the first following +** "." and omitting any initial "lib".)^ +** ^The sqlite3_load_extension() interface returns +** [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong. +** ^If an error occurs and pzErrMsg is not 0, then the +** [sqlite3_load_extension()] interface shall attempt to +** fill *pzErrMsg with error message text stored in memory +** obtained from [sqlite3_malloc()]. The calling function +** should free this memory by calling [sqlite3_free()]. +** +** ^Extension loading must be enabled using +** [sqlite3_enable_load_extension()] or +** [sqlite3_db_config](db,[SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION],1,NULL) +** prior to calling this API, +** otherwise an error will be returned. +** +** Security warning: It is recommended that the +** [SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION] method be used to enable only this +** interface. The use of the [sqlite3_enable_load_extension()] interface +** should be avoided. This will keep the SQL function [load_extension()] +** disabled and prevent SQL injections from giving attackers +** access to extension loading capabilities. +** +** See also the [load_extension() SQL function]. +*/ +SQLITE_API int sqlite3_load_extension( + sqlite3 *db, /* Load the extension into this database connection */ + const char *zFile, /* Name of the shared library containing extension */ + const char *zProc, /* Entry point. Derived from zFile if 0 */ + char **pzErrMsg /* Put error message here if not 0 */ +); + +/* +** CAPI3REF: Enable Or Disable Extension Loading +** METHOD: sqlite3 +** +** ^So as not to open security holes in older applications that are +** unprepared to deal with [extension loading], and as a means of disabling +** [extension loading] while evaluating user-entered SQL, the following API +** is provided to turn the [sqlite3_load_extension()] mechanism on and off. +** +** ^Extension loading is off by default. +** ^Call the sqlite3_enable_load_extension() routine with onoff==1 +** to turn extension loading on and call it with onoff==0 to turn +** it back off again. +** +** ^This interface enables or disables both the C-API +** [sqlite3_load_extension()] and the SQL function [load_extension()]. +** ^(Use [sqlite3_db_config](db,[SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION],..) +** to enable or disable only the C-API.)^ +** +** Security warning: It is recommended that extension loading +** be enabled using the [SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION] method +** rather than this interface, so the [load_extension()] SQL function +** remains disabled. This will prevent SQL injections from giving attackers +** access to extension loading capabilities. +*/ +SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff); + +/* +** CAPI3REF: Automatically Load Statically Linked Extensions +** +** ^This interface causes the xEntryPoint() function to be invoked for +** each new [database connection] that is created. The idea here is that +** xEntryPoint() is the entry point for a statically linked [SQLite extension] +** that is to be automatically loaded into all new database connections. +** +** ^(Even though the function prototype shows that xEntryPoint() takes +** no arguments and returns void, SQLite invokes xEntryPoint() with three +** arguments and expects an integer result as if the signature of the +** entry point where as follows: +** +** 
    +**    int xEntryPoint(
+**      sqlite3 *db,
+**      const char **pzErrMsg,
+**      const struct sqlite3_api_routines *pThunk
+**    );
+**
    )^ +** +** If the xEntryPoint routine encounters an error, it should make *pzErrMsg +** point to an appropriate error message (obtained from [sqlite3_mprintf()]) +** and return an appropriate [error code]. ^SQLite ensures that *pzErrMsg +** is NULL before calling the xEntryPoint(). ^SQLite will invoke +** [sqlite3_free()] on *pzErrMsg after xEntryPoint() returns. ^If any +** xEntryPoint() returns an error, the [sqlite3_open()], [sqlite3_open16()], +** or [sqlite3_open_v2()] call that provoked the xEntryPoint() will fail. +** +** ^Calling sqlite3_auto_extension(X) with an entry point X that is already +** on the list of automatic extensions is a harmless no-op. ^No entry point +** will be called more than once for each database connection that is opened. +** +** See also: [sqlite3_reset_auto_extension()] +** and [sqlite3_cancel_auto_extension()] +*/ +SQLITE_API int sqlite3_auto_extension(void(*xEntryPoint)(void)); + +/* +** CAPI3REF: Cancel Automatic Extension Loading +** +** ^The [sqlite3_cancel_auto_extension(X)] interface unregisters the +** initialization routine X that was registered using a prior call to +** [sqlite3_auto_extension(X)]. ^The [sqlite3_cancel_auto_extension(X)] +** routine returns 1 if initialization routine X was successfully +** unregistered and it returns 0 if X was not on the list of initialization +** routines. +*/ +SQLITE_API int sqlite3_cancel_auto_extension(void(*xEntryPoint)(void)); + +/* +** CAPI3REF: Reset Automatic Extension Loading +** +** ^This interface disables all automatic extensions previously +** registered using [sqlite3_auto_extension()]. +*/ +SQLITE_API void sqlite3_reset_auto_extension(void); + +/* +** Structures used by the virtual table interface +*/ +typedef struct sqlite3_vtab sqlite3_vtab; +typedef struct sqlite3_index_info sqlite3_index_info; +typedef struct sqlite3_vtab_cursor sqlite3_vtab_cursor; +typedef struct sqlite3_module sqlite3_module; + +/* +** CAPI3REF: Virtual Table Object +** KEYWORDS: sqlite3_module {virtual table module} +** +** This structure, sometimes called a "virtual table module", +** defines the implementation of a [virtual table]. +** This structure consists mostly of methods for the module. +** +** ^A virtual table module is created by filling in a persistent +** instance of this structure and passing a pointer to that instance +** to [sqlite3_create_module()] or [sqlite3_create_module_v2()]. +** ^The registration remains valid until it is replaced by a different +** module or until the [database connection] closes. The content +** of this structure must not change while it is registered with +** any database connection. +*/ +struct sqlite3_module { + int iVersion; + int (*xCreate)(sqlite3*, void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVTab, char**); + int (*xConnect)(sqlite3*, void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVTab, char**); + int (*xBestIndex)(sqlite3_vtab *pVTab, sqlite3_index_info*); + int (*xDisconnect)(sqlite3_vtab *pVTab); + int (*xDestroy)(sqlite3_vtab *pVTab); + int (*xOpen)(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor); + int (*xClose)(sqlite3_vtab_cursor*); + int (*xFilter)(sqlite3_vtab_cursor*, int idxNum, const char *idxStr, + int argc, sqlite3_value **argv); + int (*xNext)(sqlite3_vtab_cursor*); + int (*xEof)(sqlite3_vtab_cursor*); + int (*xColumn)(sqlite3_vtab_cursor*, sqlite3_context*, int); + int (*xRowid)(sqlite3_vtab_cursor*, sqlite3_int64 *pRowid); + int (*xUpdate)(sqlite3_vtab *, int, sqlite3_value **, sqlite3_int64 *); + int (*xBegin)(sqlite3_vtab *pVTab); + int (*xSync)(sqlite3_vtab *pVTab); + int (*xCommit)(sqlite3_vtab *pVTab); + int (*xRollback)(sqlite3_vtab *pVTab); + int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName, + void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), + void **ppArg); + int (*xRename)(sqlite3_vtab *pVtab, const char *zNew); + /* The methods above are in version 1 of the sqlite_module object. Those + ** below are for version 2 and greater. */ + int (*xSavepoint)(sqlite3_vtab *pVTab, int); + int (*xRelease)(sqlite3_vtab *pVTab, int); + int (*xRollbackTo)(sqlite3_vtab *pVTab, int); + /* The methods above are in versions 1 and 2 of the sqlite_module object. + ** Those below are for version 3 and greater. */ + int (*xShadowName)(const char*); +}; + +/* +** CAPI3REF: Virtual Table Indexing Information +** KEYWORDS: sqlite3_index_info +** +** The sqlite3_index_info structure and its substructures is used as part +** of the [virtual table] interface to +** pass information into and receive the reply from the [xBestIndex] +** method of a [virtual table module]. The fields under **Inputs** are the +** inputs to xBestIndex and are read-only. xBestIndex inserts its +** results into the **Outputs** fields. +** +** ^(The aConstraint[] array records WHERE clause constraints of the form: +** +**
    column OP expr
    +** +** where OP is =, <, <=, >, or >=.)^ ^(The particular operator is +** stored in aConstraint[].op using one of the +** [SQLITE_INDEX_CONSTRAINT_EQ | SQLITE_INDEX_CONSTRAINT_ values].)^ +** ^(The index of the column is stored in +** aConstraint[].iColumn.)^ ^(aConstraint[].usable is TRUE if the +** expr on the right-hand side can be evaluated (and thus the constraint +** is usable) and false if it cannot.)^ +** +** ^The optimizer automatically inverts terms of the form "expr OP column" +** and makes other simplifications to the WHERE clause in an attempt to +** get as many WHERE clause terms into the form shown above as possible. +** ^The aConstraint[] array only reports WHERE clause terms that are +** relevant to the particular virtual table being queried. +** +** ^Information about the ORDER BY clause is stored in aOrderBy[]. +** ^Each term of aOrderBy records a column of the ORDER BY clause. +** +** The colUsed field indicates which columns of the virtual table may be +** required by the current scan. Virtual table columns are numbered from +** zero in the order in which they appear within the CREATE TABLE statement +** passed to sqlite3_declare_vtab(). For the first 63 columns (columns 0-62), +** the corresponding bit is set within the colUsed mask if the column may be +** required by SQLite. If the table has at least 64 columns and any column +** to the right of the first 63 is required, then bit 63 of colUsed is also +** set. In other words, column iCol may be required if the expression +** (colUsed & ((sqlite3_uint64)1 << (iCol>=63 ? 63 : iCol))) evaluates to +** non-zero. +** +** The [xBestIndex] method must fill aConstraintUsage[] with information +** about what parameters to pass to xFilter. ^If argvIndex>0 then +** the right-hand side of the corresponding aConstraint[] is evaluated +** and becomes the argvIndex-th entry in argv. ^(If aConstraintUsage[].omit +** is true, then the constraint is assumed to be fully handled by the +** virtual table and might not be checked again by the byte code.)^ ^(The +** aConstraintUsage[].omit flag is an optimization hint. When the omit flag +** is left in its default setting of false, the constraint will always be +** checked separately in byte code. If the omit flag is change to true, then +** the constraint may or may not be checked in byte code. In other words, +** when the omit flag is true there is no guarantee that the constraint will +** not be checked again using byte code.)^ +** +** ^The idxNum and idxStr values are recorded and passed into the +** [xFilter] method. +** ^[sqlite3_free()] is used to free idxStr if and only if +** needToFreeIdxStr is true. +** +** ^The orderByConsumed means that output from [xFilter]/[xNext] will occur in +** the correct order to satisfy the ORDER BY clause so that no separate +** sorting step is required. +** +** ^The estimatedCost value is an estimate of the cost of a particular +** strategy. A cost of N indicates that the cost of the strategy is similar +** to a linear scan of an SQLite table with N rows. A cost of log(N) +** indicates that the expense of the operation is similar to that of a +** binary search on a unique indexed field of an SQLite table with N rows. +** +** ^The estimatedRows value is an estimate of the number of rows that +** will be returned by the strategy. +** +** The xBestIndex method may optionally populate the idxFlags field with a +** mask of SQLITE_INDEX_SCAN_* flags. Currently there is only one such flag - +** SQLITE_INDEX_SCAN_UNIQUE. If the xBestIndex method sets this flag, SQLite +** assumes that the strategy may visit at most one row. +** +** Additionally, if xBestIndex sets the SQLITE_INDEX_SCAN_UNIQUE flag, then +** SQLite also assumes that if a call to the xUpdate() method is made as +** part of the same statement to delete or update a virtual table row and the +** implementation returns SQLITE_CONSTRAINT, then there is no need to rollback +** any database changes. In other words, if the xUpdate() returns +** SQLITE_CONSTRAINT, the database contents must be exactly as they were +** before xUpdate was called. By contrast, if SQLITE_INDEX_SCAN_UNIQUE is not +** set and xUpdate returns SQLITE_CONSTRAINT, any database changes made by +** the xUpdate method are automatically rolled back by SQLite. +** +** IMPORTANT: The estimatedRows field was added to the sqlite3_index_info +** structure for SQLite [version 3.8.2] ([dateof:3.8.2]). +** If a virtual table extension is +** used with an SQLite version earlier than 3.8.2, the results of attempting +** to read or write the estimatedRows field are undefined (but are likely +** to include crashing the application). The estimatedRows field should +** therefore only be used if [sqlite3_libversion_number()] returns a +** value greater than or equal to 3008002. Similarly, the idxFlags field +** was added for [version 3.9.0] ([dateof:3.9.0]). +** It may therefore only be used if +** sqlite3_libversion_number() returns a value greater than or equal to +** 3009000. +*/ +struct sqlite3_index_info { + /* Inputs */ + int nConstraint; /* Number of entries in aConstraint */ + struct sqlite3_index_constraint { + int iColumn; /* Column constrained. -1 for ROWID */ + unsigned char op; /* Constraint operator */ + unsigned char usable; /* True if this constraint is usable */ + int iTermOffset; /* Used internally - xBestIndex should ignore */ + } *aConstraint; /* Table of WHERE clause constraints */ + int nOrderBy; /* Number of terms in the ORDER BY clause */ + struct sqlite3_index_orderby { + int iColumn; /* Column number */ + unsigned char desc; /* True for DESC. False for ASC. */ + } *aOrderBy; /* The ORDER BY clause */ + /* Outputs */ + struct sqlite3_index_constraint_usage { + int argvIndex; /* if >0, constraint is part of argv to xFilter */ + unsigned char omit; /* Do not code a test for this constraint */ + } *aConstraintUsage; + int idxNum; /* Number used to identify the index */ + char *idxStr; /* String, possibly obtained from sqlite3_malloc */ + int needToFreeIdxStr; /* Free idxStr using sqlite3_free() if true */ + int orderByConsumed; /* True if output is already ordered */ + double estimatedCost; /* Estimated cost of using this index */ + /* Fields below are only available in SQLite 3.8.2 and later */ + sqlite3_int64 estimatedRows; /* Estimated number of rows returned */ + /* Fields below are only available in SQLite 3.9.0 and later */ + int idxFlags; /* Mask of SQLITE_INDEX_SCAN_* flags */ + /* Fields below are only available in SQLite 3.10.0 and later */ + sqlite3_uint64 colUsed; /* Input: Mask of columns used by statement */ +}; + +/* +** CAPI3REF: Virtual Table Scan Flags +** +** Virtual table implementations are allowed to set the +** [sqlite3_index_info].idxFlags field to some combination of +** these bits. +*/ +#define SQLITE_INDEX_SCAN_UNIQUE 1 /* Scan visits at most 1 row */ + +/* +** CAPI3REF: Virtual Table Constraint Operator Codes +** +** These macros define the allowed values for the +** [sqlite3_index_info].aConstraint[].op field. Each value represents +** an operator that is part of a constraint term in the WHERE clause of +** a query that uses a [virtual table]. +** +** ^The left-hand operand of the operator is given by the corresponding +** aConstraint[].iColumn field. ^An iColumn of -1 indicates the left-hand +** operand is the rowid. +** The SQLITE_INDEX_CONSTRAINT_LIMIT and SQLITE_INDEX_CONSTRAINT_OFFSET +** operators have no left-hand operand, and so for those operators the +** corresponding aConstraint[].iColumn is meaningless and should not be +** used. +** +** All operator values from SQLITE_INDEX_CONSTRAINT_FUNCTION through +** value 255 are reserved to represent functions that are overloaded +** by the [xFindFunction|xFindFunction method] of the virtual table +** implementation. +** +** The right-hand operands for each constraint might be accessible using +** the [sqlite3_vtab_rhs_value()] interface. Usually the right-hand +** operand is only available if it appears as a single constant literal +** in the input SQL. If the right-hand operand is another column or an +** expression (even a constant expression) or a parameter, then the +** sqlite3_vtab_rhs_value() probably will not be able to extract it. +** ^The SQLITE_INDEX_CONSTRAINT_ISNULL and +** SQLITE_INDEX_CONSTRAINT_ISNOTNULL operators have no right-hand operand +** and hence calls to sqlite3_vtab_rhs_value() for those operators will +** always return SQLITE_NOTFOUND. +** +** The collating sequence to be used for comparison can be found using +** the [sqlite3_vtab_collation()] interface. For most real-world virtual +** tables, the collating sequence of constraints does not matter (for example +** because the constraints are numeric) and so the sqlite3_vtab_collation() +** interface is not commonly needed. +*/ +#define SQLITE_INDEX_CONSTRAINT_EQ 2 +#define SQLITE_INDEX_CONSTRAINT_GT 4 +#define SQLITE_INDEX_CONSTRAINT_LE 8 +#define SQLITE_INDEX_CONSTRAINT_LT 16 +#define SQLITE_INDEX_CONSTRAINT_GE 32 +#define SQLITE_INDEX_CONSTRAINT_MATCH 64 +#define SQLITE_INDEX_CONSTRAINT_LIKE 65 +#define SQLITE_INDEX_CONSTRAINT_GLOB 66 +#define SQLITE_INDEX_CONSTRAINT_REGEXP 67 +#define SQLITE_INDEX_CONSTRAINT_NE 68 +#define SQLITE_INDEX_CONSTRAINT_ISNOT 69 +#define SQLITE_INDEX_CONSTRAINT_ISNOTNULL 70 +#define SQLITE_INDEX_CONSTRAINT_ISNULL 71 +#define SQLITE_INDEX_CONSTRAINT_IS 72 +#define SQLITE_INDEX_CONSTRAINT_LIMIT 73 +#define SQLITE_INDEX_CONSTRAINT_OFFSET 74 +#define SQLITE_INDEX_CONSTRAINT_FUNCTION 150 + +/* +** CAPI3REF: Register A Virtual Table Implementation +** METHOD: sqlite3 +** +** ^These routines are used to register a new [virtual table module] name. +** ^Module names must be registered before +** creating a new [virtual table] using the module and before using a +** preexisting [virtual table] for the module. +** +** ^The module name is registered on the [database connection] specified +** by the first parameter. ^The name of the module is given by the +** second parameter. ^The third parameter is a pointer to +** the implementation of the [virtual table module]. ^The fourth +** parameter is an arbitrary client data pointer that is passed through +** into the [xCreate] and [xConnect] methods of the virtual table module +** when a new virtual table is be being created or reinitialized. +** +** ^The sqlite3_create_module_v2() interface has a fifth parameter which +** is a pointer to a destructor for the pClientData. ^SQLite will +** invoke the destructor function (if it is not NULL) when SQLite +** no longer needs the pClientData pointer. ^The destructor will also +** be invoked if the call to sqlite3_create_module_v2() fails. +** ^The sqlite3_create_module() +** interface is equivalent to sqlite3_create_module_v2() with a NULL +** destructor. +** +** ^If the third parameter (the pointer to the sqlite3_module object) is +** NULL then no new module is created and any existing modules with the +** same name are dropped. +** +** See also: [sqlite3_drop_modules()] +*/ +SQLITE_API int sqlite3_create_module( + sqlite3 *db, /* SQLite connection to register module with */ + const char *zName, /* Name of the module */ + const sqlite3_module *p, /* Methods for the module */ + void *pClientData /* Client data for xCreate/xConnect */ +); +SQLITE_API int sqlite3_create_module_v2( + sqlite3 *db, /* SQLite connection to register module with */ + const char *zName, /* Name of the module */ + const sqlite3_module *p, /* Methods for the module */ + void *pClientData, /* Client data for xCreate/xConnect */ + void(*xDestroy)(void*) /* Module destructor function */ +); + +/* +** CAPI3REF: Remove Unnecessary Virtual Table Implementations +** METHOD: sqlite3 +** +** ^The sqlite3_drop_modules(D,L) interface removes all virtual +** table modules from database connection D except those named on list L. +** The L parameter must be either NULL or a pointer to an array of pointers +** to strings where the array is terminated by a single NULL pointer. +** ^If the L parameter is NULL, then all virtual table modules are removed. +** +** See also: [sqlite3_create_module()] +*/ +SQLITE_API int sqlite3_drop_modules( + sqlite3 *db, /* Remove modules from this connection */ + const char **azKeep /* Except, do not remove the ones named here */ +); + +/* +** CAPI3REF: Virtual Table Instance Object +** KEYWORDS: sqlite3_vtab +** +** Every [virtual table module] implementation uses a subclass +** of this object to describe a particular instance +** of the [virtual table]. Each subclass will +** be tailored to the specific needs of the module implementation. +** The purpose of this superclass is to define certain fields that are +** common to all module implementations. +** +** ^Virtual tables methods can set an error message by assigning a +** string obtained from [sqlite3_mprintf()] to zErrMsg. The method should +** take care that any prior string is freed by a call to [sqlite3_free()] +** prior to assigning a new string to zErrMsg. ^After the error message +** is delivered up to the client application, the string will be automatically +** freed by sqlite3_free() and the zErrMsg field will be zeroed. +*/ +struct sqlite3_vtab { + const sqlite3_module *pModule; /* The module for this virtual table */ + int nRef; /* Number of open cursors */ + char *zErrMsg; /* Error message from sqlite3_mprintf() */ + /* Virtual table implementations will typically add additional fields */ +}; + +/* +** CAPI3REF: Virtual Table Cursor Object +** KEYWORDS: sqlite3_vtab_cursor {virtual table cursor} +** +** Every [virtual table module] implementation uses a subclass of the +** following structure to describe cursors that point into the +** [virtual table] and are used +** to loop through the virtual table. Cursors are created using the +** [sqlite3_module.xOpen | xOpen] method of the module and are destroyed +** by the [sqlite3_module.xClose | xClose] method. Cursors are used +** by the [xFilter], [xNext], [xEof], [xColumn], and [xRowid] methods +** of the module. Each module implementation will define +** the content of a cursor structure to suit its own needs. +** +** This superclass exists in order to define fields of the cursor that +** are common to all implementations. +*/ +struct sqlite3_vtab_cursor { + sqlite3_vtab *pVtab; /* Virtual table of this cursor */ + /* Virtual table implementations will typically add additional fields */ +}; + +/* +** CAPI3REF: Declare The Schema Of A Virtual Table +** +** ^The [xCreate] and [xConnect] methods of a +** [virtual table module] call this interface +** to declare the format (the names and datatypes of the columns) of +** the virtual tables they implement. +*/ +SQLITE_API int sqlite3_declare_vtab(sqlite3*, const char *zSQL); + +/* +** CAPI3REF: Overload A Function For A Virtual Table +** METHOD: sqlite3 +** +** ^(Virtual tables can provide alternative implementations of functions +** using the [xFindFunction] method of the [virtual table module]. +** But global versions of those functions +** must exist in order to be overloaded.)^ +** +** ^(This API makes sure a global version of a function with a particular +** name and number of parameters exists. If no such function exists +** before this API is called, a new function is created.)^ ^The implementation +** of the new function always causes an exception to be thrown. So +** the new function is not good for anything by itself. Its only +** purpose is to be a placeholder function that can be overloaded +** by a [virtual table]. +*/ +SQLITE_API int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg); + +/* +** CAPI3REF: A Handle To An Open BLOB +** KEYWORDS: {BLOB handle} {BLOB handles} +** +** An instance of this object represents an open BLOB on which +** [sqlite3_blob_open | incremental BLOB I/O] can be performed. +** ^Objects of this type are created by [sqlite3_blob_open()] +** and destroyed by [sqlite3_blob_close()]. +** ^The [sqlite3_blob_read()] and [sqlite3_blob_write()] interfaces +** can be used to read or write small subsections of the BLOB. +** ^The [sqlite3_blob_bytes()] interface returns the size of the BLOB in bytes. +*/ +typedef struct sqlite3_blob sqlite3_blob; + +/* +** CAPI3REF: Open A BLOB For Incremental I/O +** METHOD: sqlite3 +** CONSTRUCTOR: sqlite3_blob +** +** ^(This interfaces opens a [BLOB handle | handle] to the BLOB located +** in row iRow, column zColumn, table zTable in database zDb; +** in other words, the same BLOB that would be selected by: +** +** 
    +**     SELECT zColumn FROM zDb.zTable WHERE [rowid] = iRow;
+**
    )^ +** +** ^(Parameter zDb is not the filename that contains the database, but +** rather the symbolic name of the database. For attached databases, this is +** the name that appears after the AS keyword in the [ATTACH] statement. +** For the main database file, the database name is "main". For TEMP +** tables, the database name is "temp".)^ +** +** ^If the flags parameter is non-zero, then the BLOB is opened for read +** and write access. ^If the flags parameter is zero, the BLOB is opened for +** read-only access. +** +** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is stored +** in *ppBlob. Otherwise an [error code] is returned and, unless the error +** code is SQLITE_MISUSE, *ppBlob is set to NULL.)^ ^This means that, provided +** the API is not misused, it is always safe to call [sqlite3_blob_close()] +** on *ppBlob after this function it returns. +** +** This function fails with SQLITE_ERROR if any of the following are true: +**
      +**
    • ^(Database zDb does not exist)^, +**
    • ^(Table zTable does not exist within database zDb)^, +**
    • ^(Table zTable is a WITHOUT ROWID table)^, +**
    • ^(Column zColumn does not exist)^, +**
    • ^(Row iRow is not present in the table)^, +**
    • ^(The specified column of row iRow contains a value that is not +** a TEXT or BLOB value)^, +**
    • ^(Column zColumn is part of an index, PRIMARY KEY or UNIQUE +** constraint and the blob is being opened for read/write access)^, +**
    • ^([foreign key constraints | Foreign key constraints] are enabled, +** column zColumn is part of a [child key] definition and the blob is +** being opened for read/write access)^. +**
    +** +** ^Unless it returns SQLITE_MISUSE, this function sets the +** [database connection] error code and message accessible via +** [sqlite3_errcode()] and [sqlite3_errmsg()] and related functions. +** +** A BLOB referenced by sqlite3_blob_open() may be read using the +** [sqlite3_blob_read()] interface and modified by using +** [sqlite3_blob_write()]. The [BLOB handle] can be moved to a +** different row of the same table using the [sqlite3_blob_reopen()] +** interface. However, the column, table, or database of a [BLOB handle] +** cannot be changed after the [BLOB handle] is opened. +** +** ^(If the row that a BLOB handle points to is modified by an +** [UPDATE], [DELETE], or by [ON CONFLICT] side-effects +** then the BLOB handle is marked as "expired". +** This is true if any column of the row is changed, even a column +** other than the one the BLOB handle is open on.)^ +** ^Calls to [sqlite3_blob_read()] and [sqlite3_blob_write()] for +** an expired BLOB handle fail with a return code of [SQLITE_ABORT]. +** ^(Changes written into a BLOB prior to the BLOB expiring are not +** rolled back by the expiration of the BLOB. Such changes will eventually +** commit if the transaction continues to completion.)^ +** +** ^Use the [sqlite3_blob_bytes()] interface to determine the size of +** the opened blob. ^The size of a blob may not be changed by this +** interface. Use the [UPDATE] SQL command to change the size of a +** blob. +** +** ^The [sqlite3_bind_zeroblob()] and [sqlite3_result_zeroblob()] interfaces +** and the built-in [zeroblob] SQL function may be used to create a +** zero-filled blob to read or write using the incremental-blob interface. +** +** To avoid a resource leak, every open [BLOB handle] should eventually +** be released by a call to [sqlite3_blob_close()]. +** +** See also: [sqlite3_blob_close()], +** [sqlite3_blob_reopen()], [sqlite3_blob_read()], +** [sqlite3_blob_bytes()], [sqlite3_blob_write()]. +*/ +SQLITE_API int sqlite3_blob_open( + sqlite3*, + const char *zDb, + const char *zTable, + const char *zColumn, + sqlite3_int64 iRow, + int flags, + sqlite3_blob **ppBlob +); + +/* +** CAPI3REF: Move a BLOB Handle to a New Row +** METHOD: sqlite3_blob +** +** ^This function is used to move an existing [BLOB handle] so that it points +** to a different row of the same database table. ^The new row is identified +** by the rowid value passed as the second argument. Only the row can be +** changed. ^The database, table and column on which the blob handle is open +** remain the same. Moving an existing [BLOB handle] to a new row is +** faster than closing the existing handle and opening a new one. +** +** ^(The new row must meet the same criteria as for [sqlite3_blob_open()] - +** it must exist and there must be either a blob or text value stored in +** the nominated column.)^ ^If the new row is not present in the table, or if +** it does not contain a blob or text value, or if another error occurs, an +** SQLite error code is returned and the blob handle is considered aborted. +** ^All subsequent calls to [sqlite3_blob_read()], [sqlite3_blob_write()] or +** [sqlite3_blob_reopen()] on an aborted blob handle immediately return +** SQLITE_ABORT. ^Calling [sqlite3_blob_bytes()] on an aborted blob handle +** always returns zero. +** +** ^This function sets the database handle error code and message. +*/ +SQLITE_API int sqlite3_blob_reopen(sqlite3_blob *, sqlite3_int64); + +/* +** CAPI3REF: Close A BLOB Handle +** DESTRUCTOR: sqlite3_blob +** +** ^This function closes an open [BLOB handle]. ^(The BLOB handle is closed +** unconditionally. Even if this routine returns an error code, the +** handle is still closed.)^ +** +** ^If the blob handle being closed was opened for read-write access, and if +** the database is in auto-commit mode and there are no other open read-write +** blob handles or active write statements, the current transaction is +** committed. ^If an error occurs while committing the transaction, an error +** code is returned and the transaction rolled back. +** +** Calling this function with an argument that is not a NULL pointer or an +** open blob handle results in undefined behaviour. ^Calling this routine +** with a null pointer (such as would be returned by a failed call to +** [sqlite3_blob_open()]) is a harmless no-op. ^Otherwise, if this function +** is passed a valid open blob handle, the values returned by the +** sqlite3_errcode() and sqlite3_errmsg() functions are set before returning. +*/ +SQLITE_API int sqlite3_blob_close(sqlite3_blob *); + +/* +** CAPI3REF: Return The Size Of An Open BLOB +** METHOD: sqlite3_blob +** +** ^Returns the size in bytes of the BLOB accessible via the +** successfully opened [BLOB handle] in its only argument. ^The +** incremental blob I/O routines can only read or overwriting existing +** blob content; they cannot change the size of a blob. +** +** This routine only works on a [BLOB handle] which has been created +** by a prior successful call to [sqlite3_blob_open()] and which has not +** been closed by [sqlite3_blob_close()]. Passing any other pointer in +** to this routine results in undefined and probably undesirable behavior. +*/ +SQLITE_API int sqlite3_blob_bytes(sqlite3_blob *); + +/* +** CAPI3REF: Read Data From A BLOB Incrementally +** METHOD: sqlite3_blob +** +** ^(This function is used to read data from an open [BLOB handle] into a +** caller-supplied buffer. N bytes of data are copied into buffer Z +** from the open BLOB, starting at offset iOffset.)^ +** +** ^If offset iOffset is less than N bytes from the end of the BLOB, +** [SQLITE_ERROR] is returned and no data is read. ^If N or iOffset is +** less than zero, [SQLITE_ERROR] is returned and no data is read. +** ^The size of the blob (and hence the maximum value of N+iOffset) +** can be determined using the [sqlite3_blob_bytes()] interface. +** +** ^An attempt to read from an expired [BLOB handle] fails with an +** error code of [SQLITE_ABORT]. +** +** ^(On success, sqlite3_blob_read() returns SQLITE_OK. +** Otherwise, an [error code] or an [extended error code] is returned.)^ +** +** This routine only works on a [BLOB handle] which has been created +** by a prior successful call to [sqlite3_blob_open()] and which has not +** been closed by [sqlite3_blob_close()]. Passing any other pointer in +** to this routine results in undefined and probably undesirable behavior. +** +** See also: [sqlite3_blob_write()]. +*/ +SQLITE_API int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset); + +/* +** CAPI3REF: Write Data Into A BLOB Incrementally +** METHOD: sqlite3_blob +** +** ^(This function is used to write data into an open [BLOB handle] from a +** caller-supplied buffer. N bytes of data are copied from the buffer Z +** into the open BLOB, starting at offset iOffset.)^ +** +** ^(On success, sqlite3_blob_write() returns SQLITE_OK. +** Otherwise, an [error code] or an [extended error code] is returned.)^ +** ^Unless SQLITE_MISUSE is returned, this function sets the +** [database connection] error code and message accessible via +** [sqlite3_errcode()] and [sqlite3_errmsg()] and related functions. +** +** ^If the [BLOB handle] passed as the first argument was not opened for +** writing (the flags parameter to [sqlite3_blob_open()] was zero), +** this function returns [SQLITE_READONLY]. +** +** This function may only modify the contents of the BLOB; it is +** not possible to increase the size of a BLOB using this API. +** ^If offset iOffset is less than N bytes from the end of the BLOB, +** [SQLITE_ERROR] is returned and no data is written. The size of the +** BLOB (and hence the maximum value of N+iOffset) can be determined +** using the [sqlite3_blob_bytes()] interface. ^If N or iOffset are less +** than zero [SQLITE_ERROR] is returned and no data is written. +** +** ^An attempt to write to an expired [BLOB handle] fails with an +** error code of [SQLITE_ABORT]. ^Writes to the BLOB that occurred +** before the [BLOB handle] expired are not rolled back by the +** expiration of the handle, though of course those changes might +** have been overwritten by the statement that expired the BLOB handle +** or by other independent statements. +** +** This routine only works on a [BLOB handle] which has been created +** by a prior successful call to [sqlite3_blob_open()] and which has not +** been closed by [sqlite3_blob_close()]. Passing any other pointer in +** to this routine results in undefined and probably undesirable behavior. +** +** See also: [sqlite3_blob_read()]. +*/ +SQLITE_API int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset); + +/* +** CAPI3REF: Virtual File System Objects +** +** A virtual filesystem (VFS) is an [sqlite3_vfs] object +** that SQLite uses to interact +** with the underlying operating system. Most SQLite builds come with a +** single default VFS that is appropriate for the host computer. +** New VFSes can be registered and existing VFSes can be unregistered. +** The following interfaces are provided. +** +** ^The sqlite3_vfs_find() interface returns a pointer to a VFS given its name. +** ^Names are case sensitive. +** ^Names are zero-terminated UTF-8 strings. +** ^If there is no match, a NULL pointer is returned. +** ^If zVfsName is NULL then the default VFS is returned. +** +** ^New VFSes are registered with sqlite3_vfs_register(). +** ^Each new VFS becomes the default VFS if the makeDflt flag is set. +** ^The same VFS can be registered multiple times without injury. +** ^To make an existing VFS into the default VFS, register it again +** with the makeDflt flag set. If two different VFSes with the +** same name are registered, the behavior is undefined. If a +** VFS is registered with a name that is NULL or an empty string, +** then the behavior is undefined. +** +** ^Unregister a VFS with the sqlite3_vfs_unregister() interface. +** ^(If the default VFS is unregistered, another VFS is chosen as +** the default. The choice for the new VFS is arbitrary.)^ +*/ +SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName); +SQLITE_API int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt); +SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs*); + +/* +** CAPI3REF: Mutexes +** +** The SQLite core uses these routines for thread +** synchronization. Though they are intended for internal +** use by SQLite, code that links against SQLite is +** permitted to use any of these routines. +** +** The SQLite source code contains multiple implementations +** of these mutex routines. An appropriate implementation +** is selected automatically at compile-time. The following +** implementations are available in the SQLite core: +** +**
      +**
    • SQLITE_MUTEX_PTHREADS +**
    • SQLITE_MUTEX_W32 +**
    • SQLITE_MUTEX_NOOP +**
    +** +** The SQLITE_MUTEX_NOOP implementation is a set of routines +** that does no real locking and is appropriate for use in +** a single-threaded application. The SQLITE_MUTEX_PTHREADS and +** SQLITE_MUTEX_W32 implementations are appropriate for use on Unix +** and Windows. +** +** If SQLite is compiled with the SQLITE_MUTEX_APPDEF preprocessor +** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex +** implementation is included with the library. In this case the +** application must supply a custom mutex implementation using the +** [SQLITE_CONFIG_MUTEX] option of the sqlite3_config() function +** before calling sqlite3_initialize() or any other public sqlite3_ +** function that calls sqlite3_initialize(). +** +** ^The sqlite3_mutex_alloc() routine allocates a new +** mutex and returns a pointer to it. ^The sqlite3_mutex_alloc() +** routine returns NULL if it is unable to allocate the requested +** mutex. The argument to sqlite3_mutex_alloc() must one of these +** integer constants: +** +**
      +**
    • SQLITE_MUTEX_FAST +**
    • SQLITE_MUTEX_RECURSIVE +**
    • SQLITE_MUTEX_STATIC_MAIN +**
    • SQLITE_MUTEX_STATIC_MEM +**
    • SQLITE_MUTEX_STATIC_OPEN +**
    • SQLITE_MUTEX_STATIC_PRNG +**
    • SQLITE_MUTEX_STATIC_LRU +**
    • SQLITE_MUTEX_STATIC_PMEM +**
    • SQLITE_MUTEX_STATIC_APP1 +**
    • SQLITE_MUTEX_STATIC_APP2 +**
    • SQLITE_MUTEX_STATIC_APP3 +**
    • SQLITE_MUTEX_STATIC_VFS1 +**
    • SQLITE_MUTEX_STATIC_VFS2 +**
    • SQLITE_MUTEX_STATIC_VFS3 +**
    +** +** ^The first two constants (SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE) +** cause sqlite3_mutex_alloc() to create +** a new mutex. ^The new mutex is recursive when SQLITE_MUTEX_RECURSIVE +** is used but not necessarily so when SQLITE_MUTEX_FAST is used. +** The mutex implementation does not need to make a distinction +** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does +** not want to. SQLite will only request a recursive mutex in +** cases where it really needs one. If a faster non-recursive mutex +** implementation is available on the host platform, the mutex subsystem +** might return such a mutex in response to SQLITE_MUTEX_FAST. +** +** ^The other allowed parameters to sqlite3_mutex_alloc() (anything other +** than SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE) each return +** a pointer to a static preexisting mutex. ^Nine static mutexes are +** used by the current version of SQLite. Future versions of SQLite +** may add additional static mutexes. Static mutexes are for internal +** use by SQLite only. Applications that use SQLite mutexes should +** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or +** SQLITE_MUTEX_RECURSIVE. +** +** ^Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST +** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc() +** returns a different mutex on every call. ^For the static +** mutex types, the same mutex is returned on every call that has +** the same type number. +** +** ^The sqlite3_mutex_free() routine deallocates a previously +** allocated dynamic mutex. Attempting to deallocate a static +** mutex results in undefined behavior. +** +** ^The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt +** to enter a mutex. ^If another thread is already within the mutex, +** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return +** SQLITE_BUSY. ^The sqlite3_mutex_try() interface returns [SQLITE_OK] +** upon successful entry. ^(Mutexes created using +** SQLITE_MUTEX_RECURSIVE can be entered multiple times by the same thread. +** In such cases, the +** mutex must be exited an equal number of times before another thread +** can enter.)^ If the same thread tries to enter any mutex other +** than an SQLITE_MUTEX_RECURSIVE more than once, the behavior is undefined. +** +** ^(Some systems (for example, Windows 95) do not support the operation +** implemented by sqlite3_mutex_try(). On those systems, sqlite3_mutex_try() +** will always return SQLITE_BUSY. The SQLite core only ever uses +** sqlite3_mutex_try() as an optimization so this is acceptable +** behavior.)^ +** +** ^The sqlite3_mutex_leave() routine exits a mutex that was +** previously entered by the same thread. The behavior +** is undefined if the mutex is not currently entered by the +** calling thread or is not currently allocated. +** +** ^If the argument to sqlite3_mutex_enter(), sqlite3_mutex_try(), +** sqlite3_mutex_leave(), or sqlite3_mutex_free() is a NULL pointer, +** then any of the four routines behaves as a no-op. +** +** See also: [sqlite3_mutex_held()] and [sqlite3_mutex_notheld()]. +*/ +SQLITE_API sqlite3_mutex *sqlite3_mutex_alloc(int); +SQLITE_API void sqlite3_mutex_free(sqlite3_mutex*); +SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex*); +SQLITE_API int sqlite3_mutex_try(sqlite3_mutex*); +SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex*); + +/* +** CAPI3REF: Mutex Methods Object +** +** An instance of this structure defines the low-level routines +** used to allocate and use mutexes. +** +** Usually, the default mutex implementations provided by SQLite are +** sufficient, however the application has the option of substituting a custom +** implementation for specialized deployments or systems for which SQLite +** does not provide a suitable implementation. In this case, the application +** creates and populates an instance of this structure to pass +** to sqlite3_config() along with the [SQLITE_CONFIG_MUTEX] option. +** Additionally, an instance of this structure can be used as an +** output variable when querying the system for the current mutex +** implementation, using the [SQLITE_CONFIG_GETMUTEX] option. +** +** ^The xMutexInit method defined by this structure is invoked as +** part of system initialization by the sqlite3_initialize() function. +** ^The xMutexInit routine is called by SQLite exactly once for each +** effective call to [sqlite3_initialize()]. +** +** ^The xMutexEnd method defined by this structure is invoked as +** part of system shutdown by the sqlite3_shutdown() function. The +** implementation of this method is expected to release all outstanding +** resources obtained by the mutex methods implementation, especially +** those obtained by the xMutexInit method. ^The xMutexEnd() +** interface is invoked exactly once for each call to [sqlite3_shutdown()]. +** +** ^(The remaining seven methods defined by this structure (xMutexAlloc, +** xMutexFree, xMutexEnter, xMutexTry, xMutexLeave, xMutexHeld and +** xMutexNotheld) implement the following interfaces (respectively): +** +**
      +**
    • [sqlite3_mutex_alloc()]
      • +**
    • [sqlite3_mutex_free()]
      • +**
    • [sqlite3_mutex_enter()]
      • +**
    • [sqlite3_mutex_try()]
      • +**
    • [sqlite3_mutex_leave()]
      • +**
    • [sqlite3_mutex_held()]
      • +**
    • [sqlite3_mutex_notheld()]
      • +**
    )^ +** +** The only difference is that the public sqlite3_XXX functions enumerated +** above silently ignore any invocations that pass a NULL pointer instead +** of a valid mutex handle. The implementations of the methods defined +** by this structure are not required to handle this case. The results +** of passing a NULL pointer instead of a valid mutex handle are undefined +** (i.e. it is acceptable to provide an implementation that segfaults if +** it is passed a NULL pointer). +** +** The xMutexInit() method must be threadsafe. It must be harmless to +** invoke xMutexInit() multiple times within the same process and without +** intervening calls to xMutexEnd(). Second and subsequent calls to +** xMutexInit() must be no-ops. +** +** xMutexInit() must not use SQLite memory allocation ([sqlite3_malloc()] +** and its associates). Similarly, xMutexAlloc() must not use SQLite memory +** allocation for a static mutex. ^However xMutexAlloc() may use SQLite +** memory allocation for a fast or recursive mutex. +** +** ^SQLite will invoke the xMutexEnd() method when [sqlite3_shutdown()] is +** called, but only if the prior call to xMutexInit returned SQLITE_OK. +** If xMutexInit fails in any way, it is expected to clean up after itself +** prior to returning. +*/ +typedef struct sqlite3_mutex_methods sqlite3_mutex_methods; +struct sqlite3_mutex_methods { + int (*xMutexInit)(void); + int (*xMutexEnd)(void); + sqlite3_mutex *(*xMutexAlloc)(int); + void (*xMutexFree)(sqlite3_mutex *); + void (*xMutexEnter)(sqlite3_mutex *); + int (*xMutexTry)(sqlite3_mutex *); + void (*xMutexLeave)(sqlite3_mutex *); + int (*xMutexHeld)(sqlite3_mutex *); + int (*xMutexNotheld)(sqlite3_mutex *); +}; + +/* +** CAPI3REF: Mutex Verification Routines +** +** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routines +** are intended for use inside assert() statements. The SQLite core +** never uses these routines except inside an assert() and applications +** are advised to follow the lead of the core. The SQLite core only +** provides implementations for these routines when it is compiled +** with the SQLITE_DEBUG flag. External mutex implementations +** are only required to provide these routines if SQLITE_DEBUG is +** defined and if NDEBUG is not defined. +** +** These routines should return true if the mutex in their argument +** is held or not held, respectively, by the calling thread. +** +** The implementation is not required to provide versions of these +** routines that actually work. If the implementation does not provide working +** versions of these routines, it should at least provide stubs that always +** return true so that one does not get spurious assertion failures. +** +** If the argument to sqlite3_mutex_held() is a NULL pointer then +** the routine should return 1. This seems counter-intuitive since +** clearly the mutex cannot be held if it does not exist. But +** the reason the mutex does not exist is because the build is not +** using mutexes. And we do not want the assert() containing the +** call to sqlite3_mutex_held() to fail, so a non-zero return is +** the appropriate thing to do. The sqlite3_mutex_notheld() +** interface should also return 1 when given a NULL pointer. +*/ +#ifndef NDEBUG +SQLITE_API int sqlite3_mutex_held(sqlite3_mutex*); +SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex*); +#endif + +/* +** CAPI3REF: Mutex Types +** +** The [sqlite3_mutex_alloc()] interface takes a single argument +** which is one of these integer constants. +** +** The set of static mutexes may change from one SQLite release to the +** next. Applications that override the built-in mutex logic must be +** prepared to accommodate additional static mutexes. +*/ +#define SQLITE_MUTEX_FAST 0 +#define SQLITE_MUTEX_RECURSIVE 1 +#define SQLITE_MUTEX_STATIC_MAIN 2 +#define SQLITE_MUTEX_STATIC_MEM 3 /* sqlite3_malloc() */ +#define SQLITE_MUTEX_STATIC_MEM2 4 /* NOT USED */ +#define SQLITE_MUTEX_STATIC_OPEN 4 /* sqlite3BtreeOpen() */ +#define SQLITE_MUTEX_STATIC_PRNG 5 /* sqlite3_randomness() */ +#define SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */ +#define SQLITE_MUTEX_STATIC_LRU2 7 /* NOT USED */ +#define SQLITE_MUTEX_STATIC_PMEM 7 /* sqlite3PageMalloc() */ +#define SQLITE_MUTEX_STATIC_APP1 8 /* For use by application */ +#define SQLITE_MUTEX_STATIC_APP2 9 /* For use by application */ +#define SQLITE_MUTEX_STATIC_APP3 10 /* For use by application */ +#define SQLITE_MUTEX_STATIC_VFS1 11 /* For use by built-in VFS */ +#define SQLITE_MUTEX_STATIC_VFS2 12 /* For use by extension VFS */ +#define SQLITE_MUTEX_STATIC_VFS3 13 /* For use by application VFS */ + +/* Legacy compatibility: */ +#define SQLITE_MUTEX_STATIC_MASTER 2 + + +/* +** CAPI3REF: Retrieve the mutex for a database connection +** METHOD: sqlite3 +** +** ^This interface returns a pointer the [sqlite3_mutex] object that +** serializes access to the [database connection] given in the argument +** when the [threading mode] is Serialized. +** ^If the [threading mode] is Single-thread or Multi-thread then this +** routine returns a NULL pointer. +*/ +SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3*); + +/* +** CAPI3REF: Low-Level Control Of Database Files +** METHOD: sqlite3 +** KEYWORDS: {file control} +** +** ^The [sqlite3_file_control()] interface makes a direct call to the +** xFileControl method for the [sqlite3_io_methods] object associated +** with a particular database identified by the second argument. ^The +** name of the database is "main" for the main database or "temp" for the +** TEMP database, or the name that appears after the AS keyword for +** databases that are added using the [ATTACH] SQL command. +** ^A NULL pointer can be used in place of "main" to refer to the +** main database file. +** ^The third and fourth parameters to this routine +** are passed directly through to the second and third parameters of +** the xFileControl method. ^The return value of the xFileControl +** method becomes the return value of this routine. +** +** A few opcodes for [sqlite3_file_control()] are handled directly +** by the SQLite core and never invoke the +** sqlite3_io_methods.xFileControl method. +** ^The [SQLITE_FCNTL_FILE_POINTER] value for the op parameter causes +** a pointer to the underlying [sqlite3_file] object to be written into +** the space pointed to by the 4th parameter. The +** [SQLITE_FCNTL_JOURNAL_POINTER] works similarly except that it returns +** the [sqlite3_file] object associated with the journal file instead of +** the main database. The [SQLITE_FCNTL_VFS_POINTER] opcode returns +** a pointer to the underlying [sqlite3_vfs] object for the file. +** The [SQLITE_FCNTL_DATA_VERSION] returns the data version counter +** from the pager. +** +** ^If the second parameter (zDbName) does not match the name of any +** open database file, then SQLITE_ERROR is returned. ^This error +** code is not remembered and will not be recalled by [sqlite3_errcode()] +** or [sqlite3_errmsg()]. The underlying xFileControl method might +** also return SQLITE_ERROR. There is no way to distinguish between +** an incorrect zDbName and an SQLITE_ERROR return from the underlying +** xFileControl method. +** +** See also: [file control opcodes] +*/ +SQLITE_API int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*); + +/* +** CAPI3REF: Testing Interface +** +** ^The sqlite3_test_control() interface is used to read out internal +** state of SQLite and to inject faults into SQLite for testing +** purposes. ^The first parameter is an operation code that determines +** the number, meaning, and operation of all subsequent parameters. +** +** This interface is not for use by applications. It exists solely +** for verifying the correct operation of the SQLite library. Depending +** on how the SQLite library is compiled, this interface might not exist. +** +** The details of the operation codes, their meanings, the parameters +** they take, and what they do are all subject to change without notice. +** Unlike most of the SQLite API, this function is not guaranteed to +** operate consistently from one release to the next. +*/ +SQLITE_API int sqlite3_test_control(int op, ...); + +/* +** CAPI3REF: Testing Interface Operation Codes +** +** These constants are the valid operation code parameters used +** as the first argument to [sqlite3_test_control()]. +** +** These parameters and their meanings are subject to change +** without notice. These values are for testing purposes only. +** Applications should not use any of these parameters or the +** [sqlite3_test_control()] interface. +*/ +#define SQLITE_TESTCTRL_FIRST 5 +#define SQLITE_TESTCTRL_PRNG_SAVE 5 +#define SQLITE_TESTCTRL_PRNG_RESTORE 6 +#define SQLITE_TESTCTRL_PRNG_RESET 7 /* NOT USED */ +#define SQLITE_TESTCTRL_BITVEC_TEST 8 +#define SQLITE_TESTCTRL_FAULT_INSTALL 9 +#define SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS 10 +#define SQLITE_TESTCTRL_PENDING_BYTE 11 +#define SQLITE_TESTCTRL_ASSERT 12 +#define SQLITE_TESTCTRL_ALWAYS 13 +#define SQLITE_TESTCTRL_RESERVE 14 /* NOT USED */ +#define SQLITE_TESTCTRL_OPTIMIZATIONS 15 +#define SQLITE_TESTCTRL_ISKEYWORD 16 /* NOT USED */ +#define SQLITE_TESTCTRL_SCRATCHMALLOC 17 /* NOT USED */ +#define SQLITE_TESTCTRL_INTERNAL_FUNCTIONS 17 +#define SQLITE_TESTCTRL_LOCALTIME_FAULT 18 +#define SQLITE_TESTCTRL_EXPLAIN_STMT 19 /* NOT USED */ +#define SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD 19 +#define SQLITE_TESTCTRL_NEVER_CORRUPT 20 +#define SQLITE_TESTCTRL_VDBE_COVERAGE 21 +#define SQLITE_TESTCTRL_BYTEORDER 22 +#define SQLITE_TESTCTRL_ISINIT 23 +#define SQLITE_TESTCTRL_SORTER_MMAP 24 +#define SQLITE_TESTCTRL_IMPOSTER 25 +#define SQLITE_TESTCTRL_PARSER_COVERAGE 26 +#define SQLITE_TESTCTRL_RESULT_INTREAL 27 +#define SQLITE_TESTCTRL_PRNG_SEED 28 +#define SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS 29 +#define SQLITE_TESTCTRL_SEEK_COUNT 30 +#define SQLITE_TESTCTRL_TRACEFLAGS 31 +#define SQLITE_TESTCTRL_TUNE 32 +#define SQLITE_TESTCTRL_LOGEST 33 +#define SQLITE_TESTCTRL_LAST 33 /* Largest TESTCTRL */ + +/* +** CAPI3REF: SQL Keyword Checking +** +** These routines provide access to the set of SQL language keywords +** recognized by SQLite. Applications can uses these routines to determine +** whether or not a specific identifier needs to be escaped (for example, +** by enclosing in double-quotes) so as not to confuse the parser. +** +** The sqlite3_keyword_count() interface returns the number of distinct +** keywords understood by SQLite. +** +** The sqlite3_keyword_name(N,Z,L) interface finds the N-th keyword and +** makes *Z point to that keyword expressed as UTF8 and writes the number +** of bytes in the keyword into *L. The string that *Z points to is not +** zero-terminated. The sqlite3_keyword_name(N,Z,L) routine returns +** SQLITE_OK if N is within bounds and SQLITE_ERROR if not. If either Z +** or L are NULL or invalid pointers then calls to +** sqlite3_keyword_name(N,Z,L) result in undefined behavior. +** +** The sqlite3_keyword_check(Z,L) interface checks to see whether or not +** the L-byte UTF8 identifier that Z points to is a keyword, returning non-zero +** if it is and zero if not. +** +** The parser used by SQLite is forgiving. It is often possible to use +** a keyword as an identifier as long as such use does not result in a +** parsing ambiguity. For example, the statement +** "CREATE TABLE BEGIN(REPLACE,PRAGMA,END);" is accepted by SQLite, and +** creates a new table named "BEGIN" with three columns named +** "REPLACE", "PRAGMA", and "END". Nevertheless, best practice is to avoid +** using keywords as identifiers. Common techniques used to avoid keyword +** name collisions include: +**
      +**
    • Put all identifier names inside double-quotes. This is the official +** SQL way to escape identifier names. +**
    • Put identifier names inside [...]. This is not standard SQL, +** but it is what SQL Server does and so lots of programmers use this +** technique. +**
    • Begin every identifier with the letter "Z" as no SQL keywords start +** with "Z". +**
    • Include a digit somewhere in every identifier name. +**
    +** +** Note that the number of keywords understood by SQLite can depend on +** compile-time options. For example, "VACUUM" is not a keyword if +** SQLite is compiled with the [-DSQLITE_OMIT_VACUUM] option. Also, +** new keywords may be added to future releases of SQLite. +*/ +SQLITE_API int sqlite3_keyword_count(void); +SQLITE_API int sqlite3_keyword_name(int,const char**,int*); +SQLITE_API int sqlite3_keyword_check(const char*,int); + +/* +** CAPI3REF: Dynamic String Object +** KEYWORDS: {dynamic string} +** +** An instance of the sqlite3_str object contains a dynamically-sized +** string under construction. +** +** The lifecycle of an sqlite3_str object is as follows: +**
      +**
    1. ^The sqlite3_str object is created using [sqlite3_str_new()]. +**
    2. ^Text is appended to the sqlite3_str object using various +** methods, such as [sqlite3_str_appendf()]. +**
    3. ^The sqlite3_str object is destroyed and the string it created +** is returned using the [sqlite3_str_finish()] interface. +**
    +*/ +typedef struct sqlite3_str sqlite3_str; + +/* +** CAPI3REF: Create A New Dynamic String Object +** CONSTRUCTOR: sqlite3_str +** +** ^The [sqlite3_str_new(D)] interface allocates and initializes +** a new [sqlite3_str] object. To avoid memory leaks, the object returned by +** [sqlite3_str_new()] must be freed by a subsequent call to +** [sqlite3_str_finish(X)]. +** +** ^The [sqlite3_str_new(D)] interface always returns a pointer to a +** valid [sqlite3_str] object, though in the event of an out-of-memory +** error the returned object might be a special singleton that will +** silently reject new text, always return SQLITE_NOMEM from +** [sqlite3_str_errcode()], always return 0 for +** [sqlite3_str_length()], and always return NULL from +** [sqlite3_str_finish(X)]. It is always safe to use the value +** returned by [sqlite3_str_new(D)] as the sqlite3_str parameter +** to any of the other [sqlite3_str] methods. +** +** The D parameter to [sqlite3_str_new(D)] may be NULL. If the +** D parameter in [sqlite3_str_new(D)] is not NULL, then the maximum +** length of the string contained in the [sqlite3_str] object will be +** the value set for [sqlite3_limit](D,[SQLITE_LIMIT_LENGTH]) instead +** of [SQLITE_MAX_LENGTH]. +*/ +SQLITE_API sqlite3_str *sqlite3_str_new(sqlite3*); + +/* +** CAPI3REF: Finalize A Dynamic String +** DESTRUCTOR: sqlite3_str +** +** ^The [sqlite3_str_finish(X)] interface destroys the sqlite3_str object X +** and returns a pointer to a memory buffer obtained from [sqlite3_malloc64()] +** that contains the constructed string. The calling application should +** pass the returned value to [sqlite3_free()] to avoid a memory leak. +** ^The [sqlite3_str_finish(X)] interface may return a NULL pointer if any +** errors were encountered during construction of the string. ^The +** [sqlite3_str_finish(X)] interface will also return a NULL pointer if the +** string in [sqlite3_str] object X is zero bytes long. +*/ +SQLITE_API char *sqlite3_str_finish(sqlite3_str*); + +/* +** CAPI3REF: Add Content To A Dynamic String +** METHOD: sqlite3_str +** +** These interfaces add content to an sqlite3_str object previously obtained +** from [sqlite3_str_new()]. +** +** ^The [sqlite3_str_appendf(X,F,...)] and +** [sqlite3_str_vappendf(X,F,V)] interfaces uses the [built-in printf] +** functionality of SQLite to append formatted text onto the end of +** [sqlite3_str] object X. +** +** ^The [sqlite3_str_append(X,S,N)] method appends exactly N bytes from string S +** onto the end of the [sqlite3_str] object X. N must be non-negative. +** S must contain at least N non-zero bytes of content. To append a +** zero-terminated string in its entirety, use the [sqlite3_str_appendall()] +** method instead. +** +** ^The [sqlite3_str_appendall(X,S)] method appends the complete content of +** zero-terminated string S onto the end of [sqlite3_str] object X. +** +** ^The [sqlite3_str_appendchar(X,N,C)] method appends N copies of the +** single-byte character C onto the end of [sqlite3_str] object X. +** ^This method can be used, for example, to add whitespace indentation. +** +** ^The [sqlite3_str_reset(X)] method resets the string under construction +** inside [sqlite3_str] object X back to zero bytes in length. +** +** These methods do not return a result code. ^If an error occurs, that fact +** is recorded in the [sqlite3_str] object and can be recovered by a +** subsequent call to [sqlite3_str_errcode(X)]. +*/ +SQLITE_API void sqlite3_str_appendf(sqlite3_str*, const char *zFormat, ...); +SQLITE_API void sqlite3_str_vappendf(sqlite3_str*, const char *zFormat, va_list); +SQLITE_API void sqlite3_str_append(sqlite3_str*, const char *zIn, int N); +SQLITE_API void sqlite3_str_appendall(sqlite3_str*, const char *zIn); +SQLITE_API void sqlite3_str_appendchar(sqlite3_str*, int N, char C); +SQLITE_API void sqlite3_str_reset(sqlite3_str*); + +/* +** CAPI3REF: Status Of A Dynamic String +** METHOD: sqlite3_str +** +** These interfaces return the current status of an [sqlite3_str] object. +** +** ^If any prior errors have occurred while constructing the dynamic string +** in sqlite3_str X, then the [sqlite3_str_errcode(X)] method will return +** an appropriate error code. ^The [sqlite3_str_errcode(X)] method returns +** [SQLITE_NOMEM] following any out-of-memory error, or +** [SQLITE_TOOBIG] if the size of the dynamic string exceeds +** [SQLITE_MAX_LENGTH], or [SQLITE_OK] if there have been no errors. +** +** ^The [sqlite3_str_length(X)] method returns the current length, in bytes, +** of the dynamic string under construction in [sqlite3_str] object X. +** ^The length returned by [sqlite3_str_length(X)] does not include the +** zero-termination byte. +** +** ^The [sqlite3_str_value(X)] method returns a pointer to the current +** content of the dynamic string under construction in X. The value +** returned by [sqlite3_str_value(X)] is managed by the sqlite3_str object X +** and might be freed or altered by any subsequent method on the same +** [sqlite3_str] object. Applications must not used the pointer returned +** [sqlite3_str_value(X)] after any subsequent method call on the same +** object. ^Applications may change the content of the string returned +** by [sqlite3_str_value(X)] as long as they do not write into any bytes +** outside the range of 0 to [sqlite3_str_length(X)] and do not read or +** write any byte after any subsequent sqlite3_str method call. +*/ +SQLITE_API int sqlite3_str_errcode(sqlite3_str*); +SQLITE_API int sqlite3_str_length(sqlite3_str*); +SQLITE_API char *sqlite3_str_value(sqlite3_str*); + +/* +** CAPI3REF: SQLite Runtime Status +** +** ^These interfaces are used to retrieve runtime status information +** about the performance of SQLite, and optionally to reset various +** highwater marks. ^The first argument is an integer code for +** the specific parameter to measure. ^(Recognized integer codes +** are of the form [status parameters | SQLITE_STATUS_...].)^ +** ^The current value of the parameter is returned into *pCurrent. +** ^The highest recorded value is returned in *pHighwater. ^If the +** resetFlag is true, then the highest record value is reset after +** *pHighwater is written. ^(Some parameters do not record the highest +** value. For those parameters +** nothing is written into *pHighwater and the resetFlag is ignored.)^ +** ^(Other parameters record only the highwater mark and not the current +** value. For these latter parameters nothing is written into *pCurrent.)^ +** +** ^The sqlite3_status() and sqlite3_status64() routines return +** SQLITE_OK on success and a non-zero [error code] on failure. +** +** If either the current value or the highwater mark is too large to +** be represented by a 32-bit integer, then the values returned by +** sqlite3_status() are undefined. +** +** See also: [sqlite3_db_status()] +*/ +SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag); +SQLITE_API int sqlite3_status64( + int op, + sqlite3_int64 *pCurrent, + sqlite3_int64 *pHighwater, + int resetFlag +); + + +/* +** CAPI3REF: Status Parameters +** KEYWORDS: {status parameters} +** +** These integer constants designate various run-time status parameters +** that can be returned by [sqlite3_status()]. +** +**
    +** [[SQLITE_STATUS_MEMORY_USED]] ^(
    SQLITE_STATUS_MEMORY_USED
    +**
    This parameter is the current amount of memory checked out +** using [sqlite3_malloc()], either directly or indirectly. The +** figure includes calls made to [sqlite3_malloc()] by the application +** and internal memory usage by the SQLite library. Auxiliary page-cache +** memory controlled by [SQLITE_CONFIG_PAGECACHE] is not included in +** this parameter. The amount returned is the sum of the allocation +** sizes as reported by the xSize method in [sqlite3_mem_methods].
    )^ +** +** [[SQLITE_STATUS_MALLOC_SIZE]] ^(
    SQLITE_STATUS_MALLOC_SIZE
    +**
    This parameter records the largest memory allocation request +** handed to [sqlite3_malloc()] or [sqlite3_realloc()] (or their +** internal equivalents). Only the value returned in the +** *pHighwater parameter to [sqlite3_status()] is of interest. +** The value written into the *pCurrent parameter is undefined.
    )^ +** +** [[SQLITE_STATUS_MALLOC_COUNT]] ^(
    SQLITE_STATUS_MALLOC_COUNT
    +**
    This parameter records the number of separate memory allocations +** currently checked out.
    )^ +** +** [[SQLITE_STATUS_PAGECACHE_USED]] ^(
    SQLITE_STATUS_PAGECACHE_USED
    +**
    This parameter returns the number of pages used out of the +** [pagecache memory allocator] that was configured using +** [SQLITE_CONFIG_PAGECACHE]. The +** value returned is in pages, not in bytes.
    )^ +** +** [[SQLITE_STATUS_PAGECACHE_OVERFLOW]] +** ^(
    SQLITE_STATUS_PAGECACHE_OVERFLOW
    +**
    This parameter returns the number of bytes of page cache +** allocation which could not be satisfied by the [SQLITE_CONFIG_PAGECACHE] +** buffer and where forced to overflow to [sqlite3_malloc()]. The +** returned value includes allocations that overflowed because they +** where too large (they were larger than the "sz" parameter to +** [SQLITE_CONFIG_PAGECACHE]) and allocations that overflowed because +** no space was left in the page cache.
    )^ +** +** [[SQLITE_STATUS_PAGECACHE_SIZE]] ^(
    SQLITE_STATUS_PAGECACHE_SIZE
    +**
    This parameter records the largest memory allocation request +** handed to the [pagecache memory allocator]. Only the value returned in the +** *pHighwater parameter to [sqlite3_status()] is of interest. +** The value written into the *pCurrent parameter is undefined.
    )^ +** +** [[SQLITE_STATUS_SCRATCH_USED]]
    SQLITE_STATUS_SCRATCH_USED
    +**
    No longer used.
    +** +** [[SQLITE_STATUS_SCRATCH_OVERFLOW]] ^(
    SQLITE_STATUS_SCRATCH_OVERFLOW
    +**
    No longer used.
    +** +** [[SQLITE_STATUS_SCRATCH_SIZE]]
    SQLITE_STATUS_SCRATCH_SIZE
    +**
    No longer used.
    +** +** [[SQLITE_STATUS_PARSER_STACK]] ^(
    SQLITE_STATUS_PARSER_STACK
    +**
    The *pHighwater parameter records the deepest parser stack. +** The *pCurrent value is undefined. The *pHighwater value is only +** meaningful if SQLite is compiled with [YYTRACKMAXSTACKDEPTH].
    )^ +**
    +** +** New status parameters may be added from time to time. +*/ +#define SQLITE_STATUS_MEMORY_USED 0 +#define SQLITE_STATUS_PAGECACHE_USED 1 +#define SQLITE_STATUS_PAGECACHE_OVERFLOW 2 +#define SQLITE_STATUS_SCRATCH_USED 3 /* NOT USED */ +#define SQLITE_STATUS_SCRATCH_OVERFLOW 4 /* NOT USED */ +#define SQLITE_STATUS_MALLOC_SIZE 5 +#define SQLITE_STATUS_PARSER_STACK 6 +#define SQLITE_STATUS_PAGECACHE_SIZE 7 +#define SQLITE_STATUS_SCRATCH_SIZE 8 /* NOT USED */ +#define SQLITE_STATUS_MALLOC_COUNT 9 + +/* +** CAPI3REF: Database Connection Status +** METHOD: sqlite3 +** +** ^This interface is used to retrieve runtime status information +** about a single [database connection]. ^The first argument is the +** database connection object to be interrogated. ^The second argument +** is an integer constant, taken from the set of +** [SQLITE_DBSTATUS options], that +** determines the parameter to interrogate. The set of +** [SQLITE_DBSTATUS options] is likely +** to grow in future releases of SQLite. +** +** ^The current value of the requested parameter is written into *pCur +** and the highest instantaneous value is written into *pHiwtr. ^If +** the resetFlg is true, then the highest instantaneous value is +** reset back down to the current value. +** +** ^The sqlite3_db_status() routine returns SQLITE_OK on success and a +** non-zero [error code] on failure. +** +** See also: [sqlite3_status()] and [sqlite3_stmt_status()]. +*/ +SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg); + +/* +** CAPI3REF: Status Parameters for database connections +** KEYWORDS: {SQLITE_DBSTATUS options} +** +** These constants are the available integer "verbs" that can be passed as +** the second argument to the [sqlite3_db_status()] interface. +** +** New verbs may be added in future releases of SQLite. Existing verbs +** might be discontinued. Applications should check the return code from +** [sqlite3_db_status()] to make sure that the call worked. +** The [sqlite3_db_status()] interface will return a non-zero error code +** if a discontinued or unsupported verb is invoked. +** +**
    +** [[SQLITE_DBSTATUS_LOOKASIDE_USED]] ^(
    SQLITE_DBSTATUS_LOOKASIDE_USED
    +**
    This parameter returns the number of lookaside memory slots currently +** checked out.
    )^ +** +** [[SQLITE_DBSTATUS_LOOKASIDE_HIT]] ^(
    SQLITE_DBSTATUS_LOOKASIDE_HIT
    +**
    This parameter returns the number of malloc attempts that were +** satisfied using lookaside memory. Only the high-water value is meaningful; +** the current value is always zero.)^ +** +** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE]] +** ^(
    SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE
    +**
    This parameter returns the number malloc attempts that might have +** been satisfied using lookaside memory but failed due to the amount of +** memory requested being larger than the lookaside slot size. +** Only the high-water value is meaningful; +** the current value is always zero.)^ +** +** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL]] +** ^(
    SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL
    +**
    This parameter returns the number malloc attempts that might have +** been satisfied using lookaside memory but failed due to all lookaside +** memory already being in use. +** Only the high-water value is meaningful; +** the current value is always zero.)^ +** +** [[SQLITE_DBSTATUS_CACHE_USED]] ^(
    SQLITE_DBSTATUS_CACHE_USED
    +**
    This parameter returns the approximate number of bytes of heap +** memory used by all pager caches associated with the database connection.)^ +** ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_USED is always 0. +** +** [[SQLITE_DBSTATUS_CACHE_USED_SHARED]] +** ^(
    SQLITE_DBSTATUS_CACHE_USED_SHARED
    +**
    This parameter is similar to DBSTATUS_CACHE_USED, except that if a +** pager cache is shared between two or more connections the bytes of heap +** memory used by that pager cache is divided evenly between the attached +** connections.)^ In other words, if none of the pager caches associated +** with the database connection are shared, this request returns the same +** value as DBSTATUS_CACHE_USED. Or, if one or more or the pager caches are +** shared, the value returned by this call will be smaller than that returned +** by DBSTATUS_CACHE_USED. ^The highwater mark associated with +** SQLITE_DBSTATUS_CACHE_USED_SHARED is always 0. +** +** [[SQLITE_DBSTATUS_SCHEMA_USED]] ^(
    SQLITE_DBSTATUS_SCHEMA_USED
    +**
    This parameter returns the approximate number of bytes of heap +** memory used to store the schema for all databases associated +** with the connection - main, temp, and any [ATTACH]-ed databases.)^ +** ^The full amount of memory used by the schemas is reported, even if the +** schema memory is shared with other database connections due to +** [shared cache mode] being enabled. +** ^The highwater mark associated with SQLITE_DBSTATUS_SCHEMA_USED is always 0. +** +** [[SQLITE_DBSTATUS_STMT_USED]] ^(
    SQLITE_DBSTATUS_STMT_USED
    +**
    This parameter returns the approximate number of bytes of heap +** and lookaside memory used by all prepared statements associated with +** the database connection.)^ +** ^The highwater mark associated with SQLITE_DBSTATUS_STMT_USED is always 0. +**
    +** +** [[SQLITE_DBSTATUS_CACHE_HIT]] ^(
    SQLITE_DBSTATUS_CACHE_HIT
    +**
    This parameter returns the number of pager cache hits that have +** occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_HIT +** is always 0. +**
    +** +** [[SQLITE_DBSTATUS_CACHE_MISS]] ^(
    SQLITE_DBSTATUS_CACHE_MISS
    +**
    This parameter returns the number of pager cache misses that have +** occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_MISS +** is always 0. +**
    +** +** [[SQLITE_DBSTATUS_CACHE_WRITE]] ^(
    SQLITE_DBSTATUS_CACHE_WRITE
    +**
    This parameter returns the number of dirty cache entries that have +** been written to disk. Specifically, the number of pages written to the +** wal file in wal mode databases, or the number of pages written to the +** database file in rollback mode databases. Any pages written as part of +** transaction rollback or database recovery operations are not included. +** If an IO or other error occurs while writing a page to disk, the effect +** on subsequent SQLITE_DBSTATUS_CACHE_WRITE requests is undefined.)^ ^The +** highwater mark associated with SQLITE_DBSTATUS_CACHE_WRITE is always 0. +**
    +** +** [[SQLITE_DBSTATUS_CACHE_SPILL]] ^(
    SQLITE_DBSTATUS_CACHE_SPILL
    +**
    This parameter returns the number of dirty cache entries that have +** been written to disk in the middle of a transaction due to the page +** cache overflowing. Transactions are more efficient if they are written +** to disk all at once. When pages spill mid-transaction, that introduces +** additional overhead. This parameter can be used help identify +** inefficiencies that can be resolved by increasing the cache size. +**
    +** +** [[SQLITE_DBSTATUS_DEFERRED_FKS]] ^(
    SQLITE_DBSTATUS_DEFERRED_FKS
    +**
    This parameter returns zero for the current value if and only if +** all foreign key constraints (deferred or immediate) have been +** resolved.)^ ^The highwater mark is always 0. +**
    +**
    +*/ +#define SQLITE_DBSTATUS_LOOKASIDE_USED 0 +#define SQLITE_DBSTATUS_CACHE_USED 1 +#define SQLITE_DBSTATUS_SCHEMA_USED 2 +#define SQLITE_DBSTATUS_STMT_USED 3 +#define SQLITE_DBSTATUS_LOOKASIDE_HIT 4 +#define SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE 5 +#define SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL 6 +#define SQLITE_DBSTATUS_CACHE_HIT 7 +#define SQLITE_DBSTATUS_CACHE_MISS 8 +#define SQLITE_DBSTATUS_CACHE_WRITE 9 +#define SQLITE_DBSTATUS_DEFERRED_FKS 10 +#define SQLITE_DBSTATUS_CACHE_USED_SHARED 11 +#define SQLITE_DBSTATUS_CACHE_SPILL 12 +#define SQLITE_DBSTATUS_MAX 12 /* Largest defined DBSTATUS */ + + +/* +** CAPI3REF: Prepared Statement Status +** METHOD: sqlite3_stmt +** +** ^(Each prepared statement maintains various +** [SQLITE_STMTSTATUS counters] that measure the number +** of times it has performed specific operations.)^ These counters can +** be used to monitor the performance characteristics of the prepared +** statements. For example, if the number of table steps greatly exceeds +** the number of table searches or result rows, that would tend to indicate +** that the prepared statement is using a full table scan rather than +** an index. +** +** ^(This interface is used to retrieve and reset counter values from +** a [prepared statement]. The first argument is the prepared statement +** object to be interrogated. The second argument +** is an integer code for a specific [SQLITE_STMTSTATUS counter] +** to be interrogated.)^ +** ^The current value of the requested counter is returned. +** ^If the resetFlg is true, then the counter is reset to zero after this +** interface call returns. +** +** See also: [sqlite3_status()] and [sqlite3_db_status()]. +*/ +SQLITE_API int sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg); + +/* +** CAPI3REF: Status Parameters for prepared statements +** KEYWORDS: {SQLITE_STMTSTATUS counter} {SQLITE_STMTSTATUS counters} +** +** These preprocessor macros define integer codes that name counter +** values associated with the [sqlite3_stmt_status()] interface. +** The meanings of the various counters are as follows: +** +**
    +** [[SQLITE_STMTSTATUS_FULLSCAN_STEP]]
    SQLITE_STMTSTATUS_FULLSCAN_STEP
    +**
    ^This is the number of times that SQLite has stepped forward in +** a table as part of a full table scan. Large numbers for this counter +** may indicate opportunities for performance improvement through +** careful use of indices.
    +** +** [[SQLITE_STMTSTATUS_SORT]]
    SQLITE_STMTSTATUS_SORT
    +**
    ^This is the number of sort operations that have occurred. +** A non-zero value in this counter may indicate an opportunity to +** improvement performance through careful use of indices.
    +** +** [[SQLITE_STMTSTATUS_AUTOINDEX]]
    SQLITE_STMTSTATUS_AUTOINDEX
    +**
    ^This is the number of rows inserted into transient indices that +** were created automatically in order to help joins run faster. +** A non-zero value in this counter may indicate an opportunity to +** improvement performance by adding permanent indices that do not +** need to be reinitialized each time the statement is run.
    +** +** [[SQLITE_STMTSTATUS_VM_STEP]]
    SQLITE_STMTSTATUS_VM_STEP
    +**
    ^This is the number of virtual machine operations executed +** by the prepared statement if that number is less than or equal +** to 2147483647. The number of virtual machine operations can be +** used as a proxy for the total work done by the prepared statement. +** If the number of virtual machine operations exceeds 2147483647 +** then the value returned by this statement status code is undefined. +** +** [[SQLITE_STMTSTATUS_REPREPARE]]
    SQLITE_STMTSTATUS_REPREPARE
    +**
    ^This is the number of times that the prepare statement has been +** automatically regenerated due to schema changes or changes to +** [bound parameters] that might affect the query plan. +** +** [[SQLITE_STMTSTATUS_RUN]]
    SQLITE_STMTSTATUS_RUN
    +**
    ^This is the number of times that the prepared statement has +** been run. A single "run" for the purposes of this counter is one +** or more calls to [sqlite3_step()] followed by a call to [sqlite3_reset()]. +** The counter is incremented on the first [sqlite3_step()] call of each +** cycle. +** +** [[SQLITE_STMTSTATUS_FILTER_MISS]] +** [[SQLITE_STMTSTATUS_FILTER HIT]] +**
    SQLITE_STMTSTATUS_FILTER_HIT
    +** SQLITE_STMTSTATUS_FILTER_MISS
    +**
    ^SQLITE_STMTSTATUS_FILTER_HIT is the number of times that a join +** step was bypassed because a Bloom filter returned not-found. The +** corresponding SQLITE_STMTSTATUS_FILTER_MISS value is the number of +** times that the Bloom filter returned a find, and thus the join step +** had to be processed as normal. +** +** [[SQLITE_STMTSTATUS_MEMUSED]]
    SQLITE_STMTSTATUS_MEMUSED
    +**
    ^This is the approximate number of bytes of heap memory +** used to store the prepared statement. ^This value is not actually +** a counter, and so the resetFlg parameter to sqlite3_stmt_status() +** is ignored when the opcode is SQLITE_STMTSTATUS_MEMUSED. +**
    +**
    +*/ +#define SQLITE_STMTSTATUS_FULLSCAN_STEP 1 +#define SQLITE_STMTSTATUS_SORT 2 +#define SQLITE_STMTSTATUS_AUTOINDEX 3 +#define SQLITE_STMTSTATUS_VM_STEP 4 +#define SQLITE_STMTSTATUS_REPREPARE 5 +#define SQLITE_STMTSTATUS_RUN 6 +#define SQLITE_STMTSTATUS_FILTER_MISS 7 +#define SQLITE_STMTSTATUS_FILTER_HIT 8 +#define SQLITE_STMTSTATUS_MEMUSED 99 + +/* +** CAPI3REF: Custom Page Cache Object +** +** The sqlite3_pcache type is opaque. It is implemented by +** the pluggable module. The SQLite core has no knowledge of +** its size or internal structure and never deals with the +** sqlite3_pcache object except by holding and passing pointers +** to the object. +** +** See [sqlite3_pcache_methods2] for additional information. +*/ +typedef struct sqlite3_pcache sqlite3_pcache; + +/* +** CAPI3REF: Custom Page Cache Object +** +** The sqlite3_pcache_page object represents a single page in the +** page cache. The page cache will allocate instances of this +** object. Various methods of the page cache use pointers to instances +** of this object as parameters or as their return value. +** +** See [sqlite3_pcache_methods2] for additional information. +*/ +typedef struct sqlite3_pcache_page sqlite3_pcache_page; +struct sqlite3_pcache_page { + void *pBuf; /* The content of the page */ + void *pExtra; /* Extra information associated with the page */ +}; + +/* +** CAPI3REF: Application Defined Page Cache. +** KEYWORDS: {page cache} +** +** ^(The [sqlite3_config]([SQLITE_CONFIG_PCACHE2], ...) interface can +** register an alternative page cache implementation by passing in an +** instance of the sqlite3_pcache_methods2 structure.)^ +** In many applications, most of the heap memory allocated by +** SQLite is used for the page cache. +** By implementing a +** custom page cache using this API, an application can better control +** the amount of memory consumed by SQLite, the way in which +** that memory is allocated and released, and the policies used to +** determine exactly which parts of a database file are cached and for +** how long. +** +** The alternative page cache mechanism is an +** extreme measure that is only needed by the most demanding applications. +** The built-in page cache is recommended for most uses. +** +** ^(The contents of the sqlite3_pcache_methods2 structure are copied to an +** internal buffer by SQLite within the call to [sqlite3_config]. Hence +** the application may discard the parameter after the call to +** [sqlite3_config()] returns.)^ +** +** [[the xInit() page cache method]] +** ^(The xInit() method is called once for each effective +** call to [sqlite3_initialize()])^ +** (usually only once during the lifetime of the process). ^(The xInit() +** method is passed a copy of the sqlite3_pcache_methods2.pArg value.)^ +** The intent of the xInit() method is to set up global data structures +** required by the custom page cache implementation. +** ^(If the xInit() method is NULL, then the +** built-in default page cache is used instead of the application defined +** page cache.)^ +** +** [[the xShutdown() page cache method]] +** ^The xShutdown() method is called by [sqlite3_shutdown()]. +** It can be used to clean up +** any outstanding resources before process shutdown, if required. +** ^The xShutdown() method may be NULL. +** +** ^SQLite automatically serializes calls to the xInit method, +** so the xInit method need not be threadsafe. ^The +** xShutdown method is only called from [sqlite3_shutdown()] so it does +** not need to be threadsafe either. All other methods must be threadsafe +** in multithreaded applications. +** +** ^SQLite will never invoke xInit() more than once without an intervening +** call to xShutdown(). +** +** [[the xCreate() page cache methods]] +** ^SQLite invokes the xCreate() method to construct a new cache instance. +** SQLite will typically create one cache instance for each open database file, +** though this is not guaranteed. ^The +** first parameter, szPage, is the size in bytes of the pages that must +** be allocated by the cache. ^szPage will always a power of two. ^The +** second parameter szExtra is a number of bytes of extra storage +** associated with each page cache entry. ^The szExtra parameter will +** a number less than 250. SQLite will use the +** extra szExtra bytes on each page to store metadata about the underlying +** database page on disk. The value passed into szExtra depends +** on the SQLite version, the target platform, and how SQLite was compiled. +** ^The third argument to xCreate(), bPurgeable, is true if the cache being +** created will be used to cache database pages of a file stored on disk, or +** false if it is used for an in-memory database. The cache implementation +** does not have to do anything special based with the value of bPurgeable; +** it is purely advisory. ^On a cache where bPurgeable is false, SQLite will +** never invoke xUnpin() except to deliberately delete a page. +** ^In other words, calls to xUnpin() on a cache with bPurgeable set to +** false will always have the "discard" flag set to true. +** ^Hence, a cache created with bPurgeable false will +** never contain any unpinned pages. +** +** [[the xCachesize() page cache method]] +** ^(The xCachesize() method may be called at any time by SQLite to set the +** suggested maximum cache-size (number of pages stored by) the cache +** instance passed as the first argument. This is the value configured using +** the SQLite "[PRAGMA cache_size]" command.)^ As with the bPurgeable +** parameter, the implementation is not required to do anything with this +** value; it is advisory only. +** +** [[the xPagecount() page cache methods]] +** The xPagecount() method must return the number of pages currently +** stored in the cache, both pinned and unpinned. +** +** [[the xFetch() page cache methods]] +** The xFetch() method locates a page in the cache and returns a pointer to +** an sqlite3_pcache_page object associated with that page, or a NULL pointer. +** The pBuf element of the returned sqlite3_pcache_page object will be a +** pointer to a buffer of szPage bytes used to store the content of a +** single database page. The pExtra element of sqlite3_pcache_page will be +** a pointer to the szExtra bytes of extra storage that SQLite has requested +** for each entry in the page cache. +** +** The page to be fetched is determined by the key. ^The minimum key value +** is 1. After it has been retrieved using xFetch, the page is considered +** to be "pinned". +** +** If the requested page is already in the page cache, then the page cache +** implementation must return a pointer to the page buffer with its content +** intact. If the requested page is not already in the cache, then the +** cache implementation should use the value of the createFlag +** parameter to help it determined what action to take: +** +** +**
    createFlag Behavior when page is not already in cache +**
    0 Do not allocate a new page. Return NULL. +**
    1 Allocate a new page if it easy and convenient to do so. +** Otherwise return NULL. +**
    2 Make every effort to allocate a new page. Only return +** NULL if allocating a new page is effectively impossible. +**
    +** +** ^(SQLite will normally invoke xFetch() with a createFlag of 0 or 1. SQLite +** will only use a createFlag of 2 after a prior call with a createFlag of 1 +** failed.)^ In between the xFetch() calls, SQLite may +** attempt to unpin one or more cache pages by spilling the content of +** pinned pages to disk and synching the operating system disk cache. +** +** [[the xUnpin() page cache method]] +** ^xUnpin() is called by SQLite with a pointer to a currently pinned page +** as its second argument. If the third parameter, discard, is non-zero, +** then the page must be evicted from the cache. +** ^If the discard parameter is +** zero, then the page may be discarded or retained at the discretion of +** page cache implementation. ^The page cache implementation +** may choose to evict unpinned pages at any time. +** +** The cache must not perform any reference counting. A single +** call to xUnpin() unpins the page regardless of the number of prior calls +** to xFetch(). +** +** [[the xRekey() page cache methods]] +** The xRekey() method is used to change the key value associated with the +** page passed as the second argument. If the cache +** previously contains an entry associated with newKey, it must be +** discarded. ^Any prior cache entry associated with newKey is guaranteed not +** to be pinned. +** +** When SQLite calls the xTruncate() method, the cache must discard all +** existing cache entries with page numbers (keys) greater than or equal +** to the value of the iLimit parameter passed to xTruncate(). If any +** of these pages are pinned, they are implicitly unpinned, meaning that +** they can be safely discarded. +** +** [[the xDestroy() page cache method]] +** ^The xDestroy() method is used to delete a cache allocated by xCreate(). +** All resources associated with the specified cache should be freed. ^After +** calling the xDestroy() method, SQLite considers the [sqlite3_pcache*] +** handle invalid, and will not use it with any other sqlite3_pcache_methods2 +** functions. +** +** [[the xShrink() page cache method]] +** ^SQLite invokes the xShrink() method when it wants the page cache to +** free up as much of heap memory as possible. The page cache implementation +** is not obligated to free any memory, but well-behaved implementations should +** do their best. +*/ +typedef struct sqlite3_pcache_methods2 sqlite3_pcache_methods2; +struct sqlite3_pcache_methods2 { + int iVersion; + void *pArg; + int (*xInit)(void*); + void (*xShutdown)(void*); + sqlite3_pcache *(*xCreate)(int szPage, int szExtra, int bPurgeable); + void (*xCachesize)(sqlite3_pcache*, int nCachesize); + int (*xPagecount)(sqlite3_pcache*); + sqlite3_pcache_page *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag); + void (*xUnpin)(sqlite3_pcache*, sqlite3_pcache_page*, int discard); + void (*xRekey)(sqlite3_pcache*, sqlite3_pcache_page*, + unsigned oldKey, unsigned newKey); + void (*xTruncate)(sqlite3_pcache*, unsigned iLimit); + void (*xDestroy)(sqlite3_pcache*); + void (*xShrink)(sqlite3_pcache*); +}; + +/* +** This is the obsolete pcache_methods object that has now been replaced +** by sqlite3_pcache_methods2. This object is not used by SQLite. It is +** retained in the header file for backwards compatibility only. +*/ +typedef struct sqlite3_pcache_methods sqlite3_pcache_methods; +struct sqlite3_pcache_methods { + void *pArg; + int (*xInit)(void*); + void (*xShutdown)(void*); + sqlite3_pcache *(*xCreate)(int szPage, int bPurgeable); + void (*xCachesize)(sqlite3_pcache*, int nCachesize); + int (*xPagecount)(sqlite3_pcache*); + void *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag); + void (*xUnpin)(sqlite3_pcache*, void*, int discard); + void (*xRekey)(sqlite3_pcache*, void*, unsigned oldKey, unsigned newKey); + void (*xTruncate)(sqlite3_pcache*, unsigned iLimit); + void (*xDestroy)(sqlite3_pcache*); +}; + + +/* +** CAPI3REF: Online Backup Object +** +** The sqlite3_backup object records state information about an ongoing +** online backup operation. ^The sqlite3_backup object is created by +** a call to [sqlite3_backup_init()] and is destroyed by a call to +** [sqlite3_backup_finish()]. +** +** See Also: [Using the SQLite Online Backup API] +*/ +typedef struct sqlite3_backup sqlite3_backup; + +/* +** CAPI3REF: Online Backup API. +** +** The backup API copies the content of one database into another. +** It is useful either for creating backups of databases or +** for copying in-memory databases to or from persistent files. +** +** See Also: [Using the SQLite Online Backup API] +** +** ^SQLite holds a write transaction open on the destination database file +** for the duration of the backup operation. +** ^The source database is read-locked only while it is being read; +** it is not locked continuously for the entire backup operation. +** ^Thus, the backup may be performed on a live source database without +** preventing other database connections from +** reading or writing to the source database while the backup is underway. +** +** ^(To perform a backup operation: +**
      +**
    1. sqlite3_backup_init() is called once to initialize the +** backup, +**
    2. sqlite3_backup_step() is called one or more times to transfer +** the data between the two databases, and finally +**
    3. sqlite3_backup_finish() is called to release all resources +** associated with the backup operation. +**
    )^ +** There should be exactly one call to sqlite3_backup_finish() for each +** successful call to sqlite3_backup_init(). +** +** [[sqlite3_backup_init()]] sqlite3_backup_init() +** +** ^The D and N arguments to sqlite3_backup_init(D,N,S,M) are the +** [database connection] associated with the destination database +** and the database name, respectively. +** ^The database name is "main" for the main database, "temp" for the +** temporary database, or the name specified after the AS keyword in +** an [ATTACH] statement for an attached database. +** ^The S and M arguments passed to +** sqlite3_backup_init(D,N,S,M) identify the [database connection] +** and database name of the source database, respectively. +** ^The source and destination [database connections] (parameters S and D) +** must be different or else sqlite3_backup_init(D,N,S,M) will fail with +** an error. +** +** ^A call to sqlite3_backup_init() will fail, returning NULL, if +** there is already a read or read-write transaction open on the +** destination database. +** +** ^If an error occurs within sqlite3_backup_init(D,N,S,M), then NULL is +** returned and an error code and error message are stored in the +** destination [database connection] D. +** ^The error code and message for the failed call to sqlite3_backup_init() +** can be retrieved using the [sqlite3_errcode()], [sqlite3_errmsg()], and/or +** [sqlite3_errmsg16()] functions. +** ^A successful call to sqlite3_backup_init() returns a pointer to an +** [sqlite3_backup] object. +** ^The [sqlite3_backup] object may be used with the sqlite3_backup_step() and +** sqlite3_backup_finish() functions to perform the specified backup +** operation. +** +** [[sqlite3_backup_step()]] sqlite3_backup_step() +** +** ^Function sqlite3_backup_step(B,N) will copy up to N pages between +** the source and destination databases specified by [sqlite3_backup] object B. +** ^If N is negative, all remaining source pages are copied. +** ^If sqlite3_backup_step(B,N) successfully copies N pages and there +** are still more pages to be copied, then the function returns [SQLITE_OK]. +** ^If sqlite3_backup_step(B,N) successfully finishes copying all pages +** from source to destination, then it returns [SQLITE_DONE]. +** ^If an error occurs while running sqlite3_backup_step(B,N), +** then an [error code] is returned. ^As well as [SQLITE_OK] and +** [SQLITE_DONE], a call to sqlite3_backup_step() may return [SQLITE_READONLY], +** [SQLITE_NOMEM], [SQLITE_BUSY], [SQLITE_LOCKED], or an +** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX] extended error code. +** +** ^(The sqlite3_backup_step() might return [SQLITE_READONLY] if +**
      +**
    1. the destination database was opened read-only, or +**
    2. the destination database is using write-ahead-log journaling +** and the destination and source page sizes differ, or +**
    3. the destination database is an in-memory database and the +** destination and source page sizes differ. +**
    )^ +** +** ^If sqlite3_backup_step() cannot obtain a required file-system lock, then +** the [sqlite3_busy_handler | busy-handler function] +** is invoked (if one is specified). ^If the +** busy-handler returns non-zero before the lock is available, then +** [SQLITE_BUSY] is returned to the caller. ^In this case the call to +** sqlite3_backup_step() can be retried later. ^If the source +** [database connection] +** is being used to write to the source database when sqlite3_backup_step() +** is called, then [SQLITE_LOCKED] is returned immediately. ^Again, in this +** case the call to sqlite3_backup_step() can be retried later on. ^(If +** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX], [SQLITE_NOMEM], or +** [SQLITE_READONLY] is returned, then +** there is no point in retrying the call to sqlite3_backup_step(). These +** errors are considered fatal.)^ The application must accept +** that the backup operation has failed and pass the backup operation handle +** to the sqlite3_backup_finish() to release associated resources. +** +** ^The first call to sqlite3_backup_step() obtains an exclusive lock +** on the destination file. ^The exclusive lock is not released until either +** sqlite3_backup_finish() is called or the backup operation is complete +** and sqlite3_backup_step() returns [SQLITE_DONE]. ^Every call to +** sqlite3_backup_step() obtains a [shared lock] on the source database that +** lasts for the duration of the sqlite3_backup_step() call. +** ^Because the source database is not locked between calls to +** sqlite3_backup_step(), the source database may be modified mid-way +** through the backup process. ^If the source database is modified by an +** external process or via a database connection other than the one being +** used by the backup operation, then the backup will be automatically +** restarted by the next call to sqlite3_backup_step(). ^If the source +** database is modified by the using the same database connection as is used +** by the backup operation, then the backup database is automatically +** updated at the same time. +** +** [[sqlite3_backup_finish()]] sqlite3_backup_finish() +** +** When sqlite3_backup_step() has returned [SQLITE_DONE], or when the +** application wishes to abandon the backup operation, the application +** should destroy the [sqlite3_backup] by passing it to sqlite3_backup_finish(). +** ^The sqlite3_backup_finish() interfaces releases all +** resources associated with the [sqlite3_backup] object. +** ^If sqlite3_backup_step() has not yet returned [SQLITE_DONE], then any +** active write-transaction on the destination database is rolled back. +** The [sqlite3_backup] object is invalid +** and may not be used following a call to sqlite3_backup_finish(). +** +** ^The value returned by sqlite3_backup_finish is [SQLITE_OK] if no +** sqlite3_backup_step() errors occurred, regardless or whether or not +** sqlite3_backup_step() completed. +** ^If an out-of-memory condition or IO error occurred during any prior +** sqlite3_backup_step() call on the same [sqlite3_backup] object, then +** sqlite3_backup_finish() returns the corresponding [error code]. +** +** ^A return of [SQLITE_BUSY] or [SQLITE_LOCKED] from sqlite3_backup_step() +** is not a permanent error and does not affect the return value of +** sqlite3_backup_finish(). +** +** [[sqlite3_backup_remaining()]] [[sqlite3_backup_pagecount()]] +** sqlite3_backup_remaining() and sqlite3_backup_pagecount() +** +** ^The sqlite3_backup_remaining() routine returns the number of pages still +** to be backed up at the conclusion of the most recent sqlite3_backup_step(). +** ^The sqlite3_backup_pagecount() routine returns the total number of pages +** in the source database at the conclusion of the most recent +** sqlite3_backup_step(). +** ^(The values returned by these functions are only updated by +** sqlite3_backup_step(). If the source database is modified in a way that +** changes the size of the source database or the number of pages remaining, +** those changes are not reflected in the output of sqlite3_backup_pagecount() +** and sqlite3_backup_remaining() until after the next +** sqlite3_backup_step().)^ +** +** Concurrent Usage of Database Handles +** +** ^The source [database connection] may be used by the application for other +** purposes while a backup operation is underway or being initialized. +** ^If SQLite is compiled and configured to support threadsafe database +** connections, then the source database connection may be used concurrently +** from within other threads. +** +** However, the application must guarantee that the destination +** [database connection] is not passed to any other API (by any thread) after +** sqlite3_backup_init() is called and before the corresponding call to +** sqlite3_backup_finish(). SQLite does not currently check to see +** if the application incorrectly accesses the destination [database connection] +** and so no error code is reported, but the operations may malfunction +** nevertheless. Use of the destination database connection while a +** backup is in progress might also cause a mutex deadlock. +** +** If running in [shared cache mode], the application must +** guarantee that the shared cache used by the destination database +** is not accessed while the backup is running. In practice this means +** that the application must guarantee that the disk file being +** backed up to is not accessed by any connection within the process, +** not just the specific connection that was passed to sqlite3_backup_init(). +** +** The [sqlite3_backup] object itself is partially threadsafe. Multiple +** threads may safely make multiple concurrent calls to sqlite3_backup_step(). +** However, the sqlite3_backup_remaining() and sqlite3_backup_pagecount() +** APIs are not strictly speaking threadsafe. If they are invoked at the +** same time as another thread is invoking sqlite3_backup_step() it is +** possible that they return invalid values. +*/ +SQLITE_API sqlite3_backup *sqlite3_backup_init( + sqlite3 *pDest, /* Destination database handle */ + const char *zDestName, /* Destination database name */ + sqlite3 *pSource, /* Source database handle */ + const char *zSourceName /* Source database name */ +); +SQLITE_API int sqlite3_backup_step(sqlite3_backup *p, int nPage); +SQLITE_API int sqlite3_backup_finish(sqlite3_backup *p); +SQLITE_API int sqlite3_backup_remaining(sqlite3_backup *p); +SQLITE_API int sqlite3_backup_pagecount(sqlite3_backup *p); + +/* +** CAPI3REF: Unlock Notification +** METHOD: sqlite3 +** +** ^When running in shared-cache mode, a database operation may fail with +** an [SQLITE_LOCKED] error if the required locks on the shared-cache or +** individual tables within the shared-cache cannot be obtained. See +** [SQLite Shared-Cache Mode] for a description of shared-cache locking. +** ^This API may be used to register a callback that SQLite will invoke +** when the connection currently holding the required lock relinquishes it. +** ^This API is only available if the library was compiled with the +** [SQLITE_ENABLE_UNLOCK_NOTIFY] C-preprocessor symbol defined. +** +** See Also: [Using the SQLite Unlock Notification Feature]. +** +** ^Shared-cache locks are released when a database connection concludes +** its current transaction, either by committing it or rolling it back. +** +** ^When a connection (known as the blocked connection) fails to obtain a +** shared-cache lock and SQLITE_LOCKED is returned to the caller, the +** identity of the database connection (the blocking connection) that +** has locked the required resource is stored internally. ^After an +** application receives an SQLITE_LOCKED error, it may call the +** sqlite3_unlock_notify() method with the blocked connection handle as +** the first argument to register for a callback that will be invoked +** when the blocking connections current transaction is concluded. ^The +** callback is invoked from within the [sqlite3_step] or [sqlite3_close] +** call that concludes the blocking connection's transaction. +** +** ^(If sqlite3_unlock_notify() is called in a multi-threaded application, +** there is a chance that the blocking connection will have already +** concluded its transaction by the time sqlite3_unlock_notify() is invoked. +** If this happens, then the specified callback is invoked immediately, +** from within the call to sqlite3_unlock_notify().)^ +** +** ^If the blocked connection is attempting to obtain a write-lock on a +** shared-cache table, and more than one other connection currently holds +** a read-lock on the same table, then SQLite arbitrarily selects one of +** the other connections to use as the blocking connection. +** +** ^(There may be at most one unlock-notify callback registered by a +** blocked connection. If sqlite3_unlock_notify() is called when the +** blocked connection already has a registered unlock-notify callback, +** then the new callback replaces the old.)^ ^If sqlite3_unlock_notify() is +** called with a NULL pointer as its second argument, then any existing +** unlock-notify callback is canceled. ^The blocked connections +** unlock-notify callback may also be canceled by closing the blocked +** connection using [sqlite3_close()]. +** +** The unlock-notify callback is not reentrant. If an application invokes +** any sqlite3_xxx API functions from within an unlock-notify callback, a +** crash or deadlock may be the result. +** +** ^Unless deadlock is detected (see below), sqlite3_unlock_notify() always +** returns SQLITE_OK. +** +** Callback Invocation Details +** +** When an unlock-notify callback is registered, the application provides a +** single void* pointer that is passed to the callback when it is invoked. +** However, the signature of the callback function allows SQLite to pass +** it an array of void* context pointers. The first argument passed to +** an unlock-notify callback is a pointer to an array of void* pointers, +** and the second is the number of entries in the array. +** +** When a blocking connection's transaction is concluded, there may be +** more than one blocked connection that has registered for an unlock-notify +** callback. ^If two or more such blocked connections have specified the +** same callback function, then instead of invoking the callback function +** multiple times, it is invoked once with the set of void* context pointers +** specified by the blocked connections bundled together into an array. +** This gives the application an opportunity to prioritize any actions +** related to the set of unblocked database connections. +** +** Deadlock Detection +** +** Assuming that after registering for an unlock-notify callback a +** database waits for the callback to be issued before taking any further +** action (a reasonable assumption), then using this API may cause the +** application to deadlock. For example, if connection X is waiting for +** connection Y's transaction to be concluded, and similarly connection +** Y is waiting on connection X's transaction, then neither connection +** will proceed and the system may remain deadlocked indefinitely. +** +** To avoid this scenario, the sqlite3_unlock_notify() performs deadlock +** detection. ^If a given call to sqlite3_unlock_notify() would put the +** system in a deadlocked state, then SQLITE_LOCKED is returned and no +** unlock-notify callback is registered. The system is said to be in +** a deadlocked state if connection A has registered for an unlock-notify +** callback on the conclusion of connection B's transaction, and connection +** B has itself registered for an unlock-notify callback when connection +** A's transaction is concluded. ^Indirect deadlock is also detected, so +** the system is also considered to be deadlocked if connection B has +** registered for an unlock-notify callback on the conclusion of connection +** C's transaction, where connection C is waiting on connection A. ^Any +** number of levels of indirection are allowed. +** +** The "DROP TABLE" Exception +** +** When a call to [sqlite3_step()] returns SQLITE_LOCKED, it is almost +** always appropriate to call sqlite3_unlock_notify(). There is however, +** one exception. When executing a "DROP TABLE" or "DROP INDEX" statement, +** SQLite checks if there are any currently executing SELECT statements +** that belong to the same connection. If there are, SQLITE_LOCKED is +** returned. In this case there is no "blocking connection", so invoking +** sqlite3_unlock_notify() results in the unlock-notify callback being +** invoked immediately. If the application then re-attempts the "DROP TABLE" +** or "DROP INDEX" query, an infinite loop might be the result. +** +** One way around this problem is to check the extended error code returned +** by an sqlite3_step() call. ^(If there is a blocking connection, then the +** extended error code is set to SQLITE_LOCKED_SHAREDCACHE. Otherwise, in +** the special "DROP TABLE/INDEX" case, the extended error code is just +** SQLITE_LOCKED.)^ +*/ +SQLITE_API int sqlite3_unlock_notify( + sqlite3 *pBlocked, /* Waiting connection */ + void (*xNotify)(void **apArg, int nArg), /* Callback function to invoke */ + void *pNotifyArg /* Argument to pass to xNotify */ +); + + +/* +** CAPI3REF: String Comparison +** +** ^The [sqlite3_stricmp()] and [sqlite3_strnicmp()] APIs allow applications +** and extensions to compare the contents of two buffers containing UTF-8 +** strings in a case-independent fashion, using the same definition of "case +** independence" that SQLite uses internally when comparing identifiers. +*/ +SQLITE_API int sqlite3_stricmp(const char *, const char *); +SQLITE_API int sqlite3_strnicmp(const char *, const char *, int); + +/* +** CAPI3REF: String Globbing +* +** ^The [sqlite3_strglob(P,X)] interface returns zero if and only if +** string X matches the [GLOB] pattern P. +** ^The definition of [GLOB] pattern matching used in +** [sqlite3_strglob(P,X)] is the same as for the "X GLOB P" operator in the +** SQL dialect understood by SQLite. ^The [sqlite3_strglob(P,X)] function +** is case sensitive. +** +** Note that this routine returns zero on a match and non-zero if the strings +** do not match, the same as [sqlite3_stricmp()] and [sqlite3_strnicmp()]. +** +** See also: [sqlite3_strlike()]. +*/ +SQLITE_API int sqlite3_strglob(const char *zGlob, const char *zStr); + +/* +** CAPI3REF: String LIKE Matching +* +** ^The [sqlite3_strlike(P,X,E)] interface returns zero if and only if +** string X matches the [LIKE] pattern P with escape character E. +** ^The definition of [LIKE] pattern matching used in +** [sqlite3_strlike(P,X,E)] is the same as for the "X LIKE P ESCAPE E" +** operator in the SQL dialect understood by SQLite. ^For "X LIKE P" without +** the ESCAPE clause, set the E parameter of [sqlite3_strlike(P,X,E)] to 0. +** ^As with the LIKE operator, the [sqlite3_strlike(P,X,E)] function is case +** insensitive - equivalent upper and lower case ASCII characters match +** one another. +** +** ^The [sqlite3_strlike(P,X,E)] function matches Unicode characters, though +** only ASCII characters are case folded. +** +** Note that this routine returns zero on a match and non-zero if the strings +** do not match, the same as [sqlite3_stricmp()] and [sqlite3_strnicmp()]. +** +** See also: [sqlite3_strglob()]. +*/ +SQLITE_API int sqlite3_strlike(const char *zGlob, const char *zStr, unsigned int cEsc); + +/* +** CAPI3REF: Error Logging Interface +** +** ^The [sqlite3_log()] interface writes a message into the [error log] +** established by the [SQLITE_CONFIG_LOG] option to [sqlite3_config()]. +** ^If logging is enabled, the zFormat string and subsequent arguments are +** used with [sqlite3_snprintf()] to generate the final output string. +** +** The sqlite3_log() interface is intended for use by extensions such as +** virtual tables, collating functions, and SQL functions. While there is +** nothing to prevent an application from calling sqlite3_log(), doing so +** is considered bad form. +** +** The zFormat string must not be NULL. +** +** To avoid deadlocks and other threading problems, the sqlite3_log() routine +** will not use dynamically allocated memory. The log message is stored in +** a fixed-length buffer on the stack. If the log message is longer than +** a few hundred characters, it will be truncated to the length of the +** buffer. +*/ +SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...); + +/* +** CAPI3REF: Write-Ahead Log Commit Hook +** METHOD: sqlite3 +** +** ^The [sqlite3_wal_hook()] function is used to register a callback that +** is invoked each time data is committed to a database in wal mode. +** +** ^(The callback is invoked by SQLite after the commit has taken place and +** the associated write-lock on the database released)^, so the implementation +** may read, write or [checkpoint] the database as required. +** +** ^The first parameter passed to the callback function when it is invoked +** is a copy of the third parameter passed to sqlite3_wal_hook() when +** registering the callback. ^The second is a copy of the database handle. +** ^The third parameter is the name of the database that was written to - +** either "main" or the name of an [ATTACH]-ed database. ^The fourth parameter +** is the number of pages currently in the write-ahead log file, +** including those that were just committed. +** +** The callback function should normally return [SQLITE_OK]. ^If an error +** code is returned, that error will propagate back up through the +** SQLite code base to cause the statement that provoked the callback +** to report an error, though the commit will have still occurred. If the +** callback returns [SQLITE_ROW] or [SQLITE_DONE], or if it returns a value +** that does not correspond to any valid SQLite error code, the results +** are undefined. +** +** A single database handle may have at most a single write-ahead log callback +** registered at one time. ^Calling [sqlite3_wal_hook()] replaces any +** previously registered write-ahead log callback. ^The return value is +** a copy of the third parameter from the previous call, if any, or 0. +** ^Note that the [sqlite3_wal_autocheckpoint()] interface and the +** [wal_autocheckpoint pragma] both invoke [sqlite3_wal_hook()] and will +** overwrite any prior [sqlite3_wal_hook()] settings. +*/ +SQLITE_API void *sqlite3_wal_hook( + sqlite3*, + int(*)(void *,sqlite3*,const char*,int), + void* +); + +/* +** CAPI3REF: Configure an auto-checkpoint +** METHOD: sqlite3 +** +** ^The [sqlite3_wal_autocheckpoint(D,N)] is a wrapper around +** [sqlite3_wal_hook()] that causes any database on [database connection] D +** to automatically [checkpoint] +** after committing a transaction if there are N or +** more frames in the [write-ahead log] file. ^Passing zero or +** a negative value as the nFrame parameter disables automatic +** checkpoints entirely. +** +** ^The callback registered by this function replaces any existing callback +** registered using [sqlite3_wal_hook()]. ^Likewise, registering a callback +** using [sqlite3_wal_hook()] disables the automatic checkpoint mechanism +** configured by this function. +** +** ^The [wal_autocheckpoint pragma] can be used to invoke this interface +** from SQL. +** +** ^Checkpoints initiated by this mechanism are +** [sqlite3_wal_checkpoint_v2|PASSIVE]. +** +** ^Every new [database connection] defaults to having the auto-checkpoint +** enabled with a threshold of 1000 or [SQLITE_DEFAULT_WAL_AUTOCHECKPOINT] +** pages. The use of this interface +** is only necessary if the default setting is found to be suboptimal +** for a particular application. +*/ +SQLITE_API int sqlite3_wal_autocheckpoint(sqlite3 *db, int N); + +/* +** CAPI3REF: Checkpoint a database +** METHOD: sqlite3 +** +** ^(The sqlite3_wal_checkpoint(D,X) is equivalent to +** [sqlite3_wal_checkpoint_v2](D,X,[SQLITE_CHECKPOINT_PASSIVE],0,0).)^ +** +** In brief, sqlite3_wal_checkpoint(D,X) causes the content in the +** [write-ahead log] for database X on [database connection] D to be +** transferred into the database file and for the write-ahead log to +** be reset. See the [checkpointing] documentation for addition +** information. +** +** This interface used to be the only way to cause a checkpoint to +** occur. But then the newer and more powerful [sqlite3_wal_checkpoint_v2()] +** interface was added. This interface is retained for backwards +** compatibility and as a convenience for applications that need to manually +** start a callback but which do not need the full power (and corresponding +** complication) of [sqlite3_wal_checkpoint_v2()]. +*/ +SQLITE_API int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb); + +/* +** CAPI3REF: Checkpoint a database +** METHOD: sqlite3 +** +** ^(The sqlite3_wal_checkpoint_v2(D,X,M,L,C) interface runs a checkpoint +** operation on database X of [database connection] D in mode M. Status +** information is written back into integers pointed to by L and C.)^ +** ^(The M parameter must be a valid [checkpoint mode]:)^ +** +**
    +**
    SQLITE_CHECKPOINT_PASSIVE
    +** ^Checkpoint as many frames as possible without waiting for any database +** readers or writers to finish, then sync the database file if all frames +** in the log were checkpointed. ^The [busy-handler callback] +** is never invoked in the SQLITE_CHECKPOINT_PASSIVE mode. +** ^On the other hand, passive mode might leave the checkpoint unfinished +** if there are concurrent readers or writers. +** +**
    SQLITE_CHECKPOINT_FULL
    +** ^This mode blocks (it invokes the +** [sqlite3_busy_handler|busy-handler callback]) until there is no +** database writer and all readers are reading from the most recent database +** snapshot. ^It then checkpoints all frames in the log file and syncs the +** database file. ^This mode blocks new database writers while it is pending, +** but new database readers are allowed to continue unimpeded. +** +**
    SQLITE_CHECKPOINT_RESTART
    +** ^This mode works the same way as SQLITE_CHECKPOINT_FULL with the addition +** that after checkpointing the log file it blocks (calls the +** [busy-handler callback]) +** until all readers are reading from the database file only. ^This ensures +** that the next writer will restart the log file from the beginning. +** ^Like SQLITE_CHECKPOINT_FULL, this mode blocks new +** database writer attempts while it is pending, but does not impede readers. +** +**
    SQLITE_CHECKPOINT_TRUNCATE
    +** ^This mode works the same way as SQLITE_CHECKPOINT_RESTART with the +** addition that it also truncates the log file to zero bytes just prior +** to a successful return. +**
    +** +** ^If pnLog is not NULL, then *pnLog is set to the total number of frames in +** the log file or to -1 if the checkpoint could not run because +** of an error or because the database is not in [WAL mode]. ^If pnCkpt is not +** NULL,then *pnCkpt is set to the total number of checkpointed frames in the +** log file (including any that were already checkpointed before the function +** was called) or to -1 if the checkpoint could not run due to an error or +** because the database is not in WAL mode. ^Note that upon successful +** completion of an SQLITE_CHECKPOINT_TRUNCATE, the log file will have been +** truncated to zero bytes and so both *pnLog and *pnCkpt will be set to zero. +** +** ^All calls obtain an exclusive "checkpoint" lock on the database file. ^If +** any other process is running a checkpoint operation at the same time, the +** lock cannot be obtained and SQLITE_BUSY is returned. ^Even if there is a +** busy-handler configured, it will not be invoked in this case. +** +** ^The SQLITE_CHECKPOINT_FULL, RESTART and TRUNCATE modes also obtain the +** exclusive "writer" lock on the database file. ^If the writer lock cannot be +** obtained immediately, and a busy-handler is configured, it is invoked and +** the writer lock retried until either the busy-handler returns 0 or the lock +** is successfully obtained. ^The busy-handler is also invoked while waiting for +** database readers as described above. ^If the busy-handler returns 0 before +** the writer lock is obtained or while waiting for database readers, the +** checkpoint operation proceeds from that point in the same way as +** SQLITE_CHECKPOINT_PASSIVE - checkpointing as many frames as possible +** without blocking any further. ^SQLITE_BUSY is returned in this case. +** +** ^If parameter zDb is NULL or points to a zero length string, then the +** specified operation is attempted on all WAL databases [attached] to +** [database connection] db. In this case the +** values written to output parameters *pnLog and *pnCkpt are undefined. ^If +** an SQLITE_BUSY error is encountered when processing one or more of the +** attached WAL databases, the operation is still attempted on any remaining +** attached databases and SQLITE_BUSY is returned at the end. ^If any other +** error occurs while processing an attached database, processing is abandoned +** and the error code is returned to the caller immediately. ^If no error +** (SQLITE_BUSY or otherwise) is encountered while processing the attached +** databases, SQLITE_OK is returned. +** +** ^If database zDb is the name of an attached database that is not in WAL +** mode, SQLITE_OK is returned and both *pnLog and *pnCkpt set to -1. ^If +** zDb is not NULL (or a zero length string) and is not the name of any +** attached database, SQLITE_ERROR is returned to the caller. +** +** ^Unless it returns SQLITE_MISUSE, +** the sqlite3_wal_checkpoint_v2() interface +** sets the error information that is queried by +** [sqlite3_errcode()] and [sqlite3_errmsg()]. +** +** ^The [PRAGMA wal_checkpoint] command can be used to invoke this interface +** from SQL. +*/ +SQLITE_API int sqlite3_wal_checkpoint_v2( + sqlite3 *db, /* Database handle */ + const char *zDb, /* Name of attached database (or NULL) */ + int eMode, /* SQLITE_CHECKPOINT_* value */ + int *pnLog, /* OUT: Size of WAL log in frames */ + int *pnCkpt /* OUT: Total number of frames checkpointed */ +); + +/* +** CAPI3REF: Checkpoint Mode Values +** KEYWORDS: {checkpoint mode} +** +** These constants define all valid values for the "checkpoint mode" passed +** as the third parameter to the [sqlite3_wal_checkpoint_v2()] interface. +** See the [sqlite3_wal_checkpoint_v2()] documentation for details on the +** meaning of each of these checkpoint modes. +*/ +#define SQLITE_CHECKPOINT_PASSIVE 0 /* Do as much as possible w/o blocking */ +#define SQLITE_CHECKPOINT_FULL 1 /* Wait for writers, then checkpoint */ +#define SQLITE_CHECKPOINT_RESTART 2 /* Like FULL but wait for readers */ +#define SQLITE_CHECKPOINT_TRUNCATE 3 /* Like RESTART but also truncate WAL */ + +/* +** CAPI3REF: Virtual Table Interface Configuration +** +** This function may be called by either the [xConnect] or [xCreate] method +** of a [virtual table] implementation to configure +** various facets of the virtual table interface. +** +** If this interface is invoked outside the context of an xConnect or +** xCreate virtual table method then the behavior is undefined. +** +** In the call sqlite3_vtab_config(D,C,...) the D parameter is the +** [database connection] in which the virtual table is being created and +** which is passed in as the first argument to the [xConnect] or [xCreate] +** method that is invoking sqlite3_vtab_config(). The C parameter is one +** of the [virtual table configuration options]. The presence and meaning +** of parameters after C depend on which [virtual table configuration option] +** is used. +*/ +SQLITE_API int sqlite3_vtab_config(sqlite3*, int op, ...); + +/* +** CAPI3REF: Virtual Table Configuration Options +** KEYWORDS: {virtual table configuration options} +** KEYWORDS: {virtual table configuration option} +** +** These macros define the various options to the +** [sqlite3_vtab_config()] interface that [virtual table] implementations +** can use to customize and optimize their behavior. +** +**
    +** [[SQLITE_VTAB_CONSTRAINT_SUPPORT]] +**
    SQLITE_VTAB_CONSTRAINT_SUPPORT
    +**
    Calls of the form +** [sqlite3_vtab_config](db,SQLITE_VTAB_CONSTRAINT_SUPPORT,X) are supported, +** where X is an integer. If X is zero, then the [virtual table] whose +** [xCreate] or [xConnect] method invoked [sqlite3_vtab_config()] does not +** support constraints. In this configuration (which is the default) if +** a call to the [xUpdate] method returns [SQLITE_CONSTRAINT], then the entire +** statement is rolled back as if [ON CONFLICT | OR ABORT] had been +** specified as part of the users SQL statement, regardless of the actual +** ON CONFLICT mode specified. +** +** If X is non-zero, then the virtual table implementation guarantees +** that if [xUpdate] returns [SQLITE_CONSTRAINT], it will do so before +** any modifications to internal or persistent data structures have been made. +** If the [ON CONFLICT] mode is ABORT, FAIL, IGNORE or ROLLBACK, SQLite +** is able to roll back a statement or database transaction, and abandon +** or continue processing the current SQL statement as appropriate. +** If the ON CONFLICT mode is REPLACE and the [xUpdate] method returns +** [SQLITE_CONSTRAINT], SQLite handles this as if the ON CONFLICT mode +** had been ABORT. +** +** Virtual table implementations that are required to handle OR REPLACE +** must do so within the [xUpdate] method. If a call to the +** [sqlite3_vtab_on_conflict()] function indicates that the current ON +** CONFLICT policy is REPLACE, the virtual table implementation should +** silently replace the appropriate rows within the xUpdate callback and +** return SQLITE_OK. Or, if this is not possible, it may return +** SQLITE_CONSTRAINT, in which case SQLite falls back to OR ABORT +** constraint handling. +**
    +** +** [[SQLITE_VTAB_DIRECTONLY]]
    SQLITE_VTAB_DIRECTONLY
    +**
    Calls of the form +** [sqlite3_vtab_config](db,SQLITE_VTAB_DIRECTONLY) from within the +** the [xConnect] or [xCreate] methods of a [virtual table] implmentation +** prohibits that virtual table from being used from within triggers and +** views. +**
    +** +** [[SQLITE_VTAB_INNOCUOUS]]
    SQLITE_VTAB_INNOCUOUS
    +**
    Calls of the form +** [sqlite3_vtab_config](db,SQLITE_VTAB_INNOCUOUS) from within the +** the [xConnect] or [xCreate] methods of a [virtual table] implementation +** identify that virtual table as being safe to use from within triggers +** and views. Conceptually, the SQLITE_VTAB_INNOCUOUS tag means that the +** virtual table can do no serious harm even if it is controlled by a +** malicious hacker. Developers should avoid setting the SQLITE_VTAB_INNOCUOUS +** flag unless absolutely necessary. +**
    +** +** [[SQLITE_VTAB_USES_ALL_SCHEMAS]]
    SQLITE_VTAB_USES_ALL_SCHEMAS
    +**
    Calls of the form +** [sqlite3_vtab_config](db,SQLITE_VTAB_USES_ALL_SCHEMA) from within the +** the [xConnect] or [xCreate] methods of a [virtual table] implementation +** instruct the query planner to begin at least a read transaction on +** all schemas ("main", "temp", and any ATTACH-ed databases) whenever the +** virtual table is used. +**
    +**
    +*/ +#define SQLITE_VTAB_CONSTRAINT_SUPPORT 1 +#define SQLITE_VTAB_INNOCUOUS 2 +#define SQLITE_VTAB_DIRECTONLY 3 +#define SQLITE_VTAB_USES_ALL_SCHEMAS 4 + +/* +** CAPI3REF: Determine The Virtual Table Conflict Policy +** +** This function may only be called from within a call to the [xUpdate] method +** of a [virtual table] implementation for an INSERT or UPDATE operation. ^The +** value returned is one of [SQLITE_ROLLBACK], [SQLITE_IGNORE], [SQLITE_FAIL], +** [SQLITE_ABORT], or [SQLITE_REPLACE], according to the [ON CONFLICT] mode +** of the SQL statement that triggered the call to the [xUpdate] method of the +** [virtual table]. +*/ +SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *); + +/* +** CAPI3REF: Determine If Virtual Table Column Access Is For UPDATE +** +** If the sqlite3_vtab_nochange(X) routine is called within the [xColumn] +** method of a [virtual table], then it might return true if the +** column is being fetched as part of an UPDATE operation during which the +** column value will not change. The virtual table implementation can use +** this hint as permission to substitute a return value that is less +** expensive to compute and that the corresponding +** [xUpdate] method understands as a "no-change" value. +** +** If the [xColumn] method calls sqlite3_vtab_nochange() and finds that +** the column is not changed by the UPDATE statement, then the xColumn +** method can optionally return without setting a result, without calling +** any of the [sqlite3_result_int|sqlite3_result_xxxxx() interfaces]. +** In that case, [sqlite3_value_nochange(X)] will return true for the +** same column in the [xUpdate] method. +** +** The sqlite3_vtab_nochange() routine is an optimization. Virtual table +** implementations should continue to give a correct answer even if the +** sqlite3_vtab_nochange() interface were to always return false. In the +** current implementation, the sqlite3_vtab_nochange() interface does always +** returns false for the enhanced [UPDATE FROM] statement. +*/ +SQLITE_API int sqlite3_vtab_nochange(sqlite3_context*); + +/* +** CAPI3REF: Determine The Collation For a Virtual Table Constraint +** METHOD: sqlite3_index_info +** +** This function may only be called from within a call to the [xBestIndex] +** method of a [virtual table]. This function returns a pointer to a string +** that is the name of the appropriate collation sequence to use for text +** comparisons on the constraint identified by its arguments. +** +** The first argument must be the pointer to the [sqlite3_index_info] object +** that is the first parameter to the xBestIndex() method. The second argument +** must be an index into the aConstraint[] array belonging to the +** sqlite3_index_info structure passed to xBestIndex. +** +** Important: +** The first parameter must be the same pointer that is passed into the +** xBestMethod() method. The first parameter may not be a pointer to a +** different [sqlite3_index_info] object, even an exact copy. +** +** The return value is computed as follows: +** +**
      +**

    1. If the constraint comes from a WHERE clause expression that contains +** a [COLLATE operator], then the name of the collation specified by +** that COLLATE operator is returned. +**

    2. If there is no COLLATE operator, but the column that is the subject +** of the constraint specifies an alternative collating sequence via +** a [COLLATE clause] on the column definition within the CREATE TABLE +** statement that was passed into [sqlite3_declare_vtab()], then the +** name of that alternative collating sequence is returned. +**

    3. Otherwise, "BINARY" is returned. +**

    +*/ +SQLITE_API const char *sqlite3_vtab_collation(sqlite3_index_info*,int); + +/* +** CAPI3REF: Determine if a virtual table query is DISTINCT +** METHOD: sqlite3_index_info +** +** This API may only be used from within an [xBestIndex|xBestIndex method] +** of a [virtual table] implementation. The result of calling this +** interface from outside of xBestIndex() is undefined and probably harmful. +** +** ^The sqlite3_vtab_distinct() interface returns an integer between 0 and +** 3. The integer returned by sqlite3_vtab_distinct() +** gives the virtual table additional information about how the query +** planner wants the output to be ordered. As long as the virtual table +** can meet the ordering requirements of the query planner, it may set +** the "orderByConsumed" flag. +** +**

    1. +** ^If the sqlite3_vtab_distinct() interface returns 0, that means +** that the query planner needs the virtual table to return all rows in the +** sort order defined by the "nOrderBy" and "aOrderBy" fields of the +** [sqlite3_index_info] object. This is the default expectation. If the +** virtual table outputs all rows in sorted order, then it is always safe for +** the xBestIndex method to set the "orderByConsumed" flag, regardless of +** the return value from sqlite3_vtab_distinct(). +**

    2. +** ^(If the sqlite3_vtab_distinct() interface returns 1, that means +** that the query planner does not need the rows to be returned in sorted order +** as long as all rows with the same values in all columns identified by the +** "aOrderBy" field are adjacent.)^ This mode is used when the query planner +** is doing a GROUP BY. +**

    3. +** ^(If the sqlite3_vtab_distinct() interface returns 2, that means +** that the query planner does not need the rows returned in any particular +** order, as long as rows with the same values in all "aOrderBy" columns +** are adjacent.)^ ^(Furthermore, only a single row for each particular +** combination of values in the columns identified by the "aOrderBy" field +** needs to be returned.)^ ^It is always ok for two or more rows with the same +** values in all "aOrderBy" columns to be returned, as long as all such rows +** are adjacent. ^The virtual table may, if it chooses, omit extra rows +** that have the same value for all columns identified by "aOrderBy". +** ^However omitting the extra rows is optional. +** This mode is used for a DISTINCT query. +**

    4. +** ^(If the sqlite3_vtab_distinct() interface returns 3, that means +** that the query planner needs only distinct rows but it does need the +** rows to be sorted.)^ ^The virtual table implementation is free to omit +** rows that are identical in all aOrderBy columns, if it wants to, but +** it is not required to omit any rows. This mode is used for queries +** that have both DISTINCT and ORDER BY clauses. +**

    +** +** ^For the purposes of comparing virtual table output values to see if the +** values are same value for sorting purposes, two NULL values are considered +** to be the same. In other words, the comparison operator is "IS" +** (or "IS NOT DISTINCT FROM") and not "==". +** +** If a virtual table implementation is unable to meet the requirements +** specified above, then it must not set the "orderByConsumed" flag in the +** [sqlite3_index_info] object or an incorrect answer may result. +** +** ^A virtual table implementation is always free to return rows in any order +** it wants, as long as the "orderByConsumed" flag is not set. ^When the +** the "orderByConsumed" flag is unset, the query planner will add extra +** [bytecode] to ensure that the final results returned by the SQL query are +** ordered correctly. The use of the "orderByConsumed" flag and the +** sqlite3_vtab_distinct() interface is merely an optimization. ^Careful +** use of the sqlite3_vtab_distinct() interface and the "orderByConsumed" +** flag might help queries against a virtual table to run faster. Being +** overly aggressive and setting the "orderByConsumed" flag when it is not +** valid to do so, on the other hand, might cause SQLite to return incorrect +** results. +*/ +SQLITE_API int sqlite3_vtab_distinct(sqlite3_index_info*); + +/* +** CAPI3REF: Identify and handle IN constraints in xBestIndex +** +** This interface may only be used from within an +** [xBestIndex|xBestIndex() method] of a [virtual table] implementation. +** The result of invoking this interface from any other context is +** undefined and probably harmful. +** +** ^(A constraint on a virtual table of the form +** "[IN operator|column IN (...)]" is +** communicated to the xBestIndex method as a +** [SQLITE_INDEX_CONSTRAINT_EQ] constraint.)^ If xBestIndex wants to use +** this constraint, it must set the corresponding +** aConstraintUsage[].argvIndex to a postive integer. ^(Then, under +** the usual mode of handling IN operators, SQLite generates [bytecode] +** that invokes the [xFilter|xFilter() method] once for each value +** on the right-hand side of the IN operator.)^ Thus the virtual table +** only sees a single value from the right-hand side of the IN operator +** at a time. +** +** In some cases, however, it would be advantageous for the virtual +** table to see all values on the right-hand of the IN operator all at +** once. The sqlite3_vtab_in() interfaces facilitates this in two ways: +** +**
      +**

    1. +** ^A call to sqlite3_vtab_in(P,N,-1) will return true (non-zero) +** if and only if the [sqlite3_index_info|P->aConstraint][N] constraint +** is an [IN operator] that can be processed all at once. ^In other words, +** sqlite3_vtab_in() with -1 in the third argument is a mechanism +** by which the virtual table can ask SQLite if all-at-once processing +** of the IN operator is even possible. +** +**

    2. +** ^A call to sqlite3_vtab_in(P,N,F) with F==1 or F==0 indicates +** to SQLite that the virtual table does or does not want to process +** the IN operator all-at-once, respectively. ^Thus when the third +** parameter (F) is non-negative, this interface is the mechanism by +** which the virtual table tells SQLite how it wants to process the +** IN operator. +**

    +** +** ^The sqlite3_vtab_in(P,N,F) interface can be invoked multiple times +** within the same xBestIndex method call. ^For any given P,N pair, +** the return value from sqlite3_vtab_in(P,N,F) will always be the same +** within the same xBestIndex call. ^If the interface returns true +** (non-zero), that means that the constraint is an IN operator +** that can be processed all-at-once. ^If the constraint is not an IN +** operator or cannot be processed all-at-once, then the interface returns +** false. +** +** ^(All-at-once processing of the IN operator is selected if both of the +** following conditions are met: +** +**
      +**

    1. The P->aConstraintUsage[N].argvIndex value is set to a positive +** integer. This is how the virtual table tells SQLite that it wants to +** use the N-th constraint. +** +**

    2. The last call to sqlite3_vtab_in(P,N,F) for which F was +** non-negative had F>=1. +**

    )^ +** +** ^If either or both of the conditions above are false, then SQLite uses +** the traditional one-at-a-time processing strategy for the IN constraint. +** ^If both conditions are true, then the argvIndex-th parameter to the +** xFilter method will be an [sqlite3_value] that appears to be NULL, +** but which can be passed to [sqlite3_vtab_in_first()] and +** [sqlite3_vtab_in_next()] to find all values on the right-hand side +** of the IN constraint. +*/ +SQLITE_API int sqlite3_vtab_in(sqlite3_index_info*, int iCons, int bHandle); + +/* +** CAPI3REF: Find all elements on the right-hand side of an IN constraint. +** +** These interfaces are only useful from within the +** [xFilter|xFilter() method] of a [virtual table] implementation. +** The result of invoking these interfaces from any other context +** is undefined and probably harmful. +** +** The X parameter in a call to sqlite3_vtab_in_first(X,P) or +** sqlite3_vtab_in_next(X,P) should be one of the parameters to the +** xFilter method which invokes these routines, and specifically +** a parameter that was previously selected for all-at-once IN constraint +** processing use the [sqlite3_vtab_in()] interface in the +** [xBestIndex|xBestIndex method]. ^(If the X parameter is not +** an xFilter argument that was selected for all-at-once IN constraint +** processing, then these routines return [SQLITE_ERROR].)^ +** +** ^(Use these routines to access all values on the right-hand side +** of the IN constraint using code like the following: +** +** 
    +**    for(rc=sqlite3_vtab_in_first(pList, &pVal);
+**        rc==SQLITE_OK && pVal;
+**        rc=sqlite3_vtab_in_next(pList, &pVal)
+**    ){
+**      // do something with pVal
+**    }
+**    if( rc!=SQLITE_OK ){
+**      // an error has occurred
+**    }
+**
    )^ +** +** ^On success, the sqlite3_vtab_in_first(X,P) and sqlite3_vtab_in_next(X,P) +** routines return SQLITE_OK and set *P to point to the first or next value +** on the RHS of the IN constraint. ^If there are no more values on the +** right hand side of the IN constraint, then *P is set to NULL and these +** routines return [SQLITE_DONE]. ^The return value might be +** some other value, such as SQLITE_NOMEM, in the event of a malfunction. +** +** The *ppOut values returned by these routines are only valid until the +** next call to either of these routines or until the end of the xFilter +** method from which these routines were called. If the virtual table +** implementation needs to retain the *ppOut values for longer, it must make +** copies. The *ppOut values are [protected sqlite3_value|protected]. +*/ +SQLITE_API int sqlite3_vtab_in_first(sqlite3_value *pVal, sqlite3_value **ppOut); +SQLITE_API int sqlite3_vtab_in_next(sqlite3_value *pVal, sqlite3_value **ppOut); + +/* +** CAPI3REF: Constraint values in xBestIndex() +** METHOD: sqlite3_index_info +** +** This API may only be used from within the [xBestIndex|xBestIndex method] +** of a [virtual table] implementation. The result of calling this interface +** from outside of an xBestIndex method are undefined and probably harmful. +** +** ^When the sqlite3_vtab_rhs_value(P,J,V) interface is invoked from within +** the [xBestIndex] method of a [virtual table] implementation, with P being +** a copy of the [sqlite3_index_info] object pointer passed into xBestIndex and +** J being a 0-based index into P->aConstraint[], then this routine +** attempts to set *V to the value of the right-hand operand of +** that constraint if the right-hand operand is known. ^If the +** right-hand operand is not known, then *V is set to a NULL pointer. +** ^The sqlite3_vtab_rhs_value(P,J,V) interface returns SQLITE_OK if +** and only if *V is set to a value. ^The sqlite3_vtab_rhs_value(P,J,V) +** inteface returns SQLITE_NOTFOUND if the right-hand side of the J-th +** constraint is not available. ^The sqlite3_vtab_rhs_value() interface +** can return an result code other than SQLITE_OK or SQLITE_NOTFOUND if +** something goes wrong. +** +** The sqlite3_vtab_rhs_value() interface is usually only successful if +** the right-hand operand of a constraint is a literal value in the original +** SQL statement. If the right-hand operand is an expression or a reference +** to some other column or a [host parameter], then sqlite3_vtab_rhs_value() +** will probably return [SQLITE_NOTFOUND]. +** +** ^(Some constraints, such as [SQLITE_INDEX_CONSTRAINT_ISNULL] and +** [SQLITE_INDEX_CONSTRAINT_ISNOTNULL], have no right-hand operand. For such +** constraints, sqlite3_vtab_rhs_value() always returns SQLITE_NOTFOUND.)^ +** +** ^The [sqlite3_value] object returned in *V is a protected sqlite3_value +** and remains valid for the duration of the xBestIndex method call. +** ^When xBestIndex returns, the sqlite3_value object returned by +** sqlite3_vtab_rhs_value() is automatically deallocated. +** +** The "_rhs_" in the name of this routine is an abbreviation for +** "Right-Hand Side". +*/ +SQLITE_API int sqlite3_vtab_rhs_value(sqlite3_index_info*, int, sqlite3_value **ppVal); + +/* +** CAPI3REF: Conflict resolution modes +** KEYWORDS: {conflict resolution mode} +** +** These constants are returned by [sqlite3_vtab_on_conflict()] to +** inform a [virtual table] implementation what the [ON CONFLICT] mode +** is for the SQL statement being evaluated. +** +** Note that the [SQLITE_IGNORE] constant is also used as a potential +** return value from the [sqlite3_set_authorizer()] callback and that +** [SQLITE_ABORT] is also a [result code]. +*/ +#define SQLITE_ROLLBACK 1 +/* #define SQLITE_IGNORE 2 // Also used by sqlite3_authorizer() callback */ +#define SQLITE_FAIL 3 +/* #define SQLITE_ABORT 4 // Also an error code */ +#define SQLITE_REPLACE 5 + +/* +** CAPI3REF: Prepared Statement Scan Status Opcodes +** KEYWORDS: {scanstatus options} +** +** The following constants can be used for the T parameter to the +** [sqlite3_stmt_scanstatus(S,X,T,V)] interface. Each constant designates a +** different metric for sqlite3_stmt_scanstatus() to return. +** +** When the value returned to V is a string, space to hold that string is +** managed by the prepared statement S and will be automatically freed when +** S is finalized. +** +** Not all values are available for all query elements. When a value is +** not available, the output variable is set to -1 if the value is numeric, +** or to NULL if it is a string (SQLITE_SCANSTAT_NAME). +** +**
    +** [[SQLITE_SCANSTAT_NLOOP]]
    SQLITE_SCANSTAT_NLOOP
    +**
    ^The [sqlite3_int64] variable pointed to by the V parameter will be +** set to the total number of times that the X-th loop has run.
    +** +** [[SQLITE_SCANSTAT_NVISIT]]
    SQLITE_SCANSTAT_NVISIT
    +**
    ^The [sqlite3_int64] variable pointed to by the V parameter will be set +** to the total number of rows examined by all iterations of the X-th loop.
    +** +** [[SQLITE_SCANSTAT_EST]]
    SQLITE_SCANSTAT_EST
    +**
    ^The "double" variable pointed to by the V parameter will be set to the +** query planner's estimate for the average number of rows output from each +** iteration of the X-th loop. If the query planner's estimates was accurate, +** then this value will approximate the quotient NVISIT/NLOOP and the +** product of this value for all prior loops with the same SELECTID will +** be the NLOOP value for the current loop. +** +** [[SQLITE_SCANSTAT_NAME]]
    SQLITE_SCANSTAT_NAME
    +**
    ^The "const char *" variable pointed to by the V parameter will be set +** to a zero-terminated UTF-8 string containing the name of the index or table +** used for the X-th loop. +** +** [[SQLITE_SCANSTAT_EXPLAIN]]
    SQLITE_SCANSTAT_EXPLAIN
    +**
    ^The "const char *" variable pointed to by the V parameter will be set +** to a zero-terminated UTF-8 string containing the [EXPLAIN QUERY PLAN] +** description for the X-th loop. +** +** [[SQLITE_SCANSTAT_SELECTID]]
    SQLITE_SCANSTAT_SELECTID
    +**
    ^The "int" variable pointed to by the V parameter will be set to the +** id for the X-th query plan element. The id value is unique within the +** statement. The select-id is the same value as is output in the first +** column of an [EXPLAIN QUERY PLAN] query. +** +** [[SQLITE_SCANSTAT_PARENTID]]
    SQLITE_SCANSTAT_PARENTID
    +**
    The "int" variable pointed to by the V parameter will be set to the +** the id of the parent of the current query element, if applicable, or +** to zero if the query element has no parent. This is the same value as +** returned in the second column of an [EXPLAIN QUERY PLAN] query. +** +** [[SQLITE_SCANSTAT_NCYCLE]]
    SQLITE_SCANSTAT_NCYCLE
    +**
    The sqlite3_int64 output value is set to the number of cycles, +** according to the processor time-stamp counter, that elapsed while the +** query element was being processed. This value is not available for +** all query elements - if it is unavailable the output variable is +** set to -1. +**
    +*/ +#define SQLITE_SCANSTAT_NLOOP 0 +#define SQLITE_SCANSTAT_NVISIT 1 +#define SQLITE_SCANSTAT_EST 2 +#define SQLITE_SCANSTAT_NAME 3 +#define SQLITE_SCANSTAT_EXPLAIN 4 +#define SQLITE_SCANSTAT_SELECTID 5 +#define SQLITE_SCANSTAT_PARENTID 6 +#define SQLITE_SCANSTAT_NCYCLE 7 + +/* +** CAPI3REF: Prepared Statement Scan Status +** METHOD: sqlite3_stmt +** +** These interfaces return information about the predicted and measured +** performance for pStmt. Advanced applications can use this +** interface to compare the predicted and the measured performance and +** issue warnings and/or rerun [ANALYZE] if discrepancies are found. +** +** Since this interface is expected to be rarely used, it is only +** available if SQLite is compiled using the [SQLITE_ENABLE_STMT_SCANSTATUS] +** compile-time option. +** +** The "iScanStatusOp" parameter determines which status information to return. +** The "iScanStatusOp" must be one of the [scanstatus options] or the behavior +** of this interface is undefined. ^The requested measurement is written into +** a variable pointed to by the "pOut" parameter. +** +** The "flags" parameter must be passed a mask of flags. At present only +** one flag is defined - SQLITE_SCANSTAT_COMPLEX. If SQLITE_SCANSTAT_COMPLEX +** is specified, then status information is available for all elements +** of a query plan that are reported by "EXPLAIN QUERY PLAN" output. If +** SQLITE_SCANSTAT_COMPLEX is not specified, then only query plan elements +** that correspond to query loops (the "SCAN..." and "SEARCH..." elements of +** the EXPLAIN QUERY PLAN output) are available. Invoking API +** sqlite3_stmt_scanstatus() is equivalent to calling +** sqlite3_stmt_scanstatus_v2() with a zeroed flags parameter. +** +** Parameter "idx" identifies the specific query element to retrieve statistics +** for. Query elements are numbered starting from zero. A value of -1 may be +** to query for statistics regarding the entire query. ^If idx is out of range +** - less than -1 or greater than or equal to the total number of query +** elements used to implement the statement - a non-zero value is returned and +** the variable that pOut points to is unchanged. +** +** See also: [sqlite3_stmt_scanstatus_reset()] +*/ +SQLITE_API int sqlite3_stmt_scanstatus( + sqlite3_stmt *pStmt, /* Prepared statement for which info desired */ + int idx, /* Index of loop to report on */ + int iScanStatusOp, /* Information desired. SQLITE_SCANSTAT_* */ + void *pOut /* Result written here */ +); +SQLITE_API int sqlite3_stmt_scanstatus_v2( + sqlite3_stmt *pStmt, /* Prepared statement for which info desired */ + int idx, /* Index of loop to report on */ + int iScanStatusOp, /* Information desired. SQLITE_SCANSTAT_* */ + int flags, /* Mask of flags defined below */ + void *pOut /* Result written here */ +); + +/* +** CAPI3REF: Prepared Statement Scan Status +** KEYWORDS: {scan status flags} +*/ +#define SQLITE_SCANSTAT_COMPLEX 0x0001 + +/* +** CAPI3REF: Zero Scan-Status Counters +** METHOD: sqlite3_stmt +** +** ^Zero all [sqlite3_stmt_scanstatus()] related event counters. +** +** This API is only available if the library is built with pre-processor +** symbol [SQLITE_ENABLE_STMT_SCANSTATUS] defined. +*/ +SQLITE_API void sqlite3_stmt_scanstatus_reset(sqlite3_stmt*); + +/* +** CAPI3REF: Flush caches to disk mid-transaction +** METHOD: sqlite3 +** +** ^If a write-transaction is open on [database connection] D when the +** [sqlite3_db_cacheflush(D)] interface invoked, any dirty +** pages in the pager-cache that are not currently in use are written out +** to disk. A dirty page may be in use if a database cursor created by an +** active SQL statement is reading from it, or if it is page 1 of a database +** file (page 1 is always "in use"). ^The [sqlite3_db_cacheflush(D)] +** interface flushes caches for all schemas - "main", "temp", and +** any [attached] databases. +** +** ^If this function needs to obtain extra database locks before dirty pages +** can be flushed to disk, it does so. ^If those locks cannot be obtained +** immediately and there is a busy-handler callback configured, it is invoked +** in the usual manner. ^If the required lock still cannot be obtained, then +** the database is skipped and an attempt made to flush any dirty pages +** belonging to the next (if any) database. ^If any databases are skipped +** because locks cannot be obtained, but no other error occurs, this +** function returns SQLITE_BUSY. +** +** ^If any other error occurs while flushing dirty pages to disk (for +** example an IO error or out-of-memory condition), then processing is +** abandoned and an SQLite [error code] is returned to the caller immediately. +** +** ^Otherwise, if no error occurs, [sqlite3_db_cacheflush()] returns SQLITE_OK. +** +** ^This function does not set the database handle error code or message +** returned by the [sqlite3_errcode()] and [sqlite3_errmsg()] functions. +*/ +SQLITE_API int sqlite3_db_cacheflush(sqlite3*); + +/* +** CAPI3REF: The pre-update hook. +** METHOD: sqlite3 +** +** ^These interfaces are only available if SQLite is compiled using the +** [SQLITE_ENABLE_PREUPDATE_HOOK] compile-time option. +** +** ^The [sqlite3_preupdate_hook()] interface registers a callback function +** that is invoked prior to each [INSERT], [UPDATE], and [DELETE] operation +** on a database table. +** ^At most one preupdate hook may be registered at a time on a single +** [database connection]; each call to [sqlite3_preupdate_hook()] overrides +** the previous setting. +** ^The preupdate hook is disabled by invoking [sqlite3_preupdate_hook()] +** with a NULL pointer as the second parameter. +** ^The third parameter to [sqlite3_preupdate_hook()] is passed through as +** the first parameter to callbacks. +** +** ^The preupdate hook only fires for changes to real database tables; the +** preupdate hook is not invoked for changes to [virtual tables] or to +** system tables like sqlite_sequence or sqlite_stat1. +** +** ^The second parameter to the preupdate callback is a pointer to +** the [database connection] that registered the preupdate hook. +** ^The third parameter to the preupdate callback is one of the constants +** [SQLITE_INSERT], [SQLITE_DELETE], or [SQLITE_UPDATE] to identify the +** kind of update operation that is about to occur. +** ^(The fourth parameter to the preupdate callback is the name of the +** database within the database connection that is being modified. This +** will be "main" for the main database or "temp" for TEMP tables or +** the name given after the AS keyword in the [ATTACH] statement for attached +** databases.)^ +** ^The fifth parameter to the preupdate callback is the name of the +** table that is being modified. +** +** For an UPDATE or DELETE operation on a [rowid table], the sixth +** parameter passed to the preupdate callback is the initial [rowid] of the +** row being modified or deleted. For an INSERT operation on a rowid table, +** or any operation on a WITHOUT ROWID table, the value of the sixth +** parameter is undefined. For an INSERT or UPDATE on a rowid table the +** seventh parameter is the final rowid value of the row being inserted +** or updated. The value of the seventh parameter passed to the callback +** function is not defined for operations on WITHOUT ROWID tables, or for +** DELETE operations on rowid tables. +** +** ^The sqlite3_preupdate_hook(D,C,P) function returns the P argument from +** the previous call on the same [database connection] D, or NULL for +** the first call on D. +** +** The [sqlite3_preupdate_old()], [sqlite3_preupdate_new()], +** [sqlite3_preupdate_count()], and [sqlite3_preupdate_depth()] interfaces +** provide additional information about a preupdate event. These routines +** may only be called from within a preupdate callback. Invoking any of +** these routines from outside of a preupdate callback or with a +** [database connection] pointer that is different from the one supplied +** to the preupdate callback results in undefined and probably undesirable +** behavior. +** +** ^The [sqlite3_preupdate_count(D)] interface returns the number of columns +** in the row that is being inserted, updated, or deleted. +** +** ^The [sqlite3_preupdate_old(D,N,P)] interface writes into P a pointer to +** a [protected sqlite3_value] that contains the value of the Nth column of +** the table row before it is updated. The N parameter must be between 0 +** and one less than the number of columns or the behavior will be +** undefined. This must only be used within SQLITE_UPDATE and SQLITE_DELETE +** preupdate callbacks; if it is used by an SQLITE_INSERT callback then the +** behavior is undefined. The [sqlite3_value] that P points to +** will be destroyed when the preupdate callback returns. +** +** ^The [sqlite3_preupdate_new(D,N,P)] interface writes into P a pointer to +** a [protected sqlite3_value] that contains the value of the Nth column of +** the table row after it is updated. The N parameter must be between 0 +** and one less than the number of columns or the behavior will be +** undefined. This must only be used within SQLITE_INSERT and SQLITE_UPDATE +** preupdate callbacks; if it is used by an SQLITE_DELETE callback then the +** behavior is undefined. The [sqlite3_value] that P points to +** will be destroyed when the preupdate callback returns. +** +** ^The [sqlite3_preupdate_depth(D)] interface returns 0 if the preupdate +** callback was invoked as a result of a direct insert, update, or delete +** operation; or 1 for inserts, updates, or deletes invoked by top-level +** triggers; or 2 for changes resulting from triggers called by top-level +** triggers; and so forth. +** +** When the [sqlite3_blob_write()] API is used to update a blob column, +** the pre-update hook is invoked with SQLITE_DELETE. This is because the +** in this case the new values are not available. In this case, when a +** callback made with op==SQLITE_DELETE is actuall a write using the +** sqlite3_blob_write() API, the [sqlite3_preupdate_blobwrite()] returns +** the index of the column being written. In other cases, where the +** pre-update hook is being invoked for some other reason, including a +** regular DELETE, sqlite3_preupdate_blobwrite() returns -1. +** +** See also: [sqlite3_update_hook()] +*/ +#if defined(SQLITE_ENABLE_PREUPDATE_HOOK) +SQLITE_API void *sqlite3_preupdate_hook( + sqlite3 *db, + void(*xPreUpdate)( + void *pCtx, /* Copy of third arg to preupdate_hook() */ + sqlite3 *db, /* Database handle */ + int op, /* SQLITE_UPDATE, DELETE or INSERT */ + char const *zDb, /* Database name */ + char const *zName, /* Table name */ + sqlite3_int64 iKey1, /* Rowid of row about to be deleted/updated */ + sqlite3_int64 iKey2 /* New rowid value (for a rowid UPDATE) */ + ), + void* +); +SQLITE_API int sqlite3_preupdate_old(sqlite3 *, int, sqlite3_value **); +SQLITE_API int sqlite3_preupdate_count(sqlite3 *); +SQLITE_API int sqlite3_preupdate_depth(sqlite3 *); +SQLITE_API int sqlite3_preupdate_new(sqlite3 *, int, sqlite3_value **); +SQLITE_API int sqlite3_preupdate_blobwrite(sqlite3 *); +#endif + +/* +** CAPI3REF: Low-level system error code +** METHOD: sqlite3 +** +** ^Attempt to return the underlying operating system error code or error +** number that caused the most recent I/O error or failure to open a file. +** The return value is OS-dependent. For example, on unix systems, after +** [sqlite3_open_v2()] returns [SQLITE_CANTOPEN], this interface could be +** called to get back the underlying "errno" that caused the problem, such +** as ENOSPC, EAUTH, EISDIR, and so forth. +*/ +SQLITE_API int sqlite3_system_errno(sqlite3*); + +/* +** CAPI3REF: Database Snapshot +** KEYWORDS: {snapshot} {sqlite3_snapshot} +** +** An instance of the snapshot object records the state of a [WAL mode] +** database for some specific point in history. +** +** In [WAL mode], multiple [database connections] that are open on the +** same database file can each be reading a different historical version +** of the database file. When a [database connection] begins a read +** transaction, that connection sees an unchanging copy of the database +** as it existed for the point in time when the transaction first started. +** Subsequent changes to the database from other connections are not seen +** by the reader until a new read transaction is started. +** +** The sqlite3_snapshot object records state information about an historical +** version of the database file so that it is possible to later open a new read +** transaction that sees that historical version of the database rather than +** the most recent version. +*/ +typedef struct sqlite3_snapshot { + unsigned char hidden[48]; +} sqlite3_snapshot; + +/* +** CAPI3REF: Record A Database Snapshot +** CONSTRUCTOR: sqlite3_snapshot +** +** ^The [sqlite3_snapshot_get(D,S,P)] interface attempts to make a +** new [sqlite3_snapshot] object that records the current state of +** schema S in database connection D. ^On success, the +** [sqlite3_snapshot_get(D,S,P)] interface writes a pointer to the newly +** created [sqlite3_snapshot] object into *P and returns SQLITE_OK. +** If there is not already a read-transaction open on schema S when +** this function is called, one is opened automatically. +** +** The following must be true for this function to succeed. If any of +** the following statements are false when sqlite3_snapshot_get() is +** called, SQLITE_ERROR is returned. The final value of *P is undefined +** in this case. +** +**
      +**
    • The database handle must not be in [autocommit mode]. +** +**
    • Schema S of [database connection] D must be a [WAL mode] database. +** +**
    • There must not be a write transaction open on schema S of database +** connection D. +** +**
    • One or more transactions must have been written to the current wal +** file since it was created on disk (by any connection). This means +** that a snapshot cannot be taken on a wal mode database with no wal +** file immediately after it is first opened. At least one transaction +** must be written to it first. +**
    +** +** This function may also return SQLITE_NOMEM. If it is called with the +** database handle in autocommit mode but fails for some other reason, +** whether or not a read transaction is opened on schema S is undefined. +** +** The [sqlite3_snapshot] object returned from a successful call to +** [sqlite3_snapshot_get()] must be freed using [sqlite3_snapshot_free()] +** to avoid a memory leak. +** +** The [sqlite3_snapshot_get()] interface is only available when the +** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used. +*/ +SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_get( + sqlite3 *db, + const char *zSchema, + sqlite3_snapshot **ppSnapshot +); + +/* +** CAPI3REF: Start a read transaction on an historical snapshot +** METHOD: sqlite3_snapshot +** +** ^The [sqlite3_snapshot_open(D,S,P)] interface either starts a new read +** transaction or upgrades an existing one for schema S of +** [database connection] D such that the read transaction refers to +** historical [snapshot] P, rather than the most recent change to the +** database. ^The [sqlite3_snapshot_open()] interface returns SQLITE_OK +** on success or an appropriate [error code] if it fails. +** +** ^In order to succeed, the database connection must not be in +** [autocommit mode] when [sqlite3_snapshot_open(D,S,P)] is called. If there +** is already a read transaction open on schema S, then the database handle +** must have no active statements (SELECT statements that have been passed +** to sqlite3_step() but not sqlite3_reset() or sqlite3_finalize()). +** SQLITE_ERROR is returned if either of these conditions is violated, or +** if schema S does not exist, or if the snapshot object is invalid. +** +** ^A call to sqlite3_snapshot_open() will fail to open if the specified +** snapshot has been overwritten by a [checkpoint]. In this case +** SQLITE_ERROR_SNAPSHOT is returned. +** +** If there is already a read transaction open when this function is +** invoked, then the same read transaction remains open (on the same +** database snapshot) if SQLITE_ERROR, SQLITE_BUSY or SQLITE_ERROR_SNAPSHOT +** is returned. If another error code - for example SQLITE_PROTOCOL or an +** SQLITE_IOERR error code - is returned, then the final state of the +** read transaction is undefined. If SQLITE_OK is returned, then the +** read transaction is now open on database snapshot P. +** +** ^(A call to [sqlite3_snapshot_open(D,S,P)] will fail if the +** database connection D does not know that the database file for +** schema S is in [WAL mode]. A database connection might not know +** that the database file is in [WAL mode] if there has been no prior +** I/O on that database connection, or if the database entered [WAL mode] +** after the most recent I/O on the database connection.)^ +** (Hint: Run "[PRAGMA application_id]" against a newly opened +** database connection in order to make it ready to use snapshots.) +** +** The [sqlite3_snapshot_open()] interface is only available when the +** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used. +*/ +SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_open( + sqlite3 *db, + const char *zSchema, + sqlite3_snapshot *pSnapshot +); + +/* +** CAPI3REF: Destroy a snapshot +** DESTRUCTOR: sqlite3_snapshot +** +** ^The [sqlite3_snapshot_free(P)] interface destroys [sqlite3_snapshot] P. +** The application must eventually free every [sqlite3_snapshot] object +** using this routine to avoid a memory leak. +** +** The [sqlite3_snapshot_free()] interface is only available when the +** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used. +*/ +SQLITE_API SQLITE_EXPERIMENTAL void sqlite3_snapshot_free(sqlite3_snapshot*); + +/* +** CAPI3REF: Compare the ages of two snapshot handles. +** METHOD: sqlite3_snapshot +** +** The sqlite3_snapshot_cmp(P1, P2) interface is used to compare the ages +** of two valid snapshot handles. +** +** If the two snapshot handles are not associated with the same database +** file, the result of the comparison is undefined. +** +** Additionally, the result of the comparison is only valid if both of the +** snapshot handles were obtained by calling sqlite3_snapshot_get() since the +** last time the wal file was deleted. The wal file is deleted when the +** database is changed back to rollback mode or when the number of database +** clients drops to zero. If either snapshot handle was obtained before the +** wal file was last deleted, the value returned by this function +** is undefined. +** +** Otherwise, this API returns a negative value if P1 refers to an older +** snapshot than P2, zero if the two handles refer to the same database +** snapshot, and a positive value if P1 is a newer snapshot than P2. +** +** This interface is only available if SQLite is compiled with the +** [SQLITE_ENABLE_SNAPSHOT] option. +*/ +SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_cmp( + sqlite3_snapshot *p1, + sqlite3_snapshot *p2 +); + +/* +** CAPI3REF: Recover snapshots from a wal file +** METHOD: sqlite3_snapshot +** +** If a [WAL file] remains on disk after all database connections close +** (either through the use of the [SQLITE_FCNTL_PERSIST_WAL] [file control] +** or because the last process to have the database opened exited without +** calling [sqlite3_close()]) and a new connection is subsequently opened +** on that database and [WAL file], the [sqlite3_snapshot_open()] interface +** will only be able to open the last transaction added to the WAL file +** even though the WAL file contains other valid transactions. +** +** This function attempts to scan the WAL file associated with database zDb +** of database handle db and make all valid snapshots available to +** sqlite3_snapshot_open(). It is an error if there is already a read +** transaction open on the database, or if the database is not a WAL mode +** database. +** +** SQLITE_OK is returned if successful, or an SQLite error code otherwise. +** +** This interface is only available if SQLite is compiled with the +** [SQLITE_ENABLE_SNAPSHOT] option. +*/ +SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_recover(sqlite3 *db, const char *zDb); + +/* +** CAPI3REF: Serialize a database +** +** The sqlite3_serialize(D,S,P,F) interface returns a pointer to memory +** that is a serialization of the S database on [database connection] D. +** If P is not a NULL pointer, then the size of the database in bytes +** is written into *P. +** +** For an ordinary on-disk database file, the serialization is just a +** copy of the disk file. For an in-memory database or a "TEMP" database, +** the serialization is the same sequence of bytes which would be written +** to disk if that database where backed up to disk. +** +** The usual case is that sqlite3_serialize() copies the serialization of +** the database into memory obtained from [sqlite3_malloc64()] and returns +** a pointer to that memory. The caller is responsible for freeing the +** returned value to avoid a memory leak. However, if the F argument +** contains the SQLITE_SERIALIZE_NOCOPY bit, then no memory allocations +** are made, and the sqlite3_serialize() function will return a pointer +** to the contiguous memory representation of the database that SQLite +** is currently using for that database, or NULL if the no such contiguous +** memory representation of the database exists. A contiguous memory +** representation of the database will usually only exist if there has +** been a prior call to [sqlite3_deserialize(D,S,...)] with the same +** values of D and S. +** The size of the database is written into *P even if the +** SQLITE_SERIALIZE_NOCOPY bit is set but no contiguous copy +** of the database exists. +** +** A call to sqlite3_serialize(D,S,P,F) might return NULL even if the +** SQLITE_SERIALIZE_NOCOPY bit is omitted from argument F if a memory +** allocation error occurs. +** +** This interface is omitted if SQLite is compiled with the +** [SQLITE_OMIT_DESERIALIZE] option. +*/ +SQLITE_API unsigned char *sqlite3_serialize( + sqlite3 *db, /* The database connection */ + const char *zSchema, /* Which DB to serialize. ex: "main", "temp", ... */ + sqlite3_int64 *piSize, /* Write size of the DB here, if not NULL */ + unsigned int mFlags /* Zero or more SQLITE_SERIALIZE_* flags */ +); + +/* +** CAPI3REF: Flags for sqlite3_serialize +** +** Zero or more of the following constants can be OR-ed together for +** the F argument to [sqlite3_serialize(D,S,P,F)]. +** +** SQLITE_SERIALIZE_NOCOPY means that [sqlite3_serialize()] will return +** a pointer to contiguous in-memory database that it is currently using, +** without making a copy of the database. If SQLite is not currently using +** a contiguous in-memory database, then this option causes +** [sqlite3_serialize()] to return a NULL pointer. SQLite will only be +** using a contiguous in-memory database if it has been initialized by a +** prior call to [sqlite3_deserialize()]. +*/ +#define SQLITE_SERIALIZE_NOCOPY 0x001 /* Do no memory allocations */ + +/* +** CAPI3REF: Deserialize a database +** +** The sqlite3_deserialize(D,S,P,N,M,F) interface causes the +** [database connection] D to disconnect from database S and then +** reopen S as an in-memory database based on the serialization contained +** in P. The serialized database P is N bytes in size. M is the size of +** the buffer P, which might be larger than N. If M is larger than N, and +** the SQLITE_DESERIALIZE_READONLY bit is not set in F, then SQLite is +** permitted to add content to the in-memory database as long as the total +** size does not exceed M bytes. +** +** If the SQLITE_DESERIALIZE_FREEONCLOSE bit is set in F, then SQLite will +** invoke sqlite3_free() on the serialization buffer when the database +** connection closes. If the SQLITE_DESERIALIZE_RESIZEABLE bit is set, then +** SQLite will try to increase the buffer size using sqlite3_realloc64() +** if writes on the database cause it to grow larger than M bytes. +** +** The sqlite3_deserialize() interface will fail with SQLITE_BUSY if the +** database is currently in a read transaction or is involved in a backup +** operation. +** +** It is not possible to deserialized into the TEMP database. If the +** S argument to sqlite3_deserialize(D,S,P,N,M,F) is "temp" then the +** function returns SQLITE_ERROR. +** +** If sqlite3_deserialize(D,S,P,N,M,F) fails for any reason and if the +** SQLITE_DESERIALIZE_FREEONCLOSE bit is set in argument F, then +** [sqlite3_free()] is invoked on argument P prior to returning. +** +** This interface is omitted if SQLite is compiled with the +** [SQLITE_OMIT_DESERIALIZE] option. +*/ +SQLITE_API int sqlite3_deserialize( + sqlite3 *db, /* The database connection */ + const char *zSchema, /* Which DB to reopen with the deserialization */ + unsigned char *pData, /* The serialized database content */ + sqlite3_int64 szDb, /* Number bytes in the deserialization */ + sqlite3_int64 szBuf, /* Total size of buffer pData[] */ + unsigned mFlags /* Zero or more SQLITE_DESERIALIZE_* flags */ +); + +/* +** CAPI3REF: Flags for sqlite3_deserialize() +** +** The following are allowed values for 6th argument (the F argument) to +** the [sqlite3_deserialize(D,S,P,N,M,F)] interface. +** +** The SQLITE_DESERIALIZE_FREEONCLOSE means that the database serialization +** in the P argument is held in memory obtained from [sqlite3_malloc64()] +** and that SQLite should take ownership of this memory and automatically +** free it when it has finished using it. Without this flag, the caller +** is responsible for freeing any dynamically allocated memory. +** +** The SQLITE_DESERIALIZE_RESIZEABLE flag means that SQLite is allowed to +** grow the size of the database using calls to [sqlite3_realloc64()]. This +** flag should only be used if SQLITE_DESERIALIZE_FREEONCLOSE is also used. +** Without this flag, the deserialized database cannot increase in size beyond +** the number of bytes specified by the M parameter. +** +** The SQLITE_DESERIALIZE_READONLY flag means that the deserialized database +** should be treated as read-only. +*/ +#define SQLITE_DESERIALIZE_FREEONCLOSE 1 /* Call sqlite3_free() on close */ +#define SQLITE_DESERIALIZE_RESIZEABLE 2 /* Resize using sqlite3_realloc64() */ +#define SQLITE_DESERIALIZE_READONLY 4 /* Database is read-only */ + +/* +** Undo the hack that converts floating point types to integer for +** builds on processors without floating point support. +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# undef double +#endif + +#if defined(__wasi__) +# undef SQLITE_WASI +# define SQLITE_WASI 1 +# undef SQLITE_OMIT_WAL +# define SQLITE_OMIT_WAL 1/* because it requires shared memory APIs */ +# ifndef SQLITE_OMIT_LOAD_EXTENSION +# define SQLITE_OMIT_LOAD_EXTENSION +# endif +# ifndef SQLITE_THREADSAFE +# define SQLITE_THREADSAFE 0 +# endif +#endif + +#if 0 +} /* End of the 'extern "C"' block */ +#endif +#endif /* SQLITE3_H */ + +/******** Begin file sqlite3rtree.h *********/ +/* +** 2010 August 30 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +*/ + +#ifndef _SQLITE3RTREE_H_ +#define _SQLITE3RTREE_H_ + + +#if 0 +extern "C" { +#endif + +typedef struct sqlite3_rtree_geometry sqlite3_rtree_geometry; +typedef struct sqlite3_rtree_query_info sqlite3_rtree_query_info; + +/* The double-precision datatype used by RTree depends on the +** SQLITE_RTREE_INT_ONLY compile-time option. +*/ +#ifdef SQLITE_RTREE_INT_ONLY + typedef sqlite3_int64 sqlite3_rtree_dbl; +#else + typedef double sqlite3_rtree_dbl; +#endif + +/* +** Register a geometry callback named zGeom that can be used as part of an +** R-Tree geometry query as follows: +** +** SELECT ... FROM WHERE MATCH $zGeom(... params ...) +*/ +SQLITE_API int sqlite3_rtree_geometry_callback( + sqlite3 *db, + const char *zGeom, + int (*xGeom)(sqlite3_rtree_geometry*, int, sqlite3_rtree_dbl*,int*), + void *pContext +); + + +/* +** A pointer to a structure of the following type is passed as the first +** argument to callbacks registered using rtree_geometry_callback(). +*/ +struct sqlite3_rtree_geometry { + void *pContext; /* Copy of pContext passed to s_r_g_c() */ + int nParam; /* Size of array aParam[] */ + sqlite3_rtree_dbl *aParam; /* Parameters passed to SQL geom function */ + void *pUser; /* Callback implementation user data */ + void (*xDelUser)(void *); /* Called by SQLite to clean up pUser */ +}; + +/* +** Register a 2nd-generation geometry callback named zScore that can be +** used as part of an R-Tree geometry query as follows: +** +** SELECT ... FROM WHERE MATCH $zQueryFunc(... params ...) +*/ +SQLITE_API int sqlite3_rtree_query_callback( + sqlite3 *db, + const char *zQueryFunc, + int (*xQueryFunc)(sqlite3_rtree_query_info*), + void *pContext, + void (*xDestructor)(void*) +); + + +/* +** A pointer to a structure of the following type is passed as the +** argument to scored geometry callback registered using +** sqlite3_rtree_query_callback(). +** +** Note that the first 5 fields of this structure are identical to +** sqlite3_rtree_geometry. This structure is a subclass of +** sqlite3_rtree_geometry. +*/ +struct sqlite3_rtree_query_info { + void *pContext; /* pContext from when function registered */ + int nParam; /* Number of function parameters */ + sqlite3_rtree_dbl *aParam; /* value of function parameters */ + void *pUser; /* callback can use this, if desired */ + void (*xDelUser)(void*); /* function to free pUser */ + sqlite3_rtree_dbl *aCoord; /* Coordinates of node or entry to check */ + unsigned int *anQueue; /* Number of pending entries in the queue */ + int nCoord; /* Number of coordinates */ + int iLevel; /* Level of current node or entry */ + int mxLevel; /* The largest iLevel value in the tree */ + sqlite3_int64 iRowid; /* Rowid for current entry */ + sqlite3_rtree_dbl rParentScore; /* Score of parent node */ + int eParentWithin; /* Visibility of parent node */ + int eWithin; /* OUT: Visibility */ + sqlite3_rtree_dbl rScore; /* OUT: Write the score here */ + /* The following fields are only available in 3.8.11 and later */ + sqlite3_value **apSqlParam; /* Original SQL values of parameters */ +}; + +/* +** Allowed values for sqlite3_rtree_query.eWithin and .eParentWithin. +*/ +#define NOT_WITHIN 0 /* Object completely outside of query region */ +#define PARTLY_WITHIN 1 /* Object partially overlaps query region */ +#define FULLY_WITHIN 2 /* Object fully contained within query region */ + + +#if 0 +} /* end of the 'extern "C"' block */ +#endif + +#endif /* ifndef _SQLITE3RTREE_H_ */ + +/******** End of sqlite3rtree.h *********/ +/******** Begin file sqlite3session.h *********/ + +#if !defined(__SQLITESESSION_H_) && defined(SQLITE_ENABLE_SESSION) +#define __SQLITESESSION_H_ 1 + +/* +** Make sure we can call this stuff from C++. +*/ +#if 0 +extern "C" { +#endif + + +/* +** CAPI3REF: Session Object Handle +** +** An instance of this object is a [session] that can be used to +** record changes to a database. +*/ +typedef struct sqlite3_session sqlite3_session; + +/* +** CAPI3REF: Changeset Iterator Handle +** +** An instance of this object acts as a cursor for iterating +** over the elements of a [changeset] or [patchset]. +*/ +typedef struct sqlite3_changeset_iter sqlite3_changeset_iter; + +/* +** CAPI3REF: Create A New Session Object +** CONSTRUCTOR: sqlite3_session +** +** Create a new session object attached to database handle db. If successful, +** a pointer to the new object is written to *ppSession and SQLITE_OK is +** returned. If an error occurs, *ppSession is set to NULL and an SQLite +** error code (e.g. SQLITE_NOMEM) is returned. +** +** It is possible to create multiple session objects attached to a single +** database handle. +** +** Session objects created using this function should be deleted using the +** [sqlite3session_delete()] function before the database handle that they +** are attached to is itself closed. If the database handle is closed before +** the session object is deleted, then the results of calling any session +** module function, including [sqlite3session_delete()] on the session object +** are undefined. +** +** Because the session module uses the [sqlite3_preupdate_hook()] API, it +** is not possible for an application to register a pre-update hook on a +** database handle that has one or more session objects attached. Nor is +** it possible to create a session object attached to a database handle for +** which a pre-update hook is already defined. The results of attempting +** either of these things are undefined. +** +** The session object will be used to create changesets for tables in +** database zDb, where zDb is either "main", or "temp", or the name of an +** attached database. It is not an error if database zDb is not attached +** to the database when the session object is created. +*/ +SQLITE_API int sqlite3session_create( + sqlite3 *db, /* Database handle */ + const char *zDb, /* Name of db (e.g. "main") */ + sqlite3_session **ppSession /* OUT: New session object */ +); + +/* +** CAPI3REF: Delete A Session Object +** DESTRUCTOR: sqlite3_session +** +** Delete a session object previously allocated using +** [sqlite3session_create()]. Once a session object has been deleted, the +** results of attempting to use pSession with any other session module +** function are undefined. +** +** Session objects must be deleted before the database handle to which they +** are attached is closed. Refer to the documentation for +** [sqlite3session_create()] for details. +*/ +SQLITE_API void sqlite3session_delete(sqlite3_session *pSession); + +/* +** CAPI3REF: Configure a Session Object +** METHOD: sqlite3_session +** +** This method is used to configure a session object after it has been +** created. At present the only valid values for the second parameter are +** [SQLITE_SESSION_OBJCONFIG_SIZE] and [SQLITE_SESSION_OBJCONFIG_ROWID]. +** +*/ +SQLITE_API int sqlite3session_object_config(sqlite3_session*, int op, void *pArg); + +/* +** CAPI3REF: Options for sqlite3session_object_config +** +** The following values may passed as the the 2nd parameter to +** sqlite3session_object_config(). +** +**
    SQLITE_SESSION_OBJCONFIG_SIZE
    +** This option is used to set, clear or query the flag that enables +** the [sqlite3session_changeset_size()] API. Because it imposes some +** computational overhead, this API is disabled by default. Argument +** pArg must point to a value of type (int). If the value is initially +** 0, then the sqlite3session_changeset_size() API is disabled. If it +** is greater than 0, then the same API is enabled. Or, if the initial +** value is less than zero, no change is made. In all cases the (int) +** variable is set to 1 if the sqlite3session_changeset_size() API is +** enabled following the current call, or 0 otherwise. +** +** It is an error (SQLITE_MISUSE) to attempt to modify this setting after +** the first table has been attached to the session object. +** +**
    SQLITE_SESSION_OBJCONFIG_ROWID
    +** This option is used to set, clear or query the flag that enables +** collection of data for tables with no explicit PRIMARY KEY. +** +** Normally, tables with no explicit PRIMARY KEY are simply ignored +** by the sessions module. However, if this flag is set, it behaves +** as if such tables have a column "_rowid_ INTEGER PRIMARY KEY" inserted +** as their leftmost columns. +** +** It is an error (SQLITE_MISUSE) to attempt to modify this setting after +** the first table has been attached to the session object. +*/ +#define SQLITE_SESSION_OBJCONFIG_SIZE 1 +#define SQLITE_SESSION_OBJCONFIG_ROWID 2 + +/* +** CAPI3REF: Enable Or Disable A Session Object +** METHOD: sqlite3_session +** +** Enable or disable the recording of changes by a session object. When +** enabled, a session object records changes made to the database. When +** disabled - it does not. A newly created session object is enabled. +** Refer to the documentation for [sqlite3session_changeset()] for further +** details regarding how enabling and disabling a session object affects +** the eventual changesets. +** +** Passing zero to this function disables the session. Passing a value +** greater than zero enables it. Passing a value less than zero is a +** no-op, and may be used to query the current state of the session. +** +** The return value indicates the final state of the session object: 0 if +** the session is disabled, or 1 if it is enabled. +*/ +SQLITE_API int sqlite3session_enable(sqlite3_session *pSession, int bEnable); + +/* +** CAPI3REF: Set Or Clear the Indirect Change Flag +** METHOD: sqlite3_session +** +** Each change recorded by a session object is marked as either direct or +** indirect. A change is marked as indirect if either: +** +**
      +**
    • The session object "indirect" flag is set when the change is +** made, or +**
    • The change is made by an SQL trigger or foreign key action +** instead of directly as a result of a users SQL statement. +**
    +** +** If a single row is affected by more than one operation within a session, +** then the change is considered indirect if all operations meet the criteria +** for an indirect change above, or direct otherwise. +** +** This function is used to set, clear or query the session object indirect +** flag. If the second argument passed to this function is zero, then the +** indirect flag is cleared. If it is greater than zero, the indirect flag +** is set. Passing a value less than zero does not modify the current value +** of the indirect flag, and may be used to query the current state of the +** indirect flag for the specified session object. +** +** The return value indicates the final state of the indirect flag: 0 if +** it is clear, or 1 if it is set. +*/ +SQLITE_API int sqlite3session_indirect(sqlite3_session *pSession, int bIndirect); + +/* +** CAPI3REF: Attach A Table To A Session Object +** METHOD: sqlite3_session +** +** If argument zTab is not NULL, then it is the name of a table to attach +** to the session object passed as the first argument. All subsequent changes +** made to the table while the session object is enabled will be recorded. See +** documentation for [sqlite3session_changeset()] for further details. +** +** Or, if argument zTab is NULL, then changes are recorded for all tables +** in the database. If additional tables are added to the database (by +** executing "CREATE TABLE" statements) after this call is made, changes for +** the new tables are also recorded. +** +** Changes can only be recorded for tables that have a PRIMARY KEY explicitly +** defined as part of their CREATE TABLE statement. It does not matter if the +** PRIMARY KEY is an "INTEGER PRIMARY KEY" (rowid alias) or not. The PRIMARY +** KEY may consist of a single column, or may be a composite key. +** +** It is not an error if the named table does not exist in the database. Nor +** is it an error if the named table does not have a PRIMARY KEY. However, +** no changes will be recorded in either of these scenarios. +** +** Changes are not recorded for individual rows that have NULL values stored +** in one or more of their PRIMARY KEY columns. +** +** SQLITE_OK is returned if the call completes without error. Or, if an error +** occurs, an SQLite error code (e.g. SQLITE_NOMEM) is returned. +** +**

    Special sqlite_stat1 Handling

    +** +** As of SQLite version 3.22.0, the "sqlite_stat1" table is an exception to +** some of the rules above. In SQLite, the schema of sqlite_stat1 is: +** 
    +**        CREATE TABLE sqlite_stat1(tbl,idx,stat)
+**
    +** +** Even though sqlite_stat1 does not have a PRIMARY KEY, changes are +** recorded for it as if the PRIMARY KEY is (tbl,idx). Additionally, changes +** are recorded for rows for which (idx IS NULL) is true. However, for such +** rows a zero-length blob (SQL value X'') is stored in the changeset or +** patchset instead of a NULL value. This allows such changesets to be +** manipulated by legacy implementations of sqlite3changeset_invert(), +** concat() and similar. +** +** The sqlite3changeset_apply() function automatically converts the +** zero-length blob back to a NULL value when updating the sqlite_stat1 +** table. However, if the application calls sqlite3changeset_new(), +** sqlite3changeset_old() or sqlite3changeset_conflict on a changeset +** iterator directly (including on a changeset iterator passed to a +** conflict-handler callback) then the X'' value is returned. The application +** must translate X'' to NULL itself if required. +** +** Legacy (older than 3.22.0) versions of the sessions module cannot capture +** changes made to the sqlite_stat1 table. Legacy versions of the +** sqlite3changeset_apply() function silently ignore any modifications to the +** sqlite_stat1 table that are part of a changeset or patchset. +*/ +SQLITE_API int sqlite3session_attach( + sqlite3_session *pSession, /* Session object */ + const char *zTab /* Table name */ +); + +/* +** CAPI3REF: Set a table filter on a Session Object. +** METHOD: sqlite3_session +** +** The second argument (xFilter) is the "filter callback". For changes to rows +** in tables that are not attached to the Session object, the filter is called +** to determine whether changes to the table's rows should be tracked or not. +** If xFilter returns 0, changes are not tracked. Note that once a table is +** attached, xFilter will not be called again. +*/ +SQLITE_API void sqlite3session_table_filter( + sqlite3_session *pSession, /* Session object */ + int(*xFilter)( + void *pCtx, /* Copy of third arg to _filter_table() */ + const char *zTab /* Table name */ + ), + void *pCtx /* First argument passed to xFilter */ +); + +/* +** CAPI3REF: Generate A Changeset From A Session Object +** METHOD: sqlite3_session +** +** Obtain a changeset containing changes to the tables attached to the +** session object passed as the first argument. If successful, +** set *ppChangeset to point to a buffer containing the changeset +** and *pnChangeset to the size of the changeset in bytes before returning +** SQLITE_OK. If an error occurs, set both *ppChangeset and *pnChangeset to +** zero and return an SQLite error code. +** +** A changeset consists of zero or more INSERT, UPDATE and/or DELETE changes, +** each representing a change to a single row of an attached table. An INSERT +** change contains the values of each field of a new database row. A DELETE +** contains the original values of each field of a deleted database row. An +** UPDATE change contains the original values of each field of an updated +** database row along with the updated values for each updated non-primary-key +** column. It is not possible for an UPDATE change to represent a change that +** modifies the values of primary key columns. If such a change is made, it +** is represented in a changeset as a DELETE followed by an INSERT. +** +** Changes are not recorded for rows that have NULL values stored in one or +** more of their PRIMARY KEY columns. If such a row is inserted or deleted, +** no corresponding change is present in the changesets returned by this +** function. If an existing row with one or more NULL values stored in +** PRIMARY KEY columns is updated so that all PRIMARY KEY columns are non-NULL, +** only an INSERT is appears in the changeset. Similarly, if an existing row +** with non-NULL PRIMARY KEY values is updated so that one or more of its +** PRIMARY KEY columns are set to NULL, the resulting changeset contains a +** DELETE change only. +** +** The contents of a changeset may be traversed using an iterator created +** using the [sqlite3changeset_start()] API. A changeset may be applied to +** a database with a compatible schema using the [sqlite3changeset_apply()] +** API. +** +** Within a changeset generated by this function, all changes related to a +** single table are grouped together. In other words, when iterating through +** a changeset or when applying a changeset to a database, all changes related +** to a single table are processed before moving on to the next table. Tables +** are sorted in the same order in which they were attached (or auto-attached) +** to the sqlite3_session object. The order in which the changes related to +** a single table are stored is undefined. +** +** Following a successful call to this function, it is the responsibility of +** the caller to eventually free the buffer that *ppChangeset points to using +** [sqlite3_free()]. +** +**

    Changeset Generation

    +** +** Once a table has been attached to a session object, the session object +** records the primary key values of all new rows inserted into the table. +** It also records the original primary key and other column values of any +** deleted or updated rows. For each unique primary key value, data is only +** recorded once - the first time a row with said primary key is inserted, +** updated or deleted in the lifetime of the session. +** +** There is one exception to the previous paragraph: when a row is inserted, +** updated or deleted, if one or more of its primary key columns contain a +** NULL value, no record of the change is made. +** +** The session object therefore accumulates two types of records - those +** that consist of primary key values only (created when the user inserts +** a new record) and those that consist of the primary key values and the +** original values of other table columns (created when the users deletes +** or updates a record). +** +** When this function is called, the requested changeset is created using +** both the accumulated records and the current contents of the database +** file. Specifically: +** +**
      +**
    • For each record generated by an insert, the database is queried +** for a row with a matching primary key. If one is found, an INSERT +** change is added to the changeset. If no such row is found, no change +** is added to the changeset. +** +**
    • For each record generated by an update or delete, the database is +** queried for a row with a matching primary key. If such a row is +** found and one or more of the non-primary key fields have been +** modified from their original values, an UPDATE change is added to +** the changeset. Or, if no such row is found in the table, a DELETE +** change is added to the changeset. If there is a row with a matching +** primary key in the database, but all fields contain their original +** values, no change is added to the changeset. +**
    +** +** This means, amongst other things, that if a row is inserted and then later +** deleted while a session object is active, neither the insert nor the delete +** will be present in the changeset. Or if a row is deleted and then later a +** row with the same primary key values inserted while a session object is +** active, the resulting changeset will contain an UPDATE change instead of +** a DELETE and an INSERT. +** +** When a session object is disabled (see the [sqlite3session_enable()] API), +** it does not accumulate records when rows are inserted, updated or deleted. +** This may appear to have some counter-intuitive effects if a single row +** is written to more than once during a session. For example, if a row +** is inserted while a session object is enabled, then later deleted while +** the same session object is disabled, no INSERT record will appear in the +** changeset, even though the delete took place while the session was disabled. +** Or, if one field of a row is updated while a session is disabled, and +** another field of the same row is updated while the session is enabled, the +** resulting changeset will contain an UPDATE change that updates both fields. +*/ +SQLITE_API int sqlite3session_changeset( + sqlite3_session *pSession, /* Session object */ + int *pnChangeset, /* OUT: Size of buffer at *ppChangeset */ + void **ppChangeset /* OUT: Buffer containing changeset */ +); + +/* +** CAPI3REF: Return An Upper-limit For The Size Of The Changeset +** METHOD: sqlite3_session +** +** By default, this function always returns 0. For it to return +** a useful result, the sqlite3_session object must have been configured +** to enable this API using sqlite3session_object_config() with the +** SQLITE_SESSION_OBJCONFIG_SIZE verb. +** +** When enabled, this function returns an upper limit, in bytes, for the size +** of the changeset that might be produced if sqlite3session_changeset() were +** called. The final changeset size might be equal to or smaller than the +** size in bytes returned by this function. +*/ +SQLITE_API sqlite3_int64 sqlite3session_changeset_size(sqlite3_session *pSession); + +/* +** CAPI3REF: Load The Difference Between Tables Into A Session +** METHOD: sqlite3_session +** +** If it is not already attached to the session object passed as the first +** argument, this function attaches table zTbl in the same manner as the +** [sqlite3session_attach()] function. If zTbl does not exist, or if it +** does not have a primary key, this function is a no-op (but does not return +** an error). +** +** Argument zFromDb must be the name of a database ("main", "temp" etc.) +** attached to the same database handle as the session object that contains +** a table compatible with the table attached to the session by this function. +** A table is considered compatible if it: +** +**
      +**
    • Has the same name, +**
    • Has the same set of columns declared in the same order, and +**
    • Has the same PRIMARY KEY definition. +**
    +** +** If the tables are not compatible, SQLITE_SCHEMA is returned. If the tables +** are compatible but do not have any PRIMARY KEY columns, it is not an error +** but no changes are added to the session object. As with other session +** APIs, tables without PRIMARY KEYs are simply ignored. +** +** This function adds a set of changes to the session object that could be +** used to update the table in database zFrom (call this the "from-table") +** so that its content is the same as the table attached to the session +** object (call this the "to-table"). Specifically: +** +**
      +**
    • For each row (primary key) that exists in the to-table but not in +** the from-table, an INSERT record is added to the session object. +** +**
    • For each row (primary key) that exists in the to-table but not in +** the from-table, a DELETE record is added to the session object. +** +**
    • For each row (primary key) that exists in both tables, but features +** different non-PK values in each, an UPDATE record is added to the +** session. +**
    +** +** To clarify, if this function is called and then a changeset constructed +** using [sqlite3session_changeset()], then after applying that changeset to +** database zFrom the contents of the two compatible tables would be +** identical. +** +** It an error if database zFrom does not exist or does not contain the +** required compatible table. +** +** If the operation is successful, SQLITE_OK is returned. Otherwise, an SQLite +** error code. In this case, if argument pzErrMsg is not NULL, *pzErrMsg +** may be set to point to a buffer containing an English language error +** message. It is the responsibility of the caller to free this buffer using +** sqlite3_free(). +*/ +SQLITE_API int sqlite3session_diff( + sqlite3_session *pSession, + const char *zFromDb, + const char *zTbl, + char **pzErrMsg +); + + +/* +** CAPI3REF: Generate A Patchset From A Session Object +** METHOD: sqlite3_session +** +** The differences between a patchset and a changeset are that: +** +**
      +**
    • DELETE records consist of the primary key fields only. The +** original values of other fields are omitted. +**
    • The original values of any modified fields are omitted from +** UPDATE records. +**
    +** +** A patchset blob may be used with up to date versions of all +** sqlite3changeset_xxx API functions except for sqlite3changeset_invert(), +** which returns SQLITE_CORRUPT if it is passed a patchset. Similarly, +** attempting to use a patchset blob with old versions of the +** sqlite3changeset_xxx APIs also provokes an SQLITE_CORRUPT error. +** +** Because the non-primary key "old.*" fields are omitted, no +** SQLITE_CHANGESET_DATA conflicts can be detected or reported if a patchset +** is passed to the sqlite3changeset_apply() API. Other conflict types work +** in the same way as for changesets. +** +** Changes within a patchset are ordered in the same way as for changesets +** generated by the sqlite3session_changeset() function (i.e. all changes for +** a single table are grouped together, tables appear in the order in which +** they were attached to the session object). +*/ +SQLITE_API int sqlite3session_patchset( + sqlite3_session *pSession, /* Session object */ + int *pnPatchset, /* OUT: Size of buffer at *ppPatchset */ + void **ppPatchset /* OUT: Buffer containing patchset */ +); + +/* +** CAPI3REF: Test if a changeset has recorded any changes. +** +** Return non-zero if no changes to attached tables have been recorded by +** the session object passed as the first argument. Otherwise, if one or +** more changes have been recorded, return zero. +** +** Even if this function returns zero, it is possible that calling +** [sqlite3session_changeset()] on the session handle may still return a +** changeset that contains no changes. This can happen when a row in +** an attached table is modified and then later on the original values +** are restored. However, if this function returns non-zero, then it is +** guaranteed that a call to sqlite3session_changeset() will return a +** changeset containing zero changes. +*/ +SQLITE_API int sqlite3session_isempty(sqlite3_session *pSession); + +/* +** CAPI3REF: Query for the amount of heap memory used by a session object. +** +** This API returns the total amount of heap memory in bytes currently +** used by the session object passed as the only argument. +*/ +SQLITE_API sqlite3_int64 sqlite3session_memory_used(sqlite3_session *pSession); + +/* +** CAPI3REF: Create An Iterator To Traverse A Changeset +** CONSTRUCTOR: sqlite3_changeset_iter +** +** Create an iterator used to iterate through the contents of a changeset. +** If successful, *pp is set to point to the iterator handle and SQLITE_OK +** is returned. Otherwise, if an error occurs, *pp is set to zero and an +** SQLite error code is returned. +** +** The following functions can be used to advance and query a changeset +** iterator created by this function: +** +**
      +**
    • [sqlite3changeset_next()] +**
    • [sqlite3changeset_op()] +**
    • [sqlite3changeset_new()] +**
    • [sqlite3changeset_old()] +**
    +** +** It is the responsibility of the caller to eventually destroy the iterator +** by passing it to [sqlite3changeset_finalize()]. The buffer containing the +** changeset (pChangeset) must remain valid until after the iterator is +** destroyed. +** +** Assuming the changeset blob was created by one of the +** [sqlite3session_changeset()], [sqlite3changeset_concat()] or +** [sqlite3changeset_invert()] functions, all changes within the changeset +** that apply to a single table are grouped together. This means that when +** an application iterates through a changeset using an iterator created by +** this function, all changes that relate to a single table are visited +** consecutively. There is no chance that the iterator will visit a change +** the applies to table X, then one for table Y, and then later on visit +** another change for table X. +** +** The behavior of sqlite3changeset_start_v2() and its streaming equivalent +** may be modified by passing a combination of +** [SQLITE_CHANGESETSTART_INVERT | supported flags] as the 4th parameter. +** +** Note that the sqlite3changeset_start_v2() API is still experimental +** and therefore subject to change. +*/ +SQLITE_API int sqlite3changeset_start( + sqlite3_changeset_iter **pp, /* OUT: New changeset iterator handle */ + int nChangeset, /* Size of changeset blob in bytes */ + void *pChangeset /* Pointer to blob containing changeset */ +); +SQLITE_API int sqlite3changeset_start_v2( + sqlite3_changeset_iter **pp, /* OUT: New changeset iterator handle */ + int nChangeset, /* Size of changeset blob in bytes */ + void *pChangeset, /* Pointer to blob containing changeset */ + int flags /* SESSION_CHANGESETSTART_* flags */ +); + +/* +** CAPI3REF: Flags for sqlite3changeset_start_v2 +** +** The following flags may passed via the 4th parameter to +** [sqlite3changeset_start_v2] and [sqlite3changeset_start_v2_strm]: +** +**
    SQLITE_CHANGESETAPPLY_INVERT
    +** Invert the changeset while iterating through it. This is equivalent to +** inverting a changeset using sqlite3changeset_invert() before applying it. +** It is an error to specify this flag with a patchset. +*/ +#define SQLITE_CHANGESETSTART_INVERT 0x0002 + + +/* +** CAPI3REF: Advance A Changeset Iterator +** METHOD: sqlite3_changeset_iter +** +** This function may only be used with iterators created by the function +** [sqlite3changeset_start()]. If it is called on an iterator passed to +** a conflict-handler callback by [sqlite3changeset_apply()], SQLITE_MISUSE +** is returned and the call has no effect. +** +** Immediately after an iterator is created by sqlite3changeset_start(), it +** does not point to any change in the changeset. Assuming the changeset +** is not empty, the first call to this function advances the iterator to +** point to the first change in the changeset. Each subsequent call advances +** the iterator to point to the next change in the changeset (if any). If +** no error occurs and the iterator points to a valid change after a call +** to sqlite3changeset_next() has advanced it, SQLITE_ROW is returned. +** Otherwise, if all changes in the changeset have already been visited, +** SQLITE_DONE is returned. +** +** If an error occurs, an SQLite error code is returned. Possible error +** codes include SQLITE_CORRUPT (if the changeset buffer is corrupt) or +** SQLITE_NOMEM. +*/ +SQLITE_API int sqlite3changeset_next(sqlite3_changeset_iter *pIter); + +/* +** CAPI3REF: Obtain The Current Operation From A Changeset Iterator +** METHOD: sqlite3_changeset_iter +** +** The pIter argument passed to this function may either be an iterator +** passed to a conflict-handler by [sqlite3changeset_apply()], or an iterator +** created by [sqlite3changeset_start()]. In the latter case, the most recent +** call to [sqlite3changeset_next()] must have returned [SQLITE_ROW]. If this +** is not the case, this function returns [SQLITE_MISUSE]. +** +** Arguments pOp, pnCol and pzTab may not be NULL. Upon return, three +** outputs are set through these pointers: +** +** *pOp is set to one of [SQLITE_INSERT], [SQLITE_DELETE] or [SQLITE_UPDATE], +** depending on the type of change that the iterator currently points to; +** +** *pnCol is set to the number of columns in the table affected by the change; and +** +** *pzTab is set to point to a nul-terminated utf-8 encoded string containing +** the name of the table affected by the current change. The buffer remains +** valid until either sqlite3changeset_next() is called on the iterator +** or until the conflict-handler function returns. +** +** If pbIndirect is not NULL, then *pbIndirect is set to true (1) if the change +** is an indirect change, or false (0) otherwise. See the documentation for +** [sqlite3session_indirect()] for a description of direct and indirect +** changes. +** +** If no error occurs, SQLITE_OK is returned. If an error does occur, an +** SQLite error code is returned. The values of the output variables may not +** be trusted in this case. +*/ +SQLITE_API int sqlite3changeset_op( + sqlite3_changeset_iter *pIter, /* Iterator object */ + const char **pzTab, /* OUT: Pointer to table name */ + int *pnCol, /* OUT: Number of columns in table */ + int *pOp, /* OUT: SQLITE_INSERT, DELETE or UPDATE */ + int *pbIndirect /* OUT: True for an 'indirect' change */ +); + +/* +** CAPI3REF: Obtain The Primary Key Definition Of A Table +** METHOD: sqlite3_changeset_iter +** +** For each modified table, a changeset includes the following: +** +**
      +**
    • The number of columns in the table, and +**
    • Which of those columns make up the tables PRIMARY KEY. +**
    +** +** This function is used to find which columns comprise the PRIMARY KEY of +** the table modified by the change that iterator pIter currently points to. +** If successful, *pabPK is set to point to an array of nCol entries, where +** nCol is the number of columns in the table. Elements of *pabPK are set to +** 0x01 if the corresponding column is part of the tables primary key, or +** 0x00 if it is not. +** +** If argument pnCol is not NULL, then *pnCol is set to the number of columns +** in the table. +** +** If this function is called when the iterator does not point to a valid +** entry, SQLITE_MISUSE is returned and the output variables zeroed. Otherwise, +** SQLITE_OK is returned and the output variables populated as described +** above. +*/ +SQLITE_API int sqlite3changeset_pk( + sqlite3_changeset_iter *pIter, /* Iterator object */ + unsigned char **pabPK, /* OUT: Array of boolean - true for PK cols */ + int *pnCol /* OUT: Number of entries in output array */ +); + +/* +** CAPI3REF: Obtain old.* Values From A Changeset Iterator +** METHOD: sqlite3_changeset_iter +** +** The pIter argument passed to this function may either be an iterator +** passed to a conflict-handler by [sqlite3changeset_apply()], or an iterator +** created by [sqlite3changeset_start()]. In the latter case, the most recent +** call to [sqlite3changeset_next()] must have returned SQLITE_ROW. +** Furthermore, it may only be called if the type of change that the iterator +** currently points to is either [SQLITE_DELETE] or [SQLITE_UPDATE]. Otherwise, +** this function returns [SQLITE_MISUSE] and sets *ppValue to NULL. +** +** Argument iVal must be greater than or equal to 0, and less than the number +** of columns in the table affected by the current change. Otherwise, +** [SQLITE_RANGE] is returned and *ppValue is set to NULL. +** +** If successful, this function sets *ppValue to point to a protected +** sqlite3_value object containing the iVal'th value from the vector of +** original row values stored as part of the UPDATE or DELETE change and +** returns SQLITE_OK. The name of the function comes from the fact that this +** is similar to the "old.*" columns available to update or delete triggers. +** +** If some other error occurs (e.g. an OOM condition), an SQLite error code +** is returned and *ppValue is set to NULL. +*/ +SQLITE_API int sqlite3changeset_old( + sqlite3_changeset_iter *pIter, /* Changeset iterator */ + int iVal, /* Column number */ + sqlite3_value **ppValue /* OUT: Old value (or NULL pointer) */ +); + +/* +** CAPI3REF: Obtain new.* Values From A Changeset Iterator +** METHOD: sqlite3_changeset_iter +** +** The pIter argument passed to this function may either be an iterator +** passed to a conflict-handler by [sqlite3changeset_apply()], or an iterator +** created by [sqlite3changeset_start()]. In the latter case, the most recent +** call to [sqlite3changeset_next()] must have returned SQLITE_ROW. +** Furthermore, it may only be called if the type of change that the iterator +** currently points to is either [SQLITE_UPDATE] or [SQLITE_INSERT]. Otherwise, +** this function returns [SQLITE_MISUSE] and sets *ppValue to NULL. +** +** Argument iVal must be greater than or equal to 0, and less than the number +** of columns in the table affected by the current change. Otherwise, +** [SQLITE_RANGE] is returned and *ppValue is set to NULL. +** +** If successful, this function sets *ppValue to point to a protected +** sqlite3_value object containing the iVal'th value from the vector of +** new row values stored as part of the UPDATE or INSERT change and +** returns SQLITE_OK. If the change is an UPDATE and does not include +** a new value for the requested column, *ppValue is set to NULL and +** SQLITE_OK returned. The name of the function comes from the fact that +** this is similar to the "new.*" columns available to update or delete +** triggers. +** +** If some other error occurs (e.g. an OOM condition), an SQLite error code +** is returned and *ppValue is set to NULL. +*/ +SQLITE_API int sqlite3changeset_new( + sqlite3_changeset_iter *pIter, /* Changeset iterator */ + int iVal, /* Column number */ + sqlite3_value **ppValue /* OUT: New value (or NULL pointer) */ +); + +/* +** CAPI3REF: Obtain Conflicting Row Values From A Changeset Iterator +** METHOD: sqlite3_changeset_iter +** +** This function should only be used with iterator objects passed to a +** conflict-handler callback by [sqlite3changeset_apply()] with either +** [SQLITE_CHANGESET_DATA] or [SQLITE_CHANGESET_CONFLICT]. If this function +** is called on any other iterator, [SQLITE_MISUSE] is returned and *ppValue +** is set to NULL. +** +** Argument iVal must be greater than or equal to 0, and less than the number +** of columns in the table affected by the current change. Otherwise, +** [SQLITE_RANGE] is returned and *ppValue is set to NULL. +** +** If successful, this function sets *ppValue to point to a protected +** sqlite3_value object containing the iVal'th value from the +** "conflicting row" associated with the current conflict-handler callback +** and returns SQLITE_OK. +** +** If some other error occurs (e.g. an OOM condition), an SQLite error code +** is returned and *ppValue is set to NULL. +*/ +SQLITE_API int sqlite3changeset_conflict( + sqlite3_changeset_iter *pIter, /* Changeset iterator */ + int iVal, /* Column number */ + sqlite3_value **ppValue /* OUT: Value from conflicting row */ +); + +/* +** CAPI3REF: Determine The Number Of Foreign Key Constraint Violations +** METHOD: sqlite3_changeset_iter +** +** This function may only be called with an iterator passed to an +** SQLITE_CHANGESET_FOREIGN_KEY conflict handler callback. In this case +** it sets the output variable to the total number of known foreign key +** violations in the destination database and returns SQLITE_OK. +** +** In all other cases this function returns SQLITE_MISUSE. +*/ +SQLITE_API int sqlite3changeset_fk_conflicts( + sqlite3_changeset_iter *pIter, /* Changeset iterator */ + int *pnOut /* OUT: Number of FK violations */ +); + + +/* +** CAPI3REF: Finalize A Changeset Iterator +** METHOD: sqlite3_changeset_iter +** +** This function is used to finalize an iterator allocated with +** [sqlite3changeset_start()]. +** +** This function should only be called on iterators created using the +** [sqlite3changeset_start()] function. If an application calls this +** function with an iterator passed to a conflict-handler by +** [sqlite3changeset_apply()], [SQLITE_MISUSE] is immediately returned and the +** call has no effect. +** +** If an error was encountered within a call to an sqlite3changeset_xxx() +** function (for example an [SQLITE_CORRUPT] in [sqlite3changeset_next()] or an +** [SQLITE_NOMEM] in [sqlite3changeset_new()]) then an error code corresponding +** to that error is returned by this function. Otherwise, SQLITE_OK is +** returned. This is to allow the following pattern (pseudo-code): +** +** 
    +**   sqlite3changeset_start();
+**   while( SQLITE_ROW==sqlite3changeset_next() ){
+**     // Do something with change.
+**   }
+**   rc = sqlite3changeset_finalize();
+**   if( rc!=SQLITE_OK ){
+**     // An error has occurred
+**   }
+**
    +*/ +SQLITE_API int sqlite3changeset_finalize(sqlite3_changeset_iter *pIter); + +/* +** CAPI3REF: Invert A Changeset +** +** This function is used to "invert" a changeset object. Applying an inverted +** changeset to a database reverses the effects of applying the uninverted +** changeset. Specifically: +** +**
      +**
    • Each DELETE change is changed to an INSERT, and +**
    • Each INSERT change is changed to a DELETE, and +**
    • For each UPDATE change, the old.* and new.* values are exchanged. +**
    +** +** This function does not change the order in which changes appear within +** the changeset. It merely reverses the sense of each individual change. +** +** If successful, a pointer to a buffer containing the inverted changeset +** is stored in *ppOut, the size of the same buffer is stored in *pnOut, and +** SQLITE_OK is returned. If an error occurs, both *pnOut and *ppOut are +** zeroed and an SQLite error code returned. +** +** It is the responsibility of the caller to eventually call sqlite3_free() +** on the *ppOut pointer to free the buffer allocation following a successful +** call to this function. +** +** WARNING/TODO: This function currently assumes that the input is a valid +** changeset. If it is not, the results are undefined. +*/ +SQLITE_API int sqlite3changeset_invert( + int nIn, const void *pIn, /* Input changeset */ + int *pnOut, void **ppOut /* OUT: Inverse of input */ +); + +/* +** CAPI3REF: Concatenate Two Changeset Objects +** +** This function is used to concatenate two changesets, A and B, into a +** single changeset. The result is a changeset equivalent to applying +** changeset A followed by changeset B. +** +** This function combines the two input changesets using an +** sqlite3_changegroup object. Calling it produces similar results as the +** following code fragment: +** +** 
    +**   sqlite3_changegroup *pGrp;
+**   rc = sqlite3_changegroup_new(&pGrp);
+**   if( rc==SQLITE_OK ) rc = sqlite3changegroup_add(pGrp, nA, pA);
+**   if( rc==SQLITE_OK ) rc = sqlite3changegroup_add(pGrp, nB, pB);
+**   if( rc==SQLITE_OK ){
+**     rc = sqlite3changegroup_output(pGrp, pnOut, ppOut);
+**   }else{
+**     *ppOut = 0;
+**     *pnOut = 0;
+**   }
+**
    +** +** Refer to the sqlite3_changegroup documentation below for details. +*/ +SQLITE_API int sqlite3changeset_concat( + int nA, /* Number of bytes in buffer pA */ + void *pA, /* Pointer to buffer containing changeset A */ + int nB, /* Number of bytes in buffer pB */ + void *pB, /* Pointer to buffer containing changeset B */ + int *pnOut, /* OUT: Number of bytes in output changeset */ + void **ppOut /* OUT: Buffer containing output changeset */ +); + + +/* +** CAPI3REF: Changegroup Handle +** +** A changegroup is an object used to combine two or more +** [changesets] or [patchsets] +*/ +typedef struct sqlite3_changegroup sqlite3_changegroup; + +/* +** CAPI3REF: Create A New Changegroup Object +** CONSTRUCTOR: sqlite3_changegroup +** +** An sqlite3_changegroup object is used to combine two or more changesets +** (or patchsets) into a single changeset (or patchset). A single changegroup +** object may combine changesets or patchsets, but not both. The output is +** always in the same format as the input. +** +** If successful, this function returns SQLITE_OK and populates (*pp) with +** a pointer to a new sqlite3_changegroup object before returning. The caller +** should eventually free the returned object using a call to +** sqlite3changegroup_delete(). If an error occurs, an SQLite error code +** (i.e. SQLITE_NOMEM) is returned and *pp is set to NULL. +** +** The usual usage pattern for an sqlite3_changegroup object is as follows: +** +**
      +**
    • It is created using a call to sqlite3changegroup_new(). +** +**
    • Zero or more changesets (or patchsets) are added to the object +** by calling sqlite3changegroup_add(). +** +**
    • The result of combining all input changesets together is obtained +** by the application via a call to sqlite3changegroup_output(). +** +**
    • The object is deleted using a call to sqlite3changegroup_delete(). +**
    +** +** Any number of calls to add() and output() may be made between the calls to +** new() and delete(), and in any order. +** +** As well as the regular sqlite3changegroup_add() and +** sqlite3changegroup_output() functions, also available are the streaming +** versions sqlite3changegroup_add_strm() and sqlite3changegroup_output_strm(). +*/ +SQLITE_API int sqlite3changegroup_new(sqlite3_changegroup **pp); + +/* +** CAPI3REF: Add A Changeset To A Changegroup +** METHOD: sqlite3_changegroup +** +** Add all changes within the changeset (or patchset) in buffer pData (size +** nData bytes) to the changegroup. +** +** If the buffer contains a patchset, then all prior calls to this function +** on the same changegroup object must also have specified patchsets. Or, if +** the buffer contains a changeset, so must have the earlier calls to this +** function. Otherwise, SQLITE_ERROR is returned and no changes are added +** to the changegroup. +** +** Rows within the changeset and changegroup are identified by the values in +** their PRIMARY KEY columns. A change in the changeset is considered to +** apply to the same row as a change already present in the changegroup if +** the two rows have the same primary key. +** +** Changes to rows that do not already appear in the changegroup are +** simply copied into it. Or, if both the new changeset and the changegroup +** contain changes that apply to a single row, the final contents of the +** changegroup depends on the type of each change, as follows: +** +** +** +** +**
    Existing Change New Change Output Change +**
    INSERT INSERT +** The new change is ignored. This case does not occur if the new +** changeset was recorded immediately after the changesets already +** added to the changegroup. +**
    INSERT UPDATE +** The INSERT change remains in the changegroup. The values in the +** INSERT change are modified as if the row was inserted by the +** existing change and then updated according to the new change. +**
    INSERT DELETE +** The existing INSERT is removed from the changegroup. The DELETE is +** not added. +**
    UPDATE INSERT +** The new change is ignored. This case does not occur if the new +** changeset was recorded immediately after the changesets already +** added to the changegroup. +**
    UPDATE UPDATE +** The existing UPDATE remains within the changegroup. It is amended +** so that the accompanying values are as if the row was updated once +** by the existing change and then again by the new change. +**
    UPDATE DELETE +** The existing UPDATE is replaced by the new DELETE within the +** changegroup. +**
    DELETE INSERT +** If one or more of the column values in the row inserted by the +** new change differ from those in the row deleted by the existing +** change, the existing DELETE is replaced by an UPDATE within the +** changegroup. Otherwise, if the inserted row is exactly the same +** as the deleted row, the existing DELETE is simply discarded. +**
    DELETE UPDATE +** The new change is ignored. This case does not occur if the new +** changeset was recorded immediately after the changesets already +** added to the changegroup. +**
    DELETE DELETE +** The new change is ignored. This case does not occur if the new +** changeset was recorded immediately after the changesets already +** added to the changegroup. +**
    +** +** If the new changeset contains changes to a table that is already present +** in the changegroup, then the number of columns and the position of the +** primary key columns for the table must be consistent. If this is not the +** case, this function fails with SQLITE_SCHEMA. If the input changeset +** appears to be corrupt and the corruption is detected, SQLITE_CORRUPT is +** returned. Or, if an out-of-memory condition occurs during processing, this +** function returns SQLITE_NOMEM. In all cases, if an error occurs the state +** of the final contents of the changegroup is undefined. +** +** If no error occurs, SQLITE_OK is returned. +*/ +SQLITE_API int sqlite3changegroup_add(sqlite3_changegroup*, int nData, void *pData); + +/* +** CAPI3REF: Obtain A Composite Changeset From A Changegroup +** METHOD: sqlite3_changegroup +** +** Obtain a buffer containing a changeset (or patchset) representing the +** current contents of the changegroup. If the inputs to the changegroup +** were themselves changesets, the output is a changeset. Or, if the +** inputs were patchsets, the output is also a patchset. +** +** As with the output of the sqlite3session_changeset() and +** sqlite3session_patchset() functions, all changes related to a single +** table are grouped together in the output of this function. Tables appear +** in the same order as for the very first changeset added to the changegroup. +** If the second or subsequent changesets added to the changegroup contain +** changes for tables that do not appear in the first changeset, they are +** appended onto the end of the output changeset, again in the order in +** which they are first encountered. +** +** If an error occurs, an SQLite error code is returned and the output +** variables (*pnData) and (*ppData) are set to 0. Otherwise, SQLITE_OK +** is returned and the output variables are set to the size of and a +** pointer to the output buffer, respectively. In this case it is the +** responsibility of the caller to eventually free the buffer using a +** call to sqlite3_free(). +*/ +SQLITE_API int sqlite3changegroup_output( + sqlite3_changegroup*, + int *pnData, /* OUT: Size of output buffer in bytes */ + void **ppData /* OUT: Pointer to output buffer */ +); + +/* +** CAPI3REF: Delete A Changegroup Object +** DESTRUCTOR: sqlite3_changegroup +*/ +SQLITE_API void sqlite3changegroup_delete(sqlite3_changegroup*); + +/* +** CAPI3REF: Apply A Changeset To A Database +** +** Apply a changeset or patchset to a database. These functions attempt to +** update the "main" database attached to handle db with the changes found in +** the changeset passed via the second and third arguments. +** +** The fourth argument (xFilter) passed to these functions is the "filter +** callback". If it is not NULL, then for each table affected by at least one +** change in the changeset, the filter callback is invoked with +** the table name as the second argument, and a copy of the context pointer +** passed as the sixth argument as the first. If the "filter callback" +** returns zero, then no attempt is made to apply any changes to the table. +** Otherwise, if the return value is non-zero or the xFilter argument to +** is NULL, all changes related to the table are attempted. +** +** For each table that is not excluded by the filter callback, this function +** tests that the target database contains a compatible table. A table is +** considered compatible if all of the following are true: +** +**
      +**
    • The table has the same name as the name recorded in the +** changeset, and +**
    • The table has at least as many columns as recorded in the +** changeset, and +**
    • The table has primary key columns in the same position as +** recorded in the changeset. +**
    +** +** If there is no compatible table, it is not an error, but none of the +** changes associated with the table are applied. A warning message is issued +** via the sqlite3_log() mechanism with the error code SQLITE_SCHEMA. At most +** one such warning is issued for each table in the changeset. +** +** For each change for which there is a compatible table, an attempt is made +** to modify the table contents according to the UPDATE, INSERT or DELETE +** change. If a change cannot be applied cleanly, the conflict handler +** function passed as the fifth argument to sqlite3changeset_apply() may be +** invoked. A description of exactly when the conflict handler is invoked for +** each type of change is below. +** +** Unlike the xFilter argument, xConflict may not be passed NULL. The results +** of passing anything other than a valid function pointer as the xConflict +** argument are undefined. +** +** Each time the conflict handler function is invoked, it must return one +** of [SQLITE_CHANGESET_OMIT], [SQLITE_CHANGESET_ABORT] or +** [SQLITE_CHANGESET_REPLACE]. SQLITE_CHANGESET_REPLACE may only be returned +** if the second argument passed to the conflict handler is either +** SQLITE_CHANGESET_DATA or SQLITE_CHANGESET_CONFLICT. If the conflict-handler +** returns an illegal value, any changes already made are rolled back and +** the call to sqlite3changeset_apply() returns SQLITE_MISUSE. Different +** actions are taken by sqlite3changeset_apply() depending on the value +** returned by each invocation of the conflict-handler function. Refer to +** the documentation for the three +** [SQLITE_CHANGESET_OMIT|available return values] for details. +** +**
    +**
    DELETE Changes
    +** For each DELETE change, the function checks if the target database +** contains a row with the same primary key value (or values) as the +** original row values stored in the changeset. If it does, and the values +** stored in all non-primary key columns also match the values stored in +** the changeset the row is deleted from the target database. +** +** If a row with matching primary key values is found, but one or more of +** the non-primary key fields contains a value different from the original +** row value stored in the changeset, the conflict-handler function is +** invoked with [SQLITE_CHANGESET_DATA] as the second argument. If the +** database table has more columns than are recorded in the changeset, +** only the values of those non-primary key fields are compared against +** the current database contents - any trailing database table columns +** are ignored. +** +** If no row with matching primary key values is found in the database, +** the conflict-handler function is invoked with [SQLITE_CHANGESET_NOTFOUND] +** passed as the second argument. +** +** If the DELETE operation is attempted, but SQLite returns SQLITE_CONSTRAINT +** (which can only happen if a foreign key constraint is violated), the +** conflict-handler function is invoked with [SQLITE_CHANGESET_CONSTRAINT] +** passed as the second argument. This includes the case where the DELETE +** operation is attempted because an earlier call to the conflict handler +** function returned [SQLITE_CHANGESET_REPLACE]. +** +**
    INSERT Changes
    +** For each INSERT change, an attempt is made to insert the new row into +** the database. If the changeset row contains fewer fields than the +** database table, the trailing fields are populated with their default +** values. +** +** If the attempt to insert the row fails because the database already +** contains a row with the same primary key values, the conflict handler +** function is invoked with the second argument set to +** [SQLITE_CHANGESET_CONFLICT]. +** +** If the attempt to insert the row fails because of some other constraint +** violation (e.g. NOT NULL or UNIQUE), the conflict handler function is +** invoked with the second argument set to [SQLITE_CHANGESET_CONSTRAINT]. +** This includes the case where the INSERT operation is re-attempted because +** an earlier call to the conflict handler function returned +** [SQLITE_CHANGESET_REPLACE]. +** +**
    UPDATE Changes
    +** For each UPDATE change, the function checks if the target database +** contains a row with the same primary key value (or values) as the +** original row values stored in the changeset. If it does, and the values +** stored in all modified non-primary key columns also match the values +** stored in the changeset the row is updated within the target database. +** +** If a row with matching primary key values is found, but one or more of +** the modified non-primary key fields contains a value different from an +** original row value stored in the changeset, the conflict-handler function +** is invoked with [SQLITE_CHANGESET_DATA] as the second argument. Since +** UPDATE changes only contain values for non-primary key fields that are +** to be modified, only those fields need to match the original values to +** avoid the SQLITE_CHANGESET_DATA conflict-handler callback. +** +** If no row with matching primary key values is found in the database, +** the conflict-handler function is invoked with [SQLITE_CHANGESET_NOTFOUND] +** passed as the second argument. +** +** If the UPDATE operation is attempted, but SQLite returns +** SQLITE_CONSTRAINT, the conflict-handler function is invoked with +** [SQLITE_CHANGESET_CONSTRAINT] passed as the second argument. +** This includes the case where the UPDATE operation is attempted after +** an earlier call to the conflict handler function returned +** [SQLITE_CHANGESET_REPLACE]. +**
    +** +** It is safe to execute SQL statements, including those that write to the +** table that the callback related to, from within the xConflict callback. +** This can be used to further customize the application's conflict +** resolution strategy. +** +** All changes made by these functions are enclosed in a savepoint transaction. +** If any other error (aside from a constraint failure when attempting to +** write to the target database) occurs, then the savepoint transaction is +** rolled back, restoring the target database to its original state, and an +** SQLite error code returned. +** +** If the output parameters (ppRebase) and (pnRebase) are non-NULL and +** the input is a changeset (not a patchset), then sqlite3changeset_apply_v2() +** may set (*ppRebase) to point to a "rebase" that may be used with the +** sqlite3_rebaser APIs buffer before returning. In this case (*pnRebase) +** is set to the size of the buffer in bytes. It is the responsibility of the +** caller to eventually free any such buffer using sqlite3_free(). The buffer +** is only allocated and populated if one or more conflicts were encountered +** while applying the patchset. See comments surrounding the sqlite3_rebaser +** APIs for further details. +** +** The behavior of sqlite3changeset_apply_v2() and its streaming equivalent +** may be modified by passing a combination of +** [SQLITE_CHANGESETAPPLY_NOSAVEPOINT | supported flags] as the 9th parameter. +** +** Note that the sqlite3changeset_apply_v2() API is still experimental +** and therefore subject to change. +*/ +SQLITE_API int sqlite3changeset_apply( + sqlite3 *db, /* Apply change to "main" db of this handle */ + int nChangeset, /* Size of changeset in bytes */ + void *pChangeset, /* Changeset blob */ + int(*xFilter)( + void *pCtx, /* Copy of sixth arg to _apply() */ + const char *zTab /* Table name */ + ), + int(*xConflict)( + void *pCtx, /* Copy of sixth arg to _apply() */ + int eConflict, /* DATA, MISSING, CONFLICT, CONSTRAINT */ + sqlite3_changeset_iter *p /* Handle describing change and conflict */ + ), + void *pCtx /* First argument passed to xConflict */ +); +SQLITE_API int sqlite3changeset_apply_v2( + sqlite3 *db, /* Apply change to "main" db of this handle */ + int nChangeset, /* Size of changeset in bytes */ + void *pChangeset, /* Changeset blob */ + int(*xFilter)( + void *pCtx, /* Copy of sixth arg to _apply() */ + const char *zTab /* Table name */ + ), + int(*xConflict)( + void *pCtx, /* Copy of sixth arg to _apply() */ + int eConflict, /* DATA, MISSING, CONFLICT, CONSTRAINT */ + sqlite3_changeset_iter *p /* Handle describing change and conflict */ + ), + void *pCtx, /* First argument passed to xConflict */ + void **ppRebase, int *pnRebase, /* OUT: Rebase data */ + int flags /* SESSION_CHANGESETAPPLY_* flags */ +); + +/* +** CAPI3REF: Flags for sqlite3changeset_apply_v2 +** +** The following flags may passed via the 9th parameter to +** [sqlite3changeset_apply_v2] and [sqlite3changeset_apply_v2_strm]: +** +**
    +**
    SQLITE_CHANGESETAPPLY_NOSAVEPOINT
    +** Usually, the sessions module encloses all operations performed by +** a single call to apply_v2() or apply_v2_strm() in a [SAVEPOINT]. The +** SAVEPOINT is committed if the changeset or patchset is successfully +** applied, or rolled back if an error occurs. Specifying this flag +** causes the sessions module to omit this savepoint. In this case, if the +** caller has an open transaction or savepoint when apply_v2() is called, +** it may revert the partially applied changeset by rolling it back. +** +**
    SQLITE_CHANGESETAPPLY_INVERT
    +** Invert the changeset before applying it. This is equivalent to inverting +** a changeset using sqlite3changeset_invert() before applying it. It is +** an error to specify this flag with a patchset. +** +**
    SQLITE_CHANGESETAPPLY_IGNORENOOP
    +** Do not invoke the conflict handler callback for any changes that +** would not actually modify the database even if they were applied. +** Specifically, this means that the conflict handler is not invoked +** for: +**
      +**
    • a delete change if the row being deleted cannot be found, +**
    • an update change if the modified fields are already set to +** their new values in the conflicting row, or +**
    • an insert change if all fields of the conflicting row match +** the row being inserted. +**
    +*/ +#define SQLITE_CHANGESETAPPLY_NOSAVEPOINT 0x0001 +#define SQLITE_CHANGESETAPPLY_INVERT 0x0002 +#define SQLITE_CHANGESETAPPLY_IGNORENOOP 0x0004 + +/* +** CAPI3REF: Constants Passed To The Conflict Handler +** +** Values that may be passed as the second argument to a conflict-handler. +** +**
    +**
    SQLITE_CHANGESET_DATA
    +** The conflict handler is invoked with CHANGESET_DATA as the second argument +** when processing a DELETE or UPDATE change if a row with the required +** PRIMARY KEY fields is present in the database, but one or more other +** (non primary-key) fields modified by the update do not contain the +** expected "before" values. +** +** The conflicting row, in this case, is the database row with the matching +** primary key. +** +**
    SQLITE_CHANGESET_NOTFOUND
    +** The conflict handler is invoked with CHANGESET_NOTFOUND as the second +** argument when processing a DELETE or UPDATE change if a row with the +** required PRIMARY KEY fields is not present in the database. +** +** There is no conflicting row in this case. The results of invoking the +** sqlite3changeset_conflict() API are undefined. +** +**
    SQLITE_CHANGESET_CONFLICT
    +** CHANGESET_CONFLICT is passed as the second argument to the conflict +** handler while processing an INSERT change if the operation would result +** in duplicate primary key values. +** +** The conflicting row in this case is the database row with the matching +** primary key. +** +**
    SQLITE_CHANGESET_FOREIGN_KEY
    +** If foreign key handling is enabled, and applying a changeset leaves the +** database in a state containing foreign key violations, the conflict +** handler is invoked with CHANGESET_FOREIGN_KEY as the second argument +** exactly once before the changeset is committed. If the conflict handler +** returns CHANGESET_OMIT, the changes, including those that caused the +** foreign key constraint violation, are committed. Or, if it returns +** CHANGESET_ABORT, the changeset is rolled back. +** +** No current or conflicting row information is provided. The only function +** it is possible to call on the supplied sqlite3_changeset_iter handle +** is sqlite3changeset_fk_conflicts(). +** +**
    SQLITE_CHANGESET_CONSTRAINT
    +** If any other constraint violation occurs while applying a change (i.e. +** a UNIQUE, CHECK or NOT NULL constraint), the conflict handler is +** invoked with CHANGESET_CONSTRAINT as the second argument. +** +** There is no conflicting row in this case. The results of invoking the +** sqlite3changeset_conflict() API are undefined. +** +**
    +*/ +#define SQLITE_CHANGESET_DATA 1 +#define SQLITE_CHANGESET_NOTFOUND 2 +#define SQLITE_CHANGESET_CONFLICT 3 +#define SQLITE_CHANGESET_CONSTRAINT 4 +#define SQLITE_CHANGESET_FOREIGN_KEY 5 + +/* +** CAPI3REF: Constants Returned By The Conflict Handler +** +** A conflict handler callback must return one of the following three values. +** +**
    +**
    SQLITE_CHANGESET_OMIT
    +** If a conflict handler returns this value no special action is taken. The +** change that caused the conflict is not applied. The session module +** continues to the next change in the changeset. +** +**
    SQLITE_CHANGESET_REPLACE
    +** This value may only be returned if the second argument to the conflict +** handler was SQLITE_CHANGESET_DATA or SQLITE_CHANGESET_CONFLICT. If this +** is not the case, any changes applied so far are rolled back and the +** call to sqlite3changeset_apply() returns SQLITE_MISUSE. +** +** If CHANGESET_REPLACE is returned by an SQLITE_CHANGESET_DATA conflict +** handler, then the conflicting row is either updated or deleted, depending +** on the type of change. +** +** If CHANGESET_REPLACE is returned by an SQLITE_CHANGESET_CONFLICT conflict +** handler, then the conflicting row is removed from the database and a +** second attempt to apply the change is made. If this second attempt fails, +** the original row is restored to the database before continuing. +** +**
    SQLITE_CHANGESET_ABORT
    +** If this value is returned, any changes applied so far are rolled back +** and the call to sqlite3changeset_apply() returns SQLITE_ABORT. +**
    +*/ +#define SQLITE_CHANGESET_OMIT 0 +#define SQLITE_CHANGESET_REPLACE 1 +#define SQLITE_CHANGESET_ABORT 2 + +/* +** CAPI3REF: Rebasing changesets +** EXPERIMENTAL +** +** Suppose there is a site hosting a database in state S0. And that +** modifications are made that move that database to state S1 and a +** changeset recorded (the "local" changeset). Then, a changeset based +** on S0 is received from another site (the "remote" changeset) and +** applied to the database. The database is then in state +** (S1+"remote"), where the exact state depends on any conflict +** resolution decisions (OMIT or REPLACE) made while applying "remote". +** Rebasing a changeset is to update it to take those conflict +** resolution decisions into account, so that the same conflicts +** do not have to be resolved elsewhere in the network. +** +** For example, if both the local and remote changesets contain an +** INSERT of the same key on "CREATE TABLE t1(a PRIMARY KEY, b)": +** +** local: INSERT INTO t1 VALUES(1, 'v1'); +** remote: INSERT INTO t1 VALUES(1, 'v2'); +** +** and the conflict resolution is REPLACE, then the INSERT change is +** removed from the local changeset (it was overridden). Or, if the +** conflict resolution was "OMIT", then the local changeset is modified +** to instead contain: +** +** UPDATE t1 SET b = 'v2' WHERE a=1; +** +** Changes within the local changeset are rebased as follows: +** +**
    +**
    Local INSERT
    +** This may only conflict with a remote INSERT. If the conflict +** resolution was OMIT, then add an UPDATE change to the rebased +** changeset. Or, if the conflict resolution was REPLACE, add +** nothing to the rebased changeset. +** +**
    Local DELETE
    +** This may conflict with a remote UPDATE or DELETE. In both cases the +** only possible resolution is OMIT. If the remote operation was a +** DELETE, then add no change to the rebased changeset. If the remote +** operation was an UPDATE, then the old.* fields of change are updated +** to reflect the new.* values in the UPDATE. +** +**
    Local UPDATE
    +** This may conflict with a remote UPDATE or DELETE. If it conflicts +** with a DELETE, and the conflict resolution was OMIT, then the update +** is changed into an INSERT. Any undefined values in the new.* record +** from the update change are filled in using the old.* values from +** the conflicting DELETE. Or, if the conflict resolution was REPLACE, +** the UPDATE change is simply omitted from the rebased changeset. +** +** If conflict is with a remote UPDATE and the resolution is OMIT, then +** the old.* values are rebased using the new.* values in the remote +** change. Or, if the resolution is REPLACE, then the change is copied +** into the rebased changeset with updates to columns also updated by +** the conflicting remote UPDATE removed. If this means no columns would +** be updated, the change is omitted. +**
    +** +** A local change may be rebased against multiple remote changes +** simultaneously. If a single key is modified by multiple remote +** changesets, they are combined as follows before the local changeset +** is rebased: +** +**
      +**
    • If there has been one or more REPLACE resolutions on a +** key, it is rebased according to a REPLACE. +** +**
    • If there have been no REPLACE resolutions on a key, then +** the local changeset is rebased according to the most recent +** of the OMIT resolutions. +**
    +** +** Note that conflict resolutions from multiple remote changesets are +** combined on a per-field basis, not per-row. This means that in the +** case of multiple remote UPDATE operations, some fields of a single +** local change may be rebased for REPLACE while others are rebased for +** OMIT. +** +** In order to rebase a local changeset, the remote changeset must first +** be applied to the local database using sqlite3changeset_apply_v2() and +** the buffer of rebase information captured. Then: +** +**
      +**
    1. An sqlite3_rebaser object is created by calling +** sqlite3rebaser_create(). +**
    2. The new object is configured with the rebase buffer obtained from +** sqlite3changeset_apply_v2() by calling sqlite3rebaser_configure(). +** If the local changeset is to be rebased against multiple remote +** changesets, then sqlite3rebaser_configure() should be called +** multiple times, in the same order that the multiple +** sqlite3changeset_apply_v2() calls were made. +**
    3. Each local changeset is rebased by calling sqlite3rebaser_rebase(). +**
    4. The sqlite3_rebaser object is deleted by calling +** sqlite3rebaser_delete(). +**
    +*/ +typedef struct sqlite3_rebaser sqlite3_rebaser; + +/* +** CAPI3REF: Create a changeset rebaser object. +** EXPERIMENTAL +** +** Allocate a new changeset rebaser object. If successful, set (*ppNew) to +** point to the new object and return SQLITE_OK. Otherwise, if an error +** occurs, return an SQLite error code (e.g. SQLITE_NOMEM) and set (*ppNew) +** to NULL. +*/ +SQLITE_API int sqlite3rebaser_create(sqlite3_rebaser **ppNew); + +/* +** CAPI3REF: Configure a changeset rebaser object. +** EXPERIMENTAL +** +** Configure the changeset rebaser object to rebase changesets according +** to the conflict resolutions described by buffer pRebase (size nRebase +** bytes), which must have been obtained from a previous call to +** sqlite3changeset_apply_v2(). +*/ +SQLITE_API int sqlite3rebaser_configure( + sqlite3_rebaser*, + int nRebase, const void *pRebase +); + +/* +** CAPI3REF: Rebase a changeset +** EXPERIMENTAL +** +** Argument pIn must point to a buffer containing a changeset nIn bytes +** in size. This function allocates and populates a buffer with a copy +** of the changeset rebased according to the configuration of the +** rebaser object passed as the first argument. If successful, (*ppOut) +** is set to point to the new buffer containing the rebased changeset and +** (*pnOut) to its size in bytes and SQLITE_OK returned. It is the +** responsibility of the caller to eventually free the new buffer using +** sqlite3_free(). Otherwise, if an error occurs, (*ppOut) and (*pnOut) +** are set to zero and an SQLite error code returned. +*/ +SQLITE_API int sqlite3rebaser_rebase( + sqlite3_rebaser*, + int nIn, const void *pIn, + int *pnOut, void **ppOut +); + +/* +** CAPI3REF: Delete a changeset rebaser object. +** EXPERIMENTAL +** +** Delete the changeset rebaser object and all associated resources. There +** should be one call to this function for each successful invocation +** of sqlite3rebaser_create(). +*/ +SQLITE_API void sqlite3rebaser_delete(sqlite3_rebaser *p); + +/* +** CAPI3REF: Streaming Versions of API functions. +** +** The six streaming API xxx_strm() functions serve similar purposes to the +** corresponding non-streaming API functions: +** +** +** +**
    Streaming functionNon-streaming equivalent
    sqlite3changeset_apply_strm[sqlite3changeset_apply] +**
    sqlite3changeset_apply_strm_v2[sqlite3changeset_apply_v2] +**
    sqlite3changeset_concat_strm[sqlite3changeset_concat] +**
    sqlite3changeset_invert_strm[sqlite3changeset_invert] +**
    sqlite3changeset_start_strm[sqlite3changeset_start] +**
    sqlite3session_changeset_strm[sqlite3session_changeset] +**
    sqlite3session_patchset_strm[sqlite3session_patchset] +**
    +** +** Non-streaming functions that accept changesets (or patchsets) as input +** require that the entire changeset be stored in a single buffer in memory. +** Similarly, those that return a changeset or patchset do so by returning +** a pointer to a single large buffer allocated using sqlite3_malloc(). +** Normally this is convenient. However, if an application running in a +** low-memory environment is required to handle very large changesets, the +** large contiguous memory allocations required can become onerous. +** +** In order to avoid this problem, instead of a single large buffer, input +** is passed to a streaming API functions by way of a callback function that +** the sessions module invokes to incrementally request input data as it is +** required. In all cases, a pair of API function parameters such as +** +** 
    +**        int nChangeset,
+**        void *pChangeset,
+**
    +** +** Is replaced by: +** +** 
    +**        int (*xInput)(void *pIn, void *pData, int *pnData),
+**        void *pIn,
+**
    +** +** Each time the xInput callback is invoked by the sessions module, the first +** argument passed is a copy of the supplied pIn context pointer. The second +** argument, pData, points to a buffer (*pnData) bytes in size. Assuming no +** error occurs the xInput method should copy up to (*pnData) bytes of data +** into the buffer and set (*pnData) to the actual number of bytes copied +** before returning SQLITE_OK. If the input is completely exhausted, (*pnData) +** should be set to zero to indicate this. Or, if an error occurs, an SQLite +** error code should be returned. In all cases, if an xInput callback returns +** an error, all processing is abandoned and the streaming API function +** returns a copy of the error code to the caller. +** +** In the case of sqlite3changeset_start_strm(), the xInput callback may be +** invoked by the sessions module at any point during the lifetime of the +** iterator. If such an xInput callback returns an error, the iterator enters +** an error state, whereby all subsequent calls to iterator functions +** immediately fail with the same error code as returned by xInput. +** +** Similarly, streaming API functions that return changesets (or patchsets) +** return them in chunks by way of a callback function instead of via a +** pointer to a single large buffer. In this case, a pair of parameters such +** as: +** +** 
    +**        int *pnChangeset,
+**        void **ppChangeset,
+**
    +** +** Is replaced by: +** +** 
    +**        int (*xOutput)(void *pOut, const void *pData, int nData),
+**        void *pOut
+**
    +** +** The xOutput callback is invoked zero or more times to return data to +** the application. The first parameter passed to each call is a copy of the +** pOut pointer supplied by the application. The second parameter, pData, +** points to a buffer nData bytes in size containing the chunk of output +** data being returned. If the xOutput callback successfully processes the +** supplied data, it should return SQLITE_OK to indicate success. Otherwise, +** it should return some other SQLite error code. In this case processing +** is immediately abandoned and the streaming API function returns a copy +** of the xOutput error code to the application. +** +** The sessions module never invokes an xOutput callback with the third +** parameter set to a value less than or equal to zero. Other than this, +** no guarantees are made as to the size of the chunks of data returned. +*/ +SQLITE_API int sqlite3changeset_apply_strm( + sqlite3 *db, /* Apply change to "main" db of this handle */ + int (*xInput)(void *pIn, void *pData, int *pnData), /* Input function */ + void *pIn, /* First arg for xInput */ + int(*xFilter)( + void *pCtx, /* Copy of sixth arg to _apply() */ + const char *zTab /* Table name */ + ), + int(*xConflict)( + void *pCtx, /* Copy of sixth arg to _apply() */ + int eConflict, /* DATA, MISSING, CONFLICT, CONSTRAINT */ + sqlite3_changeset_iter *p /* Handle describing change and conflict */ + ), + void *pCtx /* First argument passed to xConflict */ +); +SQLITE_API int sqlite3changeset_apply_v2_strm( + sqlite3 *db, /* Apply change to "main" db of this handle */ + int (*xInput)(void *pIn, void *pData, int *pnData), /* Input function */ + void *pIn, /* First arg for xInput */ + int(*xFilter)( + void *pCtx, /* Copy of sixth arg to _apply() */ + const char *zTab /* Table name */ + ), + int(*xConflict)( + void *pCtx, /* Copy of sixth arg to _apply() */ + int eConflict, /* DATA, MISSING, CONFLICT, CONSTRAINT */ + sqlite3_changeset_iter *p /* Handle describing change and conflict */ + ), + void *pCtx, /* First argument passed to xConflict */ + void **ppRebase, int *pnRebase, + int flags +); +SQLITE_API int sqlite3changeset_concat_strm( + int (*xInputA)(void *pIn, void *pData, int *pnData), + void *pInA, + int (*xInputB)(void *pIn, void *pData, int *pnData), + void *pInB, + int (*xOutput)(void *pOut, const void *pData, int nData), + void *pOut +); +SQLITE_API int sqlite3changeset_invert_strm( + int (*xInput)(void *pIn, void *pData, int *pnData), + void *pIn, + int (*xOutput)(void *pOut, const void *pData, int nData), + void *pOut +); +SQLITE_API int sqlite3changeset_start_strm( + sqlite3_changeset_iter **pp, + int (*xInput)(void *pIn, void *pData, int *pnData), + void *pIn +); +SQLITE_API int sqlite3changeset_start_v2_strm( + sqlite3_changeset_iter **pp, + int (*xInput)(void *pIn, void *pData, int *pnData), + void *pIn, + int flags +); +SQLITE_API int sqlite3session_changeset_strm( + sqlite3_session *pSession, + int (*xOutput)(void *pOut, const void *pData, int nData), + void *pOut +); +SQLITE_API int sqlite3session_patchset_strm( + sqlite3_session *pSession, + int (*xOutput)(void *pOut, const void *pData, int nData), + void *pOut +); +SQLITE_API int sqlite3changegroup_add_strm(sqlite3_changegroup*, + int (*xInput)(void *pIn, void *pData, int *pnData), + void *pIn +); +SQLITE_API int sqlite3changegroup_output_strm(sqlite3_changegroup*, + int (*xOutput)(void *pOut, const void *pData, int nData), + void *pOut +); +SQLITE_API int sqlite3rebaser_rebase_strm( + sqlite3_rebaser *pRebaser, + int (*xInput)(void *pIn, void *pData, int *pnData), + void *pIn, + int (*xOutput)(void *pOut, const void *pData, int nData), + void *pOut +); + +/* +** CAPI3REF: Configure global parameters +** +** The sqlite3session_config() interface is used to make global configuration +** changes to the sessions module in order to tune it to the specific needs +** of the application. +** +** The sqlite3session_config() interface is not threadsafe. If it is invoked +** while any other thread is inside any other sessions method then the +** results are undefined. Furthermore, if it is invoked after any sessions +** related objects have been created, the results are also undefined. +** +** The first argument to the sqlite3session_config() function must be one +** of the SQLITE_SESSION_CONFIG_XXX constants defined below. The +** interpretation of the (void*) value passed as the second parameter and +** the effect of calling this function depends on the value of the first +** parameter. +** +**
    +**
    SQLITE_SESSION_CONFIG_STRMSIZE
    +** By default, the sessions module streaming interfaces attempt to input +** and output data in approximately 1 KiB chunks. This operand may be used +** to set and query the value of this configuration setting. The pointer +** passed as the second argument must point to a value of type (int). +** If this value is greater than 0, it is used as the new streaming data +** chunk size for both input and output. Before returning, the (int) value +** pointed to by pArg is set to the final value of the streaming interface +** chunk size. +**
    +** +** This function returns SQLITE_OK if successful, or an SQLite error code +** otherwise. +*/ +SQLITE_API int sqlite3session_config(int op, void *pArg); + +/* +** CAPI3REF: Values for sqlite3session_config(). +*/ +#define SQLITE_SESSION_CONFIG_STRMSIZE 1 + +/* +** Make sure we can call this stuff from C++. +*/ +#if 0 +} +#endif + +#endif /* !defined(__SQLITESESSION_H_) && defined(SQLITE_ENABLE_SESSION) */ + +/******** End of sqlite3session.h *********/ +/******** Begin file fts5.h *********/ +/* +** 2014 May 31 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** Interfaces to extend FTS5. Using the interfaces defined in this file, +** FTS5 may be extended with: +** +** * custom tokenizers, and +** * custom auxiliary functions. +*/ + + +#ifndef _FTS5_H +#define _FTS5_H + + +#if 0 +extern "C" { +#endif + +/************************************************************************* +** CUSTOM AUXILIARY FUNCTIONS +** +** Virtual table implementations may overload SQL functions by implementing +** the sqlite3_module.xFindFunction() method. +*/ + +typedef struct Fts5ExtensionApi Fts5ExtensionApi; +typedef struct Fts5Context Fts5Context; +typedef struct Fts5PhraseIter Fts5PhraseIter; + +typedef void (*fts5_extension_function)( + const Fts5ExtensionApi *pApi, /* API offered by current FTS version */ + Fts5Context *pFts, /* First arg to pass to pApi functions */ + sqlite3_context *pCtx, /* Context for returning result/error */ + int nVal, /* Number of values in apVal[] array */ + sqlite3_value **apVal /* Array of trailing arguments */ +); + +struct Fts5PhraseIter { + const unsigned char *a; + const unsigned char *b; +}; + +/* +** EXTENSION API FUNCTIONS +** +** xUserData(pFts): +** Return a copy of the context pointer the extension function was +** registered with. +** +** xColumnTotalSize(pFts, iCol, pnToken): +** If parameter iCol is less than zero, set output variable *pnToken +** to the total number of tokens in the FTS5 table. Or, if iCol is +** non-negative but less than the number of columns in the table, return +** the total number of tokens in column iCol, considering all rows in +** the FTS5 table. +** +** If parameter iCol is greater than or equal to the number of columns +** in the table, SQLITE_RANGE is returned. Or, if an error occurs (e.g. +** an OOM condition or IO error), an appropriate SQLite error code is +** returned. +** +** xColumnCount(pFts): +** Return the number of columns in the table. +** +** xColumnSize(pFts, iCol, pnToken): +** If parameter iCol is less than zero, set output variable *pnToken +** to the total number of tokens in the current row. Or, if iCol is +** non-negative but less than the number of columns in the table, set +** *pnToken to the number of tokens in column iCol of the current row. +** +** If parameter iCol is greater than or equal to the number of columns +** in the table, SQLITE_RANGE is returned. Or, if an error occurs (e.g. +** an OOM condition or IO error), an appropriate SQLite error code is +** returned. +** +** This function may be quite inefficient if used with an FTS5 table +** created with the "columnsize=0" option. +** +** xColumnText: +** This function attempts to retrieve the text of column iCol of the +** current document. If successful, (*pz) is set to point to a buffer +** containing the text in utf-8 encoding, (*pn) is set to the size in bytes +** (not characters) of the buffer and SQLITE_OK is returned. Otherwise, +** if an error occurs, an SQLite error code is returned and the final values +** of (*pz) and (*pn) are undefined. +** +** xPhraseCount: +** Returns the number of phrases in the current query expression. +** +** xPhraseSize: +** Returns the number of tokens in phrase iPhrase of the query. Phrases +** are numbered starting from zero. +** +** xInstCount: +** Set *pnInst to the total number of occurrences of all phrases within +** the query within the current row. Return SQLITE_OK if successful, or +** an error code (i.e. SQLITE_NOMEM) if an error occurs. +** +** This API can be quite slow if used with an FTS5 table created with the +** "detail=none" or "detail=column" option. If the FTS5 table is created +** with either "detail=none" or "detail=column" and "content=" option +** (i.e. if it is a contentless table), then this API always returns 0. +** +** xInst: +** Query for the details of phrase match iIdx within the current row. +** Phrase matches are numbered starting from zero, so the iIdx argument +** should be greater than or equal to zero and smaller than the value +** output by xInstCount(). +** +** Usually, output parameter *piPhrase is set to the phrase number, *piCol +** to the column in which it occurs and *piOff the token offset of the +** first token of the phrase. Returns SQLITE_OK if successful, or an error +** code (i.e. SQLITE_NOMEM) if an error occurs. +** +** This API can be quite slow if used with an FTS5 table created with the +** "detail=none" or "detail=column" option. +** +** xRowid: +** Returns the rowid of the current row. +** +** xTokenize: +** Tokenize text using the tokenizer belonging to the FTS5 table. +** +** xQueryPhrase(pFts5, iPhrase, pUserData, xCallback): +** This API function is used to query the FTS table for phrase iPhrase +** of the current query. Specifically, a query equivalent to: +** +** ... FROM ftstable WHERE ftstable MATCH $p ORDER BY rowid +** +** with $p set to a phrase equivalent to the phrase iPhrase of the +** current query is executed. Any column filter that applies to +** phrase iPhrase of the current query is included in $p. For each +** row visited, the callback function passed as the fourth argument +** is invoked. The context and API objects passed to the callback +** function may be used to access the properties of each matched row. +** Invoking Api.xUserData() returns a copy of the pointer passed as +** the third argument to pUserData. +** +** If the callback function returns any value other than SQLITE_OK, the +** query is abandoned and the xQueryPhrase function returns immediately. +** If the returned value is SQLITE_DONE, xQueryPhrase returns SQLITE_OK. +** Otherwise, the error code is propagated upwards. +** +** If the query runs to completion without incident, SQLITE_OK is returned. +** Or, if some error occurs before the query completes or is aborted by +** the callback, an SQLite error code is returned. +** +** +** xSetAuxdata(pFts5, pAux, xDelete) +** +** Save the pointer passed as the second argument as the extension function's +** "auxiliary data". The pointer may then be retrieved by the current or any +** future invocation of the same fts5 extension function made as part of +** the same MATCH query using the xGetAuxdata() API. +** +** Each extension function is allocated a single auxiliary data slot for +** each FTS query (MATCH expression). If the extension function is invoked +** more than once for a single FTS query, then all invocations share a +** single auxiliary data context. +** +** If there is already an auxiliary data pointer when this function is +** invoked, then it is replaced by the new pointer. If an xDelete callback +** was specified along with the original pointer, it is invoked at this +** point. +** +** The xDelete callback, if one is specified, is also invoked on the +** auxiliary data pointer after the FTS5 query has finished. +** +** If an error (e.g. an OOM condition) occurs within this function, +** the auxiliary data is set to NULL and an error code returned. If the +** xDelete parameter was not NULL, it is invoked on the auxiliary data +** pointer before returning. +** +** +** xGetAuxdata(pFts5, bClear) +** +** Returns the current auxiliary data pointer for the fts5 extension +** function. See the xSetAuxdata() method for details. +** +** If the bClear argument is non-zero, then the auxiliary data is cleared +** (set to NULL) before this function returns. In this case the xDelete, +** if any, is not invoked. +** +** +** xRowCount(pFts5, pnRow) +** +** This function is used to retrieve the total number of rows in the table. +** In other words, the same value that would be returned by: +** +** SELECT count(*) FROM ftstable; +** +** xPhraseFirst() +** This function is used, along with type Fts5PhraseIter and the xPhraseNext +** method, to iterate through all instances of a single query phrase within +** the current row. This is the same information as is accessible via the +** xInstCount/xInst APIs. While the xInstCount/xInst APIs are more convenient +** to use, this API may be faster under some circumstances. To iterate +** through instances of phrase iPhrase, use the following code: +** +** Fts5PhraseIter iter; +** int iCol, iOff; +** for(pApi->xPhraseFirst(pFts, iPhrase, &iter, &iCol, &iOff); +** iCol>=0; +** pApi->xPhraseNext(pFts, &iter, &iCol, &iOff) +** ){ +** // An instance of phrase iPhrase at offset iOff of column iCol +** } +** +** The Fts5PhraseIter structure is defined above. Applications should not +** modify this structure directly - it should only be used as shown above +** with the xPhraseFirst() and xPhraseNext() API methods (and by +** xPhraseFirstColumn() and xPhraseNextColumn() as illustrated below). +** +** This API can be quite slow if used with an FTS5 table created with the +** "detail=none" or "detail=column" option. If the FTS5 table is created +** with either "detail=none" or "detail=column" and "content=" option +** (i.e. if it is a contentless table), then this API always iterates +** through an empty set (all calls to xPhraseFirst() set iCol to -1). +** +** xPhraseNext() +** See xPhraseFirst above. +** +** xPhraseFirstColumn() +** This function and xPhraseNextColumn() are similar to the xPhraseFirst() +** and xPhraseNext() APIs described above. The difference is that instead +** of iterating through all instances of a phrase in the current row, these +** APIs are used to iterate through the set of columns in the current row +** that contain one or more instances of a specified phrase. For example: +** +** Fts5PhraseIter iter; +** int iCol; +** for(pApi->xPhraseFirstColumn(pFts, iPhrase, &iter, &iCol); +** iCol>=0; +** pApi->xPhraseNextColumn(pFts, &iter, &iCol) +** ){ +** // Column iCol contains at least one instance of phrase iPhrase +** } +** +** This API can be quite slow if used with an FTS5 table created with the +** "detail=none" option. If the FTS5 table is created with either +** "detail=none" "content=" option (i.e. if it is a contentless table), +** then this API always iterates through an empty set (all calls to +** xPhraseFirstColumn() set iCol to -1). +** +** The information accessed using this API and its companion +** xPhraseFirstColumn() may also be obtained using xPhraseFirst/xPhraseNext +** (or xInst/xInstCount). The chief advantage of this API is that it is +** significantly more efficient than those alternatives when used with +** "detail=column" tables. +** +** xPhraseNextColumn() +** See xPhraseFirstColumn above. +*/ +struct Fts5ExtensionApi { + int iVersion; /* Currently always set to 3 */ + + void *(*xUserData)(Fts5Context*); + + int (*xColumnCount)(Fts5Context*); + int (*xRowCount)(Fts5Context*, sqlite3_int64 *pnRow); + int (*xColumnTotalSize)(Fts5Context*, int iCol, sqlite3_int64 *pnToken); + + int (*xTokenize)(Fts5Context*, + const char *pText, int nText, /* Text to tokenize */ + void *pCtx, /* Context passed to xToken() */ + int (*xToken)(void*, int, const char*, int, int, int) /* Callback */ + ); + + int (*xPhraseCount)(Fts5Context*); + int (*xPhraseSize)(Fts5Context*, int iPhrase); + + int (*xInstCount)(Fts5Context*, int *pnInst); + int (*xInst)(Fts5Context*, int iIdx, int *piPhrase, int *piCol, int *piOff); + + sqlite3_int64 (*xRowid)(Fts5Context*); + int (*xColumnText)(Fts5Context*, int iCol, const char **pz, int *pn); + int (*xColumnSize)(Fts5Context*, int iCol, int *pnToken); + + int (*xQueryPhrase)(Fts5Context*, int iPhrase, void *pUserData, + int(*)(const Fts5ExtensionApi*,Fts5Context*,void*) + ); + int (*xSetAuxdata)(Fts5Context*, void *pAux, void(*xDelete)(void*)); + void *(*xGetAuxdata)(Fts5Context*, int bClear); + + int (*xPhraseFirst)(Fts5Context*, int iPhrase, Fts5PhraseIter*, int*, int*); + void (*xPhraseNext)(Fts5Context*, Fts5PhraseIter*, int *piCol, int *piOff); + + int (*xPhraseFirstColumn)(Fts5Context*, int iPhrase, Fts5PhraseIter*, int*); + void (*xPhraseNextColumn)(Fts5Context*, Fts5PhraseIter*, int *piCol); +}; + +/* +** CUSTOM AUXILIARY FUNCTIONS +*************************************************************************/ + +/************************************************************************* +** CUSTOM TOKENIZERS +** +** Applications may also register custom tokenizer types. A tokenizer +** is registered by providing fts5 with a populated instance of the +** following structure. All structure methods must be defined, setting +** any member of the fts5_tokenizer struct to NULL leads to undefined +** behaviour. The structure methods are expected to function as follows: +** +** xCreate: +** This function is used to allocate and initialize a tokenizer instance. +** A tokenizer instance is required to actually tokenize text. +** +** The first argument passed to this function is a copy of the (void*) +** pointer provided by the application when the fts5_tokenizer object +** was registered with FTS5 (the third argument to xCreateTokenizer()). +** The second and third arguments are an array of nul-terminated strings +** containing the tokenizer arguments, if any, specified following the +** tokenizer name as part of the CREATE VIRTUAL TABLE statement used +** to create the FTS5 table. +** +** The final argument is an output variable. If successful, (*ppOut) +** should be set to point to the new tokenizer handle and SQLITE_OK +** returned. If an error occurs, some value other than SQLITE_OK should +** be returned. In this case, fts5 assumes that the final value of *ppOut +** is undefined. +** +** xDelete: +** This function is invoked to delete a tokenizer handle previously +** allocated using xCreate(). Fts5 guarantees that this function will +** be invoked exactly once for each successful call to xCreate(). +** +** xTokenize: +** This function is expected to tokenize the nText byte string indicated +** by argument pText. pText may or may not be nul-terminated. The first +** argument passed to this function is a pointer to an Fts5Tokenizer object +** returned by an earlier call to xCreate(). +** +** The second argument indicates the reason that FTS5 is requesting +** tokenization of the supplied text. This is always one of the following +** four values: +** +**
    • FTS5_TOKENIZE_DOCUMENT - A document is being inserted into +** or removed from the FTS table. The tokenizer is being invoked to +** determine the set of tokens to add to (or delete from) the +** FTS index. +** +**
    • FTS5_TOKENIZE_QUERY - A MATCH query is being executed +** against the FTS index. The tokenizer is being called to tokenize +** a bareword or quoted string specified as part of the query. +** +**
    • (FTS5_TOKENIZE_QUERY | FTS5_TOKENIZE_PREFIX) - Same as +** FTS5_TOKENIZE_QUERY, except that the bareword or quoted string is +** followed by a "*" character, indicating that the last token +** returned by the tokenizer will be treated as a token prefix. +** +**
    • FTS5_TOKENIZE_AUX - The tokenizer is being invoked to +** satisfy an fts5_api.xTokenize() request made by an auxiliary +** function. Or an fts5_api.xColumnSize() request made by the same +** on a columnsize=0 database. +**
    +** +** For each token in the input string, the supplied callback xToken() must +** be invoked. The first argument to it should be a copy of the pointer +** passed as the second argument to xTokenize(). The third and fourth +** arguments are a pointer to a buffer containing the token text, and the +** size of the token in bytes. The 4th and 5th arguments are the byte offsets +** of the first byte of and first byte immediately following the text from +** which the token is derived within the input. +** +** The second argument passed to the xToken() callback ("tflags") should +** normally be set to 0. The exception is if the tokenizer supports +** synonyms. In this case see the discussion below for details. +** +** FTS5 assumes the xToken() callback is invoked for each token in the +** order that they occur within the input text. +** +** If an xToken() callback returns any value other than SQLITE_OK, then +** the tokenization should be abandoned and the xTokenize() method should +** immediately return a copy of the xToken() return value. Or, if the +** input buffer is exhausted, xTokenize() should return SQLITE_OK. Finally, +** if an error occurs with the xTokenize() implementation itself, it +** may abandon the tokenization and return any error code other than +** SQLITE_OK or SQLITE_DONE. +** +** SYNONYM SUPPORT +** +** Custom tokenizers may also support synonyms. Consider a case in which a +** user wishes to query for a phrase such as "first place". Using the +** built-in tokenizers, the FTS5 query 'first + place' will match instances +** of "first place" within the document set, but not alternative forms +** such as "1st place". In some applications, it would be better to match +** all instances of "first place" or "1st place" regardless of which form +** the user specified in the MATCH query text. +** +** There are several ways to approach this in FTS5: +** +**
    1. By mapping all synonyms to a single token. In this case, using +** the above example, this means that the tokenizer returns the +** same token for inputs "first" and "1st". Say that token is in +** fact "first", so that when the user inserts the document "I won +** 1st place" entries are added to the index for tokens "i", "won", +** "first" and "place". If the user then queries for '1st + place', +** the tokenizer substitutes "first" for "1st" and the query works +** as expected. +** +**
    2. By querying the index for all synonyms of each query term +** separately. In this case, when tokenizing query text, the +** tokenizer may provide multiple synonyms for a single term +** within the document. FTS5 then queries the index for each +** synonym individually. For example, faced with the query: +** +** +** ... MATCH 'first place' +** +** the tokenizer offers both "1st" and "first" as synonyms for the +** first token in the MATCH query and FTS5 effectively runs a query +** similar to: +** +** +** ... MATCH '(first OR 1st) place' +** +** except that, for the purposes of auxiliary functions, the query +** still appears to contain just two phrases - "(first OR 1st)" +** being treated as a single phrase. +** +**
    3. By adding multiple synonyms for a single term to the FTS index. +** Using this method, when tokenizing document text, the tokenizer +** provides multiple synonyms for each token. So that when a +** document such as "I won first place" is tokenized, entries are +** added to the FTS index for "i", "won", "first", "1st" and +** "place". +** +** This way, even if the tokenizer does not provide synonyms +** when tokenizing query text (it should not - to do so would be +** inefficient), it doesn't matter if the user queries for +** 'first + place' or '1st + place', as there are entries in the +** FTS index corresponding to both forms of the first token. +**
    +** +** Whether it is parsing document or query text, any call to xToken that +** specifies a tflags argument with the FTS5_TOKEN_COLOCATED bit +** is considered to supply a synonym for the previous token. For example, +** when parsing the document "I won first place", a tokenizer that supports +** synonyms would call xToken() 5 times, as follows: +** +** +** xToken(pCtx, 0, "i", 1, 0, 1); +** xToken(pCtx, 0, "won", 3, 2, 5); +** xToken(pCtx, 0, "first", 5, 6, 11); +** xToken(pCtx, FTS5_TOKEN_COLOCATED, "1st", 3, 6, 11); +** xToken(pCtx, 0, "place", 5, 12, 17); +** +** +** It is an error to specify the FTS5_TOKEN_COLOCATED flag the first time +** xToken() is called. Multiple synonyms may be specified for a single token +** by making multiple calls to xToken(FTS5_TOKEN_COLOCATED) in sequence. +** There is no limit to the number of synonyms that may be provided for a +** single token. +** +** In many cases, method (1) above is the best approach. It does not add +** extra data to the FTS index or require FTS5 to query for multiple terms, +** so it is efficient in terms of disk space and query speed. However, it +** does not support prefix queries very well. If, as suggested above, the +** token "first" is substituted for "1st" by the tokenizer, then the query: +** +** +** ... MATCH '1s*' +** +** will not match documents that contain the token "1st" (as the tokenizer +** will probably not map "1s" to any prefix of "first"). +** +** For full prefix support, method (3) may be preferred. In this case, +** because the index contains entries for both "first" and "1st", prefix +** queries such as 'fi*' or '1s*' will match correctly. However, because +** extra entries are added to the FTS index, this method uses more space +** within the database. +** +** Method (2) offers a midpoint between (1) and (3). Using this method, +** a query such as '1s*' will match documents that contain the literal +** token "1st", but not "first" (assuming the tokenizer is not able to +** provide synonyms for prefixes). However, a non-prefix query like '1st' +** will match against "1st" and "first". This method does not require +** extra disk space, as no extra entries are added to the FTS index. +** On the other hand, it may require more CPU cycles to run MATCH queries, +** as separate queries of the FTS index are required for each synonym. +** +** When using methods (2) or (3), it is important that the tokenizer only +** provide synonyms when tokenizing document text (method (2)) or query +** text (method (3)), not both. Doing so will not cause any errors, but is +** inefficient. +*/ +typedef struct Fts5Tokenizer Fts5Tokenizer; +typedef struct fts5_tokenizer fts5_tokenizer; +struct fts5_tokenizer { + int (*xCreate)(void*, const char **azArg, int nArg, Fts5Tokenizer **ppOut); + void (*xDelete)(Fts5Tokenizer*); + int (*xTokenize)(Fts5Tokenizer*, + void *pCtx, + int flags, /* Mask of FTS5_TOKENIZE_* flags */ + const char *pText, int nText, + int (*xToken)( + void *pCtx, /* Copy of 2nd argument to xTokenize() */ + int tflags, /* Mask of FTS5_TOKEN_* flags */ + const char *pToken, /* Pointer to buffer containing token */ + int nToken, /* Size of token in bytes */ + int iStart, /* Byte offset of token within input text */ + int iEnd /* Byte offset of end of token within input text */ + ) + ); +}; + +/* Flags that may be passed as the third argument to xTokenize() */ +#define FTS5_TOKENIZE_QUERY 0x0001 +#define FTS5_TOKENIZE_PREFIX 0x0002 +#define FTS5_TOKENIZE_DOCUMENT 0x0004 +#define FTS5_TOKENIZE_AUX 0x0008 + +/* Flags that may be passed by the tokenizer implementation back to FTS5 +** as the third argument to the supplied xToken callback. */ +#define FTS5_TOKEN_COLOCATED 0x0001 /* Same position as prev. token */ + +/* +** END OF CUSTOM TOKENIZERS +*************************************************************************/ + +/************************************************************************* +** FTS5 EXTENSION REGISTRATION API +*/ +typedef struct fts5_api fts5_api; +struct fts5_api { + int iVersion; /* Currently always set to 2 */ + + /* Create a new tokenizer */ + int (*xCreateTokenizer)( + fts5_api *pApi, + const char *zName, + void *pContext, + fts5_tokenizer *pTokenizer, + void (*xDestroy)(void*) + ); + + /* Find an existing tokenizer */ + int (*xFindTokenizer)( + fts5_api *pApi, + const char *zName, + void **ppContext, + fts5_tokenizer *pTokenizer + ); + + /* Create a new auxiliary function */ + int (*xCreateFunction)( + fts5_api *pApi, + const char *zName, + void *pContext, + fts5_extension_function xFunction, + void (*xDestroy)(void*) + ); +}; + +/* +** END OF REGISTRATION API +*************************************************************************/ + +#if 0 +} /* end of the 'extern "C"' block */ +#endif + +#endif /* _FTS5_H */ + +/******** End of fts5.h *********/ + +/************** End of sqlite3.h *********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ + +/* +** Reuse the STATIC_LRU for mutex access to sqlite3_temp_directory. +*/ +#define SQLITE_MUTEX_STATIC_TEMPDIR SQLITE_MUTEX_STATIC_VFS1 + +/* +** Include the configuration header output by 'configure' if we're using the +** autoconf-based build +*/ +#if defined(_HAVE_SQLITE_CONFIG_H) && !defined(SQLITECONFIG_H) +#include "sqlite_cfg.h" +#define SQLITECONFIG_H 1 +#endif + +/************** Include sqliteLimit.h in the middle of sqliteInt.h ***********/ +/************** Begin file sqliteLimit.h *************************************/ +/* +** 2007 May 7 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file defines various limits of what SQLite can process. +*/ + +/* +** The maximum length of a TEXT or BLOB in bytes. This also +** limits the size of a row in a table or index. +** +** The hard limit is the ability of a 32-bit signed integer +** to count the size: 2^31-1 or 2147483647. +*/ +#ifndef SQLITE_MAX_LENGTH +# define SQLITE_MAX_LENGTH 1000000000 +#endif + +/* +** This is the maximum number of +** +** * Columns in a table +** * Columns in an index +** * Columns in a view +** * Terms in the SET clause of an UPDATE statement +** * Terms in the result set of a SELECT statement +** * Terms in the GROUP BY or ORDER BY clauses of a SELECT statement. +** * Terms in the VALUES clause of an INSERT statement +** +** The hard upper limit here is 32676. Most database people will +** tell you that in a well-normalized database, you usually should +** not have more than a dozen or so columns in any table. And if +** that is the case, there is no point in having more than a few +** dozen values in any of the other situations described above. +*/ +#ifndef SQLITE_MAX_COLUMN +# define SQLITE_MAX_COLUMN 2000 +#endif + +/* +** The maximum length of a single SQL statement in bytes. +** +** It used to be the case that setting this value to zero would +** turn the limit off. That is no longer true. It is not possible +** to turn this limit off. +*/ +#ifndef SQLITE_MAX_SQL_LENGTH +# define SQLITE_MAX_SQL_LENGTH 1000000000 +#endif + +/* +** The maximum depth of an expression tree. This is limited to +** some extent by SQLITE_MAX_SQL_LENGTH. But sometime you might +** want to place more severe limits on the complexity of an +** expression. A value of 0 means that there is no limit. +*/ +#ifndef SQLITE_MAX_EXPR_DEPTH +# define SQLITE_MAX_EXPR_DEPTH 1000 +#endif + +/* +** The maximum number of terms in a compound SELECT statement. +** The code generator for compound SELECT statements does one +** level of recursion for each term. A stack overflow can result +** if the number of terms is too large. In practice, most SQL +** never has more than 3 or 4 terms. Use a value of 0 to disable +** any limit on the number of terms in a compount SELECT. +*/ +#ifndef SQLITE_MAX_COMPOUND_SELECT +# define SQLITE_MAX_COMPOUND_SELECT 500 +#endif + +/* +** The maximum number of opcodes in a VDBE program. +** Not currently enforced. +*/ +#ifndef SQLITE_MAX_VDBE_OP +# define SQLITE_MAX_VDBE_OP 250000000 +#endif + +/* +** The maximum number of arguments to an SQL function. +*/ +#ifndef SQLITE_MAX_FUNCTION_ARG +# define SQLITE_MAX_FUNCTION_ARG 127 +#endif + +/* +** The suggested maximum number of in-memory pages to use for +** the main database table and for temporary tables. +** +** IMPLEMENTATION-OF: R-30185-15359 The default suggested cache size is -2000, +** which means the cache size is limited to 2048000 bytes of memory. +** IMPLEMENTATION-OF: R-48205-43578 The default suggested cache size can be +** altered using the SQLITE_DEFAULT_CACHE_SIZE compile-time options. +*/ +#ifndef SQLITE_DEFAULT_CACHE_SIZE +# define SQLITE_DEFAULT_CACHE_SIZE -2000 +#endif + +/* +** The default number of frames to accumulate in the log file before +** checkpointing the database in WAL mode. +*/ +#ifndef SQLITE_DEFAULT_WAL_AUTOCHECKPOINT +# define SQLITE_DEFAULT_WAL_AUTOCHECKPOINT 1000 +#endif + +/* +** The maximum number of attached databases. This must be between 0 +** and 125. The upper bound of 125 is because the attached databases are +** counted using a signed 8-bit integer which has a maximum value of 127 +** and we have to allow 2 extra counts for the "main" and "temp" databases. +*/ +#ifndef SQLITE_MAX_ATTACHED +# define SQLITE_MAX_ATTACHED 10 +#endif + + +/* +** The maximum value of a ?nnn wildcard that the parser will accept. +** If the value exceeds 32767 then extra space is required for the Expr +** structure. But otherwise, we believe that the number can be as large +** as a signed 32-bit integer can hold. +*/ +#ifndef SQLITE_MAX_VARIABLE_NUMBER +# define SQLITE_MAX_VARIABLE_NUMBER 32766 +#endif + +/* Maximum page size. The upper bound on this value is 65536. This a limit +** imposed by the use of 16-bit offsets within each page. +** +** Earlier versions of SQLite allowed the user to change this value at +** compile time. This is no longer permitted, on the grounds that it creates +** a library that is technically incompatible with an SQLite library +** compiled with a different limit. If a process operating on a database +** with a page-size of 65536 bytes crashes, then an instance of SQLite +** compiled with the default page-size limit will not be able to rollback +** the aborted transaction. This could lead to database corruption. +*/ +#ifdef SQLITE_MAX_PAGE_SIZE +# undef SQLITE_MAX_PAGE_SIZE +#endif +#define SQLITE_MAX_PAGE_SIZE 65536 + + +/* +** The default size of a database page. +*/ +#ifndef SQLITE_DEFAULT_PAGE_SIZE +# define SQLITE_DEFAULT_PAGE_SIZE 4096 +#endif +#if SQLITE_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE +# undef SQLITE_DEFAULT_PAGE_SIZE +# define SQLITE_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE +#endif + +/* +** Ordinarily, if no value is explicitly provided, SQLite creates databases +** with page size SQLITE_DEFAULT_PAGE_SIZE. However, based on certain +** device characteristics (sector-size and atomic write() support), +** SQLite may choose a larger value. This constant is the maximum value +** SQLite will choose on its own. +*/ +#ifndef SQLITE_MAX_DEFAULT_PAGE_SIZE +# define SQLITE_MAX_DEFAULT_PAGE_SIZE 8192 +#endif +#if SQLITE_MAX_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE +# undef SQLITE_MAX_DEFAULT_PAGE_SIZE +# define SQLITE_MAX_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE +#endif + + +/* +** Maximum number of pages in one database file. +** +** This is really just the default value for the max_page_count pragma. +** This value can be lowered (or raised) at run-time using that the +** max_page_count macro. +*/ +#ifndef SQLITE_MAX_PAGE_COUNT +# define SQLITE_MAX_PAGE_COUNT 1073741823 +#endif + +/* +** Maximum length (in bytes) of the pattern in a LIKE or GLOB +** operator. +*/ +#ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH +# define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000 +#endif + +/* +** Maximum depth of recursion for triggers. +** +** A value of 1 means that a trigger program will not be able to itself +** fire any triggers. A value of 0 means that no trigger programs at all +** may be executed. +*/ +#ifndef SQLITE_MAX_TRIGGER_DEPTH +# define SQLITE_MAX_TRIGGER_DEPTH 1000 +#endif + +/************** End of sqliteLimit.h *****************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ + +/* Disable nuisance warnings on Borland compilers */ +#if defined(__BORLANDC__) +#pragma warn -rch /* unreachable code */ +#pragma warn -ccc /* Condition is always true or false */ +#pragma warn -aus /* Assigned value is never used */ +#pragma warn -csu /* Comparing signed and unsigned */ +#pragma warn -spa /* Suspicious pointer arithmetic */ +#endif + +/* +** A few places in the code require atomic load/store of aligned +** integer values. +*/ +#ifndef __has_extension +# define __has_extension(x) 0 /* compatibility with non-clang compilers */ +#endif +#if GCC_VERSION>=4007000 || __has_extension(c_atomic) +# define SQLITE_ATOMIC_INTRINSICS 1 +# define AtomicLoad(PTR) __atomic_load_n((PTR),__ATOMIC_RELAXED) +# define AtomicStore(PTR,VAL) __atomic_store_n((PTR),(VAL),__ATOMIC_RELAXED) +#else +# define SQLITE_ATOMIC_INTRINSICS 0 +# define AtomicLoad(PTR) (*(PTR)) +# define AtomicStore(PTR,VAL) (*(PTR) = (VAL)) +#endif + +/* +** Include standard header files as necessary +*/ +#ifdef HAVE_STDINT_H +#include +#endif +#ifdef HAVE_INTTYPES_H +#include +#endif + +/* +** The following macros are used to cast pointers to integers and +** integers to pointers. The way you do this varies from one compiler +** to the next, so we have developed the following set of #if statements +** to generate appropriate macros for a wide range of compilers. +** +** The correct "ANSI" way to do this is to use the intptr_t type. +** Unfortunately, that typedef is not available on all compilers, or +** if it is available, it requires an #include of specific headers +** that vary from one machine to the next. +** +** Ticket #3860: The llvm-gcc-4.2 compiler from Apple chokes on +** the ((void*)&((char*)0)[X]) construct. But MSVC chokes on ((void*)(X)). +** So we have to define the macros in different ways depending on the +** compiler. +*/ +#if defined(HAVE_STDINT_H) /* Use this case if we have ANSI headers */ +# define SQLITE_INT_TO_PTR(X) ((void*)(intptr_t)(X)) +# define SQLITE_PTR_TO_INT(X) ((int)(intptr_t)(X)) +#elif defined(__PTRDIFF_TYPE__) /* This case should work for GCC */ +# define SQLITE_INT_TO_PTR(X) ((void*)(__PTRDIFF_TYPE__)(X)) +# define SQLITE_PTR_TO_INT(X) ((int)(__PTRDIFF_TYPE__)(X)) +#elif !defined(__GNUC__) /* Works for compilers other than LLVM */ +# define SQLITE_INT_TO_PTR(X) ((void*)&((char*)0)[X]) +# define SQLITE_PTR_TO_INT(X) ((int)(((char*)X)-(char*)0)) +#else /* Generates a warning - but it always works */ +# define SQLITE_INT_TO_PTR(X) ((void*)(X)) +# define SQLITE_PTR_TO_INT(X) ((int)(X)) +#endif + +/* +** Macros to hint to the compiler that a function should or should not be +** inlined. +*/ +#if defined(__GNUC__) +# define SQLITE_NOINLINE __attribute__((noinline)) +# define SQLITE_INLINE __attribute__((always_inline)) inline +#elif defined(_MSC_VER) && _MSC_VER>=1310 +# define SQLITE_NOINLINE __declspec(noinline) +# define SQLITE_INLINE __forceinline +#else +# define SQLITE_NOINLINE +# define SQLITE_INLINE +#endif +#if defined(SQLITE_COVERAGE_TEST) || defined(__STRICT_ANSI__) +# undef SQLITE_INLINE +# define SQLITE_INLINE +#endif + +/* +** Make sure that the compiler intrinsics we desire are enabled when +** compiling with an appropriate version of MSVC unless prevented by +** the SQLITE_DISABLE_INTRINSIC define. +*/ +#if !defined(SQLITE_DISABLE_INTRINSIC) +# if defined(_MSC_VER) && _MSC_VER>=1400 +# if !defined(_WIN32_WCE) +# include +# pragma intrinsic(_byteswap_ushort) +# pragma intrinsic(_byteswap_ulong) +# pragma intrinsic(_byteswap_uint64) +# pragma intrinsic(_ReadWriteBarrier) +# else +# include +# endif +# endif +#endif + +/* +** The SQLITE_THREADSAFE macro must be defined as 0, 1, or 2. +** 0 means mutexes are permanently disable and the library is never +** threadsafe. 1 means the library is serialized which is the highest +** level of threadsafety. 2 means the library is multithreaded - multiple +** threads can use SQLite as long as no two threads try to use the same +** database connection at the same time. +** +** Older versions of SQLite used an optional THREADSAFE macro. +** We support that for legacy. +** +** To ensure that the correct value of "THREADSAFE" is reported when querying +** for compile-time options at runtime (e.g. "PRAGMA compile_options"), this +** logic is partially replicated in ctime.c. If it is updated here, it should +** also be updated there. +*/ +#if !defined(SQLITE_THREADSAFE) +# if defined(THREADSAFE) +# define SQLITE_THREADSAFE THREADSAFE +# else +# define SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */ +# endif +#endif + +/* +** Powersafe overwrite is on by default. But can be turned off using +** the -DSQLITE_POWERSAFE_OVERWRITE=0 command-line option. +*/ +#ifndef SQLITE_POWERSAFE_OVERWRITE +# define SQLITE_POWERSAFE_OVERWRITE 1 +#endif + +/* +** EVIDENCE-OF: R-25715-37072 Memory allocation statistics are enabled by +** default unless SQLite is compiled with SQLITE_DEFAULT_MEMSTATUS=0 in +** which case memory allocation statistics are disabled by default. +*/ +#if !defined(SQLITE_DEFAULT_MEMSTATUS) +# define SQLITE_DEFAULT_MEMSTATUS 1 +#endif + +/* +** Exactly one of the following macros must be defined in order to +** specify which memory allocation subsystem to use. +** +** SQLITE_SYSTEM_MALLOC // Use normal system malloc() +** SQLITE_WIN32_MALLOC // Use Win32 native heap API +** SQLITE_ZERO_MALLOC // Use a stub allocator that always fails +** SQLITE_MEMDEBUG // Debugging version of system malloc() +** +** On Windows, if the SQLITE_WIN32_MALLOC_VALIDATE macro is defined and the +** assert() macro is enabled, each call into the Win32 native heap subsystem +** will cause HeapValidate to be called. If heap validation should fail, an +** assertion will be triggered. +** +** If none of the above are defined, then set SQLITE_SYSTEM_MALLOC as +** the default. +*/ +#if defined(SQLITE_SYSTEM_MALLOC) \ + + defined(SQLITE_WIN32_MALLOC) \ + + defined(SQLITE_ZERO_MALLOC) \ + + defined(SQLITE_MEMDEBUG)>1 +# error "Two or more of the following compile-time configuration options\ + are defined but at most one is allowed:\ + SQLITE_SYSTEM_MALLOC, SQLITE_WIN32_MALLOC, SQLITE_MEMDEBUG,\ + SQLITE_ZERO_MALLOC" +#endif +#if defined(SQLITE_SYSTEM_MALLOC) \ + + defined(SQLITE_WIN32_MALLOC) \ + + defined(SQLITE_ZERO_MALLOC) \ + + defined(SQLITE_MEMDEBUG)==0 +# define SQLITE_SYSTEM_MALLOC 1 +#endif + +/* +** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the +** sizes of memory allocations below this value where possible. +*/ +#if !defined(SQLITE_MALLOC_SOFT_LIMIT) +# define SQLITE_MALLOC_SOFT_LIMIT 1024 +#endif + +/* +** We need to define _XOPEN_SOURCE as follows in order to enable +** recursive mutexes on most Unix systems and fchmod() on OpenBSD. +** But _XOPEN_SOURCE define causes problems for Mac OS X, so omit +** it. +*/ +#if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__) +# define _XOPEN_SOURCE 600 +#endif + +/* +** NDEBUG and SQLITE_DEBUG are opposites. It should always be true that +** defined(NDEBUG)==!defined(SQLITE_DEBUG). If this is not currently true, +** make it true by defining or undefining NDEBUG. +** +** Setting NDEBUG makes the code smaller and faster by disabling the +** assert() statements in the code. So we want the default action +** to be for NDEBUG to be set and NDEBUG to be undefined only if SQLITE_DEBUG +** is set. Thus NDEBUG becomes an opt-in rather than an opt-out +** feature. +*/ +#if !defined(NDEBUG) && !defined(SQLITE_DEBUG) +# define NDEBUG 1 +#endif +#if defined(NDEBUG) && defined(SQLITE_DEBUG) +# undef NDEBUG +#endif + +/* +** Enable SQLITE_ENABLE_EXPLAIN_COMMENTS if SQLITE_DEBUG is turned on. +*/ +#if !defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) && defined(SQLITE_DEBUG) +# define SQLITE_ENABLE_EXPLAIN_COMMENTS 1 +#endif + +/* +** The testcase() macro is used to aid in coverage testing. When +** doing coverage testing, the condition inside the argument to +** testcase() must be evaluated both true and false in order to +** get full branch coverage. The testcase() macro is inserted +** to help ensure adequate test coverage in places where simple +** condition/decision coverage is inadequate. For example, testcase() +** can be used to make sure boundary values are tested. For +** bitmask tests, testcase() can be used to make sure each bit +** is significant and used at least once. On switch statements +** where multiple cases go to the same block of code, testcase() +** can insure that all cases are evaluated. +*/ +#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_DEBUG) +# ifndef SQLITE_AMALGAMATION + extern unsigned int sqlite3CoverageCounter; +# endif +# define testcase(X) if( X ){ sqlite3CoverageCounter += (unsigned)__LINE__; } +#else +# define testcase(X) +#endif + +/* +** The TESTONLY macro is used to enclose variable declarations or +** other bits of code that are needed to support the arguments +** within testcase() and assert() macros. +*/ +#if !defined(NDEBUG) || defined(SQLITE_COVERAGE_TEST) +# define TESTONLY(X) X +#else +# define TESTONLY(X) +#endif + +/* +** Sometimes we need a small amount of code such as a variable initialization +** to setup for a later assert() statement. We do not want this code to +** appear when assert() is disabled. The following macro is therefore +** used to contain that setup code. The "VVA" acronym stands for +** "Verification, Validation, and Accreditation". In other words, the +** code within VVA_ONLY() will only run during verification processes. +*/ +#ifndef NDEBUG +# define VVA_ONLY(X) X +#else +# define VVA_ONLY(X) +#endif + +/* +** Disable ALWAYS() and NEVER() (make them pass-throughs) for coverage +** and mutation testing +*/ +#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST) +# define SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS 1 +#endif + +/* +** The ALWAYS and NEVER macros surround boolean expressions which +** are intended to always be true or false, respectively. Such +** expressions could be omitted from the code completely. But they +** are included in a few cases in order to enhance the resilience +** of SQLite to unexpected behavior - to make the code "self-healing" +** or "ductile" rather than being "brittle" and crashing at the first +** hint of unplanned behavior. +** +** In other words, ALWAYS and NEVER are added for defensive code. +** +** When doing coverage testing ALWAYS and NEVER are hard-coded to +** be true and false so that the unreachable code they specify will +** not be counted as untested code. +*/ +#if defined(SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS) +# define ALWAYS(X) (1) +# define NEVER(X) (0) +#elif !defined(NDEBUG) +# define ALWAYS(X) ((X)?1:(assert(0),0)) +# define NEVER(X) ((X)?(assert(0),1):0) +#else +# define ALWAYS(X) (X) +# define NEVER(X) (X) +#endif + +/* +** Some conditionals are optimizations only. In other words, if the +** conditionals are replaced with a constant 1 (true) or 0 (false) then +** the correct answer is still obtained, though perhaps not as quickly. +** +** The following macros mark these optimizations conditionals. +*/ +#if defined(SQLITE_MUTATION_TEST) +# define OK_IF_ALWAYS_TRUE(X) (1) +# define OK_IF_ALWAYS_FALSE(X) (0) +#else +# define OK_IF_ALWAYS_TRUE(X) (X) +# define OK_IF_ALWAYS_FALSE(X) (X) +#endif + +/* +** Some malloc failures are only possible if SQLITE_TEST_REALLOC_STRESS is +** defined. We need to defend against those failures when testing with +** SQLITE_TEST_REALLOC_STRESS, but we don't want the unreachable branches +** during a normal build. The following macro can be used to disable tests +** that are always false except when SQLITE_TEST_REALLOC_STRESS is set. +*/ +#if defined(SQLITE_TEST_REALLOC_STRESS) +# define ONLY_IF_REALLOC_STRESS(X) (X) +#elif !defined(NDEBUG) +# define ONLY_IF_REALLOC_STRESS(X) ((X)?(assert(0),1):0) +#else +# define ONLY_IF_REALLOC_STRESS(X) (0) +#endif + +/* +** Declarations used for tracing the operating system interfaces. +*/ +#if defined(SQLITE_FORCE_OS_TRACE) || defined(SQLITE_TEST) || \ + (defined(SQLITE_DEBUG) && SQLITE_OS_WIN) + extern int sqlite3OSTrace; +# define OSTRACE(X) if( sqlite3OSTrace ) sqlite3DebugPrintf X +# define SQLITE_HAVE_OS_TRACE +#else +# define OSTRACE(X) +# undef SQLITE_HAVE_OS_TRACE +#endif + +/* +** Is the sqlite3ErrName() function needed in the build? Currently, +** it is needed by "mutex_w32.c" (when debugging), "os_win.c" (when +** OSTRACE is enabled), and by several "test*.c" files (which are +** compiled using SQLITE_TEST). +*/ +#if defined(SQLITE_HAVE_OS_TRACE) || defined(SQLITE_TEST) || \ + (defined(SQLITE_DEBUG) && SQLITE_OS_WIN) +# define SQLITE_NEED_ERR_NAME +#else +# undef SQLITE_NEED_ERR_NAME +#endif + +/* +** SQLITE_ENABLE_EXPLAIN_COMMENTS is incompatible with SQLITE_OMIT_EXPLAIN +*/ +#ifdef SQLITE_OMIT_EXPLAIN +# undef SQLITE_ENABLE_EXPLAIN_COMMENTS +#endif + +/* +** SQLITE_OMIT_VIRTUALTABLE implies SQLITE_OMIT_ALTERTABLE +*/ +#if defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_ALTERTABLE) +# define SQLITE_OMIT_ALTERTABLE +#endif + +/* +** Return true (non-zero) if the input is an integer that is too large +** to fit in 32-bits. This macro is used inside of various testcase() +** macros to verify that we have tested SQLite for large-file support. +*/ +#define IS_BIG_INT(X) (((X)&~(i64)0xffffffff)!=0) + +/* +** The macro unlikely() is a hint that surrounds a boolean +** expression that is usually false. Macro likely() surrounds +** a boolean expression that is usually true. These hints could, +** in theory, be used by the compiler to generate better code, but +** currently they are just comments for human readers. +*/ +#define likely(X) (X) +#define unlikely(X) (X) + +/************** Include hash.h in the middle of sqliteInt.h ******************/ +/************** Begin file hash.h ********************************************/ +/* +** 2001 September 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This is the header file for the generic hash-table implementation +** used in SQLite. +*/ +#ifndef SQLITE_HASH_H +#define SQLITE_HASH_H + +/* Forward declarations of structures. */ +typedef struct Hash Hash; +typedef struct HashElem HashElem; + +/* A complete hash table is an instance of the following structure. +** The internals of this structure are intended to be opaque -- client +** code should not attempt to access or modify the fields of this structure +** directly. Change this structure only by using the routines below. +** However, some of the "procedures" and "functions" for modifying and +** accessing this structure are really macros, so we can't really make +** this structure opaque. +** +** All elements of the hash table are on a single doubly-linked list. +** Hash.first points to the head of this list. +** +** There are Hash.htsize buckets. Each bucket points to a spot in +** the global doubly-linked list. The contents of the bucket are the +** element pointed to plus the next _ht.count-1 elements in the list. +** +** Hash.htsize and Hash.ht may be zero. In that case lookup is done +** by a linear search of the global list. For small tables, the +** Hash.ht table is never allocated because if there are few elements +** in the table, it is faster to do a linear search than to manage +** the hash table. +*/ +struct Hash { + unsigned int htsize; /* Number of buckets in the hash table */ + unsigned int count; /* Number of entries in this table */ + HashElem *first; /* The first element of the array */ + struct _ht { /* the hash table */ + unsigned int count; /* Number of entries with this hash */ + HashElem *chain; /* Pointer to first entry with this hash */ + } *ht; +}; + +/* Each element in the hash table is an instance of the following +** structure. All elements are stored on a single doubly-linked list. +** +** Again, this structure is intended to be opaque, but it can't really +** be opaque because it is used by macros. +*/ +struct HashElem { + HashElem *next, *prev; /* Next and previous elements in the table */ + void *data; /* Data associated with this element */ + const char *pKey; /* Key associated with this element */ +}; + +/* +** Access routines. To delete, insert a NULL pointer. +*/ +SQLITE_PRIVATE void sqlite3HashInit(Hash*); +SQLITE_PRIVATE void *sqlite3HashInsert(Hash*, const char *pKey, void *pData); +SQLITE_PRIVATE void *sqlite3HashFind(const Hash*, const char *pKey); +SQLITE_PRIVATE void sqlite3HashClear(Hash*); + +/* +** Macros for looping over all elements of a hash table. The idiom is +** like this: +** +** Hash h; +** HashElem *p; +** ... +** for(p=sqliteHashFirst(&h); p; p=sqliteHashNext(p)){ +** SomeStructure *pData = sqliteHashData(p); +** // do something with pData +** } +*/ +#define sqliteHashFirst(H) ((H)->first) +#define sqliteHashNext(E) ((E)->next) +#define sqliteHashData(E) ((E)->data) +/* #define sqliteHashKey(E) ((E)->pKey) // NOT USED */ +/* #define sqliteHashKeysize(E) ((E)->nKey) // NOT USED */ + +/* +** Number of entries in a hash table +*/ +#define sqliteHashCount(H) ((H)->count) + +#endif /* SQLITE_HASH_H */ + +/************** End of hash.h ************************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +/************** Include parse.h in the middle of sqliteInt.h *****************/ +/************** Begin file parse.h *******************************************/ +#define TK_SEMI 1 +#define TK_EXPLAIN 2 +#define TK_QUERY 3 +#define TK_PLAN 4 +#define TK_BEGIN 5 +#define TK_TRANSACTION 6 +#define TK_DEFERRED 7 +#define TK_IMMEDIATE 8 +#define TK_EXCLUSIVE 9 +#define TK_COMMIT 10 +#define TK_END 11 +#define TK_ROLLBACK 12 +#define TK_SAVEPOINT 13 +#define TK_RELEASE 14 +#define TK_TO 15 +#define TK_TABLE 16 +#define TK_CREATE 17 +#define TK_IF 18 +#define TK_NOT 19 +#define TK_EXISTS 20 +#define TK_TEMP 21 +#define TK_LP 22 +#define TK_RP 23 +#define TK_AS 24 +#define TK_COMMA 25 +#define TK_WITHOUT 26 +#define TK_ABORT 27 +#define TK_ACTION 28 +#define TK_AFTER 29 +#define TK_ANALYZE 30 +#define TK_ASC 31 +#define TK_ATTACH 32 +#define TK_BEFORE 33 +#define TK_BY 34 +#define TK_CASCADE 35 +#define TK_CAST 36 +#define TK_CONFLICT 37 +#define TK_DATABASE 38 +#define TK_DESC 39 +#define TK_DETACH 40 +#define TK_EACH 41 +#define TK_FAIL 42 +#define TK_OR 43 +#define TK_AND 44 +#define TK_IS 45 +#define TK_MATCH 46 +#define TK_LIKE_KW 47 +#define TK_BETWEEN 48 +#define TK_IN 49 +#define TK_ISNULL 50 +#define TK_NOTNULL 51 +#define TK_NE 52 +#define TK_EQ 53 +#define TK_GT 54 +#define TK_LE 55 +#define TK_LT 56 +#define TK_GE 57 +#define TK_ESCAPE 58 +#define TK_ID 59 +#define TK_COLUMNKW 60 +#define TK_DO 61 +#define TK_FOR 62 +#define TK_IGNORE 63 +#define TK_INITIALLY 64 +#define TK_INSTEAD 65 +#define TK_NO 66 +#define TK_KEY 67 +#define TK_OF 68 +#define TK_OFFSET 69 +#define TK_PRAGMA 70 +#define TK_RAISE 71 +#define TK_RECURSIVE 72 +#define TK_REPLACE 73 +#define TK_RESTRICT 74 +#define TK_ROW 75 +#define TK_ROWS 76 +#define TK_TRIGGER 77 +#define TK_VACUUM 78 +#define TK_VIEW 79 +#define TK_VIRTUAL 80 +#define TK_WITH 81 +#define TK_NULLS 82 +#define TK_FIRST 83 +#define TK_LAST 84 +#define TK_CURRENT 85 +#define TK_FOLLOWING 86 +#define TK_PARTITION 87 +#define TK_PRECEDING 88 +#define TK_RANGE 89 +#define TK_UNBOUNDED 90 +#define TK_EXCLUDE 91 +#define TK_GROUPS 92 +#define TK_OTHERS 93 +#define TK_TIES 94 +#define TK_GENERATED 95 +#define TK_ALWAYS 96 +#define TK_MATERIALIZED 97 +#define TK_REINDEX 98 +#define TK_RENAME 99 +#define TK_CTIME_KW 100 +#define TK_ANY 101 +#define TK_BITAND 102 +#define TK_BITOR 103 +#define TK_LSHIFT 104 +#define TK_RSHIFT 105 +#define TK_PLUS 106 +#define TK_MINUS 107 +#define TK_STAR 108 +#define TK_SLASH 109 +#define TK_REM 110 +#define TK_CONCAT 111 +#define TK_PTR 112 +#define TK_COLLATE 113 +#define TK_BITNOT 114 +#define TK_ON 115 +#define TK_INDEXED 116 +#define TK_STRING 117 +#define TK_JOIN_KW 118 +#define TK_CONSTRAINT 119 +#define TK_DEFAULT 120 +#define TK_NULL 121 +#define TK_PRIMARY 122 +#define TK_UNIQUE 123 +#define TK_CHECK 124 +#define TK_REFERENCES 125 +#define TK_AUTOINCR 126 +#define TK_INSERT 127 +#define TK_DELETE 128 +#define TK_UPDATE 129 +#define TK_SET 130 +#define TK_DEFERRABLE 131 +#define TK_FOREIGN 132 +#define TK_DROP 133 +#define TK_UNION 134 +#define TK_ALL 135 +#define TK_EXCEPT 136 +#define TK_INTERSECT 137 +#define TK_SELECT 138 +#define TK_VALUES 139 +#define TK_DISTINCT 140 +#define TK_DOT 141 +#define TK_FROM 142 +#define TK_JOIN 143 +#define TK_USING 144 +#define TK_ORDER 145 +#define TK_GROUP 146 +#define TK_HAVING 147 +#define TK_LIMIT 148 +#define TK_WHERE 149 +#define TK_RETURNING 150 +#define TK_INTO 151 +#define TK_NOTHING 152 +#define TK_FLOAT 153 +#define TK_BLOB 154 +#define TK_INTEGER 155 +#define TK_VARIABLE 156 +#define TK_CASE 157 +#define TK_WHEN 158 +#define TK_THEN 159 +#define TK_ELSE 160 +#define TK_INDEX 161 +#define TK_ALTER 162 +#define TK_ADD 163 +#define TK_WINDOW 164 +#define TK_OVER 165 +#define TK_FILTER 166 +#define TK_COLUMN 167 +#define TK_AGG_FUNCTION 168 +#define TK_AGG_COLUMN 169 +#define TK_TRUEFALSE 170 +#define TK_ISNOT 171 +#define TK_FUNCTION 172 +#define TK_UMINUS 173 +#define TK_UPLUS 174 +#define TK_TRUTH 175 +#define TK_REGISTER 176 +#define TK_VECTOR 177 +#define TK_SELECT_COLUMN 178 +#define TK_IF_NULL_ROW 179 +#define TK_ASTERISK 180 +#define TK_SPAN 181 +#define TK_ERROR 182 +#define TK_SPACE 183 +#define TK_ILLEGAL 184 + +/************** End of parse.h ***********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +#include +#include +#include +#include +#include + +/* +** Use a macro to replace memcpy() if compiled with SQLITE_INLINE_MEMCPY. +** This allows better measurements of where memcpy() is used when running +** cachegrind. But this macro version of memcpy() is very slow so it +** should not be used in production. This is a performance measurement +** hack only. +*/ +#ifdef SQLITE_INLINE_MEMCPY +# define memcpy(D,S,N) {char*xxd=(char*)(D);const char*xxs=(const char*)(S);\ + int xxn=(N);while(xxn-->0)*(xxd++)=*(xxs++);} +#endif + +/* +** If compiling for a processor that lacks floating point support, +** substitute integer for floating-point +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# define double sqlite_int64 +# define float sqlite_int64 +# define LONGDOUBLE_TYPE sqlite_int64 +# ifndef SQLITE_BIG_DBL +# define SQLITE_BIG_DBL (((sqlite3_int64)1)<<50) +# endif +# define SQLITE_OMIT_DATETIME_FUNCS 1 +# define SQLITE_OMIT_TRACE 1 +# undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT +# undef SQLITE_HAVE_ISNAN +#endif +#ifndef SQLITE_BIG_DBL +# define SQLITE_BIG_DBL (1e99) +#endif + +/* +** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0 +** afterward. Having this macro allows us to cause the C compiler +** to omit code used by TEMP tables without messy #ifndef statements. +*/ +#ifdef SQLITE_OMIT_TEMPDB +#define OMIT_TEMPDB 1 +#else +#define OMIT_TEMPDB 0 +#endif + +/* +** The "file format" number is an integer that is incremented whenever +** the VDBE-level file format changes. The following macros define the +** the default file format for new databases and the maximum file format +** that the library can read. +*/ +#define SQLITE_MAX_FILE_FORMAT 4 +#ifndef SQLITE_DEFAULT_FILE_FORMAT +# define SQLITE_DEFAULT_FILE_FORMAT 4 +#endif + +/* +** Determine whether triggers are recursive by default. This can be +** changed at run-time using a pragma. +*/ +#ifndef SQLITE_DEFAULT_RECURSIVE_TRIGGERS +# define SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0 +#endif + +/* +** Provide a default value for SQLITE_TEMP_STORE in case it is not specified +** on the command-line +*/ +#ifndef SQLITE_TEMP_STORE +# define SQLITE_TEMP_STORE 1 +#endif + +/* +** If no value has been provided for SQLITE_MAX_WORKER_THREADS, or if +** SQLITE_TEMP_STORE is set to 3 (never use temporary files), set it +** to zero. +*/ +#if SQLITE_TEMP_STORE==3 || SQLITE_THREADSAFE==0 +# undef SQLITE_MAX_WORKER_THREADS +# define SQLITE_MAX_WORKER_THREADS 0 +#endif +#ifndef SQLITE_MAX_WORKER_THREADS +# define SQLITE_MAX_WORKER_THREADS 8 +#endif +#ifndef SQLITE_DEFAULT_WORKER_THREADS +# define SQLITE_DEFAULT_WORKER_THREADS 0 +#endif +#if SQLITE_DEFAULT_WORKER_THREADS>SQLITE_MAX_WORKER_THREADS +# undef SQLITE_MAX_WORKER_THREADS +# define SQLITE_MAX_WORKER_THREADS SQLITE_DEFAULT_WORKER_THREADS +#endif + +/* +** The default initial allocation for the pagecache when using separate +** pagecaches for each database connection. A positive number is the +** number of pages. A negative number N translations means that a buffer +** of -1024*N bytes is allocated and used for as many pages as it will hold. +** +** The default value of "20" was chosen to minimize the run-time of the +** speedtest1 test program with options: --shrink-memory --reprepare +*/ +#ifndef SQLITE_DEFAULT_PCACHE_INITSZ +# define SQLITE_DEFAULT_PCACHE_INITSZ 20 +#endif + +/* +** Default value for the SQLITE_CONFIG_SORTERREF_SIZE option. +*/ +#ifndef SQLITE_DEFAULT_SORTERREF_SIZE +# define SQLITE_DEFAULT_SORTERREF_SIZE 0x7fffffff +#endif + +/* +** The compile-time options SQLITE_MMAP_READWRITE and +** SQLITE_ENABLE_BATCH_ATOMIC_WRITE are not compatible with one another. +** You must choose one or the other (or neither) but not both. +*/ +#if defined(SQLITE_MMAP_READWRITE) && defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE) +#error Cannot use both SQLITE_MMAP_READWRITE and SQLITE_ENABLE_BATCH_ATOMIC_WRITE +#endif + +/* +** GCC does not define the offsetof() macro so we'll have to do it +** ourselves. +*/ +#ifndef offsetof +#define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD)) +#endif + +/* +** Macros to compute minimum and maximum of two numbers. +*/ +#ifndef MIN +# define MIN(A,B) ((A)<(B)?(A):(B)) +#endif +#ifndef MAX +# define MAX(A,B) ((A)>(B)?(A):(B)) +#endif + +/* +** Swap two objects of type TYPE. +*/ +#define SWAP(TYPE,A,B) {TYPE t=A; A=B; B=t;} + +/* +** Check to see if this machine uses EBCDIC. (Yes, believe it or +** not, there are still machines out there that use EBCDIC.) +*/ +#if 'A' == '\301' +# define SQLITE_EBCDIC 1 +#else +# define SQLITE_ASCII 1 +#endif + +/* +** Integers of known sizes. These typedefs might change for architectures +** where the sizes very. Preprocessor macros are available so that the +** types can be conveniently redefined at compile-type. Like this: +** +** cc '-DUINTPTR_TYPE=long long int' ... +*/ +#ifndef UINT32_TYPE +# ifdef HAVE_UINT32_T +# define UINT32_TYPE uint32_t +# else +# define UINT32_TYPE unsigned int +# endif +#endif +#ifndef UINT16_TYPE +# ifdef HAVE_UINT16_T +# define UINT16_TYPE uint16_t +# else +# define UINT16_TYPE unsigned short int +# endif +#endif +#ifndef INT16_TYPE +# ifdef HAVE_INT16_T +# define INT16_TYPE int16_t +# else +# define INT16_TYPE short int +# endif +#endif +#ifndef UINT8_TYPE +# ifdef HAVE_UINT8_T +# define UINT8_TYPE uint8_t +# else +# define UINT8_TYPE unsigned char +# endif +#endif +#ifndef INT8_TYPE +# ifdef HAVE_INT8_T +# define INT8_TYPE int8_t +# else +# define INT8_TYPE signed char +# endif +#endif +#ifndef LONGDOUBLE_TYPE +# define LONGDOUBLE_TYPE long double +#endif +typedef sqlite_int64 i64; /* 8-byte signed integer */ +typedef sqlite_uint64 u64; /* 8-byte unsigned integer */ +typedef UINT32_TYPE u32; /* 4-byte unsigned integer */ +typedef UINT16_TYPE u16; /* 2-byte unsigned integer */ +typedef INT16_TYPE i16; /* 2-byte signed integer */ +typedef UINT8_TYPE u8; /* 1-byte unsigned integer */ +typedef INT8_TYPE i8; /* 1-byte signed integer */ + +/* +** SQLITE_MAX_U32 is a u64 constant that is the maximum u64 value +** that can be stored in a u32 without loss of data. The value +** is 0x00000000ffffffff. But because of quirks of some compilers, we +** have to specify the value in the less intuitive manner shown: +*/ +#define SQLITE_MAX_U32 ((((u64)1)<<32)-1) + +/* +** The datatype used to store estimates of the number of rows in a +** table or index. +*/ +typedef u64 tRowcnt; + +/* +** Estimated quantities used for query planning are stored as 16-bit +** logarithms. For quantity X, the value stored is 10*log2(X). This +** gives a possible range of values of approximately 1.0e986 to 1e-986. +** But the allowed values are "grainy". Not every value is representable. +** For example, quantities 16 and 17 are both represented by a LogEst +** of 40. However, since LogEst quantities are suppose to be estimates, +** not exact values, this imprecision is not a problem. +** +** "LogEst" is short for "Logarithmic Estimate". +** +** Examples: +** 1 -> 0 20 -> 43 10000 -> 132 +** 2 -> 10 25 -> 46 25000 -> 146 +** 3 -> 16 100 -> 66 1000000 -> 199 +** 4 -> 20 1000 -> 99 1048576 -> 200 +** 10 -> 33 1024 -> 100 4294967296 -> 320 +** +** The LogEst can be negative to indicate fractional values. +** Examples: +** +** 0.5 -> -10 0.1 -> -33 0.0625 -> -40 +*/ +typedef INT16_TYPE LogEst; + +/* +** Set the SQLITE_PTRSIZE macro to the number of bytes in a pointer +*/ +#ifndef SQLITE_PTRSIZE +# if defined(__SIZEOF_POINTER__) +# define SQLITE_PTRSIZE __SIZEOF_POINTER__ +# elif defined(i386) || defined(__i386__) || defined(_M_IX86) || \ + defined(_M_ARM) || defined(__arm__) || defined(__x86) || \ + (defined(__APPLE__) && defined(__POWERPC__)) || \ + (defined(__TOS_AIX__) && !defined(__64BIT__)) +# define SQLITE_PTRSIZE 4 +# else +# define SQLITE_PTRSIZE 8 +# endif +#endif + +/* The uptr type is an unsigned integer large enough to hold a pointer +*/ +#if defined(HAVE_STDINT_H) + typedef uintptr_t uptr; +#elif SQLITE_PTRSIZE==4 + typedef u32 uptr; +#else + typedef u64 uptr; +#endif + +/* +** The SQLITE_WITHIN(P,S,E) macro checks to see if pointer P points to +** something between S (inclusive) and E (exclusive). +** +** In other words, S is a buffer and E is a pointer to the first byte after +** the end of buffer S. This macro returns true if P points to something +** contained within the buffer S. +*/ +#define SQLITE_WITHIN(P,S,E) (((uptr)(P)>=(uptr)(S))&&((uptr)(P)<(uptr)(E))) + + +/* +** Macros to determine whether the machine is big or little endian, +** and whether or not that determination is run-time or compile-time. +** +** For best performance, an attempt is made to guess at the byte-order +** using C-preprocessor macros. If that is unsuccessful, or if +** -DSQLITE_BYTEORDER=0 is set, then byte-order is determined +** at run-time. +*/ +#ifndef SQLITE_BYTEORDER +# if defined(i386) || defined(__i386__) || defined(_M_IX86) || \ + defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \ + defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \ + defined(__ARMEL__) || defined(__AARCH64EL__) || defined(_M_ARM64) +# define SQLITE_BYTEORDER 1234 +# elif defined(sparc) || defined(__ppc__) || \ + defined(__ARMEB__) || defined(__AARCH64EB__) +# define SQLITE_BYTEORDER 4321 +# else +# define SQLITE_BYTEORDER 0 +# endif +#endif +#if SQLITE_BYTEORDER==4321 +# define SQLITE_BIGENDIAN 1 +# define SQLITE_LITTLEENDIAN 0 +# define SQLITE_UTF16NATIVE SQLITE_UTF16BE +#elif SQLITE_BYTEORDER==1234 +# define SQLITE_BIGENDIAN 0 +# define SQLITE_LITTLEENDIAN 1 +# define SQLITE_UTF16NATIVE SQLITE_UTF16LE +#else +# ifdef SQLITE_AMALGAMATION + const int sqlite3one = 1; +# else + extern const int sqlite3one; +# endif +# define SQLITE_BIGENDIAN (*(char *)(&sqlite3one)==0) +# define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1) +# define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE) +#endif + +/* +** Constants for the largest and smallest possible 64-bit signed integers. +** These macros are designed to work correctly on both 32-bit and 64-bit +** compilers. +*/ +#define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32)) +#define LARGEST_UINT64 (0xffffffff|(((u64)0xffffffff)<<32)) +#define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64) + +/* +** Round up a number to the next larger multiple of 8. This is used +** to force 8-byte alignment on 64-bit architectures. +** +** ROUND8() always does the rounding, for any argument. +** +** ROUND8P() assumes that the argument is already an integer number of +** pointers in size, and so it is a no-op on systems where the pointer +** size is 8. +*/ +#define ROUND8(x) (((x)+7)&~7) +#if SQLITE_PTRSIZE==8 +# define ROUND8P(x) (x) +#else +# define ROUND8P(x) (((x)+7)&~7) +#endif + +/* +** Round down to the nearest multiple of 8 +*/ +#define ROUNDDOWN8(x) ((x)&~7) + +/* +** Assert that the pointer X is aligned to an 8-byte boundary. This +** macro is used only within assert() to verify that the code gets +** all alignment restrictions correct. +** +** Except, if SQLITE_4_BYTE_ALIGNED_MALLOC is defined, then the +** underlying malloc() implementation might return us 4-byte aligned +** pointers. In that case, only verify 4-byte alignment. +*/ +#ifdef SQLITE_4_BYTE_ALIGNED_MALLOC +# define EIGHT_BYTE_ALIGNMENT(X) ((((uptr)(X) - (uptr)0)&3)==0) +#else +# define EIGHT_BYTE_ALIGNMENT(X) ((((uptr)(X) - (uptr)0)&7)==0) +#endif + +/* +** Disable MMAP on platforms where it is known to not work +*/ +#if defined(__OpenBSD__) || defined(__QNXNTO__) +# undef SQLITE_MAX_MMAP_SIZE +# define SQLITE_MAX_MMAP_SIZE 0 +#endif + +/* +** Default maximum size of memory used by memory-mapped I/O in the VFS +*/ +#ifdef __APPLE__ +# include +#endif +#ifndef SQLITE_MAX_MMAP_SIZE +# if defined(__linux__) \ + || defined(_WIN32) \ + || (defined(__APPLE__) && defined(__MACH__)) \ + || defined(__sun) \ + || defined(__FreeBSD__) \ + || defined(__DragonFly__) +# define SQLITE_MAX_MMAP_SIZE 0x7fff0000 /* 2147418112 */ +# else +# define SQLITE_MAX_MMAP_SIZE 0 +# endif +#endif + +/* +** The default MMAP_SIZE is zero on all platforms. Or, even if a larger +** default MMAP_SIZE is specified at compile-time, make sure that it does +** not exceed the maximum mmap size. +*/ +#ifndef SQLITE_DEFAULT_MMAP_SIZE +# define SQLITE_DEFAULT_MMAP_SIZE 0 +#endif +#if SQLITE_DEFAULT_MMAP_SIZE>SQLITE_MAX_MMAP_SIZE +# undef SQLITE_DEFAULT_MMAP_SIZE +# define SQLITE_DEFAULT_MMAP_SIZE SQLITE_MAX_MMAP_SIZE +#endif + +/* +** TREETRACE_ENABLED will be either 1 or 0 depending on whether or not +** the Abstract Syntax Tree tracing logic is turned on. +*/ +#if !defined(SQLITE_AMALGAMATION) +SQLITE_PRIVATE u32 sqlite3TreeTrace; +#endif +#if defined(SQLITE_DEBUG) \ + && (defined(SQLITE_TEST) || defined(SQLITE_ENABLE_SELECTTRACE) \ + || defined(SQLITE_ENABLE_TREETRACE)) +# define TREETRACE_ENABLED 1 +# define TREETRACE(K,P,S,X) \ + if(sqlite3TreeTrace&(K)) \ + sqlite3DebugPrintf("%u/%d/%p: ",(S)->selId,(P)->addrExplain,(S)),\ + sqlite3DebugPrintf X +#else +# define TREETRACE(K,P,S,X) +# define TREETRACE_ENABLED 0 +#endif + +/* TREETRACE flag meanings: +** +** 0x00000001 Beginning and end of SELECT processing +** 0x00000002 WHERE clause processing +** 0x00000004 Query flattener +** 0x00000008 Result-set wildcard expansion +** 0x00000010 Query name resolution +** 0x00000020 Aggregate analysis +** 0x00000040 Window functions +** 0x00000080 Generated column names +** 0x00000100 Move HAVING terms into WHERE +** 0x00000200 Count-of-view optimization +** 0x00000400 Compound SELECT processing +** 0x00000800 Drop superfluous ORDER BY +** 0x00001000 LEFT JOIN simplifies to JOIN +** 0x00002000 Constant propagation +** 0x00004000 Push-down optimization +** 0x00008000 After all FROM-clause analysis +** 0x00010000 Beginning of DELETE/INSERT/UPDATE processing +** 0x00020000 Transform DISTINCT into GROUP BY +** 0x00040000 SELECT tree dump after all code has been generated +*/ + +/* +** Macros for "wheretrace" +*/ +SQLITE_PRIVATE u32 sqlite3WhereTrace; +#if defined(SQLITE_DEBUG) \ + && (defined(SQLITE_TEST) || defined(SQLITE_ENABLE_WHERETRACE)) +# define WHERETRACE(K,X) if(sqlite3WhereTrace&(K)) sqlite3DebugPrintf X +# define WHERETRACE_ENABLED 1 +#else +# define WHERETRACE(K,X) +#endif + +/* +** Bits for the sqlite3WhereTrace mask: +** +** (---any--) Top-level block structure +** 0x-------F High-level debug messages +** 0x----FFF- More detail +** 0xFFFF---- Low-level debug messages +** +** 0x00000001 Code generation +** 0x00000002 Solver +** 0x00000004 Solver costs +** 0x00000008 WhereLoop inserts +** +** 0x00000010 Display sqlite3_index_info xBestIndex calls +** 0x00000020 Range an equality scan metrics +** 0x00000040 IN operator decisions +** 0x00000080 WhereLoop cost adjustements +** 0x00000100 +** 0x00000200 Covering index decisions +** 0x00000400 OR optimization +** 0x00000800 Index scanner +** 0x00001000 More details associated with code generation +** 0x00002000 +** 0x00004000 Show all WHERE terms at key points +** 0x00008000 Show the full SELECT statement at key places +** +** 0x00010000 Show more detail when printing WHERE terms +** 0x00020000 Show WHERE terms returned from whereScanNext() +*/ + + +/* +** An instance of the following structure is used to store the busy-handler +** callback for a given sqlite handle. +** +** The sqlite.busyHandler member of the sqlite struct contains the busy +** callback for the database handle. Each pager opened via the sqlite +** handle is passed a pointer to sqlite.busyHandler. The busy-handler +** callback is currently invoked only from within pager.c. +*/ +typedef struct BusyHandler BusyHandler; +struct BusyHandler { + int (*xBusyHandler)(void *,int); /* The busy callback */ + void *pBusyArg; /* First arg to busy callback */ + int nBusy; /* Incremented with each busy call */ +}; + +/* +** Name of table that holds the database schema. +** +** The PREFERRED names are used whereever possible. But LEGACY is also +** used for backwards compatibility. +** +** 1. Queries can use either the PREFERRED or the LEGACY names +** 2. The sqlite3_set_authorizer() callback uses the LEGACY name +** 3. The PRAGMA table_list statement uses the PREFERRED name +** +** The LEGACY names are stored in the internal symbol hash table +** in support of (2). Names are translated using sqlite3PreferredTableName() +** for (3). The sqlite3FindTable() function takes care of translating +** names for (1). +** +** Note that "sqlite_temp_schema" can also be called "temp.sqlite_schema". +*/ +#define LEGACY_SCHEMA_TABLE "sqlite_master" +#define LEGACY_TEMP_SCHEMA_TABLE "sqlite_temp_master" +#define PREFERRED_SCHEMA_TABLE "sqlite_schema" +#define PREFERRED_TEMP_SCHEMA_TABLE "sqlite_temp_schema" + + +/* +** The root-page of the schema table. +*/ +#define SCHEMA_ROOT 1 + +/* +** The name of the schema table. The name is different for TEMP. +*/ +#define SCHEMA_TABLE(x) \ + ((!OMIT_TEMPDB)&&(x==1)?LEGACY_TEMP_SCHEMA_TABLE:LEGACY_SCHEMA_TABLE) + +/* +** A convenience macro that returns the number of elements in +** an array. +*/ +#define ArraySize(X) ((int)(sizeof(X)/sizeof(X[0]))) + +/* +** Determine if the argument is a power of two +*/ +#define IsPowerOfTwo(X) (((X)&((X)-1))==0) + +/* +** The following value as a destructor means to use sqlite3DbFree(). +** The sqlite3DbFree() routine requires two parameters instead of the +** one parameter that destructors normally want. So we have to introduce +** this magic value that the code knows to handle differently. Any +** pointer will work here as long as it is distinct from SQLITE_STATIC +** and SQLITE_TRANSIENT. +*/ +#define SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3OomClear) + +/* +** When SQLITE_OMIT_WSD is defined, it means that the target platform does +** not support Writable Static Data (WSD) such as global and static variables. +** All variables must either be on the stack or dynamically allocated from +** the heap. When WSD is unsupported, the variable declarations scattered +** throughout the SQLite code must become constants instead. The SQLITE_WSD +** macro is used for this purpose. And instead of referencing the variable +** directly, we use its constant as a key to lookup the run-time allocated +** buffer that holds real variable. The constant is also the initializer +** for the run-time allocated buffer. +** +** In the usual case where WSD is supported, the SQLITE_WSD and GLOBAL +** macros become no-ops and have zero performance impact. +*/ +#ifdef SQLITE_OMIT_WSD + #define SQLITE_WSD const + #define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v))) + #define sqlite3GlobalConfig GLOBAL(struct Sqlite3Config, sqlite3Config) +SQLITE_API int sqlite3_wsd_init(int N, int J); +SQLITE_API void *sqlite3_wsd_find(void *K, int L); +#else + #define SQLITE_WSD + #define GLOBAL(t,v) v + #define sqlite3GlobalConfig sqlite3Config +#endif + +/* +** The following macros are used to suppress compiler warnings and to +** make it clear to human readers when a function parameter is deliberately +** left unused within the body of a function. This usually happens when +** a function is called via a function pointer. For example the +** implementation of an SQL aggregate step callback may not use the +** parameter indicating the number of arguments passed to the aggregate, +** if it knows that this is enforced elsewhere. +** +** When a function parameter is not used at all within the body of a function, +** it is generally named "NotUsed" or "NotUsed2" to make things even clearer. +** However, these macros may also be used to suppress warnings related to +** parameters that may or may not be used depending on compilation options. +** For example those parameters only used in assert() statements. In these +** cases the parameters are named as per the usual conventions. +*/ +#define UNUSED_PARAMETER(x) (void)(x) +#define UNUSED_PARAMETER2(x,y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y) + +/* +** Forward references to structures +*/ +typedef struct AggInfo AggInfo; +typedef struct AuthContext AuthContext; +typedef struct AutoincInfo AutoincInfo; +typedef struct Bitvec Bitvec; +typedef struct CollSeq CollSeq; +typedef struct Column Column; +typedef struct Cte Cte; +typedef struct CteUse CteUse; +typedef struct Db Db; +typedef struct DbFixer DbFixer; +typedef struct Schema Schema; +typedef struct Expr Expr; +typedef struct ExprList ExprList; +typedef struct FKey FKey; +typedef struct FuncDestructor FuncDestructor; +typedef struct FuncDef FuncDef; +typedef struct FuncDefHash FuncDefHash; +typedef struct IdList IdList; +typedef struct Index Index; +typedef struct IndexedExpr IndexedExpr; +typedef struct IndexSample IndexSample; +typedef struct KeyClass KeyClass; +typedef struct KeyInfo KeyInfo; +typedef struct Lookaside Lookaside; +typedef struct LookasideSlot LookasideSlot; +typedef struct Module Module; +typedef struct NameContext NameContext; +typedef struct OnOrUsing OnOrUsing; +typedef struct Parse Parse; +typedef struct ParseCleanup ParseCleanup; +typedef struct PreUpdate PreUpdate; +typedef struct PrintfArguments PrintfArguments; +typedef struct RenameToken RenameToken; +typedef struct Returning Returning; +typedef struct RowSet RowSet; +typedef struct Savepoint Savepoint; +typedef struct Select Select; +typedef struct SQLiteThread SQLiteThread; +typedef struct SelectDest SelectDest; +typedef struct SrcItem SrcItem; +typedef struct SrcList SrcList; +typedef struct sqlite3_str StrAccum; /* Internal alias for sqlite3_str */ +typedef struct Table Table; +typedef struct TableLock TableLock; +typedef struct Token Token; +typedef struct TreeView TreeView; +typedef struct Trigger Trigger; +typedef struct TriggerPrg TriggerPrg; +typedef struct TriggerStep TriggerStep; +typedef struct UnpackedRecord UnpackedRecord; +typedef struct Upsert Upsert; +typedef struct VTable VTable; +typedef struct VtabCtx VtabCtx; +typedef struct Walker Walker; +typedef struct WhereInfo WhereInfo; +typedef struct Window Window; +typedef struct With With; + + +/* +** The bitmask datatype defined below is used for various optimizations. +** +** Changing this from a 64-bit to a 32-bit type limits the number of +** tables in a join to 32 instead of 64. But it also reduces the size +** of the library by 738 bytes on ix86. +*/ +#ifdef SQLITE_BITMASK_TYPE + typedef SQLITE_BITMASK_TYPE Bitmask; +#else + typedef u64 Bitmask; +#endif + +/* +** The number of bits in a Bitmask. "BMS" means "BitMask Size". +*/ +#define BMS ((int)(sizeof(Bitmask)*8)) + +/* +** A bit in a Bitmask +*/ +#define MASKBIT(n) (((Bitmask)1)<<(n)) +#define MASKBIT64(n) (((u64)1)<<(n)) +#define MASKBIT32(n) (((unsigned int)1)<<(n)) +#define SMASKBIT32(n) ((n)<=31?((unsigned int)1)<<(n):0) +#define ALLBITS ((Bitmask)-1) +#define TOPBIT (((Bitmask)1)<<(BMS-1)) + +/* A VList object records a mapping between parameters/variables/wildcards +** in the SQL statement (such as $abc, @pqr, or :xyz) and the integer +** variable number associated with that parameter. See the format description +** on the sqlite3VListAdd() routine for more information. A VList is really +** just an array of integers. +*/ +typedef int VList; + +/* +** Defer sourcing vdbe.h and btree.h until after the "u8" and +** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque +** pointer types (i.e. FuncDef) defined above. +*/ +/************** Include os.h in the middle of sqliteInt.h ********************/ +/************** Begin file os.h **********************************************/ +/* +** 2001 September 16 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This header file (together with is companion C source-code file +** "os.c") attempt to abstract the underlying operating system so that +** the SQLite library will work on both POSIX and windows systems. +** +** This header file is #include-ed by sqliteInt.h and thus ends up +** being included by every source file. +*/ +#ifndef _SQLITE_OS_H_ +#define _SQLITE_OS_H_ + +/* +** Attempt to automatically detect the operating system and setup the +** necessary pre-processor macros for it. +*/ +/************** Include os_setup.h in the middle of os.h *********************/ +/************** Begin file os_setup.h ****************************************/ +/* +** 2013 November 25 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains pre-processor directives related to operating system +** detection and/or setup. +*/ +#ifndef SQLITE_OS_SETUP_H +#define SQLITE_OS_SETUP_H + +/* +** Figure out if we are dealing with Unix, Windows, or some other operating +** system. +** +** After the following block of preprocess macros, all of +** +** SQLITE_OS_KV +** SQLITE_OS_OTHER +** SQLITE_OS_UNIX +** SQLITE_OS_WIN +** +** will defined to either 1 or 0. One of them will be 1. The others will be 0. +** If none of the macros are initially defined, then select either +** SQLITE_OS_UNIX or SQLITE_OS_WIN depending on the target platform. +** +** If SQLITE_OS_OTHER=1 is specified at compile-time, then the application +** must provide its own VFS implementation together with sqlite3_os_init() +** and sqlite3_os_end() routines. +*/ +#if !defined(SQLITE_OS_KV) && !defined(SQLITE_OS_OTHER) && \ + !defined(SQLITE_OS_UNIX) && !defined(SQLITE_OS_WIN) +# if defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || \ + defined(__MINGW32__) || defined(__BORLANDC__) +# define SQLITE_OS_WIN 1 +# define SQLITE_OS_UNIX 0 +# else +# define SQLITE_OS_WIN 0 +# define SQLITE_OS_UNIX 1 +# endif +#endif +#if SQLITE_OS_OTHER+1>1 +# undef SQLITE_OS_KV +# define SQLITE_OS_KV 0 +# undef SQLITE_OS_UNIX +# define SQLITE_OS_UNIX 0 +# undef SQLITE_OS_WIN +# define SQLITE_OS_WIN 0 +#endif +#if SQLITE_OS_KV+1>1 +# undef SQLITE_OS_OTHER +# define SQLITE_OS_OTHER 0 +# undef SQLITE_OS_UNIX +# define SQLITE_OS_UNIX 0 +# undef SQLITE_OS_WIN +# define SQLITE_OS_WIN 0 +# define SQLITE_OMIT_LOAD_EXTENSION 1 +# define SQLITE_OMIT_WAL 1 +# define SQLITE_OMIT_DEPRECATED 1 +# undef SQLITE_TEMP_STORE +# define SQLITE_TEMP_STORE 3 /* Always use memory for temporary storage */ +# define SQLITE_DQS 0 +# define SQLITE_OMIT_SHARED_CACHE 1 +# define SQLITE_OMIT_AUTOINIT 1 +#endif +#if SQLITE_OS_UNIX+1>1 +# undef SQLITE_OS_KV +# define SQLITE_OS_KV 0 +# undef SQLITE_OS_OTHER +# define SQLITE_OS_OTHER 0 +# undef SQLITE_OS_WIN +# define SQLITE_OS_WIN 0 +#endif +#if SQLITE_OS_WIN+1>1 +# undef SQLITE_OS_KV +# define SQLITE_OS_KV 0 +# undef SQLITE_OS_OTHER +# define SQLITE_OS_OTHER 0 +# undef SQLITE_OS_UNIX +# define SQLITE_OS_UNIX 0 +#endif + + +#endif /* SQLITE_OS_SETUP_H */ + +/************** End of os_setup.h ********************************************/ +/************** Continuing where we left off in os.h *************************/ + +/* If the SET_FULLSYNC macro is not defined above, then make it +** a no-op +*/ +#ifndef SET_FULLSYNC +# define SET_FULLSYNC(x,y) +#endif + +/* Maximum pathname length. Note: FILENAME_MAX defined by stdio.h +*/ +#ifndef SQLITE_MAX_PATHLEN +# define SQLITE_MAX_PATHLEN FILENAME_MAX +#endif + +/* Maximum number of symlinks that will be resolved while trying to +** expand a filename in xFullPathname() in the VFS. +*/ +#ifndef SQLITE_MAX_SYMLINK +# define SQLITE_MAX_SYMLINK 200 +#endif + +/* +** The default size of a disk sector +*/ +#ifndef SQLITE_DEFAULT_SECTOR_SIZE +# define SQLITE_DEFAULT_SECTOR_SIZE 4096 +#endif + +/* +** Temporary files are named starting with this prefix followed by 16 random +** alphanumeric characters, and no file extension. They are stored in the +** OS's standard temporary file directory, and are deleted prior to exit. +** If sqlite is being embedded in another program, you may wish to change the +** prefix to reflect your program's name, so that if your program exits +** prematurely, old temporary files can be easily identified. This can be done +** using -DSQLITE_TEMP_FILE_PREFIX=myprefix_ on the compiler command line. +** +** 2006-10-31: The default prefix used to be "sqlite_". But then +** Mcafee started using SQLite in their anti-virus product and it +** started putting files with the "sqlite" name in the c:/temp folder. +** This annoyed many windows users. Those users would then do a +** Google search for "sqlite", find the telephone numbers of the +** developers and call to wake them up at night and complain. +** For this reason, the default name prefix is changed to be "sqlite" +** spelled backwards. So the temp files are still identified, but +** anybody smart enough to figure out the code is also likely smart +** enough to know that calling the developer will not help get rid +** of the file. +*/ +#ifndef SQLITE_TEMP_FILE_PREFIX +# define SQLITE_TEMP_FILE_PREFIX "etilqs_" +#endif + +/* +** The following values may be passed as the second argument to +** sqlite3OsLock(). The various locks exhibit the following semantics: +** +** SHARED: Any number of processes may hold a SHARED lock simultaneously. +** RESERVED: A single process may hold a RESERVED lock on a file at +** any time. Other processes may hold and obtain new SHARED locks. +** PENDING: A single process may hold a PENDING lock on a file at +** any one time. Existing SHARED locks may persist, but no new +** SHARED locks may be obtained by other processes. +** EXCLUSIVE: An EXCLUSIVE lock precludes all other locks. +** +** PENDING_LOCK may not be passed directly to sqlite3OsLock(). Instead, a +** process that requests an EXCLUSIVE lock may actually obtain a PENDING +** lock. This can be upgraded to an EXCLUSIVE lock by a subsequent call to +** sqlite3OsLock(). +*/ +#define NO_LOCK 0 +#define SHARED_LOCK 1 +#define RESERVED_LOCK 2 +#define PENDING_LOCK 3 +#define EXCLUSIVE_LOCK 4 + +/* +** File Locking Notes: (Mostly about windows but also some info for Unix) +** +** We cannot use LockFileEx() or UnlockFileEx() on Win95/98/ME because +** those functions are not available. So we use only LockFile() and +** UnlockFile(). +** +** LockFile() prevents not just writing but also reading by other processes. +** A SHARED_LOCK is obtained by locking a single randomly-chosen +** byte out of a specific range of bytes. The lock byte is obtained at +** random so two separate readers can probably access the file at the +** same time, unless they are unlucky and choose the same lock byte. +** An EXCLUSIVE_LOCK is obtained by locking all bytes in the range. +** There can only be one writer. A RESERVED_LOCK is obtained by locking +** a single byte of the file that is designated as the reserved lock byte. +** A PENDING_LOCK is obtained by locking a designated byte different from +** the RESERVED_LOCK byte. +** +** On WinNT/2K/XP systems, LockFileEx() and UnlockFileEx() are available, +** which means we can use reader/writer locks. When reader/writer locks +** are used, the lock is placed on the same range of bytes that is used +** for probabilistic locking in Win95/98/ME. Hence, the locking scheme +** will support two or more Win95 readers or two or more WinNT readers. +** But a single Win95 reader will lock out all WinNT readers and a single +** WinNT reader will lock out all other Win95 readers. +** +** The following #defines specify the range of bytes used for locking. +** SHARED_SIZE is the number of bytes available in the pool from which +** a random byte is selected for a shared lock. The pool of bytes for +** shared locks begins at SHARED_FIRST. +** +** The same locking strategy and +** byte ranges are used for Unix. This leaves open the possibility of having +** clients on win95, winNT, and unix all talking to the same shared file +** and all locking correctly. To do so would require that samba (or whatever +** tool is being used for file sharing) implements locks correctly between +** windows and unix. I'm guessing that isn't likely to happen, but by +** using the same locking range we are at least open to the possibility. +** +** Locking in windows is manditory. For this reason, we cannot store +** actual data in the bytes used for locking. The pager never allocates +** the pages involved in locking therefore. SHARED_SIZE is selected so +** that all locks will fit on a single page even at the minimum page size. +** PENDING_BYTE defines the beginning of the locks. By default PENDING_BYTE +** is set high so that we don't have to allocate an unused page except +** for very large databases. But one should test the page skipping logic +** by setting PENDING_BYTE low and running the entire regression suite. +** +** Changing the value of PENDING_BYTE results in a subtly incompatible +** file format. Depending on how it is changed, you might not notice +** the incompatibility right away, even running a full regression test. +** The default location of PENDING_BYTE is the first byte past the +** 1GB boundary. +** +*/ +#ifdef SQLITE_OMIT_WSD +# define PENDING_BYTE (0x40000000) +#else +# define PENDING_BYTE sqlite3PendingByte +#endif +#define RESERVED_BYTE (PENDING_BYTE+1) +#define SHARED_FIRST (PENDING_BYTE+2) +#define SHARED_SIZE 510 + +/* +** Wrapper around OS specific sqlite3_os_init() function. +*/ +SQLITE_PRIVATE int sqlite3OsInit(void); + +/* +** Functions for accessing sqlite3_file methods +*/ +SQLITE_PRIVATE void sqlite3OsClose(sqlite3_file*); +SQLITE_PRIVATE int sqlite3OsRead(sqlite3_file*, void*, int amt, i64 offset); +SQLITE_PRIVATE int sqlite3OsWrite(sqlite3_file*, const void*, int amt, i64 offset); +SQLITE_PRIVATE int sqlite3OsTruncate(sqlite3_file*, i64 size); +SQLITE_PRIVATE int sqlite3OsSync(sqlite3_file*, int); +SQLITE_PRIVATE int sqlite3OsFileSize(sqlite3_file*, i64 *pSize); +SQLITE_PRIVATE int sqlite3OsLock(sqlite3_file*, int); +SQLITE_PRIVATE int sqlite3OsUnlock(sqlite3_file*, int); +SQLITE_PRIVATE int sqlite3OsCheckReservedLock(sqlite3_file *id, int *pResOut); +SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file*,int,void*); +SQLITE_PRIVATE void sqlite3OsFileControlHint(sqlite3_file*,int,void*); +#define SQLITE_FCNTL_DB_UNCHANGED 0xca093fa0 +SQLITE_PRIVATE int sqlite3OsSectorSize(sqlite3_file *id); +SQLITE_PRIVATE int sqlite3OsDeviceCharacteristics(sqlite3_file *id); +#ifndef SQLITE_OMIT_WAL +SQLITE_PRIVATE int sqlite3OsShmMap(sqlite3_file *,int,int,int,void volatile **); +SQLITE_PRIVATE int sqlite3OsShmLock(sqlite3_file *id, int, int, int); +SQLITE_PRIVATE void sqlite3OsShmBarrier(sqlite3_file *id); +SQLITE_PRIVATE int sqlite3OsShmUnmap(sqlite3_file *id, int); +#endif /* SQLITE_OMIT_WAL */ +SQLITE_PRIVATE int sqlite3OsFetch(sqlite3_file *id, i64, int, void **); +SQLITE_PRIVATE int sqlite3OsUnfetch(sqlite3_file *, i64, void *); + + +/* +** Functions for accessing sqlite3_vfs methods +*/ +SQLITE_PRIVATE int sqlite3OsOpen(sqlite3_vfs *, const char *, sqlite3_file*, int, int *); +SQLITE_PRIVATE int sqlite3OsDelete(sqlite3_vfs *, const char *, int); +SQLITE_PRIVATE int sqlite3OsAccess(sqlite3_vfs *, const char *, int, int *pResOut); +SQLITE_PRIVATE int sqlite3OsFullPathname(sqlite3_vfs *, const char *, int, char *); +#ifndef SQLITE_OMIT_LOAD_EXTENSION +SQLITE_PRIVATE void *sqlite3OsDlOpen(sqlite3_vfs *, const char *); +SQLITE_PRIVATE void sqlite3OsDlError(sqlite3_vfs *, int, char *); +SQLITE_PRIVATE void (*sqlite3OsDlSym(sqlite3_vfs *, void *, const char *))(void); +SQLITE_PRIVATE void sqlite3OsDlClose(sqlite3_vfs *, void *); +#endif /* SQLITE_OMIT_LOAD_EXTENSION */ +SQLITE_PRIVATE int sqlite3OsRandomness(sqlite3_vfs *, int, char *); +SQLITE_PRIVATE int sqlite3OsSleep(sqlite3_vfs *, int); +SQLITE_PRIVATE int sqlite3OsGetLastError(sqlite3_vfs*); +SQLITE_PRIVATE int sqlite3OsCurrentTimeInt64(sqlite3_vfs *, sqlite3_int64*); + +/* +** Convenience functions for opening and closing files using +** sqlite3_malloc() to obtain space for the file-handle structure. +*/ +SQLITE_PRIVATE int sqlite3OsOpenMalloc(sqlite3_vfs *, const char *, sqlite3_file **, int,int*); +SQLITE_PRIVATE void sqlite3OsCloseFree(sqlite3_file *); + +#endif /* _SQLITE_OS_H_ */ + +/************** End of os.h **************************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +/************** Include pager.h in the middle of sqliteInt.h *****************/ +/************** Begin file pager.h *******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This header file defines the interface that the sqlite page cache +** subsystem. The page cache subsystem reads and writes a file a page +** at a time and provides a journal for rollback. +*/ + +#ifndef SQLITE_PAGER_H +#define SQLITE_PAGER_H + +/* +** Default maximum size for persistent journal files. A negative +** value means no limit. This value may be overridden using the +** sqlite3PagerJournalSizeLimit() API. See also "PRAGMA journal_size_limit". +*/ +#ifndef SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT + #define SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT -1 +#endif + +/* +** The type used to represent a page number. The first page in a file +** is called page 1. 0 is used to represent "not a page". +*/ +typedef u32 Pgno; + +/* +** Each open file is managed by a separate instance of the "Pager" structure. +*/ +typedef struct Pager Pager; + +/* +** Handle type for pages. +*/ +typedef struct PgHdr DbPage; + +/* +** Page number PAGER_SJ_PGNO is never used in an SQLite database (it is +** reserved for working around a windows/posix incompatibility). It is +** used in the journal to signify that the remainder of the journal file +** is devoted to storing a super-journal name - there are no more pages to +** roll back. See comments for function writeSuperJournal() in pager.c +** for details. +*/ +#define PAGER_SJ_PGNO_COMPUTED(x) ((Pgno)((PENDING_BYTE/((x)->pageSize))+1)) +#define PAGER_SJ_PGNO(x) ((x)->lckPgno) + +/* +** Allowed values for the flags parameter to sqlite3PagerOpen(). +** +** NOTE: These values must match the corresponding BTREE_ values in btree.h. +*/ +#define PAGER_OMIT_JOURNAL 0x0001 /* Do not use a rollback journal */ +#define PAGER_MEMORY 0x0002 /* In-memory database */ + +/* +** Valid values for the second argument to sqlite3PagerLockingMode(). +*/ +#define PAGER_LOCKINGMODE_QUERY -1 +#define PAGER_LOCKINGMODE_NORMAL 0 +#define PAGER_LOCKINGMODE_EXCLUSIVE 1 + +/* +** Numeric constants that encode the journalmode. +** +** The numeric values encoded here (other than PAGER_JOURNALMODE_QUERY) +** are exposed in the API via the "PRAGMA journal_mode" command and +** therefore cannot be changed without a compatibility break. +*/ +#define PAGER_JOURNALMODE_QUERY (-1) /* Query the value of journalmode */ +#define PAGER_JOURNALMODE_DELETE 0 /* Commit by deleting journal file */ +#define PAGER_JOURNALMODE_PERSIST 1 /* Commit by zeroing journal header */ +#define PAGER_JOURNALMODE_OFF 2 /* Journal omitted. */ +#define PAGER_JOURNALMODE_TRUNCATE 3 /* Commit by truncating journal */ +#define PAGER_JOURNALMODE_MEMORY 4 /* In-memory journal file */ +#define PAGER_JOURNALMODE_WAL 5 /* Use write-ahead logging */ + +/* +** Flags that make up the mask passed to sqlite3PagerGet(). +*/ +#define PAGER_GET_NOCONTENT 0x01 /* Do not load data from disk */ +#define PAGER_GET_READONLY 0x02 /* Read-only page is acceptable */ + +/* +** Flags for sqlite3PagerSetFlags() +** +** Value constraints (enforced via assert()): +** PAGER_FULLFSYNC == SQLITE_FullFSync +** PAGER_CKPT_FULLFSYNC == SQLITE_CkptFullFSync +** PAGER_CACHE_SPILL == SQLITE_CacheSpill +*/ +#define PAGER_SYNCHRONOUS_OFF 0x01 /* PRAGMA synchronous=OFF */ +#define PAGER_SYNCHRONOUS_NORMAL 0x02 /* PRAGMA synchronous=NORMAL */ +#define PAGER_SYNCHRONOUS_FULL 0x03 /* PRAGMA synchronous=FULL */ +#define PAGER_SYNCHRONOUS_EXTRA 0x04 /* PRAGMA synchronous=EXTRA */ +#define PAGER_SYNCHRONOUS_MASK 0x07 /* Mask for four values above */ +#define PAGER_FULLFSYNC 0x08 /* PRAGMA fullfsync=ON */ +#define PAGER_CKPT_FULLFSYNC 0x10 /* PRAGMA checkpoint_fullfsync=ON */ +#define PAGER_CACHESPILL 0x20 /* PRAGMA cache_spill=ON */ +#define PAGER_FLAGS_MASK 0x38 /* All above except SYNCHRONOUS */ + +/* +** The remainder of this file contains the declarations of the functions +** that make up the Pager sub-system API. See source code comments for +** a detailed description of each routine. +*/ + +/* Open and close a Pager connection. */ +SQLITE_PRIVATE int sqlite3PagerOpen( + sqlite3_vfs*, + Pager **ppPager, + const char*, + int, + int, + int, + void(*)(DbPage*) +); +SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager, sqlite3*); +SQLITE_PRIVATE int sqlite3PagerReadFileheader(Pager*, int, unsigned char*); + +/* Functions used to configure a Pager object. */ +SQLITE_PRIVATE void sqlite3PagerSetBusyHandler(Pager*, int(*)(void *), void *); +SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager*, u32*, int); +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC +SQLITE_PRIVATE void sqlite3PagerAlignReserve(Pager*,Pager*); +#endif +/* END SQLCIPHER */ +SQLITE_PRIVATE Pgno sqlite3PagerMaxPageCount(Pager*, Pgno); +SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager*, int); +SQLITE_PRIVATE int sqlite3PagerSetSpillsize(Pager*, int); +SQLITE_PRIVATE void sqlite3PagerSetMmapLimit(Pager *, sqlite3_int64); +SQLITE_PRIVATE void sqlite3PagerShrink(Pager*); +SQLITE_PRIVATE void sqlite3PagerSetFlags(Pager*,unsigned); +SQLITE_PRIVATE int sqlite3PagerLockingMode(Pager *, int); +SQLITE_PRIVATE int sqlite3PagerSetJournalMode(Pager *, int); +SQLITE_PRIVATE int sqlite3PagerGetJournalMode(Pager*); +SQLITE_PRIVATE int sqlite3PagerOkToChangeJournalMode(Pager*); +SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *, i64); +SQLITE_PRIVATE sqlite3_backup **sqlite3PagerBackupPtr(Pager*); +SQLITE_PRIVATE int sqlite3PagerFlush(Pager*); + +/* Functions used to obtain and release page references. */ +SQLITE_PRIVATE int sqlite3PagerGet(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag); +SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno); +SQLITE_PRIVATE void sqlite3PagerRef(DbPage*); +SQLITE_PRIVATE void sqlite3PagerUnref(DbPage*); +SQLITE_PRIVATE void sqlite3PagerUnrefNotNull(DbPage*); +SQLITE_PRIVATE void sqlite3PagerUnrefPageOne(DbPage*); + +/* Operations on page references. */ +SQLITE_PRIVATE int sqlite3PagerWrite(DbPage*); +SQLITE_PRIVATE void sqlite3PagerDontWrite(DbPage*); +SQLITE_PRIVATE int sqlite3PagerMovepage(Pager*,DbPage*,Pgno,int); +SQLITE_PRIVATE int sqlite3PagerPageRefcount(DbPage*); +SQLITE_PRIVATE void *sqlite3PagerGetData(DbPage *); +SQLITE_PRIVATE void *sqlite3PagerGetExtra(DbPage *); + +/* Functions used to manage pager transactions and savepoints. */ +SQLITE_PRIVATE void sqlite3PagerPagecount(Pager*, int*); +SQLITE_PRIVATE int sqlite3PagerBegin(Pager*, int exFlag, int); +SQLITE_PRIVATE int sqlite3PagerCommitPhaseOne(Pager*,const char *zSuper, int); +SQLITE_PRIVATE int sqlite3PagerExclusiveLock(Pager*); +SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager, const char *zSuper); +SQLITE_PRIVATE int sqlite3PagerCommitPhaseTwo(Pager*); +SQLITE_PRIVATE int sqlite3PagerRollback(Pager*); +SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int n); +SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint); +SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager); + +#ifndef SQLITE_OMIT_WAL +SQLITE_PRIVATE int sqlite3PagerCheckpoint(Pager *pPager, sqlite3*, int, int*, int*); +SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager); +SQLITE_PRIVATE int sqlite3PagerWalCallback(Pager *pPager); +SQLITE_PRIVATE int sqlite3PagerOpenWal(Pager *pPager, int *pisOpen); +SQLITE_PRIVATE int sqlite3PagerCloseWal(Pager *pPager, sqlite3*); +# ifdef SQLITE_ENABLE_SNAPSHOT +SQLITE_PRIVATE int sqlite3PagerSnapshotGet(Pager*, sqlite3_snapshot **ppSnapshot); +SQLITE_PRIVATE int sqlite3PagerSnapshotOpen(Pager*, sqlite3_snapshot *pSnapshot); +SQLITE_PRIVATE int sqlite3PagerSnapshotRecover(Pager *pPager); +SQLITE_PRIVATE int sqlite3PagerSnapshotCheck(Pager *pPager, sqlite3_snapshot *pSnapshot); +SQLITE_PRIVATE void sqlite3PagerSnapshotUnlock(Pager *pPager); +# endif +#endif + +#if !defined(SQLITE_OMIT_WAL) && defined(SQLITE_ENABLE_SETLK_TIMEOUT) +SQLITE_PRIVATE int sqlite3PagerWalWriteLock(Pager*, int); +SQLITE_PRIVATE void sqlite3PagerWalDb(Pager*, sqlite3*); +#else +# define sqlite3PagerWalWriteLock(y,z) SQLITE_OK +# define sqlite3PagerWalDb(x,y) +#endif + +#ifdef SQLITE_DIRECT_OVERFLOW_READ +SQLITE_PRIVATE int sqlite3PagerDirectReadOk(Pager *pPager, Pgno pgno); +#endif + +#ifdef SQLITE_ENABLE_ZIPVFS +SQLITE_PRIVATE int sqlite3PagerWalFramesize(Pager *pPager); +#endif + +/* Functions used to query pager state and configuration. */ +SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager*); +SQLITE_PRIVATE u32 sqlite3PagerDataVersion(Pager*); +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3PagerRefcount(Pager*); +#endif +SQLITE_PRIVATE int sqlite3PagerMemUsed(Pager*); +SQLITE_PRIVATE const char *sqlite3PagerFilename(const Pager*, int); +SQLITE_PRIVATE sqlite3_vfs *sqlite3PagerVfs(Pager*); +SQLITE_PRIVATE sqlite3_file *sqlite3PagerFile(Pager*); +SQLITE_PRIVATE sqlite3_file *sqlite3PagerJrnlFile(Pager*); +SQLITE_PRIVATE const char *sqlite3PagerJournalname(Pager*); +SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager*); +SQLITE_PRIVATE int sqlite3PagerIsMemdb(Pager*); +SQLITE_PRIVATE void sqlite3PagerCacheStat(Pager *, int, int, int *); +SQLITE_PRIVATE void sqlite3PagerClearCache(Pager*); +SQLITE_PRIVATE int sqlite3SectorSize(sqlite3_file *); + +/* Functions used to truncate the database file. */ +SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager*,Pgno); + +SQLITE_PRIVATE void sqlite3PagerRekey(DbPage*, Pgno, u16); + +/* BEGIN SQLCIPHER */ +#if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_WAL) +void *sqlcipherPagerCodec(DbPage *); +#endif +/* END SQLCIPHER */ + +/* Functions to support testing and debugging. */ +#if !defined(NDEBUG) || defined(SQLITE_TEST) +SQLITE_PRIVATE Pgno sqlite3PagerPagenumber(DbPage*); +SQLITE_PRIVATE int sqlite3PagerIswriteable(DbPage*); +#endif +#ifdef SQLITE_TEST +SQLITE_PRIVATE int *sqlite3PagerStats(Pager*); +SQLITE_PRIVATE void sqlite3PagerRefdump(Pager*); + void disable_simulated_io_errors(void); + void enable_simulated_io_errors(void); +#else +# define disable_simulated_io_errors() +# define enable_simulated_io_errors() +#endif + +#endif /* SQLITE_PAGER_H */ + +/************** End of pager.h ***********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +/************** Include btree.h in the middle of sqliteInt.h *****************/ +/************** Begin file btree.h *******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This header file defines the interface that the sqlite B-Tree file +** subsystem. See comments in the source code for a detailed description +** of what each interface routine does. +*/ +#ifndef SQLITE_BTREE_H +#define SQLITE_BTREE_H + +/* TODO: This definition is just included so other modules compile. It +** needs to be revisited. +*/ +#define SQLITE_N_BTREE_META 16 + +/* +** If defined as non-zero, auto-vacuum is enabled by default. Otherwise +** it must be turned on for each database using "PRAGMA auto_vacuum = 1". +*/ +#ifndef SQLITE_DEFAULT_AUTOVACUUM + #define SQLITE_DEFAULT_AUTOVACUUM 0 +#endif + +#define BTREE_AUTOVACUUM_NONE 0 /* Do not do auto-vacuum */ +#define BTREE_AUTOVACUUM_FULL 1 /* Do full auto-vacuum */ +#define BTREE_AUTOVACUUM_INCR 2 /* Incremental vacuum */ + +/* +** Forward declarations of structure +*/ +typedef struct Btree Btree; +typedef struct BtCursor BtCursor; +typedef struct BtShared BtShared; +typedef struct BtreePayload BtreePayload; + + +SQLITE_PRIVATE int sqlite3BtreeOpen( + sqlite3_vfs *pVfs, /* VFS to use with this b-tree */ + const char *zFilename, /* Name of database file to open */ + sqlite3 *db, /* Associated database connection */ + Btree **ppBtree, /* Return open Btree* here */ + int flags, /* Flags */ + int vfsFlags /* Flags passed through to VFS open */ +); + +/* The flags parameter to sqlite3BtreeOpen can be the bitwise or of the +** following values. +** +** NOTE: These values must match the corresponding PAGER_ values in +** pager.h. +*/ +#define BTREE_OMIT_JOURNAL 1 /* Do not create or use a rollback journal */ +#define BTREE_MEMORY 2 /* This is an in-memory DB */ +#define BTREE_SINGLE 4 /* The file contains at most 1 b-tree */ +#define BTREE_UNORDERED 8 /* Use of a hash implementation is OK */ + +SQLITE_PRIVATE int sqlite3BtreeClose(Btree*); +SQLITE_PRIVATE int sqlite3BtreeSetCacheSize(Btree*,int); +SQLITE_PRIVATE int sqlite3BtreeSetSpillSize(Btree*,int); +#if SQLITE_MAX_MMAP_SIZE>0 +SQLITE_PRIVATE int sqlite3BtreeSetMmapLimit(Btree*,sqlite3_int64); +#endif +SQLITE_PRIVATE int sqlite3BtreeSetPagerFlags(Btree*,unsigned); +SQLITE_PRIVATE int sqlite3BtreeSetPageSize(Btree *p, int nPagesize, int nReserve, int eFix); +SQLITE_PRIVATE int sqlite3BtreeGetPageSize(Btree*); +SQLITE_PRIVATE Pgno sqlite3BtreeMaxPageCount(Btree*,Pgno); +SQLITE_PRIVATE Pgno sqlite3BtreeLastPage(Btree*); +SQLITE_PRIVATE int sqlite3BtreeSecureDelete(Btree*,int); +SQLITE_PRIVATE int sqlite3BtreeGetRequestedReserve(Btree*); +SQLITE_PRIVATE int sqlite3BtreeGetReserveNoMutex(Btree *p); +SQLITE_PRIVATE int sqlite3BtreeSetAutoVacuum(Btree *, int); +SQLITE_PRIVATE int sqlite3BtreeGetAutoVacuum(Btree *); +SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree*,int,int*); +SQLITE_PRIVATE int sqlite3BtreeCommitPhaseOne(Btree*, const char*); +SQLITE_PRIVATE int sqlite3BtreeCommitPhaseTwo(Btree*, int); +SQLITE_PRIVATE int sqlite3BtreeCommit(Btree*); +SQLITE_PRIVATE int sqlite3BtreeRollback(Btree*,int,int); +SQLITE_PRIVATE int sqlite3BtreeBeginStmt(Btree*,int); +SQLITE_PRIVATE int sqlite3BtreeCreateTable(Btree*, Pgno*, int flags); +SQLITE_PRIVATE int sqlite3BtreeTxnState(Btree*); +SQLITE_PRIVATE int sqlite3BtreeIsInBackup(Btree*); + +SQLITE_PRIVATE void *sqlite3BtreeSchema(Btree *, int, void(*)(void *)); +SQLITE_PRIVATE int sqlite3BtreeSchemaLocked(Btree *pBtree); +#ifndef SQLITE_OMIT_SHARED_CACHE +SQLITE_PRIVATE int sqlite3BtreeLockTable(Btree *pBtree, int iTab, u8 isWriteLock); +#endif + +/* Savepoints are named, nestable SQL transactions mostly implemented */ +/* in vdbe.c and pager.c See https://sqlite.org/lang_savepoint.html */ +SQLITE_PRIVATE int sqlite3BtreeSavepoint(Btree *, int, int); + +/* "Checkpoint" only refers to WAL. See https://sqlite.org/wal.html#ckpt */ +#ifndef SQLITE_OMIT_WAL +SQLITE_PRIVATE int sqlite3BtreeCheckpoint(Btree*, int, int *, int *); +#endif + +SQLITE_PRIVATE const char *sqlite3BtreeGetFilename(Btree *); +SQLITE_PRIVATE const char *sqlite3BtreeGetJournalname(Btree *); +SQLITE_PRIVATE int sqlite3BtreeCopyFile(Btree *, Btree *); + +SQLITE_PRIVATE int sqlite3BtreeIncrVacuum(Btree *); + +/* The flags parameter to sqlite3BtreeCreateTable can be the bitwise OR +** of the flags shown below. +** +** Every SQLite table must have either BTREE_INTKEY or BTREE_BLOBKEY set. +** With BTREE_INTKEY, the table key is a 64-bit integer and arbitrary data +** is stored in the leaves. (BTREE_INTKEY is used for SQL tables.) With +** BTREE_BLOBKEY, the key is an arbitrary BLOB and no content is stored +** anywhere - the key is the content. (BTREE_BLOBKEY is used for SQL +** indices.) +*/ +#define BTREE_INTKEY 1 /* Table has only 64-bit signed integer keys */ +#define BTREE_BLOBKEY 2 /* Table has keys only - no data */ + +SQLITE_PRIVATE int sqlite3BtreeDropTable(Btree*, int, int*); +SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree*, int, i64*); +SQLITE_PRIVATE int sqlite3BtreeClearTableOfCursor(BtCursor*); +SQLITE_PRIVATE int sqlite3BtreeTripAllCursors(Btree*, int, int); + +SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *pBtree, int idx, u32 *pValue); +SQLITE_PRIVATE int sqlite3BtreeUpdateMeta(Btree*, int idx, u32 value); + +SQLITE_PRIVATE int sqlite3BtreeNewDb(Btree *p); + +/* +** The second parameter to sqlite3BtreeGetMeta or sqlite3BtreeUpdateMeta +** should be one of the following values. The integer values are assigned +** to constants so that the offset of the corresponding field in an +** SQLite database header may be found using the following formula: +** +** offset = 36 + (idx * 4) +** +** For example, the free-page-count field is located at byte offset 36 of +** the database file header. The incr-vacuum-flag field is located at +** byte offset 64 (== 36+4*7). +** +** The BTREE_DATA_VERSION value is not really a value stored in the header. +** It is a read-only number computed by the pager. But we merge it with +** the header value access routines since its access pattern is the same. +** Call it a "virtual meta value". +*/ +#define BTREE_FREE_PAGE_COUNT 0 +#define BTREE_SCHEMA_VERSION 1 +#define BTREE_FILE_FORMAT 2 +#define BTREE_DEFAULT_CACHE_SIZE 3 +#define BTREE_LARGEST_ROOT_PAGE 4 +#define BTREE_TEXT_ENCODING 5 +#define BTREE_USER_VERSION 6 +#define BTREE_INCR_VACUUM 7 +#define BTREE_APPLICATION_ID 8 +#define BTREE_DATA_VERSION 15 /* A virtual meta-value */ + +/* +** Kinds of hints that can be passed into the sqlite3BtreeCursorHint() +** interface. +** +** BTREE_HINT_RANGE (arguments: Expr*, Mem*) +** +** The first argument is an Expr* (which is guaranteed to be constant for +** the lifetime of the cursor) that defines constraints on which rows +** might be fetched with this cursor. The Expr* tree may contain +** TK_REGISTER nodes that refer to values stored in the array of registers +** passed as the second parameter. In other words, if Expr.op==TK_REGISTER +** then the value of the node is the value in Mem[pExpr.iTable]. Any +** TK_COLUMN node in the expression tree refers to the Expr.iColumn-th +** column of the b-tree of the cursor. The Expr tree will not contain +** any function calls nor subqueries nor references to b-trees other than +** the cursor being hinted. +** +** The design of the _RANGE hint is aid b-tree implementations that try +** to prefetch content from remote machines - to provide those +** implementations with limits on what needs to be prefetched and thereby +** reduce network bandwidth. +** +** Note that BTREE_HINT_FLAGS with BTREE_BULKLOAD is the only hint used by +** standard SQLite. The other hints are provided for extensions that use +** the SQLite parser and code generator but substitute their own storage +** engine. +*/ +#define BTREE_HINT_RANGE 0 /* Range constraints on queries */ + +/* +** Values that may be OR'd together to form the argument to the +** BTREE_HINT_FLAGS hint for sqlite3BtreeCursorHint(): +** +** The BTREE_BULKLOAD flag is set on index cursors when the index is going +** to be filled with content that is already in sorted order. +** +** The BTREE_SEEK_EQ flag is set on cursors that will get OP_SeekGE or +** OP_SeekLE opcodes for a range search, but where the range of entries +** selected will all have the same key. In other words, the cursor will +** be used only for equality key searches. +** +*/ +#define BTREE_BULKLOAD 0x00000001 /* Used to full index in sorted order */ +#define BTREE_SEEK_EQ 0x00000002 /* EQ seeks only - no range seeks */ + +/* +** Flags passed as the third argument to sqlite3BtreeCursor(). +** +** For read-only cursors the wrFlag argument is always zero. For read-write +** cursors it may be set to either (BTREE_WRCSR|BTREE_FORDELETE) or just +** (BTREE_WRCSR). If the BTREE_FORDELETE bit is set, then the cursor will +** only be used by SQLite for the following: +** +** * to seek to and then delete specific entries, and/or +** +** * to read values that will be used to create keys that other +** BTREE_FORDELETE cursors will seek to and delete. +** +** The BTREE_FORDELETE flag is an optimization hint. It is not used by +** by this, the native b-tree engine of SQLite, but it is available to +** alternative storage engines that might be substituted in place of this +** b-tree system. For alternative storage engines in which a delete of +** the main table row automatically deletes corresponding index rows, +** the FORDELETE flag hint allows those alternative storage engines to +** skip a lot of work. Namely: FORDELETE cursors may treat all SEEK +** and DELETE operations as no-ops, and any READ operation against a +** FORDELETE cursor may return a null row: 0x01 0x00. +*/ +#define BTREE_WRCSR 0x00000004 /* read-write cursor */ +#define BTREE_FORDELETE 0x00000008 /* Cursor is for seek/delete only */ + +SQLITE_PRIVATE int sqlite3BtreeCursor( + Btree*, /* BTree containing table to open */ + Pgno iTable, /* Index of root page */ + int wrFlag, /* 1 for writing. 0 for read-only */ + struct KeyInfo*, /* First argument to compare function */ + BtCursor *pCursor /* Space to write cursor structure */ +); +SQLITE_PRIVATE BtCursor *sqlite3BtreeFakeValidCursor(void); +SQLITE_PRIVATE int sqlite3BtreeCursorSize(void); +SQLITE_PRIVATE void sqlite3BtreeCursorZero(BtCursor*); +SQLITE_PRIVATE void sqlite3BtreeCursorHintFlags(BtCursor*, unsigned); +#ifdef SQLITE_ENABLE_CURSOR_HINTS +SQLITE_PRIVATE void sqlite3BtreeCursorHint(BtCursor*, int, ...); +#endif + +SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor*); +SQLITE_PRIVATE int sqlite3BtreeTableMoveto( + BtCursor*, + i64 intKey, + int bias, + int *pRes +); +SQLITE_PRIVATE int sqlite3BtreeIndexMoveto( + BtCursor*, + UnpackedRecord *pUnKey, + int *pRes +); +SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor*); +SQLITE_PRIVATE int sqlite3BtreeCursorRestore(BtCursor*, int*); +SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor*, u8 flags); + +/* Allowed flags for sqlite3BtreeDelete() and sqlite3BtreeInsert() */ +#define BTREE_SAVEPOSITION 0x02 /* Leave cursor pointing at NEXT or PREV */ +#define BTREE_AUXDELETE 0x04 /* not the primary delete operation */ +#define BTREE_APPEND 0x08 /* Insert is likely an append */ +#define BTREE_PREFORMAT 0x80 /* Inserted data is a preformated cell */ + +/* An instance of the BtreePayload object describes the content of a single +** entry in either an index or table btree. +** +** Index btrees (used for indexes and also WITHOUT ROWID tables) contain +** an arbitrary key and no data. These btrees have pKey,nKey set to the +** key and the pData,nData,nZero fields are uninitialized. The aMem,nMem +** fields give an array of Mem objects that are a decomposition of the key. +** The nMem field might be zero, indicating that no decomposition is available. +** +** Table btrees (used for rowid tables) contain an integer rowid used as +** the key and passed in the nKey field. The pKey field is zero. +** pData,nData hold the content of the new entry. nZero extra zero bytes +** are appended to the end of the content when constructing the entry. +** The aMem,nMem fields are uninitialized for table btrees. +** +** Field usage summary: +** +** Table BTrees Index Btrees +** +** pKey always NULL encoded key +** nKey the ROWID length of pKey +** pData data not used +** aMem not used decomposed key value +** nMem not used entries in aMem +** nData length of pData not used +** nZero extra zeros after pData not used +** +** This object is used to pass information into sqlite3BtreeInsert(). The +** same information used to be passed as five separate parameters. But placing +** the information into this object helps to keep the interface more +** organized and understandable, and it also helps the resulting code to +** run a little faster by using fewer registers for parameter passing. +*/ +struct BtreePayload { + const void *pKey; /* Key content for indexes. NULL for tables */ + sqlite3_int64 nKey; /* Size of pKey for indexes. PRIMARY KEY for tabs */ + const void *pData; /* Data for tables. */ + sqlite3_value *aMem; /* First of nMem value in the unpacked pKey */ + u16 nMem; /* Number of aMem[] value. Might be zero */ + int nData; /* Size of pData. 0 if none. */ + int nZero; /* Extra zero data appended after pData,nData */ +}; + +SQLITE_PRIVATE int sqlite3BtreeInsert(BtCursor*, const BtreePayload *pPayload, + int flags, int seekResult); +SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor*, int *pRes); +SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor*, int *pRes); +SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor*, int flags); +SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor*); +SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor*, int flags); +SQLITE_PRIVATE i64 sqlite3BtreeIntegerKey(BtCursor*); +SQLITE_PRIVATE void sqlite3BtreeCursorPin(BtCursor*); +SQLITE_PRIVATE void sqlite3BtreeCursorUnpin(BtCursor*); +#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC +SQLITE_PRIVATE i64 sqlite3BtreeOffset(BtCursor*); +#endif +SQLITE_PRIVATE int sqlite3BtreePayload(BtCursor*, u32 offset, u32 amt, void*); +SQLITE_PRIVATE const void *sqlite3BtreePayloadFetch(BtCursor*, u32 *pAmt); +SQLITE_PRIVATE u32 sqlite3BtreePayloadSize(BtCursor*); +SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeMaxRecordSize(BtCursor*); + +SQLITE_PRIVATE int sqlite3BtreeIntegrityCheck( + sqlite3 *db, /* Database connection that is running the check */ + Btree *p, /* The btree to be checked */ + Pgno *aRoot, /* An array of root pages numbers for individual trees */ + int nRoot, /* Number of entries in aRoot[] */ + int mxErr, /* Stop reporting errors after this many */ + int *pnErr, /* OUT: Write number of errors seen to this variable */ + char **pzOut /* OUT: Write the error message string here */ +); +SQLITE_PRIVATE struct Pager *sqlite3BtreePager(Btree*); +SQLITE_PRIVATE i64 sqlite3BtreeRowCountEst(BtCursor*); + +#ifndef SQLITE_OMIT_INCRBLOB +SQLITE_PRIVATE int sqlite3BtreePayloadChecked(BtCursor*, u32 offset, u32 amt, void*); +SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor*, u32 offset, u32 amt, void*); +SQLITE_PRIVATE void sqlite3BtreeIncrblobCursor(BtCursor *); +#endif +SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *); +SQLITE_PRIVATE int sqlite3BtreeSetVersion(Btree *pBt, int iVersion); +SQLITE_PRIVATE int sqlite3BtreeCursorHasHint(BtCursor*, unsigned int mask); +SQLITE_PRIVATE int sqlite3BtreeIsReadonly(Btree *pBt); +SQLITE_PRIVATE int sqlite3HeaderSizeBtree(void); + +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE sqlite3_uint64 sqlite3BtreeSeekCount(Btree*); +#else +# define sqlite3BtreeSeekCount(X) 0 +#endif + +#ifndef NDEBUG +SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor*); +#endif +SQLITE_PRIVATE int sqlite3BtreeCursorIsValidNN(BtCursor*); + +SQLITE_PRIVATE int sqlite3BtreeCount(sqlite3*, BtCursor*, i64*); + +#ifdef SQLITE_TEST +SQLITE_PRIVATE int sqlite3BtreeCursorInfo(BtCursor*, int*, int); +SQLITE_PRIVATE void sqlite3BtreeCursorList(Btree*); +#endif + +#ifndef SQLITE_OMIT_WAL +SQLITE_PRIVATE int sqlite3BtreeCheckpoint(Btree*, int, int *, int *); +#endif + +SQLITE_PRIVATE int sqlite3BtreeTransferRow(BtCursor*, BtCursor*, i64); + +SQLITE_PRIVATE void sqlite3BtreeClearCache(Btree*); + +/* +** If we are not using shared cache, then there is no need to +** use mutexes to access the BtShared structures. So make the +** Enter and Leave procedures no-ops. +*/ +#ifndef SQLITE_OMIT_SHARED_CACHE +SQLITE_PRIVATE void sqlite3BtreeEnter(Btree*); +SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3*); +SQLITE_PRIVATE int sqlite3BtreeSharable(Btree*); +SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor*); +SQLITE_PRIVATE int sqlite3BtreeConnectionCount(Btree*); +#else +# define sqlite3BtreeEnter(X) +# define sqlite3BtreeEnterAll(X) +# define sqlite3BtreeSharable(X) 0 +# define sqlite3BtreeEnterCursor(X) +# define sqlite3BtreeConnectionCount(X) 1 +#endif + +#if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE +SQLITE_PRIVATE void sqlite3BtreeLeave(Btree*); +SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor*); +SQLITE_PRIVATE void sqlite3BtreeLeaveAll(sqlite3*); +#ifndef NDEBUG + /* These routines are used inside assert() statements only. */ +SQLITE_PRIVATE int sqlite3BtreeHoldsMutex(Btree*); +SQLITE_PRIVATE int sqlite3BtreeHoldsAllMutexes(sqlite3*); +SQLITE_PRIVATE int sqlite3SchemaMutexHeld(sqlite3*,int,Schema*); +#endif +#else + +# define sqlite3BtreeLeave(X) +# define sqlite3BtreeLeaveCursor(X) +# define sqlite3BtreeLeaveAll(X) + +# define sqlite3BtreeHoldsMutex(X) 1 +# define sqlite3BtreeHoldsAllMutexes(X) 1 +# define sqlite3SchemaMutexHeld(X,Y,Z) 1 +#endif + + +#endif /* SQLITE_BTREE_H */ + +/************** End of btree.h ***********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +/************** Include vdbe.h in the middle of sqliteInt.h ******************/ +/************** Begin file vdbe.h ********************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** Header file for the Virtual DataBase Engine (VDBE) +** +** This header defines the interface to the virtual database engine +** or VDBE. The VDBE implements an abstract machine that runs a +** simple program to access and modify the underlying database. +*/ +#ifndef SQLITE_VDBE_H +#define SQLITE_VDBE_H +/* #include */ + +/* +** A single VDBE is an opaque structure named "Vdbe". Only routines +** in the source file sqliteVdbe.c are allowed to see the insides +** of this structure. +*/ +typedef struct Vdbe Vdbe; + +/* +** The names of the following types declared in vdbeInt.h are required +** for the VdbeOp definition. +*/ +typedef struct sqlite3_value Mem; +typedef struct SubProgram SubProgram; + +/* +** A single instruction of the virtual machine has an opcode +** and as many as three operands. The instruction is recorded +** as an instance of the following structure: +*/ +struct VdbeOp { + u8 opcode; /* What operation to perform */ + signed char p4type; /* One of the P4_xxx constants for p4 */ + u16 p5; /* Fifth parameter is an unsigned 16-bit integer */ + int p1; /* First operand */ + int p2; /* Second parameter (often the jump destination) */ + int p3; /* The third parameter */ + union p4union { /* fourth parameter */ + int i; /* Integer value if p4type==P4_INT32 */ + void *p; /* Generic pointer */ + char *z; /* Pointer to data for string (char array) types */ + i64 *pI64; /* Used when p4type is P4_INT64 */ + double *pReal; /* Used when p4type is P4_REAL */ + FuncDef *pFunc; /* Used when p4type is P4_FUNCDEF */ + sqlite3_context *pCtx; /* Used when p4type is P4_FUNCCTX */ + CollSeq *pColl; /* Used when p4type is P4_COLLSEQ */ + Mem *pMem; /* Used when p4type is P4_MEM */ + VTable *pVtab; /* Used when p4type is P4_VTAB */ + KeyInfo *pKeyInfo; /* Used when p4type is P4_KEYINFO */ + u32 *ai; /* Used when p4type is P4_INTARRAY */ + SubProgram *pProgram; /* Used when p4type is P4_SUBPROGRAM */ + Table *pTab; /* Used when p4type is P4_TABLE */ +#ifdef SQLITE_ENABLE_CURSOR_HINTS + Expr *pExpr; /* Used when p4type is P4_EXPR */ +#endif + } p4; +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + char *zComment; /* Comment to improve readability */ +#endif +#ifdef SQLITE_VDBE_COVERAGE + u32 iSrcLine; /* Source-code line that generated this opcode + ** with flags in the upper 8 bits */ +#endif +#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || defined(VDBE_PROFILE) + u64 nExec; + u64 nCycle; +#endif +}; +typedef struct VdbeOp VdbeOp; + + +/* +** A sub-routine used to implement a trigger program. +*/ +struct SubProgram { + VdbeOp *aOp; /* Array of opcodes for sub-program */ + int nOp; /* Elements in aOp[] */ + int nMem; /* Number of memory cells required */ + int nCsr; /* Number of cursors required */ + u8 *aOnce; /* Array of OP_Once flags */ + void *token; /* id that may be used to recursive triggers */ + SubProgram *pNext; /* Next sub-program already visited */ +}; + +/* +** A smaller version of VdbeOp used for the VdbeAddOpList() function because +** it takes up less space. +*/ +struct VdbeOpList { + u8 opcode; /* What operation to perform */ + signed char p1; /* First operand */ + signed char p2; /* Second parameter (often the jump destination) */ + signed char p3; /* Third parameter */ +}; +typedef struct VdbeOpList VdbeOpList; + +/* +** Allowed values of VdbeOp.p4type +*/ +#define P4_NOTUSED 0 /* The P4 parameter is not used */ +#define P4_TRANSIENT 0 /* P4 is a pointer to a transient string */ +#define P4_STATIC (-1) /* Pointer to a static string */ +#define P4_COLLSEQ (-2) /* P4 is a pointer to a CollSeq structure */ +#define P4_INT32 (-3) /* P4 is a 32-bit signed integer */ +#define P4_SUBPROGRAM (-4) /* P4 is a pointer to a SubProgram structure */ +#define P4_TABLE (-5) /* P4 is a pointer to a Table structure */ +/* Above do not own any resources. Must free those below */ +#define P4_FREE_IF_LE (-6) +#define P4_DYNAMIC (-6) /* Pointer to memory from sqliteMalloc() */ +#define P4_FUNCDEF (-7) /* P4 is a pointer to a FuncDef structure */ +#define P4_KEYINFO (-8) /* P4 is a pointer to a KeyInfo structure */ +#define P4_EXPR (-9) /* P4 is a pointer to an Expr tree */ +#define P4_MEM (-10) /* P4 is a pointer to a Mem* structure */ +#define P4_VTAB (-11) /* P4 is a pointer to an sqlite3_vtab structure */ +#define P4_REAL (-12) /* P4 is a 64-bit floating point value */ +#define P4_INT64 (-13) /* P4 is a 64-bit signed integer */ +#define P4_INTARRAY (-14) /* P4 is a vector of 32-bit integers */ +#define P4_FUNCCTX (-15) /* P4 is a pointer to an sqlite3_context object */ + +/* Error message codes for OP_Halt */ +#define P5_ConstraintNotNull 1 +#define P5_ConstraintUnique 2 +#define P5_ConstraintCheck 3 +#define P5_ConstraintFK 4 + +/* +** The Vdbe.aColName array contains 5n Mem structures, where n is the +** number of columns of data returned by the statement. +*/ +#define COLNAME_NAME 0 +#define COLNAME_DECLTYPE 1 +#define COLNAME_DATABASE 2 +#define COLNAME_TABLE 3 +#define COLNAME_COLUMN 4 +#ifdef SQLITE_ENABLE_COLUMN_METADATA +# define COLNAME_N 5 /* Number of COLNAME_xxx symbols */ +#else +# ifdef SQLITE_OMIT_DECLTYPE +# define COLNAME_N 1 /* Store only the name */ +# else +# define COLNAME_N 2 /* Store the name and decltype */ +# endif +#endif + +/* +** The following macro converts a label returned by sqlite3VdbeMakeLabel() +** into an index into the Parse.aLabel[] array that contains the resolved +** address of that label. +*/ +#define ADDR(X) (~(X)) + +/* +** The makefile scans the vdbe.c source file and creates the "opcodes.h" +** header file that defines a number for each opcode used by the VDBE. +*/ +/************** Include opcodes.h in the middle of vdbe.h ********************/ +/************** Begin file opcodes.h *****************************************/ +/* Automatically generated. Do not edit */ +/* See the tool/mkopcodeh.tcl script for details */ +#define OP_Savepoint 0 +#define OP_AutoCommit 1 +#define OP_Transaction 2 +#define OP_Checkpoint 3 +#define OP_JournalMode 4 +#define OP_Vacuum 5 +#define OP_VFilter 6 /* jump, synopsis: iplan=r[P3] zplan='P4' */ +#define OP_VUpdate 7 /* synopsis: data=r[P3@P2] */ +#define OP_Init 8 /* jump, synopsis: Start at P2 */ +#define OP_Goto 9 /* jump */ +#define OP_Gosub 10 /* jump */ +#define OP_InitCoroutine 11 /* jump */ +#define OP_Yield 12 /* jump */ +#define OP_MustBeInt 13 /* jump */ +#define OP_Jump 14 /* jump */ +#define OP_Once 15 /* jump */ +#define OP_If 16 /* jump */ +#define OP_IfNot 17 /* jump */ +#define OP_IsType 18 /* jump, synopsis: if typeof(P1.P3) in P5 goto P2 */ +#define OP_Not 19 /* same as TK_NOT, synopsis: r[P2]= !r[P1] */ +#define OP_IfNullRow 20 /* jump, synopsis: if P1.nullRow then r[P3]=NULL, goto P2 */ +#define OP_SeekLT 21 /* jump, synopsis: key=r[P3@P4] */ +#define OP_SeekLE 22 /* jump, synopsis: key=r[P3@P4] */ +#define OP_SeekGE 23 /* jump, synopsis: key=r[P3@P4] */ +#define OP_SeekGT 24 /* jump, synopsis: key=r[P3@P4] */ +#define OP_IfNotOpen 25 /* jump, synopsis: if( !csr[P1] ) goto P2 */ +#define OP_IfNoHope 26 /* jump, synopsis: key=r[P3@P4] */ +#define OP_NoConflict 27 /* jump, synopsis: key=r[P3@P4] */ +#define OP_NotFound 28 /* jump, synopsis: key=r[P3@P4] */ +#define OP_Found 29 /* jump, synopsis: key=r[P3@P4] */ +#define OP_SeekRowid 30 /* jump, synopsis: intkey=r[P3] */ +#define OP_NotExists 31 /* jump, synopsis: intkey=r[P3] */ +#define OP_Last 32 /* jump */ +#define OP_IfSmaller 33 /* jump */ +#define OP_SorterSort 34 /* jump */ +#define OP_Sort 35 /* jump */ +#define OP_Rewind 36 /* jump */ +#define OP_SorterNext 37 /* jump */ +#define OP_Prev 38 /* jump */ +#define OP_Next 39 /* jump */ +#define OP_IdxLE 40 /* jump, synopsis: key=r[P3@P4] */ +#define OP_IdxGT 41 /* jump, synopsis: key=r[P3@P4] */ +#define OP_IdxLT 42 /* jump, synopsis: key=r[P3@P4] */ +#define OP_Or 43 /* same as TK_OR, synopsis: r[P3]=(r[P1] || r[P2]) */ +#define OP_And 44 /* same as TK_AND, synopsis: r[P3]=(r[P1] && r[P2]) */ +#define OP_IdxGE 45 /* jump, synopsis: key=r[P3@P4] */ +#define OP_RowSetRead 46 /* jump, synopsis: r[P3]=rowset(P1) */ +#define OP_RowSetTest 47 /* jump, synopsis: if r[P3] in rowset(P1) goto P2 */ +#define OP_Program 48 /* jump */ +#define OP_FkIfZero 49 /* jump, synopsis: if fkctr[P1]==0 goto P2 */ +#define OP_IsNull 50 /* jump, same as TK_ISNULL, synopsis: if r[P1]==NULL goto P2 */ +#define OP_NotNull 51 /* jump, same as TK_NOTNULL, synopsis: if r[P1]!=NULL goto P2 */ +#define OP_Ne 52 /* jump, same as TK_NE, synopsis: IF r[P3]!=r[P1] */ +#define OP_Eq 53 /* jump, same as TK_EQ, synopsis: IF r[P3]==r[P1] */ +#define OP_Gt 54 /* jump, same as TK_GT, synopsis: IF r[P3]>r[P1] */ +#define OP_Le 55 /* jump, same as TK_LE, synopsis: IF r[P3]<=r[P1] */ +#define OP_Lt 56 /* jump, same as TK_LT, synopsis: IF r[P3]=r[P1] */ +#define OP_ElseEq 58 /* jump, same as TK_ESCAPE */ +#define OP_IfPos 59 /* jump, synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 */ +#define OP_IfNotZero 60 /* jump, synopsis: if r[P1]!=0 then r[P1]--, goto P2 */ +#define OP_DecrJumpZero 61 /* jump, synopsis: if (--r[P1])==0 goto P2 */ +#define OP_IncrVacuum 62 /* jump */ +#define OP_VNext 63 /* jump */ +#define OP_Filter 64 /* jump, synopsis: if key(P3@P4) not in filter(P1) goto P2 */ +#define OP_PureFunc 65 /* synopsis: r[P3]=func(r[P2@NP]) */ +#define OP_Function 66 /* synopsis: r[P3]=func(r[P2@NP]) */ +#define OP_Return 67 +#define OP_EndCoroutine 68 +#define OP_HaltIfNull 69 /* synopsis: if r[P3]=null halt */ +#define OP_Halt 70 +#define OP_Integer 71 /* synopsis: r[P2]=P1 */ +#define OP_Int64 72 /* synopsis: r[P2]=P4 */ +#define OP_String 73 /* synopsis: r[P2]='P4' (len=P1) */ +#define OP_BeginSubrtn 74 /* synopsis: r[P2]=NULL */ +#define OP_Null 75 /* synopsis: r[P2..P3]=NULL */ +#define OP_SoftNull 76 /* synopsis: r[P1]=NULL */ +#define OP_Blob 77 /* synopsis: r[P2]=P4 (len=P1) */ +#define OP_Variable 78 /* synopsis: r[P2]=parameter(P1,P4) */ +#define OP_Move 79 /* synopsis: r[P2@P3]=r[P1@P3] */ +#define OP_Copy 80 /* synopsis: r[P2@P3+1]=r[P1@P3+1] */ +#define OP_SCopy 81 /* synopsis: r[P2]=r[P1] */ +#define OP_IntCopy 82 /* synopsis: r[P2]=r[P1] */ +#define OP_FkCheck 83 +#define OP_ResultRow 84 /* synopsis: output=r[P1@P2] */ +#define OP_CollSeq 85 +#define OP_AddImm 86 /* synopsis: r[P1]=r[P1]+P2 */ +#define OP_RealAffinity 87 +#define OP_Cast 88 /* synopsis: affinity(r[P1]) */ +#define OP_Permutation 89 +#define OP_Compare 90 /* synopsis: r[P1@P3] <-> r[P2@P3] */ +#define OP_IsTrue 91 /* synopsis: r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4 */ +#define OP_ZeroOrNull 92 /* synopsis: r[P2] = 0 OR NULL */ +#define OP_Offset 93 /* synopsis: r[P3] = sqlite_offset(P1) */ +#define OP_Column 94 /* synopsis: r[P3]=PX cursor P1 column P2 */ +#define OP_TypeCheck 95 /* synopsis: typecheck(r[P1@P2]) */ +#define OP_Affinity 96 /* synopsis: affinity(r[P1@P2]) */ +#define OP_MakeRecord 97 /* synopsis: r[P3]=mkrec(r[P1@P2]) */ +#define OP_Count 98 /* synopsis: r[P2]=count() */ +#define OP_ReadCookie 99 +#define OP_SetCookie 100 +#define OP_ReopenIdx 101 /* synopsis: root=P2 iDb=P3 */ +#define OP_BitAnd 102 /* same as TK_BITAND, synopsis: r[P3]=r[P1]&r[P2] */ +#define OP_BitOr 103 /* same as TK_BITOR, synopsis: r[P3]=r[P1]|r[P2] */ +#define OP_ShiftLeft 104 /* same as TK_LSHIFT, synopsis: r[P3]=r[P2]<>r[P1] */ +#define OP_Add 106 /* same as TK_PLUS, synopsis: r[P3]=r[P1]+r[P2] */ +#define OP_Subtract 107 /* same as TK_MINUS, synopsis: r[P3]=r[P2]-r[P1] */ +#define OP_Multiply 108 /* same as TK_STAR, synopsis: r[P3]=r[P1]*r[P2] */ +#define OP_Divide 109 /* same as TK_SLASH, synopsis: r[P3]=r[P2]/r[P1] */ +#define OP_Remainder 110 /* same as TK_REM, synopsis: r[P3]=r[P2]%r[P1] */ +#define OP_Concat 111 /* same as TK_CONCAT, synopsis: r[P3]=r[P2]+r[P1] */ +#define OP_OpenRead 112 /* synopsis: root=P2 iDb=P3 */ +#define OP_OpenWrite 113 /* synopsis: root=P2 iDb=P3 */ +#define OP_BitNot 114 /* same as TK_BITNOT, synopsis: r[P2]= ~r[P1] */ +#define OP_OpenDup 115 +#define OP_OpenAutoindex 116 /* synopsis: nColumn=P2 */ +#define OP_String8 117 /* same as TK_STRING, synopsis: r[P2]='P4' */ +#define OP_OpenEphemeral 118 /* synopsis: nColumn=P2 */ +#define OP_SorterOpen 119 +#define OP_SequenceTest 120 /* synopsis: if( cursor[P1].ctr++ ) pc = P2 */ +#define OP_OpenPseudo 121 /* synopsis: P3 columns in r[P2] */ +#define OP_Close 122 +#define OP_ColumnsUsed 123 +#define OP_SeekScan 124 /* synopsis: Scan-ahead up to P1 rows */ +#define OP_SeekHit 125 /* synopsis: set P2<=seekHit<=P3 */ +#define OP_Sequence 126 /* synopsis: r[P2]=cursor[P1].ctr++ */ +#define OP_NewRowid 127 /* synopsis: r[P2]=rowid */ +#define OP_Insert 128 /* synopsis: intkey=r[P3] data=r[P2] */ +#define OP_RowCell 129 +#define OP_Delete 130 +#define OP_ResetCount 131 +#define OP_SorterCompare 132 /* synopsis: if key(P1)!=trim(r[P3],P4) goto P2 */ +#define OP_SorterData 133 /* synopsis: r[P2]=data */ +#define OP_RowData 134 /* synopsis: r[P2]=data */ +#define OP_Rowid 135 /* synopsis: r[P2]=PX rowid of P1 */ +#define OP_NullRow 136 +#define OP_SeekEnd 137 +#define OP_IdxInsert 138 /* synopsis: key=r[P2] */ +#define OP_SorterInsert 139 /* synopsis: key=r[P2] */ +#define OP_IdxDelete 140 /* synopsis: key=r[P2@P3] */ +#define OP_DeferredSeek 141 /* synopsis: Move P3 to P1.rowid if needed */ +#define OP_IdxRowid 142 /* synopsis: r[P2]=rowid */ +#define OP_FinishSeek 143 +#define OP_Destroy 144 +#define OP_Clear 145 +#define OP_ResetSorter 146 +#define OP_CreateBtree 147 /* synopsis: r[P2]=root iDb=P1 flags=P3 */ +#define OP_SqlExec 148 +#define OP_ParseSchema 149 +#define OP_LoadAnalysis 150 +#define OP_DropTable 151 +#define OP_DropIndex 152 +#define OP_Real 153 /* same as TK_FLOAT, synopsis: r[P2]=P4 */ +#define OP_DropTrigger 154 +#define OP_IntegrityCk 155 +#define OP_RowSetAdd 156 /* synopsis: rowset(P1)=r[P2] */ +#define OP_Param 157 +#define OP_FkCounter 158 /* synopsis: fkctr[P1]+=P2 */ +#define OP_MemMax 159 /* synopsis: r[P1]=max(r[P1],r[P2]) */ +#define OP_OffsetLimit 160 /* synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1) */ +#define OP_AggInverse 161 /* synopsis: accum=r[P3] inverse(r[P2@P5]) */ +#define OP_AggStep 162 /* synopsis: accum=r[P3] step(r[P2@P5]) */ +#define OP_AggStep1 163 /* synopsis: accum=r[P3] step(r[P2@P5]) */ +#define OP_AggValue 164 /* synopsis: r[P3]=value N=P2 */ +#define OP_AggFinal 165 /* synopsis: accum=r[P1] N=P2 */ +#define OP_Expire 166 +#define OP_CursorLock 167 +#define OP_CursorUnlock 168 +#define OP_TableLock 169 /* synopsis: iDb=P1 root=P2 write=P3 */ +#define OP_VBegin 170 +#define OP_VCreate 171 +#define OP_VDestroy 172 +#define OP_VOpen 173 +#define OP_VInitIn 174 /* synopsis: r[P2]=ValueList(P1,P3) */ +#define OP_VColumn 175 /* synopsis: r[P3]=vcolumn(P2) */ +#define OP_VRename 176 +#define OP_Pagecount 177 +#define OP_MaxPgcnt 178 +#define OP_ClrSubtype 179 /* synopsis: r[P1].subtype = 0 */ +#define OP_FilterAdd 180 /* synopsis: filter(P1) += key(P3@P4) */ +#define OP_Trace 181 +#define OP_CursorHint 182 +#define OP_ReleaseReg 183 /* synopsis: release r[P1@P2] mask P3 */ +#define OP_Noop 184 +#define OP_Explain 185 +#define OP_Abortable 186 + +/* Properties such as "out2" or "jump" that are specified in +** comments following the "case" for each opcode in the vdbe.c +** are encoded into bitvectors as follows: +*/ +#define OPFLG_JUMP 0x01 /* jump: P2 holds jmp target */ +#define OPFLG_IN1 0x02 /* in1: P1 is an input */ +#define OPFLG_IN2 0x04 /* in2: P2 is an input */ +#define OPFLG_IN3 0x08 /* in3: P3 is an input */ +#define OPFLG_OUT2 0x10 /* out2: P2 is an output */ +#define OPFLG_OUT3 0x20 /* out3: P3 is an output */ +#define OPFLG_NCYCLE 0x40 /* ncycle:Cycles count against P1 */ +#define OPFLG_INITIALIZER {\ +/* 0 */ 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x41, 0x00,\ +/* 8 */ 0x01, 0x01, 0x01, 0x01, 0x03, 0x03, 0x01, 0x01,\ +/* 16 */ 0x03, 0x03, 0x01, 0x12, 0x01, 0x49, 0x49, 0x49,\ +/* 24 */ 0x49, 0x01, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49,\ +/* 32 */ 0x41, 0x01, 0x01, 0x01, 0x41, 0x01, 0x41, 0x41,\ +/* 40 */ 0x41, 0x41, 0x41, 0x26, 0x26, 0x41, 0x23, 0x0b,\ +/* 48 */ 0x01, 0x01, 0x03, 0x03, 0x0b, 0x0b, 0x0b, 0x0b,\ +/* 56 */ 0x0b, 0x0b, 0x01, 0x03, 0x03, 0x03, 0x01, 0x41,\ +/* 64 */ 0x01, 0x00, 0x00, 0x02, 0x02, 0x08, 0x00, 0x10,\ +/* 72 */ 0x10, 0x10, 0x00, 0x10, 0x00, 0x10, 0x10, 0x00,\ +/* 80 */ 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x02, 0x02,\ +/* 88 */ 0x02, 0x00, 0x00, 0x12, 0x1e, 0x20, 0x40, 0x00,\ +/* 96 */ 0x00, 0x00, 0x10, 0x10, 0x00, 0x40, 0x26, 0x26,\ +/* 104 */ 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,\ +/* 112 */ 0x40, 0x00, 0x12, 0x40, 0x40, 0x10, 0x40, 0x00,\ +/* 120 */ 0x00, 0x00, 0x40, 0x00, 0x40, 0x40, 0x10, 0x10,\ +/* 128 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50,\ +/* 136 */ 0x00, 0x40, 0x04, 0x04, 0x00, 0x40, 0x50, 0x40,\ +/* 144 */ 0x10, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,\ +/* 152 */ 0x00, 0x10, 0x00, 0x00, 0x06, 0x10, 0x00, 0x04,\ +/* 160 */ 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\ +/* 168 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x50, 0x40,\ +/* 176 */ 0x00, 0x10, 0x10, 0x02, 0x00, 0x00, 0x00, 0x00,\ +/* 184 */ 0x00, 0x00, 0x00,} + +/* The resolve3P2Values() routine is able to run faster if it knows +** the value of the largest JUMP opcode. The smaller the maximum +** JUMP opcode the better, so the mkopcodeh.tcl script that +** generated this include file strives to group all JUMP opcodes +** together near the beginning of the list. +*/ +#define SQLITE_MX_JUMP_OPCODE 64 /* Maximum JUMP opcode */ + +/************** End of opcodes.h *********************************************/ +/************** Continuing where we left off in vdbe.h ***********************/ + +/* +** Additional non-public SQLITE_PREPARE_* flags +*/ +#define SQLITE_PREPARE_SAVESQL 0x80 /* Preserve SQL text */ +#define SQLITE_PREPARE_MASK 0x0f /* Mask of public flags */ + +/* +** Prototypes for the VDBE interface. See comments on the implementation +** for a description of what each of these routines does. +*/ +SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(Parse*); +SQLITE_PRIVATE Parse *sqlite3VdbeParser(Vdbe*); +SQLITE_PRIVATE int sqlite3VdbeAddOp0(Vdbe*,int); +SQLITE_PRIVATE int sqlite3VdbeAddOp1(Vdbe*,int,int); +SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe*,int,int,int); +SQLITE_PRIVATE int sqlite3VdbeGoto(Vdbe*,int); +SQLITE_PRIVATE int sqlite3VdbeLoadString(Vdbe*,int,const char*); +SQLITE_PRIVATE void sqlite3VdbeMultiLoad(Vdbe*,int,const char*,...); +SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe*,int,int,int,int); +SQLITE_PRIVATE int sqlite3VdbeAddOp4(Vdbe*,int,int,int,int,const char *zP4,int); +SQLITE_PRIVATE int sqlite3VdbeAddOp4Dup8(Vdbe*,int,int,int,int,const u8*,int); +SQLITE_PRIVATE int sqlite3VdbeAddOp4Int(Vdbe*,int,int,int,int,int); +SQLITE_PRIVATE int sqlite3VdbeAddFunctionCall(Parse*,int,int,int,int,const FuncDef*,int); +SQLITE_PRIVATE void sqlite3VdbeEndCoroutine(Vdbe*,int); +#if defined(SQLITE_DEBUG) && !defined(SQLITE_TEST_REALLOC_STRESS) +SQLITE_PRIVATE void sqlite3VdbeVerifyNoMallocRequired(Vdbe *p, int N); +SQLITE_PRIVATE void sqlite3VdbeVerifyNoResultRow(Vdbe *p); +#else +# define sqlite3VdbeVerifyNoMallocRequired(A,B) +# define sqlite3VdbeVerifyNoResultRow(A) +#endif +#if defined(SQLITE_DEBUG) +SQLITE_PRIVATE void sqlite3VdbeVerifyAbortable(Vdbe *p, int); +SQLITE_PRIVATE void sqlite3VdbeNoJumpsOutsideSubrtn(Vdbe*,int,int,int); +#else +# define sqlite3VdbeVerifyAbortable(A,B) +# define sqlite3VdbeNoJumpsOutsideSubrtn(A,B,C,D) +#endif +SQLITE_PRIVATE VdbeOp *sqlite3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp,int iLineno); +#ifndef SQLITE_OMIT_EXPLAIN +SQLITE_PRIVATE int sqlite3VdbeExplain(Parse*,u8,const char*,...); +SQLITE_PRIVATE void sqlite3VdbeExplainPop(Parse*); +SQLITE_PRIVATE int sqlite3VdbeExplainParent(Parse*); +# define ExplainQueryPlan(P) sqlite3VdbeExplain P +# ifdef SQLITE_ENABLE_STMT_SCANSTATUS +# define ExplainQueryPlan2(V,P) (V = sqlite3VdbeExplain P) +# else +# define ExplainQueryPlan2(V,P) ExplainQueryPlan(P) +# endif +# define ExplainQueryPlanPop(P) sqlite3VdbeExplainPop(P) +# define ExplainQueryPlanParent(P) sqlite3VdbeExplainParent(P) +#else +# define ExplainQueryPlan(P) +# define ExplainQueryPlan2(V,P) +# define ExplainQueryPlanPop(P) +# define ExplainQueryPlanParent(P) 0 +# define sqlite3ExplainBreakpoint(A,B) /*no-op*/ +#endif +#if defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_EXPLAIN) +SQLITE_PRIVATE void sqlite3ExplainBreakpoint(const char*,const char*); +#else +# define sqlite3ExplainBreakpoint(A,B) /*no-op*/ +#endif +SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe*, int, char*, u16); +SQLITE_PRIVATE void sqlite3VdbeChangeOpcode(Vdbe*, int addr, u8); +SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe*, int addr, int P1); +SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe*, int addr, int P2); +SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe*, int addr, int P3); +SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe*, u16 P5); +SQLITE_PRIVATE void sqlite3VdbeTypeofColumn(Vdbe*, int); +SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe*, int addr); +SQLITE_PRIVATE void sqlite3VdbeJumpHereOrPopInst(Vdbe*, int addr); +SQLITE_PRIVATE int sqlite3VdbeChangeToNoop(Vdbe*, int addr); +SQLITE_PRIVATE int sqlite3VdbeDeletePriorOpcode(Vdbe*, u8 op); +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE void sqlite3VdbeReleaseRegisters(Parse*,int addr, int n, u32 mask, int); +#else +# define sqlite3VdbeReleaseRegisters(P,A,N,M,F) +#endif +SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe*, int addr, const char *zP4, int N); +SQLITE_PRIVATE void sqlite3VdbeAppendP4(Vdbe*, void *pP4, int p4type); +SQLITE_PRIVATE void sqlite3VdbeSetP4KeyInfo(Parse*, Index*); +SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe*, int); +SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe*, int); +SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetLastOp(Vdbe*); +SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Parse*); +SQLITE_PRIVATE void sqlite3VdbeRunOnlyOnce(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeReusable(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeMakeReady(Vdbe*,Parse*); +SQLITE_PRIVATE int sqlite3VdbeFinalize(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe*, int); +SQLITE_PRIVATE int sqlite3VdbeCurrentAddr(Vdbe*); +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3VdbeAssertMayAbort(Vdbe *, int); +#endif +SQLITE_PRIVATE void sqlite3VdbeResetStepResult(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeRewind(Vdbe*); +SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeSetNumCols(Vdbe*,int); +SQLITE_PRIVATE int sqlite3VdbeSetColName(Vdbe*, int, int, const char *, void(*)(void*)); +SQLITE_PRIVATE void sqlite3VdbeCountChanges(Vdbe*); +SQLITE_PRIVATE sqlite3 *sqlite3VdbeDb(Vdbe*); +SQLITE_PRIVATE u8 sqlite3VdbePrepareFlags(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe*, const char *z, int n, u8); +#ifdef SQLITE_ENABLE_NORMALIZE +SQLITE_PRIVATE void sqlite3VdbeAddDblquoteStr(sqlite3*,Vdbe*,const char*); +SQLITE_PRIVATE int sqlite3VdbeUsesDoubleQuotedString(Vdbe*,const char*); +#endif +SQLITE_PRIVATE void sqlite3VdbeSwap(Vdbe*,Vdbe*); +SQLITE_PRIVATE VdbeOp *sqlite3VdbeTakeOpArray(Vdbe*, int*, int*); +SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetBoundValue(Vdbe*, int, u8); +SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe*, int); +#ifndef SQLITE_OMIT_TRACE +SQLITE_PRIVATE char *sqlite3VdbeExpandSql(Vdbe*, const char*); +#endif +SQLITE_PRIVATE int sqlite3MemCompare(const Mem*, const Mem*, const CollSeq*); +SQLITE_PRIVATE int sqlite3BlobCompare(const Mem*, const Mem*); + +SQLITE_PRIVATE void sqlite3VdbeRecordUnpack(KeyInfo*,int,const void*,UnpackedRecord*); +SQLITE_PRIVATE int sqlite3VdbeRecordCompare(int,const void*,UnpackedRecord*); +SQLITE_PRIVATE int sqlite3VdbeRecordCompareWithSkip(int, const void *, UnpackedRecord *, int); +SQLITE_PRIVATE UnpackedRecord *sqlite3VdbeAllocUnpackedRecord(KeyInfo*); + +typedef int (*RecordCompare)(int,const void*,UnpackedRecord*); +SQLITE_PRIVATE RecordCompare sqlite3VdbeFindCompare(UnpackedRecord*); + +SQLITE_PRIVATE void sqlite3VdbeLinkSubProgram(Vdbe *, SubProgram *); +SQLITE_PRIVATE int sqlite3VdbeHasSubProgram(Vdbe*); + +SQLITE_PRIVATE int sqlite3NotPureFunc(sqlite3_context*); +#ifdef SQLITE_ENABLE_BYTECODE_VTAB +SQLITE_PRIVATE int sqlite3VdbeBytecodeVtabInit(sqlite3*); +#endif + +/* Use SQLITE_ENABLE_COMMENTS to enable generation of extra comments on +** each VDBE opcode. +** +** Use the SQLITE_ENABLE_MODULE_COMMENTS macro to see some extra no-op +** comments in VDBE programs that show key decision points in the code +** generator. +*/ +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS +SQLITE_PRIVATE void sqlite3VdbeComment(Vdbe*, const char*, ...); +# define VdbeComment(X) sqlite3VdbeComment X +SQLITE_PRIVATE void sqlite3VdbeNoopComment(Vdbe*, const char*, ...); +# define VdbeNoopComment(X) sqlite3VdbeNoopComment X +# ifdef SQLITE_ENABLE_MODULE_COMMENTS +# define VdbeModuleComment(X) sqlite3VdbeNoopComment X +# else +# define VdbeModuleComment(X) +# endif +#else +# define VdbeComment(X) +# define VdbeNoopComment(X) +# define VdbeModuleComment(X) +#endif + +/* +** The VdbeCoverage macros are used to set a coverage testing point +** for VDBE branch instructions. The coverage testing points are line +** numbers in the sqlite3.c source file. VDBE branch coverage testing +** only works with an amalagmation build. That's ok since a VDBE branch +** coverage build designed for testing the test suite only. No application +** should ever ship with VDBE branch coverage measuring turned on. +** +** VdbeCoverage(v) // Mark the previously coded instruction +** // as a branch +** +** VdbeCoverageIf(v, conditional) // Mark previous if conditional true +** +** VdbeCoverageAlwaysTaken(v) // Previous branch is always taken +** +** VdbeCoverageNeverTaken(v) // Previous branch is never taken +** +** VdbeCoverageNeverNull(v) // Previous three-way branch is only +** // taken on the first two ways. The +** // NULL option is not possible +** +** VdbeCoverageEqNe(v) // Previous OP_Jump is only interested +** // in distingishing equal and not-equal. +** +** Every VDBE branch operation must be tagged with one of the macros above. +** If not, then when "make test" is run with -DSQLITE_VDBE_COVERAGE and +** -DSQLITE_DEBUG then an ALWAYS() will fail in the vdbeTakeBranch() +** routine in vdbe.c, alerting the developer to the missed tag. +** +** During testing, the test application will invoke +** sqlite3_test_control(SQLITE_TESTCTRL_VDBE_COVERAGE,...) to set a callback +** routine that is invoked as each bytecode branch is taken. The callback +** contains the sqlite3.c source line number ov the VdbeCoverage macro and +** flags to indicate whether or not the branch was taken. The test application +** is responsible for keeping track of this and reporting byte-code branches +** that are never taken. +** +** See the VdbeBranchTaken() macro and vdbeTakeBranch() function in the +** vdbe.c source file for additional information. +*/ +#ifdef SQLITE_VDBE_COVERAGE +SQLITE_PRIVATE void sqlite3VdbeSetLineNumber(Vdbe*,int); +# define VdbeCoverage(v) sqlite3VdbeSetLineNumber(v,__LINE__) +# define VdbeCoverageIf(v,x) if(x)sqlite3VdbeSetLineNumber(v,__LINE__) +# define VdbeCoverageAlwaysTaken(v) \ + sqlite3VdbeSetLineNumber(v,__LINE__|0x5000000); +# define VdbeCoverageNeverTaken(v) \ + sqlite3VdbeSetLineNumber(v,__LINE__|0x6000000); +# define VdbeCoverageNeverNull(v) \ + sqlite3VdbeSetLineNumber(v,__LINE__|0x4000000); +# define VdbeCoverageNeverNullIf(v,x) \ + if(x)sqlite3VdbeSetLineNumber(v,__LINE__|0x4000000); +# define VdbeCoverageEqNe(v) \ + sqlite3VdbeSetLineNumber(v,__LINE__|0x8000000); +# define VDBE_OFFSET_LINENO(x) (__LINE__+x) +#else +# define VdbeCoverage(v) +# define VdbeCoverageIf(v,x) +# define VdbeCoverageAlwaysTaken(v) +# define VdbeCoverageNeverTaken(v) +# define VdbeCoverageNeverNull(v) +# define VdbeCoverageNeverNullIf(v,x) +# define VdbeCoverageEqNe(v) +# define VDBE_OFFSET_LINENO(x) 0 +#endif + +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS +SQLITE_PRIVATE void sqlite3VdbeScanStatus(Vdbe*, int, int, int, LogEst, const char*); +SQLITE_PRIVATE void sqlite3VdbeScanStatusRange(Vdbe*, int, int, int); +SQLITE_PRIVATE void sqlite3VdbeScanStatusCounters(Vdbe*, int, int, int); +#else +# define sqlite3VdbeScanStatus(a,b,c,d,e,f) +# define sqlite3VdbeScanStatusRange(a,b,c,d) +# define sqlite3VdbeScanStatusCounters(a,b,c,d) +#endif + +#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE) +SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE*, int, VdbeOp*); +#endif + +#if defined(SQLITE_ENABLE_CURSOR_HINTS) && defined(SQLITE_DEBUG) +SQLITE_PRIVATE int sqlite3CursorRangeHintExprCheck(Walker *pWalker, Expr *pExpr); +#endif + +#endif /* SQLITE_VDBE_H */ + +/************** End of vdbe.h ************************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +/************** Include pcache.h in the middle of sqliteInt.h ****************/ +/************** Begin file pcache.h ******************************************/ +/* +** 2008 August 05 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This header file defines the interface that the sqlite page cache +** subsystem. +*/ + +#ifndef _PCACHE_H_ + +typedef struct PgHdr PgHdr; +typedef struct PCache PCache; + +/* +** Every page in the cache is controlled by an instance of the following +** structure. +*/ +struct PgHdr { + sqlite3_pcache_page *pPage; /* Pcache object page handle */ + void *pData; /* Page data */ + void *pExtra; /* Extra content */ + PCache *pCache; /* PRIVATE: Cache that owns this page */ + PgHdr *pDirty; /* Transient list of dirty sorted by pgno */ + Pager *pPager; /* The pager this page is part of */ + Pgno pgno; /* Page number for this page */ +#ifdef SQLITE_CHECK_PAGES + u32 pageHash; /* Hash of page content */ +#endif + u16 flags; /* PGHDR flags defined below */ + + /********************************************************************** + ** Elements above, except pCache, are public. All that follow are + ** private to pcache.c and should not be accessed by other modules. + ** pCache is grouped with the public elements for efficiency. + */ + i64 nRef; /* Number of users of this page */ + PgHdr *pDirtyNext; /* Next element in list of dirty pages */ + PgHdr *pDirtyPrev; /* Previous element in list of dirty pages */ + /* NB: pDirtyNext and pDirtyPrev are undefined if the + ** PgHdr object is not dirty */ +}; + +/* Bit values for PgHdr.flags */ +#define PGHDR_CLEAN 0x001 /* Page not on the PCache.pDirty list */ +#define PGHDR_DIRTY 0x002 /* Page is on the PCache.pDirty list */ +#define PGHDR_WRITEABLE 0x004 /* Journaled and ready to modify */ +#define PGHDR_NEED_SYNC 0x008 /* Fsync the rollback journal before + ** writing this page to the database */ +#define PGHDR_DONT_WRITE 0x010 /* Do not write content to disk */ +#define PGHDR_MMAP 0x020 /* This is an mmap page object */ + +#define PGHDR_WAL_APPEND 0x040 /* Appended to wal file */ + +/* Initialize and shutdown the page cache subsystem */ +SQLITE_PRIVATE int sqlite3PcacheInitialize(void); +SQLITE_PRIVATE void sqlite3PcacheShutdown(void); + +/* Page cache buffer management: +** These routines implement SQLITE_CONFIG_PAGECACHE. +*/ +SQLITE_PRIVATE void sqlite3PCacheBufferSetup(void *, int sz, int n); + +/* Create a new pager cache. +** Under memory stress, invoke xStress to try to make pages clean. +** Only clean and unpinned pages can be reclaimed. +*/ +SQLITE_PRIVATE int sqlite3PcacheOpen( + int szPage, /* Size of every page */ + int szExtra, /* Extra space associated with each page */ + int bPurgeable, /* True if pages are on backing store */ + int (*xStress)(void*, PgHdr*), /* Call to try to make pages clean */ + void *pStress, /* Argument to xStress */ + PCache *pToInit /* Preallocated space for the PCache */ +); + +/* Modify the page-size after the cache has been created. */ +SQLITE_PRIVATE int sqlite3PcacheSetPageSize(PCache *, int); + +/* Return the size in bytes of a PCache object. Used to preallocate +** storage space. +*/ +SQLITE_PRIVATE int sqlite3PcacheSize(void); + +/* One release per successful fetch. Page is pinned until released. +** Reference counted. +*/ +SQLITE_PRIVATE sqlite3_pcache_page *sqlite3PcacheFetch(PCache*, Pgno, int createFlag); +SQLITE_PRIVATE int sqlite3PcacheFetchStress(PCache*, Pgno, sqlite3_pcache_page**); +SQLITE_PRIVATE PgHdr *sqlite3PcacheFetchFinish(PCache*, Pgno, sqlite3_pcache_page *pPage); +SQLITE_PRIVATE void sqlite3PcacheRelease(PgHdr*); + +SQLITE_PRIVATE void sqlite3PcacheDrop(PgHdr*); /* Remove page from cache */ +SQLITE_PRIVATE void sqlite3PcacheMakeDirty(PgHdr*); /* Make sure page is marked dirty */ +SQLITE_PRIVATE void sqlite3PcacheMakeClean(PgHdr*); /* Mark a single page as clean */ +SQLITE_PRIVATE void sqlite3PcacheCleanAll(PCache*); /* Mark all dirty list pages as clean */ +SQLITE_PRIVATE void sqlite3PcacheClearWritable(PCache*); + +/* Change a page number. Used by incr-vacuum. */ +SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr*, Pgno); + +/* Remove all pages with pgno>x. Reset the cache if x==0 */ +SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache*, Pgno x); + +/* Get a list of all dirty pages in the cache, sorted by page number */ +SQLITE_PRIVATE PgHdr *sqlite3PcacheDirtyList(PCache*); + +/* Reset and close the cache object */ +SQLITE_PRIVATE void sqlite3PcacheClose(PCache*); + +/* Clear flags from pages of the page cache */ +SQLITE_PRIVATE void sqlite3PcacheClearSyncFlags(PCache *); + +/* Discard the contents of the cache */ +SQLITE_PRIVATE void sqlite3PcacheClear(PCache*); + +/* Return the total number of outstanding page references */ +SQLITE_PRIVATE i64 sqlite3PcacheRefCount(PCache*); + +/* Increment the reference count of an existing page */ +SQLITE_PRIVATE void sqlite3PcacheRef(PgHdr*); + +SQLITE_PRIVATE i64 sqlite3PcachePageRefcount(PgHdr*); + +/* Return the total number of pages stored in the cache */ +SQLITE_PRIVATE int sqlite3PcachePagecount(PCache*); + +#if defined(SQLITE_CHECK_PAGES) || defined(SQLITE_DEBUG) +/* Iterate through all dirty pages currently stored in the cache. This +** interface is only available if SQLITE_CHECK_PAGES is defined when the +** library is built. +*/ +SQLITE_PRIVATE void sqlite3PcacheIterateDirty(PCache *pCache, void (*xIter)(PgHdr *)); +#endif + +#if defined(SQLITE_DEBUG) +/* Check invariants on a PgHdr object */ +SQLITE_PRIVATE int sqlite3PcachePageSanity(PgHdr*); +#endif + +/* Set and get the suggested cache-size for the specified pager-cache. +** +** If no global maximum is configured, then the system attempts to limit +** the total number of pages cached by purgeable pager-caches to the sum +** of the suggested cache-sizes. +*/ +SQLITE_PRIVATE void sqlite3PcacheSetCachesize(PCache *, int); +#ifdef SQLITE_TEST +SQLITE_PRIVATE int sqlite3PcacheGetCachesize(PCache *); +#endif + +/* Set or get the suggested spill-size for the specified pager-cache. +** +** The spill-size is the minimum number of pages in cache before the cache +** will attempt to spill dirty pages by calling xStress. +*/ +SQLITE_PRIVATE int sqlite3PcacheSetSpillsize(PCache *, int); + +/* Free up as much memory as possible from the page cache */ +SQLITE_PRIVATE void sqlite3PcacheShrink(PCache*); + +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT +/* Try to return memory used by the pcache module to the main memory heap */ +SQLITE_PRIVATE int sqlite3PcacheReleaseMemory(int); +#endif + +#ifdef SQLITE_TEST +SQLITE_PRIVATE void sqlite3PcacheStats(int*,int*,int*,int*); +#endif + +SQLITE_PRIVATE void sqlite3PCacheSetDefault(void); + +/* Return the header size */ +SQLITE_PRIVATE int sqlite3HeaderSizePcache(void); +SQLITE_PRIVATE int sqlite3HeaderSizePcache1(void); + +/* Number of dirty pages as a percentage of the configured cache size */ +SQLITE_PRIVATE int sqlite3PCachePercentDirty(PCache*); + +#ifdef SQLITE_DIRECT_OVERFLOW_READ +SQLITE_PRIVATE int sqlite3PCacheIsDirty(PCache *pCache); +#endif + +#endif /* _PCACHE_H_ */ + +/************** End of pcache.h **********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +/************** Include mutex.h in the middle of sqliteInt.h *****************/ +/************** Begin file mutex.h *******************************************/ +/* +** 2007 August 28 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains the common header for all mutex implementations. +** The sqliteInt.h header #includes this file so that it is available +** to all source files. We break it out in an effort to keep the code +** better organized. +** +** NOTE: source files should *not* #include this header file directly. +** Source files should #include the sqliteInt.h file and let that file +** include this one indirectly. +*/ + + +/* +** Figure out what version of the code to use. The choices are +** +** SQLITE_MUTEX_OMIT No mutex logic. Not even stubs. The +** mutexes implementation cannot be overridden +** at start-time. +** +** SQLITE_MUTEX_NOOP For single-threaded applications. No +** mutual exclusion is provided. But this +** implementation can be overridden at +** start-time. +** +** SQLITE_MUTEX_PTHREADS For multi-threaded applications on Unix. +** +** SQLITE_MUTEX_W32 For multi-threaded applications on Win32. +*/ +#if !SQLITE_THREADSAFE +# define SQLITE_MUTEX_OMIT +#endif +#if SQLITE_THREADSAFE && !defined(SQLITE_MUTEX_NOOP) +# if SQLITE_OS_UNIX +# define SQLITE_MUTEX_PTHREADS +# elif SQLITE_OS_WIN +# define SQLITE_MUTEX_W32 +# else +# define SQLITE_MUTEX_NOOP +# endif +#endif + +#ifdef SQLITE_MUTEX_OMIT +/* +** If this is a no-op implementation, implement everything as macros. +*/ +#define sqlite3_mutex_alloc(X) ((sqlite3_mutex*)8) +#define sqlite3_mutex_free(X) +#define sqlite3_mutex_enter(X) +#define sqlite3_mutex_try(X) SQLITE_OK +#define sqlite3_mutex_leave(X) +#define sqlite3_mutex_held(X) ((void)(X),1) +#define sqlite3_mutex_notheld(X) ((void)(X),1) +#define sqlite3MutexAlloc(X) ((sqlite3_mutex*)8) +#define sqlite3MutexInit() SQLITE_OK +#define sqlite3MutexEnd() +#define MUTEX_LOGIC(X) +#else +#define MUTEX_LOGIC(X) X +SQLITE_API int sqlite3_mutex_held(sqlite3_mutex*); +#endif /* defined(SQLITE_MUTEX_OMIT) */ + +/************** End of mutex.h ***********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ + +/* The SQLITE_EXTRA_DURABLE compile-time option used to set the default +** synchronous setting to EXTRA. It is no longer supported. +*/ +#ifdef SQLITE_EXTRA_DURABLE +# warning Use SQLITE_DEFAULT_SYNCHRONOUS=3 instead of SQLITE_EXTRA_DURABLE +# define SQLITE_DEFAULT_SYNCHRONOUS 3 +#endif + +/* +** Default synchronous levels. +** +** Note that (for historcal reasons) the PAGER_SYNCHRONOUS_* macros differ +** from the SQLITE_DEFAULT_SYNCHRONOUS value by 1. +** +** PAGER_SYNCHRONOUS DEFAULT_SYNCHRONOUS +** OFF 1 0 +** NORMAL 2 1 +** FULL 3 2 +** EXTRA 4 3 +** +** The "PRAGMA synchronous" statement also uses the zero-based numbers. +** In other words, the zero-based numbers are used for all external interfaces +** and the one-based values are used internally. +*/ +#ifndef SQLITE_DEFAULT_SYNCHRONOUS +# define SQLITE_DEFAULT_SYNCHRONOUS 2 +#endif +#ifndef SQLITE_DEFAULT_WAL_SYNCHRONOUS +# define SQLITE_DEFAULT_WAL_SYNCHRONOUS SQLITE_DEFAULT_SYNCHRONOUS +#endif + +/* +** Each database file to be accessed by the system is an instance +** of the following structure. There are normally two of these structures +** in the sqlite.aDb[] array. aDb[0] is the main database file and +** aDb[1] is the database file used to hold temporary tables. Additional +** databases may be attached. +*/ +struct Db { + char *zDbSName; /* Name of this database. (schema name, not filename) */ + Btree *pBt; /* The B*Tree structure for this database file */ + u8 safety_level; /* How aggressive at syncing data to disk */ + u8 bSyncSet; /* True if "PRAGMA synchronous=N" has been run */ + Schema *pSchema; /* Pointer to database schema (possibly shared) */ +}; + +/* +** An instance of the following structure stores a database schema. +** +** Most Schema objects are associated with a Btree. The exception is +** the Schema for the TEMP databaes (sqlite3.aDb[1]) which is free-standing. +** In shared cache mode, a single Schema object can be shared by multiple +** Btrees that refer to the same underlying BtShared object. +** +** Schema objects are automatically deallocated when the last Btree that +** references them is destroyed. The TEMP Schema is manually freed by +** sqlite3_close(). +* +** A thread must be holding a mutex on the corresponding Btree in order +** to access Schema content. This implies that the thread must also be +** holding a mutex on the sqlite3 connection pointer that owns the Btree. +** For a TEMP Schema, only the connection mutex is required. +*/ +struct Schema { + int schema_cookie; /* Database schema version number for this file */ + int iGeneration; /* Generation counter. Incremented with each change */ + Hash tblHash; /* All tables indexed by name */ + Hash idxHash; /* All (named) indices indexed by name */ + Hash trigHash; /* All triggers indexed by name */ + Hash fkeyHash; /* All foreign keys by referenced table name */ + Table *pSeqTab; /* The sqlite_sequence table used by AUTOINCREMENT */ + u8 file_format; /* Schema format version for this file */ + u8 enc; /* Text encoding used by this database */ + u16 schemaFlags; /* Flags associated with this schema */ + int cache_size; /* Number of pages to use in the cache */ +}; + +/* +** These macros can be used to test, set, or clear bits in the +** Db.pSchema->flags field. +*/ +#define DbHasProperty(D,I,P) (((D)->aDb[I].pSchema->schemaFlags&(P))==(P)) +#define DbHasAnyProperty(D,I,P) (((D)->aDb[I].pSchema->schemaFlags&(P))!=0) +#define DbSetProperty(D,I,P) (D)->aDb[I].pSchema->schemaFlags|=(P) +#define DbClearProperty(D,I,P) (D)->aDb[I].pSchema->schemaFlags&=~(P) + +/* +** Allowed values for the DB.pSchema->flags field. +** +** The DB_SchemaLoaded flag is set after the database schema has been +** read into internal hash tables. +** +** DB_UnresetViews means that one or more views have column names that +** have been filled out. If the schema changes, these column names might +** changes and so the view will need to be reset. +*/ +#define DB_SchemaLoaded 0x0001 /* The schema has been loaded */ +#define DB_UnresetViews 0x0002 /* Some views have defined column names */ +#define DB_ResetWanted 0x0008 /* Reset the schema when nSchemaLock==0 */ + +/* +** The number of different kinds of things that can be limited +** using the sqlite3_limit() interface. +*/ +#define SQLITE_N_LIMIT (SQLITE_LIMIT_WORKER_THREADS+1) + +/* +** Lookaside malloc is a set of fixed-size buffers that can be used +** to satisfy small transient memory allocation requests for objects +** associated with a particular database connection. The use of +** lookaside malloc provides a significant performance enhancement +** (approx 10%) by avoiding numerous malloc/free requests while parsing +** SQL statements. +** +** The Lookaside structure holds configuration information about the +** lookaside malloc subsystem. Each available memory allocation in +** the lookaside subsystem is stored on a linked list of LookasideSlot +** objects. +** +** Lookaside allocations are only allowed for objects that are associated +** with a particular database connection. Hence, schema information cannot +** be stored in lookaside because in shared cache mode the schema information +** is shared by multiple database connections. Therefore, while parsing +** schema information, the Lookaside.bEnabled flag is cleared so that +** lookaside allocations are not used to construct the schema objects. +** +** New lookaside allocations are only allowed if bDisable==0. When +** bDisable is greater than zero, sz is set to zero which effectively +** disables lookaside without adding a new test for the bDisable flag +** in a performance-critical path. sz should be set by to szTrue whenever +** bDisable changes back to zero. +** +** Lookaside buffers are initially held on the pInit list. As they are +** used and freed, they are added back to the pFree list. New allocations +** come off of pFree first, then pInit as a fallback. This dual-list +** allows use to compute a high-water mark - the maximum number of allocations +** outstanding at any point in the past - by subtracting the number of +** allocations on the pInit list from the total number of allocations. +** +** Enhancement on 2019-12-12: Two-size-lookaside +** The default lookaside configuration is 100 slots of 1200 bytes each. +** The larger slot sizes are important for performance, but they waste +** a lot of space, as most lookaside allocations are less than 128 bytes. +** The two-size-lookaside enhancement breaks up the lookaside allocation +** into two pools: One of 128-byte slots and the other of the default size +** (1200-byte) slots. Allocations are filled from the small-pool first, +** failing over to the full-size pool if that does not work. Thus more +** lookaside slots are available while also using less memory. +** This enhancement can be omitted by compiling with +** SQLITE_OMIT_TWOSIZE_LOOKASIDE. +*/ +struct Lookaside { + u32 bDisable; /* Only operate the lookaside when zero */ + u16 sz; /* Size of each buffer in bytes */ + u16 szTrue; /* True value of sz, even if disabled */ + u8 bMalloced; /* True if pStart obtained from sqlite3_malloc() */ + u32 nSlot; /* Number of lookaside slots allocated */ + u32 anStat[3]; /* 0: hits. 1: size misses. 2: full misses */ + LookasideSlot *pInit; /* List of buffers not previously used */ + LookasideSlot *pFree; /* List of available buffers */ +#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE + LookasideSlot *pSmallInit; /* List of small buffers not prediously used */ + LookasideSlot *pSmallFree; /* List of available small buffers */ + void *pMiddle; /* First byte past end of full-size buffers and + ** the first byte of LOOKASIDE_SMALL buffers */ +#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */ + void *pStart; /* First byte of available memory space */ + void *pEnd; /* First byte past end of available space */ + void *pTrueEnd; /* True value of pEnd, when db->pnBytesFreed!=0 */ +}; +struct LookasideSlot { + LookasideSlot *pNext; /* Next buffer in the list of free buffers */ +}; + +#define DisableLookaside db->lookaside.bDisable++;db->lookaside.sz=0 +#define EnableLookaside db->lookaside.bDisable--;\ + db->lookaside.sz=db->lookaside.bDisable?0:db->lookaside.szTrue + +/* Size of the smaller allocations in two-size lookside */ +#ifdef SQLITE_OMIT_TWOSIZE_LOOKASIDE +# define LOOKASIDE_SMALL 0 +#else +# define LOOKASIDE_SMALL 128 +#endif + +/* +** A hash table for built-in function definitions. (Application-defined +** functions use a regular table table from hash.h.) +** +** Hash each FuncDef structure into one of the FuncDefHash.a[] slots. +** Collisions are on the FuncDef.u.pHash chain. Use the SQLITE_FUNC_HASH() +** macro to compute a hash on the function name. +*/ +#define SQLITE_FUNC_HASH_SZ 23 +struct FuncDefHash { + FuncDef *a[SQLITE_FUNC_HASH_SZ]; /* Hash table for functions */ +}; +#define SQLITE_FUNC_HASH(C,L) (((C)+(L))%SQLITE_FUNC_HASH_SZ) + +#ifdef SQLITE_USER_AUTHENTICATION +/* +** Information held in the "sqlite3" database connection object and used +** to manage user authentication. +*/ +typedef struct sqlite3_userauth sqlite3_userauth; +struct sqlite3_userauth { + u8 authLevel; /* Current authentication level */ + int nAuthPW; /* Size of the zAuthPW in bytes */ + char *zAuthPW; /* Password used to authenticate */ + char *zAuthUser; /* User name used to authenticate */ +}; + +/* Allowed values for sqlite3_userauth.authLevel */ +#define UAUTH_Unknown 0 /* Authentication not yet checked */ +#define UAUTH_Fail 1 /* User authentication failed */ +#define UAUTH_User 2 /* Authenticated as a normal user */ +#define UAUTH_Admin 3 /* Authenticated as an administrator */ + +/* Functions used only by user authorization logic */ +SQLITE_PRIVATE int sqlite3UserAuthTable(const char*); +SQLITE_PRIVATE int sqlite3UserAuthCheckLogin(sqlite3*,const char*,u8*); +SQLITE_PRIVATE void sqlite3UserAuthInit(sqlite3*); +SQLITE_PRIVATE void sqlite3CryptFunc(sqlite3_context*,int,sqlite3_value**); + +#endif /* SQLITE_USER_AUTHENTICATION */ + +/* +** typedef for the authorization callback function. +*/ +#ifdef SQLITE_USER_AUTHENTICATION + typedef int (*sqlite3_xauth)(void*,int,const char*,const char*,const char*, + const char*, const char*); +#else + typedef int (*sqlite3_xauth)(void*,int,const char*,const char*,const char*, + const char*); +#endif + +#ifndef SQLITE_OMIT_DEPRECATED +/* This is an extra SQLITE_TRACE macro that indicates "legacy" tracing +** in the style of sqlite3_trace() +*/ +#define SQLITE_TRACE_LEGACY 0x40 /* Use the legacy xTrace */ +#define SQLITE_TRACE_XPROFILE 0x80 /* Use the legacy xProfile */ +#else +#define SQLITE_TRACE_LEGACY 0 +#define SQLITE_TRACE_XPROFILE 0 +#endif /* SQLITE_OMIT_DEPRECATED */ +#define SQLITE_TRACE_NONLEGACY_MASK 0x0f /* Normal flags */ + +/* +** Maximum number of sqlite3.aDb[] entries. This is the number of attached +** databases plus 2 for "main" and "temp". +*/ +#define SQLITE_MAX_DB (SQLITE_MAX_ATTACHED+2) + +/* +** Each database connection is an instance of the following structure. +*/ +struct sqlite3 { + sqlite3_vfs *pVfs; /* OS Interface */ + struct Vdbe *pVdbe; /* List of active virtual machines */ + CollSeq *pDfltColl; /* BINARY collseq for the database encoding */ + sqlite3_mutex *mutex; /* Connection mutex */ + Db *aDb; /* All backends */ + int nDb; /* Number of backends currently in use */ + u32 mDbFlags; /* flags recording internal state */ + u64 flags; /* flags settable by pragmas. See below */ + i64 lastRowid; /* ROWID of most recent insert (see above) */ + i64 szMmap; /* Default mmap_size setting */ + u32 nSchemaLock; /* Do not reset the schema when non-zero */ + unsigned int openFlags; /* Flags passed to sqlite3_vfs.xOpen() */ + int errCode; /* Most recent error code (SQLITE_*) */ + int errByteOffset; /* Byte offset of error in SQL statement */ + int errMask; /* & result codes with this before returning */ + int iSysErrno; /* Errno value from last system error */ + u32 dbOptFlags; /* Flags to enable/disable optimizations */ + u8 enc; /* Text encoding */ + u8 autoCommit; /* The auto-commit flag. */ + u8 temp_store; /* 1: file 2: memory 0: default */ + u8 mallocFailed; /* True if we have seen a malloc failure */ + u8 bBenignMalloc; /* Do not require OOMs if true */ + u8 dfltLockMode; /* Default locking-mode for attached dbs */ + signed char nextAutovac; /* Autovac setting after VACUUM if >=0 */ + u8 suppressErr; /* Do not issue error messages if true */ + u8 vtabOnConflict; /* Value to return for s3_vtab_on_conflict() */ + u8 isTransactionSavepoint; /* True if the outermost savepoint is a TS */ + u8 mTrace; /* zero or more SQLITE_TRACE flags */ + u8 noSharedCache; /* True if no shared-cache backends */ + u8 nSqlExec; /* Number of pending OP_SqlExec opcodes */ + u8 eOpenState; /* Current condition of the connection */ + int nextPagesize; /* Pagesize after VACUUM if >0 */ + i64 nChange; /* Value returned by sqlite3_changes() */ + i64 nTotalChange; /* Value returned by sqlite3_total_changes() */ + int aLimit[SQLITE_N_LIMIT]; /* Limits */ + int nMaxSorterMmap; /* Maximum size of regions mapped by sorter */ + struct sqlite3InitInfo { /* Information used during initialization */ + Pgno newTnum; /* Rootpage of table being initialized */ + u8 iDb; /* Which db file is being initialized */ + u8 busy; /* TRUE if currently initializing */ + unsigned orphanTrigger : 1; /* Last statement is orphaned TEMP trigger */ + unsigned imposterTable : 1; /* Building an imposter table */ + unsigned reopenMemdb : 1; /* ATTACH is really a reopen using MemDB */ + const char **azInit; /* "type", "name", and "tbl_name" columns */ + } init; + int nVdbeActive; /* Number of VDBEs currently running */ + int nVdbeRead; /* Number of active VDBEs that read or write */ + int nVdbeWrite; /* Number of active VDBEs that read and write */ + int nVdbeExec; /* Number of nested calls to VdbeExec() */ + int nVDestroy; /* Number of active OP_VDestroy operations */ + int nExtension; /* Number of loaded extensions */ + void **aExtension; /* Array of shared library handles */ + union { + void (*xLegacy)(void*,const char*); /* mTrace==SQLITE_TRACE_LEGACY */ + int (*xV2)(u32,void*,void*,void*); /* All other mTrace values */ + } trace; + void *pTraceArg; /* Argument to the trace function */ +#ifndef SQLITE_OMIT_DEPRECATED + void (*xProfile)(void*,const char*,u64); /* Profiling function */ + void *pProfileArg; /* Argument to profile function */ +#endif + void *pCommitArg; /* Argument to xCommitCallback() */ + int (*xCommitCallback)(void*); /* Invoked at every commit. */ + void *pRollbackArg; /* Argument to xRollbackCallback() */ + void (*xRollbackCallback)(void*); /* Invoked at every commit. */ + void *pUpdateArg; + void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64); + void *pAutovacPagesArg; /* Client argument to autovac_pages */ + void (*xAutovacDestr)(void*); /* Destructor for pAutovacPAgesArg */ + unsigned int (*xAutovacPages)(void*,const char*,u32,u32,u32); + Parse *pParse; /* Current parse */ +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + void *pPreUpdateArg; /* First argument to xPreUpdateCallback */ + void (*xPreUpdateCallback)( /* Registered using sqlite3_preupdate_hook() */ + void*,sqlite3*,int,char const*,char const*,sqlite3_int64,sqlite3_int64 + ); + PreUpdate *pPreUpdate; /* Context for active pre-update callback */ +#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ +#ifndef SQLITE_OMIT_WAL + int (*xWalCallback)(void *, sqlite3 *, const char *, int); + void *pWalArg; +#endif + void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*); + void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*); + void *pCollNeededArg; + sqlite3_value *pErr; /* Most recent error message */ + union { + volatile int isInterrupted; /* True if sqlite3_interrupt has been called */ + double notUsed1; /* Spacer */ + } u1; + Lookaside lookaside; /* Lookaside malloc configuration */ +#ifndef SQLITE_OMIT_AUTHORIZATION + sqlite3_xauth xAuth; /* Access authorization function */ + void *pAuthArg; /* 1st argument to the access auth function */ +#endif +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + int (*xProgress)(void *); /* The progress callback */ + void *pProgressArg; /* Argument to the progress callback */ + unsigned nProgressOps; /* Number of opcodes for progress callback */ +#endif +#ifndef SQLITE_OMIT_VIRTUALTABLE + int nVTrans; /* Allocated size of aVTrans */ + Hash aModule; /* populated by sqlite3_create_module() */ + VtabCtx *pVtabCtx; /* Context for active vtab connect/create */ + VTable **aVTrans; /* Virtual tables with open transactions */ + VTable *pDisconnect; /* Disconnect these in next sqlite3_prepare() */ +#endif + Hash aFunc; /* Hash table of connection functions */ + Hash aCollSeq; /* All collating sequences */ + BusyHandler busyHandler; /* Busy callback */ + Db aDbStatic[2]; /* Static space for the 2 default backends */ + Savepoint *pSavepoint; /* List of active savepoints */ + int nAnalysisLimit; /* Number of index rows to ANALYZE */ + int busyTimeout; /* Busy handler timeout, in msec */ + int nSavepoint; /* Number of non-transaction savepoints */ + int nStatement; /* Number of nested statement-transactions */ + i64 nDeferredCons; /* Net deferred constraints this transaction. */ + i64 nDeferredImmCons; /* Net deferred immediate constraints */ + int *pnBytesFreed; /* If not NULL, increment this in DbFree() */ +#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY + /* The following variables are all protected by the STATIC_MAIN + ** mutex, not by sqlite3.mutex. They are used by code in notify.c. + ** + ** When X.pUnlockConnection==Y, that means that X is waiting for Y to + ** unlock so that it can proceed. + ** + ** When X.pBlockingConnection==Y, that means that something that X tried + ** tried to do recently failed with an SQLITE_LOCKED error due to locks + ** held by Y. + */ + sqlite3 *pBlockingConnection; /* Connection that caused SQLITE_LOCKED */ + sqlite3 *pUnlockConnection; /* Connection to watch for unlock */ + void *pUnlockArg; /* Argument to xUnlockNotify */ + void (*xUnlockNotify)(void **, int); /* Unlock notify callback */ + sqlite3 *pNextBlocked; /* Next in list of all blocked connections */ +#endif +#ifdef SQLITE_USER_AUTHENTICATION + sqlite3_userauth auth; /* User authentication information */ +#endif +}; + +/* +** A macro to discover the encoding of a database. +*/ +#define SCHEMA_ENC(db) ((db)->aDb[0].pSchema->enc) +#define ENC(db) ((db)->enc) + +/* +** A u64 constant where the lower 32 bits are all zeros. Only the +** upper 32 bits are included in the argument. Necessary because some +** C-compilers still do not accept LL integer literals. +*/ +#define HI(X) ((u64)(X)<<32) + +/* +** Possible values for the sqlite3.flags. +** +** Value constraints (enforced via assert()): +** SQLITE_FullFSync == PAGER_FULLFSYNC +** SQLITE_CkptFullFSync == PAGER_CKPT_FULLFSYNC +** SQLITE_CacheSpill == PAGER_CACHE_SPILL +*/ +#define SQLITE_WriteSchema 0x00000001 /* OK to update SQLITE_SCHEMA */ +#define SQLITE_LegacyFileFmt 0x00000002 /* Create new databases in format 1 */ +#define SQLITE_FullColNames 0x00000004 /* Show full column names on SELECT */ +#define SQLITE_FullFSync 0x00000008 /* Use full fsync on the backend */ +#define SQLITE_CkptFullFSync 0x00000010 /* Use full fsync for checkpoint */ +#define SQLITE_CacheSpill 0x00000020 /* OK to spill pager cache */ +#define SQLITE_ShortColNames 0x00000040 /* Show short columns names */ +#define SQLITE_TrustedSchema 0x00000080 /* Allow unsafe functions and + ** vtabs in the schema definition */ +#define SQLITE_NullCallback 0x00000100 /* Invoke the callback once if the */ + /* result set is empty */ +#define SQLITE_IgnoreChecks 0x00000200 /* Do not enforce check constraints */ +#define SQLITE_StmtScanStatus 0x00000400 /* Enable stmt_scanstats() counters */ +#define SQLITE_NoCkptOnClose 0x00000800 /* No checkpoint on close()/DETACH */ +#define SQLITE_ReverseOrder 0x00001000 /* Reverse unordered SELECTs */ +#define SQLITE_RecTriggers 0x00002000 /* Enable recursive triggers */ +#define SQLITE_ForeignKeys 0x00004000 /* Enforce foreign key constraints */ +#define SQLITE_AutoIndex 0x00008000 /* Enable automatic indexes */ +#define SQLITE_LoadExtension 0x00010000 /* Enable load_extension */ +#define SQLITE_LoadExtFunc 0x00020000 /* Enable load_extension() SQL func */ +#define SQLITE_EnableTrigger 0x00040000 /* True to enable triggers */ +#define SQLITE_DeferFKs 0x00080000 /* Defer all FK constraints */ +#define SQLITE_QueryOnly 0x00100000 /* Disable database changes */ +#define SQLITE_CellSizeCk 0x00200000 /* Check btree cell sizes on load */ +#define SQLITE_Fts3Tokenizer 0x00400000 /* Enable fts3_tokenizer(2) */ +#define SQLITE_EnableQPSG 0x00800000 /* Query Planner Stability Guarantee*/ +#define SQLITE_TriggerEQP 0x01000000 /* Show trigger EXPLAIN QUERY PLAN */ +#define SQLITE_ResetDatabase 0x02000000 /* Reset the database */ +#define SQLITE_LegacyAlter 0x04000000 /* Legacy ALTER TABLE behaviour */ +#define SQLITE_NoSchemaError 0x08000000 /* Do not report schema parse errors*/ +#define SQLITE_Defensive 0x10000000 /* Input SQL is likely hostile */ +#define SQLITE_DqsDDL 0x20000000 /* dbl-quoted strings allowed in DDL*/ +#define SQLITE_DqsDML 0x40000000 /* dbl-quoted strings allowed in DML*/ +#define SQLITE_EnableView 0x80000000 /* Enable the use of views */ +#define SQLITE_CountRows HI(0x00001) /* Count rows changed by INSERT, */ + /* DELETE, or UPDATE and return */ + /* the count using a callback. */ +#define SQLITE_CorruptRdOnly HI(0x00002) /* Prohibit writes due to error */ +#define SQLITE_ReadUncommit HI(0x00004) /* READ UNCOMMITTED in shared-cache */ + +/* Flags used only if debugging */ +#ifdef SQLITE_DEBUG +#define SQLITE_SqlTrace HI(0x0100000) /* Debug print SQL as it executes */ +#define SQLITE_VdbeListing HI(0x0200000) /* Debug listings of VDBE progs */ +#define SQLITE_VdbeTrace HI(0x0400000) /* True to trace VDBE execution */ +#define SQLITE_VdbeAddopTrace HI(0x0800000) /* Trace sqlite3VdbeAddOp() calls */ +#define SQLITE_VdbeEQP HI(0x1000000) /* Debug EXPLAIN QUERY PLAN */ +#define SQLITE_ParserTrace HI(0x2000000) /* PRAGMA parser_trace=ON */ +#endif + +/* +** Allowed values for sqlite3.mDbFlags +*/ +#define DBFLAG_SchemaChange 0x0001 /* Uncommitted Hash table changes */ +#define DBFLAG_PreferBuiltin 0x0002 /* Preference to built-in funcs */ +#define DBFLAG_Vacuum 0x0004 /* Currently in a VACUUM */ +#define DBFLAG_VacuumInto 0x0008 /* Currently running VACUUM INTO */ +#define DBFLAG_SchemaKnownOk 0x0010 /* Schema is known to be valid */ +#define DBFLAG_InternalFunc 0x0020 /* Allow use of internal functions */ +#define DBFLAG_EncodingFixed 0x0040 /* No longer possible to change enc. */ + +/* +** Bits of the sqlite3.dbOptFlags field that are used by the +** sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS,...) interface to +** selectively disable various optimizations. +*/ +#define SQLITE_QueryFlattener 0x00000001 /* Query flattening */ +#define SQLITE_WindowFunc 0x00000002 /* Use xInverse for window functions */ +#define SQLITE_GroupByOrder 0x00000004 /* GROUPBY cover of ORDERBY */ +#define SQLITE_FactorOutConst 0x00000008 /* Constant factoring */ +#define SQLITE_DistinctOpt 0x00000010 /* DISTINCT using indexes */ +#define SQLITE_CoverIdxScan 0x00000020 /* Covering index scans */ +#define SQLITE_OrderByIdxJoin 0x00000040 /* ORDER BY of joins via index */ +#define SQLITE_Transitive 0x00000080 /* Transitive constraints */ +#define SQLITE_OmitNoopJoin 0x00000100 /* Omit unused tables in joins */ +#define SQLITE_CountOfView 0x00000200 /* The count-of-view optimization */ +#define SQLITE_CursorHints 0x00000400 /* Add OP_CursorHint opcodes */ +#define SQLITE_Stat4 0x00000800 /* Use STAT4 data */ + /* TH3 expects this value ^^^^^^^^^^ to be 0x0000800. Don't change it */ +#define SQLITE_PushDown 0x00001000 /* The push-down optimization */ +#define SQLITE_SimplifyJoin 0x00002000 /* Convert LEFT JOIN to JOIN */ +#define SQLITE_SkipScan 0x00004000 /* Skip-scans */ +#define SQLITE_PropagateConst 0x00008000 /* The constant propagation opt */ +#define SQLITE_MinMaxOpt 0x00010000 /* The min/max optimization */ +#define SQLITE_SeekScan 0x00020000 /* The OP_SeekScan optimization */ +#define SQLITE_OmitOrderBy 0x00040000 /* Omit pointless ORDER BY */ + /* TH3 expects this value ^^^^^^^^^^ to be 0x40000. Coordinate any change */ +#define SQLITE_BloomFilter 0x00080000 /* Use a Bloom filter on searches */ +#define SQLITE_BloomPulldown 0x00100000 /* Run Bloom filters early */ +#define SQLITE_BalancedMerge 0x00200000 /* Balance multi-way merges */ +#define SQLITE_ReleaseReg 0x00400000 /* Use OP_ReleaseReg for testing */ +#define SQLITE_FlttnUnionAll 0x00800000 /* Disable the UNION ALL flattener */ + /* TH3 expects this value ^^^^^^^^^^ See flatten04.test */ +#define SQLITE_IndexedExpr 0x01000000 /* Pull exprs from index when able */ +#define SQLITE_Coroutines 0x02000000 /* Co-routines for subqueries */ +#define SQLITE_NullUnusedCols 0x04000000 /* NULL unused columns in subqueries */ +#define SQLITE_AllOpts 0xffffffff /* All optimizations */ + +/* +** Macros for testing whether or not optimizations are enabled or disabled. +*/ +#define OptimizationDisabled(db, mask) (((db)->dbOptFlags&(mask))!=0) +#define OptimizationEnabled(db, mask) (((db)->dbOptFlags&(mask))==0) + +/* +** Return true if it OK to factor constant expressions into the initialization +** code. The argument is a Parse object for the code generator. +*/ +#define ConstFactorOk(P) ((P)->okConstFactor) + +/* Possible values for the sqlite3.eOpenState field. +** The numbers are randomly selected such that a minimum of three bits must +** change to convert any number to another or to zero +*/ +#define SQLITE_STATE_OPEN 0x76 /* Database is open */ +#define SQLITE_STATE_CLOSED 0xce /* Database is closed */ +#define SQLITE_STATE_SICK 0xba /* Error and awaiting close */ +#define SQLITE_STATE_BUSY 0x6d /* Database currently in use */ +#define SQLITE_STATE_ERROR 0xd5 /* An SQLITE_MISUSE error occurred */ +#define SQLITE_STATE_ZOMBIE 0xa7 /* Close with last statement close */ + +/* +** Each SQL function is defined by an instance of the following +** structure. For global built-in functions (ex: substr(), max(), count()) +** a pointer to this structure is held in the sqlite3BuiltinFunctions object. +** For per-connection application-defined functions, a pointer to this +** structure is held in the db->aHash hash table. +** +** The u.pHash field is used by the global built-ins. The u.pDestructor +** field is used by per-connection app-def functions. +*/ +struct FuncDef { + i8 nArg; /* Number of arguments. -1 means unlimited */ + u32 funcFlags; /* Some combination of SQLITE_FUNC_* */ + void *pUserData; /* User data parameter */ + FuncDef *pNext; /* Next function with same name */ + void (*xSFunc)(sqlite3_context*,int,sqlite3_value**); /* func or agg-step */ + void (*xFinalize)(sqlite3_context*); /* Agg finalizer */ + void (*xValue)(sqlite3_context*); /* Current agg value */ + void (*xInverse)(sqlite3_context*,int,sqlite3_value**); /* inverse agg-step */ + const char *zName; /* SQL name of the function. */ + union { + FuncDef *pHash; /* Next with a different name but the same hash */ + FuncDestructor *pDestructor; /* Reference counted destructor function */ + } u; /* pHash if SQLITE_FUNC_BUILTIN, pDestructor otherwise */ +}; + +/* +** This structure encapsulates a user-function destructor callback (as +** configured using create_function_v2()) and a reference counter. When +** create_function_v2() is called to create a function with a destructor, +** a single object of this type is allocated. FuncDestructor.nRef is set to +** the number of FuncDef objects created (either 1 or 3, depending on whether +** or not the specified encoding is SQLITE_ANY). The FuncDef.pDestructor +** member of each of the new FuncDef objects is set to point to the allocated +** FuncDestructor. +** +** Thereafter, when one of the FuncDef objects is deleted, the reference +** count on this object is decremented. When it reaches 0, the destructor +** is invoked and the FuncDestructor structure freed. +*/ +struct FuncDestructor { + int nRef; + void (*xDestroy)(void *); + void *pUserData; +}; + +/* +** Possible values for FuncDef.flags. Note that the _LENGTH and _TYPEOF +** values must correspond to OPFLAG_LENGTHARG and OPFLAG_TYPEOFARG. And +** SQLITE_FUNC_CONSTANT must be the same as SQLITE_DETERMINISTIC. There +** are assert() statements in the code to verify this. +** +** Value constraints (enforced via assert()): +** SQLITE_FUNC_MINMAX == NC_MinMaxAgg == SF_MinMaxAgg +** SQLITE_FUNC_ANYORDER == NC_OrderAgg == SF_OrderByReqd +** SQLITE_FUNC_LENGTH == OPFLAG_LENGTHARG +** SQLITE_FUNC_TYPEOF == OPFLAG_TYPEOFARG +** SQLITE_FUNC_CONSTANT == SQLITE_DETERMINISTIC from the API +** SQLITE_FUNC_DIRECT == SQLITE_DIRECTONLY from the API +** SQLITE_FUNC_UNSAFE == SQLITE_INNOCUOUS -- opposite meanings!!! +** SQLITE_FUNC_ENCMASK depends on SQLITE_UTF* macros in the API +** +** Note that even though SQLITE_FUNC_UNSAFE and SQLITE_INNOCUOUS have the +** same bit value, their meanings are inverted. SQLITE_FUNC_UNSAFE is +** used internally and if set means tha the function has side effects. +** SQLITE_INNOCUOUS is used by application code and means "not unsafe". +** See multiple instances of tag-20230109-1. +*/ +#define SQLITE_FUNC_ENCMASK 0x0003 /* SQLITE_UTF8, SQLITE_UTF16BE or UTF16LE */ +#define SQLITE_FUNC_LIKE 0x0004 /* Candidate for the LIKE optimization */ +#define SQLITE_FUNC_CASE 0x0008 /* Case-sensitive LIKE-type function */ +#define SQLITE_FUNC_EPHEM 0x0010 /* Ephemeral. Delete with VDBE */ +#define SQLITE_FUNC_NEEDCOLL 0x0020 /* sqlite3GetFuncCollSeq() might be called*/ +#define SQLITE_FUNC_LENGTH 0x0040 /* Built-in length() function */ +#define SQLITE_FUNC_TYPEOF 0x0080 /* Built-in typeof() function */ +#define SQLITE_FUNC_COUNT 0x0100 /* Built-in count(*) aggregate */ +/* 0x0200 -- available for reuse */ +#define SQLITE_FUNC_UNLIKELY 0x0400 /* Built-in unlikely() function */ +#define SQLITE_FUNC_CONSTANT 0x0800 /* Constant inputs give a constant output */ +#define SQLITE_FUNC_MINMAX 0x1000 /* True for min() and max() aggregates */ +#define SQLITE_FUNC_SLOCHNG 0x2000 /* "Slow Change". Value constant during a + ** single query - might change over time */ +#define SQLITE_FUNC_TEST 0x4000 /* Built-in testing functions */ +/* 0x8000 -- available for reuse */ +#define SQLITE_FUNC_WINDOW 0x00010000 /* Built-in window-only function */ +#define SQLITE_FUNC_INTERNAL 0x00040000 /* For use by NestedParse() only */ +#define SQLITE_FUNC_DIRECT 0x00080000 /* Not for use in TRIGGERs or VIEWs */ +#define SQLITE_FUNC_SUBTYPE 0x00100000 /* Result likely to have sub-type */ +#define SQLITE_FUNC_UNSAFE 0x00200000 /* Function has side effects */ +#define SQLITE_FUNC_INLINE 0x00400000 /* Functions implemented in-line */ +#define SQLITE_FUNC_BUILTIN 0x00800000 /* This is a built-in function */ +#define SQLITE_FUNC_ANYORDER 0x08000000 /* count/min/max aggregate */ + +/* Identifier numbers for each in-line function */ +#define INLINEFUNC_coalesce 0 +#define INLINEFUNC_implies_nonnull_row 1 +#define INLINEFUNC_expr_implies_expr 2 +#define INLINEFUNC_expr_compare 3 +#define INLINEFUNC_affinity 4 +#define INLINEFUNC_iif 5 +#define INLINEFUNC_sqlite_offset 6 +#define INLINEFUNC_unlikely 99 /* Default case */ + +/* +** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are +** used to create the initializers for the FuncDef structures. +** +** FUNCTION(zName, nArg, iArg, bNC, xFunc) +** Used to create a scalar function definition of a function zName +** implemented by C function xFunc that accepts nArg arguments. The +** value passed as iArg is cast to a (void*) and made available +** as the user-data (sqlite3_user_data()) for the function. If +** argument bNC is true, then the SQLITE_FUNC_NEEDCOLL flag is set. +** +** VFUNCTION(zName, nArg, iArg, bNC, xFunc) +** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag. +** +** SFUNCTION(zName, nArg, iArg, bNC, xFunc) +** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag and +** adds the SQLITE_DIRECTONLY flag. +** +** INLINE_FUNC(zName, nArg, iFuncId, mFlags) +** zName is the name of a function that is implemented by in-line +** byte code rather than by the usual callbacks. The iFuncId +** parameter determines the function id. The mFlags parameter is +** optional SQLITE_FUNC_ flags for this function. +** +** TEST_FUNC(zName, nArg, iFuncId, mFlags) +** zName is the name of a test-only function implemented by in-line +** byte code rather than by the usual callbacks. The iFuncId +** parameter determines the function id. The mFlags parameter is +** optional SQLITE_FUNC_ flags for this function. +** +** DFUNCTION(zName, nArg, iArg, bNC, xFunc) +** Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag and +** adds the SQLITE_FUNC_SLOCHNG flag. Used for date & time functions +** and functions like sqlite_version() that can change, but not during +** a single query. The iArg is ignored. The user-data is always set +** to a NULL pointer. The bNC parameter is not used. +** +** MFUNCTION(zName, nArg, xPtr, xFunc) +** For math-library functions. xPtr is an arbitrary pointer. +** +** PURE_DATE(zName, nArg, iArg, bNC, xFunc) +** Used for "pure" date/time functions, this macro is like DFUNCTION +** except that it does set the SQLITE_FUNC_CONSTANT flags. iArg is +** ignored and the user-data for these functions is set to an +** arbitrary non-NULL pointer. The bNC parameter is not used. +** +** AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal) +** Used to create an aggregate function definition implemented by +** the C functions xStep and xFinal. The first four parameters +** are interpreted in the same way as the first 4 parameters to +** FUNCTION(). +** +** WAGGREGATE(zName, nArg, iArg, xStep, xFinal, xValue, xInverse) +** Used to create an aggregate function definition implemented by +** the C functions xStep and xFinal. The first four parameters +** are interpreted in the same way as the first 4 parameters to +** FUNCTION(). +** +** LIKEFUNC(zName, nArg, pArg, flags) +** Used to create a scalar function definition of a function zName +** that accepts nArg arguments and is implemented by a call to C +** function likeFunc. Argument pArg is cast to a (void *) and made +** available as the function user-data (sqlite3_user_data()). The +** FuncDef.flags variable is set to the value passed as the flags +** parameter. +*/ +#define FUNCTION(zName, nArg, iArg, bNC, xFunc) \ + {nArg, SQLITE_FUNC_BUILTIN|\ + SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \ + SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} } +#define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \ + {nArg, SQLITE_FUNC_BUILTIN|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \ + SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} } +#define SFUNCTION(zName, nArg, iArg, bNC, xFunc) \ + {nArg, SQLITE_FUNC_BUILTIN|SQLITE_UTF8|SQLITE_DIRECTONLY|SQLITE_FUNC_UNSAFE, \ + SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} } +#define MFUNCTION(zName, nArg, xPtr, xFunc) \ + {nArg, SQLITE_FUNC_BUILTIN|SQLITE_FUNC_CONSTANT|SQLITE_UTF8, \ + xPtr, 0, xFunc, 0, 0, 0, #zName, {0} } +#define JFUNCTION(zName, nArg, iArg, xFunc) \ + {nArg, SQLITE_FUNC_BUILTIN|SQLITE_DETERMINISTIC|\ + SQLITE_FUNC_CONSTANT|SQLITE_UTF8, \ + SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} } +#define INLINE_FUNC(zName, nArg, iArg, mFlags) \ + {nArg, SQLITE_FUNC_BUILTIN|\ + SQLITE_UTF8|SQLITE_FUNC_INLINE|SQLITE_FUNC_CONSTANT|(mFlags), \ + SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} } +#define TEST_FUNC(zName, nArg, iArg, mFlags) \ + {nArg, SQLITE_FUNC_BUILTIN|\ + SQLITE_UTF8|SQLITE_FUNC_INTERNAL|SQLITE_FUNC_TEST| \ + SQLITE_FUNC_INLINE|SQLITE_FUNC_CONSTANT|(mFlags), \ + SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} } +#define DFUNCTION(zName, nArg, iArg, bNC, xFunc) \ + {nArg, SQLITE_FUNC_BUILTIN|SQLITE_FUNC_SLOCHNG|SQLITE_UTF8, \ + 0, 0, xFunc, 0, 0, 0, #zName, {0} } +#define PURE_DATE(zName, nArg, iArg, bNC, xFunc) \ + {nArg, SQLITE_FUNC_BUILTIN|\ + SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \ + (void*)&sqlite3Config, 0, xFunc, 0, 0, 0, #zName, {0} } +#define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \ + {nArg, SQLITE_FUNC_BUILTIN|\ + SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags,\ + SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} } +#define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \ + {nArg, SQLITE_FUNC_BUILTIN|\ + SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \ + pArg, 0, xFunc, 0, 0, 0, #zName, } +#define LIKEFUNC(zName, nArg, arg, flags) \ + {nArg, SQLITE_FUNC_BUILTIN|SQLITE_FUNC_CONSTANT|SQLITE_UTF8|flags, \ + (void *)arg, 0, likeFunc, 0, 0, 0, #zName, {0} } +#define WAGGREGATE(zName, nArg, arg, nc, xStep, xFinal, xValue, xInverse, f) \ + {nArg, SQLITE_FUNC_BUILTIN|SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|f, \ + SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,xValue,xInverse,#zName, {0}} +#define INTERNAL_FUNCTION(zName, nArg, xFunc) \ + {nArg, SQLITE_FUNC_BUILTIN|\ + SQLITE_FUNC_INTERNAL|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \ + 0, 0, xFunc, 0, 0, 0, #zName, {0} } + + +/* +** All current savepoints are stored in a linked list starting at +** sqlite3.pSavepoint. The first element in the list is the most recently +** opened savepoint. Savepoints are added to the list by the vdbe +** OP_Savepoint instruction. +*/ +struct Savepoint { + char *zName; /* Savepoint name (nul-terminated) */ + i64 nDeferredCons; /* Number of deferred fk violations */ + i64 nDeferredImmCons; /* Number of deferred imm fk. */ + Savepoint *pNext; /* Parent savepoint (if any) */ +}; + +/* +** The following are used as the second parameter to sqlite3Savepoint(), +** and as the P1 argument to the OP_Savepoint instruction. +*/ +#define SAVEPOINT_BEGIN 0 +#define SAVEPOINT_RELEASE 1 +#define SAVEPOINT_ROLLBACK 2 + + +/* +** Each SQLite module (virtual table definition) is defined by an +** instance of the following structure, stored in the sqlite3.aModule +** hash table. +*/ +struct Module { + const sqlite3_module *pModule; /* Callback pointers */ + const char *zName; /* Name passed to create_module() */ + int nRefModule; /* Number of pointers to this object */ + void *pAux; /* pAux passed to create_module() */ + void (*xDestroy)(void *); /* Module destructor function */ + Table *pEpoTab; /* Eponymous table for this module */ +}; + +/* +** Information about each column of an SQL table is held in an instance +** of the Column structure, in the Table.aCol[] array. +** +** Definitions: +** +** "table column index" This is the index of the column in the +** Table.aCol[] array, and also the index of +** the column in the original CREATE TABLE stmt. +** +** "storage column index" This is the index of the column in the +** record BLOB generated by the OP_MakeRecord +** opcode. The storage column index is less than +** or equal to the table column index. It is +** equal if and only if there are no VIRTUAL +** columns to the left. +** +** Notes on zCnName: +** The zCnName field stores the name of the column, the datatype of the +** column, and the collating sequence for the column, in that order, all in +** a single allocation. Each string is 0x00 terminated. The datatype +** is only included if the COLFLAG_HASTYPE bit of colFlags is set and the +** collating sequence name is only included if the COLFLAG_HASCOLL bit is +** set. +*/ +struct Column { + char *zCnName; /* Name of this column */ + unsigned notNull :4; /* An OE_ code for handling a NOT NULL constraint */ + unsigned eCType :4; /* One of the standard types */ + char affinity; /* One of the SQLITE_AFF_... values */ + u8 szEst; /* Est size of value in this column. sizeof(INT)==1 */ + u8 hName; /* Column name hash for faster lookup */ + u16 iDflt; /* 1-based index of DEFAULT. 0 means "none" */ + u16 colFlags; /* Boolean properties. See COLFLAG_ defines below */ +}; + +/* Allowed values for Column.eCType. +** +** Values must match entries in the global constant arrays +** sqlite3StdTypeLen[] and sqlite3StdType[]. Each value is one more +** than the offset into these arrays for the corresponding name. +** Adjust the SQLITE_N_STDTYPE value if adding or removing entries. +*/ +#define COLTYPE_CUSTOM 0 /* Type appended to zName */ +#define COLTYPE_ANY 1 +#define COLTYPE_BLOB 2 +#define COLTYPE_INT 3 +#define COLTYPE_INTEGER 4 +#define COLTYPE_REAL 5 +#define COLTYPE_TEXT 6 +#define SQLITE_N_STDTYPE 6 /* Number of standard types */ + +/* Allowed values for Column.colFlags. +** +** Constraints: +** TF_HasVirtual == COLFLAG_VIRTUAL +** TF_HasStored == COLFLAG_STORED +** TF_HasHidden == COLFLAG_HIDDEN +*/ +#define COLFLAG_PRIMKEY 0x0001 /* Column is part of the primary key */ +#define COLFLAG_HIDDEN 0x0002 /* A hidden column in a virtual table */ +#define COLFLAG_HASTYPE 0x0004 /* Type name follows column name */ +#define COLFLAG_UNIQUE 0x0008 /* Column def contains "UNIQUE" or "PK" */ +#define COLFLAG_SORTERREF 0x0010 /* Use sorter-refs with this column */ +#define COLFLAG_VIRTUAL 0x0020 /* GENERATED ALWAYS AS ... VIRTUAL */ +#define COLFLAG_STORED 0x0040 /* GENERATED ALWAYS AS ... STORED */ +#define COLFLAG_NOTAVAIL 0x0080 /* STORED column not yet calculated */ +#define COLFLAG_BUSY 0x0100 /* Blocks recursion on GENERATED columns */ +#define COLFLAG_HASCOLL 0x0200 /* Has collating sequence name in zCnName */ +#define COLFLAG_NOEXPAND 0x0400 /* Omit this column when expanding "*" */ +#define COLFLAG_GENERATED 0x0060 /* Combo: _STORED, _VIRTUAL */ +#define COLFLAG_NOINSERT 0x0062 /* Combo: _HIDDEN, _STORED, _VIRTUAL */ + +/* +** A "Collating Sequence" is defined by an instance of the following +** structure. Conceptually, a collating sequence consists of a name and +** a comparison routine that defines the order of that sequence. +** +** If CollSeq.xCmp is NULL, it means that the +** collating sequence is undefined. Indices built on an undefined +** collating sequence may not be read or written. +*/ +struct CollSeq { + char *zName; /* Name of the collating sequence, UTF-8 encoded */ + u8 enc; /* Text encoding handled by xCmp() */ + void *pUser; /* First argument to xCmp() */ + int (*xCmp)(void*,int, const void*, int, const void*); + void (*xDel)(void*); /* Destructor for pUser */ +}; + +/* +** A sort order can be either ASC or DESC. +*/ +#define SQLITE_SO_ASC 0 /* Sort in ascending order */ +#define SQLITE_SO_DESC 1 /* Sort in ascending order */ +#define SQLITE_SO_UNDEFINED -1 /* No sort order specified */ + +/* +** Column affinity types. +** +** These used to have mnemonic name like 'i' for SQLITE_AFF_INTEGER and +** 't' for SQLITE_AFF_TEXT. But we can save a little space and improve +** the speed a little by numbering the values consecutively. +** +** But rather than start with 0 or 1, we begin with 'A'. That way, +** when multiple affinity types are concatenated into a string and +** used as the P4 operand, they will be more readable. +** +** Note also that the numeric types are grouped together so that testing +** for a numeric type is a single comparison. And the BLOB type is first. +*/ +#define SQLITE_AFF_NONE 0x40 /* '@' */ +#define SQLITE_AFF_BLOB 0x41 /* 'A' */ +#define SQLITE_AFF_TEXT 0x42 /* 'B' */ +#define SQLITE_AFF_NUMERIC 0x43 /* 'C' */ +#define SQLITE_AFF_INTEGER 0x44 /* 'D' */ +#define SQLITE_AFF_REAL 0x45 /* 'E' */ +#define SQLITE_AFF_FLEXNUM 0x46 /* 'F' */ + +#define sqlite3IsNumericAffinity(X) ((X)>=SQLITE_AFF_NUMERIC) + +/* +** The SQLITE_AFF_MASK values masks off the significant bits of an +** affinity value. +*/ +#define SQLITE_AFF_MASK 0x47 + +/* +** Additional bit values that can be ORed with an affinity without +** changing the affinity. +** +** The SQLITE_NOTNULL flag is a combination of NULLEQ and JUMPIFNULL. +** It causes an assert() to fire if either operand to a comparison +** operator is NULL. It is added to certain comparison operators to +** prove that the operands are always NOT NULL. +*/ +#define SQLITE_JUMPIFNULL 0x10 /* jumps if either operand is NULL */ +#define SQLITE_NULLEQ 0x80 /* NULL=NULL */ +#define SQLITE_NOTNULL 0x90 /* Assert that operands are never NULL */ + +/* +** An object of this type is created for each virtual table present in +** the database schema. +** +** If the database schema is shared, then there is one instance of this +** structure for each database connection (sqlite3*) that uses the shared +** schema. This is because each database connection requires its own unique +** instance of the sqlite3_vtab* handle used to access the virtual table +** implementation. sqlite3_vtab* handles can not be shared between +** database connections, even when the rest of the in-memory database +** schema is shared, as the implementation often stores the database +** connection handle passed to it via the xConnect() or xCreate() method +** during initialization internally. This database connection handle may +** then be used by the virtual table implementation to access real tables +** within the database. So that they appear as part of the callers +** transaction, these accesses need to be made via the same database +** connection as that used to execute SQL operations on the virtual table. +** +** All VTable objects that correspond to a single table in a shared +** database schema are initially stored in a linked-list pointed to by +** the Table.pVTable member variable of the corresponding Table object. +** When an sqlite3_prepare() operation is required to access the virtual +** table, it searches the list for the VTable that corresponds to the +** database connection doing the preparing so as to use the correct +** sqlite3_vtab* handle in the compiled query. +** +** When an in-memory Table object is deleted (for example when the +** schema is being reloaded for some reason), the VTable objects are not +** deleted and the sqlite3_vtab* handles are not xDisconnect()ed +** immediately. Instead, they are moved from the Table.pVTable list to +** another linked list headed by the sqlite3.pDisconnect member of the +** corresponding sqlite3 structure. They are then deleted/xDisconnected +** next time a statement is prepared using said sqlite3*. This is done +** to avoid deadlock issues involving multiple sqlite3.mutex mutexes. +** Refer to comments above function sqlite3VtabUnlockList() for an +** explanation as to why it is safe to add an entry to an sqlite3.pDisconnect +** list without holding the corresponding sqlite3.mutex mutex. +** +** The memory for objects of this type is always allocated by +** sqlite3DbMalloc(), using the connection handle stored in VTable.db as +** the first argument. +*/ +struct VTable { + sqlite3 *db; /* Database connection associated with this table */ + Module *pMod; /* Pointer to module implementation */ + sqlite3_vtab *pVtab; /* Pointer to vtab instance */ + int nRef; /* Number of pointers to this structure */ + u8 bConstraint; /* True if constraints are supported */ + u8 bAllSchemas; /* True if might use any attached schema */ + u8 eVtabRisk; /* Riskiness of allowing hacker access */ + int iSavepoint; /* Depth of the SAVEPOINT stack */ + VTable *pNext; /* Next in linked list (see above) */ +}; + +/* Allowed values for VTable.eVtabRisk +*/ +#define SQLITE_VTABRISK_Low 0 +#define SQLITE_VTABRISK_Normal 1 +#define SQLITE_VTABRISK_High 2 + +/* +** The schema for each SQL table, virtual table, and view is represented +** in memory by an instance of the following structure. +*/ +struct Table { + char *zName; /* Name of the table or view */ + Column *aCol; /* Information about each column */ + Index *pIndex; /* List of SQL indexes on this table. */ + char *zColAff; /* String defining the affinity of each column */ + ExprList *pCheck; /* All CHECK constraints */ + /* ... also used as column name list in a VIEW */ + Pgno tnum; /* Root BTree page for this table */ + u32 nTabRef; /* Number of pointers to this Table */ + u32 tabFlags; /* Mask of TF_* values */ + i16 iPKey; /* If not negative, use aCol[iPKey] as the rowid */ + i16 nCol; /* Number of columns in this table */ + i16 nNVCol; /* Number of columns that are not VIRTUAL */ + LogEst nRowLogEst; /* Estimated rows in table - from sqlite_stat1 table */ + LogEst szTabRow; /* Estimated size of each table row in bytes */ +#ifdef SQLITE_ENABLE_COSTMULT + LogEst costMult; /* Cost multiplier for using this table */ +#endif + u8 keyConf; /* What to do in case of uniqueness conflict on iPKey */ + u8 eTabType; /* 0: normal, 1: virtual, 2: view */ + union { + struct { /* Used by ordinary tables: */ + int addColOffset; /* Offset in CREATE TABLE stmt to add a new column */ + FKey *pFKey; /* Linked list of all foreign keys in this table */ + ExprList *pDfltList; /* DEFAULT clauses on various columns. + ** Or the AS clause for generated columns. */ + } tab; + struct { /* Used by views: */ + Select *pSelect; /* View definition */ + } view; + struct { /* Used by virtual tables only: */ + int nArg; /* Number of arguments to the module */ + char **azArg; /* 0: module 1: schema 2: vtab name 3...: args */ + VTable *p; /* List of VTable objects. */ + } vtab; + } u; + Trigger *pTrigger; /* List of triggers on this object */ + Schema *pSchema; /* Schema that contains this table */ +}; + +/* +** Allowed values for Table.tabFlags. +** +** TF_OOOHidden applies to tables or view that have hidden columns that are +** followed by non-hidden columns. Example: "CREATE VIRTUAL TABLE x USING +** vtab1(a HIDDEN, b);". Since "b" is a non-hidden column but "a" is hidden, +** the TF_OOOHidden attribute would apply in this case. Such tables require +** special handling during INSERT processing. The "OOO" means "Out Of Order". +** +** Constraints: +** +** TF_HasVirtual == COLFLAG_VIRTUAL +** TF_HasStored == COLFLAG_STORED +** TF_HasHidden == COLFLAG_HIDDEN +*/ +#define TF_Readonly 0x00000001 /* Read-only system table */ +#define TF_HasHidden 0x00000002 /* Has one or more hidden columns */ +#define TF_HasPrimaryKey 0x00000004 /* Table has a primary key */ +#define TF_Autoincrement 0x00000008 /* Integer primary key is autoincrement */ +#define TF_HasStat1 0x00000010 /* nRowLogEst set from sqlite_stat1 */ +#define TF_HasVirtual 0x00000020 /* Has one or more VIRTUAL columns */ +#define TF_HasStored 0x00000040 /* Has one or more STORED columns */ +#define TF_HasGenerated 0x00000060 /* Combo: HasVirtual + HasStored */ +#define TF_WithoutRowid 0x00000080 /* No rowid. PRIMARY KEY is the key */ +#define TF_StatsUsed 0x00000100 /* Query planner decisions affected by + ** Index.aiRowLogEst[] values */ +#define TF_NoVisibleRowid 0x00000200 /* No user-visible "rowid" column */ +#define TF_OOOHidden 0x00000400 /* Out-of-Order hidden columns */ +#define TF_HasNotNull 0x00000800 /* Contains NOT NULL constraints */ +#define TF_Shadow 0x00001000 /* True for a shadow table */ +#define TF_HasStat4 0x00002000 /* STAT4 info available for this table */ +#define TF_Ephemeral 0x00004000 /* An ephemeral table */ +#define TF_Eponymous 0x00008000 /* An eponymous virtual table */ +#define TF_Strict 0x00010000 /* STRICT mode */ + +/* +** Allowed values for Table.eTabType +*/ +#define TABTYP_NORM 0 /* Ordinary table */ +#define TABTYP_VTAB 1 /* Virtual table */ +#define TABTYP_VIEW 2 /* A view */ + +#define IsView(X) ((X)->eTabType==TABTYP_VIEW) +#define IsOrdinaryTable(X) ((X)->eTabType==TABTYP_NORM) + +/* +** Test to see whether or not a table is a virtual table. This is +** done as a macro so that it will be optimized out when virtual +** table support is omitted from the build. +*/ +#ifndef SQLITE_OMIT_VIRTUALTABLE +# define IsVirtual(X) ((X)->eTabType==TABTYP_VTAB) +# define ExprIsVtab(X) \ + ((X)->op==TK_COLUMN && (X)->y.pTab->eTabType==TABTYP_VTAB) +#else +# define IsVirtual(X) 0 +# define ExprIsVtab(X) 0 +#endif + +/* +** Macros to determine if a column is hidden. IsOrdinaryHiddenColumn() +** only works for non-virtual tables (ordinary tables and views) and is +** always false unless SQLITE_ENABLE_HIDDEN_COLUMNS is defined. The +** IsHiddenColumn() macro is general purpose. +*/ +#if defined(SQLITE_ENABLE_HIDDEN_COLUMNS) +# define IsHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0) +# define IsOrdinaryHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0) +#elif !defined(SQLITE_OMIT_VIRTUALTABLE) +# define IsHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0) +# define IsOrdinaryHiddenColumn(X) 0 +#else +# define IsHiddenColumn(X) 0 +# define IsOrdinaryHiddenColumn(X) 0 +#endif + + +/* Does the table have a rowid */ +#define HasRowid(X) (((X)->tabFlags & TF_WithoutRowid)==0) +#define VisibleRowid(X) (((X)->tabFlags & TF_NoVisibleRowid)==0) + +/* +** Each foreign key constraint is an instance of the following structure. +** +** A foreign key is associated with two tables. The "from" table is +** the table that contains the REFERENCES clause that creates the foreign +** key. The "to" table is the table that is named in the REFERENCES clause. +** Consider this example: +** +** CREATE TABLE ex1( +** a INTEGER PRIMARY KEY, +** b INTEGER CONSTRAINT fk1 REFERENCES ex2(x) +** ); +** +** For foreign key "fk1", the from-table is "ex1" and the to-table is "ex2". +** Equivalent names: +** +** from-table == child-table +** to-table == parent-table +** +** Each REFERENCES clause generates an instance of the following structure +** which is attached to the from-table. The to-table need not exist when +** the from-table is created. The existence of the to-table is not checked. +** +** The list of all parents for child Table X is held at X.pFKey. +** +** A list of all children for a table named Z (which might not even exist) +** is held in Schema.fkeyHash with a hash key of Z. +*/ +struct FKey { + Table *pFrom; /* Table containing the REFERENCES clause (aka: Child) */ + FKey *pNextFrom; /* Next FKey with the same in pFrom. Next parent of pFrom */ + char *zTo; /* Name of table that the key points to (aka: Parent) */ + FKey *pNextTo; /* Next with the same zTo. Next child of zTo. */ + FKey *pPrevTo; /* Previous with the same zTo */ + int nCol; /* Number of columns in this key */ + /* EV: R-30323-21917 */ + u8 isDeferred; /* True if constraint checking is deferred till COMMIT */ + u8 aAction[2]; /* ON DELETE and ON UPDATE actions, respectively */ + Trigger *apTrigger[2];/* Triggers for aAction[] actions */ + struct sColMap { /* Mapping of columns in pFrom to columns in zTo */ + int iFrom; /* Index of column in pFrom */ + char *zCol; /* Name of column in zTo. If NULL use PRIMARY KEY */ + } aCol[1]; /* One entry for each of nCol columns */ +}; + +/* +** SQLite supports many different ways to resolve a constraint +** error. ROLLBACK processing means that a constraint violation +** causes the operation in process to fail and for the current transaction +** to be rolled back. ABORT processing means the operation in process +** fails and any prior changes from that one operation are backed out, +** but the transaction is not rolled back. FAIL processing means that +** the operation in progress stops and returns an error code. But prior +** changes due to the same operation are not backed out and no rollback +** occurs. IGNORE means that the particular row that caused the constraint +** error is not inserted or updated. Processing continues and no error +** is returned. REPLACE means that preexisting database rows that caused +** a UNIQUE constraint violation are removed so that the new insert or +** update can proceed. Processing continues and no error is reported. +** UPDATE applies to insert operations only and means that the insert +** is omitted and the DO UPDATE clause of an upsert is run instead. +** +** RESTRICT, SETNULL, SETDFLT, and CASCADE actions apply only to foreign keys. +** RESTRICT is the same as ABORT for IMMEDIATE foreign keys and the +** same as ROLLBACK for DEFERRED keys. SETNULL means that the foreign +** key is set to NULL. SETDFLT means that the foreign key is set +** to its default value. CASCADE means that a DELETE or UPDATE of the +** referenced table row is propagated into the row that holds the +** foreign key. +** +** The OE_Default value is a place holder that means to use whatever +** conflict resolution algorthm is required from context. +** +** The following symbolic values are used to record which type +** of conflict resolution action to take. +*/ +#define OE_None 0 /* There is no constraint to check */ +#define OE_Rollback 1 /* Fail the operation and rollback the transaction */ +#define OE_Abort 2 /* Back out changes but do no rollback transaction */ +#define OE_Fail 3 /* Stop the operation but leave all prior changes */ +#define OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */ +#define OE_Replace 5 /* Delete existing record, then do INSERT or UPDATE */ +#define OE_Update 6 /* Process as a DO UPDATE in an upsert */ +#define OE_Restrict 7 /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */ +#define OE_SetNull 8 /* Set the foreign key value to NULL */ +#define OE_SetDflt 9 /* Set the foreign key value to its default */ +#define OE_Cascade 10 /* Cascade the changes */ +#define OE_Default 11 /* Do whatever the default action is */ + + +/* +** An instance of the following structure is passed as the first +** argument to sqlite3VdbeKeyCompare and is used to control the +** comparison of the two index keys. +** +** Note that aSortOrder[] and aColl[] have nField+1 slots. There +** are nField slots for the columns of an index then one extra slot +** for the rowid at the end. +*/ +struct KeyInfo { + u32 nRef; /* Number of references to this KeyInfo object */ + u8 enc; /* Text encoding - one of the SQLITE_UTF* values */ + u16 nKeyField; /* Number of key columns in the index */ + u16 nAllField; /* Total columns, including key plus others */ + sqlite3 *db; /* The database connection */ + u8 *aSortFlags; /* Sort order for each column. */ + CollSeq *aColl[1]; /* Collating sequence for each term of the key */ +}; + +/* +** Allowed bit values for entries in the KeyInfo.aSortFlags[] array. +*/ +#define KEYINFO_ORDER_DESC 0x01 /* DESC sort order */ +#define KEYINFO_ORDER_BIGNULL 0x02 /* NULL is larger than any other value */ + +/* +** This object holds a record which has been parsed out into individual +** fields, for the purposes of doing a comparison. +** +** A record is an object that contains one or more fields of data. +** Records are used to store the content of a table row and to store +** the key of an index. A blob encoding of a record is created by +** the OP_MakeRecord opcode of the VDBE and is disassembled by the +** OP_Column opcode. +** +** An instance of this object serves as a "key" for doing a search on +** an index b+tree. The goal of the search is to find the entry that +** is closed to the key described by this object. This object might hold +** just a prefix of the key. The number of fields is given by +** pKeyInfo->nField. +** +** The r1 and r2 fields are the values to return if this key is less than +** or greater than a key in the btree, respectively. These are normally +** -1 and +1 respectively, but might be inverted to +1 and -1 if the b-tree +** is in DESC order. +** +** The key comparison functions actually return default_rc when they find +** an equals comparison. default_rc can be -1, 0, or +1. If there are +** multiple entries in the b-tree with the same key (when only looking +** at the first pKeyInfo->nFields,) then default_rc can be set to -1 to +** cause the search to find the last match, or +1 to cause the search to +** find the first match. +** +** The key comparison functions will set eqSeen to true if they ever +** get and equal results when comparing this structure to a b-tree record. +** When default_rc!=0, the search might end up on the record immediately +** before the first match or immediately after the last match. The +** eqSeen field will indicate whether or not an exact match exists in the +** b-tree. +*/ +struct UnpackedRecord { + KeyInfo *pKeyInfo; /* Collation and sort-order information */ + Mem *aMem; /* Values */ + union { + char *z; /* Cache of aMem[0].z for vdbeRecordCompareString() */ + i64 i; /* Cache of aMem[0].u.i for vdbeRecordCompareInt() */ + } u; + int n; /* Cache of aMem[0].n used by vdbeRecordCompareString() */ + u16 nField; /* Number of entries in apMem[] */ + i8 default_rc; /* Comparison result if keys are equal */ + u8 errCode; /* Error detected by xRecordCompare (CORRUPT or NOMEM) */ + i8 r1; /* Value to return if (lhs < rhs) */ + i8 r2; /* Value to return if (lhs > rhs) */ + u8 eqSeen; /* True if an equality comparison has been seen */ +}; + + +/* +** Each SQL index is represented in memory by an +** instance of the following structure. +** +** The columns of the table that are to be indexed are described +** by the aiColumn[] field of this structure. For example, suppose +** we have the following table and index: +** +** CREATE TABLE Ex1(c1 int, c2 int, c3 text); +** CREATE INDEX Ex2 ON Ex1(c3,c1); +** +** In the Table structure describing Ex1, nCol==3 because there are +** three columns in the table. In the Index structure describing +** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed. +** The value of aiColumn is {2, 0}. aiColumn[0]==2 because the +** first column to be indexed (c3) has an index of 2 in Ex1.aCol[]. +** The second column to be indexed (c1) has an index of 0 in +** Ex1.aCol[], hence Ex2.aiColumn[1]==0. +** +** The Index.onError field determines whether or not the indexed columns +** must be unique and what to do if they are not. When Index.onError=OE_None, +** it means this is not a unique index. Otherwise it is a unique index +** and the value of Index.onError indicates which conflict resolution +** algorithm to employ when an attempt is made to insert a non-unique +** element. +** +** The colNotIdxed bitmask is used in combination with SrcItem.colUsed +** for a fast test to see if an index can serve as a covering index. +** colNotIdxed has a 1 bit for every column of the original table that +** is *not* available in the index. Thus the expression +** "colUsed & colNotIdxed" will be non-zero if the index is not a +** covering index. The most significant bit of of colNotIdxed will always +** be true (note-20221022-a). If a column beyond the 63rd column of the +** table is used, the "colUsed & colNotIdxed" test will always be non-zero +** and we have to assume either that the index is not covering, or use +** an alternative (slower) algorithm to determine whether or not +** the index is covering. +** +** While parsing a CREATE TABLE or CREATE INDEX statement in order to +** generate VDBE code (as opposed to parsing one read from an sqlite_schema +** table as part of parsing an existing database schema), transient instances +** of this structure may be created. In this case the Index.tnum variable is +** used to store the address of a VDBE instruction, not a database page +** number (it cannot - the database page is not allocated until the VDBE +** program is executed). See convertToWithoutRowidTable() for details. +*/ +struct Index { + char *zName; /* Name of this index */ + i16 *aiColumn; /* Which columns are used by this index. 1st is 0 */ + LogEst *aiRowLogEst; /* From ANALYZE: Est. rows selected by each column */ + Table *pTable; /* The SQL table being indexed */ + char *zColAff; /* String defining the affinity of each column */ + Index *pNext; /* The next index associated with the same table */ + Schema *pSchema; /* Schema containing this index */ + u8 *aSortOrder; /* for each column: True==DESC, False==ASC */ + const char **azColl; /* Array of collation sequence names for index */ + Expr *pPartIdxWhere; /* WHERE clause for partial indices */ + ExprList *aColExpr; /* Column expressions */ + Pgno tnum; /* DB Page containing root of this index */ + LogEst szIdxRow; /* Estimated average row size in bytes */ + u16 nKeyCol; /* Number of columns forming the key */ + u16 nColumn; /* Number of columns stored in the index */ + u8 onError; /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */ + unsigned idxType:2; /* 0:Normal 1:UNIQUE, 2:PRIMARY KEY, 3:IPK */ + unsigned bUnordered:1; /* Use this index for == or IN queries only */ + unsigned uniqNotNull:1; /* True if UNIQUE and NOT NULL for all columns */ + unsigned isResized:1; /* True if resizeIndexObject() has been called */ + unsigned isCovering:1; /* True if this is a covering index */ + unsigned noSkipScan:1; /* Do not try to use skip-scan if true */ + unsigned hasStat1:1; /* aiRowLogEst values come from sqlite_stat1 */ + unsigned bNoQuery:1; /* Do not use this index to optimize queries */ + unsigned bAscKeyBug:1; /* True if the bba7b69f9849b5bf bug applies */ + unsigned bHasVCol:1; /* Index references one or more VIRTUAL columns */ + unsigned bHasExpr:1; /* Index contains an expression, either a literal + ** expression, or a reference to a VIRTUAL column */ +#ifdef SQLITE_ENABLE_STAT4 + int nSample; /* Number of elements in aSample[] */ + int mxSample; /* Number of slots allocated to aSample[] */ + int nSampleCol; /* Size of IndexSample.anEq[] and so on */ + tRowcnt *aAvgEq; /* Average nEq values for keys not in aSample */ + IndexSample *aSample; /* Samples of the left-most key */ + tRowcnt *aiRowEst; /* Non-logarithmic stat1 data for this index */ + tRowcnt nRowEst0; /* Non-logarithmic number of rows in the index */ +#endif + Bitmask colNotIdxed; /* Unindexed columns in pTab */ +}; + +/* +** Allowed values for Index.idxType +*/ +#define SQLITE_IDXTYPE_APPDEF 0 /* Created using CREATE INDEX */ +#define SQLITE_IDXTYPE_UNIQUE 1 /* Implements a UNIQUE constraint */ +#define SQLITE_IDXTYPE_PRIMARYKEY 2 /* Is the PRIMARY KEY for the table */ +#define SQLITE_IDXTYPE_IPK 3 /* INTEGER PRIMARY KEY index */ + +/* Return true if index X is a PRIMARY KEY index */ +#define IsPrimaryKeyIndex(X) ((X)->idxType==SQLITE_IDXTYPE_PRIMARYKEY) + +/* Return true if index X is a UNIQUE index */ +#define IsUniqueIndex(X) ((X)->onError!=OE_None) + +/* The Index.aiColumn[] values are normally positive integer. But +** there are some negative values that have special meaning: +*/ +#define XN_ROWID (-1) /* Indexed column is the rowid */ +#define XN_EXPR (-2) /* Indexed column is an expression */ + +/* +** Each sample stored in the sqlite_stat4 table is represented in memory +** using a structure of this type. See documentation at the top of the +** analyze.c source file for additional information. +*/ +struct IndexSample { + void *p; /* Pointer to sampled record */ + int n; /* Size of record in bytes */ + tRowcnt *anEq; /* Est. number of rows where the key equals this sample */ + tRowcnt *anLt; /* Est. number of rows where key is less than this sample */ + tRowcnt *anDLt; /* Est. number of distinct keys less than this sample */ +}; + +/* +** Possible values to use within the flags argument to sqlite3GetToken(). +*/ +#define SQLITE_TOKEN_QUOTED 0x1 /* Token is a quoted identifier. */ +#define SQLITE_TOKEN_KEYWORD 0x2 /* Token is a keyword. */ + +/* +** Each token coming out of the lexer is an instance of +** this structure. Tokens are also used as part of an expression. +** +** The memory that "z" points to is owned by other objects. Take care +** that the owner of the "z" string does not deallocate the string before +** the Token goes out of scope! Very often, the "z" points to some place +** in the middle of the Parse.zSql text. But it might also point to a +** static string. +*/ +struct Token { + const char *z; /* Text of the token. Not NULL-terminated! */ + unsigned int n; /* Number of characters in this token */ +}; + +/* +** An instance of this structure contains information needed to generate +** code for a SELECT that contains aggregate functions. +** +** If Expr.op==TK_AGG_COLUMN or TK_AGG_FUNCTION then Expr.pAggInfo is a +** pointer to this structure. The Expr.iAgg field is the index in +** AggInfo.aCol[] or AggInfo.aFunc[] of information needed to generate +** code for that node. +** +** AggInfo.pGroupBy and AggInfo.aFunc.pExpr point to fields within the +** original Select structure that describes the SELECT statement. These +** fields do not need to be freed when deallocating the AggInfo structure. +*/ +struct AggInfo { + u8 directMode; /* Direct rendering mode means take data directly + ** from source tables rather than from accumulators */ + u8 useSortingIdx; /* In direct mode, reference the sorting index rather + ** than the source table */ + u16 nSortingColumn; /* Number of columns in the sorting index */ + int sortingIdx; /* Cursor number of the sorting index */ + int sortingIdxPTab; /* Cursor number of pseudo-table */ + int iFirstReg; /* First register in range for aCol[] and aFunc[] */ + ExprList *pGroupBy; /* The group by clause */ + struct AggInfo_col { /* For each column used in source tables */ + Table *pTab; /* Source table */ + Expr *pCExpr; /* The original expression */ + int iTable; /* Cursor number of the source table */ + i16 iColumn; /* Column number within the source table */ + i16 iSorterColumn; /* Column number in the sorting index */ + } *aCol; + int nColumn; /* Number of used entries in aCol[] */ + int nAccumulator; /* Number of columns that show through to the output. + ** Additional columns are used only as parameters to + ** aggregate functions */ + struct AggInfo_func { /* For each aggregate function */ + Expr *pFExpr; /* Expression encoding the function */ + FuncDef *pFunc; /* The aggregate function implementation */ + int iDistinct; /* Ephemeral table used to enforce DISTINCT */ + int iDistAddr; /* Address of OP_OpenEphemeral */ + } *aFunc; + int nFunc; /* Number of entries in aFunc[] */ + u32 selId; /* Select to which this AggInfo belongs */ +#ifdef SQLITE_DEBUG + Select *pSelect; /* SELECT statement that this AggInfo supports */ +#endif +}; + +/* +** Macros to compute aCol[] and aFunc[] register numbers. +** +** These macros should not be used prior to the call to +** assignAggregateRegisters() that computes the value of pAggInfo->iFirstReg. +** The assert()s that are part of this macro verify that constraint. +*/ +#define AggInfoColumnReg(A,I) (assert((A)->iFirstReg),(A)->iFirstReg+(I)) +#define AggInfoFuncReg(A,I) \ + (assert((A)->iFirstReg),(A)->iFirstReg+(A)->nColumn+(I)) + +/* +** The datatype ynVar is a signed integer, either 16-bit or 32-bit. +** Usually it is 16-bits. But if SQLITE_MAX_VARIABLE_NUMBER is greater +** than 32767 we have to make it 32-bit. 16-bit is preferred because +** it uses less memory in the Expr object, which is a big memory user +** in systems with lots of prepared statements. And few applications +** need more than about 10 or 20 variables. But some extreme users want +** to have prepared statements with over 32766 variables, and for them +** the option is available (at compile-time). +*/ +#if SQLITE_MAX_VARIABLE_NUMBER<32767 +typedef i16 ynVar; +#else +typedef int ynVar; +#endif + +/* +** Each node of an expression in the parse tree is an instance +** of this structure. +** +** Expr.op is the opcode. The integer parser token codes are reused +** as opcodes here. For example, the parser defines TK_GE to be an integer +** code representing the ">=" operator. This same integer code is reused +** to represent the greater-than-or-equal-to operator in the expression +** tree. +** +** If the expression is an SQL literal (TK_INTEGER, TK_FLOAT, TK_BLOB, +** or TK_STRING), then Expr.u.zToken contains the text of the SQL literal. If +** the expression is a variable (TK_VARIABLE), then Expr.u.zToken contains the +** variable name. Finally, if the expression is an SQL function (TK_FUNCTION), +** then Expr.u.zToken contains the name of the function. +** +** Expr.pRight and Expr.pLeft are the left and right subexpressions of a +** binary operator. Either or both may be NULL. +** +** Expr.x.pList is a list of arguments if the expression is an SQL function, +** a CASE expression or an IN expression of the form " IN (, ...)". +** Expr.x.pSelect is used if the expression is a sub-select or an expression of +** the form " IN (SELECT ...)". If the EP_xIsSelect bit is set in the +** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is +** valid. +** +** An expression of the form ID or ID.ID refers to a column in a table. +** For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is +** the integer cursor number of a VDBE cursor pointing to that table and +** Expr.iColumn is the column number for the specific column. If the +** expression is used as a result in an aggregate SELECT, then the +** value is also stored in the Expr.iAgg column in the aggregate so that +** it can be accessed after all aggregates are computed. +** +** If the expression is an unbound variable marker (a question mark +** character '?' in the original SQL) then the Expr.iTable holds the index +** number for that variable. +** +** If the expression is a subquery then Expr.iColumn holds an integer +** register number containing the result of the subquery. If the +** subquery gives a constant result, then iTable is -1. If the subquery +** gives a different answer at different times during statement processing +** then iTable is the address of a subroutine that computes the subquery. +** +** If the Expr is of type OP_Column, and the table it is selecting from +** is a disk table or the "old.*" pseudo-table, then pTab points to the +** corresponding table definition. +** +** ALLOCATION NOTES: +** +** Expr objects can use a lot of memory space in database schema. To +** help reduce memory requirements, sometimes an Expr object will be +** truncated. And to reduce the number of memory allocations, sometimes +** two or more Expr objects will be stored in a single memory allocation, +** together with Expr.u.zToken strings. +** +** If the EP_Reduced and EP_TokenOnly flags are set when +** an Expr object is truncated. When EP_Reduced is set, then all +** the child Expr objects in the Expr.pLeft and Expr.pRight subtrees +** are contained within the same memory allocation. Note, however, that +** the subtrees in Expr.x.pList or Expr.x.pSelect are always separately +** allocated, regardless of whether or not EP_Reduced is set. +*/ +struct Expr { + u8 op; /* Operation performed by this node */ + char affExpr; /* affinity, or RAISE type */ + u8 op2; /* TK_REGISTER/TK_TRUTH: original value of Expr.op + ** TK_COLUMN: the value of p5 for OP_Column + ** TK_AGG_FUNCTION: nesting depth + ** TK_FUNCTION: NC_SelfRef flag if needs OP_PureFunc */ +#ifdef SQLITE_DEBUG + u8 vvaFlags; /* Verification flags. */ +#endif + u32 flags; /* Various flags. EP_* See below */ + union { + char *zToken; /* Token value. Zero terminated and dequoted */ + int iValue; /* Non-negative integer value if EP_IntValue */ + } u; + + /* If the EP_TokenOnly flag is set in the Expr.flags mask, then no + ** space is allocated for the fields below this point. An attempt to + ** access them will result in a segfault or malfunction. + *********************************************************************/ + + Expr *pLeft; /* Left subnode */ + Expr *pRight; /* Right subnode */ + union { + ExprList *pList; /* op = IN, EXISTS, SELECT, CASE, FUNCTION, BETWEEN */ + Select *pSelect; /* EP_xIsSelect and op = IN, EXISTS, SELECT */ + } x; + + /* If the EP_Reduced flag is set in the Expr.flags mask, then no + ** space is allocated for the fields below this point. An attempt to + ** access them will result in a segfault or malfunction. + *********************************************************************/ + +#if SQLITE_MAX_EXPR_DEPTH>0 + int nHeight; /* Height of the tree headed by this node */ +#endif + int iTable; /* TK_COLUMN: cursor number of table holding column + ** TK_REGISTER: register number + ** TK_TRIGGER: 1 -> new, 0 -> old + ** EP_Unlikely: 134217728 times likelihood + ** TK_IN: ephemerial table holding RHS + ** TK_SELECT_COLUMN: Number of columns on the LHS + ** TK_SELECT: 1st register of result vector */ + ynVar iColumn; /* TK_COLUMN: column index. -1 for rowid. + ** TK_VARIABLE: variable number (always >= 1). + ** TK_SELECT_COLUMN: column of the result vector */ + i16 iAgg; /* Which entry in pAggInfo->aCol[] or ->aFunc[] */ + union { + int iJoin; /* If EP_OuterON or EP_InnerON, the right table */ + int iOfst; /* else: start of token from start of statement */ + } w; + AggInfo *pAggInfo; /* Used by TK_AGG_COLUMN and TK_AGG_FUNCTION */ + union { + Table *pTab; /* TK_COLUMN: Table containing column. Can be NULL + ** for a column of an index on an expression */ + Window *pWin; /* EP_WinFunc: Window/Filter defn for a function */ + struct { /* TK_IN, TK_SELECT, and TK_EXISTS */ + int iAddr; /* Subroutine entry address */ + int regReturn; /* Register used to hold return address */ + } sub; + } y; +}; + +/* The following are the meanings of bits in the Expr.flags field. +** Value restrictions: +** +** EP_Agg == NC_HasAgg == SF_HasAgg +** EP_Win == NC_HasWin +*/ +#define EP_OuterON 0x000001 /* Originates in ON/USING clause of outer join */ +#define EP_InnerON 0x000002 /* Originates in ON/USING of an inner join */ +#define EP_Distinct 0x000004 /* Aggregate function with DISTINCT keyword */ +#define EP_HasFunc 0x000008 /* Contains one or more functions of any kind */ +#define EP_Agg 0x000010 /* Contains one or more aggregate functions */ +#define EP_FixedCol 0x000020 /* TK_Column with a known fixed value */ +#define EP_VarSelect 0x000040 /* pSelect is correlated, not constant */ +#define EP_DblQuoted 0x000080 /* token.z was originally in "..." */ +#define EP_InfixFunc 0x000100 /* True for an infix function: LIKE, GLOB, etc */ +#define EP_Collate 0x000200 /* Tree contains a TK_COLLATE operator */ +#define EP_Commuted 0x000400 /* Comparison operator has been commuted */ +#define EP_IntValue 0x000800 /* Integer value contained in u.iValue */ +#define EP_xIsSelect 0x001000 /* x.pSelect is valid (otherwise x.pList is) */ +#define EP_Skip 0x002000 /* Operator does not contribute to affinity */ +#define EP_Reduced 0x004000 /* Expr struct EXPR_REDUCEDSIZE bytes only */ +#define EP_Win 0x008000 /* Contains window functions */ +#define EP_TokenOnly 0x010000 /* Expr struct EXPR_TOKENONLYSIZE bytes only */ + /* 0x020000 // Available for reuse */ +#define EP_IfNullRow 0x040000 /* The TK_IF_NULL_ROW opcode */ +#define EP_Unlikely 0x080000 /* unlikely() or likelihood() function */ +#define EP_ConstFunc 0x100000 /* A SQLITE_FUNC_CONSTANT or _SLOCHNG function */ +#define EP_CanBeNull 0x200000 /* Can be null despite NOT NULL constraint */ +#define EP_Subquery 0x400000 /* Tree contains a TK_SELECT operator */ +#define EP_Leaf 0x800000 /* Expr.pLeft, .pRight, .u.pSelect all NULL */ +#define EP_WinFunc 0x1000000 /* TK_FUNCTION with Expr.y.pWin set */ +#define EP_Subrtn 0x2000000 /* Uses Expr.y.sub. TK_IN, _SELECT, or _EXISTS */ +#define EP_Quoted 0x4000000 /* TK_ID was originally quoted */ +#define EP_Static 0x8000000 /* Held in memory not obtained from malloc() */ +#define EP_IsTrue 0x10000000 /* Always has boolean value of TRUE */ +#define EP_IsFalse 0x20000000 /* Always has boolean value of FALSE */ +#define EP_FromDDL 0x40000000 /* Originates from sqlite_schema */ + /* 0x80000000 // Available */ + +/* The EP_Propagate mask is a set of properties that automatically propagate +** upwards into parent nodes. +*/ +#define EP_Propagate (EP_Collate|EP_Subquery|EP_HasFunc) + +/* Macros can be used to test, set, or clear bits in the +** Expr.flags field. +*/ +#define ExprHasProperty(E,P) (((E)->flags&(P))!=0) +#define ExprHasAllProperty(E,P) (((E)->flags&(P))==(P)) +#define ExprSetProperty(E,P) (E)->flags|=(P) +#define ExprClearProperty(E,P) (E)->flags&=~(P) +#define ExprAlwaysTrue(E) (((E)->flags&(EP_OuterON|EP_IsTrue))==EP_IsTrue) +#define ExprAlwaysFalse(E) (((E)->flags&(EP_OuterON|EP_IsFalse))==EP_IsFalse) + +/* Macros used to ensure that the correct members of unions are accessed +** in Expr. +*/ +#define ExprUseUToken(E) (((E)->flags&EP_IntValue)==0) +#define ExprUseUValue(E) (((E)->flags&EP_IntValue)!=0) +#define ExprUseXList(E) (((E)->flags&EP_xIsSelect)==0) +#define ExprUseXSelect(E) (((E)->flags&EP_xIsSelect)!=0) +#define ExprUseYTab(E) (((E)->flags&(EP_WinFunc|EP_Subrtn))==0) +#define ExprUseYWin(E) (((E)->flags&EP_WinFunc)!=0) +#define ExprUseYSub(E) (((E)->flags&EP_Subrtn)!=0) + +/* Flags for use with Expr.vvaFlags +*/ +#define EP_NoReduce 0x01 /* Cannot EXPRDUP_REDUCE this Expr */ +#define EP_Immutable 0x02 /* Do not change this Expr node */ + +/* The ExprSetVVAProperty() macro is used for Verification, Validation, +** and Accreditation only. It works like ExprSetProperty() during VVA +** processes but is a no-op for delivery. +*/ +#ifdef SQLITE_DEBUG +# define ExprSetVVAProperty(E,P) (E)->vvaFlags|=(P) +# define ExprHasVVAProperty(E,P) (((E)->vvaFlags&(P))!=0) +# define ExprClearVVAProperties(E) (E)->vvaFlags = 0 +#else +# define ExprSetVVAProperty(E,P) +# define ExprHasVVAProperty(E,P) 0 +# define ExprClearVVAProperties(E) +#endif + +/* +** Macros to determine the number of bytes required by a normal Expr +** struct, an Expr struct with the EP_Reduced flag set in Expr.flags +** and an Expr struct with the EP_TokenOnly flag set. +*/ +#define EXPR_FULLSIZE sizeof(Expr) /* Full size */ +#define EXPR_REDUCEDSIZE offsetof(Expr,iTable) /* Common features */ +#define EXPR_TOKENONLYSIZE offsetof(Expr,pLeft) /* Fewer features */ + +/* +** Flags passed to the sqlite3ExprDup() function. See the header comment +** above sqlite3ExprDup() for details. +*/ +#define EXPRDUP_REDUCE 0x0001 /* Used reduced-size Expr nodes */ + +/* +** True if the expression passed as an argument was a function with +** an OVER() clause (a window function). +*/ +#ifdef SQLITE_OMIT_WINDOWFUNC +# define IsWindowFunc(p) 0 +#else +# define IsWindowFunc(p) ( \ + ExprHasProperty((p), EP_WinFunc) && p->y.pWin->eFrmType!=TK_FILTER \ + ) +#endif + +/* +** A list of expressions. Each expression may optionally have a +** name. An expr/name combination can be used in several ways, such +** as the list of "expr AS ID" fields following a "SELECT" or in the +** list of "ID = expr" items in an UPDATE. A list of expressions can +** also be used as the argument to a function, in which case the a.zName +** field is not used. +** +** In order to try to keep memory usage down, the Expr.a.zEName field +** is used for multiple purposes: +** +** eEName Usage +** ---------- ------------------------- +** ENAME_NAME (1) the AS of result set column +** (2) COLUMN= of an UPDATE +** +** ENAME_TAB DB.TABLE.NAME used to resolve names +** of subqueries +** +** ENAME_SPAN Text of the original result set +** expression. +*/ +struct ExprList { + int nExpr; /* Number of expressions on the list */ + int nAlloc; /* Number of a[] slots allocated */ + struct ExprList_item { /* For each expression in the list */ + Expr *pExpr; /* The parse tree for this expression */ + char *zEName; /* Token associated with this expression */ + struct { + u8 sortFlags; /* Mask of KEYINFO_ORDER_* flags */ + unsigned eEName :2; /* Meaning of zEName */ + unsigned done :1; /* Indicates when processing is finished */ + unsigned reusable :1; /* Constant expression is reusable */ + unsigned bSorterRef :1; /* Defer evaluation until after sorting */ + unsigned bNulls :1; /* True if explicit "NULLS FIRST/LAST" */ + unsigned bUsed :1; /* This column used in a SF_NestedFrom subquery */ + unsigned bUsingTerm:1; /* Term from the USING clause of a NestedFrom */ + unsigned bNoExpand: 1; /* Term is an auxiliary in NestedFrom and should + ** not be expanded by "*" in parent queries */ + } fg; + union { + struct { /* Used by any ExprList other than Parse.pConsExpr */ + u16 iOrderByCol; /* For ORDER BY, column number in result set */ + u16 iAlias; /* Index into Parse.aAlias[] for zName */ + } x; + int iConstExprReg; /* Register in which Expr value is cached. Used only + ** by Parse.pConstExpr */ + } u; + } a[1]; /* One slot for each expression in the list */ +}; + +/* +** Allowed values for Expr.a.eEName +*/ +#define ENAME_NAME 0 /* The AS clause of a result set */ +#define ENAME_SPAN 1 /* Complete text of the result set expression */ +#define ENAME_TAB 2 /* "DB.TABLE.NAME" for the result set */ + +/* +** An instance of this structure can hold a simple list of identifiers, +** such as the list "a,b,c" in the following statements: +** +** INSERT INTO t(a,b,c) VALUES ...; +** CREATE INDEX idx ON t(a,b,c); +** CREATE TRIGGER trig BEFORE UPDATE ON t(a,b,c) ...; +** +** The IdList.a.idx field is used when the IdList represents the list of +** column names after a table name in an INSERT statement. In the statement +** +** INSERT INTO t(a,b,c) ... +** +** If "a" is the k-th column of table "t", then IdList.a[0].idx==k. +*/ +struct IdList { + int nId; /* Number of identifiers on the list */ + u8 eU4; /* Which element of a.u4 is valid */ + struct IdList_item { + char *zName; /* Name of the identifier */ + union { + int idx; /* Index in some Table.aCol[] of a column named zName */ + Expr *pExpr; /* Expr to implement a USING variable -- NOT USED */ + } u4; + } a[1]; +}; + +/* +** Allowed values for IdList.eType, which determines which value of the a.u4 +** is valid. +*/ +#define EU4_NONE 0 /* Does not use IdList.a.u4 */ +#define EU4_IDX 1 /* Uses IdList.a.u4.idx */ +#define EU4_EXPR 2 /* Uses IdList.a.u4.pExpr -- NOT CURRENTLY USED */ + +/* +** The SrcItem object represents a single term in the FROM clause of a query. +** The SrcList object is mostly an array of SrcItems. +** +** The jointype starts out showing the join type between the current table +** and the next table on the list. The parser builds the list this way. +** But sqlite3SrcListShiftJoinType() later shifts the jointypes so that each +** jointype expresses the join between the table and the previous table. +** +** In the colUsed field, the high-order bit (bit 63) is set if the table +** contains more than 63 columns and the 64-th or later column is used. +** +** Union member validity: +** +** u1.zIndexedBy fg.isIndexedBy && !fg.isTabFunc +** u1.pFuncArg fg.isTabFunc && !fg.isIndexedBy +** u2.pIBIndex fg.isIndexedBy && !fg.isCte +** u2.pCteUse fg.isCte && !fg.isIndexedBy +*/ +struct SrcItem { + Schema *pSchema; /* Schema to which this item is fixed */ + char *zDatabase; /* Name of database holding this table */ + char *zName; /* Name of the table */ + char *zAlias; /* The "B" part of a "A AS B" phrase. zName is the "A" */ + Table *pTab; /* An SQL table corresponding to zName */ + Select *pSelect; /* A SELECT statement used in place of a table name */ + int addrFillSub; /* Address of subroutine to manifest a subquery */ + int regReturn; /* Register holding return address of addrFillSub */ + int regResult; /* Registers holding results of a co-routine */ + struct { + u8 jointype; /* Type of join between this table and the previous */ + unsigned notIndexed :1; /* True if there is a NOT INDEXED clause */ + unsigned isIndexedBy :1; /* True if there is an INDEXED BY clause */ + unsigned isTabFunc :1; /* True if table-valued-function syntax */ + unsigned isCorrelated :1; /* True if sub-query is correlated */ + unsigned isMaterialized:1; /* This is a materialized view */ + unsigned viaCoroutine :1; /* Implemented as a co-routine */ + unsigned isRecursive :1; /* True for recursive reference in WITH */ + unsigned fromDDL :1; /* Comes from sqlite_schema */ + unsigned isCte :1; /* This is a CTE */ + unsigned notCte :1; /* This item may not match a CTE */ + unsigned isUsing :1; /* u3.pUsing is valid */ + unsigned isOn :1; /* u3.pOn was once valid and non-NULL */ + unsigned isSynthUsing :1; /* u3.pUsing is synthensized from NATURAL */ + unsigned isNestedFrom :1; /* pSelect is a SF_NestedFrom subquery */ + } fg; + int iCursor; /* The VDBE cursor number used to access this table */ + union { + Expr *pOn; /* fg.isUsing==0 => The ON clause of a join */ + IdList *pUsing; /* fg.isUsing==1 => The USING clause of a join */ + } u3; + Bitmask colUsed; /* Bit N set if column N used. Details above for N>62 */ + union { + char *zIndexedBy; /* Identifier from "INDEXED BY " clause */ + ExprList *pFuncArg; /* Arguments to table-valued-function */ + } u1; + union { + Index *pIBIndex; /* Index structure corresponding to u1.zIndexedBy */ + CteUse *pCteUse; /* CTE Usage info when fg.isCte is true */ + } u2; +}; + +/* +** The OnOrUsing object represents either an ON clause or a USING clause. +** It can never be both at the same time, but it can be neither. +*/ +struct OnOrUsing { + Expr *pOn; /* The ON clause of a join */ + IdList *pUsing; /* The USING clause of a join */ +}; + +/* +** This object represents one or more tables that are the source of +** content for an SQL statement. For example, a single SrcList object +** is used to hold the FROM clause of a SELECT statement. SrcList also +** represents the target tables for DELETE, INSERT, and UPDATE statements. +** +*/ +struct SrcList { + int nSrc; /* Number of tables or subqueries in the FROM clause */ + u32 nAlloc; /* Number of entries allocated in a[] below */ + SrcItem a[1]; /* One entry for each identifier on the list */ +}; + +/* +** Permitted values of the SrcList.a.jointype field +*/ +#define JT_INNER 0x01 /* Any kind of inner or cross join */ +#define JT_CROSS 0x02 /* Explicit use of the CROSS keyword */ +#define JT_NATURAL 0x04 /* True for a "natural" join */ +#define JT_LEFT 0x08 /* Left outer join */ +#define JT_RIGHT 0x10 /* Right outer join */ +#define JT_OUTER 0x20 /* The "OUTER" keyword is present */ +#define JT_LTORJ 0x40 /* One of the LEFT operands of a RIGHT JOIN + ** Mnemonic: Left Table Of Right Join */ +#define JT_ERROR 0x80 /* unknown or unsupported join type */ + +/* +** Flags appropriate for the wctrlFlags parameter of sqlite3WhereBegin() +** and the WhereInfo.wctrlFlags member. +** +** Value constraints (enforced via assert()): +** WHERE_USE_LIMIT == SF_FixedLimit +*/ +#define WHERE_ORDERBY_NORMAL 0x0000 /* No-op */ +#define WHERE_ORDERBY_MIN 0x0001 /* ORDER BY processing for min() func */ +#define WHERE_ORDERBY_MAX 0x0002 /* ORDER BY processing for max() func */ +#define WHERE_ONEPASS_DESIRED 0x0004 /* Want to do one-pass UPDATE/DELETE */ +#define WHERE_ONEPASS_MULTIROW 0x0008 /* ONEPASS is ok with multiple rows */ +#define WHERE_DUPLICATES_OK 0x0010 /* Ok to return a row more than once */ +#define WHERE_OR_SUBCLAUSE 0x0020 /* Processing a sub-WHERE as part of + ** the OR optimization */ +#define WHERE_GROUPBY 0x0040 /* pOrderBy is really a GROUP BY */ +#define WHERE_DISTINCTBY 0x0080 /* pOrderby is really a DISTINCT clause */ +#define WHERE_WANT_DISTINCT 0x0100 /* All output needs to be distinct */ +#define WHERE_SORTBYGROUP 0x0200 /* Support sqlite3WhereIsSorted() */ +#define WHERE_AGG_DISTINCT 0x0400 /* Query is "SELECT agg(DISTINCT ...)" */ +#define WHERE_ORDERBY_LIMIT 0x0800 /* ORDERBY+LIMIT on the inner loop */ +#define WHERE_RIGHT_JOIN 0x1000 /* Processing a RIGHT JOIN */ + /* 0x2000 not currently used */ +#define WHERE_USE_LIMIT 0x4000 /* Use the LIMIT in cost estimates */ + /* 0x8000 not currently used */ + +/* Allowed return values from sqlite3WhereIsDistinct() +*/ +#define WHERE_DISTINCT_NOOP 0 /* DISTINCT keyword not used */ +#define WHERE_DISTINCT_UNIQUE 1 /* No duplicates */ +#define WHERE_DISTINCT_ORDERED 2 /* All duplicates are adjacent */ +#define WHERE_DISTINCT_UNORDERED 3 /* Duplicates are scattered */ + +/* +** A NameContext defines a context in which to resolve table and column +** names. The context consists of a list of tables (the pSrcList) field and +** a list of named expression (pEList). The named expression list may +** be NULL. The pSrc corresponds to the FROM clause of a SELECT or +** to the table being operated on by INSERT, UPDATE, or DELETE. The +** pEList corresponds to the result set of a SELECT and is NULL for +** other statements. +** +** NameContexts can be nested. When resolving names, the inner-most +** context is searched first. If no match is found, the next outer +** context is checked. If there is still no match, the next context +** is checked. This process continues until either a match is found +** or all contexts are check. When a match is found, the nRef member of +** the context containing the match is incremented. +** +** Each subquery gets a new NameContext. The pNext field points to the +** NameContext in the parent query. Thus the process of scanning the +** NameContext list corresponds to searching through successively outer +** subqueries looking for a match. +*/ +struct NameContext { + Parse *pParse; /* The parser */ + SrcList *pSrcList; /* One or more tables used to resolve names */ + union { + ExprList *pEList; /* Optional list of result-set columns */ + AggInfo *pAggInfo; /* Information about aggregates at this level */ + Upsert *pUpsert; /* ON CONFLICT clause information from an upsert */ + int iBaseReg; /* For TK_REGISTER when parsing RETURNING */ + } uNC; + NameContext *pNext; /* Next outer name context. NULL for outermost */ + int nRef; /* Number of names resolved by this context */ + int nNcErr; /* Number of errors encountered while resolving names */ + int ncFlags; /* Zero or more NC_* flags defined below */ + Select *pWinSelect; /* SELECT statement for any window functions */ +}; + +/* +** Allowed values for the NameContext, ncFlags field. +** +** Value constraints (all checked via assert()): +** NC_HasAgg == SF_HasAgg == EP_Agg +** NC_MinMaxAgg == SF_MinMaxAgg == SQLITE_FUNC_MINMAX +** NC_OrderAgg == SF_OrderByReqd == SQLITE_FUNC_ANYORDER +** NC_HasWin == EP_Win +** +*/ +#define NC_AllowAgg 0x000001 /* Aggregate functions are allowed here */ +#define NC_PartIdx 0x000002 /* True if resolving a partial index WHERE */ +#define NC_IsCheck 0x000004 /* True if resolving a CHECK constraint */ +#define NC_GenCol 0x000008 /* True for a GENERATED ALWAYS AS clause */ +#define NC_HasAgg 0x000010 /* One or more aggregate functions seen */ +#define NC_IdxExpr 0x000020 /* True if resolving columns of CREATE INDEX */ +#define NC_SelfRef 0x00002e /* Combo: PartIdx, isCheck, GenCol, and IdxExpr */ +#define NC_Subquery 0x000040 /* A subquery has been seen */ +#define NC_UEList 0x000080 /* True if uNC.pEList is used */ +#define NC_UAggInfo 0x000100 /* True if uNC.pAggInfo is used */ +#define NC_UUpsert 0x000200 /* True if uNC.pUpsert is used */ +#define NC_UBaseReg 0x000400 /* True if uNC.iBaseReg is used */ +#define NC_MinMaxAgg 0x001000 /* min/max aggregates seen. See note above */ +#define NC_Complex 0x002000 /* True if a function or subquery seen */ +#define NC_AllowWin 0x004000 /* Window functions are allowed here */ +#define NC_HasWin 0x008000 /* One or more window functions seen */ +#define NC_IsDDL 0x010000 /* Resolving names in a CREATE statement */ +#define NC_InAggFunc 0x020000 /* True if analyzing arguments to an agg func */ +#define NC_FromDDL 0x040000 /* SQL text comes from sqlite_schema */ +#define NC_NoSelect 0x080000 /* Do not descend into sub-selects */ +#define NC_OrderAgg 0x8000000 /* Has an aggregate other than count/min/max */ + +/* +** An instance of the following object describes a single ON CONFLICT +** clause in an upsert. +** +** The pUpsertTarget field is only set if the ON CONFLICT clause includes +** conflict-target clause. (In "ON CONFLICT(a,b)" the "(a,b)" is the +** conflict-target clause.) The pUpsertTargetWhere is the optional +** WHERE clause used to identify partial unique indexes. +** +** pUpsertSet is the list of column=expr terms of the UPDATE statement. +** The pUpsertSet field is NULL for a ON CONFLICT DO NOTHING. The +** pUpsertWhere is the WHERE clause for the UPDATE and is NULL if the +** WHERE clause is omitted. +*/ +struct Upsert { + ExprList *pUpsertTarget; /* Optional description of conflict target */ + Expr *pUpsertTargetWhere; /* WHERE clause for partial index targets */ + ExprList *pUpsertSet; /* The SET clause from an ON CONFLICT UPDATE */ + Expr *pUpsertWhere; /* WHERE clause for the ON CONFLICT UPDATE */ + Upsert *pNextUpsert; /* Next ON CONFLICT clause in the list */ + u8 isDoUpdate; /* True for DO UPDATE. False for DO NOTHING */ + /* Above this point is the parse tree for the ON CONFLICT clauses. + ** The next group of fields stores intermediate data. */ + void *pToFree; /* Free memory when deleting the Upsert object */ + /* All fields above are owned by the Upsert object and must be freed + ** when the Upsert is destroyed. The fields below are used to transfer + ** information from the INSERT processing down into the UPDATE processing + ** while generating code. The fields below are owned by the INSERT + ** statement and will be freed by INSERT processing. */ + Index *pUpsertIdx; /* UNIQUE constraint specified by pUpsertTarget */ + SrcList *pUpsertSrc; /* Table to be updated */ + int regData; /* First register holding array of VALUES */ + int iDataCur; /* Index of the data cursor */ + int iIdxCur; /* Index of the first index cursor */ +}; + +/* +** An instance of the following structure contains all information +** needed to generate code for a single SELECT statement. +** +** See the header comment on the computeLimitRegisters() routine for a +** detailed description of the meaning of the iLimit and iOffset fields. +** +** addrOpenEphm[] entries contain the address of OP_OpenEphemeral opcodes. +** These addresses must be stored so that we can go back and fill in +** the P4_KEYINFO and P2 parameters later. Neither the KeyInfo nor +** the number of columns in P2 can be computed at the same time +** as the OP_OpenEphm instruction is coded because not +** enough information about the compound query is known at that point. +** The KeyInfo for addrOpenTran[0] and [1] contains collating sequences +** for the result set. The KeyInfo for addrOpenEphm[2] contains collating +** sequences for the ORDER BY clause. +*/ +struct Select { + u8 op; /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */ + LogEst nSelectRow; /* Estimated number of result rows */ + u32 selFlags; /* Various SF_* values */ + int iLimit, iOffset; /* Memory registers holding LIMIT & OFFSET counters */ + u32 selId; /* Unique identifier number for this SELECT */ + int addrOpenEphm[2]; /* OP_OpenEphem opcodes related to this select */ + ExprList *pEList; /* The fields of the result */ + SrcList *pSrc; /* The FROM clause */ + Expr *pWhere; /* The WHERE clause */ + ExprList *pGroupBy; /* The GROUP BY clause */ + Expr *pHaving; /* The HAVING clause */ + ExprList *pOrderBy; /* The ORDER BY clause */ + Select *pPrior; /* Prior select in a compound select statement */ + Select *pNext; /* Next select to the left in a compound */ + Expr *pLimit; /* LIMIT expression. NULL means not used. */ + With *pWith; /* WITH clause attached to this select. Or NULL. */ +#ifndef SQLITE_OMIT_WINDOWFUNC + Window *pWin; /* List of window functions */ + Window *pWinDefn; /* List of named window definitions */ +#endif +}; + +/* +** Allowed values for Select.selFlags. The "SF" prefix stands for +** "Select Flag". +** +** Value constraints (all checked via assert()) +** SF_HasAgg == NC_HasAgg +** SF_MinMaxAgg == NC_MinMaxAgg == SQLITE_FUNC_MINMAX +** SF_OrderByReqd == NC_OrderAgg == SQLITE_FUNC_ANYORDER +** SF_FixedLimit == WHERE_USE_LIMIT +*/ +#define SF_Distinct 0x0000001 /* Output should be DISTINCT */ +#define SF_All 0x0000002 /* Includes the ALL keyword */ +#define SF_Resolved 0x0000004 /* Identifiers have been resolved */ +#define SF_Aggregate 0x0000008 /* Contains agg functions or a GROUP BY */ +#define SF_HasAgg 0x0000010 /* Contains aggregate functions */ +#define SF_UsesEphemeral 0x0000020 /* Uses the OpenEphemeral opcode */ +#define SF_Expanded 0x0000040 /* sqlite3SelectExpand() called on this */ +#define SF_HasTypeInfo 0x0000080 /* FROM subqueries have Table metadata */ +#define SF_Compound 0x0000100 /* Part of a compound query */ +#define SF_Values 0x0000200 /* Synthesized from VALUES clause */ +#define SF_MultiValue 0x0000400 /* Single VALUES term with multiple rows */ +#define SF_NestedFrom 0x0000800 /* Part of a parenthesized FROM clause */ +#define SF_MinMaxAgg 0x0001000 /* Aggregate containing min() or max() */ +#define SF_Recursive 0x0002000 /* The recursive part of a recursive CTE */ +#define SF_FixedLimit 0x0004000 /* nSelectRow set by a constant LIMIT */ +#define SF_MaybeConvert 0x0008000 /* Need convertCompoundSelectToSubquery() */ +#define SF_Converted 0x0010000 /* By convertCompoundSelectToSubquery() */ +#define SF_IncludeHidden 0x0020000 /* Include hidden columns in output */ +#define SF_ComplexResult 0x0040000 /* Result contains subquery or function */ +#define SF_WhereBegin 0x0080000 /* Really a WhereBegin() call. Debug Only */ +#define SF_WinRewrite 0x0100000 /* Window function rewrite accomplished */ +#define SF_View 0x0200000 /* SELECT statement is a view */ +#define SF_NoopOrderBy 0x0400000 /* ORDER BY is ignored for this query */ +#define SF_UFSrcCheck 0x0800000 /* Check pSrc as required by UPDATE...FROM */ +#define SF_PushDown 0x1000000 /* SELECT has be modified by push-down opt */ +#define SF_MultiPart 0x2000000 /* Has multiple incompatible PARTITIONs */ +#define SF_CopyCte 0x4000000 /* SELECT statement is a copy of a CTE */ +#define SF_OrderByReqd 0x8000000 /* The ORDER BY clause may not be omitted */ +#define SF_UpdateFrom 0x10000000 /* Query originates with UPDATE FROM */ + +/* True if S exists and has SF_NestedFrom */ +#define IsNestedFrom(S) ((S)!=0 && ((S)->selFlags&SF_NestedFrom)!=0) + +/* +** The results of a SELECT can be distributed in several ways, as defined +** by one of the following macros. The "SRT" prefix means "SELECT Result +** Type". +** +** SRT_Union Store results as a key in a temporary index +** identified by pDest->iSDParm. +** +** SRT_Except Remove results from the temporary index pDest->iSDParm. +** +** SRT_Exists Store a 1 in memory cell pDest->iSDParm if the result +** set is not empty. +** +** SRT_Discard Throw the results away. This is used by SELECT +** statements within triggers whose only purpose is +** the side-effects of functions. +** +** SRT_Output Generate a row of output (using the OP_ResultRow +** opcode) for each row in the result set. +** +** SRT_Mem Only valid if the result is a single column. +** Store the first column of the first result row +** in register pDest->iSDParm then abandon the rest +** of the query. This destination implies "LIMIT 1". +** +** SRT_Set The result must be a single column. Store each +** row of result as the key in table pDest->iSDParm. +** Apply the affinity pDest->affSdst before storing +** results. Used to implement "IN (SELECT ...)". +** +** SRT_EphemTab Create an temporary table pDest->iSDParm and store +** the result there. The cursor is left open after +** returning. This is like SRT_Table except that +** this destination uses OP_OpenEphemeral to create +** the table first. +** +** SRT_Coroutine Generate a co-routine that returns a new row of +** results each time it is invoked. The entry point +** of the co-routine is stored in register pDest->iSDParm +** and the result row is stored in pDest->nDest registers +** starting with pDest->iSdst. +** +** SRT_Table Store results in temporary table pDest->iSDParm. +** SRT_Fifo This is like SRT_EphemTab except that the table +** is assumed to already be open. SRT_Fifo has +** the additional property of being able to ignore +** the ORDER BY clause. +** +** SRT_DistFifo Store results in a temporary table pDest->iSDParm. +** But also use temporary table pDest->iSDParm+1 as +** a record of all prior results and ignore any duplicate +** rows. Name means: "Distinct Fifo". +** +** SRT_Queue Store results in priority queue pDest->iSDParm (really +** an index). Append a sequence number so that all entries +** are distinct. +** +** SRT_DistQueue Store results in priority queue pDest->iSDParm only if +** the same record has never been stored before. The +** index at pDest->iSDParm+1 hold all prior stores. +** +** SRT_Upfrom Store results in the temporary table already opened by +** pDest->iSDParm. If (pDest->iSDParm<0), then the temp +** table is an intkey table - in this case the first +** column returned by the SELECT is used as the integer +** key. If (pDest->iSDParm>0), then the table is an index +** table. (pDest->iSDParm) is the number of key columns in +** each index record in this case. +*/ +#define SRT_Union 1 /* Store result as keys in an index */ +#define SRT_Except 2 /* Remove result from a UNION index */ +#define SRT_Exists 3 /* Store 1 if the result is not empty */ +#define SRT_Discard 4 /* Do not save the results anywhere */ +#define SRT_DistFifo 5 /* Like SRT_Fifo, but unique results only */ +#define SRT_DistQueue 6 /* Like SRT_Queue, but unique results only */ + +/* The DISTINCT clause is ignored for all of the above. Not that +** IgnorableDistinct() implies IgnorableOrderby() */ +#define IgnorableDistinct(X) ((X->eDest)<=SRT_DistQueue) + +#define SRT_Queue 7 /* Store result in an queue */ +#define SRT_Fifo 8 /* Store result as data with an automatic rowid */ + +/* The ORDER BY clause is ignored for all of the above */ +#define IgnorableOrderby(X) ((X->eDest)<=SRT_Fifo) + +#define SRT_Output 9 /* Output each row of result */ +#define SRT_Mem 10 /* Store result in a memory cell */ +#define SRT_Set 11 /* Store results as keys in an index */ +#define SRT_EphemTab 12 /* Create transient tab and store like SRT_Table */ +#define SRT_Coroutine 13 /* Generate a single row of result */ +#define SRT_Table 14 /* Store result as data with an automatic rowid */ +#define SRT_Upfrom 15 /* Store result as data with rowid */ + +/* +** An instance of this object describes where to put of the results of +** a SELECT statement. +*/ +struct SelectDest { + u8 eDest; /* How to dispose of the results. One of SRT_* above. */ + int iSDParm; /* A parameter used by the eDest disposal method */ + int iSDParm2; /* A second parameter for the eDest disposal method */ + int iSdst; /* Base register where results are written */ + int nSdst; /* Number of registers allocated */ + char *zAffSdst; /* Affinity used for SRT_Set */ + ExprList *pOrderBy; /* Key columns for SRT_Queue and SRT_DistQueue */ +}; + +/* +** During code generation of statements that do inserts into AUTOINCREMENT +** tables, the following information is attached to the Table.u.autoInc.p +** pointer of each autoincrement table to record some side information that +** the code generator needs. We have to keep per-table autoincrement +** information in case inserts are done within triggers. Triggers do not +** normally coordinate their activities, but we do need to coordinate the +** loading and saving of autoincrement information. +*/ +struct AutoincInfo { + AutoincInfo *pNext; /* Next info block in a list of them all */ + Table *pTab; /* Table this info block refers to */ + int iDb; /* Index in sqlite3.aDb[] of database holding pTab */ + int regCtr; /* Memory register holding the rowid counter */ +}; + +/* +** At least one instance of the following structure is created for each +** trigger that may be fired while parsing an INSERT, UPDATE or DELETE +** statement. All such objects are stored in the linked list headed at +** Parse.pTriggerPrg and deleted once statement compilation has been +** completed. +** +** A Vdbe sub-program that implements the body and WHEN clause of trigger +** TriggerPrg.pTrigger, assuming a default ON CONFLICT clause of +** TriggerPrg.orconf, is stored in the TriggerPrg.pProgram variable. +** The Parse.pTriggerPrg list never contains two entries with the same +** values for both pTrigger and orconf. +** +** The TriggerPrg.aColmask[0] variable is set to a mask of old.* columns +** accessed (or set to 0 for triggers fired as a result of INSERT +** statements). Similarly, the TriggerPrg.aColmask[1] variable is set to +** a mask of new.* columns used by the program. +*/ +struct TriggerPrg { + Trigger *pTrigger; /* Trigger this program was coded from */ + TriggerPrg *pNext; /* Next entry in Parse.pTriggerPrg list */ + SubProgram *pProgram; /* Program implementing pTrigger/orconf */ + int orconf; /* Default ON CONFLICT policy */ + u32 aColmask[2]; /* Masks of old.*, new.* columns accessed */ +}; + +/* +** The yDbMask datatype for the bitmask of all attached databases. +*/ +#if SQLITE_MAX_ATTACHED>30 + typedef unsigned char yDbMask[(SQLITE_MAX_ATTACHED+9)/8]; +# define DbMaskTest(M,I) (((M)[(I)/8]&(1<<((I)&7)))!=0) +# define DbMaskZero(M) memset((M),0,sizeof(M)) +# define DbMaskSet(M,I) (M)[(I)/8]|=(1<<((I)&7)) +# define DbMaskAllZero(M) sqlite3DbMaskAllZero(M) +# define DbMaskNonZero(M) (sqlite3DbMaskAllZero(M)==0) +#else + typedef unsigned int yDbMask; +# define DbMaskTest(M,I) (((M)&(((yDbMask)1)<<(I)))!=0) +# define DbMaskZero(M) ((M)=0) +# define DbMaskSet(M,I) ((M)|=(((yDbMask)1)<<(I))) +# define DbMaskAllZero(M) ((M)==0) +# define DbMaskNonZero(M) ((M)!=0) +#endif + +/* +** For each index X that has as one of its arguments either an expression +** or the name of a virtual generated column, and if X is in scope such that +** the value of the expression can simply be read from the index, then +** there is an instance of this object on the Parse.pIdxExpr list. +** +** During code generation, while generating code to evaluate expressions, +** this list is consulted and if a matching expression is found, the value +** is read from the index rather than being recomputed. +*/ +struct IndexedExpr { + Expr *pExpr; /* The expression contained in the index */ + int iDataCur; /* The data cursor associated with the index */ + int iIdxCur; /* The index cursor */ + int iIdxCol; /* The index column that contains value of pExpr */ + u8 bMaybeNullRow; /* True if we need an OP_IfNullRow check */ + u8 aff; /* Affinity of the pExpr expression */ + IndexedExpr *pIENext; /* Next in a list of all indexed expressions */ +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + const char *zIdxName; /* Name of index, used only for bytecode comments */ +#endif +}; + +/* +** An instance of the ParseCleanup object specifies an operation that +** should be performed after parsing to deallocation resources obtained +** during the parse and which are no longer needed. +*/ +struct ParseCleanup { + ParseCleanup *pNext; /* Next cleanup task */ + void *pPtr; /* Pointer to object to deallocate */ + void (*xCleanup)(sqlite3*,void*); /* Deallocation routine */ +}; + +/* +** An SQL parser context. A copy of this structure is passed through +** the parser and down into all the parser action routine in order to +** carry around information that is global to the entire parse. +** +** The structure is divided into two parts. When the parser and code +** generate call themselves recursively, the first part of the structure +** is constant but the second part is reset at the beginning and end of +** each recursion. +** +** The nTableLock and aTableLock variables are only used if the shared-cache +** feature is enabled (if sqlite3Tsd()->useSharedData is true). They are +** used to store the set of table-locks required by the statement being +** compiled. Function sqlite3TableLock() is used to add entries to the +** list. +*/ +struct Parse { + sqlite3 *db; /* The main database structure */ + char *zErrMsg; /* An error message */ + Vdbe *pVdbe; /* An engine for executing database bytecode */ + int rc; /* Return code from execution */ + u8 colNamesSet; /* TRUE after OP_ColumnName has been issued to pVdbe */ + u8 checkSchema; /* Causes schema cookie check after an error */ + u8 nested; /* Number of nested calls to the parser/code generator */ + u8 nTempReg; /* Number of temporary registers in aTempReg[] */ + u8 isMultiWrite; /* True if statement may modify/insert multiple rows */ + u8 mayAbort; /* True if statement may throw an ABORT exception */ + u8 hasCompound; /* Need to invoke convertCompoundSelectToSubquery() */ + u8 okConstFactor; /* OK to factor out constants */ + u8 disableLookaside; /* Number of times lookaside has been disabled */ + u8 prepFlags; /* SQLITE_PREPARE_* flags */ + u8 withinRJSubrtn; /* Nesting level for RIGHT JOIN body subroutines */ +#if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST) + u8 earlyCleanup; /* OOM inside sqlite3ParserAddCleanup() */ +#endif +#ifdef SQLITE_DEBUG + u8 ifNotExists; /* Might be true if IF NOT EXISTS. Assert()s only */ +#endif + int nRangeReg; /* Size of the temporary register block */ + int iRangeReg; /* First register in temporary register block */ + int nErr; /* Number of errors seen */ + int nTab; /* Number of previously allocated VDBE cursors */ + int nMem; /* Number of memory cells used so far */ + int szOpAlloc; /* Bytes of memory space allocated for Vdbe.aOp[] */ + int iSelfTab; /* Table associated with an index on expr, or negative + ** of the base register during check-constraint eval */ + int nLabel; /* The *negative* of the number of labels used */ + int nLabelAlloc; /* Number of slots in aLabel */ + int *aLabel; /* Space to hold the labels */ + ExprList *pConstExpr;/* Constant expressions */ + IndexedExpr *pIdxEpr;/* List of expressions used by active indexes */ + Token constraintName;/* Name of the constraint currently being parsed */ + yDbMask writeMask; /* Start a write transaction on these databases */ + yDbMask cookieMask; /* Bitmask of schema verified databases */ + int regRowid; /* Register holding rowid of CREATE TABLE entry */ + int regRoot; /* Register holding root page number for new objects */ + int nMaxArg; /* Max args passed to user function by sub-program */ + int nSelect; /* Number of SELECT stmts. Counter for Select.selId */ +#ifndef SQLITE_OMIT_SHARED_CACHE + int nTableLock; /* Number of locks in aTableLock */ + TableLock *aTableLock; /* Required table locks for shared-cache mode */ +#endif + AutoincInfo *pAinc; /* Information about AUTOINCREMENT counters */ + Parse *pToplevel; /* Parse structure for main program (or NULL) */ + Table *pTriggerTab; /* Table triggers are being coded for */ + TriggerPrg *pTriggerPrg; /* Linked list of coded triggers */ + ParseCleanup *pCleanup; /* List of cleanup operations to run after parse */ + union { + int addrCrTab; /* Address of OP_CreateBtree on CREATE TABLE */ + Returning *pReturning; /* The RETURNING clause */ + } u1; + u32 nQueryLoop; /* Est number of iterations of a query (10*log2(N)) */ + u32 oldmask; /* Mask of old.* columns referenced */ + u32 newmask; /* Mask of new.* columns referenced */ +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + u32 nProgressSteps; /* xProgress steps taken during sqlite3_prepare() */ +#endif + u8 eTriggerOp; /* TK_UPDATE, TK_INSERT or TK_DELETE */ + u8 bReturning; /* Coding a RETURNING trigger */ + u8 eOrconf; /* Default ON CONFLICT policy for trigger steps */ + u8 disableTriggers; /* True to disable triggers */ + + /************************************************************************** + ** Fields above must be initialized to zero. The fields that follow, + ** down to the beginning of the recursive section, do not need to be + ** initialized as they will be set before being used. The boundary is + ** determined by offsetof(Parse,aTempReg). + **************************************************************************/ + + int aTempReg[8]; /* Holding area for temporary registers */ + Parse *pOuterParse; /* Outer Parse object when nested */ + Token sNameToken; /* Token with unqualified schema object name */ + + /************************************************************************ + ** Above is constant between recursions. Below is reset before and after + ** each recursion. The boundary between these two regions is determined + ** using offsetof(Parse,sLastToken) so the sLastToken field must be the + ** first field in the recursive region. + ************************************************************************/ + + Token sLastToken; /* The last token parsed */ + ynVar nVar; /* Number of '?' variables seen in the SQL so far */ + u8 iPkSortOrder; /* ASC or DESC for INTEGER PRIMARY KEY */ + u8 explain; /* True if the EXPLAIN flag is found on the query */ + u8 eParseMode; /* PARSE_MODE_XXX constant */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + int nVtabLock; /* Number of virtual tables to lock */ +#endif + int nHeight; /* Expression tree height of current sub-select */ +#ifndef SQLITE_OMIT_EXPLAIN + int addrExplain; /* Address of current OP_Explain opcode */ +#endif + VList *pVList; /* Mapping between variable names and numbers */ + Vdbe *pReprepare; /* VM being reprepared (sqlite3Reprepare()) */ + const char *zTail; /* All SQL text past the last semicolon parsed */ + Table *pNewTable; /* A table being constructed by CREATE TABLE */ + Index *pNewIndex; /* An index being constructed by CREATE INDEX. + ** Also used to hold redundant UNIQUE constraints + ** during a RENAME COLUMN */ + Trigger *pNewTrigger; /* Trigger under construct by a CREATE TRIGGER */ + const char *zAuthContext; /* The 6th parameter to db->xAuth callbacks */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + Token sArg; /* Complete text of a module argument */ + Table **apVtabLock; /* Pointer to virtual tables needing locking */ +#endif + With *pWith; /* Current WITH clause, or NULL */ +#ifndef SQLITE_OMIT_ALTERTABLE + RenameToken *pRename; /* Tokens subject to renaming by ALTER TABLE */ +#endif +}; + +/* Allowed values for Parse.eParseMode +*/ +#define PARSE_MODE_NORMAL 0 +#define PARSE_MODE_DECLARE_VTAB 1 +#define PARSE_MODE_RENAME 2 +#define PARSE_MODE_UNMAP 3 + +/* +** Sizes and pointers of various parts of the Parse object. +*/ +#define PARSE_HDR(X) (((char*)(X))+offsetof(Parse,zErrMsg)) +#define PARSE_HDR_SZ (offsetof(Parse,aTempReg)-offsetof(Parse,zErrMsg)) /* Recursive part w/o aColCache*/ +#define PARSE_RECURSE_SZ offsetof(Parse,sLastToken) /* Recursive part */ +#define PARSE_TAIL_SZ (sizeof(Parse)-PARSE_RECURSE_SZ) /* Non-recursive part */ +#define PARSE_TAIL(X) (((char*)(X))+PARSE_RECURSE_SZ) /* Pointer to tail */ + +/* +** Return true if currently inside an sqlite3_declare_vtab() call. +*/ +#ifdef SQLITE_OMIT_VIRTUALTABLE + #define IN_DECLARE_VTAB 0 +#else + #define IN_DECLARE_VTAB (pParse->eParseMode==PARSE_MODE_DECLARE_VTAB) +#endif + +#if defined(SQLITE_OMIT_ALTERTABLE) + #define IN_RENAME_OBJECT 0 +#else + #define IN_RENAME_OBJECT (pParse->eParseMode>=PARSE_MODE_RENAME) +#endif + +#if defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_OMIT_ALTERTABLE) + #define IN_SPECIAL_PARSE 0 +#else + #define IN_SPECIAL_PARSE (pParse->eParseMode!=PARSE_MODE_NORMAL) +#endif + +/* +** An instance of the following structure can be declared on a stack and used +** to save the Parse.zAuthContext value so that it can be restored later. +*/ +struct AuthContext { + const char *zAuthContext; /* Put saved Parse.zAuthContext here */ + Parse *pParse; /* The Parse structure */ +}; + +/* +** Bitfield flags for P5 value in various opcodes. +** +** Value constraints (enforced via assert()): +** OPFLAG_LENGTHARG == SQLITE_FUNC_LENGTH +** OPFLAG_TYPEOFARG == SQLITE_FUNC_TYPEOF +** OPFLAG_BULKCSR == BTREE_BULKLOAD +** OPFLAG_SEEKEQ == BTREE_SEEK_EQ +** OPFLAG_FORDELETE == BTREE_FORDELETE +** OPFLAG_SAVEPOSITION == BTREE_SAVEPOSITION +** OPFLAG_AUXDELETE == BTREE_AUXDELETE +*/ +#define OPFLAG_NCHANGE 0x01 /* OP_Insert: Set to update db->nChange */ + /* Also used in P2 (not P5) of OP_Delete */ +#define OPFLAG_NOCHNG 0x01 /* OP_VColumn nochange for UPDATE */ +#define OPFLAG_EPHEM 0x01 /* OP_Column: Ephemeral output is ok */ +#define OPFLAG_LASTROWID 0x20 /* Set to update db->lastRowid */ +#define OPFLAG_ISUPDATE 0x04 /* This OP_Insert is an sql UPDATE */ +#define OPFLAG_APPEND 0x08 /* This is likely to be an append */ +#define OPFLAG_USESEEKRESULT 0x10 /* Try to avoid a seek in BtreeInsert() */ +#define OPFLAG_ISNOOP 0x40 /* OP_Delete does pre-update-hook only */ +#define OPFLAG_LENGTHARG 0x40 /* OP_Column only used for length() */ +#define OPFLAG_TYPEOFARG 0x80 /* OP_Column only used for typeof() */ +#define OPFLAG_BULKCSR 0x01 /* OP_Open** used to open bulk cursor */ +#define OPFLAG_SEEKEQ 0x02 /* OP_Open** cursor uses EQ seek only */ +#define OPFLAG_FORDELETE 0x08 /* OP_Open should use BTREE_FORDELETE */ +#define OPFLAG_P2ISREG 0x10 /* P2 to OP_Open** is a register number */ +#define OPFLAG_PERMUTE 0x01 /* OP_Compare: use the permutation */ +#define OPFLAG_SAVEPOSITION 0x02 /* OP_Delete/Insert: save cursor pos */ +#define OPFLAG_AUXDELETE 0x04 /* OP_Delete: index in a DELETE op */ +#define OPFLAG_NOCHNG_MAGIC 0x6d /* OP_MakeRecord: serialtype 10 is ok */ +#define OPFLAG_PREFORMAT 0x80 /* OP_Insert uses preformatted cell */ + +/* +** Each trigger present in the database schema is stored as an instance of +** struct Trigger. +** +** Pointers to instances of struct Trigger are stored in two ways. +** 1. In the "trigHash" hash table (part of the sqlite3* that represents the +** database). This allows Trigger structures to be retrieved by name. +** 2. All triggers associated with a single table form a linked list, using the +** pNext member of struct Trigger. A pointer to the first element of the +** linked list is stored as the "pTrigger" member of the associated +** struct Table. +** +** The "step_list" member points to the first element of a linked list +** containing the SQL statements specified as the trigger program. +*/ +struct Trigger { + char *zName; /* The name of the trigger */ + char *table; /* The table or view to which the trigger applies */ + u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT */ + u8 tr_tm; /* One of TRIGGER_BEFORE, TRIGGER_AFTER */ + u8 bReturning; /* This trigger implements a RETURNING clause */ + Expr *pWhen; /* The WHEN clause of the expression (may be NULL) */ + IdList *pColumns; /* If this is an UPDATE OF trigger, + the is stored here */ + Schema *pSchema; /* Schema containing the trigger */ + Schema *pTabSchema; /* Schema containing the table */ + TriggerStep *step_list; /* Link list of trigger program steps */ + Trigger *pNext; /* Next trigger associated with the table */ +}; + +/* +** A trigger is either a BEFORE or an AFTER trigger. The following constants +** determine which. +** +** If there are multiple triggers, you might of some BEFORE and some AFTER. +** In that cases, the constants below can be ORed together. +*/ +#define TRIGGER_BEFORE 1 +#define TRIGGER_AFTER 2 + +/* +** An instance of struct TriggerStep is used to store a single SQL statement +** that is a part of a trigger-program. +** +** Instances of struct TriggerStep are stored in a singly linked list (linked +** using the "pNext" member) referenced by the "step_list" member of the +** associated struct Trigger instance. The first element of the linked list is +** the first step of the trigger-program. +** +** The "op" member indicates whether this is a "DELETE", "INSERT", "UPDATE" or +** "SELECT" statement. The meanings of the other members is determined by the +** value of "op" as follows: +** +** (op == TK_INSERT) +** orconf -> stores the ON CONFLICT algorithm +** pSelect -> The content to be inserted - either a SELECT statement or +** a VALUES clause. +** zTarget -> Dequoted name of the table to insert into. +** pIdList -> If this is an INSERT INTO ... () VALUES ... +** statement, then this stores the column-names to be +** inserted into. +** pUpsert -> The ON CONFLICT clauses for an Upsert +** +** (op == TK_DELETE) +** zTarget -> Dequoted name of the table to delete from. +** pWhere -> The WHERE clause of the DELETE statement if one is specified. +** Otherwise NULL. +** +** (op == TK_UPDATE) +** zTarget -> Dequoted name of the table to update. +** pWhere -> The WHERE clause of the UPDATE statement if one is specified. +** Otherwise NULL. +** pExprList -> A list of the columns to update and the expressions to update +** them to. See sqlite3Update() documentation of "pChanges" +** argument. +** +** (op == TK_SELECT) +** pSelect -> The SELECT statement +** +** (op == TK_RETURNING) +** pExprList -> The list of expressions that follow the RETURNING keyword. +** +*/ +struct TriggerStep { + u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT, + ** or TK_RETURNING */ + u8 orconf; /* OE_Rollback etc. */ + Trigger *pTrig; /* The trigger that this step is a part of */ + Select *pSelect; /* SELECT statement or RHS of INSERT INTO SELECT ... */ + char *zTarget; /* Target table for DELETE, UPDATE, INSERT */ + SrcList *pFrom; /* FROM clause for UPDATE statement (if any) */ + Expr *pWhere; /* The WHERE clause for DELETE or UPDATE steps */ + ExprList *pExprList; /* SET clause for UPDATE, or RETURNING clause */ + IdList *pIdList; /* Column names for INSERT */ + Upsert *pUpsert; /* Upsert clauses on an INSERT */ + char *zSpan; /* Original SQL text of this command */ + TriggerStep *pNext; /* Next in the link-list */ + TriggerStep *pLast; /* Last element in link-list. Valid for 1st elem only */ +}; + +/* +** Information about a RETURNING clause +*/ +struct Returning { + Parse *pParse; /* The parse that includes the RETURNING clause */ + ExprList *pReturnEL; /* List of expressions to return */ + Trigger retTrig; /* The transient trigger that implements RETURNING */ + TriggerStep retTStep; /* The trigger step */ + int iRetCur; /* Transient table holding RETURNING results */ + int nRetCol; /* Number of in pReturnEL after expansion */ + int iRetReg; /* Register array for holding a row of RETURNING */ +}; + +/* +** An objected used to accumulate the text of a string where we +** do not necessarily know how big the string will be in the end. +*/ +struct sqlite3_str { + sqlite3 *db; /* Optional database for lookaside. Can be NULL */ + char *zText; /* The string collected so far */ + u32 nAlloc; /* Amount of space allocated in zText */ + u32 mxAlloc; /* Maximum allowed allocation. 0 for no malloc usage */ + u32 nChar; /* Length of the string so far */ + u8 accError; /* SQLITE_NOMEM or SQLITE_TOOBIG */ + u8 printfFlags; /* SQLITE_PRINTF flags below */ +}; +#define SQLITE_PRINTF_INTERNAL 0x01 /* Internal-use-only converters allowed */ +#define SQLITE_PRINTF_SQLFUNC 0x02 /* SQL function arguments to VXPrintf */ +#define SQLITE_PRINTF_MALLOCED 0x04 /* True if xText is allocated space */ + +#define isMalloced(X) (((X)->printfFlags & SQLITE_PRINTF_MALLOCED)!=0) + + +/* +** A pointer to this structure is used to communicate information +** from sqlite3Init and OP_ParseSchema into the sqlite3InitCallback. +*/ +typedef struct { + sqlite3 *db; /* The database being initialized */ + char **pzErrMsg; /* Error message stored here */ + int iDb; /* 0 for main database. 1 for TEMP, 2.. for ATTACHed */ + int rc; /* Result code stored here */ + u32 mInitFlags; /* Flags controlling error messages */ + u32 nInitRow; /* Number of rows processed */ + Pgno mxPage; /* Maximum page number. 0 for no limit. */ +} InitData; + +/* +** Allowed values for mInitFlags +*/ +#define INITFLAG_AlterMask 0x0003 /* Types of ALTER */ +#define INITFLAG_AlterRename 0x0001 /* Reparse after a RENAME */ +#define INITFLAG_AlterDrop 0x0002 /* Reparse after a DROP COLUMN */ +#define INITFLAG_AlterAdd 0x0003 /* Reparse after an ADD COLUMN */ + +/* Tuning parameters are set using SQLITE_TESTCTRL_TUNE and are controlled +** on debug-builds of the CLI using ".testctrl tune ID VALUE". Tuning +** parameters are for temporary use during development, to help find +** optimial values for parameters in the query planner. The should not +** be used on trunk check-ins. They are a temporary mechanism available +** for transient development builds only. +** +** Tuning parameters are numbered starting with 1. +*/ +#define SQLITE_NTUNE 6 /* Should be zero for all trunk check-ins */ +#ifdef SQLITE_DEBUG +# define Tuning(X) (sqlite3Config.aTune[(X)-1]) +#else +# define Tuning(X) 0 +#endif + +/* +** Structure containing global configuration data for the SQLite library. +** +** This structure also contains some state information. +*/ +struct Sqlite3Config { + int bMemstat; /* True to enable memory status */ + u8 bCoreMutex; /* True to enable core mutexing */ + u8 bFullMutex; /* True to enable full mutexing */ + u8 bOpenUri; /* True to interpret filenames as URIs */ + u8 bUseCis; /* Use covering indices for full-scans */ + u8 bSmallMalloc; /* Avoid large memory allocations if true */ + u8 bExtraSchemaChecks; /* Verify type,name,tbl_name in schema */ + int mxStrlen; /* Maximum string length */ + int neverCorrupt; /* Database is always well-formed */ + int szLookaside; /* Default lookaside buffer size */ + int nLookaside; /* Default lookaside buffer count */ + int nStmtSpill; /* Stmt-journal spill-to-disk threshold */ + sqlite3_mem_methods m; /* Low-level memory allocation interface */ + sqlite3_mutex_methods mutex; /* Low-level mutex interface */ + sqlite3_pcache_methods2 pcache2; /* Low-level page-cache interface */ + void *pHeap; /* Heap storage space */ + int nHeap; /* Size of pHeap[] */ + int mnReq, mxReq; /* Min and max heap requests sizes */ + sqlite3_int64 szMmap; /* mmap() space per open file */ + sqlite3_int64 mxMmap; /* Maximum value for szMmap */ + void *pPage; /* Page cache memory */ + int szPage; /* Size of each page in pPage[] */ + int nPage; /* Number of pages in pPage[] */ + int mxParserStack; /* maximum depth of the parser stack */ + int sharedCacheEnabled; /* true if shared-cache mode enabled */ + u32 szPma; /* Maximum Sorter PMA size */ + /* The above might be initialized to non-zero. The following need to always + ** initially be zero, however. */ + int isInit; /* True after initialization has finished */ + int inProgress; /* True while initialization in progress */ + int isMutexInit; /* True after mutexes are initialized */ + int isMallocInit; /* True after malloc is initialized */ + int isPCacheInit; /* True after malloc is initialized */ + int nRefInitMutex; /* Number of users of pInitMutex */ + sqlite3_mutex *pInitMutex; /* Mutex used by sqlite3_initialize() */ + void (*xLog)(void*,int,const char*); /* Function for logging */ + void *pLogArg; /* First argument to xLog() */ +#ifdef SQLITE_ENABLE_SQLLOG + void(*xSqllog)(void*,sqlite3*,const char*, int); + void *pSqllogArg; +#endif +#ifdef SQLITE_VDBE_COVERAGE + /* The following callback (if not NULL) is invoked on every VDBE branch + ** operation. Set the callback using SQLITE_TESTCTRL_VDBE_COVERAGE. + */ + void (*xVdbeBranch)(void*,unsigned iSrcLine,u8 eThis,u8 eMx); /* Callback */ + void *pVdbeBranchArg; /* 1st argument */ +#endif +#ifndef SQLITE_OMIT_DESERIALIZE + sqlite3_int64 mxMemdbSize; /* Default max memdb size */ +#endif +#ifndef SQLITE_UNTESTABLE + int (*xTestCallback)(int); /* Invoked by sqlite3FaultSim() */ +#endif + int bLocaltimeFault; /* True to fail localtime() calls */ + int (*xAltLocaltime)(const void*,void*); /* Alternative localtime() routine */ + int iOnceResetThreshold; /* When to reset OP_Once counters */ + u32 szSorterRef; /* Min size in bytes to use sorter-refs */ + unsigned int iPrngSeed; /* Alternative fixed seed for the PRNG */ + /* vvvv--- must be last ---vvv */ +#ifdef SQLITE_DEBUG + sqlite3_int64 aTune[SQLITE_NTUNE]; /* Tuning parameters */ +#endif +}; + +/* +** This macro is used inside of assert() statements to indicate that +** the assert is only valid on a well-formed database. Instead of: +** +** assert( X ); +** +** One writes: +** +** assert( X || CORRUPT_DB ); +** +** CORRUPT_DB is true during normal operation. CORRUPT_DB does not indicate +** that the database is definitely corrupt, only that it might be corrupt. +** For most test cases, CORRUPT_DB is set to false using a special +** sqlite3_test_control(). This enables assert() statements to prove +** things that are always true for well-formed databases. +*/ +#define CORRUPT_DB (sqlite3Config.neverCorrupt==0) + +/* +** Context pointer passed down through the tree-walk. +*/ +struct Walker { + Parse *pParse; /* Parser context. */ + int (*xExprCallback)(Walker*, Expr*); /* Callback for expressions */ + int (*xSelectCallback)(Walker*,Select*); /* Callback for SELECTs */ + void (*xSelectCallback2)(Walker*,Select*);/* Second callback for SELECTs */ + int walkerDepth; /* Number of subqueries */ + u16 eCode; /* A small processing code */ + union { /* Extra data for callback */ + NameContext *pNC; /* Naming context */ + int n; /* A counter */ + int iCur; /* A cursor number */ + SrcList *pSrcList; /* FROM clause */ + struct CCurHint *pCCurHint; /* Used by codeCursorHint() */ + struct RefSrcList *pRefSrcList; /* sqlite3ReferencesSrcList() */ + int *aiCol; /* array of column indexes */ + struct IdxCover *pIdxCover; /* Check for index coverage */ + ExprList *pGroupBy; /* GROUP BY clause */ + Select *pSelect; /* HAVING to WHERE clause ctx */ + struct WindowRewrite *pRewrite; /* Window rewrite context */ + struct WhereConst *pConst; /* WHERE clause constants */ + struct RenameCtx *pRename; /* RENAME COLUMN context */ + struct Table *pTab; /* Table of generated column */ + struct CoveringIndexCheck *pCovIdxCk; /* Check for covering index */ + SrcItem *pSrcItem; /* A single FROM clause item */ + DbFixer *pFix; /* See sqlite3FixSelect() */ + Mem *aMem; /* See sqlite3BtreeCursorHint() */ + } u; +}; + +/* +** The following structure contains information used by the sqliteFix... +** routines as they walk the parse tree to make database references +** explicit. +*/ +struct DbFixer { + Parse *pParse; /* The parsing context. Error messages written here */ + Walker w; /* Walker object */ + Schema *pSchema; /* Fix items to this schema */ + u8 bTemp; /* True for TEMP schema entries */ + const char *zDb; /* Make sure all objects are contained in this database */ + const char *zType; /* Type of the container - used for error messages */ + const Token *pName; /* Name of the container - used for error messages */ +}; + +/* Forward declarations */ +SQLITE_PRIVATE int sqlite3WalkExpr(Walker*, Expr*); +SQLITE_PRIVATE int sqlite3WalkExprList(Walker*, ExprList*); +SQLITE_PRIVATE int sqlite3WalkSelect(Walker*, Select*); +SQLITE_PRIVATE int sqlite3WalkSelectExpr(Walker*, Select*); +SQLITE_PRIVATE int sqlite3WalkSelectFrom(Walker*, Select*); +SQLITE_PRIVATE int sqlite3ExprWalkNoop(Walker*, Expr*); +SQLITE_PRIVATE int sqlite3SelectWalkNoop(Walker*, Select*); +SQLITE_PRIVATE int sqlite3SelectWalkFail(Walker*, Select*); +SQLITE_PRIVATE int sqlite3WalkerDepthIncrease(Walker*,Select*); +SQLITE_PRIVATE void sqlite3WalkerDepthDecrease(Walker*,Select*); +SQLITE_PRIVATE void sqlite3WalkWinDefnDummyCallback(Walker*,Select*); + +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE void sqlite3SelectWalkAssert2(Walker*, Select*); +#endif + +#ifndef SQLITE_OMIT_CTE +SQLITE_PRIVATE void sqlite3SelectPopWith(Walker*, Select*); +#else +# define sqlite3SelectPopWith 0 +#endif + +/* +** Return code from the parse-tree walking primitives and their +** callbacks. +*/ +#define WRC_Continue 0 /* Continue down into children */ +#define WRC_Prune 1 /* Omit children but continue walking siblings */ +#define WRC_Abort 2 /* Abandon the tree walk */ + +/* +** A single common table expression +*/ +struct Cte { + char *zName; /* Name of this CTE */ + ExprList *pCols; /* List of explicit column names, or NULL */ + Select *pSelect; /* The definition of this CTE */ + const char *zCteErr; /* Error message for circular references */ + CteUse *pUse; /* Usage information for this CTE */ + u8 eM10d; /* The MATERIALIZED flag */ +}; + +/* +** Allowed values for the materialized flag (eM10d): +*/ +#define M10d_Yes 0 /* AS MATERIALIZED */ +#define M10d_Any 1 /* Not specified. Query planner's choice */ +#define M10d_No 2 /* AS NOT MATERIALIZED */ + +/* +** An instance of the With object represents a WITH clause containing +** one or more CTEs (common table expressions). +*/ +struct With { + int nCte; /* Number of CTEs in the WITH clause */ + int bView; /* Belongs to the outermost Select of a view */ + With *pOuter; /* Containing WITH clause, or NULL */ + Cte a[1]; /* For each CTE in the WITH clause.... */ +}; + +/* +** The Cte object is not guaranteed to persist for the entire duration +** of code generation. (The query flattener or other parser tree +** edits might delete it.) The following object records information +** about each Common Table Expression that must be preserved for the +** duration of the parse. +** +** The CteUse objects are freed using sqlite3ParserAddCleanup() rather +** than sqlite3SelectDelete(), which is what enables them to persist +** until the end of code generation. +*/ +struct CteUse { + int nUse; /* Number of users of this CTE */ + int addrM9e; /* Start of subroutine to compute materialization */ + int regRtn; /* Return address register for addrM9e subroutine */ + int iCur; /* Ephemeral table holding the materialization */ + LogEst nRowEst; /* Estimated number of rows in the table */ + u8 eM10d; /* The MATERIALIZED flag */ +}; + + +#ifdef SQLITE_DEBUG +/* +** An instance of the TreeView object is used for printing the content of +** data structures on sqlite3DebugPrintf() using a tree-like view. +*/ +struct TreeView { + int iLevel; /* Which level of the tree we are on */ + u8 bLine[100]; /* Draw vertical in column i if bLine[i] is true */ +}; +#endif /* SQLITE_DEBUG */ + +/* +** This object is used in various ways, most (but not all) related to window +** functions. +** +** (1) A single instance of this structure is attached to the +** the Expr.y.pWin field for each window function in an expression tree. +** This object holds the information contained in the OVER clause, +** plus additional fields used during code generation. +** +** (2) All window functions in a single SELECT form a linked-list +** attached to Select.pWin. The Window.pFunc and Window.pExpr +** fields point back to the expression that is the window function. +** +** (3) The terms of the WINDOW clause of a SELECT are instances of this +** object on a linked list attached to Select.pWinDefn. +** +** (4) For an aggregate function with a FILTER clause, an instance +** of this object is stored in Expr.y.pWin with eFrmType set to +** TK_FILTER. In this case the only field used is Window.pFilter. +** +** The uses (1) and (2) are really the same Window object that just happens +** to be accessible in two different ways. Use case (3) are separate objects. +*/ +struct Window { + char *zName; /* Name of window (may be NULL) */ + char *zBase; /* Name of base window for chaining (may be NULL) */ + ExprList *pPartition; /* PARTITION BY clause */ + ExprList *pOrderBy; /* ORDER BY clause */ + u8 eFrmType; /* TK_RANGE, TK_GROUPS, TK_ROWS, or 0 */ + u8 eStart; /* UNBOUNDED, CURRENT, PRECEDING or FOLLOWING */ + u8 eEnd; /* UNBOUNDED, CURRENT, PRECEDING or FOLLOWING */ + u8 bImplicitFrame; /* True if frame was implicitly specified */ + u8 eExclude; /* TK_NO, TK_CURRENT, TK_TIES, TK_GROUP, or 0 */ + Expr *pStart; /* Expression for " PRECEDING" */ + Expr *pEnd; /* Expression for " FOLLOWING" */ + Window **ppThis; /* Pointer to this object in Select.pWin list */ + Window *pNextWin; /* Next window function belonging to this SELECT */ + Expr *pFilter; /* The FILTER expression */ + FuncDef *pWFunc; /* The function */ + int iEphCsr; /* Partition buffer or Peer buffer */ + int regAccum; /* Accumulator */ + int regResult; /* Interim result */ + int csrApp; /* Function cursor (used by min/max) */ + int regApp; /* Function register (also used by min/max) */ + int regPart; /* Array of registers for PARTITION BY values */ + Expr *pOwner; /* Expression object this window is attached to */ + int nBufferCol; /* Number of columns in buffer table */ + int iArgCol; /* Offset of first argument for this function */ + int regOne; /* Register containing constant value 1 */ + int regStartRowid; + int regEndRowid; + u8 bExprArgs; /* Defer evaluation of window function arguments + ** due to the SQLITE_SUBTYPE flag */ +}; + +#ifndef SQLITE_OMIT_WINDOWFUNC +SQLITE_PRIVATE void sqlite3WindowDelete(sqlite3*, Window*); +SQLITE_PRIVATE void sqlite3WindowUnlinkFromSelect(Window*); +SQLITE_PRIVATE void sqlite3WindowListDelete(sqlite3 *db, Window *p); +SQLITE_PRIVATE Window *sqlite3WindowAlloc(Parse*, int, int, Expr*, int , Expr*, u8); +SQLITE_PRIVATE void sqlite3WindowAttach(Parse*, Expr*, Window*); +SQLITE_PRIVATE void sqlite3WindowLink(Select *pSel, Window *pWin); +SQLITE_PRIVATE int sqlite3WindowCompare(const Parse*, const Window*, const Window*, int); +SQLITE_PRIVATE void sqlite3WindowCodeInit(Parse*, Select*); +SQLITE_PRIVATE void sqlite3WindowCodeStep(Parse*, Select*, WhereInfo*, int, int); +SQLITE_PRIVATE int sqlite3WindowRewrite(Parse*, Select*); +SQLITE_PRIVATE void sqlite3WindowUpdate(Parse*, Window*, Window*, FuncDef*); +SQLITE_PRIVATE Window *sqlite3WindowDup(sqlite3 *db, Expr *pOwner, Window *p); +SQLITE_PRIVATE Window *sqlite3WindowListDup(sqlite3 *db, Window *p); +SQLITE_PRIVATE void sqlite3WindowFunctions(void); +SQLITE_PRIVATE void sqlite3WindowChain(Parse*, Window*, Window*); +SQLITE_PRIVATE Window *sqlite3WindowAssemble(Parse*, Window*, ExprList*, ExprList*, Token*); +#else +# define sqlite3WindowDelete(a,b) +# define sqlite3WindowFunctions() +# define sqlite3WindowAttach(a,b,c) +#endif + +/* +** Assuming zIn points to the first byte of a UTF-8 character, +** advance zIn to point to the first byte of the next UTF-8 character. +*/ +#define SQLITE_SKIP_UTF8(zIn) { \ + if( (*(zIn++))>=0xc0 ){ \ + while( (*zIn & 0xc0)==0x80 ){ zIn++; } \ + } \ +} + +/* +** The SQLITE_*_BKPT macros are substitutes for the error codes with +** the same name but without the _BKPT suffix. These macros invoke +** routines that report the line-number on which the error originated +** using sqlite3_log(). The routines also provide a convenient place +** to set a debugger breakpoint. +*/ +SQLITE_PRIVATE int sqlite3ReportError(int iErr, int lineno, const char *zType); +SQLITE_PRIVATE int sqlite3CorruptError(int); +SQLITE_PRIVATE int sqlite3MisuseError(int); +SQLITE_PRIVATE int sqlite3CantopenError(int); +#define SQLITE_CORRUPT_BKPT sqlite3CorruptError(__LINE__) +#define SQLITE_MISUSE_BKPT sqlite3MisuseError(__LINE__) +#define SQLITE_CANTOPEN_BKPT sqlite3CantopenError(__LINE__) +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3NomemError(int); +SQLITE_PRIVATE int sqlite3IoerrnomemError(int); +# define SQLITE_NOMEM_BKPT sqlite3NomemError(__LINE__) +# define SQLITE_IOERR_NOMEM_BKPT sqlite3IoerrnomemError(__LINE__) +#else +# define SQLITE_NOMEM_BKPT SQLITE_NOMEM +# define SQLITE_IOERR_NOMEM_BKPT SQLITE_IOERR_NOMEM +#endif +#if defined(SQLITE_DEBUG) || defined(SQLITE_ENABLE_CORRUPT_PGNO) +SQLITE_PRIVATE int sqlite3CorruptPgnoError(int,Pgno); +# define SQLITE_CORRUPT_PGNO(P) sqlite3CorruptPgnoError(__LINE__,(P)) +#else +# define SQLITE_CORRUPT_PGNO(P) sqlite3CorruptError(__LINE__) +#endif + +/* +** FTS3 and FTS4 both require virtual table support +*/ +#if defined(SQLITE_OMIT_VIRTUALTABLE) +# undef SQLITE_ENABLE_FTS3 +# undef SQLITE_ENABLE_FTS4 +#endif + +/* +** FTS4 is really an extension for FTS3. It is enabled using the +** SQLITE_ENABLE_FTS3 macro. But to avoid confusion we also call +** the SQLITE_ENABLE_FTS4 macro to serve as an alias for SQLITE_ENABLE_FTS3. +*/ +#if defined(SQLITE_ENABLE_FTS4) && !defined(SQLITE_ENABLE_FTS3) +# define SQLITE_ENABLE_FTS3 1 +#endif + +/* +** The ctype.h header is needed for non-ASCII systems. It is also +** needed by FTS3 when FTS3 is included in the amalgamation. +*/ +#if !defined(SQLITE_ASCII) || \ + (defined(SQLITE_ENABLE_FTS3) && defined(SQLITE_AMALGAMATION)) +# include +#endif + +/* +** The following macros mimic the standard library functions toupper(), +** isspace(), isalnum(), isdigit() and isxdigit(), respectively. The +** sqlite versions only work for ASCII characters, regardless of locale. +*/ +#ifdef SQLITE_ASCII +# define sqlite3Toupper(x) ((x)&~(sqlite3CtypeMap[(unsigned char)(x)]&0x20)) +# define sqlite3Isspace(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x01) +# define sqlite3Isalnum(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x06) +# define sqlite3Isalpha(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x02) +# define sqlite3Isdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x04) +# define sqlite3Isxdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x08) +# define sqlite3Tolower(x) (sqlite3UpperToLower[(unsigned char)(x)]) +# define sqlite3Isquote(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x80) +# define sqlite3JsonId1(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x42) +# define sqlite3JsonId2(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x46) +#else +# define sqlite3Toupper(x) toupper((unsigned char)(x)) +# define sqlite3Isspace(x) isspace((unsigned char)(x)) +# define sqlite3Isalnum(x) isalnum((unsigned char)(x)) +# define sqlite3Isalpha(x) isalpha((unsigned char)(x)) +# define sqlite3Isdigit(x) isdigit((unsigned char)(x)) +# define sqlite3Isxdigit(x) isxdigit((unsigned char)(x)) +# define sqlite3Tolower(x) tolower((unsigned char)(x)) +# define sqlite3Isquote(x) ((x)=='"'||(x)=='\''||(x)=='['||(x)=='`') +# define sqlite3JsonId1(x) (sqlite3IsIdChar(x)&&(x)<'0') +# define sqlite3JsonId2(x) sqlite3IsIdChar(x) +#endif +SQLITE_PRIVATE int sqlite3IsIdChar(u8); + +/* +** Internal function prototypes +*/ +SQLITE_PRIVATE int sqlite3StrICmp(const char*,const char*); +SQLITE_PRIVATE int sqlite3Strlen30(const char*); +#define sqlite3Strlen30NN(C) (strlen(C)&0x3fffffff) +SQLITE_PRIVATE char *sqlite3ColumnType(Column*,char*); +#define sqlite3StrNICmp sqlite3_strnicmp + +SQLITE_PRIVATE int sqlite3MallocInit(void); +SQLITE_PRIVATE void sqlite3MallocEnd(void); +SQLITE_PRIVATE void *sqlite3Malloc(u64); +SQLITE_PRIVATE void *sqlite3MallocZero(u64); +SQLITE_PRIVATE void *sqlite3DbMallocZero(sqlite3*, u64); +SQLITE_PRIVATE void *sqlite3DbMallocRaw(sqlite3*, u64); +SQLITE_PRIVATE void *sqlite3DbMallocRawNN(sqlite3*, u64); +SQLITE_PRIVATE char *sqlite3DbStrDup(sqlite3*,const char*); +SQLITE_PRIVATE char *sqlite3DbStrNDup(sqlite3*,const char*, u64); +SQLITE_PRIVATE char *sqlite3DbSpanDup(sqlite3*,const char*,const char*); +SQLITE_PRIVATE void *sqlite3Realloc(void*, u64); +SQLITE_PRIVATE void *sqlite3DbReallocOrFree(sqlite3 *, void *, u64); +SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *, void *, u64); +SQLITE_PRIVATE void sqlite3DbFree(sqlite3*, void*); +SQLITE_PRIVATE void sqlite3DbFreeNN(sqlite3*, void*); +SQLITE_PRIVATE void sqlite3DbNNFreeNN(sqlite3*, void*); +SQLITE_PRIVATE int sqlite3MallocSize(const void*); +SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3*, const void*); +SQLITE_PRIVATE void *sqlite3PageMalloc(int); +SQLITE_PRIVATE void sqlite3PageFree(void*); +SQLITE_PRIVATE void sqlite3MemSetDefault(void); +#ifndef SQLITE_UNTESTABLE +SQLITE_PRIVATE void sqlite3BenignMallocHooks(void (*)(void), void (*)(void)); +#endif +SQLITE_PRIVATE int sqlite3HeapNearlyFull(void); + +/* +** On systems with ample stack space and that support alloca(), make +** use of alloca() to obtain space for large automatic objects. By default, +** obtain space from malloc(). +** +** The alloca() routine never returns NULL. This will cause code paths +** that deal with sqlite3StackAlloc() failures to be unreachable. +*/ +#ifdef SQLITE_USE_ALLOCA +# define sqlite3StackAllocRaw(D,N) alloca(N) +# define sqlite3StackAllocRawNN(D,N) alloca(N) +# define sqlite3StackFree(D,P) +# define sqlite3StackFreeNN(D,P) +#else +# define sqlite3StackAllocRaw(D,N) sqlite3DbMallocRaw(D,N) +# define sqlite3StackAllocRawNN(D,N) sqlite3DbMallocRawNN(D,N) +# define sqlite3StackFree(D,P) sqlite3DbFree(D,P) +# define sqlite3StackFreeNN(D,P) sqlite3DbFreeNN(D,P) +#endif + +/* Do not allow both MEMSYS5 and MEMSYS3 to be defined together. If they +** are, disable MEMSYS3 +*/ +#ifdef SQLITE_ENABLE_MEMSYS5 +SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys5(void); +#undef SQLITE_ENABLE_MEMSYS3 +#endif +#ifdef SQLITE_ENABLE_MEMSYS3 +SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys3(void); +#endif + + +#ifndef SQLITE_MUTEX_OMIT +SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void); +SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3NoopMutex(void); +SQLITE_PRIVATE sqlite3_mutex *sqlite3MutexAlloc(int); +SQLITE_PRIVATE int sqlite3MutexInit(void); +SQLITE_PRIVATE int sqlite3MutexEnd(void); +#endif +#if !defined(SQLITE_MUTEX_OMIT) && !defined(SQLITE_MUTEX_NOOP) +SQLITE_PRIVATE void sqlite3MemoryBarrier(void); +#else +# define sqlite3MemoryBarrier() +#endif + +SQLITE_PRIVATE sqlite3_int64 sqlite3StatusValue(int); +SQLITE_PRIVATE void sqlite3StatusUp(int, int); +SQLITE_PRIVATE void sqlite3StatusDown(int, int); +SQLITE_PRIVATE void sqlite3StatusHighwater(int, int); +SQLITE_PRIVATE int sqlite3LookasideUsed(sqlite3*,int*); + +/* Access to mutexes used by sqlite3_status() */ +SQLITE_PRIVATE sqlite3_mutex *sqlite3Pcache1Mutex(void); +SQLITE_PRIVATE sqlite3_mutex *sqlite3MallocMutex(void); + +#if defined(SQLITE_ENABLE_MULTITHREADED_CHECKS) && !defined(SQLITE_MUTEX_OMIT) +SQLITE_PRIVATE void sqlite3MutexWarnOnContention(sqlite3_mutex*); +#else +# define sqlite3MutexWarnOnContention(x) +#endif + +#ifndef SQLITE_OMIT_FLOATING_POINT +# define EXP754 (((u64)0x7ff)<<52) +# define MAN754 ((((u64)1)<<52)-1) +# define IsNaN(X) (((X)&EXP754)==EXP754 && ((X)&MAN754)!=0) +SQLITE_PRIVATE int sqlite3IsNaN(double); +#else +# define IsNaN(X) 0 +# define sqlite3IsNaN(X) 0 +#endif + +/* +** An instance of the following structure holds information about SQL +** functions arguments that are the parameters to the printf() function. +*/ +struct PrintfArguments { + int nArg; /* Total number of arguments */ + int nUsed; /* Number of arguments used so far */ + sqlite3_value **apArg; /* The argument values */ +}; + +SQLITE_PRIVATE char *sqlite3MPrintf(sqlite3*,const char*, ...); +SQLITE_PRIVATE char *sqlite3VMPrintf(sqlite3*,const char*, va_list); +#if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE) +SQLITE_PRIVATE void sqlite3DebugPrintf(const char*, ...); +#endif +#if defined(SQLITE_TEST) +SQLITE_PRIVATE void *sqlite3TestTextToPtr(const char*); +#endif + +#if defined(SQLITE_DEBUG) +SQLITE_PRIVATE void sqlite3TreeViewLine(TreeView*, const char *zFormat, ...); +SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView*, const Expr*, u8); +SQLITE_PRIVATE void sqlite3TreeViewBareExprList(TreeView*, const ExprList*, const char*); +SQLITE_PRIVATE void sqlite3TreeViewExprList(TreeView*, const ExprList*, u8, const char*); +SQLITE_PRIVATE void sqlite3TreeViewBareIdList(TreeView*, const IdList*, const char*); +SQLITE_PRIVATE void sqlite3TreeViewIdList(TreeView*, const IdList*, u8, const char*); +SQLITE_PRIVATE void sqlite3TreeViewColumnList(TreeView*, const Column*, int, u8); +SQLITE_PRIVATE void sqlite3TreeViewSrcList(TreeView*, const SrcList*); +SQLITE_PRIVATE void sqlite3TreeViewSelect(TreeView*, const Select*, u8); +SQLITE_PRIVATE void sqlite3TreeViewWith(TreeView*, const With*, u8); +SQLITE_PRIVATE void sqlite3TreeViewUpsert(TreeView*, const Upsert*, u8); +#if TREETRACE_ENABLED +SQLITE_PRIVATE void sqlite3TreeViewDelete(const With*, const SrcList*, const Expr*, + const ExprList*,const Expr*, const Trigger*); +SQLITE_PRIVATE void sqlite3TreeViewInsert(const With*, const SrcList*, + const IdList*, const Select*, const ExprList*, + int, const Upsert*, const Trigger*); +SQLITE_PRIVATE void sqlite3TreeViewUpdate(const With*, const SrcList*, const ExprList*, + const Expr*, int, const ExprList*, const Expr*, + const Upsert*, const Trigger*); +#endif +#ifndef SQLITE_OMIT_TRIGGER +SQLITE_PRIVATE void sqlite3TreeViewTriggerStep(TreeView*, const TriggerStep*, u8, u8); +SQLITE_PRIVATE void sqlite3TreeViewTrigger(TreeView*, const Trigger*, u8, u8); +#endif +#ifndef SQLITE_OMIT_WINDOWFUNC +SQLITE_PRIVATE void sqlite3TreeViewWindow(TreeView*, const Window*, u8); +SQLITE_PRIVATE void sqlite3TreeViewWinFunc(TreeView*, const Window*, u8); +#endif +SQLITE_PRIVATE void sqlite3ShowExpr(const Expr*); +SQLITE_PRIVATE void sqlite3ShowExprList(const ExprList*); +SQLITE_PRIVATE void sqlite3ShowIdList(const IdList*); +SQLITE_PRIVATE void sqlite3ShowSrcList(const SrcList*); +SQLITE_PRIVATE void sqlite3ShowSelect(const Select*); +SQLITE_PRIVATE void sqlite3ShowWith(const With*); +SQLITE_PRIVATE void sqlite3ShowUpsert(const Upsert*); +#ifndef SQLITE_OMIT_TRIGGER +SQLITE_PRIVATE void sqlite3ShowTriggerStep(const TriggerStep*); +SQLITE_PRIVATE void sqlite3ShowTriggerStepList(const TriggerStep*); +SQLITE_PRIVATE void sqlite3ShowTrigger(const Trigger*); +SQLITE_PRIVATE void sqlite3ShowTriggerList(const Trigger*); +#endif +#ifndef SQLITE_OMIT_WINDOWFUNC +SQLITE_PRIVATE void sqlite3ShowWindow(const Window*); +SQLITE_PRIVATE void sqlite3ShowWinFunc(const Window*); +#endif +#endif + +SQLITE_PRIVATE void sqlite3SetString(char **, sqlite3*, const char*); +SQLITE_PRIVATE void sqlite3ProgressCheck(Parse*); +SQLITE_PRIVATE void sqlite3ErrorMsg(Parse*, const char*, ...); +SQLITE_PRIVATE int sqlite3ErrorToParser(sqlite3*,int); +SQLITE_PRIVATE void sqlite3Dequote(char*); +SQLITE_PRIVATE void sqlite3DequoteExpr(Expr*); +SQLITE_PRIVATE void sqlite3DequoteToken(Token*); +SQLITE_PRIVATE void sqlite3TokenInit(Token*,char*); +SQLITE_PRIVATE int sqlite3KeywordCode(const unsigned char*, int); +SQLITE_PRIVATE int sqlite3RunParser(Parse*, const char*); +SQLITE_PRIVATE void sqlite3FinishCoding(Parse*); +SQLITE_PRIVATE int sqlite3GetTempReg(Parse*); +SQLITE_PRIVATE void sqlite3ReleaseTempReg(Parse*,int); +SQLITE_PRIVATE int sqlite3GetTempRange(Parse*,int); +SQLITE_PRIVATE void sqlite3ReleaseTempRange(Parse*,int,int); +SQLITE_PRIVATE void sqlite3ClearTempRegCache(Parse*); +SQLITE_PRIVATE void sqlite3TouchRegister(Parse*,int); +#if defined(SQLITE_ENABLE_STAT4) || defined(SQLITE_DEBUG) +SQLITE_PRIVATE int sqlite3FirstAvailableRegister(Parse*,int); +#endif +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3NoTempsInRange(Parse*,int,int); +#endif +SQLITE_PRIVATE Expr *sqlite3ExprAlloc(sqlite3*,int,const Token*,int); +SQLITE_PRIVATE Expr *sqlite3Expr(sqlite3*,int,const char*); +SQLITE_PRIVATE void sqlite3ExprAttachSubtrees(sqlite3*,Expr*,Expr*,Expr*); +SQLITE_PRIVATE Expr *sqlite3PExpr(Parse*, int, Expr*, Expr*); +SQLITE_PRIVATE void sqlite3PExprAddSelect(Parse*, Expr*, Select*); +SQLITE_PRIVATE Expr *sqlite3ExprAnd(Parse*,Expr*, Expr*); +SQLITE_PRIVATE Expr *sqlite3ExprSimplifiedAndOr(Expr*); +SQLITE_PRIVATE Expr *sqlite3ExprFunction(Parse*,ExprList*, const Token*, int); +SQLITE_PRIVATE void sqlite3ExprFunctionUsable(Parse*,const Expr*,const FuncDef*); +SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse*, Expr*, u32); +SQLITE_PRIVATE void sqlite3ExprDelete(sqlite3*, Expr*); +SQLITE_PRIVATE void sqlite3ExprDeferredDelete(Parse*, Expr*); +SQLITE_PRIVATE void sqlite3ExprUnmapAndDelete(Parse*, Expr*); +SQLITE_PRIVATE ExprList *sqlite3ExprListAppend(Parse*,ExprList*,Expr*); +SQLITE_PRIVATE ExprList *sqlite3ExprListAppendVector(Parse*,ExprList*,IdList*,Expr*); +SQLITE_PRIVATE Select *sqlite3ExprListToValues(Parse*, int, ExprList*); +SQLITE_PRIVATE void sqlite3ExprListSetSortOrder(ExprList*,int,int); +SQLITE_PRIVATE void sqlite3ExprListSetName(Parse*,ExprList*,const Token*,int); +SQLITE_PRIVATE void sqlite3ExprListSetSpan(Parse*,ExprList*,const char*,const char*); +SQLITE_PRIVATE void sqlite3ExprListDelete(sqlite3*, ExprList*); +SQLITE_PRIVATE u32 sqlite3ExprListFlags(const ExprList*); +SQLITE_PRIVATE int sqlite3IndexHasDuplicateRootPage(Index*); +SQLITE_PRIVATE int sqlite3Init(sqlite3*, char**); +SQLITE_PRIVATE int sqlite3InitCallback(void*, int, char**, char**); +SQLITE_PRIVATE int sqlite3InitOne(sqlite3*, int, char**, u32); +SQLITE_PRIVATE void sqlite3Pragma(Parse*,Token*,Token*,Token*,int); +#ifndef SQLITE_OMIT_VIRTUALTABLE +SQLITE_PRIVATE Module *sqlite3PragmaVtabRegister(sqlite3*,const char *zName); +#endif +SQLITE_PRIVATE void sqlite3ResetAllSchemasOfConnection(sqlite3*); +SQLITE_PRIVATE void sqlite3ResetOneSchema(sqlite3*,int); +SQLITE_PRIVATE void sqlite3CollapseDatabaseArray(sqlite3*); +SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3*); +SQLITE_PRIVATE void sqlite3ColumnSetExpr(Parse*,Table*,Column*,Expr*); +SQLITE_PRIVATE Expr *sqlite3ColumnExpr(Table*,Column*); +SQLITE_PRIVATE void sqlite3ColumnSetColl(sqlite3*,Column*,const char*zColl); +SQLITE_PRIVATE const char *sqlite3ColumnColl(Column*); +SQLITE_PRIVATE void sqlite3DeleteColumnNames(sqlite3*,Table*); +SQLITE_PRIVATE void sqlite3GenerateColumnNames(Parse *pParse, Select *pSelect); +SQLITE_PRIVATE int sqlite3ColumnsFromExprList(Parse*,ExprList*,i16*,Column**); +SQLITE_PRIVATE void sqlite3SubqueryColumnTypes(Parse*,Table*,Select*,char); +SQLITE_PRIVATE Table *sqlite3ResultSetOfSelect(Parse*,Select*,char); +SQLITE_PRIVATE void sqlite3OpenSchemaTable(Parse *, int); +SQLITE_PRIVATE Index *sqlite3PrimaryKeyIndex(Table*); +SQLITE_PRIVATE i16 sqlite3TableColumnToIndex(Index*, i16); +#ifdef SQLITE_OMIT_GENERATED_COLUMNS +# define sqlite3TableColumnToStorage(T,X) (X) /* No-op pass-through */ +# define sqlite3StorageColumnToTable(T,X) (X) /* No-op pass-through */ +#else +SQLITE_PRIVATE i16 sqlite3TableColumnToStorage(Table*, i16); +SQLITE_PRIVATE i16 sqlite3StorageColumnToTable(Table*, i16); +#endif +SQLITE_PRIVATE void sqlite3StartTable(Parse*,Token*,Token*,int,int,int,int); +#if SQLITE_ENABLE_HIDDEN_COLUMNS +SQLITE_PRIVATE void sqlite3ColumnPropertiesFromName(Table*, Column*); +#else +# define sqlite3ColumnPropertiesFromName(T,C) /* no-op */ +#endif +SQLITE_PRIVATE void sqlite3AddColumn(Parse*,Token,Token); +SQLITE_PRIVATE void sqlite3AddNotNull(Parse*, int); +SQLITE_PRIVATE void sqlite3AddPrimaryKey(Parse*, ExprList*, int, int, int); +SQLITE_PRIVATE void sqlite3AddCheckConstraint(Parse*, Expr*, const char*, const char*); +SQLITE_PRIVATE void sqlite3AddDefaultValue(Parse*,Expr*,const char*,const char*); +SQLITE_PRIVATE void sqlite3AddCollateType(Parse*, Token*); +SQLITE_PRIVATE void sqlite3AddGenerated(Parse*,Expr*,Token*); +SQLITE_PRIVATE void sqlite3EndTable(Parse*,Token*,Token*,u32,Select*); +SQLITE_PRIVATE void sqlite3AddReturning(Parse*,ExprList*); +SQLITE_PRIVATE int sqlite3ParseUri(const char*,const char*,unsigned int*, + sqlite3_vfs**,char**,char **); +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC +SQLITE_PRIVATE int sqlite3CodecQueryParameters(sqlite3*,const char*,const char*); +#else +# define sqlite3CodecQueryParameters(A,B,C) 0 +#endif +/* END SQLCIPHER */ +SQLITE_PRIVATE Btree *sqlite3DbNameToBtree(sqlite3*,const char*); + +#ifdef SQLITE_UNTESTABLE +# define sqlite3FaultSim(X) SQLITE_OK +#else +SQLITE_PRIVATE int sqlite3FaultSim(int); +#endif + +SQLITE_PRIVATE Bitvec *sqlite3BitvecCreate(u32); +SQLITE_PRIVATE int sqlite3BitvecTest(Bitvec*, u32); +SQLITE_PRIVATE int sqlite3BitvecTestNotNull(Bitvec*, u32); +SQLITE_PRIVATE int sqlite3BitvecSet(Bitvec*, u32); +SQLITE_PRIVATE void sqlite3BitvecClear(Bitvec*, u32, void*); +SQLITE_PRIVATE void sqlite3BitvecDestroy(Bitvec*); +SQLITE_PRIVATE u32 sqlite3BitvecSize(Bitvec*); +#ifndef SQLITE_UNTESTABLE +SQLITE_PRIVATE int sqlite3BitvecBuiltinTest(int,int*); +#endif + +SQLITE_PRIVATE RowSet *sqlite3RowSetInit(sqlite3*); +SQLITE_PRIVATE void sqlite3RowSetDelete(void*); +SQLITE_PRIVATE void sqlite3RowSetClear(void*); +SQLITE_PRIVATE void sqlite3RowSetInsert(RowSet*, i64); +SQLITE_PRIVATE int sqlite3RowSetTest(RowSet*, int iBatch, i64); +SQLITE_PRIVATE int sqlite3RowSetNext(RowSet*, i64*); + +SQLITE_PRIVATE void sqlite3CreateView(Parse*,Token*,Token*,Token*,ExprList*,Select*,int,int); + +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) +SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse*,Table*); +#else +# define sqlite3ViewGetColumnNames(A,B) 0 +#endif + +#if SQLITE_MAX_ATTACHED>30 +SQLITE_PRIVATE int sqlite3DbMaskAllZero(yDbMask); +#endif +SQLITE_PRIVATE void sqlite3DropTable(Parse*, SrcList*, int, int); +SQLITE_PRIVATE void sqlite3CodeDropTable(Parse*, Table*, int, int); +SQLITE_PRIVATE void sqlite3DeleteTable(sqlite3*, Table*); +SQLITE_PRIVATE void sqlite3FreeIndex(sqlite3*, Index*); +#ifndef SQLITE_OMIT_AUTOINCREMENT +SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse); +SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse); +#else +# define sqlite3AutoincrementBegin(X) +# define sqlite3AutoincrementEnd(X) +#endif +SQLITE_PRIVATE void sqlite3Insert(Parse*, SrcList*, Select*, IdList*, int, Upsert*); +#ifndef SQLITE_OMIT_GENERATED_COLUMNS +SQLITE_PRIVATE void sqlite3ComputeGeneratedColumns(Parse*, int, Table*); +#endif +SQLITE_PRIVATE void *sqlite3ArrayAllocate(sqlite3*,void*,int,int*,int*); +SQLITE_PRIVATE IdList *sqlite3IdListAppend(Parse*, IdList*, Token*); +SQLITE_PRIVATE int sqlite3IdListIndex(IdList*,const char*); +SQLITE_PRIVATE SrcList *sqlite3SrcListEnlarge(Parse*, SrcList*, int, int); +SQLITE_PRIVATE SrcList *sqlite3SrcListAppendList(Parse *pParse, SrcList *p1, SrcList *p2); +SQLITE_PRIVATE SrcList *sqlite3SrcListAppend(Parse*, SrcList*, Token*, Token*); +SQLITE_PRIVATE SrcList *sqlite3SrcListAppendFromTerm(Parse*, SrcList*, Token*, Token*, + Token*, Select*, OnOrUsing*); +SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *, SrcList *, Token *); +SQLITE_PRIVATE void sqlite3SrcListFuncArgs(Parse*, SrcList*, ExprList*); +SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *, SrcItem *); +SQLITE_PRIVATE void sqlite3SrcListShiftJoinType(Parse*,SrcList*); +SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse*, SrcList*); +SQLITE_PRIVATE void sqlite3IdListDelete(sqlite3*, IdList*); +SQLITE_PRIVATE void sqlite3ClearOnOrUsing(sqlite3*, OnOrUsing*); +SQLITE_PRIVATE void sqlite3SrcListDelete(sqlite3*, SrcList*); +SQLITE_PRIVATE Index *sqlite3AllocateIndexObject(sqlite3*,i16,int,char**); +SQLITE_PRIVATE void sqlite3CreateIndex(Parse*,Token*,Token*,SrcList*,ExprList*,int,Token*, + Expr*, int, int, u8); +SQLITE_PRIVATE void sqlite3DropIndex(Parse*, SrcList*, int); +SQLITE_PRIVATE int sqlite3Select(Parse*, Select*, SelectDest*); +SQLITE_PRIVATE Select *sqlite3SelectNew(Parse*,ExprList*,SrcList*,Expr*,ExprList*, + Expr*,ExprList*,u32,Expr*); +SQLITE_PRIVATE void sqlite3SelectDelete(sqlite3*, Select*); +SQLITE_PRIVATE Table *sqlite3SrcListLookup(Parse*, SrcList*); +SQLITE_PRIVATE int sqlite3IsReadOnly(Parse*, Table*, Trigger*); +SQLITE_PRIVATE void sqlite3OpenTable(Parse*, int iCur, int iDb, Table*, int); +#if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) +SQLITE_PRIVATE Expr *sqlite3LimitWhere(Parse*,SrcList*,Expr*,ExprList*,Expr*,char*); +#endif +SQLITE_PRIVATE void sqlite3CodeChangeCount(Vdbe*,int,const char*); +SQLITE_PRIVATE void sqlite3DeleteFrom(Parse*, SrcList*, Expr*, ExprList*, Expr*); +SQLITE_PRIVATE void sqlite3Update(Parse*, SrcList*, ExprList*,Expr*,int,ExprList*,Expr*, + Upsert*); +SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(Parse*,SrcList*,Expr*,ExprList*, + ExprList*,Select*,u16,int); +SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo*); +SQLITE_PRIVATE LogEst sqlite3WhereOutputRowCount(WhereInfo*); +SQLITE_PRIVATE int sqlite3WhereIsDistinct(WhereInfo*); +SQLITE_PRIVATE int sqlite3WhereIsOrdered(WhereInfo*); +SQLITE_PRIVATE int sqlite3WhereOrderByLimitOptLabel(WhereInfo*); +SQLITE_PRIVATE void sqlite3WhereMinMaxOptEarlyOut(Vdbe*,WhereInfo*); +SQLITE_PRIVATE int sqlite3WhereIsSorted(WhereInfo*); +SQLITE_PRIVATE int sqlite3WhereContinueLabel(WhereInfo*); +SQLITE_PRIVATE int sqlite3WhereBreakLabel(WhereInfo*); +SQLITE_PRIVATE int sqlite3WhereOkOnePass(WhereInfo*, int*); +#define ONEPASS_OFF 0 /* Use of ONEPASS not allowed */ +#define ONEPASS_SINGLE 1 /* ONEPASS valid for a single row update */ +#define ONEPASS_MULTI 2 /* ONEPASS is valid for multiple rows */ +SQLITE_PRIVATE int sqlite3WhereUsesDeferredSeek(WhereInfo*); +SQLITE_PRIVATE void sqlite3ExprCodeLoadIndexColumn(Parse*, Index*, int, int, int); +SQLITE_PRIVATE int sqlite3ExprCodeGetColumn(Parse*, Table*, int, int, int, u8); +SQLITE_PRIVATE void sqlite3ExprCodeGetColumnOfTable(Vdbe*, Table*, int, int, int); +SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse*, int, int, int); +SQLITE_PRIVATE void sqlite3ExprCode(Parse*, Expr*, int); +#ifndef SQLITE_OMIT_GENERATED_COLUMNS +SQLITE_PRIVATE void sqlite3ExprCodeGeneratedColumn(Parse*, Table*, Column*, int); +#endif +SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse*, Expr*, int); +SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse*, Expr*, int); +SQLITE_PRIVATE int sqlite3ExprCodeRunJustOnce(Parse*, Expr*, int); +SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse*, Expr*, int*); +SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse*, Expr*, int); +SQLITE_PRIVATE int sqlite3ExprCodeExprList(Parse*, ExprList*, int, int, u8); +#define SQLITE_ECEL_DUP 0x01 /* Deep, not shallow copies */ +#define SQLITE_ECEL_FACTOR 0x02 /* Factor out constant terms */ +#define SQLITE_ECEL_REF 0x04 /* Use ExprList.u.x.iOrderByCol */ +#define SQLITE_ECEL_OMITREF 0x08 /* Omit if ExprList.u.x.iOrderByCol */ +SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse*, Expr*, int, int); +SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse*, Expr*, int, int); +SQLITE_PRIVATE void sqlite3ExprIfFalseDup(Parse*, Expr*, int, int); +SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3*,const char*, const char*); +#define LOCATE_VIEW 0x01 +#define LOCATE_NOERR 0x02 +SQLITE_PRIVATE Table *sqlite3LocateTable(Parse*,u32 flags,const char*, const char*); +SQLITE_PRIVATE const char *sqlite3PreferredTableName(const char*); +SQLITE_PRIVATE Table *sqlite3LocateTableItem(Parse*,u32 flags,SrcItem *); +SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3*,const char*, const char*); +SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3*,int,const char*); +SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3*,int,const char*); +SQLITE_PRIVATE void sqlite3Vacuum(Parse*,Token*,Expr*); +SQLITE_PRIVATE int sqlite3RunVacuum(char**, sqlite3*, int, sqlite3_value*); +SQLITE_PRIVATE char *sqlite3NameFromToken(sqlite3*, const Token*); +SQLITE_PRIVATE int sqlite3ExprCompare(const Parse*,const Expr*,const Expr*, int); +SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr*,Expr*,int); +SQLITE_PRIVATE int sqlite3ExprListCompare(const ExprList*,const ExprList*, int); +SQLITE_PRIVATE int sqlite3ExprImpliesExpr(const Parse*,const Expr*,const Expr*, int); +SQLITE_PRIVATE int sqlite3ExprImpliesNonNullRow(Expr*,int); +SQLITE_PRIVATE void sqlite3AggInfoPersistWalkerInit(Walker*,Parse*); +SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext*, Expr*); +SQLITE_PRIVATE void sqlite3ExprAnalyzeAggList(NameContext*,ExprList*); +SQLITE_PRIVATE int sqlite3ExprCoveredByIndex(Expr*, int iCur, Index *pIdx); +SQLITE_PRIVATE int sqlite3ReferencesSrcList(Parse*, Expr*, SrcList*); +SQLITE_PRIVATE Vdbe *sqlite3GetVdbe(Parse*); +#ifndef SQLITE_UNTESTABLE +SQLITE_PRIVATE void sqlite3PrngSaveState(void); +SQLITE_PRIVATE void sqlite3PrngRestoreState(void); +#endif +SQLITE_PRIVATE void sqlite3RollbackAll(sqlite3*,int); +SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse*, int); +SQLITE_PRIVATE void sqlite3CodeVerifyNamedSchema(Parse*, const char *zDb); +SQLITE_PRIVATE void sqlite3BeginTransaction(Parse*, int); +SQLITE_PRIVATE void sqlite3EndTransaction(Parse*,int); +SQLITE_PRIVATE void sqlite3Savepoint(Parse*, int, Token*); +SQLITE_PRIVATE void sqlite3CloseSavepoints(sqlite3 *); +SQLITE_PRIVATE void sqlite3LeaveMutexAndCloseZombie(sqlite3*); +SQLITE_PRIVATE u32 sqlite3IsTrueOrFalse(const char*); +SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr*); +SQLITE_PRIVATE int sqlite3ExprTruthValue(const Expr*); +SQLITE_PRIVATE int sqlite3ExprIsConstant(Expr*); +SQLITE_PRIVATE int sqlite3ExprIsConstantNotJoin(Expr*); +SQLITE_PRIVATE int sqlite3ExprIsConstantOrFunction(Expr*, u8); +SQLITE_PRIVATE int sqlite3ExprIsConstantOrGroupBy(Parse*, Expr*, ExprList*); +SQLITE_PRIVATE int sqlite3ExprIsTableConstant(Expr*,int); +SQLITE_PRIVATE int sqlite3ExprIsSingleTableConstraint(Expr*,const SrcList*,int); +#ifdef SQLITE_ENABLE_CURSOR_HINTS +SQLITE_PRIVATE int sqlite3ExprContainsSubquery(Expr*); +#endif +SQLITE_PRIVATE int sqlite3ExprIsInteger(const Expr*, int*); +SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr*); +SQLITE_PRIVATE int sqlite3ExprNeedsNoAffinityChange(const Expr*, char); +SQLITE_PRIVATE int sqlite3IsRowid(const char*); +SQLITE_PRIVATE void sqlite3GenerateRowDelete( + Parse*,Table*,Trigger*,int,int,int,i16,u8,u8,u8,int); +SQLITE_PRIVATE void sqlite3GenerateRowIndexDelete(Parse*, Table*, int, int, int*, int); +SQLITE_PRIVATE int sqlite3GenerateIndexKey(Parse*, Index*, int, int, int, int*,Index*,int); +SQLITE_PRIVATE void sqlite3ResolvePartIdxLabel(Parse*,int); +SQLITE_PRIVATE int sqlite3ExprReferencesUpdatedColumn(Expr*,int*,int); +SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(Parse*,Table*,int*,int,int,int,int, + u8,u8,int,int*,int*,Upsert*); +#ifdef SQLITE_ENABLE_NULL_TRIM +SQLITE_PRIVATE void sqlite3SetMakeRecordP5(Vdbe*,Table*); +#else +# define sqlite3SetMakeRecordP5(A,B) +#endif +SQLITE_PRIVATE void sqlite3CompleteInsertion(Parse*,Table*,int,int,int,int*,int,int,int); +SQLITE_PRIVATE int sqlite3OpenTableAndIndices(Parse*, Table*, int, u8, int, u8*, int*, int*); +SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse*, int, int); +SQLITE_PRIVATE void sqlite3MultiWrite(Parse*); +SQLITE_PRIVATE void sqlite3MayAbort(Parse*); +SQLITE_PRIVATE void sqlite3HaltConstraint(Parse*, int, int, char*, i8, u8); +SQLITE_PRIVATE void sqlite3UniqueConstraint(Parse*, int, Index*); +SQLITE_PRIVATE void sqlite3RowidConstraint(Parse*, int, Table*); +SQLITE_PRIVATE Expr *sqlite3ExprDup(sqlite3*,const Expr*,int); +SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3*,const ExprList*,int); +SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3*,const SrcList*,int); +SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3*,const IdList*); +SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3*,const Select*,int); +SQLITE_PRIVATE FuncDef *sqlite3FunctionSearch(int,const char*); +SQLITE_PRIVATE void sqlite3InsertBuiltinFuncs(FuncDef*,int); +SQLITE_PRIVATE FuncDef *sqlite3FindFunction(sqlite3*,const char*,int,u8,u8); +SQLITE_PRIVATE void sqlite3QuoteValue(StrAccum*,sqlite3_value*); +SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(void); +SQLITE_PRIVATE void sqlite3RegisterDateTimeFunctions(void); +SQLITE_PRIVATE void sqlite3RegisterJsonFunctions(void); +SQLITE_PRIVATE void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3*); +#if !defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_JSON) +SQLITE_PRIVATE int sqlite3JsonTableFunctions(sqlite3*); +#endif +SQLITE_PRIVATE int sqlite3SafetyCheckOk(sqlite3*); +SQLITE_PRIVATE int sqlite3SafetyCheckSickOrOk(sqlite3*); +SQLITE_PRIVATE void sqlite3ChangeCookie(Parse*, int); +SQLITE_PRIVATE With *sqlite3WithDup(sqlite3 *db, With *p); + +#if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) +SQLITE_PRIVATE void sqlite3MaterializeView(Parse*, Table*, Expr*, ExprList*,Expr*,int); +#endif + +#ifndef SQLITE_OMIT_TRIGGER +SQLITE_PRIVATE void sqlite3BeginTrigger(Parse*, Token*,Token*,int,int,IdList*,SrcList*, + Expr*,int, int); +SQLITE_PRIVATE void sqlite3FinishTrigger(Parse*, TriggerStep*, Token*); +SQLITE_PRIVATE void sqlite3DropTrigger(Parse*, SrcList*, int); +SQLITE_PRIVATE void sqlite3DropTriggerPtr(Parse*, Trigger*); +SQLITE_PRIVATE Trigger *sqlite3TriggersExist(Parse *, Table*, int, ExprList*, int *pMask); +SQLITE_PRIVATE Trigger *sqlite3TriggerList(Parse *, Table *); +SQLITE_PRIVATE void sqlite3CodeRowTrigger(Parse*, Trigger *, int, ExprList*, int, Table *, + int, int, int); +SQLITE_PRIVATE void sqlite3CodeRowTriggerDirect(Parse *, Trigger *, Table *, int, int, int); + void sqliteViewTriggers(Parse*, Table*, Expr*, int, ExprList*); +SQLITE_PRIVATE void sqlite3DeleteTriggerStep(sqlite3*, TriggerStep*); +SQLITE_PRIVATE TriggerStep *sqlite3TriggerSelectStep(sqlite3*,Select*, + const char*,const char*); +SQLITE_PRIVATE TriggerStep *sqlite3TriggerInsertStep(Parse*,Token*, IdList*, + Select*,u8,Upsert*, + const char*,const char*); +SQLITE_PRIVATE TriggerStep *sqlite3TriggerUpdateStep(Parse*,Token*,SrcList*,ExprList*, + Expr*, u8, const char*,const char*); +SQLITE_PRIVATE TriggerStep *sqlite3TriggerDeleteStep(Parse*,Token*, Expr*, + const char*,const char*); +SQLITE_PRIVATE void sqlite3DeleteTrigger(sqlite3*, Trigger*); +SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3*,int,const char*); +SQLITE_PRIVATE u32 sqlite3TriggerColmask(Parse*,Trigger*,ExprList*,int,int,Table*,int); +SQLITE_PRIVATE SrcList *sqlite3TriggerStepSrc(Parse*, TriggerStep*); +# define sqlite3ParseToplevel(p) ((p)->pToplevel ? (p)->pToplevel : (p)) +# define sqlite3IsToplevel(p) ((p)->pToplevel==0) +#else +# define sqlite3TriggersExist(B,C,D,E,F) 0 +# define sqlite3DeleteTrigger(A,B) +# define sqlite3DropTriggerPtr(A,B) +# define sqlite3UnlinkAndDeleteTrigger(A,B,C) +# define sqlite3CodeRowTrigger(A,B,C,D,E,F,G,H,I) +# define sqlite3CodeRowTriggerDirect(A,B,C,D,E,F) +# define sqlite3TriggerList(X, Y) 0 +# define sqlite3ParseToplevel(p) p +# define sqlite3IsToplevel(p) 1 +# define sqlite3TriggerColmask(A,B,C,D,E,F,G) 0 +# define sqlite3TriggerStepSrc(A,B) 0 +#endif + +SQLITE_PRIVATE int sqlite3JoinType(Parse*, Token*, Token*, Token*); +SQLITE_PRIVATE int sqlite3ColumnIndex(Table *pTab, const char *zCol); +SQLITE_PRIVATE void sqlite3SrcItemColumnUsed(SrcItem*,int); +SQLITE_PRIVATE void sqlite3SetJoinExpr(Expr*,int,u32); +SQLITE_PRIVATE void sqlite3CreateForeignKey(Parse*, ExprList*, Token*, ExprList*, int); +SQLITE_PRIVATE void sqlite3DeferForeignKey(Parse*, int); +#ifndef SQLITE_OMIT_AUTHORIZATION +SQLITE_PRIVATE void sqlite3AuthRead(Parse*,Expr*,Schema*,SrcList*); +SQLITE_PRIVATE int sqlite3AuthCheck(Parse*,int, const char*, const char*, const char*); +SQLITE_PRIVATE void sqlite3AuthContextPush(Parse*, AuthContext*, const char*); +SQLITE_PRIVATE void sqlite3AuthContextPop(AuthContext*); +SQLITE_PRIVATE int sqlite3AuthReadCol(Parse*, const char *, const char *, int); +#else +# define sqlite3AuthRead(a,b,c,d) +# define sqlite3AuthCheck(a,b,c,d,e) SQLITE_OK +# define sqlite3AuthContextPush(a,b,c) +# define sqlite3AuthContextPop(a) ((void)(a)) +#endif +SQLITE_PRIVATE int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName); +SQLITE_PRIVATE void sqlite3Attach(Parse*, Expr*, Expr*, Expr*); +SQLITE_PRIVATE void sqlite3Detach(Parse*, Expr*); +SQLITE_PRIVATE void sqlite3FixInit(DbFixer*, Parse*, int, const char*, const Token*); +SQLITE_PRIVATE int sqlite3FixSrcList(DbFixer*, SrcList*); +SQLITE_PRIVATE int sqlite3FixSelect(DbFixer*, Select*); +SQLITE_PRIVATE int sqlite3FixExpr(DbFixer*, Expr*); +SQLITE_PRIVATE int sqlite3FixTriggerStep(DbFixer*, TriggerStep*); +SQLITE_PRIVATE int sqlite3RealSameAsInt(double,sqlite3_int64); +SQLITE_PRIVATE i64 sqlite3RealToI64(double); +SQLITE_PRIVATE int sqlite3Int64ToText(i64,char*); +SQLITE_PRIVATE int sqlite3AtoF(const char *z, double*, int, u8); +SQLITE_PRIVATE int sqlite3GetInt32(const char *, int*); +SQLITE_PRIVATE int sqlite3GetUInt32(const char*, u32*); +SQLITE_PRIVATE int sqlite3Atoi(const char*); +#ifndef SQLITE_OMIT_UTF16 +SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *pData, int nChar); +#endif +SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *pData, int nByte); +SQLITE_PRIVATE u32 sqlite3Utf8Read(const u8**); +SQLITE_PRIVATE LogEst sqlite3LogEst(u64); +SQLITE_PRIVATE LogEst sqlite3LogEstAdd(LogEst,LogEst); +SQLITE_PRIVATE LogEst sqlite3LogEstFromDouble(double); +SQLITE_PRIVATE u64 sqlite3LogEstToInt(LogEst); +SQLITE_PRIVATE VList *sqlite3VListAdd(sqlite3*,VList*,const char*,int,int); +SQLITE_PRIVATE const char *sqlite3VListNumToName(VList*,int); +SQLITE_PRIVATE int sqlite3VListNameToNum(VList*,const char*,int); + +/* +** Routines to read and write variable-length integers. These used to +** be defined locally, but now we use the varint routines in the util.c +** file. +*/ +SQLITE_PRIVATE int sqlite3PutVarint(unsigned char*, u64); +SQLITE_PRIVATE u8 sqlite3GetVarint(const unsigned char *, u64 *); +SQLITE_PRIVATE u8 sqlite3GetVarint32(const unsigned char *, u32 *); +SQLITE_PRIVATE int sqlite3VarintLen(u64 v); + +/* +** The common case is for a varint to be a single byte. They following +** macros handle the common case without a procedure call, but then call +** the procedure for larger varints. +*/ +#define getVarint32(A,B) \ + (u8)((*(A)<(u8)0x80)?((B)=(u32)*(A)),1:sqlite3GetVarint32((A),(u32 *)&(B))) +#define getVarint32NR(A,B) \ + B=(u32)*(A);if(B>=0x80)sqlite3GetVarint32((A),(u32*)&(B)) +#define putVarint32(A,B) \ + (u8)(((u32)(B)<(u32)0x80)?(*(A)=(unsigned char)(B)),1:\ + sqlite3PutVarint((A),(B))) +#define getVarint sqlite3GetVarint +#define putVarint sqlite3PutVarint + + +SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(sqlite3*, Index*); +SQLITE_PRIVATE char *sqlite3TableAffinityStr(sqlite3*,const Table*); +SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe*, Table*, int); +SQLITE_PRIVATE char sqlite3CompareAffinity(const Expr *pExpr, char aff2); +SQLITE_PRIVATE int sqlite3IndexAffinityOk(const Expr *pExpr, char idx_affinity); +SQLITE_PRIVATE char sqlite3TableColumnAffinity(const Table*,int); +SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr); +SQLITE_PRIVATE int sqlite3ExprDataType(const Expr *pExpr); +SQLITE_PRIVATE int sqlite3Atoi64(const char*, i64*, int, u8); +SQLITE_PRIVATE int sqlite3DecOrHexToI64(const char*, i64*); +SQLITE_PRIVATE void sqlite3ErrorWithMsg(sqlite3*, int, const char*,...); +SQLITE_PRIVATE void sqlite3Error(sqlite3*,int); +SQLITE_PRIVATE void sqlite3ErrorClear(sqlite3*); +SQLITE_PRIVATE void sqlite3SystemError(sqlite3*,int); +SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3*, const char *z, int n); +SQLITE_PRIVATE u8 sqlite3HexToInt(int h); +SQLITE_PRIVATE int sqlite3TwoPartName(Parse *, Token *, Token *, Token **); + +#if defined(SQLITE_NEED_ERR_NAME) +SQLITE_PRIVATE const char *sqlite3ErrName(int); +#endif + +#ifndef SQLITE_OMIT_DESERIALIZE +SQLITE_PRIVATE int sqlite3MemdbInit(void); +SQLITE_PRIVATE int sqlite3IsMemdb(const sqlite3_vfs*); +#else +# define sqlite3IsMemdb(X) 0 +#endif + +SQLITE_PRIVATE const char *sqlite3ErrStr(int); +SQLITE_PRIVATE int sqlite3ReadSchema(Parse *pParse); +SQLITE_PRIVATE CollSeq *sqlite3FindCollSeq(sqlite3*,u8 enc, const char*,int); +SQLITE_PRIVATE int sqlite3IsBinary(const CollSeq*); +SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char*zName); +SQLITE_PRIVATE void sqlite3SetTextEncoding(sqlite3 *db, u8); +SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr); +SQLITE_PRIVATE CollSeq *sqlite3ExprNNCollSeq(Parse *pParse, const Expr *pExpr); +SQLITE_PRIVATE int sqlite3ExprCollSeqMatch(Parse*,const Expr*,const Expr*); +SQLITE_PRIVATE Expr *sqlite3ExprAddCollateToken(const Parse *pParse, Expr*, const Token*, int); +SQLITE_PRIVATE Expr *sqlite3ExprAddCollateString(const Parse*,Expr*,const char*); +SQLITE_PRIVATE Expr *sqlite3ExprSkipCollate(Expr*); +SQLITE_PRIVATE Expr *sqlite3ExprSkipCollateAndLikely(Expr*); +SQLITE_PRIVATE int sqlite3CheckCollSeq(Parse *, CollSeq *); +SQLITE_PRIVATE int sqlite3WritableSchema(sqlite3*); +SQLITE_PRIVATE int sqlite3CheckObjectName(Parse*, const char*,const char*,const char*); +SQLITE_PRIVATE void sqlite3VdbeSetChanges(sqlite3 *, i64); +SQLITE_PRIVATE int sqlite3AddInt64(i64*,i64); +SQLITE_PRIVATE int sqlite3SubInt64(i64*,i64); +SQLITE_PRIVATE int sqlite3MulInt64(i64*,i64); +SQLITE_PRIVATE int sqlite3AbsInt32(int); +#ifdef SQLITE_ENABLE_8_3_NAMES +SQLITE_PRIVATE void sqlite3FileSuffix3(const char*, char*); +#else +# define sqlite3FileSuffix3(X,Y) +#endif +SQLITE_PRIVATE u8 sqlite3GetBoolean(const char *z,u8); + +SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value*, u8); +SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value*, u8); +SQLITE_PRIVATE void sqlite3ValueSetStr(sqlite3_value*, int, const void *,u8, + void(*)(void*)); +SQLITE_PRIVATE void sqlite3ValueSetNull(sqlite3_value*); +SQLITE_PRIVATE void sqlite3ValueFree(sqlite3_value*); +#ifndef SQLITE_UNTESTABLE +SQLITE_PRIVATE void sqlite3ResultIntReal(sqlite3_context*); +#endif +SQLITE_PRIVATE sqlite3_value *sqlite3ValueNew(sqlite3 *); +#ifndef SQLITE_OMIT_UTF16 +SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *, const void*, int, u8); +#endif +SQLITE_PRIVATE int sqlite3ValueFromExpr(sqlite3 *, const Expr *, u8, u8, sqlite3_value **); +SQLITE_PRIVATE void sqlite3ValueApplyAffinity(sqlite3_value *, u8, u8); +#ifndef SQLITE_AMALGAMATION +SQLITE_PRIVATE const unsigned char sqlite3OpcodeProperty[]; +SQLITE_PRIVATE const char sqlite3StrBINARY[]; +SQLITE_PRIVATE const unsigned char sqlite3StdTypeLen[]; +SQLITE_PRIVATE const char sqlite3StdTypeAffinity[]; +SQLITE_PRIVATE const char *sqlite3StdType[]; +SQLITE_PRIVATE const unsigned char sqlite3UpperToLower[]; +SQLITE_PRIVATE const unsigned char *sqlite3aLTb; +SQLITE_PRIVATE const unsigned char *sqlite3aEQb; +SQLITE_PRIVATE const unsigned char *sqlite3aGTb; +SQLITE_PRIVATE const unsigned char sqlite3CtypeMap[]; +SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config; +SQLITE_PRIVATE FuncDefHash sqlite3BuiltinFunctions; +#ifndef SQLITE_OMIT_WSD +SQLITE_PRIVATE int sqlite3PendingByte; +#endif +#endif /* SQLITE_AMALGAMATION */ +#ifdef VDBE_PROFILE +SQLITE_PRIVATE sqlite3_uint64 sqlite3NProfileCnt; +#endif +SQLITE_PRIVATE void sqlite3RootPageMoved(sqlite3*, int, Pgno, Pgno); +SQLITE_PRIVATE void sqlite3Reindex(Parse*, Token*, Token*); +SQLITE_PRIVATE void sqlite3AlterFunctions(void); +SQLITE_PRIVATE void sqlite3AlterRenameTable(Parse*, SrcList*, Token*); +SQLITE_PRIVATE void sqlite3AlterRenameColumn(Parse*, SrcList*, Token*, Token*); +SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *, int *); +SQLITE_PRIVATE void sqlite3NestedParse(Parse*, const char*, ...); +SQLITE_PRIVATE void sqlite3ExpirePreparedStatements(sqlite3*, int); +SQLITE_PRIVATE void sqlite3CodeRhsOfIN(Parse*, Expr*, int); +SQLITE_PRIVATE int sqlite3CodeSubselect(Parse*, Expr*); +SQLITE_PRIVATE void sqlite3SelectPrep(Parse*, Select*, NameContext*); +SQLITE_PRIVATE int sqlite3ExpandSubquery(Parse*, SrcItem*); +SQLITE_PRIVATE void sqlite3SelectWrongNumTermsError(Parse *pParse, Select *p); +SQLITE_PRIVATE int sqlite3MatchEName( + const struct ExprList_item*, + const char*, + const char*, + const char* +); +SQLITE_PRIVATE Bitmask sqlite3ExprColUsed(Expr*); +SQLITE_PRIVATE u8 sqlite3StrIHash(const char*); +SQLITE_PRIVATE int sqlite3ResolveExprNames(NameContext*, Expr*); +SQLITE_PRIVATE int sqlite3ResolveExprListNames(NameContext*, ExprList*); +SQLITE_PRIVATE void sqlite3ResolveSelectNames(Parse*, Select*, NameContext*); +SQLITE_PRIVATE int sqlite3ResolveSelfReference(Parse*,Table*,int,Expr*,ExprList*); +SQLITE_PRIVATE int sqlite3ResolveOrderGroupBy(Parse*, Select*, ExprList*, const char*); +SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *, Table *, int, int); +SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *, Token *); +SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *, SrcList *); +SQLITE_PRIVATE void sqlite3AlterDropColumn(Parse*, SrcList*, const Token*); +SQLITE_PRIVATE const void *sqlite3RenameTokenMap(Parse*, const void*, const Token*); +SQLITE_PRIVATE void sqlite3RenameTokenRemap(Parse*, const void *pTo, const void *pFrom); +SQLITE_PRIVATE void sqlite3RenameExprUnmap(Parse*, Expr*); +SQLITE_PRIVATE void sqlite3RenameExprlistUnmap(Parse*, ExprList*); +SQLITE_PRIVATE CollSeq *sqlite3GetCollSeq(Parse*, u8, CollSeq *, const char*); +SQLITE_PRIVATE char sqlite3AffinityType(const char*, Column*); +SQLITE_PRIVATE void sqlite3Analyze(Parse*, Token*, Token*); +SQLITE_PRIVATE int sqlite3InvokeBusyHandler(BusyHandler*); +SQLITE_PRIVATE int sqlite3FindDb(sqlite3*, Token*); +SQLITE_PRIVATE int sqlite3FindDbName(sqlite3 *, const char *); +SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3*,int iDB); +SQLITE_PRIVATE void sqlite3DeleteIndexSamples(sqlite3*,Index*); +SQLITE_PRIVATE void sqlite3DefaultRowEst(Index*); +SQLITE_PRIVATE void sqlite3RegisterLikeFunctions(sqlite3*, int); +SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3*,Expr*,int*,char*); +SQLITE_PRIVATE void sqlite3SchemaClear(void *); +SQLITE_PRIVATE Schema *sqlite3SchemaGet(sqlite3 *, Btree *); +SQLITE_PRIVATE int sqlite3SchemaToIndex(sqlite3 *db, Schema *); +SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoAlloc(sqlite3*,int,int); +SQLITE_PRIVATE void sqlite3KeyInfoUnref(KeyInfo*); +SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoRef(KeyInfo*); +SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoOfIndex(Parse*, Index*); +SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoFromExprList(Parse*, ExprList*, int, int); +SQLITE_PRIVATE const char *sqlite3SelectOpName(int); +SQLITE_PRIVATE int sqlite3HasExplicitNulls(Parse*, ExprList*); + +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3KeyInfoIsWriteable(KeyInfo*); +#endif +SQLITE_PRIVATE int sqlite3CreateFunc(sqlite3 *, const char *, int, int, void *, + void (*)(sqlite3_context*,int,sqlite3_value **), + void (*)(sqlite3_context*,int,sqlite3_value **), + void (*)(sqlite3_context*), + void (*)(sqlite3_context*), + void (*)(sqlite3_context*,int,sqlite3_value **), + FuncDestructor *pDestructor +); +SQLITE_PRIVATE void sqlite3NoopDestructor(void*); +SQLITE_PRIVATE void *sqlite3OomFault(sqlite3*); +SQLITE_PRIVATE void sqlite3OomClear(sqlite3*); +SQLITE_PRIVATE int sqlite3ApiExit(sqlite3 *db, int); +SQLITE_PRIVATE int sqlite3OpenTempDatabase(Parse *); + +SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum*, sqlite3*, char*, int, int); +SQLITE_PRIVATE int sqlite3StrAccumEnlarge(StrAccum*, i64); +SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum*); +SQLITE_PRIVATE void sqlite3StrAccumSetError(StrAccum*, u8); +SQLITE_PRIVATE void sqlite3ResultStrAccum(sqlite3_context*,StrAccum*); +SQLITE_PRIVATE void sqlite3SelectDestInit(SelectDest*,int,int); +SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *, SrcList *, int, int); +SQLITE_PRIVATE void sqlite3RecordErrorByteOffset(sqlite3*,const char*); +SQLITE_PRIVATE void sqlite3RecordErrorOffsetOfExpr(sqlite3*,const Expr*); + +SQLITE_PRIVATE void sqlite3BackupRestart(sqlite3_backup *); +SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *, Pgno, const u8 *); + +#ifndef SQLITE_OMIT_SUBQUERY +SQLITE_PRIVATE int sqlite3ExprCheckIN(Parse*, Expr*); +#else +# define sqlite3ExprCheckIN(x,y) SQLITE_OK +#endif + +#ifdef SQLITE_ENABLE_STAT4 +SQLITE_PRIVATE int sqlite3Stat4ProbeSetValue( + Parse*,Index*,UnpackedRecord**,Expr*,int,int,int*); +SQLITE_PRIVATE int sqlite3Stat4ValueFromExpr(Parse*, Expr*, u8, sqlite3_value**); +SQLITE_PRIVATE void sqlite3Stat4ProbeFree(UnpackedRecord*); +SQLITE_PRIVATE int sqlite3Stat4Column(sqlite3*, const void*, int, int, sqlite3_value**); +SQLITE_PRIVATE char sqlite3IndexColumnAffinity(sqlite3*, Index*, int); +#endif + +/* +** The interface to the LEMON-generated parser +*/ +#ifndef SQLITE_AMALGAMATION +SQLITE_PRIVATE void *sqlite3ParserAlloc(void*(*)(u64), Parse*); +SQLITE_PRIVATE void sqlite3ParserFree(void*, void(*)(void*)); +#endif +SQLITE_PRIVATE void sqlite3Parser(void*, int, Token); +SQLITE_PRIVATE int sqlite3ParserFallback(int); +#ifdef YYTRACKMAXSTACKDEPTH +SQLITE_PRIVATE int sqlite3ParserStackPeak(void*); +#endif + +SQLITE_PRIVATE void sqlite3AutoLoadExtensions(sqlite3*); +#ifndef SQLITE_OMIT_LOAD_EXTENSION +SQLITE_PRIVATE void sqlite3CloseExtensions(sqlite3*); +#else +# define sqlite3CloseExtensions(X) +#endif + +#ifndef SQLITE_OMIT_SHARED_CACHE +SQLITE_PRIVATE void sqlite3TableLock(Parse *, int, Pgno, u8, const char *); +#else + #define sqlite3TableLock(v,w,x,y,z) +#endif + +#ifdef SQLITE_TEST +SQLITE_PRIVATE int sqlite3Utf8To8(unsigned char*); +#endif + +#ifdef SQLITE_OMIT_VIRTUALTABLE +# define sqlite3VtabClear(D,T) +# define sqlite3VtabSync(X,Y) SQLITE_OK +# define sqlite3VtabRollback(X) +# define sqlite3VtabCommit(X) +# define sqlite3VtabInSync(db) 0 +# define sqlite3VtabLock(X) +# define sqlite3VtabUnlock(X) +# define sqlite3VtabModuleUnref(D,X) +# define sqlite3VtabUnlockList(X) +# define sqlite3VtabSavepoint(X, Y, Z) SQLITE_OK +# define sqlite3GetVTable(X,Y) ((VTable*)0) +#else +SQLITE_PRIVATE void sqlite3VtabClear(sqlite3 *db, Table*); +SQLITE_PRIVATE void sqlite3VtabDisconnect(sqlite3 *db, Table *p); +SQLITE_PRIVATE int sqlite3VtabSync(sqlite3 *db, Vdbe*); +SQLITE_PRIVATE int sqlite3VtabRollback(sqlite3 *db); +SQLITE_PRIVATE int sqlite3VtabCommit(sqlite3 *db); +SQLITE_PRIVATE void sqlite3VtabLock(VTable *); +SQLITE_PRIVATE void sqlite3VtabUnlock(VTable *); +SQLITE_PRIVATE void sqlite3VtabModuleUnref(sqlite3*,Module*); +SQLITE_PRIVATE void sqlite3VtabUnlockList(sqlite3*); +SQLITE_PRIVATE int sqlite3VtabSavepoint(sqlite3 *, int, int); +SQLITE_PRIVATE void sqlite3VtabImportErrmsg(Vdbe*, sqlite3_vtab*); +SQLITE_PRIVATE VTable *sqlite3GetVTable(sqlite3*, Table*); +SQLITE_PRIVATE Module *sqlite3VtabCreateModule( + sqlite3*, + const char*, + const sqlite3_module*, + void*, + void(*)(void*) + ); +# define sqlite3VtabInSync(db) ((db)->nVTrans>0 && (db)->aVTrans==0) +#endif +SQLITE_PRIVATE int sqlite3ReadOnlyShadowTables(sqlite3 *db); +#ifndef SQLITE_OMIT_VIRTUALTABLE +SQLITE_PRIVATE int sqlite3ShadowTableName(sqlite3 *db, const char *zName); +SQLITE_PRIVATE int sqlite3IsShadowTableOf(sqlite3*,Table*,const char*); +SQLITE_PRIVATE void sqlite3MarkAllShadowTablesOf(sqlite3*, Table*); +#else +# define sqlite3ShadowTableName(A,B) 0 +# define sqlite3IsShadowTableOf(A,B,C) 0 +# define sqlite3MarkAllShadowTablesOf(A,B) +#endif +SQLITE_PRIVATE int sqlite3VtabEponymousTableInit(Parse*,Module*); +SQLITE_PRIVATE void sqlite3VtabEponymousTableClear(sqlite3*,Module*); +SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse*,Table*); +SQLITE_PRIVATE void sqlite3VtabBeginParse(Parse*, Token*, Token*, Token*, int); +SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse*, Token*); +SQLITE_PRIVATE void sqlite3VtabArgInit(Parse*); +SQLITE_PRIVATE void sqlite3VtabArgExtend(Parse*, Token*); +SQLITE_PRIVATE int sqlite3VtabCallCreate(sqlite3*, int, const char *, char **); +SQLITE_PRIVATE int sqlite3VtabCallConnect(Parse*, Table*); +SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3*, int, const char *); +SQLITE_PRIVATE int sqlite3VtabBegin(sqlite3 *, VTable *); + +SQLITE_PRIVATE FuncDef *sqlite3VtabOverloadFunction(sqlite3 *,FuncDef*, int nArg, Expr*); +SQLITE_PRIVATE void sqlite3VtabUsesAllSchemas(Parse*); +SQLITE_PRIVATE sqlite3_int64 sqlite3StmtCurrentTime(sqlite3_context*); +SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe*, const char*, int); +SQLITE_PRIVATE int sqlite3TransferBindings(sqlite3_stmt *, sqlite3_stmt *); +SQLITE_PRIVATE void sqlite3ParseObjectInit(Parse*,sqlite3*); +SQLITE_PRIVATE void sqlite3ParseObjectReset(Parse*); +SQLITE_PRIVATE void *sqlite3ParserAddCleanup(Parse*,void(*)(sqlite3*,void*),void*); +#ifdef SQLITE_ENABLE_NORMALIZE +SQLITE_PRIVATE char *sqlite3Normalize(Vdbe*, const char*); +#endif +SQLITE_PRIVATE int sqlite3Reprepare(Vdbe*); +SQLITE_PRIVATE void sqlite3ExprListCheckLength(Parse*, ExprList*, const char*); +SQLITE_PRIVATE CollSeq *sqlite3ExprCompareCollSeq(Parse*,const Expr*); +SQLITE_PRIVATE CollSeq *sqlite3BinaryCompareCollSeq(Parse *, const Expr*, const Expr*); +SQLITE_PRIVATE int sqlite3TempInMemory(const sqlite3*); +SQLITE_PRIVATE const char *sqlite3JournalModename(int); +#ifndef SQLITE_OMIT_WAL +SQLITE_PRIVATE int sqlite3Checkpoint(sqlite3*, int, int, int*, int*); +SQLITE_PRIVATE int sqlite3WalDefaultHook(void*,sqlite3*,const char*,int); +#endif +#ifndef SQLITE_OMIT_CTE +SQLITE_PRIVATE Cte *sqlite3CteNew(Parse*,Token*,ExprList*,Select*,u8); +SQLITE_PRIVATE void sqlite3CteDelete(sqlite3*,Cte*); +SQLITE_PRIVATE With *sqlite3WithAdd(Parse*,With*,Cte*); +SQLITE_PRIVATE void sqlite3WithDelete(sqlite3*,With*); +SQLITE_PRIVATE With *sqlite3WithPush(Parse*, With*, u8); +#else +# define sqlite3CteNew(P,T,E,S) ((void*)0) +# define sqlite3CteDelete(D,C) +# define sqlite3CteWithAdd(P,W,C) ((void*)0) +# define sqlite3WithDelete(x,y) +# define sqlite3WithPush(x,y,z) ((void*)0) +#endif +#ifndef SQLITE_OMIT_UPSERT +SQLITE_PRIVATE Upsert *sqlite3UpsertNew(sqlite3*,ExprList*,Expr*,ExprList*,Expr*,Upsert*); +SQLITE_PRIVATE void sqlite3UpsertDelete(sqlite3*,Upsert*); +SQLITE_PRIVATE Upsert *sqlite3UpsertDup(sqlite3*,Upsert*); +SQLITE_PRIVATE int sqlite3UpsertAnalyzeTarget(Parse*,SrcList*,Upsert*); +SQLITE_PRIVATE void sqlite3UpsertDoUpdate(Parse*,Upsert*,Table*,Index*,int); +SQLITE_PRIVATE Upsert *sqlite3UpsertOfIndex(Upsert*,Index*); +SQLITE_PRIVATE int sqlite3UpsertNextIsIPK(Upsert*); +#else +#define sqlite3UpsertNew(u,v,w,x,y,z) ((Upsert*)0) +#define sqlite3UpsertDelete(x,y) +#define sqlite3UpsertDup(x,y) ((Upsert*)0) +#define sqlite3UpsertOfIndex(x,y) ((Upsert*)0) +#define sqlite3UpsertNextIsIPK(x) 0 +#endif + + +/* Declarations for functions in fkey.c. All of these are replaced by +** no-op macros if OMIT_FOREIGN_KEY is defined. In this case no foreign +** key functionality is available. If OMIT_TRIGGER is defined but +** OMIT_FOREIGN_KEY is not, only some of the functions are no-oped. In +** this case foreign keys are parsed, but no other functionality is +** provided (enforcement of FK constraints requires the triggers sub-system). +*/ +#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER) +SQLITE_PRIVATE void sqlite3FkCheck(Parse*, Table*, int, int, int*, int); +SQLITE_PRIVATE void sqlite3FkDropTable(Parse*, SrcList *, Table*); +SQLITE_PRIVATE void sqlite3FkActions(Parse*, Table*, ExprList*, int, int*, int); +SQLITE_PRIVATE int sqlite3FkRequired(Parse*, Table*, int*, int); +SQLITE_PRIVATE u32 sqlite3FkOldmask(Parse*, Table*); +SQLITE_PRIVATE FKey *sqlite3FkReferences(Table *); +SQLITE_PRIVATE void sqlite3FkClearTriggerCache(sqlite3*,int); +#else + #define sqlite3FkActions(a,b,c,d,e,f) + #define sqlite3FkCheck(a,b,c,d,e,f) + #define sqlite3FkDropTable(a,b,c) + #define sqlite3FkOldmask(a,b) 0 + #define sqlite3FkRequired(a,b,c,d) 0 + #define sqlite3FkReferences(a) 0 + #define sqlite3FkClearTriggerCache(a,b) +#endif +#ifndef SQLITE_OMIT_FOREIGN_KEY +SQLITE_PRIVATE void sqlite3FkDelete(sqlite3 *, Table*); +SQLITE_PRIVATE int sqlite3FkLocateIndex(Parse*,Table*,FKey*,Index**,int**); +#else + #define sqlite3FkDelete(a,b) + #define sqlite3FkLocateIndex(a,b,c,d,e) +#endif + + +/* +** Available fault injectors. Should be numbered beginning with 0. +*/ +#define SQLITE_FAULTINJECTOR_MALLOC 0 +#define SQLITE_FAULTINJECTOR_COUNT 1 + +/* +** The interface to the code in fault.c used for identifying "benign" +** malloc failures. This is only present if SQLITE_UNTESTABLE +** is not defined. +*/ +#ifndef SQLITE_UNTESTABLE +SQLITE_PRIVATE void sqlite3BeginBenignMalloc(void); +SQLITE_PRIVATE void sqlite3EndBenignMalloc(void); +#else + #define sqlite3BeginBenignMalloc() + #define sqlite3EndBenignMalloc() +#endif + +/* +** Allowed return values from sqlite3FindInIndex() +*/ +#define IN_INDEX_ROWID 1 /* Search the rowid of the table */ +#define IN_INDEX_EPH 2 /* Search an ephemeral b-tree */ +#define IN_INDEX_INDEX_ASC 3 /* Existing index ASCENDING */ +#define IN_INDEX_INDEX_DESC 4 /* Existing index DESCENDING */ +#define IN_INDEX_NOOP 5 /* No table available. Use comparisons */ +/* +** Allowed flags for the 3rd parameter to sqlite3FindInIndex(). +*/ +#define IN_INDEX_NOOP_OK 0x0001 /* OK to return IN_INDEX_NOOP */ +#define IN_INDEX_MEMBERSHIP 0x0002 /* IN operator used for membership test */ +#define IN_INDEX_LOOP 0x0004 /* IN operator used as a loop */ +SQLITE_PRIVATE int sqlite3FindInIndex(Parse *, Expr *, u32, int*, int*, int*); + +SQLITE_PRIVATE int sqlite3JournalOpen(sqlite3_vfs *, const char *, sqlite3_file *, int, int); +SQLITE_PRIVATE int sqlite3JournalSize(sqlite3_vfs *); +#if defined(SQLITE_ENABLE_ATOMIC_WRITE) \ + || defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE) +SQLITE_PRIVATE int sqlite3JournalCreate(sqlite3_file *); +#endif + +SQLITE_PRIVATE int sqlite3JournalIsInMemory(sqlite3_file *p); +SQLITE_PRIVATE void sqlite3MemJournalOpen(sqlite3_file *); + +SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p); +#if SQLITE_MAX_EXPR_DEPTH>0 +SQLITE_PRIVATE int sqlite3SelectExprHeight(const Select *); +SQLITE_PRIVATE int sqlite3ExprCheckHeight(Parse*, int); +#else + #define sqlite3SelectExprHeight(x) 0 + #define sqlite3ExprCheckHeight(x,y) +#endif + +SQLITE_PRIVATE u32 sqlite3Get4byte(const u8*); +SQLITE_PRIVATE void sqlite3Put4byte(u8*, u32); + +#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY +SQLITE_PRIVATE void sqlite3ConnectionBlocked(sqlite3 *, sqlite3 *); +SQLITE_PRIVATE void sqlite3ConnectionUnlocked(sqlite3 *db); +SQLITE_PRIVATE void sqlite3ConnectionClosed(sqlite3 *db); +#else + #define sqlite3ConnectionBlocked(x,y) + #define sqlite3ConnectionUnlocked(x) + #define sqlite3ConnectionClosed(x) +#endif + +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE void sqlite3ParserTrace(FILE*, char *); +#endif +#if defined(YYCOVERAGE) +SQLITE_PRIVATE int sqlite3ParserCoverage(FILE*); +#endif + +/* +** If the SQLITE_ENABLE IOTRACE exists then the global variable +** sqlite3IoTrace is a pointer to a printf-like routine used to +** print I/O tracing messages. +*/ +#ifdef SQLITE_ENABLE_IOTRACE +# define IOTRACE(A) if( sqlite3IoTrace ){ sqlite3IoTrace A; } +SQLITE_PRIVATE void sqlite3VdbeIOTraceSql(Vdbe*); +SQLITE_API SQLITE_EXTERN void (SQLITE_CDECL *sqlite3IoTrace)(const char*,...); +#else +# define IOTRACE(A) +# define sqlite3VdbeIOTraceSql(X) +#endif + +/* +** These routines are available for the mem2.c debugging memory allocator +** only. They are used to verify that different "types" of memory +** allocations are properly tracked by the system. +** +** sqlite3MemdebugSetType() sets the "type" of an allocation to one of +** the MEMTYPE_* macros defined below. The type must be a bitmask with +** a single bit set. +** +** sqlite3MemdebugHasType() returns true if any of the bits in its second +** argument match the type set by the previous sqlite3MemdebugSetType(). +** sqlite3MemdebugHasType() is intended for use inside assert() statements. +** +** sqlite3MemdebugNoType() returns true if none of the bits in its second +** argument match the type set by the previous sqlite3MemdebugSetType(). +** +** Perhaps the most important point is the difference between MEMTYPE_HEAP +** and MEMTYPE_LOOKASIDE. If an allocation is MEMTYPE_LOOKASIDE, that means +** it might have been allocated by lookaside, except the allocation was +** too large or lookaside was already full. It is important to verify +** that allocations that might have been satisfied by lookaside are not +** passed back to non-lookaside free() routines. Asserts such as the +** example above are placed on the non-lookaside free() routines to verify +** this constraint. +** +** All of this is no-op for a production build. It only comes into +** play when the SQLITE_MEMDEBUG compile-time option is used. +*/ +#ifdef SQLITE_MEMDEBUG +SQLITE_PRIVATE void sqlite3MemdebugSetType(void*,u8); +SQLITE_PRIVATE int sqlite3MemdebugHasType(const void*,u8); +SQLITE_PRIVATE int sqlite3MemdebugNoType(const void*,u8); +#else +# define sqlite3MemdebugSetType(X,Y) /* no-op */ +# define sqlite3MemdebugHasType(X,Y) 1 +# define sqlite3MemdebugNoType(X,Y) 1 +#endif +#define MEMTYPE_HEAP 0x01 /* General heap allocations */ +#define MEMTYPE_LOOKASIDE 0x02 /* Heap that might have been lookaside */ +#define MEMTYPE_PCACHE 0x04 /* Page cache allocations */ + +/* +** Threading interface +*/ +#if SQLITE_MAX_WORKER_THREADS>0 +SQLITE_PRIVATE int sqlite3ThreadCreate(SQLiteThread**,void*(*)(void*),void*); +SQLITE_PRIVATE int sqlite3ThreadJoin(SQLiteThread*, void**); +#endif + +#if defined(SQLITE_ENABLE_DBPAGE_VTAB) || defined(SQLITE_TEST) +SQLITE_PRIVATE int sqlite3DbpageRegister(sqlite3*); +#endif +#if defined(SQLITE_ENABLE_DBSTAT_VTAB) || defined(SQLITE_TEST) +SQLITE_PRIVATE int sqlite3DbstatRegister(sqlite3*); +#endif + +SQLITE_PRIVATE int sqlite3ExprVectorSize(const Expr *pExpr); +SQLITE_PRIVATE int sqlite3ExprIsVector(const Expr *pExpr); +SQLITE_PRIVATE Expr *sqlite3VectorFieldSubexpr(Expr*, int); +SQLITE_PRIVATE Expr *sqlite3ExprForVectorField(Parse*,Expr*,int,int); +SQLITE_PRIVATE void sqlite3VectorErrorMsg(Parse*, Expr*); + +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS +SQLITE_PRIVATE const char **sqlite3CompileOptions(int *pnOpt); +#endif + +#if SQLITE_OS_UNIX && defined(SQLITE_OS_KV_OPTIONAL) +SQLITE_PRIVATE int sqlite3KvvfsInit(void); +#endif + +#if defined(VDBE_PROFILE) \ + || defined(SQLITE_PERFORMANCE_TRACE) \ + || defined(SQLITE_ENABLE_STMT_SCANSTATUS) +SQLITE_PRIVATE sqlite3_uint64 sqlite3Hwtime(void); +#endif + +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS +# define IS_STMT_SCANSTATUS(db) (db->flags & SQLITE_StmtScanStatus) +#else +# define IS_STMT_SCANSTATUS(db) 0 +#endif + +#endif /* SQLITEINT_H */ + +/************** End of sqliteInt.h *******************************************/ +/************** Begin file os_common.h ***************************************/ +/* +** 2004 May 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains macros and a little bit of code that is common to +** all of the platform-specific files (os_*.c) and is #included into those +** files. +** +** This file should be #included by the os_*.c files only. It is not a +** general purpose header file. +*/ +#ifndef _OS_COMMON_H_ +#define _OS_COMMON_H_ + +/* +** At least two bugs have slipped in because we changed the MEMORY_DEBUG +** macro to SQLITE_DEBUG and some older makefiles have not yet made the +** switch. The following code should catch this problem at compile-time. +*/ +#ifdef MEMORY_DEBUG +# error "The MEMORY_DEBUG macro is obsolete. Use SQLITE_DEBUG instead." +#endif + +/* +** Macros for performance tracing. Normally turned off. Only works +** on i486 hardware. +*/ +#ifdef SQLITE_PERFORMANCE_TRACE + +static sqlite_uint64 g_start; +static sqlite_uint64 g_elapsed; +#define TIMER_START g_start=sqlite3Hwtime() +#define TIMER_END g_elapsed=sqlite3Hwtime()-g_start +#define TIMER_ELAPSED g_elapsed +#else +#define TIMER_START +#define TIMER_END +#define TIMER_ELAPSED ((sqlite_uint64)0) +#endif + +/* +** If we compile with the SQLITE_TEST macro set, then the following block +** of code will give us the ability to simulate a disk I/O error. This +** is used for testing the I/O recovery logic. +*/ +#if defined(SQLITE_TEST) +SQLITE_API extern int sqlite3_io_error_hit; +SQLITE_API extern int sqlite3_io_error_hardhit; +SQLITE_API extern int sqlite3_io_error_pending; +SQLITE_API extern int sqlite3_io_error_persist; +SQLITE_API extern int sqlite3_io_error_benign; +SQLITE_API extern int sqlite3_diskfull_pending; +SQLITE_API extern int sqlite3_diskfull; +#define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X) +#define SimulateIOError(CODE) \ + if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \ + || sqlite3_io_error_pending-- == 1 ) \ + { local_ioerr(); CODE; } +static void local_ioerr(){ + IOTRACE(("IOERR\n")); + sqlite3_io_error_hit++; + if( !sqlite3_io_error_benign ) sqlite3_io_error_hardhit++; +} +#define SimulateDiskfullError(CODE) \ + if( sqlite3_diskfull_pending ){ \ + if( sqlite3_diskfull_pending == 1 ){ \ + local_ioerr(); \ + sqlite3_diskfull = 1; \ + sqlite3_io_error_hit = 1; \ + CODE; \ + }else{ \ + sqlite3_diskfull_pending--; \ + } \ + } +#else +#define SimulateIOErrorBenign(X) +#define SimulateIOError(A) +#define SimulateDiskfullError(A) +#endif /* defined(SQLITE_TEST) */ + +/* +** When testing, keep a count of the number of open files. +*/ +#if defined(SQLITE_TEST) +SQLITE_API extern int sqlite3_open_file_count; +#define OpenCounter(X) sqlite3_open_file_count+=(X) +#else +#define OpenCounter(X) +#endif /* defined(SQLITE_TEST) */ + +#endif /* !defined(_OS_COMMON_H_) */ + +/************** End of os_common.h *******************************************/ +/************** Begin file ctime.c *******************************************/ +/* DO NOT EDIT! +** This file is automatically generated by the script in the canonical +** SQLite source tree at tool/mkctimec.tcl. +** +** To modify this header, edit any of the various lists in that script +** which specify categories of generated conditionals in this file. +*/ + +/* +** 2010 February 23 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file implements routines used to report what compile-time options +** SQLite was built with. +*/ +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS /* IMP: R-16824-07538 */ + +/* +** Include the configuration header output by 'configure' if we're using the +** autoconf-based build +*/ +#if defined(_HAVE_SQLITE_CONFIG_H) && !defined(SQLITECONFIG_H) +/* #include "sqlite_cfg.h" */ +#define SQLITECONFIG_H 1 +#endif + +/* These macros are provided to "stringify" the value of the define +** for those options in which the value is meaningful. */ +#define CTIMEOPT_VAL_(opt) #opt +#define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt) + +/* Like CTIMEOPT_VAL, but especially for SQLITE_DEFAULT_LOOKASIDE. This +** option requires a separate macro because legal values contain a single +** comma. e.g. (-DSQLITE_DEFAULT_LOOKASIDE="100,100") */ +#define CTIMEOPT_VAL2_(opt1,opt2) #opt1 "," #opt2 +#define CTIMEOPT_VAL2(opt) CTIMEOPT_VAL2_(opt) +/* #include "sqliteInt.h" */ + +/* +** An array of names of all compile-time options. This array should +** be sorted A-Z. +** +** This array looks large, but in a typical installation actually uses +** only a handful of compile-time options, so most times this array is usually +** rather short and uses little memory space. +*/ +static const char * const sqlite3azCompileOpt[] = { + +#ifdef SQLITE_32BIT_ROWID + "32BIT_ROWID", +#endif +#ifdef SQLITE_4_BYTE_ALIGNED_MALLOC + "4_BYTE_ALIGNED_MALLOC", +#endif +#ifdef SQLITE_64BIT_STATS + "64BIT_STATS", +#endif +#ifdef SQLITE_ALLOW_COVERING_INDEX_SCAN +# if SQLITE_ALLOW_COVERING_INDEX_SCAN != 1 + "ALLOW_COVERING_INDEX_SCAN=" CTIMEOPT_VAL(SQLITE_ALLOW_COVERING_INDEX_SCAN), +# endif +#endif +#ifdef SQLITE_ALLOW_URI_AUTHORITY + "ALLOW_URI_AUTHORITY", +#endif +#ifdef SQLITE_ATOMIC_INTRINSICS + "ATOMIC_INTRINSICS=" CTIMEOPT_VAL(SQLITE_ATOMIC_INTRINSICS), +#endif +#ifdef SQLITE_BITMASK_TYPE + "BITMASK_TYPE=" CTIMEOPT_VAL(SQLITE_BITMASK_TYPE), +#endif +#ifdef SQLITE_BUG_COMPATIBLE_20160819 + "BUG_COMPATIBLE_20160819", +#endif +#ifdef SQLITE_CASE_SENSITIVE_LIKE + "CASE_SENSITIVE_LIKE", +#endif +#ifdef SQLITE_CHECK_PAGES + "CHECK_PAGES", +#endif +#if defined(__clang__) && defined(__clang_major__) + "COMPILER=clang-" CTIMEOPT_VAL(__clang_major__) "." + CTIMEOPT_VAL(__clang_minor__) "." + CTIMEOPT_VAL(__clang_patchlevel__), +#elif defined(_MSC_VER) + "COMPILER=msvc-" CTIMEOPT_VAL(_MSC_VER), +#elif defined(__GNUC__) && defined(__VERSION__) + "COMPILER=gcc-" __VERSION__, +#endif +#ifdef SQLITE_COVERAGE_TEST + "COVERAGE_TEST", +#endif +#ifdef SQLITE_DEBUG + "DEBUG", +#endif +#ifdef SQLITE_DEFAULT_AUTOMATIC_INDEX + "DEFAULT_AUTOMATIC_INDEX", +#endif +#ifdef SQLITE_DEFAULT_AUTOVACUUM + "DEFAULT_AUTOVACUUM", +#endif +#ifdef SQLITE_DEFAULT_CACHE_SIZE + "DEFAULT_CACHE_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_CACHE_SIZE), +#endif +#ifdef SQLITE_DEFAULT_CKPTFULLFSYNC + "DEFAULT_CKPTFULLFSYNC", +#endif +#ifdef SQLITE_DEFAULT_FILE_FORMAT + "DEFAULT_FILE_FORMAT=" CTIMEOPT_VAL(SQLITE_DEFAULT_FILE_FORMAT), +#endif +#ifdef SQLITE_DEFAULT_FILE_PERMISSIONS + "DEFAULT_FILE_PERMISSIONS=" CTIMEOPT_VAL(SQLITE_DEFAULT_FILE_PERMISSIONS), +#endif +#ifdef SQLITE_DEFAULT_FOREIGN_KEYS + "DEFAULT_FOREIGN_KEYS", +#endif +#ifdef SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT + "DEFAULT_JOURNAL_SIZE_LIMIT=" CTIMEOPT_VAL(SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT), +#endif +#ifdef SQLITE_DEFAULT_LOCKING_MODE + "DEFAULT_LOCKING_MODE=" CTIMEOPT_VAL(SQLITE_DEFAULT_LOCKING_MODE), +#endif +#ifdef SQLITE_DEFAULT_LOOKASIDE + "DEFAULT_LOOKASIDE=" CTIMEOPT_VAL2(SQLITE_DEFAULT_LOOKASIDE), +#endif +#ifdef SQLITE_DEFAULT_MEMSTATUS +# if SQLITE_DEFAULT_MEMSTATUS != 1 + "DEFAULT_MEMSTATUS=" CTIMEOPT_VAL(SQLITE_DEFAULT_MEMSTATUS), +# endif +#endif +#ifdef SQLITE_DEFAULT_MMAP_SIZE + "DEFAULT_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_MMAP_SIZE), +#endif +#ifdef SQLITE_DEFAULT_PAGE_SIZE + "DEFAULT_PAGE_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_PAGE_SIZE), +#endif +#ifdef SQLITE_DEFAULT_PCACHE_INITSZ + "DEFAULT_PCACHE_INITSZ=" CTIMEOPT_VAL(SQLITE_DEFAULT_PCACHE_INITSZ), +#endif +#ifdef SQLITE_DEFAULT_PROXYDIR_PERMISSIONS + "DEFAULT_PROXYDIR_PERMISSIONS=" CTIMEOPT_VAL(SQLITE_DEFAULT_PROXYDIR_PERMISSIONS), +#endif +#ifdef SQLITE_DEFAULT_RECURSIVE_TRIGGERS + "DEFAULT_RECURSIVE_TRIGGERS", +#endif +#ifdef SQLITE_DEFAULT_ROWEST + "DEFAULT_ROWEST=" CTIMEOPT_VAL(SQLITE_DEFAULT_ROWEST), +#endif +#ifdef SQLITE_DEFAULT_SECTOR_SIZE + "DEFAULT_SECTOR_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_SECTOR_SIZE), +#endif +#ifdef SQLITE_DEFAULT_SYNCHRONOUS + "DEFAULT_SYNCHRONOUS=" CTIMEOPT_VAL(SQLITE_DEFAULT_SYNCHRONOUS), +#endif +#ifdef SQLITE_DEFAULT_WAL_AUTOCHECKPOINT + "DEFAULT_WAL_AUTOCHECKPOINT=" CTIMEOPT_VAL(SQLITE_DEFAULT_WAL_AUTOCHECKPOINT), +#endif +#ifdef SQLITE_DEFAULT_WAL_SYNCHRONOUS + "DEFAULT_WAL_SYNCHRONOUS=" CTIMEOPT_VAL(SQLITE_DEFAULT_WAL_SYNCHRONOUS), +#endif +#ifdef SQLITE_DEFAULT_WORKER_THREADS + "DEFAULT_WORKER_THREADS=" CTIMEOPT_VAL(SQLITE_DEFAULT_WORKER_THREADS), +#endif +#ifdef SQLITE_DIRECT_OVERFLOW_READ + "DIRECT_OVERFLOW_READ", +#endif +#ifdef SQLITE_DISABLE_DIRSYNC + "DISABLE_DIRSYNC", +#endif +#ifdef SQLITE_DISABLE_FTS3_UNICODE + "DISABLE_FTS3_UNICODE", +#endif +#ifdef SQLITE_DISABLE_FTS4_DEFERRED + "DISABLE_FTS4_DEFERRED", +#endif +#ifdef SQLITE_DISABLE_INTRINSIC + "DISABLE_INTRINSIC", +#endif +#ifdef SQLITE_DISABLE_LFS + "DISABLE_LFS", +#endif +#ifdef SQLITE_DISABLE_PAGECACHE_OVERFLOW_STATS + "DISABLE_PAGECACHE_OVERFLOW_STATS", +#endif +#ifdef SQLITE_DISABLE_SKIPAHEAD_DISTINCT + "DISABLE_SKIPAHEAD_DISTINCT", +#endif +#ifdef SQLITE_DQS + "DQS=" CTIMEOPT_VAL(SQLITE_DQS), +#endif +#ifdef SQLITE_ENABLE_8_3_NAMES + "ENABLE_8_3_NAMES=" CTIMEOPT_VAL(SQLITE_ENABLE_8_3_NAMES), +#endif +#ifdef SQLITE_ENABLE_API_ARMOR + "ENABLE_API_ARMOR", +#endif +#ifdef SQLITE_ENABLE_ATOMIC_WRITE + "ENABLE_ATOMIC_WRITE", +#endif +#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE + "ENABLE_BATCH_ATOMIC_WRITE", +#endif +#ifdef SQLITE_ENABLE_BYTECODE_VTAB + "ENABLE_BYTECODE_VTAB", +#endif +#ifdef SQLITE_ENABLE_CEROD + "ENABLE_CEROD=" CTIMEOPT_VAL(SQLITE_ENABLE_CEROD), +#endif +#ifdef SQLITE_ENABLE_COLUMN_METADATA + "ENABLE_COLUMN_METADATA", +#endif +#ifdef SQLITE_ENABLE_COLUMN_USED_MASK + "ENABLE_COLUMN_USED_MASK", +#endif +#ifdef SQLITE_ENABLE_COSTMULT + "ENABLE_COSTMULT", +#endif +#ifdef SQLITE_ENABLE_CURSOR_HINTS + "ENABLE_CURSOR_HINTS", +#endif +#ifdef SQLITE_ENABLE_DBPAGE_VTAB + "ENABLE_DBPAGE_VTAB", +#endif +#ifdef SQLITE_ENABLE_DBSTAT_VTAB + "ENABLE_DBSTAT_VTAB", +#endif +#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT + "ENABLE_EXPENSIVE_ASSERT", +#endif +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + "ENABLE_EXPLAIN_COMMENTS", +#endif +#ifdef SQLITE_ENABLE_FTS3 + "ENABLE_FTS3", +#endif +#ifdef SQLITE_ENABLE_FTS3_PARENTHESIS + "ENABLE_FTS3_PARENTHESIS", +#endif +#ifdef SQLITE_ENABLE_FTS3_TOKENIZER + "ENABLE_FTS3_TOKENIZER", +#endif +#ifdef SQLITE_ENABLE_FTS4 + "ENABLE_FTS4", +#endif +#ifdef SQLITE_ENABLE_FTS5 + "ENABLE_FTS5", +#endif +#ifdef SQLITE_ENABLE_GEOPOLY + "ENABLE_GEOPOLY", +#endif +#ifdef SQLITE_ENABLE_HIDDEN_COLUMNS + "ENABLE_HIDDEN_COLUMNS", +#endif +#ifdef SQLITE_ENABLE_ICU + "ENABLE_ICU", +#endif +#ifdef SQLITE_ENABLE_IOTRACE + "ENABLE_IOTRACE", +#endif +#ifdef SQLITE_ENABLE_LOAD_EXTENSION + "ENABLE_LOAD_EXTENSION", +#endif +#ifdef SQLITE_ENABLE_LOCKING_STYLE + "ENABLE_LOCKING_STYLE=" CTIMEOPT_VAL(SQLITE_ENABLE_LOCKING_STYLE), +#endif +#ifdef SQLITE_ENABLE_MATH_FUNCTIONS + "ENABLE_MATH_FUNCTIONS", +#endif +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + "ENABLE_MEMORY_MANAGEMENT", +#endif +#ifdef SQLITE_ENABLE_MEMSYS3 + "ENABLE_MEMSYS3", +#endif +#ifdef SQLITE_ENABLE_MEMSYS5 + "ENABLE_MEMSYS5", +#endif +#ifdef SQLITE_ENABLE_MULTIPLEX + "ENABLE_MULTIPLEX", +#endif +#ifdef SQLITE_ENABLE_NORMALIZE + "ENABLE_NORMALIZE", +#endif +#ifdef SQLITE_ENABLE_NULL_TRIM + "ENABLE_NULL_TRIM", +#endif +#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC + "ENABLE_OFFSET_SQL_FUNC", +#endif +#ifdef SQLITE_ENABLE_OVERSIZE_CELL_CHECK + "ENABLE_OVERSIZE_CELL_CHECK", +#endif +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + "ENABLE_PREUPDATE_HOOK", +#endif +#ifdef SQLITE_ENABLE_QPSG + "ENABLE_QPSG", +#endif +#ifdef SQLITE_ENABLE_RBU + "ENABLE_RBU", +#endif +#ifdef SQLITE_ENABLE_RTREE + "ENABLE_RTREE", +#endif +#ifdef SQLITE_ENABLE_SESSION + "ENABLE_SESSION", +#endif +#ifdef SQLITE_ENABLE_SNAPSHOT + "ENABLE_SNAPSHOT", +#endif +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + "ENABLE_SORTER_REFERENCES", +#endif +#ifdef SQLITE_ENABLE_SQLLOG + "ENABLE_SQLLOG", +#endif +#ifdef SQLITE_ENABLE_STAT4 + "ENABLE_STAT4", +#endif +#ifdef SQLITE_ENABLE_STMTVTAB + "ENABLE_STMTVTAB", +#endif +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + "ENABLE_STMT_SCANSTATUS", +#endif +#ifdef SQLITE_ENABLE_TREETRACE + "ENABLE_TREETRACE", +#endif +#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION + "ENABLE_UNKNOWN_SQL_FUNCTION", +#endif +#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY + "ENABLE_UNLOCK_NOTIFY", +#endif +#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT + "ENABLE_UPDATE_DELETE_LIMIT", +#endif +#ifdef SQLITE_ENABLE_URI_00_ERROR + "ENABLE_URI_00_ERROR", +#endif +#ifdef SQLITE_ENABLE_VFSTRACE + "ENABLE_VFSTRACE", +#endif +#ifdef SQLITE_ENABLE_WHERETRACE + "ENABLE_WHERETRACE", +#endif +#ifdef SQLITE_ENABLE_ZIPVFS + "ENABLE_ZIPVFS", +#endif +#ifdef SQLITE_EXPLAIN_ESTIMATED_ROWS + "EXPLAIN_ESTIMATED_ROWS", +#endif +#ifdef SQLITE_EXTRA_IFNULLROW + "EXTRA_IFNULLROW", +#endif +#ifdef SQLITE_EXTRA_INIT + "EXTRA_INIT=" CTIMEOPT_VAL(SQLITE_EXTRA_INIT), +#endif +#ifdef SQLITE_EXTRA_SHUTDOWN + "EXTRA_SHUTDOWN=" CTIMEOPT_VAL(SQLITE_EXTRA_SHUTDOWN), +#endif +#ifdef SQLITE_FTS3_MAX_EXPR_DEPTH + "FTS3_MAX_EXPR_DEPTH=" CTIMEOPT_VAL(SQLITE_FTS3_MAX_EXPR_DEPTH), +#endif +#ifdef SQLITE_FTS5_ENABLE_TEST_MI + "FTS5_ENABLE_TEST_MI", +#endif +#ifdef SQLITE_FTS5_NO_WITHOUT_ROWID + "FTS5_NO_WITHOUT_ROWID", +#endif +/* BEGIN SQLCIPHER */ +#if SQLITE_HAS_CODEC + "HAS_CODEC", +#endif +/* END SQLCIPHER */ +#if HAVE_ISNAN || SQLITE_HAVE_ISNAN + "HAVE_ISNAN", +#endif +#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX +# if SQLITE_HOMEGROWN_RECURSIVE_MUTEX != 1 + "HOMEGROWN_RECURSIVE_MUTEX=" CTIMEOPT_VAL(SQLITE_HOMEGROWN_RECURSIVE_MUTEX), +# endif +#endif +#ifdef SQLITE_IGNORE_AFP_LOCK_ERRORS + "IGNORE_AFP_LOCK_ERRORS", +#endif +#ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS + "IGNORE_FLOCK_LOCK_ERRORS", +#endif +#ifdef SQLITE_INLINE_MEMCPY + "INLINE_MEMCPY", +#endif +#ifdef SQLITE_INT64_TYPE + "INT64_TYPE", +#endif +#ifdef SQLITE_INTEGRITY_CHECK_ERROR_MAX + "INTEGRITY_CHECK_ERROR_MAX=" CTIMEOPT_VAL(SQLITE_INTEGRITY_CHECK_ERROR_MAX), +#endif +#ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS + "LIKE_DOESNT_MATCH_BLOBS", +#endif +#ifdef SQLITE_LOCK_TRACE + "LOCK_TRACE", +#endif +#ifdef SQLITE_LOG_CACHE_SPILL + "LOG_CACHE_SPILL", +#endif +#ifdef SQLITE_MALLOC_SOFT_LIMIT + "MALLOC_SOFT_LIMIT=" CTIMEOPT_VAL(SQLITE_MALLOC_SOFT_LIMIT), +#endif +#ifdef SQLITE_MAX_ATTACHED + "MAX_ATTACHED=" CTIMEOPT_VAL(SQLITE_MAX_ATTACHED), +#endif +#ifdef SQLITE_MAX_COLUMN + "MAX_COLUMN=" CTIMEOPT_VAL(SQLITE_MAX_COLUMN), +#endif +#ifdef SQLITE_MAX_COMPOUND_SELECT + "MAX_COMPOUND_SELECT=" CTIMEOPT_VAL(SQLITE_MAX_COMPOUND_SELECT), +#endif +#ifdef SQLITE_MAX_DEFAULT_PAGE_SIZE + "MAX_DEFAULT_PAGE_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_DEFAULT_PAGE_SIZE), +#endif +#ifdef SQLITE_MAX_EXPR_DEPTH + "MAX_EXPR_DEPTH=" CTIMEOPT_VAL(SQLITE_MAX_EXPR_DEPTH), +#endif +#ifdef SQLITE_MAX_FUNCTION_ARG + "MAX_FUNCTION_ARG=" CTIMEOPT_VAL(SQLITE_MAX_FUNCTION_ARG), +#endif +#ifdef SQLITE_MAX_LENGTH + "MAX_LENGTH=" CTIMEOPT_VAL(SQLITE_MAX_LENGTH), +#endif +#ifdef SQLITE_MAX_LIKE_PATTERN_LENGTH + "MAX_LIKE_PATTERN_LENGTH=" CTIMEOPT_VAL(SQLITE_MAX_LIKE_PATTERN_LENGTH), +#endif +#ifdef SQLITE_MAX_MEMORY + "MAX_MEMORY=" CTIMEOPT_VAL(SQLITE_MAX_MEMORY), +#endif +#ifdef SQLITE_MAX_MMAP_SIZE + "MAX_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_MMAP_SIZE), +#endif +#ifdef SQLITE_MAX_MMAP_SIZE_ + "MAX_MMAP_SIZE_=" CTIMEOPT_VAL(SQLITE_MAX_MMAP_SIZE_), +#endif +#ifdef SQLITE_MAX_PAGE_COUNT + "MAX_PAGE_COUNT=" CTIMEOPT_VAL(SQLITE_MAX_PAGE_COUNT), +#endif +#ifdef SQLITE_MAX_PAGE_SIZE + "MAX_PAGE_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_PAGE_SIZE), +#endif +#ifdef SQLITE_MAX_SCHEMA_RETRY + "MAX_SCHEMA_RETRY=" CTIMEOPT_VAL(SQLITE_MAX_SCHEMA_RETRY), +#endif +#ifdef SQLITE_MAX_SQL_LENGTH + "MAX_SQL_LENGTH=" CTIMEOPT_VAL(SQLITE_MAX_SQL_LENGTH), +#endif +#ifdef SQLITE_MAX_TRIGGER_DEPTH + "MAX_TRIGGER_DEPTH=" CTIMEOPT_VAL(SQLITE_MAX_TRIGGER_DEPTH), +#endif +#ifdef SQLITE_MAX_VARIABLE_NUMBER + "MAX_VARIABLE_NUMBER=" CTIMEOPT_VAL(SQLITE_MAX_VARIABLE_NUMBER), +#endif +#ifdef SQLITE_MAX_VDBE_OP + "MAX_VDBE_OP=" CTIMEOPT_VAL(SQLITE_MAX_VDBE_OP), +#endif +#ifdef SQLITE_MAX_WORKER_THREADS + "MAX_WORKER_THREADS=" CTIMEOPT_VAL(SQLITE_MAX_WORKER_THREADS), +#endif +#ifdef SQLITE_MEMDEBUG + "MEMDEBUG", +#endif +#ifdef SQLITE_MIXED_ENDIAN_64BIT_FLOAT + "MIXED_ENDIAN_64BIT_FLOAT", +#endif +#ifdef SQLITE_MMAP_READWRITE + "MMAP_READWRITE", +#endif +#ifdef SQLITE_MUTEX_NOOP + "MUTEX_NOOP", +#endif +#ifdef SQLITE_MUTEX_OMIT + "MUTEX_OMIT", +#endif +#ifdef SQLITE_MUTEX_PTHREADS + "MUTEX_PTHREADS", +#endif +#ifdef SQLITE_MUTEX_W32 + "MUTEX_W32", +#endif +#ifdef SQLITE_NEED_ERR_NAME + "NEED_ERR_NAME", +#endif +#ifdef SQLITE_NO_SYNC + "NO_SYNC", +#endif +#ifdef SQLITE_OMIT_ALTERTABLE + "OMIT_ALTERTABLE", +#endif +#ifdef SQLITE_OMIT_ANALYZE + "OMIT_ANALYZE", +#endif +#ifdef SQLITE_OMIT_ATTACH + "OMIT_ATTACH", +#endif +#ifdef SQLITE_OMIT_AUTHORIZATION + "OMIT_AUTHORIZATION", +#endif +#ifdef SQLITE_OMIT_AUTOINCREMENT + "OMIT_AUTOINCREMENT", +#endif +#ifdef SQLITE_OMIT_AUTOINIT + "OMIT_AUTOINIT", +#endif +#ifdef SQLITE_OMIT_AUTOMATIC_INDEX + "OMIT_AUTOMATIC_INDEX", +#endif +#ifdef SQLITE_OMIT_AUTORESET + "OMIT_AUTORESET", +#endif +#ifdef SQLITE_OMIT_AUTOVACUUM + "OMIT_AUTOVACUUM", +#endif +#ifdef SQLITE_OMIT_BETWEEN_OPTIMIZATION + "OMIT_BETWEEN_OPTIMIZATION", +#endif +#ifdef SQLITE_OMIT_BLOB_LITERAL + "OMIT_BLOB_LITERAL", +#endif +#ifdef SQLITE_OMIT_CAST + "OMIT_CAST", +#endif +#ifdef SQLITE_OMIT_CHECK + "OMIT_CHECK", +#endif +#ifdef SQLITE_OMIT_COMPLETE + "OMIT_COMPLETE", +#endif +#ifdef SQLITE_OMIT_COMPOUND_SELECT + "OMIT_COMPOUND_SELECT", +#endif +#ifdef SQLITE_OMIT_CONFLICT_CLAUSE + "OMIT_CONFLICT_CLAUSE", +#endif +#ifdef SQLITE_OMIT_CTE + "OMIT_CTE", +#endif +#if defined(SQLITE_OMIT_DATETIME_FUNCS) || defined(SQLITE_OMIT_FLOATING_POINT) + "OMIT_DATETIME_FUNCS", +#endif +#ifdef SQLITE_OMIT_DECLTYPE + "OMIT_DECLTYPE", +#endif +#ifdef SQLITE_OMIT_DEPRECATED + "OMIT_DEPRECATED", +#endif +#ifdef SQLITE_OMIT_DESERIALIZE + "OMIT_DESERIALIZE", +#endif +#ifdef SQLITE_OMIT_DISKIO + "OMIT_DISKIO", +#endif +#ifdef SQLITE_OMIT_EXPLAIN + "OMIT_EXPLAIN", +#endif +#ifdef SQLITE_OMIT_FLAG_PRAGMAS + "OMIT_FLAG_PRAGMAS", +#endif +#ifdef SQLITE_OMIT_FLOATING_POINT + "OMIT_FLOATING_POINT", +#endif +#ifdef SQLITE_OMIT_FOREIGN_KEY + "OMIT_FOREIGN_KEY", +#endif +#ifdef SQLITE_OMIT_GET_TABLE + "OMIT_GET_TABLE", +#endif +#ifdef SQLITE_OMIT_HEX_INTEGER + "OMIT_HEX_INTEGER", +#endif +#ifdef SQLITE_OMIT_INCRBLOB + "OMIT_INCRBLOB", +#endif +#ifdef SQLITE_OMIT_INTEGRITY_CHECK + "OMIT_INTEGRITY_CHECK", +#endif +#ifdef SQLITE_OMIT_INTROSPECTION_PRAGMAS + "OMIT_INTROSPECTION_PRAGMAS", +#endif +#ifdef SQLITE_OMIT_JSON + "OMIT_JSON", +#endif +#ifdef SQLITE_OMIT_LIKE_OPTIMIZATION + "OMIT_LIKE_OPTIMIZATION", +#endif +#ifdef SQLITE_OMIT_LOAD_EXTENSION + "OMIT_LOAD_EXTENSION", +#endif +#ifdef SQLITE_OMIT_LOCALTIME + "OMIT_LOCALTIME", +#endif +#ifdef SQLITE_OMIT_LOOKASIDE + "OMIT_LOOKASIDE", +#endif +#ifdef SQLITE_OMIT_MEMORYDB + "OMIT_MEMORYDB", +#endif +#ifdef SQLITE_OMIT_OR_OPTIMIZATION + "OMIT_OR_OPTIMIZATION", +#endif +#ifdef SQLITE_OMIT_PAGER_PRAGMAS + "OMIT_PAGER_PRAGMAS", +#endif +#ifdef SQLITE_OMIT_PARSER_TRACE + "OMIT_PARSER_TRACE", +#endif +#ifdef SQLITE_OMIT_POPEN + "OMIT_POPEN", +#endif +#ifdef SQLITE_OMIT_PRAGMA + "OMIT_PRAGMA", +#endif +#ifdef SQLITE_OMIT_PROGRESS_CALLBACK + "OMIT_PROGRESS_CALLBACK", +#endif +#ifdef SQLITE_OMIT_QUICKBALANCE + "OMIT_QUICKBALANCE", +#endif +#ifdef SQLITE_OMIT_REINDEX + "OMIT_REINDEX", +#endif +#ifdef SQLITE_OMIT_SCHEMA_PRAGMAS + "OMIT_SCHEMA_PRAGMAS", +#endif +#ifdef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS + "OMIT_SCHEMA_VERSION_PRAGMAS", +#endif +#ifdef SQLITE_OMIT_SHARED_CACHE + "OMIT_SHARED_CACHE", +#endif +#ifdef SQLITE_OMIT_SHUTDOWN_DIRECTORIES + "OMIT_SHUTDOWN_DIRECTORIES", +#endif +#ifdef SQLITE_OMIT_SUBQUERY + "OMIT_SUBQUERY", +#endif +#ifdef SQLITE_OMIT_TCL_VARIABLE + "OMIT_TCL_VARIABLE", +#endif +#ifdef SQLITE_OMIT_TEMPDB + "OMIT_TEMPDB", +#endif +#ifdef SQLITE_OMIT_TEST_CONTROL + "OMIT_TEST_CONTROL", +#endif +#ifdef SQLITE_OMIT_TRACE +# if SQLITE_OMIT_TRACE != 1 + "OMIT_TRACE=" CTIMEOPT_VAL(SQLITE_OMIT_TRACE), +# endif +#endif +#ifdef SQLITE_OMIT_TRIGGER + "OMIT_TRIGGER", +#endif +#ifdef SQLITE_OMIT_TRUNCATE_OPTIMIZATION + "OMIT_TRUNCATE_OPTIMIZATION", +#endif +#ifdef SQLITE_OMIT_UTF16 + "OMIT_UTF16", +#endif +#ifdef SQLITE_OMIT_VACUUM + "OMIT_VACUUM", +#endif +#ifdef SQLITE_OMIT_VIEW + "OMIT_VIEW", +#endif +#ifdef SQLITE_OMIT_VIRTUALTABLE + "OMIT_VIRTUALTABLE", +#endif +#ifdef SQLITE_OMIT_WAL + "OMIT_WAL", +#endif +#ifdef SQLITE_OMIT_WSD + "OMIT_WSD", +#endif +#ifdef SQLITE_OMIT_XFER_OPT + "OMIT_XFER_OPT", +#endif +#ifdef SQLITE_PERFORMANCE_TRACE + "PERFORMANCE_TRACE", +#endif +#ifdef SQLITE_POWERSAFE_OVERWRITE +# if SQLITE_POWERSAFE_OVERWRITE != 1 + "POWERSAFE_OVERWRITE=" CTIMEOPT_VAL(SQLITE_POWERSAFE_OVERWRITE), +# endif +#endif +#ifdef SQLITE_PREFER_PROXY_LOCKING + "PREFER_PROXY_LOCKING", +#endif +#ifdef SQLITE_PROXY_DEBUG + "PROXY_DEBUG", +#endif +#ifdef SQLITE_REVERSE_UNORDERED_SELECTS + "REVERSE_UNORDERED_SELECTS", +#endif +#ifdef SQLITE_RTREE_INT_ONLY + "RTREE_INT_ONLY", +#endif +#ifdef SQLITE_SECURE_DELETE + "SECURE_DELETE", +#endif +#ifdef SQLITE_SMALL_STACK + "SMALL_STACK", +#endif +#ifdef SQLITE_SORTER_PMASZ + "SORTER_PMASZ=" CTIMEOPT_VAL(SQLITE_SORTER_PMASZ), +#endif +#ifdef SQLITE_SOUNDEX + "SOUNDEX", +#endif +#ifdef SQLITE_STAT4_SAMPLES + "STAT4_SAMPLES=" CTIMEOPT_VAL(SQLITE_STAT4_SAMPLES), +#endif +#ifdef SQLITE_STMTJRNL_SPILL + "STMTJRNL_SPILL=" CTIMEOPT_VAL(SQLITE_STMTJRNL_SPILL), +#endif +#ifdef SQLITE_SUBSTR_COMPATIBILITY + "SUBSTR_COMPATIBILITY", +#endif +#if (!defined(SQLITE_WIN32_MALLOC) \ + && !defined(SQLITE_ZERO_MALLOC) \ + && !defined(SQLITE_MEMDEBUG) \ + ) || defined(SQLITE_SYSTEM_MALLOC) + "SYSTEM_MALLOC", +#endif +#ifdef SQLITE_TCL + "TCL", +#endif +#ifdef SQLITE_TEMP_STORE + "TEMP_STORE=" CTIMEOPT_VAL(SQLITE_TEMP_STORE), +#endif +#ifdef SQLITE_TEST + "TEST", +#endif +#if defined(SQLITE_THREADSAFE) + "THREADSAFE=" CTIMEOPT_VAL(SQLITE_THREADSAFE), +#elif defined(THREADSAFE) + "THREADSAFE=" CTIMEOPT_VAL(THREADSAFE), +#else + "THREADSAFE=1", +#endif +#ifdef SQLITE_UNLINK_AFTER_CLOSE + "UNLINK_AFTER_CLOSE", +#endif +#ifdef SQLITE_UNTESTABLE + "UNTESTABLE", +#endif +#ifdef SQLITE_USER_AUTHENTICATION + "USER_AUTHENTICATION", +#endif +#ifdef SQLITE_USE_ALLOCA + "USE_ALLOCA", +#endif +#ifdef SQLITE_USE_FCNTL_TRACE + "USE_FCNTL_TRACE", +#endif +#ifdef SQLITE_USE_URI + "USE_URI", +#endif +#ifdef SQLITE_VDBE_COVERAGE + "VDBE_COVERAGE", +#endif +#ifdef SQLITE_WIN32_MALLOC + "WIN32_MALLOC", +#endif +#ifdef SQLITE_ZERO_MALLOC + "ZERO_MALLOC", +#endif + +} ; + +SQLITE_PRIVATE const char **sqlite3CompileOptions(int *pnOpt){ + *pnOpt = sizeof(sqlite3azCompileOpt) / sizeof(sqlite3azCompileOpt[0]); + return (const char**)sqlite3azCompileOpt; +} + +#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ + +/************** End of ctime.c ***********************************************/ +/************** Begin file global.c ******************************************/ +/* +** 2008 June 13 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains definitions of global variables and constants. +*/ +/* #include "sqliteInt.h" */ + +/* An array to map all upper-case characters into their corresponding +** lower-case character. +** +** SQLite only considers US-ASCII (or EBCDIC) characters. We do not +** handle case conversions for the UTF character set since the tables +** involved are nearly as big or bigger than SQLite itself. +*/ +SQLITE_PRIVATE const unsigned char sqlite3UpperToLower[] = { +#ifdef SQLITE_ASCII + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99,100,101,102,103, + 104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121, + 122, 91, 92, 93, 94, 95, 96, 97, 98, 99,100,101,102,103,104,105,106,107, + 108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125, + 126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, + 144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161, + 162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179, + 180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197, + 198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215, + 216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233, + 234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251, + 252,253,254,255, +#endif +#ifdef SQLITE_EBCDIC + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* 0x */ + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* 1x */ + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, /* 2x */ + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, /* 3x */ + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, /* 4x */ + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, /* 5x */ + 96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111, /* 6x */ + 112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127, /* 7x */ + 128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, /* 8x */ + 144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159, /* 9x */ + 160,161,162,163,164,165,166,167,168,169,170,171,140,141,142,175, /* Ax */ + 176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191, /* Bx */ + 192,129,130,131,132,133,134,135,136,137,202,203,204,205,206,207, /* Cx */ + 208,145,146,147,148,149,150,151,152,153,218,219,220,221,222,223, /* Dx */ + 224,225,162,163,164,165,166,167,168,169,234,235,236,237,238,239, /* Ex */ + 240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255, /* Fx */ +#endif +/* All of the upper-to-lower conversion data is above. The following +** 18 integers are completely unrelated. They are appended to the +** sqlite3UpperToLower[] array to avoid UBSAN warnings. Here's what is +** going on: +** +** The SQL comparison operators (<>, =, >, <=, <, and >=) are implemented +** by invoking sqlite3MemCompare(A,B) which compares values A and B and +** returns negative, zero, or positive if A is less then, equal to, or +** greater than B, respectively. Then the true false results is found by +** consulting sqlite3aLTb[opcode], sqlite3aEQb[opcode], or +** sqlite3aGTb[opcode] depending on whether the result of compare(A,B) +** is negative, zero, or positive, where opcode is the specific opcode. +** The only works because the comparison opcodes are consecutive and in +** this order: NE EQ GT LE LT GE. Various assert()s throughout the code +** ensure that is the case. +** +** These elements must be appended to another array. Otherwise the +** index (here shown as [256-OP_Ne]) would be out-of-bounds and thus +** be undefined behavior. That's goofy, but the C-standards people thought +** it was a good idea, so here we are. +*/ +/* NE EQ GT LE LT GE */ + 1, 0, 0, 1, 1, 0, /* aLTb[]: Use when compare(A,B) less than zero */ + 0, 1, 0, 1, 0, 1, /* aEQb[]: Use when compare(A,B) equals zero */ + 1, 0, 1, 0, 0, 1 /* aGTb[]: Use when compare(A,B) greater than zero*/ +}; +SQLITE_PRIVATE const unsigned char *sqlite3aLTb = &sqlite3UpperToLower[256-OP_Ne]; +SQLITE_PRIVATE const unsigned char *sqlite3aEQb = &sqlite3UpperToLower[256+6-OP_Ne]; +SQLITE_PRIVATE const unsigned char *sqlite3aGTb = &sqlite3UpperToLower[256+12-OP_Ne]; + +/* +** The following 256 byte lookup table is used to support SQLites built-in +** equivalents to the following standard library functions: +** +** isspace() 0x01 +** isalpha() 0x02 +** isdigit() 0x04 +** isalnum() 0x06 +** isxdigit() 0x08 +** toupper() 0x20 +** SQLite identifier character 0x40 $, _, or non-ascii +** Quote character 0x80 +** +** Bit 0x20 is set if the mapped character requires translation to upper +** case. i.e. if the character is a lower-case ASCII character. +** If x is a lower-case ASCII character, then its upper-case equivalent +** is (x - 0x20). Therefore toupper() can be implemented as: +** +** (x & ~(map[x]&0x20)) +** +** The equivalent of tolower() is implemented using the sqlite3UpperToLower[] +** array. tolower() is used more often than toupper() by SQLite. +** +** Bit 0x40 is set if the character is non-alphanumeric and can be used in an +** SQLite identifier. Identifiers are alphanumerics, "_", "$", and any +** non-ASCII UTF character. Hence the test for whether or not a character is +** part of an identifier is 0x46. +*/ +SQLITE_PRIVATE const unsigned char sqlite3CtypeMap[256] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 00..07 ........ */ + 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, /* 08..0f ........ */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 10..17 ........ */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 18..1f ........ */ + 0x01, 0x00, 0x80, 0x00, 0x40, 0x00, 0x00, 0x80, /* 20..27 !"#$%&' */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 28..2f ()*+,-./ */ + 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, /* 30..37 01234567 */ + 0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 38..3f 89:;<=>? */ + + 0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x02, /* 40..47 @ABCDEFG */ + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, /* 48..4f HIJKLMNO */ + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, /* 50..57 PQRSTUVW */ + 0x02, 0x02, 0x02, 0x80, 0x00, 0x00, 0x00, 0x40, /* 58..5f XYZ[\]^_ */ + 0x80, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x22, /* 60..67 `abcdefg */ + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, /* 68..6f hijklmno */ + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, /* 70..77 pqrstuvw */ + 0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, /* 78..7f xyz{|}~. */ + + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 80..87 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 88..8f ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 90..97 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 98..9f ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* a0..a7 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* a8..af ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* b0..b7 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* b8..bf ........ */ + + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* c0..c7 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* c8..cf ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* d0..d7 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* d8..df ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* e0..e7 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* e8..ef ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* f0..f7 ........ */ + 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40 /* f8..ff ........ */ +}; + +/* EVIDENCE-OF: R-02982-34736 In order to maintain full backwards +** compatibility for legacy applications, the URI filename capability is +** disabled by default. +** +** EVIDENCE-OF: R-38799-08373 URI filenames can be enabled or disabled +** using the SQLITE_USE_URI=1 or SQLITE_USE_URI=0 compile-time options. +** +** EVIDENCE-OF: R-43642-56306 By default, URI handling is globally +** disabled. The default value may be changed by compiling with the +** SQLITE_USE_URI symbol defined. +** +** URI filenames are enabled by default if SQLITE_HAS_CODEC is +** enabled. +*/ +#ifndef SQLITE_USE_URI +/* BEGIN SQLCIPHER */ +# ifdef SQLITE_HAS_CODEC +# define SQLITE_USE_URI 1 +# else +# define SQLITE_USE_URI 0 +# endif +/* END SQLCIPHER */ +#endif + +/* EVIDENCE-OF: R-38720-18127 The default setting is determined by the +** SQLITE_ALLOW_COVERING_INDEX_SCAN compile-time option, or is "on" if +** that compile-time option is omitted. +*/ +#if !defined(SQLITE_ALLOW_COVERING_INDEX_SCAN) +# define SQLITE_ALLOW_COVERING_INDEX_SCAN 1 +#else +# if !SQLITE_ALLOW_COVERING_INDEX_SCAN +# error "Compile-time disabling of covering index scan using the\ + -DSQLITE_ALLOW_COVERING_INDEX_SCAN=0 option is deprecated.\ + Contact SQLite developers if this is a problem for you, and\ + delete this #error macro to continue with your build." +# endif +#endif + +/* The minimum PMA size is set to this value multiplied by the database +** page size in bytes. +*/ +#ifndef SQLITE_SORTER_PMASZ +# define SQLITE_SORTER_PMASZ 250 +#endif + +/* Statement journals spill to disk when their size exceeds the following +** threshold (in bytes). 0 means that statement journals are created and +** written to disk immediately (the default behavior for SQLite versions +** before 3.12.0). -1 means always keep the entire statement journal in +** memory. (The statement journal is also always held entirely in memory +** if journal_mode=MEMORY or if temp_store=MEMORY, regardless of this +** setting.) +*/ +#ifndef SQLITE_STMTJRNL_SPILL +# define SQLITE_STMTJRNL_SPILL (64*1024) +#endif + +/* +** The default lookaside-configuration, the format "SZ,N". SZ is the +** number of bytes in each lookaside slot (should be a multiple of 8) +** and N is the number of slots. The lookaside-configuration can be +** changed as start-time using sqlite3_config(SQLITE_CONFIG_LOOKASIDE) +** or at run-time for an individual database connection using +** sqlite3_db_config(db, SQLITE_DBCONFIG_LOOKASIDE); +** +** With the two-size-lookaside enhancement, less lookaside is required. +** The default configuration of 1200,40 actually provides 30 1200-byte slots +** and 93 128-byte slots, which is more lookaside than is available +** using the older 1200,100 configuration without two-size-lookaside. +*/ +#ifndef SQLITE_DEFAULT_LOOKASIDE +# ifdef SQLITE_OMIT_TWOSIZE_LOOKASIDE +# define SQLITE_DEFAULT_LOOKASIDE 1200,100 /* 120KB of memory */ +# else +# define SQLITE_DEFAULT_LOOKASIDE 1200,40 /* 48KB of memory */ +# endif +#endif + + +/* The default maximum size of an in-memory database created using +** sqlite3_deserialize() +*/ +#ifndef SQLITE_MEMDB_DEFAULT_MAXSIZE +# define SQLITE_MEMDB_DEFAULT_MAXSIZE 1073741824 +#endif + +/* +** The following singleton contains the global configuration for +** the SQLite library. +*/ +SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config = { + SQLITE_DEFAULT_MEMSTATUS, /* bMemstat */ + 1, /* bCoreMutex */ + SQLITE_THREADSAFE==1, /* bFullMutex */ + SQLITE_USE_URI, /* bOpenUri */ + SQLITE_ALLOW_COVERING_INDEX_SCAN, /* bUseCis */ + 0, /* bSmallMalloc */ + 1, /* bExtraSchemaChecks */ + 0x7ffffffe, /* mxStrlen */ + 0, /* neverCorrupt */ + SQLITE_DEFAULT_LOOKASIDE, /* szLookaside, nLookaside */ + SQLITE_STMTJRNL_SPILL, /* nStmtSpill */ + {0,0,0,0,0,0,0,0}, /* m */ + {0,0,0,0,0,0,0,0,0}, /* mutex */ + {0,0,0,0,0,0,0,0,0,0,0,0,0},/* pcache2 */ + (void*)0, /* pHeap */ + 0, /* nHeap */ + 0, 0, /* mnHeap, mxHeap */ + SQLITE_DEFAULT_MMAP_SIZE, /* szMmap */ + SQLITE_MAX_MMAP_SIZE, /* mxMmap */ + (void*)0, /* pPage */ + 0, /* szPage */ + SQLITE_DEFAULT_PCACHE_INITSZ, /* nPage */ + 0, /* mxParserStack */ + 0, /* sharedCacheEnabled */ + SQLITE_SORTER_PMASZ, /* szPma */ + /* All the rest should always be initialized to zero */ + 0, /* isInit */ + 0, /* inProgress */ + 0, /* isMutexInit */ + 0, /* isMallocInit */ + 0, /* isPCacheInit */ + 0, /* nRefInitMutex */ + 0, /* pInitMutex */ + 0, /* xLog */ + 0, /* pLogArg */ +#ifdef SQLITE_ENABLE_SQLLOG + 0, /* xSqllog */ + 0, /* pSqllogArg */ +#endif +#ifdef SQLITE_VDBE_COVERAGE + 0, /* xVdbeBranch */ + 0, /* pVbeBranchArg */ +#endif +#ifndef SQLITE_OMIT_DESERIALIZE + SQLITE_MEMDB_DEFAULT_MAXSIZE, /* mxMemdbSize */ +#endif +#ifndef SQLITE_UNTESTABLE + 0, /* xTestCallback */ +#endif + 0, /* bLocaltimeFault */ + 0, /* xAltLocaltime */ + 0x7ffffffe, /* iOnceResetThreshold */ + SQLITE_DEFAULT_SORTERREF_SIZE, /* szSorterRef */ + 0, /* iPrngSeed */ +#ifdef SQLITE_DEBUG + {0,0,0,0,0,0}, /* aTune */ +#endif +}; + +/* +** Hash table for global functions - functions common to all +** database connections. After initialization, this table is +** read-only. +*/ +SQLITE_PRIVATE FuncDefHash sqlite3BuiltinFunctions; + +#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_DEBUG) +/* +** Counter used for coverage testing. Does not come into play for +** release builds. +** +** Access to this global variable is not mutex protected. This might +** result in TSAN warnings. But as the variable does not exist in +** release builds, that should not be a concern. +*/ +SQLITE_PRIVATE unsigned int sqlite3CoverageCounter; +#endif /* SQLITE_COVERAGE_TEST || SQLITE_DEBUG */ + +#ifdef VDBE_PROFILE +/* +** The following performance counter can be used in place of +** sqlite3Hwtime() for profiling. This is a no-op on standard builds. +*/ +SQLITE_PRIVATE sqlite3_uint64 sqlite3NProfileCnt = 0; +#endif + +/* +** The value of the "pending" byte must be 0x40000000 (1 byte past the +** 1-gibabyte boundary) in a compatible database. SQLite never uses +** the database page that contains the pending byte. It never attempts +** to read or write that page. The pending byte page is set aside +** for use by the VFS layers as space for managing file locks. +** +** During testing, it is often desirable to move the pending byte to +** a different position in the file. This allows code that has to +** deal with the pending byte to run on files that are much smaller +** than 1 GiB. The sqlite3_test_control() interface can be used to +** move the pending byte. +** +** IMPORTANT: Changing the pending byte to any value other than +** 0x40000000 results in an incompatible database file format! +** Changing the pending byte during operation will result in undefined +** and incorrect behavior. +*/ +#ifndef SQLITE_OMIT_WSD +SQLITE_PRIVATE int sqlite3PendingByte = 0x40000000; +#endif + +/* +** Tracing flags set by SQLITE_TESTCTRL_TRACEFLAGS. +*/ +SQLITE_PRIVATE u32 sqlite3TreeTrace = 0; +SQLITE_PRIVATE u32 sqlite3WhereTrace = 0; + +/* #include "opcodes.h" */ +/* +** Properties of opcodes. The OPFLG_INITIALIZER macro is +** created by mkopcodeh.awk during compilation. Data is obtained +** from the comments following the "case OP_xxxx:" statements in +** the vdbe.c file. +*/ +SQLITE_PRIVATE const unsigned char sqlite3OpcodeProperty[] = OPFLG_INITIALIZER; + +/* +** Name of the default collating sequence +*/ +SQLITE_PRIVATE const char sqlite3StrBINARY[] = "BINARY"; + +/* +** Standard typenames. These names must match the COLTYPE_* definitions. +** Adjust the SQLITE_N_STDTYPE value if adding or removing entries. +** +** sqlite3StdType[] The actual names of the datatypes. +** +** sqlite3StdTypeLen[] The length (in bytes) of each entry +** in sqlite3StdType[]. +** +** sqlite3StdTypeAffinity[] The affinity associated with each entry +** in sqlite3StdType[]. +*/ +SQLITE_PRIVATE const unsigned char sqlite3StdTypeLen[] = { 3, 4, 3, 7, 4, 4 }; +SQLITE_PRIVATE const char sqlite3StdTypeAffinity[] = { + SQLITE_AFF_NUMERIC, + SQLITE_AFF_BLOB, + SQLITE_AFF_INTEGER, + SQLITE_AFF_INTEGER, + SQLITE_AFF_REAL, + SQLITE_AFF_TEXT +}; +SQLITE_PRIVATE const char *sqlite3StdType[] = { + "ANY", + "BLOB", + "INT", + "INTEGER", + "REAL", + "TEXT" +}; + +/************** End of global.c **********************************************/ +/************** Begin file status.c ******************************************/ +/* +** 2008 June 18 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This module implements the sqlite3_status() interface and related +** functionality. +*/ +/* #include "sqliteInt.h" */ +/************** Include vdbeInt.h in the middle of status.c ******************/ +/************** Begin file vdbeInt.h *****************************************/ +/* +** 2003 September 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This is the header file for information that is private to the +** VDBE. This information used to all be at the top of the single +** source code file "vdbe.c". When that file became too big (over +** 6000 lines long) it was split up into several smaller files and +** this header information was factored out. +*/ +#ifndef SQLITE_VDBEINT_H +#define SQLITE_VDBEINT_H + +/* +** The maximum number of times that a statement will try to reparse +** itself before giving up and returning SQLITE_SCHEMA. +*/ +#ifndef SQLITE_MAX_SCHEMA_RETRY +# define SQLITE_MAX_SCHEMA_RETRY 50 +#endif + +/* +** VDBE_DISPLAY_P4 is true or false depending on whether or not the +** "explain" P4 display logic is enabled. +*/ +#if !defined(SQLITE_OMIT_EXPLAIN) || !defined(NDEBUG) \ + || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG) \ + || defined(SQLITE_ENABLE_BYTECODE_VTAB) +# define VDBE_DISPLAY_P4 1 +#else +# define VDBE_DISPLAY_P4 0 +#endif + +/* +** SQL is translated into a sequence of instructions to be +** executed by a virtual machine. Each instruction is an instance +** of the following structure. +*/ +typedef struct VdbeOp Op; + +/* +** Boolean values +*/ +typedef unsigned Bool; + +/* Opaque type used by code in vdbesort.c */ +typedef struct VdbeSorter VdbeSorter; + +/* Elements of the linked list at Vdbe.pAuxData */ +typedef struct AuxData AuxData; + +/* Types of VDBE cursors */ +#define CURTYPE_BTREE 0 +#define CURTYPE_SORTER 1 +#define CURTYPE_VTAB 2 +#define CURTYPE_PSEUDO 3 + +/* +** A VdbeCursor is an superclass (a wrapper) for various cursor objects: +** +** * A b-tree cursor +** - In the main database or in an ephemeral database +** - On either an index or a table +** * A sorter +** * A virtual table +** * A one-row "pseudotable" stored in a single register +*/ +typedef struct VdbeCursor VdbeCursor; +struct VdbeCursor { + u8 eCurType; /* One of the CURTYPE_* values above */ + i8 iDb; /* Index of cursor database in db->aDb[] */ + u8 nullRow; /* True if pointing to a row with no data */ + u8 deferredMoveto; /* A call to sqlite3BtreeMoveto() is needed */ + u8 isTable; /* True for rowid tables. False for indexes */ +#ifdef SQLITE_DEBUG + u8 seekOp; /* Most recent seek operation on this cursor */ + u8 wrFlag; /* The wrFlag argument to sqlite3BtreeCursor() */ +#endif + Bool isEphemeral:1; /* True for an ephemeral table */ + Bool useRandomRowid:1; /* Generate new record numbers semi-randomly */ + Bool isOrdered:1; /* True if the table is not BTREE_UNORDERED */ + Bool noReuse:1; /* OpenEphemeral may not reuse this cursor */ + u16 seekHit; /* See the OP_SeekHit and OP_IfNoHope opcodes */ + union { /* pBtx for isEphermeral. pAltMap otherwise */ + Btree *pBtx; /* Separate file holding temporary table */ + u32 *aAltMap; /* Mapping from table to index column numbers */ + } ub; + i64 seqCount; /* Sequence counter */ + + /* Cached OP_Column parse information is only valid if cacheStatus matches + ** Vdbe.cacheCtr. Vdbe.cacheCtr will never take on the value of + ** CACHE_STALE (0) and so setting cacheStatus=CACHE_STALE guarantees that + ** the cache is out of date. */ + u32 cacheStatus; /* Cache is valid if this matches Vdbe.cacheCtr */ + int seekResult; /* Result of previous sqlite3BtreeMoveto() or 0 + ** if there have been no prior seeks on the cursor. */ + /* seekResult does not distinguish between "no seeks have ever occurred + ** on this cursor" and "the most recent seek was an exact match". + ** For CURTYPE_PSEUDO, seekResult is the register holding the record */ + + /* When a new VdbeCursor is allocated, only the fields above are zeroed. + ** The fields that follow are uninitialized, and must be individually + ** initialized prior to first use. */ + VdbeCursor *pAltCursor; /* Associated index cursor from which to read */ + union { + BtCursor *pCursor; /* CURTYPE_BTREE or _PSEUDO. Btree cursor */ + sqlite3_vtab_cursor *pVCur; /* CURTYPE_VTAB. Vtab cursor */ + VdbeSorter *pSorter; /* CURTYPE_SORTER. Sorter object */ + } uc; + KeyInfo *pKeyInfo; /* Info about index keys needed by index cursors */ + u32 iHdrOffset; /* Offset to next unparsed byte of the header */ + Pgno pgnoRoot; /* Root page of the open btree cursor */ + i16 nField; /* Number of fields in the header */ + u16 nHdrParsed; /* Number of header fields parsed so far */ + i64 movetoTarget; /* Argument to the deferred sqlite3BtreeMoveto() */ + u32 *aOffset; /* Pointer to aType[nField] */ + const u8 *aRow; /* Data for the current row, if all on one page */ + u32 payloadSize; /* Total number of bytes in the record */ + u32 szRow; /* Byte available in aRow */ +#ifdef SQLITE_ENABLE_COLUMN_USED_MASK + u64 maskUsed; /* Mask of columns used by this cursor */ +#endif + + /* 2*nField extra array elements allocated for aType[], beyond the one + ** static element declared in the structure. nField total array slots for + ** aType[] and nField+1 array slots for aOffset[] */ + u32 aType[1]; /* Type values record decode. MUST BE LAST */ +}; + +/* Return true if P is a null-only cursor +*/ +#define IsNullCursor(P) \ + ((P)->eCurType==CURTYPE_PSEUDO && (P)->nullRow && (P)->seekResult==0) + + +/* +** A value for VdbeCursor.cacheStatus that means the cache is always invalid. +*/ +#define CACHE_STALE 0 + +/* +** When a sub-program is executed (OP_Program), a structure of this type +** is allocated to store the current value of the program counter, as +** well as the current memory cell array and various other frame specific +** values stored in the Vdbe struct. When the sub-program is finished, +** these values are copied back to the Vdbe from the VdbeFrame structure, +** restoring the state of the VM to as it was before the sub-program +** began executing. +** +** The memory for a VdbeFrame object is allocated and managed by a memory +** cell in the parent (calling) frame. When the memory cell is deleted or +** overwritten, the VdbeFrame object is not freed immediately. Instead, it +** is linked into the Vdbe.pDelFrame list. The contents of the Vdbe.pDelFrame +** list is deleted when the VM is reset in VdbeHalt(). The reason for doing +** this instead of deleting the VdbeFrame immediately is to avoid recursive +** calls to sqlite3VdbeMemRelease() when the memory cells belonging to the +** child frame are released. +** +** The currently executing frame is stored in Vdbe.pFrame. Vdbe.pFrame is +** set to NULL if the currently executing frame is the main program. +*/ +typedef struct VdbeFrame VdbeFrame; +struct VdbeFrame { + Vdbe *v; /* VM this frame belongs to */ + VdbeFrame *pParent; /* Parent of this frame, or NULL if parent is main */ + Op *aOp; /* Program instructions for parent frame */ + Mem *aMem; /* Array of memory cells for parent frame */ + VdbeCursor **apCsr; /* Array of Vdbe cursors for parent frame */ + u8 *aOnce; /* Bitmask used by OP_Once */ + void *token; /* Copy of SubProgram.token */ + i64 lastRowid; /* Last insert rowid (sqlite3.lastRowid) */ + AuxData *pAuxData; /* Linked list of auxdata allocations */ +#if SQLITE_DEBUG + u32 iFrameMagic; /* magic number for sanity checking */ +#endif + int nCursor; /* Number of entries in apCsr */ + int pc; /* Program Counter in parent (calling) frame */ + int nOp; /* Size of aOp array */ + int nMem; /* Number of entries in aMem */ + int nChildMem; /* Number of memory cells for child frame */ + int nChildCsr; /* Number of cursors for child frame */ + i64 nChange; /* Statement changes (Vdbe.nChange) */ + i64 nDbChange; /* Value of db->nChange */ +}; + +/* Magic number for sanity checking on VdbeFrame objects */ +#define SQLITE_FRAME_MAGIC 0x879fb71e + +/* +** Return a pointer to the array of registers allocated for use +** by a VdbeFrame. +*/ +#define VdbeFrameMem(p) ((Mem *)&((u8 *)p)[ROUND8(sizeof(VdbeFrame))]) + +/* +** Internally, the vdbe manipulates nearly all SQL values as Mem +** structures. Each Mem struct may cache multiple representations (string, +** integer etc.) of the same value. +*/ +struct sqlite3_value { + union MemValue { + double r; /* Real value used when MEM_Real is set in flags */ + i64 i; /* Integer value used when MEM_Int is set in flags */ + int nZero; /* Extra zero bytes when MEM_Zero and MEM_Blob set */ + const char *zPType; /* Pointer type when MEM_Term|MEM_Subtype|MEM_Null */ + FuncDef *pDef; /* Used only when flags==MEM_Agg */ + } u; + char *z; /* String or BLOB value */ + int n; /* Number of characters in string value, excluding '\0' */ + u16 flags; /* Some combination of MEM_Null, MEM_Str, MEM_Dyn, etc. */ + u8 enc; /* SQLITE_UTF8, SQLITE_UTF16BE, SQLITE_UTF16LE */ + u8 eSubtype; /* Subtype for this value */ + /* ShallowCopy only needs to copy the information above */ + sqlite3 *db; /* The associated database connection */ + int szMalloc; /* Size of the zMalloc allocation */ + u32 uTemp; /* Transient storage for serial_type in OP_MakeRecord */ + char *zMalloc; /* Space to hold MEM_Str or MEM_Blob if szMalloc>0 */ + void (*xDel)(void*);/* Destructor for Mem.z - only valid if MEM_Dyn */ +#ifdef SQLITE_DEBUG + Mem *pScopyFrom; /* This Mem is a shallow copy of pScopyFrom */ + u16 mScopyFlags; /* flags value immediately after the shallow copy */ +#endif +}; + +/* +** Size of struct Mem not including the Mem.zMalloc member or anything that +** follows. +*/ +#define MEMCELLSIZE offsetof(Mem,db) + +/* One or more of the following flags are set to indicate the +** representations of the value stored in the Mem struct. +** +** * MEM_Null An SQL NULL value +** +** * MEM_Null|MEM_Zero An SQL NULL with the virtual table +** UPDATE no-change flag set +** +** * MEM_Null|MEM_Term| An SQL NULL, but also contains a +** MEM_Subtype pointer accessible using +** sqlite3_value_pointer(). +** +** * MEM_Null|MEM_Cleared Special SQL NULL that compares non-equal +** to other NULLs even using the IS operator. +** +** * MEM_Str A string, stored in Mem.z with +** length Mem.n. Zero-terminated if +** MEM_Term is set. This flag is +** incompatible with MEM_Blob and +** MEM_Null, but can appear with MEM_Int, +** MEM_Real, and MEM_IntReal. +** +** * MEM_Blob A blob, stored in Mem.z length Mem.n. +** Incompatible with MEM_Str, MEM_Null, +** MEM_Int, MEM_Real, and MEM_IntReal. +** +** * MEM_Blob|MEM_Zero A blob in Mem.z of length Mem.n plus +** MEM.u.i extra 0x00 bytes at the end. +** +** * MEM_Int Integer stored in Mem.u.i. +** +** * MEM_Real Real stored in Mem.u.r. +** +** * MEM_IntReal Real stored as an integer in Mem.u.i. +** +** If the MEM_Null flag is set, then the value is an SQL NULL value. +** For a pointer type created using sqlite3_bind_pointer() or +** sqlite3_result_pointer() the MEM_Term and MEM_Subtype flags are also set. +** +** If the MEM_Str flag is set then Mem.z points at a string representation. +** Usually this is encoded in the same unicode encoding as the main +** database (see below for exceptions). If the MEM_Term flag is also +** set, then the string is nul terminated. The MEM_Int and MEM_Real +** flags may coexist with the MEM_Str flag. +*/ +#define MEM_Undefined 0x0000 /* Value is undefined */ +#define MEM_Null 0x0001 /* Value is NULL (or a pointer) */ +#define MEM_Str 0x0002 /* Value is a string */ +#define MEM_Int 0x0004 /* Value is an integer */ +#define MEM_Real 0x0008 /* Value is a real number */ +#define MEM_Blob 0x0010 /* Value is a BLOB */ +#define MEM_IntReal 0x0020 /* MEM_Int that stringifies like MEM_Real */ +#define MEM_AffMask 0x003f /* Mask of affinity bits */ + +/* Extra bits that modify the meanings of the core datatypes above +*/ +#define MEM_FromBind 0x0040 /* Value originates from sqlite3_bind() */ + /* 0x0080 // Available */ +#define MEM_Cleared 0x0100 /* NULL set by OP_Null, not from data */ +#define MEM_Term 0x0200 /* String in Mem.z is zero terminated */ +#define MEM_Zero 0x0400 /* Mem.i contains count of 0s appended to blob */ +#define MEM_Subtype 0x0800 /* Mem.eSubtype is valid */ +#define MEM_TypeMask 0x0dbf /* Mask of type bits */ + +/* Bits that determine the storage for Mem.z for a string or blob or +** aggregate accumulator. +*/ +#define MEM_Dyn 0x1000 /* Need to call Mem.xDel() on Mem.z */ +#define MEM_Static 0x2000 /* Mem.z points to a static string */ +#define MEM_Ephem 0x4000 /* Mem.z points to an ephemeral string */ +#define MEM_Agg 0x8000 /* Mem.z points to an agg function context */ + +/* Return TRUE if Mem X contains dynamically allocated content - anything +** that needs to be deallocated to avoid a leak. +*/ +#define VdbeMemDynamic(X) \ + (((X)->flags&(MEM_Agg|MEM_Dyn))!=0) + +/* +** Clear any existing type flags from a Mem and replace them with f +*/ +#define MemSetTypeFlag(p, f) \ + ((p)->flags = ((p)->flags&~(MEM_TypeMask|MEM_Zero))|f) + +/* +** True if Mem X is a NULL-nochng type. +*/ +#define MemNullNochng(X) \ + (((X)->flags&MEM_TypeMask)==(MEM_Null|MEM_Zero) \ + && (X)->n==0 && (X)->u.nZero==0) + +/* +** Return true if a memory cell has been initialized and is valid. +** is for use inside assert() statements only. +** +** A Memory cell is initialized if at least one of the +** MEM_Null, MEM_Str, MEM_Int, MEM_Real, MEM_Blob, or MEM_IntReal bits +** is set. It is "undefined" if all those bits are zero. +*/ +#ifdef SQLITE_DEBUG +#define memIsValid(M) ((M)->flags & MEM_AffMask)!=0 +#endif + +/* +** Each auxiliary data pointer stored by a user defined function +** implementation calling sqlite3_set_auxdata() is stored in an instance +** of this structure. All such structures associated with a single VM +** are stored in a linked list headed at Vdbe.pAuxData. All are destroyed +** when the VM is halted (if not before). +*/ +struct AuxData { + int iAuxOp; /* Instruction number of OP_Function opcode */ + int iAuxArg; /* Index of function argument. */ + void *pAux; /* Aux data pointer */ + void (*xDeleteAux)(void*); /* Destructor for the aux data */ + AuxData *pNextAux; /* Next element in list */ +}; + +/* +** The "context" argument for an installable function. A pointer to an +** instance of this structure is the first argument to the routines used +** implement the SQL functions. +** +** There is a typedef for this structure in sqlite.h. So all routines, +** even the public interface to SQLite, can use a pointer to this structure. +** But this file is the only place where the internal details of this +** structure are known. +** +** This structure is defined inside of vdbeInt.h because it uses substructures +** (Mem) which are only defined there. +*/ +struct sqlite3_context { + Mem *pOut; /* The return value is stored here */ + FuncDef *pFunc; /* Pointer to function information */ + Mem *pMem; /* Memory cell used to store aggregate context */ + Vdbe *pVdbe; /* The VM that owns this context */ + int iOp; /* Instruction number of OP_Function */ + int isError; /* Error code returned by the function. */ + u8 enc; /* Encoding to use for results */ + u8 skipFlag; /* Skip accumulator loading if true */ + u8 argc; /* Number of arguments */ + sqlite3_value *argv[1]; /* Argument set */ +}; + +/* A bitfield type for use inside of structures. Always follow with :N where +** N is the number of bits. +*/ +typedef unsigned bft; /* Bit Field Type */ + +/* The ScanStatus object holds a single value for the +** sqlite3_stmt_scanstatus() interface. +** +** aAddrRange[]: +** This array is used by ScanStatus elements associated with EQP +** notes that make an SQLITE_SCANSTAT_NCYCLE value available. It is +** an array of up to 3 ranges of VM addresses for which the Vdbe.anCycle[] +** values should be summed to calculate the NCYCLE value. Each pair of +** integer addresses is a start and end address (both inclusive) for a range +** instructions. A start value of 0 indicates an empty range. +*/ +typedef struct ScanStatus ScanStatus; +struct ScanStatus { + int addrExplain; /* OP_Explain for loop */ + int aAddrRange[6]; + int addrLoop; /* Address of "loops" counter */ + int addrVisit; /* Address of "rows visited" counter */ + int iSelectID; /* The "Select-ID" for this loop */ + LogEst nEst; /* Estimated output rows per loop */ + char *zName; /* Name of table or index */ +}; + +/* The DblquoteStr object holds the text of a double-quoted +** string for a prepared statement. A linked list of these objects +** is constructed during statement parsing and is held on Vdbe.pDblStr. +** When computing a normalized SQL statement for an SQL statement, that +** list is consulted for each double-quoted identifier to see if the +** identifier should really be a string literal. +*/ +typedef struct DblquoteStr DblquoteStr; +struct DblquoteStr { + DblquoteStr *pNextStr; /* Next string literal in the list */ + char z[8]; /* Dequoted value for the string */ +}; + +/* +** An instance of the virtual machine. This structure contains the complete +** state of the virtual machine. +** +** The "sqlite3_stmt" structure pointer that is returned by sqlite3_prepare() +** is really a pointer to an instance of this structure. +*/ +struct Vdbe { + sqlite3 *db; /* The database connection that owns this statement */ + Vdbe **ppVPrev,*pVNext; /* Linked list of VDBEs with the same Vdbe.db */ + Parse *pParse; /* Parsing context used to create this Vdbe */ + ynVar nVar; /* Number of entries in aVar[] */ + int nMem; /* Number of memory locations currently allocated */ + int nCursor; /* Number of slots in apCsr[] */ + u32 cacheCtr; /* VdbeCursor row cache generation counter */ + int pc; /* The program counter */ + int rc; /* Value to return */ + i64 nChange; /* Number of db changes made since last reset */ + int iStatement; /* Statement number (or 0 if has no opened stmt) */ + i64 iCurrentTime; /* Value of julianday('now') for this statement */ + i64 nFkConstraint; /* Number of imm. FK constraints this VM */ + i64 nStmtDefCons; /* Number of def. constraints when stmt started */ + i64 nStmtDefImmCons; /* Number of def. imm constraints when stmt started */ + Mem *aMem; /* The memory locations */ + Mem **apArg; /* Arguments to currently executing user function */ + VdbeCursor **apCsr; /* One element of this array for each open cursor */ + Mem *aVar; /* Values for the OP_Variable opcode. */ + + /* When allocating a new Vdbe object, all of the fields below should be + ** initialized to zero or NULL */ + + Op *aOp; /* Space to hold the virtual machine's program */ + int nOp; /* Number of instructions in the program */ + int nOpAlloc; /* Slots allocated for aOp[] */ + Mem *aColName; /* Column names to return */ + Mem *pResultRow; /* Current output row */ + char *zErrMsg; /* Error message written here */ + VList *pVList; /* Name of variables */ +#ifndef SQLITE_OMIT_TRACE + i64 startTime; /* Time when query started - used for profiling */ +#endif +#ifdef SQLITE_DEBUG + int rcApp; /* errcode set by sqlite3_result_error_code() */ + u32 nWrite; /* Number of write operations that have occurred */ +#endif + u16 nResColumn; /* Number of columns in one row of the result set */ + u8 errorAction; /* Recovery action to do in case of an error */ + u8 minWriteFileFormat; /* Minimum file format for writable database files */ + u8 prepFlags; /* SQLITE_PREPARE_* flags */ + u8 eVdbeState; /* On of the VDBE_*_STATE values */ + bft expired:2; /* 1: recompile VM immediately 2: when convenient */ + bft explain:2; /* True if EXPLAIN present on SQL command */ + bft changeCntOn:1; /* True to update the change-counter */ + bft usesStmtJournal:1; /* True if uses a statement journal */ + bft readOnly:1; /* True for statements that do not write */ + bft bIsReader:1; /* True for statements that read */ + yDbMask btreeMask; /* Bitmask of db->aDb[] entries referenced */ + yDbMask lockMask; /* Subset of btreeMask that requires a lock */ + u32 aCounter[9]; /* Counters used by sqlite3_stmt_status() */ + char *zSql; /* Text of the SQL statement that generated this */ +#ifdef SQLITE_ENABLE_NORMALIZE + char *zNormSql; /* Normalization of the associated SQL statement */ + DblquoteStr *pDblStr; /* List of double-quoted string literals */ +#endif + void *pFree; /* Free this when deleting the vdbe */ + VdbeFrame *pFrame; /* Parent frame */ + VdbeFrame *pDelFrame; /* List of frame objects to free on VM reset */ + int nFrame; /* Number of frames in pFrame list */ + u32 expmask; /* Binding to these vars invalidates VM */ + SubProgram *pProgram; /* Linked list of all sub-programs used by VM */ + AuxData *pAuxData; /* Linked list of auxdata allocations */ +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + int nScan; /* Entries in aScan[] */ + ScanStatus *aScan; /* Scan definitions for sqlite3_stmt_scanstatus() */ +#endif +}; + +/* +** The following are allowed values for Vdbe.eVdbeState +*/ +#define VDBE_INIT_STATE 0 /* Prepared statement under construction */ +#define VDBE_READY_STATE 1 /* Ready to run but not yet started */ +#define VDBE_RUN_STATE 2 /* Run in progress */ +#define VDBE_HALT_STATE 3 /* Finished. Need reset() or finalize() */ + +/* +** Structure used to store the context required by the +** sqlite3_preupdate_*() API functions. +*/ +struct PreUpdate { + Vdbe *v; + VdbeCursor *pCsr; /* Cursor to read old values from */ + int op; /* One of SQLITE_INSERT, UPDATE, DELETE */ + u8 *aRecord; /* old.* database record */ + KeyInfo keyinfo; + UnpackedRecord *pUnpacked; /* Unpacked version of aRecord[] */ + UnpackedRecord *pNewUnpacked; /* Unpacked version of new.* record */ + int iNewReg; /* Register for new.* values */ + int iBlobWrite; /* Value returned by preupdate_blobwrite() */ + i64 iKey1; /* First key value passed to hook */ + i64 iKey2; /* Second key value passed to hook */ + Mem *aNew; /* Array of new.* values */ + Table *pTab; /* Schema object being upated */ + Index *pPk; /* PK index if pTab is WITHOUT ROWID */ +}; + +/* +** An instance of this object is used to pass an vector of values into +** OP_VFilter, the xFilter method of a virtual table. The vector is the +** set of values on the right-hand side of an IN constraint. +** +** The value as passed into xFilter is an sqlite3_value with a "pointer" +** type, such as is generated by sqlite3_result_pointer() and read by +** sqlite3_value_pointer. Such values have MEM_Term|MEM_Subtype|MEM_Null +** and a subtype of 'p'. The sqlite3_vtab_in_first() and _next() interfaces +** know how to use this object to step through all the values in the +** right operand of the IN constraint. +*/ +typedef struct ValueList ValueList; +struct ValueList { + BtCursor *pCsr; /* An ephemeral table holding all values */ + sqlite3_value *pOut; /* Register to hold each decoded output value */ +}; + +/* Size of content associated with serial types that fit into a +** single-byte varint. +*/ +#ifndef SQLITE_AMALGAMATION +SQLITE_PRIVATE const u8 sqlite3SmallTypeSizes[]; +#endif + +/* +** Function prototypes +*/ +SQLITE_PRIVATE void sqlite3VdbeError(Vdbe*, const char *, ...); +SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *, VdbeCursor*); +SQLITE_PRIVATE void sqlite3VdbeFreeCursorNN(Vdbe*,VdbeCursor*); +void sqliteVdbePopStack(Vdbe*,int); +SQLITE_PRIVATE int SQLITE_NOINLINE sqlite3VdbeHandleMovedCursor(VdbeCursor *p); +SQLITE_PRIVATE int SQLITE_NOINLINE sqlite3VdbeFinishMoveto(VdbeCursor*); +SQLITE_PRIVATE int sqlite3VdbeCursorRestore(VdbeCursor*); +SQLITE_PRIVATE u32 sqlite3VdbeSerialTypeLen(u32); +SQLITE_PRIVATE u8 sqlite3VdbeOneByteSerialTypeLen(u8); +#ifdef SQLITE_MIXED_ENDIAN_64BIT_FLOAT +SQLITE_PRIVATE u64 sqlite3FloatSwap(u64 in); +# define swapMixedEndianFloat(X) X = sqlite3FloatSwap(X) +#else +# define swapMixedEndianFloat(X) +#endif +SQLITE_PRIVATE void sqlite3VdbeSerialGet(const unsigned char*, u32, Mem*); +SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData(sqlite3*, AuxData**, int, int); + +int sqlite2BtreeKeyCompare(BtCursor *, const void *, int, int, int *); +SQLITE_PRIVATE int sqlite3VdbeIdxKeyCompare(sqlite3*,VdbeCursor*,UnpackedRecord*,int*); +SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3*, BtCursor*, i64*); +SQLITE_PRIVATE int sqlite3VdbeExec(Vdbe*); +#if !defined(SQLITE_OMIT_EXPLAIN) || defined(SQLITE_ENABLE_BYTECODE_VTAB) +SQLITE_PRIVATE int sqlite3VdbeNextOpcode(Vdbe*,Mem*,int,int*,int*,Op**); +SQLITE_PRIVATE char *sqlite3VdbeDisplayP4(sqlite3*,Op*); +#endif +#if defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) +SQLITE_PRIVATE char *sqlite3VdbeDisplayComment(sqlite3*,const Op*,const char*); +#endif +#if !defined(SQLITE_OMIT_EXPLAIN) +SQLITE_PRIVATE int sqlite3VdbeList(Vdbe*); +#endif +SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe*); +SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *, int); +SQLITE_PRIVATE int sqlite3VdbeMemTooBig(Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem*, const Mem*); +SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem*, const Mem*, int); +SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem*, Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemSetStr(Mem*, const char*, i64, u8, void(*)(void*)); +SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem*, i64); +#ifdef SQLITE_OMIT_FLOATING_POINT +# define sqlite3VdbeMemSetDouble sqlite3VdbeMemSetInt64 +#else +SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem*, double); +#endif +SQLITE_PRIVATE void sqlite3VdbeMemSetPointer(Mem*, void*, const char*, void(*)(void*)); +SQLITE_PRIVATE void sqlite3VdbeMemInit(Mem*,sqlite3*,u16); +SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem*); +#ifndef SQLITE_OMIT_INCRBLOB +SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem*,int); +#else +SQLITE_PRIVATE int sqlite3VdbeMemSetZeroBlob(Mem*,int); +#endif +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3VdbeMemIsRowSet(const Mem*); +#endif +SQLITE_PRIVATE int sqlite3VdbeMemSetRowSet(Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem*, u8, u8); +SQLITE_PRIVATE int sqlite3IntFloatCompare(i64,double); +SQLITE_PRIVATE i64 sqlite3VdbeIntValue(const Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem*); +SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem*); +SQLITE_PRIVATE int sqlite3VdbeBooleanValue(Mem*, int ifNull); +SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemRealify(Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemCast(Mem*,u8,u8); +SQLITE_PRIVATE int sqlite3VdbeMemFromBtree(BtCursor*,u32,u32,Mem*); +SQLITE_PRIVATE int sqlite3VdbeMemFromBtreeZeroOffset(BtCursor*,u32,Mem*); +SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p); +SQLITE_PRIVATE void sqlite3VdbeMemReleaseMalloc(Mem*p); +SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem*, FuncDef*); +#ifndef SQLITE_OMIT_WINDOWFUNC +SQLITE_PRIVATE int sqlite3VdbeMemAggValue(Mem*, Mem*, FuncDef*); +#endif +#if !defined(SQLITE_OMIT_EXPLAIN) || defined(SQLITE_ENABLE_BYTECODE_VTAB) +SQLITE_PRIVATE const char *sqlite3OpcodeName(int); +#endif +SQLITE_PRIVATE int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve); +SQLITE_PRIVATE int sqlite3VdbeMemClearAndResize(Mem *pMem, int n); +SQLITE_PRIVATE int sqlite3VdbeCloseStatement(Vdbe *, int); +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3VdbeFrameIsValid(VdbeFrame*); +#endif +SQLITE_PRIVATE void sqlite3VdbeFrameMemDel(void*); /* Destructor on Mem */ +SQLITE_PRIVATE void sqlite3VdbeFrameDelete(VdbeFrame*); /* Actually deletes the Frame */ +SQLITE_PRIVATE int sqlite3VdbeFrameRestore(VdbeFrame *); +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK +SQLITE_PRIVATE void sqlite3VdbePreUpdateHook( + Vdbe*,VdbeCursor*,int,const char*,Table*,i64,int,int); +#endif +SQLITE_PRIVATE int sqlite3VdbeTransferError(Vdbe *p); + +SQLITE_PRIVATE int sqlite3VdbeSorterInit(sqlite3 *, int, VdbeCursor *); +SQLITE_PRIVATE void sqlite3VdbeSorterReset(sqlite3 *, VdbeSorter *); +SQLITE_PRIVATE void sqlite3VdbeSorterClose(sqlite3 *, VdbeCursor *); +SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(const VdbeCursor *, Mem *); +SQLITE_PRIVATE int sqlite3VdbeSorterNext(sqlite3 *, const VdbeCursor *); +SQLITE_PRIVATE int sqlite3VdbeSorterRewind(const VdbeCursor *, int *); +SQLITE_PRIVATE int sqlite3VdbeSorterWrite(const VdbeCursor *, Mem *); +SQLITE_PRIVATE int sqlite3VdbeSorterCompare(const VdbeCursor *, Mem *, int, int *); + +SQLITE_PRIVATE void sqlite3VdbeValueListFree(void*); + +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE void sqlite3VdbeIncrWriteCounter(Vdbe*, VdbeCursor*); +SQLITE_PRIVATE void sqlite3VdbeAssertAbortable(Vdbe*); +#else +# define sqlite3VdbeIncrWriteCounter(V,C) +# define sqlite3VdbeAssertAbortable(V) +#endif + +#if !defined(SQLITE_OMIT_SHARED_CACHE) +SQLITE_PRIVATE void sqlite3VdbeEnter(Vdbe*); +#else +# define sqlite3VdbeEnter(X) +#endif + +#if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0 +SQLITE_PRIVATE void sqlite3VdbeLeave(Vdbe*); +#else +# define sqlite3VdbeLeave(X) +#endif + +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE void sqlite3VdbeMemAboutToChange(Vdbe*,Mem*); +SQLITE_PRIVATE int sqlite3VdbeCheckMemInvariants(Mem*); +#endif + +#ifndef SQLITE_OMIT_FOREIGN_KEY +SQLITE_PRIVATE int sqlite3VdbeCheckFk(Vdbe *, int); +#else +# define sqlite3VdbeCheckFk(p,i) 0 +#endif + +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE void sqlite3VdbePrintSql(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeMemPrettyPrint(Mem *pMem, StrAccum *pStr); +#endif +#ifndef SQLITE_OMIT_UTF16 +SQLITE_PRIVATE int sqlite3VdbeMemTranslate(Mem*, u8); +SQLITE_PRIVATE int sqlite3VdbeMemHandleBom(Mem *pMem); +#endif + +#ifndef SQLITE_OMIT_INCRBLOB +SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *); + #define ExpandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0) +#else + #define sqlite3VdbeMemExpandBlob(x) SQLITE_OK + #define ExpandBlob(P) SQLITE_OK +#endif + +#endif /* !defined(SQLITE_VDBEINT_H) */ + +/************** End of vdbeInt.h *********************************************/ +/************** Continuing where we left off in status.c *********************/ + +/* +** Variables in which to record status information. +*/ +#if SQLITE_PTRSIZE>4 +typedef sqlite3_int64 sqlite3StatValueType; +#else +typedef u32 sqlite3StatValueType; +#endif +typedef struct sqlite3StatType sqlite3StatType; +static SQLITE_WSD struct sqlite3StatType { + sqlite3StatValueType nowValue[10]; /* Current value */ + sqlite3StatValueType mxValue[10]; /* Maximum value */ +} sqlite3Stat = { {0,}, {0,} }; + +/* +** Elements of sqlite3Stat[] are protected by either the memory allocator +** mutex, or by the pcache1 mutex. The following array determines which. +*/ +static const char statMutex[] = { + 0, /* SQLITE_STATUS_MEMORY_USED */ + 1, /* SQLITE_STATUS_PAGECACHE_USED */ + 1, /* SQLITE_STATUS_PAGECACHE_OVERFLOW */ + 0, /* SQLITE_STATUS_SCRATCH_USED */ + 0, /* SQLITE_STATUS_SCRATCH_OVERFLOW */ + 0, /* SQLITE_STATUS_MALLOC_SIZE */ + 0, /* SQLITE_STATUS_PARSER_STACK */ + 1, /* SQLITE_STATUS_PAGECACHE_SIZE */ + 0, /* SQLITE_STATUS_SCRATCH_SIZE */ + 0, /* SQLITE_STATUS_MALLOC_COUNT */ +}; + + +/* The "wsdStat" macro will resolve to the status information +** state vector. If writable static data is unsupported on the target, +** we have to locate the state vector at run-time. In the more common +** case where writable static data is supported, wsdStat can refer directly +** to the "sqlite3Stat" state vector declared above. +*/ +#ifdef SQLITE_OMIT_WSD +# define wsdStatInit sqlite3StatType *x = &GLOBAL(sqlite3StatType,sqlite3Stat) +# define wsdStat x[0] +#else +# define wsdStatInit +# define wsdStat sqlite3Stat +#endif + +/* +** Return the current value of a status parameter. The caller must +** be holding the appropriate mutex. +*/ +SQLITE_PRIVATE sqlite3_int64 sqlite3StatusValue(int op){ + wsdStatInit; + assert( op>=0 && op=0 && op=0 && op=0 && opwsdStat.mxValue[op] ){ + wsdStat.mxValue[op] = wsdStat.nowValue[op]; + } +} +SQLITE_PRIVATE void sqlite3StatusDown(int op, int N){ + wsdStatInit; + assert( N>=0 ); + assert( op>=0 && op=0 && op=0 ); + newValue = (sqlite3StatValueType)X; + assert( op>=0 && op=0 && opwsdStat.mxValue[op] ){ + wsdStat.mxValue[op] = newValue; + } +} + +/* +** Query status information. +*/ +SQLITE_API int sqlite3_status64( + int op, + sqlite3_int64 *pCurrent, + sqlite3_int64 *pHighwater, + int resetFlag +){ + sqlite3_mutex *pMutex; + wsdStatInit; + if( op<0 || op>=ArraySize(wsdStat.nowValue) ){ + return SQLITE_MISUSE_BKPT; + } +#ifdef SQLITE_ENABLE_API_ARMOR + if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT; +#endif + pMutex = statMutex[op] ? sqlite3Pcache1Mutex() : sqlite3MallocMutex(); + sqlite3_mutex_enter(pMutex); + *pCurrent = wsdStat.nowValue[op]; + *pHighwater = wsdStat.mxValue[op]; + if( resetFlag ){ + wsdStat.mxValue[op] = wsdStat.nowValue[op]; + } + sqlite3_mutex_leave(pMutex); + (void)pMutex; /* Prevent warning when SQLITE_THREADSAFE=0 */ + return SQLITE_OK; +} +SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag){ + sqlite3_int64 iCur = 0, iHwtr = 0; + int rc; +#ifdef SQLITE_ENABLE_API_ARMOR + if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT; +#endif + rc = sqlite3_status64(op, &iCur, &iHwtr, resetFlag); + if( rc==0 ){ + *pCurrent = (int)iCur; + *pHighwater = (int)iHwtr; + } + return rc; +} + +/* +** Return the number of LookasideSlot elements on the linked list +*/ +static u32 countLookasideSlots(LookasideSlot *p){ + u32 cnt = 0; + while( p ){ + p = p->pNext; + cnt++; + } + return cnt; +} + +/* +** Count the number of slots of lookaside memory that are outstanding +*/ +SQLITE_PRIVATE int sqlite3LookasideUsed(sqlite3 *db, int *pHighwater){ + u32 nInit = countLookasideSlots(db->lookaside.pInit); + u32 nFree = countLookasideSlots(db->lookaside.pFree); +#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE + nInit += countLookasideSlots(db->lookaside.pSmallInit); + nFree += countLookasideSlots(db->lookaside.pSmallFree); +#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */ + if( pHighwater ) *pHighwater = db->lookaside.nSlot - nInit; + return db->lookaside.nSlot - (nInit+nFree); +} + +/* +** Query status information for a single database connection +*/ +SQLITE_API int sqlite3_db_status( + sqlite3 *db, /* The database connection whose status is desired */ + int op, /* Status verb */ + int *pCurrent, /* Write current value here */ + int *pHighwater, /* Write high-water mark here */ + int resetFlag /* Reset high-water mark if true */ +){ + int rc = SQLITE_OK; /* Return code */ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || pCurrent==0|| pHighwater==0 ){ + return SQLITE_MISUSE_BKPT; + } +#endif + sqlite3_mutex_enter(db->mutex); + switch( op ){ + case SQLITE_DBSTATUS_LOOKASIDE_USED: { + *pCurrent = sqlite3LookasideUsed(db, pHighwater); + if( resetFlag ){ + LookasideSlot *p = db->lookaside.pFree; + if( p ){ + while( p->pNext ) p = p->pNext; + p->pNext = db->lookaside.pInit; + db->lookaside.pInit = db->lookaside.pFree; + db->lookaside.pFree = 0; + } +#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE + p = db->lookaside.pSmallFree; + if( p ){ + while( p->pNext ) p = p->pNext; + p->pNext = db->lookaside.pSmallInit; + db->lookaside.pSmallInit = db->lookaside.pSmallFree; + db->lookaside.pSmallFree = 0; + } +#endif + } + break; + } + + case SQLITE_DBSTATUS_LOOKASIDE_HIT: + case SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: + case SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: { + testcase( op==SQLITE_DBSTATUS_LOOKASIDE_HIT ); + testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE ); + testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL ); + assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)>=0 ); + assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)<3 ); + *pCurrent = 0; + *pHighwater = db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT]; + if( resetFlag ){ + db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT] = 0; + } + break; + } + + /* + ** Return an approximation for the amount of memory currently used + ** by all pagers associated with the given database connection. The + ** highwater mark is meaningless and is returned as zero. + */ + case SQLITE_DBSTATUS_CACHE_USED_SHARED: + case SQLITE_DBSTATUS_CACHE_USED: { + int totalUsed = 0; + int i; + sqlite3BtreeEnterAll(db); + for(i=0; inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + Pager *pPager = sqlite3BtreePager(pBt); + int nByte = sqlite3PagerMemUsed(pPager); + if( op==SQLITE_DBSTATUS_CACHE_USED_SHARED ){ + nByte = nByte / sqlite3BtreeConnectionCount(pBt); + } + totalUsed += nByte; + } + } + sqlite3BtreeLeaveAll(db); + *pCurrent = totalUsed; + *pHighwater = 0; + break; + } + + /* + ** *pCurrent gets an accurate estimate of the amount of memory used + ** to store the schema for all databases (main, temp, and any ATTACHed + ** databases. *pHighwater is set to zero. + */ + case SQLITE_DBSTATUS_SCHEMA_USED: { + int i; /* Used to iterate through schemas */ + int nByte = 0; /* Used to accumulate return value */ + + sqlite3BtreeEnterAll(db); + db->pnBytesFreed = &nByte; + assert( db->lookaside.pEnd==db->lookaside.pTrueEnd ); + db->lookaside.pEnd = db->lookaside.pStart; + for(i=0; inDb; i++){ + Schema *pSchema = db->aDb[i].pSchema; + if( ALWAYS(pSchema!=0) ){ + HashElem *p; + + nByte += sqlite3GlobalConfig.m.xRoundup(sizeof(HashElem)) * ( + pSchema->tblHash.count + + pSchema->trigHash.count + + pSchema->idxHash.count + + pSchema->fkeyHash.count + ); + nByte += sqlite3_msize(pSchema->tblHash.ht); + nByte += sqlite3_msize(pSchema->trigHash.ht); + nByte += sqlite3_msize(pSchema->idxHash.ht); + nByte += sqlite3_msize(pSchema->fkeyHash.ht); + + for(p=sqliteHashFirst(&pSchema->trigHash); p; p=sqliteHashNext(p)){ + sqlite3DeleteTrigger(db, (Trigger*)sqliteHashData(p)); + } + for(p=sqliteHashFirst(&pSchema->tblHash); p; p=sqliteHashNext(p)){ + sqlite3DeleteTable(db, (Table *)sqliteHashData(p)); + } + } + } + db->pnBytesFreed = 0; + db->lookaside.pEnd = db->lookaside.pTrueEnd; + sqlite3BtreeLeaveAll(db); + + *pHighwater = 0; + *pCurrent = nByte; + break; + } + + /* + ** *pCurrent gets an accurate estimate of the amount of memory used + ** to store all prepared statements. + ** *pHighwater is set to zero. + */ + case SQLITE_DBSTATUS_STMT_USED: { + struct Vdbe *pVdbe; /* Used to iterate through VMs */ + int nByte = 0; /* Used to accumulate return value */ + + db->pnBytesFreed = &nByte; + assert( db->lookaside.pEnd==db->lookaside.pTrueEnd ); + db->lookaside.pEnd = db->lookaside.pStart; + for(pVdbe=db->pVdbe; pVdbe; pVdbe=pVdbe->pVNext){ + sqlite3VdbeDelete(pVdbe); + } + db->lookaside.pEnd = db->lookaside.pTrueEnd; + db->pnBytesFreed = 0; + + *pHighwater = 0; /* IMP: R-64479-57858 */ + *pCurrent = nByte; + + break; + } + + /* + ** Set *pCurrent to the total cache hits or misses encountered by all + ** pagers the database handle is connected to. *pHighwater is always set + ** to zero. + */ + case SQLITE_DBSTATUS_CACHE_SPILL: + op = SQLITE_DBSTATUS_CACHE_WRITE+1; + /* no break */ deliberate_fall_through + case SQLITE_DBSTATUS_CACHE_HIT: + case SQLITE_DBSTATUS_CACHE_MISS: + case SQLITE_DBSTATUS_CACHE_WRITE:{ + int i; + int nRet = 0; + assert( SQLITE_DBSTATUS_CACHE_MISS==SQLITE_DBSTATUS_CACHE_HIT+1 ); + assert( SQLITE_DBSTATUS_CACHE_WRITE==SQLITE_DBSTATUS_CACHE_HIT+2 ); + + for(i=0; inDb; i++){ + if( db->aDb[i].pBt ){ + Pager *pPager = sqlite3BtreePager(db->aDb[i].pBt); + sqlite3PagerCacheStat(pPager, op, resetFlag, &nRet); + } + } + *pHighwater = 0; /* IMP: R-42420-56072 */ + /* IMP: R-54100-20147 */ + /* IMP: R-29431-39229 */ + *pCurrent = nRet; + break; + } + + /* Set *pCurrent to non-zero if there are unresolved deferred foreign + ** key constraints. Set *pCurrent to zero if all foreign key constraints + ** have been satisfied. The *pHighwater is always set to zero. + */ + case SQLITE_DBSTATUS_DEFERRED_FKS: { + *pHighwater = 0; /* IMP: R-11967-56545 */ + *pCurrent = db->nDeferredImmCons>0 || db->nDeferredCons>0; + break; + } + + default: { + rc = SQLITE_ERROR; + } + } + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/************** End of status.c **********************************************/ +/************** Begin file date.c ********************************************/ +/* +** 2003 October 31 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement date and time +** functions for SQLite. +** +** There is only one exported symbol in this file - the function +** sqlite3RegisterDateTimeFunctions() found at the bottom of the file. +** All other code has file scope. +** +** SQLite processes all times and dates as julian day numbers. The +** dates and times are stored as the number of days since noon +** in Greenwich on November 24, 4714 B.C. according to the Gregorian +** calendar system. +** +** 1970-01-01 00:00:00 is JD 2440587.5 +** 2000-01-01 00:00:00 is JD 2451544.5 +** +** This implementation requires years to be expressed as a 4-digit number +** which means that only dates between 0000-01-01 and 9999-12-31 can +** be represented, even though julian day numbers allow a much wider +** range of dates. +** +** The Gregorian calendar system is used for all dates and times, +** even those that predate the Gregorian calendar. Historians usually +** use the julian calendar for dates prior to 1582-10-15 and for some +** dates afterwards, depending on locale. Beware of this difference. +** +** The conversion algorithms are implemented based on descriptions +** in the following text: +** +** Jean Meeus +** Astronomical Algorithms, 2nd Edition, 1998 +** ISBN 0-943396-61-1 +** Willmann-Bell, Inc +** Richmond, Virginia (USA) +*/ +/* #include "sqliteInt.h" */ +/* #include */ +/* #include */ +#include + +#ifndef SQLITE_OMIT_DATETIME_FUNCS + +/* +** The MSVC CRT on Windows CE may not have a localtime() function. +** So declare a substitute. The substitute function itself is +** defined in "os_win.c". +*/ +#if !defined(SQLITE_OMIT_LOCALTIME) && defined(_WIN32_WCE) && \ + (!defined(SQLITE_MSVC_LOCALTIME_API) || !SQLITE_MSVC_LOCALTIME_API) +struct tm *__cdecl localtime(const time_t *); +#endif + +/* +** A structure for holding a single date and time. +*/ +typedef struct DateTime DateTime; +struct DateTime { + sqlite3_int64 iJD; /* The julian day number times 86400000 */ + int Y, M, D; /* Year, month, and day */ + int h, m; /* Hour and minutes */ + int tz; /* Timezone offset in minutes */ + double s; /* Seconds */ + char validJD; /* True (1) if iJD is valid */ + char rawS; /* Raw numeric value stored in s */ + char validYMD; /* True (1) if Y,M,D are valid */ + char validHMS; /* True (1) if h,m,s are valid */ + char validTZ; /* True (1) if tz is valid */ + char tzSet; /* Timezone was set explicitly */ + char isError; /* An overflow has occurred */ + char useSubsec; /* Display subsecond precision */ +}; + + +/* +** Convert zDate into one or more integers according to the conversion +** specifier zFormat. +** +** zFormat[] contains 4 characters for each integer converted, except for +** the last integer which is specified by three characters. The meaning +** of a four-character format specifiers ABCD is: +** +** A: number of digits to convert. Always "2" or "4". +** B: minimum value. Always "0" or "1". +** C: maximum value, decoded as: +** a: 12 +** b: 14 +** c: 24 +** d: 31 +** e: 59 +** f: 9999 +** D: the separator character, or \000 to indicate this is the +** last number to convert. +** +** Example: To translate an ISO-8601 date YYYY-MM-DD, the format would +** be "40f-21a-20c". The "40f-" indicates the 4-digit year followed by "-". +** The "21a-" indicates the 2-digit month followed by "-". The "20c" indicates +** the 2-digit day which is the last integer in the set. +** +** The function returns the number of successful conversions. +*/ +static int getDigits(const char *zDate, const char *zFormat, ...){ + /* The aMx[] array translates the 3rd character of each format + ** spec into a max size: a b c d e f */ + static const u16 aMx[] = { 12, 14, 24, 31, 59, 9999 }; + va_list ap; + int cnt = 0; + char nextC; + va_start(ap, zFormat); + do{ + char N = zFormat[0] - '0'; + char min = zFormat[1] - '0'; + int val = 0; + u16 max; + + assert( zFormat[2]>='a' && zFormat[2]<='f' ); + max = aMx[zFormat[2] - 'a']; + nextC = zFormat[3]; + val = 0; + while( N-- ){ + if( !sqlite3Isdigit(*zDate) ){ + goto end_getDigits; + } + val = val*10 + *zDate - '0'; + zDate++; + } + if( val<(int)min || val>(int)max || (nextC!=0 && nextC!=*zDate) ){ + goto end_getDigits; + } + *va_arg(ap,int*) = val; + zDate++; + cnt++; + zFormat += 4; + }while( nextC ); +end_getDigits: + va_end(ap); + return cnt; +} + +/* +** Parse a timezone extension on the end of a date-time. +** The extension is of the form: +** +** (+/-)HH:MM +** +** Or the "zulu" notation: +** +** Z +** +** If the parse is successful, write the number of minutes +** of change in p->tz and return 0. If a parser error occurs, +** return non-zero. +** +** A missing specifier is not considered an error. +*/ +static int parseTimezone(const char *zDate, DateTime *p){ + int sgn = 0; + int nHr, nMn; + int c; + while( sqlite3Isspace(*zDate) ){ zDate++; } + p->tz = 0; + c = *zDate; + if( c=='-' ){ + sgn = -1; + }else if( c=='+' ){ + sgn = +1; + }else if( c=='Z' || c=='z' ){ + zDate++; + goto zulu_time; + }else{ + return c!=0; + } + zDate++; + if( getDigits(zDate, "20b:20e", &nHr, &nMn)!=2 ){ + return 1; + } + zDate += 5; + p->tz = sgn*(nMn + nHr*60); +zulu_time: + while( sqlite3Isspace(*zDate) ){ zDate++; } + p->tzSet = 1; + return *zDate!=0; +} + +/* +** Parse times of the form HH:MM or HH:MM:SS or HH:MM:SS.FFFF. +** The HH, MM, and SS must each be exactly 2 digits. The +** fractional seconds FFFF can be one or more digits. +** +** Return 1 if there is a parsing error and 0 on success. +*/ +static int parseHhMmSs(const char *zDate, DateTime *p){ + int h, m, s; + double ms = 0.0; + if( getDigits(zDate, "20c:20e", &h, &m)!=2 ){ + return 1; + } + zDate += 5; + if( *zDate==':' ){ + zDate++; + if( getDigits(zDate, "20e", &s)!=1 ){ + return 1; + } + zDate += 2; + if( *zDate=='.' && sqlite3Isdigit(zDate[1]) ){ + double rScale = 1.0; + zDate++; + while( sqlite3Isdigit(*zDate) ){ + ms = ms*10.0 + *zDate - '0'; + rScale *= 10.0; + zDate++; + } + ms /= rScale; + } + }else{ + s = 0; + } + p->validJD = 0; + p->rawS = 0; + p->validHMS = 1; + p->h = h; + p->m = m; + p->s = s + ms; + if( parseTimezone(zDate, p) ) return 1; + p->validTZ = (p->tz!=0)?1:0; + return 0; +} + +/* +** Put the DateTime object into its error state. +*/ +static void datetimeError(DateTime *p){ + memset(p, 0, sizeof(*p)); + p->isError = 1; +} + +/* +** Convert from YYYY-MM-DD HH:MM:SS to julian day. We always assume +** that the YYYY-MM-DD is according to the Gregorian calendar. +** +** Reference: Meeus page 61 +*/ +static void computeJD(DateTime *p){ + int Y, M, D, A, B, X1, X2; + + if( p->validJD ) return; + if( p->validYMD ){ + Y = p->Y; + M = p->M; + D = p->D; + }else{ + Y = 2000; /* If no YMD specified, assume 2000-Jan-01 */ + M = 1; + D = 1; + } + if( Y<-4713 || Y>9999 || p->rawS ){ + datetimeError(p); + return; + } + if( M<=2 ){ + Y--; + M += 12; + } + A = Y/100; + B = 2 - A + (A/4); + X1 = 36525*(Y+4716)/100; + X2 = 306001*(M+1)/10000; + p->iJD = (sqlite3_int64)((X1 + X2 + D + B - 1524.5 ) * 86400000); + p->validJD = 1; + if( p->validHMS ){ + p->iJD += p->h*3600000 + p->m*60000 + (sqlite3_int64)(p->s*1000 + 0.5); + if( p->validTZ ){ + p->iJD -= p->tz*60000; + p->validYMD = 0; + p->validHMS = 0; + p->validTZ = 0; + } + } +} + +/* +** Parse dates of the form +** +** YYYY-MM-DD HH:MM:SS.FFF +** YYYY-MM-DD HH:MM:SS +** YYYY-MM-DD HH:MM +** YYYY-MM-DD +** +** Write the result into the DateTime structure and return 0 +** on success and 1 if the input string is not a well-formed +** date. +*/ +static int parseYyyyMmDd(const char *zDate, DateTime *p){ + int Y, M, D, neg; + + if( zDate[0]=='-' ){ + zDate++; + neg = 1; + }else{ + neg = 0; + } + if( getDigits(zDate, "40f-21a-21d", &Y, &M, &D)!=3 ){ + return 1; + } + zDate += 10; + while( sqlite3Isspace(*zDate) || 'T'==*(u8*)zDate ){ zDate++; } + if( parseHhMmSs(zDate, p)==0 ){ + /* We got the time */ + }else if( *zDate==0 ){ + p->validHMS = 0; + }else{ + return 1; + } + p->validJD = 0; + p->validYMD = 1; + p->Y = neg ? -Y : Y; + p->M = M; + p->D = D; + if( p->validTZ ){ + computeJD(p); + } + return 0; +} + +/* +** Set the time to the current time reported by the VFS. +** +** Return the number of errors. +*/ +static int setDateTimeToCurrent(sqlite3_context *context, DateTime *p){ + p->iJD = sqlite3StmtCurrentTime(context); + if( p->iJD>0 ){ + p->validJD = 1; + return 0; + }else{ + return 1; + } +} + +/* +** Input "r" is a numeric quantity which might be a julian day number, +** or the number of seconds since 1970. If the value if r is within +** range of a julian day number, install it as such and set validJD. +** If the value is a valid unix timestamp, put it in p->s and set p->rawS. +*/ +static void setRawDateNumber(DateTime *p, double r){ + p->s = r; + p->rawS = 1; + if( r>=0.0 && r<5373484.5 ){ + p->iJD = (sqlite3_int64)(r*86400000.0 + 0.5); + p->validJD = 1; + } +} + +/* +** Attempt to parse the given string into a julian day number. Return +** the number of errors. +** +** The following are acceptable forms for the input string: +** +** YYYY-MM-DD HH:MM:SS.FFF +/-HH:MM +** DDDD.DD +** now +** +** In the first form, the +/-HH:MM is always optional. The fractional +** seconds extension (the ".FFF") is optional. The seconds portion +** (":SS.FFF") is option. The year and date can be omitted as long +** as there is a time string. The time string can be omitted as long +** as there is a year and date. +*/ +static int parseDateOrTime( + sqlite3_context *context, + const char *zDate, + DateTime *p +){ + double r; + if( parseYyyyMmDd(zDate,p)==0 ){ + return 0; + }else if( parseHhMmSs(zDate, p)==0 ){ + return 0; + }else if( sqlite3StrICmp(zDate,"now")==0 && sqlite3NotPureFunc(context) ){ + return setDateTimeToCurrent(context, p); + }else if( sqlite3AtoF(zDate, &r, sqlite3Strlen30(zDate), SQLITE_UTF8)>0 ){ + setRawDateNumber(p, r); + return 0; + }else if( (sqlite3StrICmp(zDate,"subsec")==0 + || sqlite3StrICmp(zDate,"subsecond")==0) + && sqlite3NotPureFunc(context) ){ + p->useSubsec = 1; + return setDateTimeToCurrent(context, p); + } + return 1; +} + +/* The julian day number for 9999-12-31 23:59:59.999 is 5373484.4999999. +** Multiplying this by 86400000 gives 464269060799999 as the maximum value +** for DateTime.iJD. +** +** But some older compilers (ex: gcc 4.2.1 on older Macs) cannot deal with +** such a large integer literal, so we have to encode it. +*/ +#define INT_464269060799999 ((((i64)0x1a640)<<32)|0x1072fdff) + +/* +** Return TRUE if the given julian day number is within range. +** +** The input is the JulianDay times 86400000. +*/ +static int validJulianDay(sqlite3_int64 iJD){ + return iJD>=0 && iJD<=INT_464269060799999; +} + +/* +** Compute the Year, Month, and Day from the julian day number. +*/ +static void computeYMD(DateTime *p){ + int Z, A, B, C, D, E, X1; + if( p->validYMD ) return; + if( !p->validJD ){ + p->Y = 2000; + p->M = 1; + p->D = 1; + }else if( !validJulianDay(p->iJD) ){ + datetimeError(p); + return; + }else{ + Z = (int)((p->iJD + 43200000)/86400000); + A = (int)((Z - 1867216.25)/36524.25); + A = Z + 1 + A - (A/4); + B = A + 1524; + C = (int)((B - 122.1)/365.25); + D = (36525*(C&32767))/100; + E = (int)((B-D)/30.6001); + X1 = (int)(30.6001*E); + p->D = B - D - X1; + p->M = E<14 ? E-1 : E-13; + p->Y = p->M>2 ? C - 4716 : C - 4715; + } + p->validYMD = 1; +} + +/* +** Compute the Hour, Minute, and Seconds from the julian day number. +*/ +static void computeHMS(DateTime *p){ + int s; + if( p->validHMS ) return; + computeJD(p); + s = (int)((p->iJD + 43200000) % 86400000); + p->s = s/1000.0; + s = (int)p->s; + p->s -= s; + p->h = s/3600; + s -= p->h*3600; + p->m = s/60; + p->s += s - p->m*60; + p->rawS = 0; + p->validHMS = 1; +} + +/* +** Compute both YMD and HMS +*/ +static void computeYMD_HMS(DateTime *p){ + computeYMD(p); + computeHMS(p); +} + +/* +** Clear the YMD and HMS and the TZ +*/ +static void clearYMD_HMS_TZ(DateTime *p){ + p->validYMD = 0; + p->validHMS = 0; + p->validTZ = 0; +} + +#ifndef SQLITE_OMIT_LOCALTIME +/* +** On recent Windows platforms, the localtime_s() function is available +** as part of the "Secure CRT". It is essentially equivalent to +** localtime_r() available under most POSIX platforms, except that the +** order of the parameters is reversed. +** +** See http://msdn.microsoft.com/en-us/library/a442x3ye(VS.80).aspx. +** +** If the user has not indicated to use localtime_r() or localtime_s() +** already, check for an MSVC build environment that provides +** localtime_s(). +*/ +#if !HAVE_LOCALTIME_R && !HAVE_LOCALTIME_S \ + && defined(_MSC_VER) && defined(_CRT_INSECURE_DEPRECATE) +#undef HAVE_LOCALTIME_S +#define HAVE_LOCALTIME_S 1 +#endif + +/* +** The following routine implements the rough equivalent of localtime_r() +** using whatever operating-system specific localtime facility that +** is available. This routine returns 0 on success and +** non-zero on any kind of error. +** +** If the sqlite3GlobalConfig.bLocaltimeFault variable is non-zero then this +** routine will always fail. If bLocaltimeFault is nonzero and +** sqlite3GlobalConfig.xAltLocaltime is not NULL, then xAltLocaltime() is +** invoked in place of the OS-defined localtime() function. +** +** EVIDENCE-OF: R-62172-00036 In this implementation, the standard C +** library function localtime_r() is used to assist in the calculation of +** local time. +*/ +static int osLocaltime(time_t *t, struct tm *pTm){ + int rc; +#if !HAVE_LOCALTIME_R && !HAVE_LOCALTIME_S + struct tm *pX; +#if SQLITE_THREADSAFE>0 + sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); +#endif + sqlite3_mutex_enter(mutex); + pX = localtime(t); +#ifndef SQLITE_UNTESTABLE + if( sqlite3GlobalConfig.bLocaltimeFault ){ + if( sqlite3GlobalConfig.xAltLocaltime!=0 + && 0==sqlite3GlobalConfig.xAltLocaltime((const void*)t,(void*)pTm) + ){ + pX = pTm; + }else{ + pX = 0; + } + } +#endif + if( pX ) *pTm = *pX; +#if SQLITE_THREADSAFE>0 + sqlite3_mutex_leave(mutex); +#endif + rc = pX==0; +#else +#ifndef SQLITE_UNTESTABLE + if( sqlite3GlobalConfig.bLocaltimeFault ){ + if( sqlite3GlobalConfig.xAltLocaltime!=0 ){ + return sqlite3GlobalConfig.xAltLocaltime((const void*)t,(void*)pTm); + }else{ + return 1; + } + } +#endif +#if HAVE_LOCALTIME_R + rc = localtime_r(t, pTm)==0; +#else + rc = localtime_s(pTm, t); +#endif /* HAVE_LOCALTIME_R */ +#endif /* HAVE_LOCALTIME_R || HAVE_LOCALTIME_S */ + return rc; +} +#endif /* SQLITE_OMIT_LOCALTIME */ + + +#ifndef SQLITE_OMIT_LOCALTIME +/* +** Assuming the input DateTime is UTC, move it to its localtime equivalent. +*/ +static int toLocaltime( + DateTime *p, /* Date at which to calculate offset */ + sqlite3_context *pCtx /* Write error here if one occurs */ +){ + time_t t; + struct tm sLocal; + int iYearDiff; + + /* Initialize the contents of sLocal to avoid a compiler warning. */ + memset(&sLocal, 0, sizeof(sLocal)); + + computeJD(p); + if( p->iJD<2108667600*(i64)100000 /* 1970-01-01 */ + || p->iJD>2130141456*(i64)100000 /* 2038-01-18 */ + ){ + /* EVIDENCE-OF: R-55269-29598 The localtime_r() C function normally only + ** works for years between 1970 and 2037. For dates outside this range, + ** SQLite attempts to map the year into an equivalent year within this + ** range, do the calculation, then map the year back. + */ + DateTime x = *p; + computeYMD_HMS(&x); + iYearDiff = (2000 + x.Y%4) - x.Y; + x.Y += iYearDiff; + x.validJD = 0; + computeJD(&x); + t = (time_t)(x.iJD/1000 - 21086676*(i64)10000); + }else{ + iYearDiff = 0; + t = (time_t)(p->iJD/1000 - 21086676*(i64)10000); + } + if( osLocaltime(&t, &sLocal) ){ + sqlite3_result_error(pCtx, "local time unavailable", -1); + return SQLITE_ERROR; + } + p->Y = sLocal.tm_year + 1900 - iYearDiff; + p->M = sLocal.tm_mon + 1; + p->D = sLocal.tm_mday; + p->h = sLocal.tm_hour; + p->m = sLocal.tm_min; + p->s = sLocal.tm_sec + (p->iJD%1000)*0.001; + p->validYMD = 1; + p->validHMS = 1; + p->validJD = 0; + p->rawS = 0; + p->validTZ = 0; + p->isError = 0; + return SQLITE_OK; +} +#endif /* SQLITE_OMIT_LOCALTIME */ + +/* +** The following table defines various date transformations of the form +** +** 'NNN days' +** +** Where NNN is an arbitrary floating-point number and "days" can be one +** of several units of time. +*/ +static const struct { + u8 nName; /* Length of the name */ + char zName[7]; /* Name of the transformation */ + float rLimit; /* Maximum NNN value for this transform */ + float rXform; /* Constant used for this transform */ +} aXformType[] = { + { 6, "second", 4.6427e+14, 1.0 }, + { 6, "minute", 7.7379e+12, 60.0 }, + { 4, "hour", 1.2897e+11, 3600.0 }, + { 3, "day", 5373485.0, 86400.0 }, + { 5, "month", 176546.0, 2592000.0 }, + { 4, "year", 14713.0, 31536000.0 }, +}; + +/* +** Process a modifier to a date-time stamp. The modifiers are +** as follows: +** +** NNN days +** NNN hours +** NNN minutes +** NNN.NNNN seconds +** NNN months +** NNN years +** start of month +** start of year +** start of week +** start of day +** weekday N +** unixepoch +** localtime +** utc +** +** Return 0 on success and 1 if there is any kind of error. If the error +** is in a system call (i.e. localtime()), then an error message is written +** to context pCtx. If the error is an unrecognized modifier, no error is +** written to pCtx. +*/ +static int parseModifier( + sqlite3_context *pCtx, /* Function context */ + const char *z, /* The text of the modifier */ + int n, /* Length of zMod in bytes */ + DateTime *p, /* The date/time value to be modified */ + int idx /* Parameter index of the modifier */ +){ + int rc = 1; + double r; + switch(sqlite3UpperToLower[(u8)z[0]] ){ + case 'a': { + /* + ** auto + ** + ** If rawS is available, then interpret as a julian day number, or + ** a unix timestamp, depending on its magnitude. + */ + if( sqlite3_stricmp(z, "auto")==0 ){ + if( idx>1 ) return 1; /* IMP: R-33611-57934 */ + if( !p->rawS || p->validJD ){ + rc = 0; + p->rawS = 0; + }else if( p->s>=-21086676*(i64)10000 /* -4713-11-24 12:00:00 */ + && p->s<=(25340230*(i64)10000)+799 /* 9999-12-31 23:59:59 */ + ){ + r = p->s*1000.0 + 210866760000000.0; + clearYMD_HMS_TZ(p); + p->iJD = (sqlite3_int64)(r + 0.5); + p->validJD = 1; + p->rawS = 0; + rc = 0; + } + } + break; + } + case 'j': { + /* + ** julianday + ** + ** Always interpret the prior number as a julian-day value. If this + ** is not the first modifier, or if the prior argument is not a numeric + ** value in the allowed range of julian day numbers understood by + ** SQLite (0..5373484.5) then the result will be NULL. + */ + if( sqlite3_stricmp(z, "julianday")==0 ){ + if( idx>1 ) return 1; /* IMP: R-31176-64601 */ + if( p->validJD && p->rawS ){ + rc = 0; + p->rawS = 0; + } + } + break; + } +#ifndef SQLITE_OMIT_LOCALTIME + case 'l': { + /* localtime + ** + ** Assuming the current time value is UTC (a.k.a. GMT), shift it to + ** show local time. + */ + if( sqlite3_stricmp(z, "localtime")==0 && sqlite3NotPureFunc(pCtx) ){ + rc = toLocaltime(p, pCtx); + } + break; + } +#endif + case 'u': { + /* + ** unixepoch + ** + ** Treat the current value of p->s as the number of + ** seconds since 1970. Convert to a real julian day number. + */ + if( sqlite3_stricmp(z, "unixepoch")==0 && p->rawS ){ + if( idx>1 ) return 1; /* IMP: R-49255-55373 */ + r = p->s*1000.0 + 210866760000000.0; + if( r>=0.0 && r<464269060800000.0 ){ + clearYMD_HMS_TZ(p); + p->iJD = (sqlite3_int64)(r + 0.5); + p->validJD = 1; + p->rawS = 0; + rc = 0; + } + } +#ifndef SQLITE_OMIT_LOCALTIME + else if( sqlite3_stricmp(z, "utc")==0 && sqlite3NotPureFunc(pCtx) ){ + if( p->tzSet==0 ){ + i64 iOrigJD; /* Original localtime */ + i64 iGuess; /* Guess at the corresponding utc time */ + int cnt = 0; /* Safety to prevent infinite loop */ + i64 iErr; /* Guess is off by this much */ + + computeJD(p); + iGuess = iOrigJD = p->iJD; + iErr = 0; + do{ + DateTime new; + memset(&new, 0, sizeof(new)); + iGuess -= iErr; + new.iJD = iGuess; + new.validJD = 1; + rc = toLocaltime(&new, pCtx); + if( rc ) return rc; + computeJD(&new); + iErr = new.iJD - iOrigJD; + }while( iErr && cnt++<3 ); + memset(p, 0, sizeof(*p)); + p->iJD = iGuess; + p->validJD = 1; + p->tzSet = 1; + } + rc = SQLITE_OK; + } +#endif + break; + } + case 'w': { + /* + ** weekday N + ** + ** Move the date to the same time on the next occurrence of + ** weekday N where 0==Sunday, 1==Monday, and so forth. If the + ** date is already on the appropriate weekday, this is a no-op. + */ + if( sqlite3_strnicmp(z, "weekday ", 8)==0 + && sqlite3AtoF(&z[8], &r, sqlite3Strlen30(&z[8]), SQLITE_UTF8)>0 + && r>=0.0 && r<7.0 && (n=(int)r)==r ){ + sqlite3_int64 Z; + computeYMD_HMS(p); + p->validTZ = 0; + p->validJD = 0; + computeJD(p); + Z = ((p->iJD + 129600000)/86400000) % 7; + if( Z>n ) Z -= 7; + p->iJD += (n - Z)*86400000; + clearYMD_HMS_TZ(p); + rc = 0; + } + break; + } + case 's': { + /* + ** start of TTTTT + ** + ** Move the date backwards to the beginning of the current day, + ** or month or year. + ** + ** subsecond + ** subsec + ** + ** Show subsecond precision in the output of datetime() and + ** unixepoch() and strftime('%s'). + */ + if( sqlite3_strnicmp(z, "start of ", 9)!=0 ){ + if( sqlite3_stricmp(z, "subsec")==0 + || sqlite3_stricmp(z, "subsecond")==0 + ){ + p->useSubsec = 1; + rc = 0; + } + break; + } + if( !p->validJD && !p->validYMD && !p->validHMS ) break; + z += 9; + computeYMD(p); + p->validHMS = 1; + p->h = p->m = 0; + p->s = 0.0; + p->rawS = 0; + p->validTZ = 0; + p->validJD = 0; + if( sqlite3_stricmp(z,"month")==0 ){ + p->D = 1; + rc = 0; + }else if( sqlite3_stricmp(z,"year")==0 ){ + p->M = 1; + p->D = 1; + rc = 0; + }else if( sqlite3_stricmp(z,"day")==0 ){ + rc = 0; + } + break; + } + case '+': + case '-': + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': { + double rRounder; + int i; + for(n=1; z[n] && z[n]!=':' && !sqlite3Isspace(z[n]); n++){} + if( sqlite3AtoF(z, &r, n, SQLITE_UTF8)<=0 ){ + rc = 1; + break; + } + if( z[n]==':' ){ + /* A modifier of the form (+|-)HH:MM:SS.FFF adds (or subtracts) the + ** specified number of hours, minutes, seconds, and fractional seconds + ** to the time. The ".FFF" may be omitted. The ":SS.FFF" may be + ** omitted. + */ + const char *z2 = z; + DateTime tx; + sqlite3_int64 day; + if( !sqlite3Isdigit(*z2) ) z2++; + memset(&tx, 0, sizeof(tx)); + if( parseHhMmSs(z2, &tx) ) break; + computeJD(&tx); + tx.iJD -= 43200000; + day = tx.iJD/86400000; + tx.iJD -= day*86400000; + if( z[0]=='-' ) tx.iJD = -tx.iJD; + computeJD(p); + clearYMD_HMS_TZ(p); + p->iJD += tx.iJD; + rc = 0; + break; + } + + /* If control reaches this point, it means the transformation is + ** one of the forms like "+NNN days". */ + z += n; + while( sqlite3Isspace(*z) ) z++; + n = sqlite3Strlen30(z); + if( n>10 || n<3 ) break; + if( sqlite3UpperToLower[(u8)z[n-1]]=='s' ) n--; + computeJD(p); + rc = 1; + rRounder = r<0 ? -0.5 : +0.5; + for(i=0; i-aXformType[i].rLimit && rM += (int)r; + x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12; + p->Y += x; + p->M -= x*12; + p->validJD = 0; + r -= (int)r; + break; + } + case 5: { /* Special processing to add years */ + int y = (int)r; + assert( strcmp(aXformType[i].zName,"year")==0 ); + computeYMD_HMS(p); + p->Y += y; + p->validJD = 0; + r -= (int)r; + break; + } + } + computeJD(p); + p->iJD += (sqlite3_int64)(r*1000.0*aXformType[i].rXform + rRounder); + rc = 0; + break; + } + } + clearYMD_HMS_TZ(p); + break; + } + default: { + break; + } + } + return rc; +} + +/* +** Process time function arguments. argv[0] is a date-time stamp. +** argv[1] and following are modifiers. Parse them all and write +** the resulting time into the DateTime structure p. Return 0 +** on success and 1 if there are any errors. +** +** If there are zero parameters (if even argv[0] is undefined) +** then assume a default value of "now" for argv[0]. +*/ +static int isDate( + sqlite3_context *context, + int argc, + sqlite3_value **argv, + DateTime *p +){ + int i, n; + const unsigned char *z; + int eType; + memset(p, 0, sizeof(*p)); + if( argc==0 ){ + if( !sqlite3NotPureFunc(context) ) return 1; + return setDateTimeToCurrent(context, p); + } + if( (eType = sqlite3_value_type(argv[0]))==SQLITE_FLOAT + || eType==SQLITE_INTEGER ){ + setRawDateNumber(p, sqlite3_value_double(argv[0])); + }else{ + z = sqlite3_value_text(argv[0]); + if( !z || parseDateOrTime(context, (char*)z, p) ){ + return 1; + } + } + for(i=1; iisError || !validJulianDay(p->iJD) ) return 1; + return 0; +} + + +/* +** The following routines implement the various date and time functions +** of SQLite. +*/ + +/* +** julianday( TIMESTRING, MOD, MOD, ...) +** +** Return the julian day number of the date specified in the arguments +*/ +static void juliandayFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + DateTime x; + if( isDate(context, argc, argv, &x)==0 ){ + computeJD(&x); + sqlite3_result_double(context, x.iJD/86400000.0); + } +} + +/* +** unixepoch( TIMESTRING, MOD, MOD, ...) +** +** Return the number of seconds (including fractional seconds) since +** the unix epoch of 1970-01-01 00:00:00 GMT. +*/ +static void unixepochFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + DateTime x; + if( isDate(context, argc, argv, &x)==0 ){ + computeJD(&x); + if( x.useSubsec ){ + sqlite3_result_double(context, (x.iJD - 21086676*(i64)10000000)/1000.0); + }else{ + sqlite3_result_int64(context, x.iJD/1000 - 21086676*(i64)10000); + } + } +} + +/* +** datetime( TIMESTRING, MOD, MOD, ...) +** +** Return YYYY-MM-DD HH:MM:SS +*/ +static void datetimeFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + DateTime x; + if( isDate(context, argc, argv, &x)==0 ){ + int Y, s, n; + char zBuf[32]; + computeYMD_HMS(&x); + Y = x.Y; + if( Y<0 ) Y = -Y; + zBuf[1] = '0' + (Y/1000)%10; + zBuf[2] = '0' + (Y/100)%10; + zBuf[3] = '0' + (Y/10)%10; + zBuf[4] = '0' + (Y)%10; + zBuf[5] = '-'; + zBuf[6] = '0' + (x.M/10)%10; + zBuf[7] = '0' + (x.M)%10; + zBuf[8] = '-'; + zBuf[9] = '0' + (x.D/10)%10; + zBuf[10] = '0' + (x.D)%10; + zBuf[11] = ' '; + zBuf[12] = '0' + (x.h/10)%10; + zBuf[13] = '0' + (x.h)%10; + zBuf[14] = ':'; + zBuf[15] = '0' + (x.m/10)%10; + zBuf[16] = '0' + (x.m)%10; + zBuf[17] = ':'; + if( x.useSubsec ){ + s = (int)1000.0*x.s; + zBuf[18] = '0' + (s/10000)%10; + zBuf[19] = '0' + (s/1000)%10; + zBuf[20] = '.'; + zBuf[21] = '0' + (s/100)%10; + zBuf[22] = '0' + (s/10)%10; + zBuf[23] = '0' + (s)%10; + zBuf[24] = 0; + n = 24; + }else{ + s = (int)x.s; + zBuf[18] = '0' + (s/10)%10; + zBuf[19] = '0' + (s)%10; + zBuf[20] = 0; + n = 20; + } + if( x.Y<0 ){ + zBuf[0] = '-'; + sqlite3_result_text(context, zBuf, n, SQLITE_TRANSIENT); + }else{ + sqlite3_result_text(context, &zBuf[1], n-1, SQLITE_TRANSIENT); + } + } +} + +/* +** time( TIMESTRING, MOD, MOD, ...) +** +** Return HH:MM:SS +*/ +static void timeFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + DateTime x; + if( isDate(context, argc, argv, &x)==0 ){ + int s, n; + char zBuf[16]; + computeHMS(&x); + zBuf[0] = '0' + (x.h/10)%10; + zBuf[1] = '0' + (x.h)%10; + zBuf[2] = ':'; + zBuf[3] = '0' + (x.m/10)%10; + zBuf[4] = '0' + (x.m)%10; + zBuf[5] = ':'; + if( x.useSubsec ){ + s = (int)1000.0*x.s; + zBuf[6] = '0' + (s/10000)%10; + zBuf[7] = '0' + (s/1000)%10; + zBuf[8] = '.'; + zBuf[9] = '0' + (s/100)%10; + zBuf[10] = '0' + (s/10)%10; + zBuf[11] = '0' + (s)%10; + zBuf[12] = 0; + n = 12; + }else{ + s = (int)x.s; + zBuf[6] = '0' + (s/10)%10; + zBuf[7] = '0' + (s)%10; + zBuf[8] = 0; + n = 8; + } + sqlite3_result_text(context, zBuf, n, SQLITE_TRANSIENT); + } +} + +/* +** date( TIMESTRING, MOD, MOD, ...) +** +** Return YYYY-MM-DD +*/ +static void dateFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + DateTime x; + if( isDate(context, argc, argv, &x)==0 ){ + int Y; + char zBuf[16]; + computeYMD(&x); + Y = x.Y; + if( Y<0 ) Y = -Y; + zBuf[1] = '0' + (Y/1000)%10; + zBuf[2] = '0' + (Y/100)%10; + zBuf[3] = '0' + (Y/10)%10; + zBuf[4] = '0' + (Y)%10; + zBuf[5] = '-'; + zBuf[6] = '0' + (x.M/10)%10; + zBuf[7] = '0' + (x.M)%10; + zBuf[8] = '-'; + zBuf[9] = '0' + (x.D/10)%10; + zBuf[10] = '0' + (x.D)%10; + zBuf[11] = 0; + if( x.Y<0 ){ + zBuf[0] = '-'; + sqlite3_result_text(context, zBuf, 11, SQLITE_TRANSIENT); + }else{ + sqlite3_result_text(context, &zBuf[1], 10, SQLITE_TRANSIENT); + } + } +} + +/* +** strftime( FORMAT, TIMESTRING, MOD, MOD, ...) +** +** Return a string described by FORMAT. Conversions as follows: +** +** %d day of month +** %f ** fractional seconds SS.SSS +** %H hour 00-24 +** %j day of year 000-366 +** %J ** julian day number +** %m month 01-12 +** %M minute 00-59 +** %s seconds since 1970-01-01 +** %S seconds 00-59 +** %w day of week 0-6 sunday==0 +** %W week of year 00-53 +** %Y year 0000-9999 +** %% % +*/ +static void strftimeFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + DateTime x; + size_t i,j; + sqlite3 *db; + const char *zFmt; + sqlite3_str sRes; + + + if( argc==0 ) return; + zFmt = (const char*)sqlite3_value_text(argv[0]); + if( zFmt==0 || isDate(context, argc-1, argv+1, &x) ) return; + db = sqlite3_context_db_handle(context); + sqlite3StrAccumInit(&sRes, 0, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]); + + computeJD(&x); + computeYMD_HMS(&x); + for(i=j=0; zFmt[i]; i++){ + if( zFmt[i]!='%' ) continue; + if( j59.999 ) s = 59.999; + sqlite3_str_appendf(&sRes, "%06.3f", s); + break; + } + case 'H': { + sqlite3_str_appendf(&sRes, "%02d", x.h); + break; + } + case 'W': /* Fall thru */ + case 'j': { + int nDay; /* Number of days since 1st day of year */ + DateTime y = x; + y.validJD = 0; + y.M = 1; + y.D = 1; + computeJD(&y); + nDay = (int)((x.iJD-y.iJD+43200000)/86400000); + if( zFmt[i]=='W' ){ + int wd; /* 0=Monday, 1=Tuesday, ... 6=Sunday */ + wd = (int)(((x.iJD+43200000)/86400000)%7); + sqlite3_str_appendf(&sRes,"%02d",(nDay+7-wd)/7); + }else{ + sqlite3_str_appendf(&sRes,"%03d",nDay+1); + } + break; + } + case 'J': { + sqlite3_str_appendf(&sRes,"%.16g",x.iJD/86400000.0); + break; + } + case 'm': { + sqlite3_str_appendf(&sRes,"%02d",x.M); + break; + } + case 'M': { + sqlite3_str_appendf(&sRes,"%02d",x.m); + break; + } + case 's': { + if( x.useSubsec ){ + sqlite3_str_appendf(&sRes,"%.3f", + (x.iJD - 21086676*(i64)10000000)/1000.0); + }else{ + i64 iS = (i64)(x.iJD/1000 - 21086676*(i64)10000); + sqlite3_str_appendf(&sRes,"%lld",iS); + } + break; + } + case 'S': { + sqlite3_str_appendf(&sRes,"%02d",(int)x.s); + break; + } + case 'w': { + sqlite3_str_appendchar(&sRes, 1, + (char)(((x.iJD+129600000)/86400000) % 7) + '0'); + break; + } + case 'Y': { + sqlite3_str_appendf(&sRes,"%04d",x.Y); + break; + } + case '%': { + sqlite3_str_appendchar(&sRes, 1, '%'); + break; + } + default: { + sqlite3_str_reset(&sRes); + return; + } + } + } + if( jpMethods ){ + pId->pMethods->xClose(pId); + pId->pMethods = 0; + } +} +SQLITE_PRIVATE int sqlite3OsRead(sqlite3_file *id, void *pBuf, int amt, i64 offset){ + DO_OS_MALLOC_TEST(id); + return id->pMethods->xRead(id, pBuf, amt, offset); +} +SQLITE_PRIVATE int sqlite3OsWrite(sqlite3_file *id, const void *pBuf, int amt, i64 offset){ + DO_OS_MALLOC_TEST(id); + return id->pMethods->xWrite(id, pBuf, amt, offset); +} +SQLITE_PRIVATE int sqlite3OsTruncate(sqlite3_file *id, i64 size){ + return id->pMethods->xTruncate(id, size); +} +SQLITE_PRIVATE int sqlite3OsSync(sqlite3_file *id, int flags){ + DO_OS_MALLOC_TEST(id); + return flags ? id->pMethods->xSync(id, flags) : SQLITE_OK; +} +SQLITE_PRIVATE int sqlite3OsFileSize(sqlite3_file *id, i64 *pSize){ + DO_OS_MALLOC_TEST(id); + return id->pMethods->xFileSize(id, pSize); +} +SQLITE_PRIVATE int sqlite3OsLock(sqlite3_file *id, int lockType){ + DO_OS_MALLOC_TEST(id); + assert( lockType>=SQLITE_LOCK_SHARED && lockType<=SQLITE_LOCK_EXCLUSIVE ); + return id->pMethods->xLock(id, lockType); +} +SQLITE_PRIVATE int sqlite3OsUnlock(sqlite3_file *id, int lockType){ + assert( lockType==SQLITE_LOCK_NONE || lockType==SQLITE_LOCK_SHARED ); + return id->pMethods->xUnlock(id, lockType); +} +SQLITE_PRIVATE int sqlite3OsCheckReservedLock(sqlite3_file *id, int *pResOut){ + DO_OS_MALLOC_TEST(id); + return id->pMethods->xCheckReservedLock(id, pResOut); +} + +/* +** Use sqlite3OsFileControl() when we are doing something that might fail +** and we need to know about the failures. Use sqlite3OsFileControlHint() +** when simply tossing information over the wall to the VFS and we do not +** really care if the VFS receives and understands the information since it +** is only a hint and can be safely ignored. The sqlite3OsFileControlHint() +** routine has no return value since the return value would be meaningless. +*/ +SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){ + if( id->pMethods==0 ) return SQLITE_NOTFOUND; +#ifdef SQLITE_TEST + if( op!=SQLITE_FCNTL_COMMIT_PHASETWO + && op!=SQLITE_FCNTL_LOCK_TIMEOUT + && op!=SQLITE_FCNTL_CKPT_DONE + && op!=SQLITE_FCNTL_CKPT_START + ){ + /* Faults are not injected into COMMIT_PHASETWO because, assuming SQLite + ** is using a regular VFS, it is called after the corresponding + ** transaction has been committed. Injecting a fault at this point + ** confuses the test scripts - the COMMIT comand returns SQLITE_NOMEM + ** but the transaction is committed anyway. + ** + ** The core must call OsFileControl() though, not OsFileControlHint(), + ** as if a custom VFS (e.g. zipvfs) returns an error here, it probably + ** means the commit really has failed and an error should be returned + ** to the user. + ** + ** The CKPT_DONE and CKPT_START file-controls are write-only signals + ** to the cksumvfs. Their return code is meaningless and is ignored + ** by the SQLite core, so there is no point in simulating OOMs for them. + */ + DO_OS_MALLOC_TEST(id); + } +#endif + return id->pMethods->xFileControl(id, op, pArg); +} +SQLITE_PRIVATE void sqlite3OsFileControlHint(sqlite3_file *id, int op, void *pArg){ + if( id->pMethods ) (void)id->pMethods->xFileControl(id, op, pArg); +} + +SQLITE_PRIVATE int sqlite3OsSectorSize(sqlite3_file *id){ + int (*xSectorSize)(sqlite3_file*) = id->pMethods->xSectorSize; + return (xSectorSize ? xSectorSize(id) : SQLITE_DEFAULT_SECTOR_SIZE); +} +SQLITE_PRIVATE int sqlite3OsDeviceCharacteristics(sqlite3_file *id){ + if( NEVER(id->pMethods==0) ) return 0; + return id->pMethods->xDeviceCharacteristics(id); +} +#ifndef SQLITE_OMIT_WAL +SQLITE_PRIVATE int sqlite3OsShmLock(sqlite3_file *id, int offset, int n, int flags){ + return id->pMethods->xShmLock(id, offset, n, flags); +} +SQLITE_PRIVATE void sqlite3OsShmBarrier(sqlite3_file *id){ + id->pMethods->xShmBarrier(id); +} +SQLITE_PRIVATE int sqlite3OsShmUnmap(sqlite3_file *id, int deleteFlag){ + return id->pMethods->xShmUnmap(id, deleteFlag); +} +SQLITE_PRIVATE int sqlite3OsShmMap( + sqlite3_file *id, /* Database file handle */ + int iPage, + int pgsz, + int bExtend, /* True to extend file if necessary */ + void volatile **pp /* OUT: Pointer to mapping */ +){ + DO_OS_MALLOC_TEST(id); + return id->pMethods->xShmMap(id, iPage, pgsz, bExtend, pp); +} +#endif /* SQLITE_OMIT_WAL */ + +#if SQLITE_MAX_MMAP_SIZE>0 +/* The real implementation of xFetch and xUnfetch */ +SQLITE_PRIVATE int sqlite3OsFetch(sqlite3_file *id, i64 iOff, int iAmt, void **pp){ + DO_OS_MALLOC_TEST(id); + return id->pMethods->xFetch(id, iOff, iAmt, pp); +} +SQLITE_PRIVATE int sqlite3OsUnfetch(sqlite3_file *id, i64 iOff, void *p){ + return id->pMethods->xUnfetch(id, iOff, p); +} +#else +/* No-op stubs to use when memory-mapped I/O is disabled */ +SQLITE_PRIVATE int sqlite3OsFetch(sqlite3_file *id, i64 iOff, int iAmt, void **pp){ + *pp = 0; + return SQLITE_OK; +} +SQLITE_PRIVATE int sqlite3OsUnfetch(sqlite3_file *id, i64 iOff, void *p){ + return SQLITE_OK; +} +#endif + +/* +** The next group of routines are convenience wrappers around the +** VFS methods. +*/ +SQLITE_PRIVATE int sqlite3OsOpen( + sqlite3_vfs *pVfs, + const char *zPath, + sqlite3_file *pFile, + int flags, + int *pFlagsOut +){ + int rc; + DO_OS_MALLOC_TEST(0); + /* 0x87f7f is a mask of SQLITE_OPEN_ flags that are valid to be passed + ** down into the VFS layer. Some SQLITE_OPEN_ flags (for example, + ** SQLITE_OPEN_FULLMUTEX or SQLITE_OPEN_SHAREDCACHE) are blocked before + ** reaching the VFS. */ + assert( zPath || (flags & SQLITE_OPEN_EXCLUSIVE) ); + rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x1087f7f, pFlagsOut); + assert( rc==SQLITE_OK || pFile->pMethods==0 ); + return rc; +} +SQLITE_PRIVATE int sqlite3OsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){ + DO_OS_MALLOC_TEST(0); + assert( dirSync==0 || dirSync==1 ); + return pVfs->xDelete!=0 ? pVfs->xDelete(pVfs, zPath, dirSync) : SQLITE_OK; +} +SQLITE_PRIVATE int sqlite3OsAccess( + sqlite3_vfs *pVfs, + const char *zPath, + int flags, + int *pResOut +){ + DO_OS_MALLOC_TEST(0); + return pVfs->xAccess(pVfs, zPath, flags, pResOut); +} +SQLITE_PRIVATE int sqlite3OsFullPathname( + sqlite3_vfs *pVfs, + const char *zPath, + int nPathOut, + char *zPathOut +){ + DO_OS_MALLOC_TEST(0); + zPathOut[0] = 0; + return pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut); +} +#ifndef SQLITE_OMIT_LOAD_EXTENSION +SQLITE_PRIVATE void *sqlite3OsDlOpen(sqlite3_vfs *pVfs, const char *zPath){ + assert( zPath!=0 ); + assert( strlen(zPath)<=SQLITE_MAX_PATHLEN ); /* tag-20210611-1 */ + return pVfs->xDlOpen(pVfs, zPath); +} +SQLITE_PRIVATE void sqlite3OsDlError(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ + pVfs->xDlError(pVfs, nByte, zBufOut); +} +SQLITE_PRIVATE void (*sqlite3OsDlSym(sqlite3_vfs *pVfs, void *pHdle, const char *zSym))(void){ + return pVfs->xDlSym(pVfs, pHdle, zSym); +} +SQLITE_PRIVATE void sqlite3OsDlClose(sqlite3_vfs *pVfs, void *pHandle){ + pVfs->xDlClose(pVfs, pHandle); +} +#endif /* SQLITE_OMIT_LOAD_EXTENSION */ +SQLITE_PRIVATE int sqlite3OsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ + if( sqlite3Config.iPrngSeed ){ + memset(zBufOut, 0, nByte); + if( ALWAYS(nByte>(signed)sizeof(unsigned)) ) nByte = sizeof(unsigned int); + memcpy(zBufOut, &sqlite3Config.iPrngSeed, nByte); + return SQLITE_OK; + }else{ + return pVfs->xRandomness(pVfs, nByte, zBufOut); + } + +} +SQLITE_PRIVATE int sqlite3OsSleep(sqlite3_vfs *pVfs, int nMicro){ + return pVfs->xSleep(pVfs, nMicro); +} +SQLITE_PRIVATE int sqlite3OsGetLastError(sqlite3_vfs *pVfs){ + return pVfs->xGetLastError ? pVfs->xGetLastError(pVfs, 0, 0) : 0; +} +SQLITE_PRIVATE int sqlite3OsCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *pTimeOut){ + int rc; + /* IMPLEMENTATION-OF: R-49045-42493 SQLite will use the xCurrentTimeInt64() + ** method to get the current date and time if that method is available + ** (if iVersion is 2 or greater and the function pointer is not NULL) and + ** will fall back to xCurrentTime() if xCurrentTimeInt64() is + ** unavailable. + */ + if( pVfs->iVersion>=2 && pVfs->xCurrentTimeInt64 ){ + rc = pVfs->xCurrentTimeInt64(pVfs, pTimeOut); + }else{ + double r; + rc = pVfs->xCurrentTime(pVfs, &r); + *pTimeOut = (sqlite3_int64)(r*86400000.0); + } + return rc; +} + +SQLITE_PRIVATE int sqlite3OsOpenMalloc( + sqlite3_vfs *pVfs, + const char *zFile, + sqlite3_file **ppFile, + int flags, + int *pOutFlags +){ + int rc; + sqlite3_file *pFile; + pFile = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile); + if( pFile ){ + rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags); + if( rc!=SQLITE_OK ){ + sqlite3_free(pFile); + *ppFile = 0; + }else{ + *ppFile = pFile; + } + }else{ + *ppFile = 0; + rc = SQLITE_NOMEM_BKPT; + } + assert( *ppFile!=0 || rc!=SQLITE_OK ); + return rc; +} +SQLITE_PRIVATE void sqlite3OsCloseFree(sqlite3_file *pFile){ + assert( pFile ); + sqlite3OsClose(pFile); + sqlite3_free(pFile); +} + +/* +** This function is a wrapper around the OS specific implementation of +** sqlite3_os_init(). The purpose of the wrapper is to provide the +** ability to simulate a malloc failure, so that the handling of an +** error in sqlite3_os_init() by the upper layers can be tested. +*/ +SQLITE_PRIVATE int sqlite3OsInit(void){ + void *p = sqlite3_malloc(10); + if( p==0 ) return SQLITE_NOMEM_BKPT; + sqlite3_free(p); + return sqlite3_os_init(); +} + +/* +** The list of all registered VFS implementations. +*/ +static sqlite3_vfs * SQLITE_WSD vfsList = 0; +#define vfsList GLOBAL(sqlite3_vfs *, vfsList) + +/* +** Locate a VFS by name. If no name is given, simply return the +** first VFS on the list. +*/ +SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfs){ + sqlite3_vfs *pVfs = 0; +#if SQLITE_THREADSAFE + sqlite3_mutex *mutex; +#endif +#ifndef SQLITE_OMIT_AUTOINIT + int rc = sqlite3_initialize(); + if( rc ) return 0; +#endif +#if SQLITE_THREADSAFE + mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); +#endif + sqlite3_mutex_enter(mutex); + for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){ + if( zVfs==0 ) break; + if( strcmp(zVfs, pVfs->zName)==0 ) break; + } + sqlite3_mutex_leave(mutex); + return pVfs; +} + +/* +** Unlink a VFS from the linked list +*/ +static void vfsUnlink(sqlite3_vfs *pVfs){ + assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN)) ); + if( pVfs==0 ){ + /* No-op */ + }else if( vfsList==pVfs ){ + vfsList = pVfs->pNext; + }else if( vfsList ){ + sqlite3_vfs *p = vfsList; + while( p->pNext && p->pNext!=pVfs ){ + p = p->pNext; + } + if( p->pNext==pVfs ){ + p->pNext = pVfs->pNext; + } + } +} + +/* +** Register a VFS with the system. It is harmless to register the same +** VFS multiple times. The new VFS becomes the default if makeDflt is +** true. +*/ +SQLITE_API int sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){ + MUTEX_LOGIC(sqlite3_mutex *mutex;) +#ifndef SQLITE_OMIT_AUTOINIT + int rc = sqlite3_initialize(); + if( rc ) return rc; +#endif +#ifdef SQLITE_ENABLE_API_ARMOR + if( pVfs==0 ) return SQLITE_MISUSE_BKPT; +#endif + + MUTEX_LOGIC( mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); ) + sqlite3_mutex_enter(mutex); + vfsUnlink(pVfs); + if( makeDflt || vfsList==0 ){ + pVfs->pNext = vfsList; + vfsList = pVfs; + }else{ + pVfs->pNext = vfsList->pNext; + vfsList->pNext = pVfs; + } + assert(vfsList); + sqlite3_mutex_leave(mutex); + return SQLITE_OK; +} + +/* +** Unregister a VFS so that it is no longer accessible. +*/ +SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs *pVfs){ + MUTEX_LOGIC(sqlite3_mutex *mutex;) +#ifndef SQLITE_OMIT_AUTOINIT + int rc = sqlite3_initialize(); + if( rc ) return rc; +#endif + MUTEX_LOGIC( mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); ) + sqlite3_mutex_enter(mutex); + vfsUnlink(pVfs); + sqlite3_mutex_leave(mutex); + return SQLITE_OK; +} + +/************** End of os.c **************************************************/ +/************** Begin file fault.c *******************************************/ +/* +** 2008 Jan 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains code to support the concept of "benign" +** malloc failures (when the xMalloc() or xRealloc() method of the +** sqlite3_mem_methods structure fails to allocate a block of memory +** and returns 0). +** +** Most malloc failures are non-benign. After they occur, SQLite +** abandons the current operation and returns an error code (usually +** SQLITE_NOMEM) to the user. However, sometimes a fault is not necessarily +** fatal. For example, if a malloc fails while resizing a hash table, this +** is completely recoverable simply by not carrying out the resize. The +** hash table will continue to function normally. So a malloc failure +** during a hash table resize is a benign fault. +*/ + +/* #include "sqliteInt.h" */ + +#ifndef SQLITE_UNTESTABLE + +/* +** Global variables. +*/ +typedef struct BenignMallocHooks BenignMallocHooks; +static SQLITE_WSD struct BenignMallocHooks { + void (*xBenignBegin)(void); + void (*xBenignEnd)(void); +} sqlite3Hooks = { 0, 0 }; + +/* The "wsdHooks" macro will resolve to the appropriate BenignMallocHooks +** structure. If writable static data is unsupported on the target, +** we have to locate the state vector at run-time. In the more common +** case where writable static data is supported, wsdHooks can refer directly +** to the "sqlite3Hooks" state vector declared above. +*/ +#ifdef SQLITE_OMIT_WSD +# define wsdHooksInit \ + BenignMallocHooks *x = &GLOBAL(BenignMallocHooks,sqlite3Hooks) +# define wsdHooks x[0] +#else +# define wsdHooksInit +# define wsdHooks sqlite3Hooks +#endif + + +/* +** Register hooks to call when sqlite3BeginBenignMalloc() and +** sqlite3EndBenignMalloc() are called, respectively. +*/ +SQLITE_PRIVATE void sqlite3BenignMallocHooks( + void (*xBenignBegin)(void), + void (*xBenignEnd)(void) +){ + wsdHooksInit; + wsdHooks.xBenignBegin = xBenignBegin; + wsdHooks.xBenignEnd = xBenignEnd; +} + +/* +** This (sqlite3EndBenignMalloc()) is called by SQLite code to indicate that +** subsequent malloc failures are benign. A call to sqlite3EndBenignMalloc() +** indicates that subsequent malloc failures are non-benign. +*/ +SQLITE_PRIVATE void sqlite3BeginBenignMalloc(void){ + wsdHooksInit; + if( wsdHooks.xBenignBegin ){ + wsdHooks.xBenignBegin(); + } +} +SQLITE_PRIVATE void sqlite3EndBenignMalloc(void){ + wsdHooksInit; + if( wsdHooks.xBenignEnd ){ + wsdHooks.xBenignEnd(); + } +} + +#endif /* #ifndef SQLITE_UNTESTABLE */ + +/************** End of fault.c ***********************************************/ +/************** Begin file mem0.c ********************************************/ +/* +** 2008 October 28 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains a no-op memory allocation drivers for use when +** SQLITE_ZERO_MALLOC is defined. The allocation drivers implemented +** here always fail. SQLite will not operate with these drivers. These +** are merely placeholders. Real drivers must be substituted using +** sqlite3_config() before SQLite will operate. +*/ +/* #include "sqliteInt.h" */ + +/* +** This version of the memory allocator is the default. It is +** used when no other memory allocator is specified using compile-time +** macros. +*/ +#ifdef SQLITE_ZERO_MALLOC + +/* +** No-op versions of all memory allocation routines +*/ +static void *sqlite3MemMalloc(int nByte){ return 0; } +static void sqlite3MemFree(void *pPrior){ return; } +static void *sqlite3MemRealloc(void *pPrior, int nByte){ return 0; } +static int sqlite3MemSize(void *pPrior){ return 0; } +static int sqlite3MemRoundup(int n){ return n; } +static int sqlite3MemInit(void *NotUsed){ return SQLITE_OK; } +static void sqlite3MemShutdown(void *NotUsed){ return; } + +/* +** This routine is the only routine in this file with external linkage. +** +** Populate the low-level memory allocation function pointers in +** sqlite3GlobalConfig.m with pointers to the routines in this file. +*/ +SQLITE_PRIVATE void sqlite3MemSetDefault(void){ + static const sqlite3_mem_methods defaultMethods = { + sqlite3MemMalloc, + sqlite3MemFree, + sqlite3MemRealloc, + sqlite3MemSize, + sqlite3MemRoundup, + sqlite3MemInit, + sqlite3MemShutdown, + 0 + }; + sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods); +} + +#endif /* SQLITE_ZERO_MALLOC */ + +/************** End of mem0.c ************************************************/ +/************** Begin file mem1.c ********************************************/ +/* +** 2007 August 14 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains low-level memory allocation drivers for when +** SQLite will use the standard C-library malloc/realloc/free interface +** to obtain the memory it needs. +** +** This file contains implementations of the low-level memory allocation +** routines specified in the sqlite3_mem_methods object. The content of +** this file is only used if SQLITE_SYSTEM_MALLOC is defined. The +** SQLITE_SYSTEM_MALLOC macro is defined automatically if neither the +** SQLITE_MEMDEBUG nor the SQLITE_WIN32_MALLOC macros are defined. The +** default configuration is to use memory allocation routines in this +** file. +** +** C-preprocessor macro summary: +** +** HAVE_MALLOC_USABLE_SIZE The configure script sets this symbol if +** the malloc_usable_size() interface exists +** on the target platform. Or, this symbol +** can be set manually, if desired. +** If an equivalent interface exists by +** a different name, using a separate -D +** option to rename it. +** +** SQLITE_WITHOUT_ZONEMALLOC Some older macs lack support for the zone +** memory allocator. Set this symbol to enable +** building on older macs. +** +** SQLITE_WITHOUT_MSIZE Set this symbol to disable the use of +** _msize() on windows systems. This might +** be necessary when compiling for Delphi, +** for example. +*/ +/* #include "sqliteInt.h" */ + +/* +** This version of the memory allocator is the default. It is +** used when no other memory allocator is specified using compile-time +** macros. +*/ +#ifdef SQLITE_SYSTEM_MALLOC +#if defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC) + +/* +** Use the zone allocator available on apple products unless the +** SQLITE_WITHOUT_ZONEMALLOC symbol is defined. +*/ +#include +#include +#ifdef SQLITE_MIGHT_BE_SINGLE_CORE +#include +#endif /* SQLITE_MIGHT_BE_SINGLE_CORE */ +static malloc_zone_t* _sqliteZone_; +#define SQLITE_MALLOC(x) malloc_zone_malloc(_sqliteZone_, (x)) +#define SQLITE_FREE(x) malloc_zone_free(_sqliteZone_, (x)); +#define SQLITE_REALLOC(x,y) malloc_zone_realloc(_sqliteZone_, (x), (y)) +#define SQLITE_MALLOCSIZE(x) \ + (_sqliteZone_ ? _sqliteZone_->size(_sqliteZone_,x) : malloc_size(x)) + +#else /* if not __APPLE__ */ + +/* +** Use standard C library malloc and free on non-Apple systems. +** Also used by Apple systems if SQLITE_WITHOUT_ZONEMALLOC is defined. +*/ +#define SQLITE_MALLOC(x) malloc(x) +#define SQLITE_FREE(x) free(x) +#define SQLITE_REALLOC(x,y) realloc((x),(y)) + +/* +** The malloc.h header file is needed for malloc_usable_size() function +** on some systems (e.g. Linux). +*/ +#if HAVE_MALLOC_H && HAVE_MALLOC_USABLE_SIZE +# define SQLITE_USE_MALLOC_H 1 +# define SQLITE_USE_MALLOC_USABLE_SIZE 1 +/* +** The MSVCRT has malloc_usable_size(), but it is called _msize(). The +** use of _msize() is automatic, but can be disabled by compiling with +** -DSQLITE_WITHOUT_MSIZE. Using the _msize() function also requires +** the malloc.h header file. +*/ +#elif defined(_MSC_VER) && !defined(SQLITE_WITHOUT_MSIZE) +# define SQLITE_USE_MALLOC_H +# define SQLITE_USE_MSIZE +#endif + +/* +** Include the malloc.h header file, if necessary. Also set define macro +** SQLITE_MALLOCSIZE to the appropriate function name, which is _msize() +** for MSVC and malloc_usable_size() for most other systems (e.g. Linux). +** The memory size function can always be overridden manually by defining +** the macro SQLITE_MALLOCSIZE to the desired function name. +*/ +#if defined(SQLITE_USE_MALLOC_H) +# include +# if defined(SQLITE_USE_MALLOC_USABLE_SIZE) +# if !defined(SQLITE_MALLOCSIZE) +# define SQLITE_MALLOCSIZE(x) malloc_usable_size(x) +# endif +# elif defined(SQLITE_USE_MSIZE) +# if !defined(SQLITE_MALLOCSIZE) +# define SQLITE_MALLOCSIZE _msize +# endif +# endif +#endif /* defined(SQLITE_USE_MALLOC_H) */ + +#endif /* __APPLE__ or not __APPLE__ */ + +/* +** Like malloc(), but remember the size of the allocation +** so that we can find it later using sqlite3MemSize(). +** +** For this low-level routine, we are guaranteed that nByte>0 because +** cases of nByte<=0 will be intercepted and dealt with by higher level +** routines. +*/ +static void *sqlite3MemMalloc(int nByte){ +#ifdef SQLITE_MALLOCSIZE + void *p; + testcase( ROUND8(nByte)==nByte ); + p = SQLITE_MALLOC( nByte ); + if( p==0 ){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte); + } + return p; +#else + sqlite3_int64 *p; + assert( nByte>0 ); + testcase( ROUND8(nByte)!=nByte ); + p = SQLITE_MALLOC( nByte+8 ); + if( p ){ + p[0] = nByte; + p++; + }else{ + testcase( sqlite3GlobalConfig.xLog!=0 ); + sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte); + } + return (void *)p; +#endif +} + +/* +** Like free() but works for allocations obtained from sqlite3MemMalloc() +** or sqlite3MemRealloc(). +** +** For this low-level routine, we already know that pPrior!=0 since +** cases where pPrior==0 will have been intecepted and dealt with +** by higher-level routines. +*/ +static void sqlite3MemFree(void *pPrior){ +#ifdef SQLITE_MALLOCSIZE + SQLITE_FREE(pPrior); +#else + sqlite3_int64 *p = (sqlite3_int64*)pPrior; + assert( pPrior!=0 ); + p--; + SQLITE_FREE(p); +#endif +} + +/* +** Report the allocated size of a prior return from xMalloc() +** or xRealloc(). +*/ +static int sqlite3MemSize(void *pPrior){ +#ifdef SQLITE_MALLOCSIZE + assert( pPrior!=0 ); + return (int)SQLITE_MALLOCSIZE(pPrior); +#else + sqlite3_int64 *p; + assert( pPrior!=0 ); + p = (sqlite3_int64*)pPrior; + p--; + return (int)p[0]; +#endif +} + +/* +** Like realloc(). Resize an allocation previously obtained from +** sqlite3MemMalloc(). +** +** For this low-level interface, we know that pPrior!=0. Cases where +** pPrior==0 while have been intercepted by higher-level routine and +** redirected to xMalloc. Similarly, we know that nByte>0 because +** cases where nByte<=0 will have been intercepted by higher-level +** routines and redirected to xFree. +*/ +static void *sqlite3MemRealloc(void *pPrior, int nByte){ +#ifdef SQLITE_MALLOCSIZE + void *p = SQLITE_REALLOC(pPrior, nByte); + if( p==0 ){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + sqlite3_log(SQLITE_NOMEM, + "failed memory resize %u to %u bytes", + SQLITE_MALLOCSIZE(pPrior), nByte); + } + return p; +#else + sqlite3_int64 *p = (sqlite3_int64*)pPrior; + assert( pPrior!=0 && nByte>0 ); + assert( nByte==ROUND8(nByte) ); /* EV: R-46199-30249 */ + p--; + p = SQLITE_REALLOC(p, nByte+8 ); + if( p ){ + p[0] = nByte; + p++; + }else{ + testcase( sqlite3GlobalConfig.xLog!=0 ); + sqlite3_log(SQLITE_NOMEM, + "failed memory resize %u to %u bytes", + sqlite3MemSize(pPrior), nByte); + } + return (void*)p; +#endif +} + +/* +** Round up a request size to the next valid allocation size. +*/ +static int sqlite3MemRoundup(int n){ + return ROUND8(n); +} + +/* +** Initialize this module. +*/ +static int sqlite3MemInit(void *NotUsed){ +#if defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC) + int cpuCount; + size_t len; + if( _sqliteZone_ ){ + return SQLITE_OK; + } + len = sizeof(cpuCount); + /* One usually wants to use hw.acctivecpu for MT decisions, but not here */ + sysctlbyname("hw.ncpu", &cpuCount, &len, NULL, 0); + if( cpuCount>1 ){ + /* defer MT decisions to system malloc */ + _sqliteZone_ = malloc_default_zone(); + }else{ + /* only 1 core, use our own zone to contention over global locks, + ** e.g. we have our own dedicated locks */ + _sqliteZone_ = malloc_create_zone(4096, 0); + malloc_set_zone_name(_sqliteZone_, "Sqlite_Heap"); + } +#endif /* defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC) */ + UNUSED_PARAMETER(NotUsed); + return SQLITE_OK; +} + +/* +** Deinitialize this module. +*/ +static void sqlite3MemShutdown(void *NotUsed){ + UNUSED_PARAMETER(NotUsed); + return; +} + +/* +** This routine is the only routine in this file with external linkage. +** +** Populate the low-level memory allocation function pointers in +** sqlite3GlobalConfig.m with pointers to the routines in this file. +*/ +SQLITE_PRIVATE void sqlite3MemSetDefault(void){ + static const sqlite3_mem_methods defaultMethods = { + sqlite3MemMalloc, + sqlite3MemFree, + sqlite3MemRealloc, + sqlite3MemSize, + sqlite3MemRoundup, + sqlite3MemInit, + sqlite3MemShutdown, + 0 + }; + sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods); +} + +#endif /* SQLITE_SYSTEM_MALLOC */ + +/************** End of mem1.c ************************************************/ +/************** Begin file mem2.c ********************************************/ +/* +** 2007 August 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains low-level memory allocation drivers for when +** SQLite will use the standard C-library malloc/realloc/free interface +** to obtain the memory it needs while adding lots of additional debugging +** information to each allocation in order to help detect and fix memory +** leaks and memory usage errors. +** +** This file contains implementations of the low-level memory allocation +** routines specified in the sqlite3_mem_methods object. +*/ +/* #include "sqliteInt.h" */ + +/* +** This version of the memory allocator is used only if the +** SQLITE_MEMDEBUG macro is defined +*/ +#ifdef SQLITE_MEMDEBUG + +/* +** The backtrace functionality is only available with GLIBC +*/ +#ifdef __GLIBC__ + extern int backtrace(void**,int); + extern void backtrace_symbols_fd(void*const*,int,int); +#else +# define backtrace(A,B) 1 +# define backtrace_symbols_fd(A,B,C) +#endif +/* #include */ + +/* +** Each memory allocation looks like this: +** +** ------------------------------------------------------------------------ +** | Title | backtrace pointers | MemBlockHdr | allocation | EndGuard | +** ------------------------------------------------------------------------ +** +** The application code sees only a pointer to the allocation. We have +** to back up from the allocation pointer to find the MemBlockHdr. The +** MemBlockHdr tells us the size of the allocation and the number of +** backtrace pointers. There is also a guard word at the end of the +** MemBlockHdr. +*/ +struct MemBlockHdr { + i64 iSize; /* Size of this allocation */ + struct MemBlockHdr *pNext, *pPrev; /* Linked list of all unfreed memory */ + char nBacktrace; /* Number of backtraces on this alloc */ + char nBacktraceSlots; /* Available backtrace slots */ + u8 nTitle; /* Bytes of title; includes '\0' */ + u8 eType; /* Allocation type code */ + int iForeGuard; /* Guard word for sanity */ +}; + +/* +** Guard words +*/ +#define FOREGUARD 0x80F5E153 +#define REARGUARD 0xE4676B53 + +/* +** Number of malloc size increments to track. +*/ +#define NCSIZE 1000 + +/* +** All of the static variables used by this module are collected +** into a single structure named "mem". This is to keep the +** static variables organized and to reduce namespace pollution +** when this module is combined with other in the amalgamation. +*/ +static struct { + + /* + ** Mutex to control access to the memory allocation subsystem. + */ + sqlite3_mutex *mutex; + + /* + ** Head and tail of a linked list of all outstanding allocations + */ + struct MemBlockHdr *pFirst; + struct MemBlockHdr *pLast; + + /* + ** The number of levels of backtrace to save in new allocations. + */ + int nBacktrace; + void (*xBacktrace)(int, int, void **); + + /* + ** Title text to insert in front of each block + */ + int nTitle; /* Bytes of zTitle to save. Includes '\0' and padding */ + char zTitle[100]; /* The title text */ + + /* + ** sqlite3MallocDisallow() increments the following counter. + ** sqlite3MallocAllow() decrements it. + */ + int disallow; /* Do not allow memory allocation */ + + /* + ** Gather statistics on the sizes of memory allocations. + ** nAlloc[i] is the number of allocation attempts of i*8 + ** bytes. i==NCSIZE is the number of allocation attempts for + ** sizes more than NCSIZE*8 bytes. + */ + int nAlloc[NCSIZE]; /* Total number of allocations */ + int nCurrent[NCSIZE]; /* Current number of allocations */ + int mxCurrent[NCSIZE]; /* Highwater mark for nCurrent */ + +} mem; + + +/* +** Adjust memory usage statistics +*/ +static void adjustStats(int iSize, int increment){ + int i = ROUND8(iSize)/8; + if( i>NCSIZE-1 ){ + i = NCSIZE - 1; + } + if( increment>0 ){ + mem.nAlloc[i]++; + mem.nCurrent[i]++; + if( mem.nCurrent[i]>mem.mxCurrent[i] ){ + mem.mxCurrent[i] = mem.nCurrent[i]; + } + }else{ + mem.nCurrent[i]--; + assert( mem.nCurrent[i]>=0 ); + } +} + +/* +** Given an allocation, find the MemBlockHdr for that allocation. +** +** This routine checks the guards at either end of the allocation and +** if they are incorrect it asserts. +*/ +static struct MemBlockHdr *sqlite3MemsysGetHeader(const void *pAllocation){ + struct MemBlockHdr *p; + int *pInt; + u8 *pU8; + int nReserve; + + p = (struct MemBlockHdr*)pAllocation; + p--; + assert( p->iForeGuard==(int)FOREGUARD ); + nReserve = ROUND8(p->iSize); + pInt = (int*)pAllocation; + pU8 = (u8*)pAllocation; + assert( pInt[nReserve/sizeof(int)]==(int)REARGUARD ); + /* This checks any of the "extra" bytes allocated due + ** to rounding up to an 8 byte boundary to ensure + ** they haven't been overwritten. + */ + while( nReserve-- > p->iSize ) assert( pU8[nReserve]==0x65 ); + return p; +} + +/* +** Return the number of bytes currently allocated at address p. +*/ +static int sqlite3MemSize(void *p){ + struct MemBlockHdr *pHdr; + if( !p ){ + return 0; + } + pHdr = sqlite3MemsysGetHeader(p); + return (int)pHdr->iSize; +} + +/* +** Initialize the memory allocation subsystem. +*/ +static int sqlite3MemInit(void *NotUsed){ + UNUSED_PARAMETER(NotUsed); + assert( (sizeof(struct MemBlockHdr)&7) == 0 ); + if( !sqlite3GlobalConfig.bMemstat ){ + /* If memory status is enabled, then the malloc.c wrapper will already + ** hold the STATIC_MEM mutex when the routines here are invoked. */ + mem.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM); + } + return SQLITE_OK; +} + +/* +** Deinitialize the memory allocation subsystem. +*/ +static void sqlite3MemShutdown(void *NotUsed){ + UNUSED_PARAMETER(NotUsed); + mem.mutex = 0; +} + +/* +** Round up a request size to the next valid allocation size. +*/ +static int sqlite3MemRoundup(int n){ + return ROUND8(n); +} + +/* +** Fill a buffer with pseudo-random bytes. This is used to preset +** the content of a new memory allocation to unpredictable values and +** to clear the content of a freed allocation to unpredictable values. +*/ +static void randomFill(char *pBuf, int nByte){ + unsigned int x, y, r; + x = SQLITE_PTR_TO_INT(pBuf); + y = nByte | 1; + while( nByte >= 4 ){ + x = (x>>1) ^ (-(int)(x&1) & 0xd0000001); + y = y*1103515245 + 12345; + r = x ^ y; + *(int*)pBuf = r; + pBuf += 4; + nByte -= 4; + } + while( nByte-- > 0 ){ + x = (x>>1) ^ (-(int)(x&1) & 0xd0000001); + y = y*1103515245 + 12345; + r = x ^ y; + *(pBuf++) = r & 0xff; + } +} + +/* +** Allocate nByte bytes of memory. +*/ +static void *sqlite3MemMalloc(int nByte){ + struct MemBlockHdr *pHdr; + void **pBt; + char *z; + int *pInt; + void *p = 0; + int totalSize; + int nReserve; + sqlite3_mutex_enter(mem.mutex); + assert( mem.disallow==0 ); + nReserve = ROUND8(nByte); + totalSize = nReserve + sizeof(*pHdr) + sizeof(int) + + mem.nBacktrace*sizeof(void*) + mem.nTitle; + p = malloc(totalSize); + if( p ){ + z = p; + pBt = (void**)&z[mem.nTitle]; + pHdr = (struct MemBlockHdr*)&pBt[mem.nBacktrace]; + pHdr->pNext = 0; + pHdr->pPrev = mem.pLast; + if( mem.pLast ){ + mem.pLast->pNext = pHdr; + }else{ + mem.pFirst = pHdr; + } + mem.pLast = pHdr; + pHdr->iForeGuard = FOREGUARD; + pHdr->eType = MEMTYPE_HEAP; + pHdr->nBacktraceSlots = mem.nBacktrace; + pHdr->nTitle = mem.nTitle; + if( mem.nBacktrace ){ + void *aAddr[40]; + pHdr->nBacktrace = backtrace(aAddr, mem.nBacktrace+1)-1; + memcpy(pBt, &aAddr[1], pHdr->nBacktrace*sizeof(void*)); + assert(pBt[0]); + if( mem.xBacktrace ){ + mem.xBacktrace(nByte, pHdr->nBacktrace-1, &aAddr[1]); + } + }else{ + pHdr->nBacktrace = 0; + } + if( mem.nTitle ){ + memcpy(z, mem.zTitle, mem.nTitle); + } + pHdr->iSize = nByte; + adjustStats(nByte, +1); + pInt = (int*)&pHdr[1]; + pInt[nReserve/sizeof(int)] = REARGUARD; + randomFill((char*)pInt, nByte); + memset(((char*)pInt)+nByte, 0x65, nReserve-nByte); + p = (void*)pInt; + } + sqlite3_mutex_leave(mem.mutex); + return p; +} + +/* +** Free memory. +*/ +static void sqlite3MemFree(void *pPrior){ + struct MemBlockHdr *pHdr; + void **pBt; + char *z; + assert( sqlite3GlobalConfig.bMemstat || sqlite3GlobalConfig.bCoreMutex==0 + || mem.mutex!=0 ); + pHdr = sqlite3MemsysGetHeader(pPrior); + pBt = (void**)pHdr; + pBt -= pHdr->nBacktraceSlots; + sqlite3_mutex_enter(mem.mutex); + if( pHdr->pPrev ){ + assert( pHdr->pPrev->pNext==pHdr ); + pHdr->pPrev->pNext = pHdr->pNext; + }else{ + assert( mem.pFirst==pHdr ); + mem.pFirst = pHdr->pNext; + } + if( pHdr->pNext ){ + assert( pHdr->pNext->pPrev==pHdr ); + pHdr->pNext->pPrev = pHdr->pPrev; + }else{ + assert( mem.pLast==pHdr ); + mem.pLast = pHdr->pPrev; + } + z = (char*)pBt; + z -= pHdr->nTitle; + adjustStats((int)pHdr->iSize, -1); + randomFill(z, sizeof(void*)*pHdr->nBacktraceSlots + sizeof(*pHdr) + + (int)pHdr->iSize + sizeof(int) + pHdr->nTitle); + free(z); + sqlite3_mutex_leave(mem.mutex); +} + +/* +** Change the size of an existing memory allocation. +** +** For this debugging implementation, we *always* make a copy of the +** allocation into a new place in memory. In this way, if the +** higher level code is using pointer to the old allocation, it is +** much more likely to break and we are much more liking to find +** the error. +*/ +static void *sqlite3MemRealloc(void *pPrior, int nByte){ + struct MemBlockHdr *pOldHdr; + void *pNew; + assert( mem.disallow==0 ); + assert( (nByte & 7)==0 ); /* EV: R-46199-30249 */ + pOldHdr = sqlite3MemsysGetHeader(pPrior); + pNew = sqlite3MemMalloc(nByte); + if( pNew ){ + memcpy(pNew, pPrior, (int)(nByteiSize ? nByte : pOldHdr->iSize)); + if( nByte>pOldHdr->iSize ){ + randomFill(&((char*)pNew)[pOldHdr->iSize], nByte - (int)pOldHdr->iSize); + } + sqlite3MemFree(pPrior); + } + return pNew; +} + +/* +** Populate the low-level memory allocation function pointers in +** sqlite3GlobalConfig.m with pointers to the routines in this file. +*/ +SQLITE_PRIVATE void sqlite3MemSetDefault(void){ + static const sqlite3_mem_methods defaultMethods = { + sqlite3MemMalloc, + sqlite3MemFree, + sqlite3MemRealloc, + sqlite3MemSize, + sqlite3MemRoundup, + sqlite3MemInit, + sqlite3MemShutdown, + 0 + }; + sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods); +} + +/* +** Set the "type" of an allocation. +*/ +SQLITE_PRIVATE void sqlite3MemdebugSetType(void *p, u8 eType){ + if( p && sqlite3GlobalConfig.m.xFree==sqlite3MemFree ){ + struct MemBlockHdr *pHdr; + pHdr = sqlite3MemsysGetHeader(p); + assert( pHdr->iForeGuard==FOREGUARD ); + pHdr->eType = eType; + } +} + +/* +** Return TRUE if the mask of type in eType matches the type of the +** allocation p. Also return true if p==NULL. +** +** This routine is designed for use within an assert() statement, to +** verify the type of an allocation. For example: +** +** assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); +*/ +SQLITE_PRIVATE int sqlite3MemdebugHasType(const void *p, u8 eType){ + int rc = 1; + if( p && sqlite3GlobalConfig.m.xFree==sqlite3MemFree ){ + struct MemBlockHdr *pHdr; + pHdr = sqlite3MemsysGetHeader(p); + assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */ + if( (pHdr->eType&eType)==0 ){ + rc = 0; + } + } + return rc; +} + +/* +** Return TRUE if the mask of type in eType matches no bits of the type of the +** allocation p. Also return true if p==NULL. +** +** This routine is designed for use within an assert() statement, to +** verify the type of an allocation. For example: +** +** assert( sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) ); +*/ +SQLITE_PRIVATE int sqlite3MemdebugNoType(const void *p, u8 eType){ + int rc = 1; + if( p && sqlite3GlobalConfig.m.xFree==sqlite3MemFree ){ + struct MemBlockHdr *pHdr; + pHdr = sqlite3MemsysGetHeader(p); + assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */ + if( (pHdr->eType&eType)!=0 ){ + rc = 0; + } + } + return rc; +} + +/* +** Set the number of backtrace levels kept for each allocation. +** A value of zero turns off backtracing. The number is always rounded +** up to a multiple of 2. +*/ +SQLITE_PRIVATE void sqlite3MemdebugBacktrace(int depth){ + if( depth<0 ){ depth = 0; } + if( depth>20 ){ depth = 20; } + depth = (depth+1)&0xfe; + mem.nBacktrace = depth; +} + +SQLITE_PRIVATE void sqlite3MemdebugBacktraceCallback(void (*xBacktrace)(int, int, void **)){ + mem.xBacktrace = xBacktrace; +} + +/* +** Set the title string for subsequent allocations. +*/ +SQLITE_PRIVATE void sqlite3MemdebugSettitle(const char *zTitle){ + unsigned int n = sqlite3Strlen30(zTitle) + 1; + sqlite3_mutex_enter(mem.mutex); + if( n>=sizeof(mem.zTitle) ) n = sizeof(mem.zTitle)-1; + memcpy(mem.zTitle, zTitle, n); + mem.zTitle[n] = 0; + mem.nTitle = ROUND8(n); + sqlite3_mutex_leave(mem.mutex); +} + +SQLITE_PRIVATE void sqlite3MemdebugSync(){ + struct MemBlockHdr *pHdr; + for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){ + void **pBt = (void**)pHdr; + pBt -= pHdr->nBacktraceSlots; + mem.xBacktrace((int)pHdr->iSize, pHdr->nBacktrace-1, &pBt[1]); + } +} + +/* +** Open the file indicated and write a log of all unfreed memory +** allocations into that log. +*/ +SQLITE_PRIVATE void sqlite3MemdebugDump(const char *zFilename){ + FILE *out; + struct MemBlockHdr *pHdr; + void **pBt; + int i; + out = fopen(zFilename, "w"); + if( out==0 ){ + fprintf(stderr, "** Unable to output memory debug output log: %s **\n", + zFilename); + return; + } + for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){ + char *z = (char*)pHdr; + z -= pHdr->nBacktraceSlots*sizeof(void*) + pHdr->nTitle; + fprintf(out, "**** %lld bytes at %p from %s ****\n", + pHdr->iSize, &pHdr[1], pHdr->nTitle ? z : "???"); + if( pHdr->nBacktrace ){ + fflush(out); + pBt = (void**)pHdr; + pBt -= pHdr->nBacktraceSlots; + backtrace_symbols_fd(pBt, pHdr->nBacktrace, fileno(out)); + fprintf(out, "\n"); + } + } + fprintf(out, "COUNTS:\n"); + for(i=0; i=1 ); + size = mem3.aPool[i-1].u.hdr.size4x/4; + assert( size==mem3.aPool[i+size-1].u.hdr.prevSize ); + assert( size>=2 ); + if( size <= MX_SMALL ){ + memsys3UnlinkFromList(i, &mem3.aiSmall[size-2]); + }else{ + hash = size % N_HASH; + memsys3UnlinkFromList(i, &mem3.aiHash[hash]); + } +} + +/* +** Link the chunk at mem3.aPool[i] so that is on the list rooted +** at *pRoot. +*/ +static void memsys3LinkIntoList(u32 i, u32 *pRoot){ + assert( sqlite3_mutex_held(mem3.mutex) ); + mem3.aPool[i].u.list.next = *pRoot; + mem3.aPool[i].u.list.prev = 0; + if( *pRoot ){ + mem3.aPool[*pRoot].u.list.prev = i; + } + *pRoot = i; +} + +/* +** Link the chunk at index i into either the appropriate +** small chunk list, or into the large chunk hash table. +*/ +static void memsys3Link(u32 i){ + u32 size, hash; + assert( sqlite3_mutex_held(mem3.mutex) ); + assert( i>=1 ); + assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 ); + size = mem3.aPool[i-1].u.hdr.size4x/4; + assert( size==mem3.aPool[i+size-1].u.hdr.prevSize ); + assert( size>=2 ); + if( size <= MX_SMALL ){ + memsys3LinkIntoList(i, &mem3.aiSmall[size-2]); + }else{ + hash = size % N_HASH; + memsys3LinkIntoList(i, &mem3.aiHash[hash]); + } +} + +/* +** If the STATIC_MEM mutex is not already held, obtain it now. The mutex +** will already be held (obtained by code in malloc.c) if +** sqlite3GlobalConfig.bMemStat is true. +*/ +static void memsys3Enter(void){ + if( sqlite3GlobalConfig.bMemstat==0 && mem3.mutex==0 ){ + mem3.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM); + } + sqlite3_mutex_enter(mem3.mutex); +} +static void memsys3Leave(void){ + sqlite3_mutex_leave(mem3.mutex); +} + +/* +** Called when we are unable to satisfy an allocation of nBytes. +*/ +static void memsys3OutOfMemory(int nByte){ + if( !mem3.alarmBusy ){ + mem3.alarmBusy = 1; + assert( sqlite3_mutex_held(mem3.mutex) ); + sqlite3_mutex_leave(mem3.mutex); + sqlite3_release_memory(nByte); + sqlite3_mutex_enter(mem3.mutex); + mem3.alarmBusy = 0; + } +} + + +/* +** Chunk i is a free chunk that has been unlinked. Adjust its +** size parameters for check-out and return a pointer to the +** user portion of the chunk. +*/ +static void *memsys3Checkout(u32 i, u32 nBlock){ + u32 x; + assert( sqlite3_mutex_held(mem3.mutex) ); + assert( i>=1 ); + assert( mem3.aPool[i-1].u.hdr.size4x/4==nBlock ); + assert( mem3.aPool[i+nBlock-1].u.hdr.prevSize==nBlock ); + x = mem3.aPool[i-1].u.hdr.size4x; + mem3.aPool[i-1].u.hdr.size4x = nBlock*4 | 1 | (x&2); + mem3.aPool[i+nBlock-1].u.hdr.prevSize = nBlock; + mem3.aPool[i+nBlock-1].u.hdr.size4x |= 2; + return &mem3.aPool[i]; +} + +/* +** Carve a piece off of the end of the mem3.iKeyBlk free chunk. +** Return a pointer to the new allocation. Or, if the key chunk +** is not large enough, return 0. +*/ +static void *memsys3FromKeyBlk(u32 nBlock){ + assert( sqlite3_mutex_held(mem3.mutex) ); + assert( mem3.szKeyBlk>=nBlock ); + if( nBlock>=mem3.szKeyBlk-1 ){ + /* Use the entire key chunk */ + void *p = memsys3Checkout(mem3.iKeyBlk, mem3.szKeyBlk); + mem3.iKeyBlk = 0; + mem3.szKeyBlk = 0; + mem3.mnKeyBlk = 0; + return p; + }else{ + /* Split the key block. Return the tail. */ + u32 newi, x; + newi = mem3.iKeyBlk + mem3.szKeyBlk - nBlock; + assert( newi > mem3.iKeyBlk+1 ); + mem3.aPool[mem3.iKeyBlk+mem3.szKeyBlk-1].u.hdr.prevSize = nBlock; + mem3.aPool[mem3.iKeyBlk+mem3.szKeyBlk-1].u.hdr.size4x |= 2; + mem3.aPool[newi-1].u.hdr.size4x = nBlock*4 + 1; + mem3.szKeyBlk -= nBlock; + mem3.aPool[newi-1].u.hdr.prevSize = mem3.szKeyBlk; + x = mem3.aPool[mem3.iKeyBlk-1].u.hdr.size4x & 2; + mem3.aPool[mem3.iKeyBlk-1].u.hdr.size4x = mem3.szKeyBlk*4 | x; + if( mem3.szKeyBlk < mem3.mnKeyBlk ){ + mem3.mnKeyBlk = mem3.szKeyBlk; + } + return (void*)&mem3.aPool[newi]; + } +} + +/* +** *pRoot is the head of a list of free chunks of the same size +** or same size hash. In other words, *pRoot is an entry in either +** mem3.aiSmall[] or mem3.aiHash[]. +** +** This routine examines all entries on the given list and tries +** to coalesce each entries with adjacent free chunks. +** +** If it sees a chunk that is larger than mem3.iKeyBlk, it replaces +** the current mem3.iKeyBlk with the new larger chunk. In order for +** this mem3.iKeyBlk replacement to work, the key chunk must be +** linked into the hash tables. That is not the normal state of +** affairs, of course. The calling routine must link the key +** chunk before invoking this routine, then must unlink the (possibly +** changed) key chunk once this routine has finished. +*/ +static void memsys3Merge(u32 *pRoot){ + u32 iNext, prev, size, i, x; + + assert( sqlite3_mutex_held(mem3.mutex) ); + for(i=*pRoot; i>0; i=iNext){ + iNext = mem3.aPool[i].u.list.next; + size = mem3.aPool[i-1].u.hdr.size4x; + assert( (size&1)==0 ); + if( (size&2)==0 ){ + memsys3UnlinkFromList(i, pRoot); + assert( i > mem3.aPool[i-1].u.hdr.prevSize ); + prev = i - mem3.aPool[i-1].u.hdr.prevSize; + if( prev==iNext ){ + iNext = mem3.aPool[prev].u.list.next; + } + memsys3Unlink(prev); + size = i + size/4 - prev; + x = mem3.aPool[prev-1].u.hdr.size4x & 2; + mem3.aPool[prev-1].u.hdr.size4x = size*4 | x; + mem3.aPool[prev+size-1].u.hdr.prevSize = size; + memsys3Link(prev); + i = prev; + }else{ + size /= 4; + } + if( size>mem3.szKeyBlk ){ + mem3.iKeyBlk = i; + mem3.szKeyBlk = size; + } + } +} + +/* +** Return a block of memory of at least nBytes in size. +** Return NULL if unable. +** +** This function assumes that the necessary mutexes, if any, are +** already held by the caller. Hence "Unsafe". +*/ +static void *memsys3MallocUnsafe(int nByte){ + u32 i; + u32 nBlock; + u32 toFree; + + assert( sqlite3_mutex_held(mem3.mutex) ); + assert( sizeof(Mem3Block)==8 ); + if( nByte<=12 ){ + nBlock = 2; + }else{ + nBlock = (nByte + 11)/8; + } + assert( nBlock>=2 ); + + /* STEP 1: + ** Look for an entry of the correct size in either the small + ** chunk table or in the large chunk hash table. This is + ** successful most of the time (about 9 times out of 10). + */ + if( nBlock <= MX_SMALL ){ + i = mem3.aiSmall[nBlock-2]; + if( i>0 ){ + memsys3UnlinkFromList(i, &mem3.aiSmall[nBlock-2]); + return memsys3Checkout(i, nBlock); + } + }else{ + int hash = nBlock % N_HASH; + for(i=mem3.aiHash[hash]; i>0; i=mem3.aPool[i].u.list.next){ + if( mem3.aPool[i-1].u.hdr.size4x/4==nBlock ){ + memsys3UnlinkFromList(i, &mem3.aiHash[hash]); + return memsys3Checkout(i, nBlock); + } + } + } + + /* STEP 2: + ** Try to satisfy the allocation by carving a piece off of the end + ** of the key chunk. This step usually works if step 1 fails. + */ + if( mem3.szKeyBlk>=nBlock ){ + return memsys3FromKeyBlk(nBlock); + } + + + /* STEP 3: + ** Loop through the entire memory pool. Coalesce adjacent free + ** chunks. Recompute the key chunk as the largest free chunk. + ** Then try again to satisfy the allocation by carving a piece off + ** of the end of the key chunk. This step happens very + ** rarely (we hope!) + */ + for(toFree=nBlock*16; toFree<(mem3.nPool*16); toFree *= 2){ + memsys3OutOfMemory(toFree); + if( mem3.iKeyBlk ){ + memsys3Link(mem3.iKeyBlk); + mem3.iKeyBlk = 0; + mem3.szKeyBlk = 0; + } + for(i=0; i=nBlock ){ + return memsys3FromKeyBlk(nBlock); + } + } + } + + /* If none of the above worked, then we fail. */ + return 0; +} + +/* +** Free an outstanding memory allocation. +** +** This function assumes that the necessary mutexes, if any, are +** already held by the caller. Hence "Unsafe". +*/ +static void memsys3FreeUnsafe(void *pOld){ + Mem3Block *p = (Mem3Block*)pOld; + int i; + u32 size, x; + assert( sqlite3_mutex_held(mem3.mutex) ); + assert( p>mem3.aPool && p<&mem3.aPool[mem3.nPool] ); + i = p - mem3.aPool; + assert( (mem3.aPool[i-1].u.hdr.size4x&1)==1 ); + size = mem3.aPool[i-1].u.hdr.size4x/4; + assert( i+size<=mem3.nPool+1 ); + mem3.aPool[i-1].u.hdr.size4x &= ~1; + mem3.aPool[i+size-1].u.hdr.prevSize = size; + mem3.aPool[i+size-1].u.hdr.size4x &= ~2; + memsys3Link(i); + + /* Try to expand the key using the newly freed chunk */ + if( mem3.iKeyBlk ){ + while( (mem3.aPool[mem3.iKeyBlk-1].u.hdr.size4x&2)==0 ){ + size = mem3.aPool[mem3.iKeyBlk-1].u.hdr.prevSize; + mem3.iKeyBlk -= size; + mem3.szKeyBlk += size; + memsys3Unlink(mem3.iKeyBlk); + x = mem3.aPool[mem3.iKeyBlk-1].u.hdr.size4x & 2; + mem3.aPool[mem3.iKeyBlk-1].u.hdr.size4x = mem3.szKeyBlk*4 | x; + mem3.aPool[mem3.iKeyBlk+mem3.szKeyBlk-1].u.hdr.prevSize = mem3.szKeyBlk; + } + x = mem3.aPool[mem3.iKeyBlk-1].u.hdr.size4x & 2; + while( (mem3.aPool[mem3.iKeyBlk+mem3.szKeyBlk-1].u.hdr.size4x&1)==0 ){ + memsys3Unlink(mem3.iKeyBlk+mem3.szKeyBlk); + mem3.szKeyBlk += mem3.aPool[mem3.iKeyBlk+mem3.szKeyBlk-1].u.hdr.size4x/4; + mem3.aPool[mem3.iKeyBlk-1].u.hdr.size4x = mem3.szKeyBlk*4 | x; + mem3.aPool[mem3.iKeyBlk+mem3.szKeyBlk-1].u.hdr.prevSize = mem3.szKeyBlk; + } + } +} + +/* +** Return the size of an outstanding allocation, in bytes. The +** size returned omits the 8-byte header overhead. This only +** works for chunks that are currently checked out. +*/ +static int memsys3Size(void *p){ + Mem3Block *pBlock; + assert( p!=0 ); + pBlock = (Mem3Block*)p; + assert( (pBlock[-1].u.hdr.size4x&1)!=0 ); + return (pBlock[-1].u.hdr.size4x&~3)*2 - 4; +} + +/* +** Round up a request size to the next valid allocation size. +*/ +static int memsys3Roundup(int n){ + if( n<=12 ){ + return 12; + }else{ + return ((n+11)&~7) - 4; + } +} + +/* +** Allocate nBytes of memory. +*/ +static void *memsys3Malloc(int nBytes){ + sqlite3_int64 *p; + assert( nBytes>0 ); /* malloc.c filters out 0 byte requests */ + memsys3Enter(); + p = memsys3MallocUnsafe(nBytes); + memsys3Leave(); + return (void*)p; +} + +/* +** Free memory. +*/ +static void memsys3Free(void *pPrior){ + assert( pPrior ); + memsys3Enter(); + memsys3FreeUnsafe(pPrior); + memsys3Leave(); +} + +/* +** Change the size of an existing memory allocation +*/ +static void *memsys3Realloc(void *pPrior, int nBytes){ + int nOld; + void *p; + if( pPrior==0 ){ + return sqlite3_malloc(nBytes); + } + if( nBytes<=0 ){ + sqlite3_free(pPrior); + return 0; + } + nOld = memsys3Size(pPrior); + if( nBytes<=nOld && nBytes>=nOld-128 ){ + return pPrior; + } + memsys3Enter(); + p = memsys3MallocUnsafe(nBytes); + if( p ){ + if( nOld>1)!=(size&1) ){ + fprintf(out, "%p tail checkout bit is incorrect\n", &mem3.aPool[i]); + assert( 0 ); + break; + } + if( size&1 ){ + fprintf(out, "%p %6d bytes checked out\n", &mem3.aPool[i], (size/4)*8-8); + }else{ + fprintf(out, "%p %6d bytes free%s\n", &mem3.aPool[i], (size/4)*8-8, + i==mem3.iKeyBlk ? " **key**" : ""); + } + } + for(i=0; i0; j=mem3.aPool[j].u.list.next){ + fprintf(out, " %p(%d)", &mem3.aPool[j], + (mem3.aPool[j-1].u.hdr.size4x/4)*8-8); + } + fprintf(out, "\n"); + } + for(i=0; i0; j=mem3.aPool[j].u.list.next){ + fprintf(out, " %p(%d)", &mem3.aPool[j], + (mem3.aPool[j-1].u.hdr.size4x/4)*8-8); + } + fprintf(out, "\n"); + } + fprintf(out, "key=%d\n", mem3.iKeyBlk); + fprintf(out, "nowUsed=%d\n", mem3.nPool*8 - mem3.szKeyBlk*8); + fprintf(out, "mxUsed=%d\n", mem3.nPool*8 - mem3.mnKeyBlk*8); + sqlite3_mutex_leave(mem3.mutex); + if( out==stdout ){ + fflush(stdout); + }else{ + fclose(out); + } +#else + UNUSED_PARAMETER(zFilename); +#endif +} + +/* +** This routine is the only routine in this file with external +** linkage. +** +** Populate the low-level memory allocation function pointers in +** sqlite3GlobalConfig.m with pointers to the routines in this file. The +** arguments specify the block of memory to manage. +** +** This routine is only called by sqlite3_config(), and therefore +** is not required to be threadsafe (it is not). +*/ +SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys3(void){ + static const sqlite3_mem_methods mempoolMethods = { + memsys3Malloc, + memsys3Free, + memsys3Realloc, + memsys3Size, + memsys3Roundup, + memsys3Init, + memsys3Shutdown, + 0 + }; + return &mempoolMethods; +} + +#endif /* SQLITE_ENABLE_MEMSYS3 */ + +/************** End of mem3.c ************************************************/ +/************** Begin file mem5.c ********************************************/ +/* +** 2007 October 14 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement a memory +** allocation subsystem for use by SQLite. +** +** This version of the memory allocation subsystem omits all +** use of malloc(). The application gives SQLite a block of memory +** before calling sqlite3_initialize() from which allocations +** are made and returned by the xMalloc() and xRealloc() +** implementations. Once sqlite3_initialize() has been called, +** the amount of memory available to SQLite is fixed and cannot +** be changed. +** +** This version of the memory allocation subsystem is included +** in the build only if SQLITE_ENABLE_MEMSYS5 is defined. +** +** This memory allocator uses the following algorithm: +** +** 1. All memory allocation sizes are rounded up to a power of 2. +** +** 2. If two adjacent free blocks are the halves of a larger block, +** then the two blocks are coalesced into the single larger block. +** +** 3. New memory is allocated from the first available free block. +** +** This algorithm is described in: J. M. Robson. "Bounds for Some Functions +** Concerning Dynamic Storage Allocation". Journal of the Association for +** Computing Machinery, Volume 21, Number 8, July 1974, pages 491-499. +** +** Let n be the size of the largest allocation divided by the minimum +** allocation size (after rounding all sizes up to a power of 2.) Let M +** be the maximum amount of memory ever outstanding at one time. Let +** N be the total amount of memory available for allocation. Robson +** proved that this memory allocator will never breakdown due to +** fragmentation as long as the following constraint holds: +** +** N >= M*(1 + log2(n)/2) - n + 1 +** +** The sqlite3_status() logic tracks the maximum values of n and M so +** that an application can, at any time, verify this constraint. +*/ +/* #include "sqliteInt.h" */ + +/* +** This version of the memory allocator is used only when +** SQLITE_ENABLE_MEMSYS5 is defined. +*/ +#ifdef SQLITE_ENABLE_MEMSYS5 + +/* +** A minimum allocation is an instance of the following structure. +** Larger allocations are an array of these structures where the +** size of the array is a power of 2. +** +** The size of this object must be a power of two. That fact is +** verified in memsys5Init(). +*/ +typedef struct Mem5Link Mem5Link; +struct Mem5Link { + int next; /* Index of next free chunk */ + int prev; /* Index of previous free chunk */ +}; + +/* +** Maximum size of any allocation is ((1<=0 && i=0 && iLogsize<=LOGMAX ); + assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize ); + + next = MEM5LINK(i)->next; + prev = MEM5LINK(i)->prev; + if( prev<0 ){ + mem5.aiFreelist[iLogsize] = next; + }else{ + MEM5LINK(prev)->next = next; + } + if( next>=0 ){ + MEM5LINK(next)->prev = prev; + } +} + +/* +** Link the chunk at mem5.aPool[i] so that is on the iLogsize +** free list. +*/ +static void memsys5Link(int i, int iLogsize){ + int x; + assert( sqlite3_mutex_held(mem5.mutex) ); + assert( i>=0 && i=0 && iLogsize<=LOGMAX ); + assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize ); + + x = MEM5LINK(i)->next = mem5.aiFreelist[iLogsize]; + MEM5LINK(i)->prev = -1; + if( x>=0 ){ + assert( xprev = i; + } + mem5.aiFreelist[iLogsize] = i; +} + +/* +** Obtain or release the mutex needed to access global data structures. +*/ +static void memsys5Enter(void){ + sqlite3_mutex_enter(mem5.mutex); +} +static void memsys5Leave(void){ + sqlite3_mutex_leave(mem5.mutex); +} + +/* +** Return the size of an outstanding allocation, in bytes. +** This only works for chunks that are currently checked out. +*/ +static int memsys5Size(void *p){ + int iSize, i; + assert( p!=0 ); + i = (int)(((u8 *)p-mem5.zPool)/mem5.szAtom); + assert( i>=0 && i0 ); + + /* No more than 1GiB per allocation */ + if( nByte > 0x40000000 ) return 0; + +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + /* Keep track of the maximum allocation request. Even unfulfilled + ** requests are counted */ + if( (u32)nByte>mem5.maxRequest ){ + mem5.maxRequest = nByte; + } +#endif + + + /* Round nByte up to the next valid power of two */ + for(iFullSz=mem5.szAtom,iLogsize=0; iFullSzLOGMAX ){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes", nByte); + return 0; + } + i = mem5.aiFreelist[iBin]; + memsys5Unlink(i, iBin); + while( iBin>iLogsize ){ + int newSize; + + iBin--; + newSize = 1 << iBin; + mem5.aCtrl[i+newSize] = CTRL_FREE | iBin; + memsys5Link(i+newSize, iBin); + } + mem5.aCtrl[i] = iLogsize; + +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + /* Update allocator performance statistics. */ + mem5.nAlloc++; + mem5.totalAlloc += iFullSz; + mem5.totalExcess += iFullSz - nByte; + mem5.currentCount++; + mem5.currentOut += iFullSz; + if( mem5.maxCount=0 && iBlock0 ); + assert( mem5.currentOut>=(size*mem5.szAtom) ); + mem5.currentCount--; + mem5.currentOut -= size*mem5.szAtom; + assert( mem5.currentOut>0 || mem5.currentCount==0 ); + assert( mem5.currentCount>0 || mem5.currentOut==0 ); +#endif + + mem5.aCtrl[iBlock] = CTRL_FREE | iLogsize; + while( ALWAYS(iLogsize>iLogsize) & 1 ){ + iBuddy = iBlock - size; + assert( iBuddy>=0 ); + }else{ + iBuddy = iBlock + size; + if( iBuddy>=mem5.nBlock ) break; + } + if( mem5.aCtrl[iBuddy]!=(CTRL_FREE | iLogsize) ) break; + memsys5Unlink(iBuddy, iLogsize); + iLogsize++; + if( iBuddy0 ){ + memsys5Enter(); + p = memsys5MallocUnsafe(nBytes); + memsys5Leave(); + } + return (void*)p; +} + +/* +** Free memory. +** +** The outer layer memory allocator prevents this routine from +** being called with pPrior==0. +*/ +static void memsys5Free(void *pPrior){ + assert( pPrior!=0 ); + memsys5Enter(); + memsys5FreeUnsafe(pPrior); + memsys5Leave(); +} + +/* +** Change the size of an existing memory allocation. +** +** The outer layer memory allocator prevents this routine from +** being called with pPrior==0. +** +** nBytes is always a value obtained from a prior call to +** memsys5Round(). Hence nBytes is always a non-negative power +** of two. If nBytes==0 that means that an oversize allocation +** (an allocation larger than 0x40000000) was requested and this +** routine should return 0 without freeing pPrior. +*/ +static void *memsys5Realloc(void *pPrior, int nBytes){ + int nOld; + void *p; + assert( pPrior!=0 ); + assert( (nBytes&(nBytes-1))==0 ); /* EV: R-46199-30249 */ + assert( nBytes>=0 ); + if( nBytes==0 ){ + return 0; + } + nOld = memsys5Size(pPrior); + if( nBytes<=nOld ){ + return pPrior; + } + p = memsys5Malloc(nBytes); + if( p ){ + memcpy(p, pPrior, nOld); + memsys5Free(pPrior); + } + return p; +} + +/* +** Round up a request size to the next valid allocation size. If +** the allocation is too large to be handled by this allocation system, +** return 0. +** +** All allocations must be a power of two and must be expressed by a +** 32-bit signed integer. Hence the largest allocation is 0x40000000 +** or 1073741824 bytes. +*/ +static int memsys5Roundup(int n){ + int iFullSz; + if( n<=mem5.szAtom*2 ){ + if( n<=mem5.szAtom ) return mem5.szAtom; + return mem5.szAtom*2; + } + if( n>0x10000000 ){ + if( n>0x40000000 ) return 0; + if( n>0x20000000 ) return 0x40000000; + return 0x20000000; + } + for(iFullSz=mem5.szAtom*8; iFullSz=(i64)n ) return iFullSz/2; + return iFullSz; +} + +/* +** Return the ceiling of the logarithm base 2 of iValue. +** +** Examples: memsys5Log(1) -> 0 +** memsys5Log(2) -> 1 +** memsys5Log(4) -> 2 +** memsys5Log(5) -> 3 +** memsys5Log(8) -> 3 +** memsys5Log(9) -> 4 +*/ +static int memsys5Log(int iValue){ + int iLog; + for(iLog=0; (iLog<(int)((sizeof(int)*8)-1)) && (1<mem5.szAtom ){ + mem5.szAtom = mem5.szAtom << 1; + } + + mem5.nBlock = (nByte / (mem5.szAtom+sizeof(u8))); + mem5.zPool = zByte; + mem5.aCtrl = (u8 *)&mem5.zPool[mem5.nBlock*mem5.szAtom]; + + for(ii=0; ii<=LOGMAX; ii++){ + mem5.aiFreelist[ii] = -1; + } + + iOffset = 0; + for(ii=LOGMAX; ii>=0; ii--){ + int nAlloc = (1<mem5.nBlock); + } + + /* If a mutex is required for normal operation, allocate one */ + if( sqlite3GlobalConfig.bMemstat==0 ){ + mem5.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM); + } + + return SQLITE_OK; +} + +/* +** Deinitialize this module. +*/ +static void memsys5Shutdown(void *NotUsed){ + UNUSED_PARAMETER(NotUsed); + mem5.mutex = 0; + return; +} + +#ifdef SQLITE_TEST +/* +** Open the file indicated and write a log of all unfreed memory +** allocations into that log. +*/ +SQLITE_PRIVATE void sqlite3Memsys5Dump(const char *zFilename){ + FILE *out; + int i, j, n; + int nMinLog; + + if( zFilename==0 || zFilename[0]==0 ){ + out = stdout; + }else{ + out = fopen(zFilename, "w"); + if( out==0 ){ + fprintf(stderr, "** Unable to output memory debug output log: %s **\n", + zFilename); + return; + } + } + memsys5Enter(); + nMinLog = memsys5Log(mem5.szAtom); + for(i=0; i<=LOGMAX && i+nMinLog<32; i++){ + for(n=0, j=mem5.aiFreelist[i]; j>=0; j = MEM5LINK(j)->next, n++){} + fprintf(out, "freelist items of size %d: %d\n", mem5.szAtom << i, n); + } + fprintf(out, "mem5.nAlloc = %llu\n", mem5.nAlloc); + fprintf(out, "mem5.totalAlloc = %llu\n", mem5.totalAlloc); + fprintf(out, "mem5.totalExcess = %llu\n", mem5.totalExcess); + fprintf(out, "mem5.currentOut = %u\n", mem5.currentOut); + fprintf(out, "mem5.currentCount = %u\n", mem5.currentCount); + fprintf(out, "mem5.maxOut = %u\n", mem5.maxOut); + fprintf(out, "mem5.maxCount = %u\n", mem5.maxCount); + fprintf(out, "mem5.maxRequest = %u\n", mem5.maxRequest); + memsys5Leave(); + if( out==stdout ){ + fflush(stdout); + }else{ + fclose(out); + } +} +#endif + +/* +** This routine is the only routine in this file with external +** linkage. It returns a pointer to a static sqlite3_mem_methods +** struct populated with the memsys5 methods. +*/ +SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys5(void){ + static const sqlite3_mem_methods memsys5Methods = { + memsys5Malloc, + memsys5Free, + memsys5Realloc, + memsys5Size, + memsys5Roundup, + memsys5Init, + memsys5Shutdown, + 0 + }; + return &memsys5Methods; +} + +#endif /* SQLITE_ENABLE_MEMSYS5 */ + +/************** End of mem5.c ************************************************/ +/************** Begin file mutex.c *******************************************/ +/* +** 2007 August 14 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement mutexes. +** +** This file contains code that is common across all mutex implementations. +*/ +/* #include "sqliteInt.h" */ + +#if defined(SQLITE_DEBUG) && !defined(SQLITE_MUTEX_OMIT) +/* +** For debugging purposes, record when the mutex subsystem is initialized +** and uninitialized so that we can assert() if there is an attempt to +** allocate a mutex while the system is uninitialized. +*/ +static SQLITE_WSD int mutexIsInit = 0; +#endif /* SQLITE_DEBUG && !defined(SQLITE_MUTEX_OMIT) */ + + +#ifndef SQLITE_MUTEX_OMIT + +#ifdef SQLITE_ENABLE_MULTITHREADED_CHECKS +/* +** This block (enclosed by SQLITE_ENABLE_MULTITHREADED_CHECKS) contains +** the implementation of a wrapper around the system default mutex +** implementation (sqlite3DefaultMutex()). +** +** Most calls are passed directly through to the underlying default +** mutex implementation. Except, if a mutex is configured by calling +** sqlite3MutexWarnOnContention() on it, then if contention is ever +** encountered within xMutexEnter() a warning is emitted via sqlite3_log(). +** +** This type of mutex is used as the database handle mutex when testing +** apps that usually use SQLITE_CONFIG_MULTITHREAD mode. +*/ + +/* +** Type for all mutexes used when SQLITE_ENABLE_MULTITHREADED_CHECKS +** is defined. Variable CheckMutex.mutex is a pointer to the real mutex +** allocated by the system mutex implementation. Variable iType is usually set +** to the type of mutex requested - SQLITE_MUTEX_RECURSIVE, SQLITE_MUTEX_FAST +** or one of the static mutex identifiers. Or, if this is a recursive mutex +** that has been configured using sqlite3MutexWarnOnContention(), it is +** set to SQLITE_MUTEX_WARNONCONTENTION. +*/ +typedef struct CheckMutex CheckMutex; +struct CheckMutex { + int iType; + sqlite3_mutex *mutex; +}; + +#define SQLITE_MUTEX_WARNONCONTENTION (-1) + +/* +** Pointer to real mutex methods object used by the CheckMutex +** implementation. Set by checkMutexInit(). +*/ +static SQLITE_WSD const sqlite3_mutex_methods *pGlobalMutexMethods; + +#ifdef SQLITE_DEBUG +static int checkMutexHeld(sqlite3_mutex *p){ + return pGlobalMutexMethods->xMutexHeld(((CheckMutex*)p)->mutex); +} +static int checkMutexNotheld(sqlite3_mutex *p){ + return pGlobalMutexMethods->xMutexNotheld(((CheckMutex*)p)->mutex); +} +#endif + +/* +** Initialize and deinitialize the mutex subsystem. +*/ +static int checkMutexInit(void){ + pGlobalMutexMethods = sqlite3DefaultMutex(); + return SQLITE_OK; +} +static int checkMutexEnd(void){ + pGlobalMutexMethods = 0; + return SQLITE_OK; +} + +/* +** Allocate a mutex. +*/ +static sqlite3_mutex *checkMutexAlloc(int iType){ + static CheckMutex staticMutexes[] = { + {2, 0}, {3, 0}, {4, 0}, {5, 0}, + {6, 0}, {7, 0}, {8, 0}, {9, 0}, + {10, 0}, {11, 0}, {12, 0}, {13, 0} + }; + CheckMutex *p = 0; + + assert( SQLITE_MUTEX_RECURSIVE==1 && SQLITE_MUTEX_FAST==0 ); + if( iType<2 ){ + p = sqlite3MallocZero(sizeof(CheckMutex)); + if( p==0 ) return 0; + p->iType = iType; + }else{ +#ifdef SQLITE_ENABLE_API_ARMOR + if( iType-2>=ArraySize(staticMutexes) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + p = &staticMutexes[iType-2]; + } + + if( p->mutex==0 ){ + p->mutex = pGlobalMutexMethods->xMutexAlloc(iType); + if( p->mutex==0 ){ + if( iType<2 ){ + sqlite3_free(p); + } + p = 0; + } + } + + return (sqlite3_mutex*)p; +} + +/* +** Free a mutex. +*/ +static void checkMutexFree(sqlite3_mutex *p){ + assert( SQLITE_MUTEX_RECURSIVE<2 ); + assert( SQLITE_MUTEX_FAST<2 ); + assert( SQLITE_MUTEX_WARNONCONTENTION<2 ); + +#if SQLITE_ENABLE_API_ARMOR + if( ((CheckMutex*)p)->iType<2 ) +#endif + { + CheckMutex *pCheck = (CheckMutex*)p; + pGlobalMutexMethods->xMutexFree(pCheck->mutex); + sqlite3_free(pCheck); + } +#ifdef SQLITE_ENABLE_API_ARMOR + else{ + (void)SQLITE_MISUSE_BKPT; + } +#endif +} + +/* +** Enter the mutex. +*/ +static void checkMutexEnter(sqlite3_mutex *p){ + CheckMutex *pCheck = (CheckMutex*)p; + if( pCheck->iType==SQLITE_MUTEX_WARNONCONTENTION ){ + if( SQLITE_OK==pGlobalMutexMethods->xMutexTry(pCheck->mutex) ){ + return; + } + sqlite3_log(SQLITE_MISUSE, + "illegal multi-threaded access to database connection" + ); + } + pGlobalMutexMethods->xMutexEnter(pCheck->mutex); +} + +/* +** Enter the mutex (do not block). +*/ +static int checkMutexTry(sqlite3_mutex *p){ + CheckMutex *pCheck = (CheckMutex*)p; + return pGlobalMutexMethods->xMutexTry(pCheck->mutex); +} + +/* +** Leave the mutex. +*/ +static void checkMutexLeave(sqlite3_mutex *p){ + CheckMutex *pCheck = (CheckMutex*)p; + pGlobalMutexMethods->xMutexLeave(pCheck->mutex); +} + +sqlite3_mutex_methods const *multiThreadedCheckMutex(void){ + static const sqlite3_mutex_methods sMutex = { + checkMutexInit, + checkMutexEnd, + checkMutexAlloc, + checkMutexFree, + checkMutexEnter, + checkMutexTry, + checkMutexLeave, +#ifdef SQLITE_DEBUG + checkMutexHeld, + checkMutexNotheld +#else + 0, + 0 +#endif + }; + return &sMutex; +} + +/* +** Mark the SQLITE_MUTEX_RECURSIVE mutex passed as the only argument as +** one on which there should be no contention. +*/ +SQLITE_PRIVATE void sqlite3MutexWarnOnContention(sqlite3_mutex *p){ + if( sqlite3GlobalConfig.mutex.xMutexAlloc==checkMutexAlloc ){ + CheckMutex *pCheck = (CheckMutex*)p; + assert( pCheck->iType==SQLITE_MUTEX_RECURSIVE ); + pCheck->iType = SQLITE_MUTEX_WARNONCONTENTION; + } +} +#endif /* ifdef SQLITE_ENABLE_MULTITHREADED_CHECKS */ + +/* +** Initialize the mutex system. +*/ +SQLITE_PRIVATE int sqlite3MutexInit(void){ + int rc = SQLITE_OK; + if( !sqlite3GlobalConfig.mutex.xMutexAlloc ){ + /* If the xMutexAlloc method has not been set, then the user did not + ** install a mutex implementation via sqlite3_config() prior to + ** sqlite3_initialize() being called. This block copies pointers to + ** the default implementation into the sqlite3GlobalConfig structure. + */ + sqlite3_mutex_methods const *pFrom; + sqlite3_mutex_methods *pTo = &sqlite3GlobalConfig.mutex; + + if( sqlite3GlobalConfig.bCoreMutex ){ +#ifdef SQLITE_ENABLE_MULTITHREADED_CHECKS + pFrom = multiThreadedCheckMutex(); +#else + pFrom = sqlite3DefaultMutex(); +#endif + }else{ + pFrom = sqlite3NoopMutex(); + } + pTo->xMutexInit = pFrom->xMutexInit; + pTo->xMutexEnd = pFrom->xMutexEnd; + pTo->xMutexFree = pFrom->xMutexFree; + pTo->xMutexEnter = pFrom->xMutexEnter; + pTo->xMutexTry = pFrom->xMutexTry; + pTo->xMutexLeave = pFrom->xMutexLeave; + pTo->xMutexHeld = pFrom->xMutexHeld; + pTo->xMutexNotheld = pFrom->xMutexNotheld; + sqlite3MemoryBarrier(); + pTo->xMutexAlloc = pFrom->xMutexAlloc; + } + assert( sqlite3GlobalConfig.mutex.xMutexInit ); + rc = sqlite3GlobalConfig.mutex.xMutexInit(); + +#ifdef SQLITE_DEBUG + GLOBAL(int, mutexIsInit) = 1; +#endif + + sqlite3MemoryBarrier(); + return rc; +} + +/* +** Shutdown the mutex system. This call frees resources allocated by +** sqlite3MutexInit(). +*/ +SQLITE_PRIVATE int sqlite3MutexEnd(void){ + int rc = SQLITE_OK; + if( sqlite3GlobalConfig.mutex.xMutexEnd ){ + rc = sqlite3GlobalConfig.mutex.xMutexEnd(); + } + +#ifdef SQLITE_DEBUG + GLOBAL(int, mutexIsInit) = 0; +#endif + + return rc; +} + +/* +** Retrieve a pointer to a static mutex or allocate a new dynamic one. +*/ +SQLITE_API sqlite3_mutex *sqlite3_mutex_alloc(int id){ +#ifndef SQLITE_OMIT_AUTOINIT + if( id<=SQLITE_MUTEX_RECURSIVE && sqlite3_initialize() ) return 0; + if( id>SQLITE_MUTEX_RECURSIVE && sqlite3MutexInit() ) return 0; +#endif + assert( sqlite3GlobalConfig.mutex.xMutexAlloc ); + return sqlite3GlobalConfig.mutex.xMutexAlloc(id); +} + +SQLITE_PRIVATE sqlite3_mutex *sqlite3MutexAlloc(int id){ + if( !sqlite3GlobalConfig.bCoreMutex ){ + return 0; + } + assert( GLOBAL(int, mutexIsInit) ); + assert( sqlite3GlobalConfig.mutex.xMutexAlloc ); + return sqlite3GlobalConfig.mutex.xMutexAlloc(id); +} + +/* +** Free a dynamic mutex. +*/ +SQLITE_API void sqlite3_mutex_free(sqlite3_mutex *p){ + if( p ){ + assert( sqlite3GlobalConfig.mutex.xMutexFree ); + sqlite3GlobalConfig.mutex.xMutexFree(p); + } +} + +/* +** Obtain the mutex p. If some other thread already has the mutex, block +** until it can be obtained. +*/ +SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex *p){ + if( p ){ + assert( sqlite3GlobalConfig.mutex.xMutexEnter ); + sqlite3GlobalConfig.mutex.xMutexEnter(p); + } +} + +/* +** Obtain the mutex p. If successful, return SQLITE_OK. Otherwise, if another +** thread holds the mutex and it cannot be obtained, return SQLITE_BUSY. +*/ +SQLITE_API int sqlite3_mutex_try(sqlite3_mutex *p){ + int rc = SQLITE_OK; + if( p ){ + assert( sqlite3GlobalConfig.mutex.xMutexTry ); + return sqlite3GlobalConfig.mutex.xMutexTry(p); + } + return rc; +} + +/* +** The sqlite3_mutex_leave() routine exits a mutex that was previously +** entered by the same thread. The behavior is undefined if the mutex +** is not currently entered. If a NULL pointer is passed as an argument +** this function is a no-op. +*/ +SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex *p){ + if( p ){ + assert( sqlite3GlobalConfig.mutex.xMutexLeave ); + sqlite3GlobalConfig.mutex.xMutexLeave(p); + } +} + +#ifndef NDEBUG +/* +** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are +** intended for use inside assert() statements. +*/ +SQLITE_API int sqlite3_mutex_held(sqlite3_mutex *p){ + assert( p==0 || sqlite3GlobalConfig.mutex.xMutexHeld ); + return p==0 || sqlite3GlobalConfig.mutex.xMutexHeld(p); +} +SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex *p){ + assert( p==0 || sqlite3GlobalConfig.mutex.xMutexNotheld ); + return p==0 || sqlite3GlobalConfig.mutex.xMutexNotheld(p); +} +#endif + +#endif /* !defined(SQLITE_MUTEX_OMIT) */ + +/************** End of mutex.c ***********************************************/ +/************** Begin file mutex_noop.c **************************************/ +/* +** 2008 October 07 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement mutexes. +** +** This implementation in this file does not provide any mutual +** exclusion and is thus suitable for use only in applications +** that use SQLite in a single thread. The routines defined +** here are place-holders. Applications can substitute working +** mutex routines at start-time using the +** +** sqlite3_config(SQLITE_CONFIG_MUTEX,...) +** +** interface. +** +** If compiled with SQLITE_DEBUG, then additional logic is inserted +** that does error checking on mutexes to make sure they are being +** called correctly. +*/ +/* #include "sqliteInt.h" */ + +#ifndef SQLITE_MUTEX_OMIT + +#ifndef SQLITE_DEBUG +/* +** Stub routines for all mutex methods. +** +** This routines provide no mutual exclusion or error checking. +*/ +static int noopMutexInit(void){ return SQLITE_OK; } +static int noopMutexEnd(void){ return SQLITE_OK; } +static sqlite3_mutex *noopMutexAlloc(int id){ + UNUSED_PARAMETER(id); + return (sqlite3_mutex*)8; +} +static void noopMutexFree(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; } +static void noopMutexEnter(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; } +static int noopMutexTry(sqlite3_mutex *p){ + UNUSED_PARAMETER(p); + return SQLITE_OK; +} +static void noopMutexLeave(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; } + +SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3NoopMutex(void){ + static const sqlite3_mutex_methods sMutex = { + noopMutexInit, + noopMutexEnd, + noopMutexAlloc, + noopMutexFree, + noopMutexEnter, + noopMutexTry, + noopMutexLeave, + + 0, + 0, + }; + + return &sMutex; +} +#endif /* !SQLITE_DEBUG */ + +#ifdef SQLITE_DEBUG +/* +** In this implementation, error checking is provided for testing +** and debugging purposes. The mutexes still do not provide any +** mutual exclusion. +*/ + +/* +** The mutex object +*/ +typedef struct sqlite3_debug_mutex { + int id; /* The mutex type */ + int cnt; /* Number of entries without a matching leave */ +} sqlite3_debug_mutex; + +/* +** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are +** intended for use inside assert() statements. +*/ +static int debugMutexHeld(sqlite3_mutex *pX){ + sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; + return p==0 || p->cnt>0; +} +static int debugMutexNotheld(sqlite3_mutex *pX){ + sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; + return p==0 || p->cnt==0; +} + +/* +** Initialize and deinitialize the mutex subsystem. +*/ +static int debugMutexInit(void){ return SQLITE_OK; } +static int debugMutexEnd(void){ return SQLITE_OK; } + +/* +** The sqlite3_mutex_alloc() routine allocates a new +** mutex and returns a pointer to it. If it returns NULL +** that means that a mutex could not be allocated. +*/ +static sqlite3_mutex *debugMutexAlloc(int id){ + static sqlite3_debug_mutex aStatic[SQLITE_MUTEX_STATIC_VFS3 - 1]; + sqlite3_debug_mutex *pNew = 0; + switch( id ){ + case SQLITE_MUTEX_FAST: + case SQLITE_MUTEX_RECURSIVE: { + pNew = sqlite3Malloc(sizeof(*pNew)); + if( pNew ){ + pNew->id = id; + pNew->cnt = 0; + } + break; + } + default: { +#ifdef SQLITE_ENABLE_API_ARMOR + if( id-2<0 || id-2>=ArraySize(aStatic) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + pNew = &aStatic[id-2]; + pNew->id = id; + break; + } + } + return (sqlite3_mutex*)pNew; +} + +/* +** This routine deallocates a previously allocated mutex. +*/ +static void debugMutexFree(sqlite3_mutex *pX){ + sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; + assert( p->cnt==0 ); + if( p->id==SQLITE_MUTEX_RECURSIVE || p->id==SQLITE_MUTEX_FAST ){ + sqlite3_free(p); + }else{ +#ifdef SQLITE_ENABLE_API_ARMOR + (void)SQLITE_MISUSE_BKPT; +#endif + } +} + +/* +** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt +** to enter a mutex. If another thread is already within the mutex, +** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return +** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK +** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can +** be entered multiple times by the same thread. In such cases the, +** mutex must be exited an equal number of times before another thread +** can enter. If the same thread tries to enter any other kind of mutex +** more than once, the behavior is undefined. +*/ +static void debugMutexEnter(sqlite3_mutex *pX){ + sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; + assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); + p->cnt++; +} +static int debugMutexTry(sqlite3_mutex *pX){ + sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; + assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); + p->cnt++; + return SQLITE_OK; +} + +/* +** The sqlite3_mutex_leave() routine exits a mutex that was +** previously entered by the same thread. The behavior +** is undefined if the mutex is not currently entered or +** is not currently allocated. SQLite will never do either. +*/ +static void debugMutexLeave(sqlite3_mutex *pX){ + sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX; + assert( debugMutexHeld(pX) ); + p->cnt--; + assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) ); +} + +SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3NoopMutex(void){ + static const sqlite3_mutex_methods sMutex = { + debugMutexInit, + debugMutexEnd, + debugMutexAlloc, + debugMutexFree, + debugMutexEnter, + debugMutexTry, + debugMutexLeave, + + debugMutexHeld, + debugMutexNotheld + }; + + return &sMutex; +} +#endif /* SQLITE_DEBUG */ + +/* +** If compiled with SQLITE_MUTEX_NOOP, then the no-op mutex implementation +** is used regardless of the run-time threadsafety setting. +*/ +#ifdef SQLITE_MUTEX_NOOP +SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){ + return sqlite3NoopMutex(); +} +#endif /* defined(SQLITE_MUTEX_NOOP) */ +#endif /* !defined(SQLITE_MUTEX_OMIT) */ + +/************** End of mutex_noop.c ******************************************/ +/************** Begin file mutex_unix.c **************************************/ +/* +** 2007 August 28 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement mutexes for pthreads +*/ +/* #include "sqliteInt.h" */ + +/* +** The code in this file is only used if we are compiling threadsafe +** under unix with pthreads. +** +** Note that this implementation requires a version of pthreads that +** supports recursive mutexes. +*/ +#ifdef SQLITE_MUTEX_PTHREADS + +#include + +/* +** The sqlite3_mutex.id, sqlite3_mutex.nRef, and sqlite3_mutex.owner fields +** are necessary under two condidtions: (1) Debug builds and (2) using +** home-grown mutexes. Encapsulate these conditions into a single #define. +*/ +#if defined(SQLITE_DEBUG) || defined(SQLITE_HOMEGROWN_RECURSIVE_MUTEX) +# define SQLITE_MUTEX_NREF 1 +#else +# define SQLITE_MUTEX_NREF 0 +#endif + +/* +** Each recursive mutex is an instance of the following structure. +*/ +struct sqlite3_mutex { + pthread_mutex_t mutex; /* Mutex controlling the lock */ +#if SQLITE_MUTEX_NREF || defined(SQLITE_ENABLE_API_ARMOR) + int id; /* Mutex type */ +#endif +#if SQLITE_MUTEX_NREF + volatile int nRef; /* Number of entrances */ + volatile pthread_t owner; /* Thread that is within this mutex */ + int trace; /* True to trace changes */ +#endif +}; +#if SQLITE_MUTEX_NREF +# define SQLITE3_MUTEX_INITIALIZER(id) \ + {PTHREAD_MUTEX_INITIALIZER,id,0,(pthread_t)0,0} +#elif defined(SQLITE_ENABLE_API_ARMOR) +# define SQLITE3_MUTEX_INITIALIZER(id) { PTHREAD_MUTEX_INITIALIZER, id } +#else +#define SQLITE3_MUTEX_INITIALIZER(id) { PTHREAD_MUTEX_INITIALIZER } +#endif + +/* +** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are +** intended for use only inside assert() statements. On some platforms, +** there might be race conditions that can cause these routines to +** deliver incorrect results. In particular, if pthread_equal() is +** not an atomic operation, then these routines might delivery +** incorrect results. On most platforms, pthread_equal() is a +** comparison of two integers and is therefore atomic. But we are +** told that HPUX is not such a platform. If so, then these routines +** will not always work correctly on HPUX. +** +** On those platforms where pthread_equal() is not atomic, SQLite +** should be compiled without -DSQLITE_DEBUG and with -DNDEBUG to +** make sure no assert() statements are evaluated and hence these +** routines are never called. +*/ +#if !defined(NDEBUG) || defined(SQLITE_DEBUG) +static int pthreadMutexHeld(sqlite3_mutex *p){ + return (p->nRef!=0 && pthread_equal(p->owner, pthread_self())); +} +static int pthreadMutexNotheld(sqlite3_mutex *p){ + return p->nRef==0 || pthread_equal(p->owner, pthread_self())==0; +} +#endif + +/* +** Try to provide a memory barrier operation, needed for initialization +** and also for the implementation of xShmBarrier in the VFS in cases +** where SQLite is compiled without mutexes. +*/ +SQLITE_PRIVATE void sqlite3MemoryBarrier(void){ +#if defined(SQLITE_MEMORY_BARRIER) + SQLITE_MEMORY_BARRIER; +#elif defined(__GNUC__) && GCC_VERSION>=4001000 + __sync_synchronize(); +#endif +} + +/* +** Initialize and deinitialize the mutex subsystem. +*/ +static int pthreadMutexInit(void){ return SQLITE_OK; } +static int pthreadMutexEnd(void){ return SQLITE_OK; } + +/* +** The sqlite3_mutex_alloc() routine allocates a new +** mutex and returns a pointer to it. If it returns NULL +** that means that a mutex could not be allocated. SQLite +** will unwind its stack and return an error. The argument +** to sqlite3_mutex_alloc() is one of these integer constants: +** +**
      +**
    • SQLITE_MUTEX_FAST +**
    • SQLITE_MUTEX_RECURSIVE +**
    • SQLITE_MUTEX_STATIC_MAIN +**
    • SQLITE_MUTEX_STATIC_MEM +**
    • SQLITE_MUTEX_STATIC_OPEN +**
    • SQLITE_MUTEX_STATIC_PRNG +**
    • SQLITE_MUTEX_STATIC_LRU +**
    • SQLITE_MUTEX_STATIC_PMEM +**
    • SQLITE_MUTEX_STATIC_APP1 +**
    • SQLITE_MUTEX_STATIC_APP2 +**
    • SQLITE_MUTEX_STATIC_APP3 +**
    • SQLITE_MUTEX_STATIC_VFS1 +**
    • SQLITE_MUTEX_STATIC_VFS2 +**
    • SQLITE_MUTEX_STATIC_VFS3 +**
    +** +** The first two constants cause sqlite3_mutex_alloc() to create +** a new mutex. The new mutex is recursive when SQLITE_MUTEX_RECURSIVE +** is used but not necessarily so when SQLITE_MUTEX_FAST is used. +** The mutex implementation does not need to make a distinction +** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does +** not want to. But SQLite will only request a recursive mutex in +** cases where it really needs one. If a faster non-recursive mutex +** implementation is available on the host platform, the mutex subsystem +** might return such a mutex in response to SQLITE_MUTEX_FAST. +** +** The other allowed parameters to sqlite3_mutex_alloc() each return +** a pointer to a static preexisting mutex. Six static mutexes are +** used by the current version of SQLite. Future versions of SQLite +** may add additional static mutexes. Static mutexes are for internal +** use by SQLite only. Applications that use SQLite mutexes should +** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or +** SQLITE_MUTEX_RECURSIVE. +** +** Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST +** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc() +** returns a different mutex on every call. But for the static +** mutex types, the same mutex is returned on every call that has +** the same type number. +*/ +static sqlite3_mutex *pthreadMutexAlloc(int iType){ + static sqlite3_mutex staticMutexes[] = { + SQLITE3_MUTEX_INITIALIZER(2), + SQLITE3_MUTEX_INITIALIZER(3), + SQLITE3_MUTEX_INITIALIZER(4), + SQLITE3_MUTEX_INITIALIZER(5), + SQLITE3_MUTEX_INITIALIZER(6), + SQLITE3_MUTEX_INITIALIZER(7), + SQLITE3_MUTEX_INITIALIZER(8), + SQLITE3_MUTEX_INITIALIZER(9), + SQLITE3_MUTEX_INITIALIZER(10), + SQLITE3_MUTEX_INITIALIZER(11), + SQLITE3_MUTEX_INITIALIZER(12), + SQLITE3_MUTEX_INITIALIZER(13) + }; + sqlite3_mutex *p; + switch( iType ){ + case SQLITE_MUTEX_RECURSIVE: { + p = sqlite3MallocZero( sizeof(*p) ); + if( p ){ +#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX + /* If recursive mutexes are not available, we will have to + ** build our own. See below. */ + pthread_mutex_init(&p->mutex, 0); +#else + /* Use a recursive mutex if it is available */ + pthread_mutexattr_t recursiveAttr; + pthread_mutexattr_init(&recursiveAttr); + pthread_mutexattr_settype(&recursiveAttr, PTHREAD_MUTEX_RECURSIVE); + pthread_mutex_init(&p->mutex, &recursiveAttr); + pthread_mutexattr_destroy(&recursiveAttr); +#endif +#if SQLITE_MUTEX_NREF || defined(SQLITE_ENABLE_API_ARMOR) + p->id = SQLITE_MUTEX_RECURSIVE; +#endif + } + break; + } + case SQLITE_MUTEX_FAST: { + p = sqlite3MallocZero( sizeof(*p) ); + if( p ){ + pthread_mutex_init(&p->mutex, 0); +#if SQLITE_MUTEX_NREF || defined(SQLITE_ENABLE_API_ARMOR) + p->id = SQLITE_MUTEX_FAST; +#endif + } + break; + } + default: { +#ifdef SQLITE_ENABLE_API_ARMOR + if( iType-2<0 || iType-2>=ArraySize(staticMutexes) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + p = &staticMutexes[iType-2]; + break; + } + } +#if SQLITE_MUTEX_NREF || defined(SQLITE_ENABLE_API_ARMOR) + assert( p==0 || p->id==iType ); +#endif + return p; +} + + +/* +** This routine deallocates a previously +** allocated mutex. SQLite is careful to deallocate every +** mutex that it allocates. +*/ +static void pthreadMutexFree(sqlite3_mutex *p){ + assert( p->nRef==0 ); +#if SQLITE_ENABLE_API_ARMOR + if( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE ) +#endif + { + pthread_mutex_destroy(&p->mutex); + sqlite3_free(p); + } +#ifdef SQLITE_ENABLE_API_ARMOR + else{ + (void)SQLITE_MISUSE_BKPT; + } +#endif +} + +/* +** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt +** to enter a mutex. If another thread is already within the mutex, +** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return +** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK +** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can +** be entered multiple times by the same thread. In such cases the, +** mutex must be exited an equal number of times before another thread +** can enter. If the same thread tries to enter any other kind of mutex +** more than once, the behavior is undefined. +*/ +static void pthreadMutexEnter(sqlite3_mutex *p){ + assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) ); + +#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX + /* If recursive mutexes are not available, then we have to grow + ** our own. This implementation assumes that pthread_equal() + ** is atomic - that it cannot be deceived into thinking self + ** and p->owner are equal if p->owner changes between two values + ** that are not equal to self while the comparison is taking place. + ** This implementation also assumes a coherent cache - that + ** separate processes cannot read different values from the same + ** address at the same time. If either of these two conditions + ** are not met, then the mutexes will fail and problems will result. + */ + { + pthread_t self = pthread_self(); + if( p->nRef>0 && pthread_equal(p->owner, self) ){ + p->nRef++; + }else{ + pthread_mutex_lock(&p->mutex); + assert( p->nRef==0 ); + p->owner = self; + p->nRef = 1; + } + } +#else + /* Use the built-in recursive mutexes if they are available. + */ + pthread_mutex_lock(&p->mutex); +#if SQLITE_MUTEX_NREF + assert( p->nRef>0 || p->owner==0 ); + p->owner = pthread_self(); + p->nRef++; +#endif +#endif + +#ifdef SQLITE_DEBUG + if( p->trace ){ + printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef); + } +#endif +} +static int pthreadMutexTry(sqlite3_mutex *p){ + int rc; + assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) ); + +#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX + /* If recursive mutexes are not available, then we have to grow + ** our own. This implementation assumes that pthread_equal() + ** is atomic - that it cannot be deceived into thinking self + ** and p->owner are equal if p->owner changes between two values + ** that are not equal to self while the comparison is taking place. + ** This implementation also assumes a coherent cache - that + ** separate processes cannot read different values from the same + ** address at the same time. If either of these two conditions + ** are not met, then the mutexes will fail and problems will result. + */ + { + pthread_t self = pthread_self(); + if( p->nRef>0 && pthread_equal(p->owner, self) ){ + p->nRef++; + rc = SQLITE_OK; + }else if( pthread_mutex_trylock(&p->mutex)==0 ){ + assert( p->nRef==0 ); + p->owner = self; + p->nRef = 1; + rc = SQLITE_OK; + }else{ + rc = SQLITE_BUSY; + } + } +#else + /* Use the built-in recursive mutexes if they are available. + */ + if( pthread_mutex_trylock(&p->mutex)==0 ){ +#if SQLITE_MUTEX_NREF + p->owner = pthread_self(); + p->nRef++; +#endif + rc = SQLITE_OK; + }else{ + rc = SQLITE_BUSY; + } +#endif + +#ifdef SQLITE_DEBUG + if( rc==SQLITE_OK && p->trace ){ + printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef); + } +#endif + return rc; +} + +/* +** The sqlite3_mutex_leave() routine exits a mutex that was +** previously entered by the same thread. The behavior +** is undefined if the mutex is not currently entered or +** is not currently allocated. SQLite will never do either. +*/ +static void pthreadMutexLeave(sqlite3_mutex *p){ + assert( pthreadMutexHeld(p) ); +#if SQLITE_MUTEX_NREF + p->nRef--; + if( p->nRef==0 ) p->owner = 0; +#endif + assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE ); + +#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX + if( p->nRef==0 ){ + pthread_mutex_unlock(&p->mutex); + } +#else + pthread_mutex_unlock(&p->mutex); +#endif + +#ifdef SQLITE_DEBUG + if( p->trace ){ + printf("leave mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef); + } +#endif +} + +SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){ + static const sqlite3_mutex_methods sMutex = { + pthreadMutexInit, + pthreadMutexEnd, + pthreadMutexAlloc, + pthreadMutexFree, + pthreadMutexEnter, + pthreadMutexTry, + pthreadMutexLeave, +#ifdef SQLITE_DEBUG + pthreadMutexHeld, + pthreadMutexNotheld +#else + 0, + 0 +#endif + }; + + return &sMutex; +} + +#endif /* SQLITE_MUTEX_PTHREADS */ + +/************** End of mutex_unix.c ******************************************/ +/************** Begin file mutex_w32.c ***************************************/ +/* +** 2007 August 14 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement mutexes for Win32. +*/ +/* #include "sqliteInt.h" */ + +#if SQLITE_OS_WIN +/* +** Include code that is common to all os_*.c files +*/ +/* #include "os_common.h" */ + +/* +** Include the header file for the Windows VFS. +*/ +/************** Include os_win.h in the middle of mutex_w32.c ****************/ +/************** Begin file os_win.h ******************************************/ +/* +** 2013 November 25 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains code that is specific to Windows. +*/ +#ifndef SQLITE_OS_WIN_H +#define SQLITE_OS_WIN_H + +/* +** Include the primary Windows SDK header file. +*/ +#include "windows.h" + +#ifdef __CYGWIN__ +# include +# include /* amalgamator: dontcache */ +#endif + +/* +** Determine if we are dealing with Windows NT. +** +** We ought to be able to determine if we are compiling for Windows 9x or +** Windows NT using the _WIN32_WINNT macro as follows: +** +** #if defined(_WIN32_WINNT) +** # define SQLITE_OS_WINNT 1 +** #else +** # define SQLITE_OS_WINNT 0 +** #endif +** +** However, Visual Studio 2005 does not set _WIN32_WINNT by default, as +** it ought to, so the above test does not work. We'll just assume that +** everything is Windows NT unless the programmer explicitly says otherwise +** by setting SQLITE_OS_WINNT to 0. +*/ +#if SQLITE_OS_WIN && !defined(SQLITE_OS_WINNT) +# define SQLITE_OS_WINNT 1 +#endif + +/* +** Determine if we are dealing with Windows CE - which has a much reduced +** API. +*/ +#if defined(_WIN32_WCE) +# define SQLITE_OS_WINCE 1 +#else +# define SQLITE_OS_WINCE 0 +#endif + +/* +** Determine if we are dealing with WinRT, which provides only a subset of +** the full Win32 API. +*/ +#if !defined(SQLITE_OS_WINRT) +# define SQLITE_OS_WINRT 0 +#endif + +/* +** For WinCE, some API function parameters do not appear to be declared as +** volatile. +*/ +#if SQLITE_OS_WINCE +# define SQLITE_WIN32_VOLATILE +#else +# define SQLITE_WIN32_VOLATILE volatile +#endif + +/* +** For some Windows sub-platforms, the _beginthreadex() / _endthreadex() +** functions are not available (e.g. those not using MSVC, Cygwin, etc). +*/ +#if SQLITE_OS_WIN && !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && \ + SQLITE_THREADSAFE>0 && !defined(__CYGWIN__) +# define SQLITE_OS_WIN_THREADS 1 +#else +# define SQLITE_OS_WIN_THREADS 0 +#endif + +#endif /* SQLITE_OS_WIN_H */ + +/************** End of os_win.h **********************************************/ +/************** Continuing where we left off in mutex_w32.c ******************/ +#endif + +/* +** The code in this file is only used if we are compiling multithreaded +** on a Win32 system. +*/ +#ifdef SQLITE_MUTEX_W32 + +/* +** Each recursive mutex is an instance of the following structure. +*/ +struct sqlite3_mutex { + CRITICAL_SECTION mutex; /* Mutex controlling the lock */ + int id; /* Mutex type */ +#ifdef SQLITE_DEBUG + volatile int nRef; /* Number of enterances */ + volatile DWORD owner; /* Thread holding this mutex */ + volatile LONG trace; /* True to trace changes */ +#endif +}; + +/* +** These are the initializer values used when declaring a "static" mutex +** on Win32. It should be noted that all mutexes require initialization +** on the Win32 platform. +*/ +#define SQLITE_W32_MUTEX_INITIALIZER { 0 } + +#ifdef SQLITE_DEBUG +#define SQLITE3_MUTEX_INITIALIZER(id) { SQLITE_W32_MUTEX_INITIALIZER, id, \ + 0L, (DWORD)0, 0 } +#else +#define SQLITE3_MUTEX_INITIALIZER(id) { SQLITE_W32_MUTEX_INITIALIZER, id } +#endif + +#ifdef SQLITE_DEBUG +/* +** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are +** intended for use only inside assert() statements. +*/ +static int winMutexHeld(sqlite3_mutex *p){ + return p->nRef!=0 && p->owner==GetCurrentThreadId(); +} + +static int winMutexNotheld2(sqlite3_mutex *p, DWORD tid){ + return p->nRef==0 || p->owner!=tid; +} + +static int winMutexNotheld(sqlite3_mutex *p){ + DWORD tid = GetCurrentThreadId(); + return winMutexNotheld2(p, tid); +} +#endif + +/* +** Try to provide a memory barrier operation, needed for initialization +** and also for the xShmBarrier method of the VFS in cases when SQLite is +** compiled without mutexes (SQLITE_THREADSAFE=0). +*/ +SQLITE_PRIVATE void sqlite3MemoryBarrier(void){ +#if defined(SQLITE_MEMORY_BARRIER) + SQLITE_MEMORY_BARRIER; +#elif defined(__GNUC__) + __sync_synchronize(); +#elif MSVC_VERSION>=1300 + _ReadWriteBarrier(); +#elif defined(MemoryBarrier) + MemoryBarrier(); +#endif +} + +/* +** Initialize and deinitialize the mutex subsystem. +*/ +static sqlite3_mutex winMutex_staticMutexes[] = { + SQLITE3_MUTEX_INITIALIZER(2), + SQLITE3_MUTEX_INITIALIZER(3), + SQLITE3_MUTEX_INITIALIZER(4), + SQLITE3_MUTEX_INITIALIZER(5), + SQLITE3_MUTEX_INITIALIZER(6), + SQLITE3_MUTEX_INITIALIZER(7), + SQLITE3_MUTEX_INITIALIZER(8), + SQLITE3_MUTEX_INITIALIZER(9), + SQLITE3_MUTEX_INITIALIZER(10), + SQLITE3_MUTEX_INITIALIZER(11), + SQLITE3_MUTEX_INITIALIZER(12), + SQLITE3_MUTEX_INITIALIZER(13) +}; + +static int winMutex_isInit = 0; +static int winMutex_isNt = -1; /* <0 means "need to query" */ + +/* As the winMutexInit() and winMutexEnd() functions are called as part +** of the sqlite3_initialize() and sqlite3_shutdown() processing, the +** "interlocked" magic used here is probably not strictly necessary. +*/ +static LONG SQLITE_WIN32_VOLATILE winMutex_lock = 0; + +SQLITE_API int sqlite3_win32_is_nt(void); /* os_win.c */ +SQLITE_API void sqlite3_win32_sleep(DWORD milliseconds); /* os_win.c */ + +static int winMutexInit(void){ + /* The first to increment to 1 does actual initialization */ + if( InterlockedCompareExchange(&winMutex_lock, 1, 0)==0 ){ + int i; + for(i=0; i +**
  • SQLITE_MUTEX_FAST +**
  • SQLITE_MUTEX_RECURSIVE +**
  • SQLITE_MUTEX_STATIC_MAIN +**
  • SQLITE_MUTEX_STATIC_MEM +**
  • SQLITE_MUTEX_STATIC_OPEN +**
  • SQLITE_MUTEX_STATIC_PRNG +**
  • SQLITE_MUTEX_STATIC_LRU +**
  • SQLITE_MUTEX_STATIC_PMEM +**
  • SQLITE_MUTEX_STATIC_APP1 +**
  • SQLITE_MUTEX_STATIC_APP2 +**
  • SQLITE_MUTEX_STATIC_APP3 +**
  • SQLITE_MUTEX_STATIC_VFS1 +**
  • SQLITE_MUTEX_STATIC_VFS2 +**
  • SQLITE_MUTEX_STATIC_VFS3 +**
+** +** The first two constants cause sqlite3_mutex_alloc() to create +** a new mutex. The new mutex is recursive when SQLITE_MUTEX_RECURSIVE +** is used but not necessarily so when SQLITE_MUTEX_FAST is used. +** The mutex implementation does not need to make a distinction +** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does +** not want to. But SQLite will only request a recursive mutex in +** cases where it really needs one. If a faster non-recursive mutex +** implementation is available on the host platform, the mutex subsystem +** might return such a mutex in response to SQLITE_MUTEX_FAST. +** +** The other allowed parameters to sqlite3_mutex_alloc() each return +** a pointer to a static preexisting mutex. Six static mutexes are +** used by the current version of SQLite. Future versions of SQLite +** may add additional static mutexes. Static mutexes are for internal +** use by SQLite only. Applications that use SQLite mutexes should +** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or +** SQLITE_MUTEX_RECURSIVE. +** +** Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST +** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc() +** returns a different mutex on every call. But for the static +** mutex types, the same mutex is returned on every call that has +** the same type number. +*/ +static sqlite3_mutex *winMutexAlloc(int iType){ + sqlite3_mutex *p; + + switch( iType ){ + case SQLITE_MUTEX_FAST: + case SQLITE_MUTEX_RECURSIVE: { + p = sqlite3MallocZero( sizeof(*p) ); + if( p ){ + p->id = iType; +#ifdef SQLITE_DEBUG +#ifdef SQLITE_WIN32_MUTEX_TRACE_DYNAMIC + p->trace = 1; +#endif +#endif +#if SQLITE_OS_WINRT + InitializeCriticalSectionEx(&p->mutex, 0, 0); +#else + InitializeCriticalSection(&p->mutex); +#endif + } + break; + } + default: { +#ifdef SQLITE_ENABLE_API_ARMOR + if( iType-2<0 || iType-2>=ArraySize(winMutex_staticMutexes) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + p = &winMutex_staticMutexes[iType-2]; +#ifdef SQLITE_DEBUG +#ifdef SQLITE_WIN32_MUTEX_TRACE_STATIC + InterlockedCompareExchange(&p->trace, 1, 0); +#endif +#endif + break; + } + } + assert( p==0 || p->id==iType ); + return p; +} + + +/* +** This routine deallocates a previously +** allocated mutex. SQLite is careful to deallocate every +** mutex that it allocates. +*/ +static void winMutexFree(sqlite3_mutex *p){ + assert( p ); + assert( p->nRef==0 && p->owner==0 ); + if( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE ){ + DeleteCriticalSection(&p->mutex); + sqlite3_free(p); + }else{ +#ifdef SQLITE_ENABLE_API_ARMOR + (void)SQLITE_MISUSE_BKPT; +#endif + } +} + +/* +** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt +** to enter a mutex. If another thread is already within the mutex, +** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return +** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK +** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can +** be entered multiple times by the same thread. In such cases the, +** mutex must be exited an equal number of times before another thread +** can enter. If the same thread tries to enter any other kind of mutex +** more than once, the behavior is undefined. +*/ +static void winMutexEnter(sqlite3_mutex *p){ +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + DWORD tid = GetCurrentThreadId(); +#endif +#ifdef SQLITE_DEBUG + assert( p ); + assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) ); +#else + assert( p ); +#endif + assert( winMutex_isInit==1 ); + EnterCriticalSection(&p->mutex); +#ifdef SQLITE_DEBUG + assert( p->nRef>0 || p->owner==0 ); + p->owner = tid; + p->nRef++; + if( p->trace ){ + OSTRACE(("ENTER-MUTEX tid=%lu, mutex(%d)=%p (%d), nRef=%d\n", + tid, p->id, p, p->trace, p->nRef)); + } +#endif +} + +static int winMutexTry(sqlite3_mutex *p){ +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + DWORD tid = GetCurrentThreadId(); +#endif + int rc = SQLITE_BUSY; + assert( p ); + assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) ); + /* + ** The sqlite3_mutex_try() routine is very rarely used, and when it + ** is used it is merely an optimization. So it is OK for it to always + ** fail. + ** + ** The TryEnterCriticalSection() interface is only available on WinNT. + ** And some windows compilers complain if you try to use it without + ** first doing some #defines that prevent SQLite from building on Win98. + ** For that reason, we will omit this optimization for now. See + ** ticket #2685. + */ +#if defined(_WIN32_WINNT) && _WIN32_WINNT >= 0x0400 + assert( winMutex_isInit==1 ); + assert( winMutex_isNt>=-1 && winMutex_isNt<=1 ); + if( winMutex_isNt<0 ){ + winMutex_isNt = sqlite3_win32_is_nt(); + } + assert( winMutex_isNt==0 || winMutex_isNt==1 ); + if( winMutex_isNt && TryEnterCriticalSection(&p->mutex) ){ +#ifdef SQLITE_DEBUG + p->owner = tid; + p->nRef++; +#endif + rc = SQLITE_OK; + } +#else + UNUSED_PARAMETER(p); +#endif +#ifdef SQLITE_DEBUG + if( p->trace ){ + OSTRACE(("TRY-MUTEX tid=%lu, mutex(%d)=%p (%d), owner=%lu, nRef=%d, rc=%s\n", + tid, p->id, p, p->trace, p->owner, p->nRef, sqlite3ErrName(rc))); + } +#endif + return rc; +} + +/* +** The sqlite3_mutex_leave() routine exits a mutex that was +** previously entered by the same thread. The behavior +** is undefined if the mutex is not currently entered or +** is not currently allocated. SQLite will never do either. +*/ +static void winMutexLeave(sqlite3_mutex *p){ +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + DWORD tid = GetCurrentThreadId(); +#endif + assert( p ); +#ifdef SQLITE_DEBUG + assert( p->nRef>0 ); + assert( p->owner==tid ); + p->nRef--; + if( p->nRef==0 ) p->owner = 0; + assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE ); +#endif + assert( winMutex_isInit==1 ); + LeaveCriticalSection(&p->mutex); +#ifdef SQLITE_DEBUG + if( p->trace ){ + OSTRACE(("LEAVE-MUTEX tid=%lu, mutex(%d)=%p (%d), nRef=%d\n", + tid, p->id, p, p->trace, p->nRef)); + } +#endif +} + +SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){ + static const sqlite3_mutex_methods sMutex = { + winMutexInit, + winMutexEnd, + winMutexAlloc, + winMutexFree, + winMutexEnter, + winMutexTry, + winMutexLeave, +#ifdef SQLITE_DEBUG + winMutexHeld, + winMutexNotheld +#else + 0, + 0 +#endif + }; + return &sMutex; +} + +#endif /* SQLITE_MUTEX_W32 */ + +/************** End of mutex_w32.c *******************************************/ +/************** Begin file malloc.c ******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** Memory allocation functions used throughout sqlite. +*/ +/* #include "sqliteInt.h" */ +/* #include */ + +/* +** Attempt to release up to n bytes of non-essential memory currently +** held by SQLite. An example of non-essential memory is memory used to +** cache database pages that are not currently in use. +*/ +SQLITE_API int sqlite3_release_memory(int n){ +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + return sqlite3PcacheReleaseMemory(n); +#else + /* IMPLEMENTATION-OF: R-34391-24921 The sqlite3_release_memory() routine + ** is a no-op returning zero if SQLite is not compiled with + ** SQLITE_ENABLE_MEMORY_MANAGEMENT. */ + UNUSED_PARAMETER(n); + return 0; +#endif +} + +/* +** Default value of the hard heap limit. 0 means "no limit". +*/ +#ifndef SQLITE_MAX_MEMORY +# define SQLITE_MAX_MEMORY 0 +#endif + +/* +** State information local to the memory allocation subsystem. +*/ +static SQLITE_WSD struct Mem0Global { + sqlite3_mutex *mutex; /* Mutex to serialize access */ + sqlite3_int64 alarmThreshold; /* The soft heap limit */ + sqlite3_int64 hardLimit; /* The hard upper bound on memory */ + + /* + ** True if heap is nearly "full" where "full" is defined by the + ** sqlite3_soft_heap_limit() setting. + */ + int nearlyFull; +} mem0 = { 0, SQLITE_MAX_MEMORY, SQLITE_MAX_MEMORY, 0 }; + +#define mem0 GLOBAL(struct Mem0Global, mem0) + +/* +** Return the memory allocator mutex. sqlite3_status() needs it. +*/ +SQLITE_PRIVATE sqlite3_mutex *sqlite3MallocMutex(void){ + return mem0.mutex; +} + +#ifndef SQLITE_OMIT_DEPRECATED +/* +** Deprecated external interface. It used to set an alarm callback +** that was invoked when memory usage grew too large. Now it is a +** no-op. +*/ +SQLITE_API int sqlite3_memory_alarm( + void(*xCallback)(void *pArg, sqlite3_int64 used,int N), + void *pArg, + sqlite3_int64 iThreshold +){ + (void)xCallback; + (void)pArg; + (void)iThreshold; + return SQLITE_OK; +} +#endif + +/* +** Set the soft heap-size limit for the library. An argument of +** zero disables the limit. A negative argument is a no-op used to +** obtain the return value. +** +** The return value is the value of the heap limit just before this +** interface was called. +** +** If the hard heap limit is enabled, then the soft heap limit cannot +** be disabled nor raised above the hard heap limit. +*/ +SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 n){ + sqlite3_int64 priorLimit; + sqlite3_int64 excess; + sqlite3_int64 nUsed; +#ifndef SQLITE_OMIT_AUTOINIT + int rc = sqlite3_initialize(); + if( rc ) return -1; +#endif + sqlite3_mutex_enter(mem0.mutex); + priorLimit = mem0.alarmThreshold; + if( n<0 ){ + sqlite3_mutex_leave(mem0.mutex); + return priorLimit; + } + if( mem0.hardLimit>0 && (n>mem0.hardLimit || n==0) ){ + n = mem0.hardLimit; + } + mem0.alarmThreshold = n; + nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED); + AtomicStore(&mem0.nearlyFull, n>0 && n<=nUsed); + sqlite3_mutex_leave(mem0.mutex); + excess = sqlite3_memory_used() - n; + if( excess>0 ) sqlite3_release_memory((int)(excess & 0x7fffffff)); + return priorLimit; +} +SQLITE_API void sqlite3_soft_heap_limit(int n){ + if( n<0 ) n = 0; + sqlite3_soft_heap_limit64(n); +} + +/* +** Set the hard heap-size limit for the library. An argument of zero +** disables the hard heap limit. A negative argument is a no-op used +** to obtain the return value without affecting the hard heap limit. +** +** The return value is the value of the hard heap limit just prior to +** calling this interface. +** +** Setting the hard heap limit will also activate the soft heap limit +** and constrain the soft heap limit to be no more than the hard heap +** limit. +*/ +SQLITE_API sqlite3_int64 sqlite3_hard_heap_limit64(sqlite3_int64 n){ + sqlite3_int64 priorLimit; +#ifndef SQLITE_OMIT_AUTOINIT + int rc = sqlite3_initialize(); + if( rc ) return -1; +#endif + sqlite3_mutex_enter(mem0.mutex); + priorLimit = mem0.hardLimit; + if( n>=0 ){ + mem0.hardLimit = n; + if( n0 ); + + /* In Firefox (circa 2017-02-08), xRoundup() is remapped to an internal + ** implementation of malloc_good_size(), which must be called in debug + ** mode and specifically when the DMD "Dark Matter Detector" is enabled + ** or else a crash results. Hence, do not attempt to optimize out the + ** following xRoundup() call. */ + nFull = sqlite3GlobalConfig.m.xRoundup(n); + + sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, n); + if( mem0.alarmThreshold>0 ){ + sqlite3_int64 nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED); + if( nUsed >= mem0.alarmThreshold - nFull ){ + AtomicStore(&mem0.nearlyFull, 1); + sqlite3MallocAlarm(nFull); + if( mem0.hardLimit ){ + nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED); + if( nUsed >= mem0.hardLimit - nFull ){ + *pp = 0; + return; + } + } + }else{ + AtomicStore(&mem0.nearlyFull, 0); + } + } + p = sqlite3GlobalConfig.m.xMalloc(nFull); +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + if( p==0 && mem0.alarmThreshold>0 ){ + sqlite3MallocAlarm(nFull); + p = sqlite3GlobalConfig.m.xMalloc(nFull); + } +#endif + if( p ){ + nFull = sqlite3MallocSize(p); + sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nFull); + sqlite3StatusUp(SQLITE_STATUS_MALLOC_COUNT, 1); + } + *pp = p; +} + +/* +** Maximum size of any single memory allocation. +** +** This is not a limit on the total amount of memory used. This is +** a limit on the size parameter to sqlite3_malloc() and sqlite3_realloc(). +** +** The upper bound is slightly less than 2GiB: 0x7ffffeff == 2,147,483,391 +** This provides a 256-byte safety margin for defense against 32-bit +** signed integer overflow bugs when computing memory allocation sizes. +** Paranoid applications might want to reduce the maximum allocation size +** further for an even larger safety margin. 0x3fffffff or 0x0fffffff +** or even smaller would be reasonable upper bounds on the size of a memory +** allocations for most applications. +*/ +#ifndef SQLITE_MAX_ALLOCATION_SIZE +# define SQLITE_MAX_ALLOCATION_SIZE 2147483391 +#endif +#if SQLITE_MAX_ALLOCATION_SIZE>2147483391 +# error Maximum size for SQLITE_MAX_ALLOCATION_SIZE is 2147483391 +#endif + +/* +** Allocate memory. This routine is like sqlite3_malloc() except that it +** assumes the memory subsystem has already been initialized. +*/ +SQLITE_PRIVATE void *sqlite3Malloc(u64 n){ + void *p; + if( n==0 || n>SQLITE_MAX_ALLOCATION_SIZE ){ + p = 0; + }else if( sqlite3GlobalConfig.bMemstat ){ + sqlite3_mutex_enter(mem0.mutex); + mallocWithAlarm((int)n, &p); + sqlite3_mutex_leave(mem0.mutex); + }else{ + p = sqlite3GlobalConfig.m.xMalloc((int)n); + } + assert( EIGHT_BYTE_ALIGNMENT(p) ); /* IMP: R-11148-40995 */ + return p; +} + +/* +** This version of the memory allocation is for use by the application. +** First make sure the memory subsystem is initialized, then do the +** allocation. +*/ +SQLITE_API void *sqlite3_malloc(int n){ +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + return n<=0 ? 0 : sqlite3Malloc(n); +} +SQLITE_API void *sqlite3_malloc64(sqlite3_uint64 n){ +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + return sqlite3Malloc(n); +} + +/* +** TRUE if p is a lookaside memory allocation from db +*/ +#ifndef SQLITE_OMIT_LOOKASIDE +static int isLookaside(sqlite3 *db, const void *p){ + return SQLITE_WITHIN(p, db->lookaside.pStart, db->lookaside.pTrueEnd); +} +#else +#define isLookaside(A,B) 0 +#endif + +/* +** Return the size of a memory allocation previously obtained from +** sqlite3Malloc() or sqlite3_malloc(). +*/ +SQLITE_PRIVATE int sqlite3MallocSize(const void *p){ + assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); + return sqlite3GlobalConfig.m.xSize((void*)p); +} +static int lookasideMallocSize(sqlite3 *db, const void *p){ +#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE + return plookaside.pMiddle ? db->lookaside.szTrue : LOOKASIDE_SMALL; +#else + return db->lookaside.szTrue; +#endif +} +SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3 *db, const void *p){ + assert( p!=0 ); +#ifdef SQLITE_DEBUG + if( db==0 ){ + assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) ); + assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); + }else if( !isLookaside(db,p) ){ + assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); + assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); + } +#endif + if( db ){ + if( ((uptr)p)<(uptr)(db->lookaside.pTrueEnd) ){ +#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE + if( ((uptr)p)>=(uptr)(db->lookaside.pMiddle) ){ + assert( sqlite3_mutex_held(db->mutex) ); + return LOOKASIDE_SMALL; + } +#endif + if( ((uptr)p)>=(uptr)(db->lookaside.pStart) ){ + assert( sqlite3_mutex_held(db->mutex) ); + return db->lookaside.szTrue; + } + } + } + return sqlite3GlobalConfig.m.xSize((void*)p); +} +SQLITE_API sqlite3_uint64 sqlite3_msize(void *p){ + assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) ); + assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); + return p ? sqlite3GlobalConfig.m.xSize(p) : 0; +} + +/* +** Free memory previously obtained from sqlite3Malloc(). +*/ +SQLITE_API void sqlite3_free(void *p){ + if( p==0 ) return; /* IMP: R-49053-54554 */ + assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) ); + assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) ); + if( sqlite3GlobalConfig.bMemstat ){ + sqlite3_mutex_enter(mem0.mutex); + sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED, sqlite3MallocSize(p)); + sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT, 1); + sqlite3GlobalConfig.m.xFree(p); + sqlite3_mutex_leave(mem0.mutex); + }else{ + sqlite3GlobalConfig.m.xFree(p); + } +} + +/* +** Add the size of memory allocation "p" to the count in +** *db->pnBytesFreed. +*/ +static SQLITE_NOINLINE void measureAllocationSize(sqlite3 *db, void *p){ + *db->pnBytesFreed += sqlite3DbMallocSize(db,p); +} + +/* +** Free memory that might be associated with a particular database +** connection. Calling sqlite3DbFree(D,X) for X==0 is a harmless no-op. +** The sqlite3DbFreeNN(D,X) version requires that X be non-NULL. +*/ +SQLITE_PRIVATE void sqlite3DbFreeNN(sqlite3 *db, void *p){ + assert( db==0 || sqlite3_mutex_held(db->mutex) ); + assert( p!=0 ); + if( db ){ + if( ((uptr)p)<(uptr)(db->lookaside.pEnd) ){ +#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE + if( ((uptr)p)>=(uptr)(db->lookaside.pMiddle) ){ + LookasideSlot *pBuf = (LookasideSlot*)p; + assert( db->pnBytesFreed==0 ); +#ifdef SQLITE_DEBUG + memset(p, 0xaa, LOOKASIDE_SMALL); /* Trash freed content */ +#endif + pBuf->pNext = db->lookaside.pSmallFree; + db->lookaside.pSmallFree = pBuf; + return; + } +#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */ + if( ((uptr)p)>=(uptr)(db->lookaside.pStart) ){ + LookasideSlot *pBuf = (LookasideSlot*)p; + assert( db->pnBytesFreed==0 ); +#ifdef SQLITE_DEBUG + memset(p, 0xaa, db->lookaside.szTrue); /* Trash freed content */ +#endif + pBuf->pNext = db->lookaside.pFree; + db->lookaside.pFree = pBuf; + return; + } + } + if( db->pnBytesFreed ){ + measureAllocationSize(db, p); + return; + } + } + assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); + assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); + assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) ); + sqlite3MemdebugSetType(p, MEMTYPE_HEAP); + sqlite3_free(p); +} +SQLITE_PRIVATE void sqlite3DbNNFreeNN(sqlite3 *db, void *p){ + assert( db!=0 ); + assert( sqlite3_mutex_held(db->mutex) ); + assert( p!=0 ); + if( ((uptr)p)<(uptr)(db->lookaside.pEnd) ){ +#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE + if( ((uptr)p)>=(uptr)(db->lookaside.pMiddle) ){ + LookasideSlot *pBuf = (LookasideSlot*)p; + assert( db->pnBytesFreed==0 ); +#ifdef SQLITE_DEBUG + memset(p, 0xaa, LOOKASIDE_SMALL); /* Trash freed content */ +#endif + pBuf->pNext = db->lookaside.pSmallFree; + db->lookaside.pSmallFree = pBuf; + return; + } +#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */ + if( ((uptr)p)>=(uptr)(db->lookaside.pStart) ){ + LookasideSlot *pBuf = (LookasideSlot*)p; + assert( db->pnBytesFreed==0 ); +#ifdef SQLITE_DEBUG + memset(p, 0xaa, db->lookaside.szTrue); /* Trash freed content */ +#endif + pBuf->pNext = db->lookaside.pFree; + db->lookaside.pFree = pBuf; + return; + } + } + if( db->pnBytesFreed ){ + measureAllocationSize(db, p); + return; + } + assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); + assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); + sqlite3MemdebugSetType(p, MEMTYPE_HEAP); + sqlite3_free(p); +} +SQLITE_PRIVATE void sqlite3DbFree(sqlite3 *db, void *p){ + assert( db==0 || sqlite3_mutex_held(db->mutex) ); + if( p ) sqlite3DbFreeNN(db, p); +} + +/* +** Change the size of an existing memory allocation +*/ +SQLITE_PRIVATE void *sqlite3Realloc(void *pOld, u64 nBytes){ + int nOld, nNew, nDiff; + void *pNew; + assert( sqlite3MemdebugHasType(pOld, MEMTYPE_HEAP) ); + assert( sqlite3MemdebugNoType(pOld, (u8)~MEMTYPE_HEAP) ); + if( pOld==0 ){ + return sqlite3Malloc(nBytes); /* IMP: R-04300-56712 */ + } + if( nBytes==0 ){ + sqlite3_free(pOld); /* IMP: R-26507-47431 */ + return 0; + } + if( nBytes>=0x7fffff00 ){ + /* The 0x7ffff00 limit term is explained in comments on sqlite3Malloc() */ + return 0; + } + nOld = sqlite3MallocSize(pOld); + /* IMPLEMENTATION-OF: R-46199-30249 SQLite guarantees that the second + ** argument to xRealloc is always a value returned by a prior call to + ** xRoundup. */ + nNew = sqlite3GlobalConfig.m.xRoundup((int)nBytes); + if( nOld==nNew ){ + pNew = pOld; + }else if( sqlite3GlobalConfig.bMemstat ){ + sqlite3_int64 nUsed; + sqlite3_mutex_enter(mem0.mutex); + sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, (int)nBytes); + nDiff = nNew - nOld; + if( nDiff>0 && (nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED)) >= + mem0.alarmThreshold-nDiff ){ + sqlite3MallocAlarm(nDiff); + if( mem0.hardLimit>0 && nUsed >= mem0.hardLimit - nDiff ){ + sqlite3_mutex_leave(mem0.mutex); + return 0; + } + } + pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew); +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + if( pNew==0 && mem0.alarmThreshold>0 ){ + sqlite3MallocAlarm((int)nBytes); + pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew); + } +#endif + if( pNew ){ + nNew = sqlite3MallocSize(pNew); + sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nNew-nOld); + } + sqlite3_mutex_leave(mem0.mutex); + }else{ + pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew); + } + assert( EIGHT_BYTE_ALIGNMENT(pNew) ); /* IMP: R-11148-40995 */ + return pNew; +} + +/* +** The public interface to sqlite3Realloc. Make sure that the memory +** subsystem is initialized prior to invoking sqliteRealloc. +*/ +SQLITE_API void *sqlite3_realloc(void *pOld, int n){ +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + if( n<0 ) n = 0; /* IMP: R-26507-47431 */ + return sqlite3Realloc(pOld, n); +} +SQLITE_API void *sqlite3_realloc64(void *pOld, sqlite3_uint64 n){ +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + return sqlite3Realloc(pOld, n); +} + + +/* +** Allocate and zero memory. +*/ +SQLITE_PRIVATE void *sqlite3MallocZero(u64 n){ + void *p = sqlite3Malloc(n); + if( p ){ + memset(p, 0, (size_t)n); + } + return p; +} + +/* +** Allocate and zero memory. If the allocation fails, make +** the mallocFailed flag in the connection pointer. +*/ +SQLITE_PRIVATE void *sqlite3DbMallocZero(sqlite3 *db, u64 n){ + void *p; + testcase( db==0 ); + p = sqlite3DbMallocRaw(db, n); + if( p ) memset(p, 0, (size_t)n); + return p; +} + + +/* Finish the work of sqlite3DbMallocRawNN for the unusual and +** slower case when the allocation cannot be fulfilled using lookaside. +*/ +static SQLITE_NOINLINE void *dbMallocRawFinish(sqlite3 *db, u64 n){ + void *p; + assert( db!=0 ); + p = sqlite3Malloc(n); + if( !p ) sqlite3OomFault(db); + sqlite3MemdebugSetType(p, + (db->lookaside.bDisable==0) ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP); + return p; +} + +/* +** Allocate memory, either lookaside (if possible) or heap. +** If the allocation fails, set the mallocFailed flag in +** the connection pointer. +** +** If db!=0 and db->mallocFailed is true (indicating a prior malloc +** failure on the same database connection) then always return 0. +** Hence for a particular database connection, once malloc starts +** failing, it fails consistently until mallocFailed is reset. +** This is an important assumption. There are many places in the +** code that do things like this: +** +** int *a = (int*)sqlite3DbMallocRaw(db, 100); +** int *b = (int*)sqlite3DbMallocRaw(db, 200); +** if( b ) a[10] = 9; +** +** In other words, if a subsequent malloc (ex: "b") worked, it is assumed +** that all prior mallocs (ex: "a") worked too. +** +** The sqlite3MallocRawNN() variant guarantees that the "db" parameter is +** not a NULL pointer. +*/ +SQLITE_PRIVATE void *sqlite3DbMallocRaw(sqlite3 *db, u64 n){ + void *p; + if( db ) return sqlite3DbMallocRawNN(db, n); + p = sqlite3Malloc(n); + sqlite3MemdebugSetType(p, MEMTYPE_HEAP); + return p; +} +SQLITE_PRIVATE void *sqlite3DbMallocRawNN(sqlite3 *db, u64 n){ +#ifndef SQLITE_OMIT_LOOKASIDE + LookasideSlot *pBuf; + assert( db!=0 ); + assert( sqlite3_mutex_held(db->mutex) ); + assert( db->pnBytesFreed==0 ); + if( n>db->lookaside.sz ){ + if( !db->lookaside.bDisable ){ + db->lookaside.anStat[1]++; + }else if( db->mallocFailed ){ + return 0; + } + return dbMallocRawFinish(db, n); + } +#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE + if( n<=LOOKASIDE_SMALL ){ + if( (pBuf = db->lookaside.pSmallFree)!=0 ){ + db->lookaside.pSmallFree = pBuf->pNext; + db->lookaside.anStat[0]++; + return (void*)pBuf; + }else if( (pBuf = db->lookaside.pSmallInit)!=0 ){ + db->lookaside.pSmallInit = pBuf->pNext; + db->lookaside.anStat[0]++; + return (void*)pBuf; + } + } +#endif + if( (pBuf = db->lookaside.pFree)!=0 ){ + db->lookaside.pFree = pBuf->pNext; + db->lookaside.anStat[0]++; + return (void*)pBuf; + }else if( (pBuf = db->lookaside.pInit)!=0 ){ + db->lookaside.pInit = pBuf->pNext; + db->lookaside.anStat[0]++; + return (void*)pBuf; + }else{ + db->lookaside.anStat[2]++; + } +#else + assert( db!=0 ); + assert( sqlite3_mutex_held(db->mutex) ); + assert( db->pnBytesFreed==0 ); + if( db->mallocFailed ){ + return 0; + } +#endif + return dbMallocRawFinish(db, n); +} + +/* Forward declaration */ +static SQLITE_NOINLINE void *dbReallocFinish(sqlite3 *db, void *p, u64 n); + +/* +** Resize the block of memory pointed to by p to n bytes. If the +** resize fails, set the mallocFailed flag in the connection object. +*/ +SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *db, void *p, u64 n){ + assert( db!=0 ); + if( p==0 ) return sqlite3DbMallocRawNN(db, n); + assert( sqlite3_mutex_held(db->mutex) ); + if( ((uptr)p)<(uptr)db->lookaside.pEnd ){ +#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE + if( ((uptr)p)>=(uptr)db->lookaside.pMiddle ){ + if( n<=LOOKASIDE_SMALL ) return p; + }else +#endif + if( ((uptr)p)>=(uptr)db->lookaside.pStart ){ + if( n<=db->lookaside.szTrue ) return p; + } + } + return dbReallocFinish(db, p, n); +} +static SQLITE_NOINLINE void *dbReallocFinish(sqlite3 *db, void *p, u64 n){ + void *pNew = 0; + assert( db!=0 ); + assert( p!=0 ); + if( db->mallocFailed==0 ){ + if( isLookaside(db, p) ){ + pNew = sqlite3DbMallocRawNN(db, n); + if( pNew ){ + memcpy(pNew, p, lookasideMallocSize(db, p)); + sqlite3DbFree(db, p); + } + }else{ + assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); + assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) ); + sqlite3MemdebugSetType(p, MEMTYPE_HEAP); + pNew = sqlite3Realloc(p, n); + if( !pNew ){ + sqlite3OomFault(db); + } + sqlite3MemdebugSetType(pNew, + (db->lookaside.bDisable==0 ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP)); + } + } + return pNew; +} + +/* +** Attempt to reallocate p. If the reallocation fails, then free p +** and set the mallocFailed flag in the database connection. +*/ +SQLITE_PRIVATE void *sqlite3DbReallocOrFree(sqlite3 *db, void *p, u64 n){ + void *pNew; + pNew = sqlite3DbRealloc(db, p, n); + if( !pNew ){ + sqlite3DbFree(db, p); + } + return pNew; +} + +/* +** Make a copy of a string in memory obtained from sqliteMalloc(). These +** functions call sqlite3MallocRaw() directly instead of sqliteMalloc(). This +** is because when memory debugging is turned on, these two functions are +** called via macros that record the current file and line number in the +** ThreadData structure. +*/ +SQLITE_PRIVATE char *sqlite3DbStrDup(sqlite3 *db, const char *z){ + char *zNew; + size_t n; + if( z==0 ){ + return 0; + } + n = strlen(z) + 1; + zNew = sqlite3DbMallocRaw(db, n); + if( zNew ){ + memcpy(zNew, z, n); + } + return zNew; +} +SQLITE_PRIVATE char *sqlite3DbStrNDup(sqlite3 *db, const char *z, u64 n){ + char *zNew; + assert( db!=0 ); + assert( z!=0 || n==0 ); + assert( (n&0x7fffffff)==n ); + zNew = z ? sqlite3DbMallocRawNN(db, n+1) : 0; + if( zNew ){ + memcpy(zNew, z, (size_t)n); + zNew[n] = 0; + } + return zNew; +} + +/* +** The text between zStart and zEnd represents a phrase within a larger +** SQL statement. Make a copy of this phrase in space obtained form +** sqlite3DbMalloc(). Omit leading and trailing whitespace. +*/ +SQLITE_PRIVATE char *sqlite3DbSpanDup(sqlite3 *db, const char *zStart, const char *zEnd){ + int n; +#ifdef SQLITE_DEBUG + /* Because of the way the parser works, the span is guaranteed to contain + ** at least one non-space character */ + for(n=0; sqlite3Isspace(zStart[n]); n++){ assert( &zStart[n]mallocFailed, and also +** temporarily disable the lookaside memory allocator and interrupt +** any running VDBEs. +** +** Always return a NULL pointer so that this routine can be invoked using +** +** return sqlite3OomFault(db); +** +** and thereby avoid unnecessary stack frame allocations for the overwhelmingly +** common case where no OOM occurs. +*/ +SQLITE_PRIVATE void *sqlite3OomFault(sqlite3 *db){ + if( db->mallocFailed==0 && db->bBenignMalloc==0 ){ + db->mallocFailed = 1; + if( db->nVdbeExec>0 ){ + AtomicStore(&db->u1.isInterrupted, 1); + } + DisableLookaside; + if( db->pParse ){ + Parse *pParse; + sqlite3ErrorMsg(db->pParse, "out of memory"); + db->pParse->rc = SQLITE_NOMEM_BKPT; + for(pParse=db->pParse->pOuterParse; pParse; pParse = pParse->pOuterParse){ + pParse->nErr++; + pParse->rc = SQLITE_NOMEM; + } + } + } + return 0; +} + +/* +** This routine reactivates the memory allocator and clears the +** db->mallocFailed flag as necessary. +** +** The memory allocator is not restarted if there are running +** VDBEs. +*/ +SQLITE_PRIVATE void sqlite3OomClear(sqlite3 *db){ + if( db->mallocFailed && db->nVdbeExec==0 ){ + db->mallocFailed = 0; + AtomicStore(&db->u1.isInterrupted, 0); + assert( db->lookaside.bDisable>0 ); + EnableLookaside; + } +} + +/* +** Take actions at the end of an API call to deal with error codes. +*/ +static SQLITE_NOINLINE int apiHandleError(sqlite3 *db, int rc){ + if( db->mallocFailed || rc==SQLITE_IOERR_NOMEM ){ + sqlite3OomClear(db); + sqlite3Error(db, SQLITE_NOMEM); + return SQLITE_NOMEM_BKPT; + } + return rc & db->errMask; +} + +/* +** This function must be called before exiting any API function (i.e. +** returning control to the user) that has called sqlite3_malloc or +** sqlite3_realloc. +** +** The returned value is normally a copy of the second argument to this +** function. However, if a malloc() failure has occurred since the previous +** invocation SQLITE_NOMEM is returned instead. +** +** If an OOM as occurred, then the connection error-code (the value +** returned by sqlite3_errcode()) is set to SQLITE_NOMEM. +*/ +SQLITE_PRIVATE int sqlite3ApiExit(sqlite3* db, int rc){ + /* If the db handle must hold the connection handle mutex here. + ** Otherwise the read (and possible write) of db->mallocFailed + ** is unsafe, as is the call to sqlite3Error(). + */ + assert( db!=0 ); + assert( sqlite3_mutex_held(db->mutex) ); + if( db->mallocFailed || rc ){ + return apiHandleError(db, rc); + } + return rc & db->errMask; +} + +/************** End of malloc.c **********************************************/ +/************** Begin file printf.c ******************************************/ +/* +** The "printf" code that follows dates from the 1980's. It is in +** the public domain. +** +************************************************************************** +** +** This file contains code for a set of "printf"-like routines. These +** routines format strings much like the printf() from the standard C +** library, though the implementation here has enhancements to support +** SQLite. +*/ +/* #include "sqliteInt.h" */ + +/* +** Conversion types fall into various categories as defined by the +** following enumeration. +*/ +#define etRADIX 0 /* non-decimal integer types. %x %o */ +#define etFLOAT 1 /* Floating point. %f */ +#define etEXP 2 /* Exponentional notation. %e and %E */ +#define etGENERIC 3 /* Floating or exponential, depending on exponent. %g */ +#define etSIZE 4 /* Return number of characters processed so far. %n */ +#define etSTRING 5 /* Strings. %s */ +#define etDYNSTRING 6 /* Dynamically allocated strings. %z */ +#define etPERCENT 7 /* Percent symbol. %% */ +#define etCHARX 8 /* Characters. %c */ +/* The rest are extensions, not normally found in printf() */ +#define etSQLESCAPE 9 /* Strings with '\'' doubled. %q */ +#define etSQLESCAPE2 10 /* Strings with '\'' doubled and enclosed in '', + NULL pointers replaced by SQL NULL. %Q */ +#define etTOKEN 11 /* a pointer to a Token structure */ +#define etSRCITEM 12 /* a pointer to a SrcItem */ +#define etPOINTER 13 /* The %p conversion */ +#define etSQLESCAPE3 14 /* %w -> Strings with '\"' doubled */ +#define etORDINAL 15 /* %r -> 1st, 2nd, 3rd, 4th, etc. English only */ +#define etDECIMAL 16 /* %d or %u, but not %x, %o */ + +#define etINVALID 17 /* Any unrecognized conversion type */ + + +/* +** An "etByte" is an 8-bit unsigned value. +*/ +typedef unsigned char etByte; + +/* +** Each builtin conversion character (ex: the 'd' in "%d") is described +** by an instance of the following structure +*/ +typedef struct et_info { /* Information about each format field */ + char fmttype; /* The format field code letter */ + etByte base; /* The base for radix conversion */ + etByte flags; /* One or more of FLAG_ constants below */ + etByte type; /* Conversion paradigm */ + etByte charset; /* Offset into aDigits[] of the digits string */ + etByte prefix; /* Offset into aPrefix[] of the prefix string */ +} et_info; + +/* +** Allowed values for et_info.flags +*/ +#define FLAG_SIGNED 1 /* True if the value to convert is signed */ +#define FLAG_STRING 4 /* Allow infinite precision */ + + +/* +** The following table is searched linearly, so it is good to put the +** most frequently used conversion types first. +*/ +static const char aDigits[] = "0123456789ABCDEF0123456789abcdef"; +static const char aPrefix[] = "-x0\000X0"; +static const et_info fmtinfo[] = { + { 'd', 10, 1, etDECIMAL, 0, 0 }, + { 's', 0, 4, etSTRING, 0, 0 }, + { 'g', 0, 1, etGENERIC, 30, 0 }, + { 'z', 0, 4, etDYNSTRING, 0, 0 }, + { 'q', 0, 4, etSQLESCAPE, 0, 0 }, + { 'Q', 0, 4, etSQLESCAPE2, 0, 0 }, + { 'w', 0, 4, etSQLESCAPE3, 0, 0 }, + { 'c', 0, 0, etCHARX, 0, 0 }, + { 'o', 8, 0, etRADIX, 0, 2 }, + { 'u', 10, 0, etDECIMAL, 0, 0 }, + { 'x', 16, 0, etRADIX, 16, 1 }, + { 'X', 16, 0, etRADIX, 0, 4 }, +#ifndef SQLITE_OMIT_FLOATING_POINT + { 'f', 0, 1, etFLOAT, 0, 0 }, + { 'e', 0, 1, etEXP, 30, 0 }, + { 'E', 0, 1, etEXP, 14, 0 }, + { 'G', 0, 1, etGENERIC, 14, 0 }, +#endif + { 'i', 10, 1, etDECIMAL, 0, 0 }, + { 'n', 0, 0, etSIZE, 0, 0 }, + { '%', 0, 0, etPERCENT, 0, 0 }, + { 'p', 16, 0, etPOINTER, 0, 1 }, + + /* All the rest are undocumented and are for internal use only */ + { 'T', 0, 0, etTOKEN, 0, 0 }, + { 'S', 0, 0, etSRCITEM, 0, 0 }, + { 'r', 10, 1, etORDINAL, 0, 0 }, +}; + +/* Notes: +** +** %S Takes a pointer to SrcItem. Shows name or database.name +** %!S Like %S but prefer the zName over the zAlias +*/ + +/* Floating point constants used for rounding */ +static const double arRound[] = { + 5.0e-01, 5.0e-02, 5.0e-03, 5.0e-04, 5.0e-05, + 5.0e-06, 5.0e-07, 5.0e-08, 5.0e-09, 5.0e-10, +}; + +/* +** If SQLITE_OMIT_FLOATING_POINT is defined, then none of the floating point +** conversions will work. +*/ +#ifndef SQLITE_OMIT_FLOATING_POINT +/* +** "*val" is a double such that 0.1 <= *val < 10.0 +** Return the ascii code for the leading digit of *val, then +** multiply "*val" by 10.0 to renormalize. +** +** Example: +** input: *val = 3.14159 +** output: *val = 1.4159 function return = '3' +** +** The counter *cnt is incremented each time. After counter exceeds +** 16 (the number of significant digits in a 64-bit float) '0' is +** always returned. +*/ +static char et_getdigit(LONGDOUBLE_TYPE *val, int *cnt){ + int digit; + LONGDOUBLE_TYPE d; + if( (*cnt)<=0 ) return '0'; + (*cnt)--; + digit = (int)*val; + d = digit; + digit += '0'; + *val = (*val - d)*10.0; + return (char)digit; +} +#endif /* SQLITE_OMIT_FLOATING_POINT */ + +#ifndef SQLITE_OMIT_FLOATING_POINT +/* +** "*val" is a u64. *msd is a divisor used to extract the +** most significant digit of *val. Extract that most significant +** digit and return it. +*/ +static char et_getdigit_int(u64 *val, u64 *msd){ + u64 x = (*val)/(*msd); + *val -= x*(*msd); + if( *msd>=10 ) *msd /= 10; + return '0' + (char)(x & 15); +} +#endif /* SQLITE_OMIT_FLOATING_POINT */ + +/* +** Set the StrAccum object to an error mode. +*/ +SQLITE_PRIVATE void sqlite3StrAccumSetError(StrAccum *p, u8 eError){ + assert( eError==SQLITE_NOMEM || eError==SQLITE_TOOBIG ); + p->accError = eError; + if( p->mxAlloc ) sqlite3_str_reset(p); + if( eError==SQLITE_TOOBIG ) sqlite3ErrorToParser(p->db, eError); +} + +/* +** Extra argument values from a PrintfArguments object +*/ +static sqlite3_int64 getIntArg(PrintfArguments *p){ + if( p->nArg<=p->nUsed ) return 0; + return sqlite3_value_int64(p->apArg[p->nUsed++]); +} +static double getDoubleArg(PrintfArguments *p){ + if( p->nArg<=p->nUsed ) return 0.0; + return sqlite3_value_double(p->apArg[p->nUsed++]); +} +static char *getTextArg(PrintfArguments *p){ + if( p->nArg<=p->nUsed ) return 0; + return (char*)sqlite3_value_text(p->apArg[p->nUsed++]); +} + +/* +** Allocate memory for a temporary buffer needed for printf rendering. +** +** If the requested size of the temp buffer is larger than the size +** of the output buffer in pAccum, then cause an SQLITE_TOOBIG error. +** Do the size check before the memory allocation to prevent rogue +** SQL from requesting large allocations using the precision or width +** field of the printf() function. +*/ +static char *printfTempBuf(sqlite3_str *pAccum, sqlite3_int64 n){ + char *z; + if( pAccum->accError ) return 0; + if( n>pAccum->nAlloc && n>pAccum->mxAlloc ){ + sqlite3StrAccumSetError(pAccum, SQLITE_TOOBIG); + return 0; + } + z = sqlite3DbMallocRaw(pAccum->db, n); + if( z==0 ){ + sqlite3StrAccumSetError(pAccum, SQLITE_NOMEM); + } + return z; +} + +/* +** On machines with a small stack size, you can redefine the +** SQLITE_PRINT_BUF_SIZE to be something smaller, if desired. +*/ +#ifndef SQLITE_PRINT_BUF_SIZE +# define SQLITE_PRINT_BUF_SIZE 70 +#endif +#define etBUFSIZE SQLITE_PRINT_BUF_SIZE /* Size of the output buffer */ + +/* +** Hard limit on the precision of floating-point conversions. +*/ +#ifndef SQLITE_PRINTF_PRECISION_LIMIT +# define SQLITE_FP_PRECISION_LIMIT 100000000 +#endif + +/* +** Render a string given by "fmt" into the StrAccum object. +*/ +SQLITE_API void sqlite3_str_vappendf( + sqlite3_str *pAccum, /* Accumulate results here */ + const char *fmt, /* Format string */ + va_list ap /* arguments */ +){ + int c; /* Next character in the format string */ + char *bufpt; /* Pointer to the conversion buffer */ + int precision; /* Precision of the current field */ + int length; /* Length of the field */ + int idx; /* A general purpose loop counter */ + int width; /* Width of the current field */ + etByte flag_leftjustify; /* True if "-" flag is present */ + etByte flag_prefix; /* '+' or ' ' or 0 for prefix */ + etByte flag_alternateform; /* True if "#" flag is present */ + etByte flag_altform2; /* True if "!" flag is present */ + etByte flag_zeropad; /* True if field width constant starts with zero */ + etByte flag_long; /* 1 for the "l" flag, 2 for "ll", 0 by default */ + etByte done; /* Loop termination flag */ + etByte cThousand; /* Thousands separator for %d and %u */ + etByte xtype = etINVALID; /* Conversion paradigm */ + u8 bArgList; /* True for SQLITE_PRINTF_SQLFUNC */ + char prefix; /* Prefix character. "+" or "-" or " " or '\0'. */ + sqlite_uint64 longvalue; /* Value for integer types */ + LONGDOUBLE_TYPE realvalue; /* Value for real types */ + sqlite_uint64 msd; /* Divisor to get most-significant-digit + ** of longvalue */ + const et_info *infop; /* Pointer to the appropriate info structure */ + char *zOut; /* Rendering buffer */ + int nOut; /* Size of the rendering buffer */ + char *zExtra = 0; /* Malloced memory used by some conversion */ +#ifndef SQLITE_OMIT_FLOATING_POINT + int exp, e2; /* exponent of real numbers */ + int nsd; /* Number of significant digits returned */ + double rounder; /* Used for rounding floating point values */ + etByte flag_dp; /* True if decimal point should be shown */ + etByte flag_rtz; /* True if trailing zeros should be removed */ +#endif + PrintfArguments *pArgList = 0; /* Arguments for SQLITE_PRINTF_SQLFUNC */ + char buf[etBUFSIZE]; /* Conversion buffer */ + + /* pAccum never starts out with an empty buffer that was obtained from + ** malloc(). This precondition is required by the mprintf("%z...") + ** optimization. */ + assert( pAccum->nChar>0 || (pAccum->printfFlags&SQLITE_PRINTF_MALLOCED)==0 ); + + bufpt = 0; + if( (pAccum->printfFlags & SQLITE_PRINTF_SQLFUNC)!=0 ){ + pArgList = va_arg(ap, PrintfArguments*); + bArgList = 1; + }else{ + bArgList = 0; + } + for(; (c=(*fmt))!=0; ++fmt){ + if( c!='%' ){ + bufpt = (char *)fmt; +#if HAVE_STRCHRNUL + fmt = strchrnul(fmt, '%'); +#else + do{ fmt++; }while( *fmt && *fmt != '%' ); +#endif + sqlite3_str_append(pAccum, bufpt, (int)(fmt - bufpt)); + if( *fmt==0 ) break; + } + if( (c=(*++fmt))==0 ){ + sqlite3_str_append(pAccum, "%", 1); + break; + } + /* Find out what flags are present */ + flag_leftjustify = flag_prefix = cThousand = + flag_alternateform = flag_altform2 = flag_zeropad = 0; + done = 0; + width = 0; + flag_long = 0; + precision = -1; + do{ + switch( c ){ + case '-': flag_leftjustify = 1; break; + case '+': flag_prefix = '+'; break; + case ' ': flag_prefix = ' '; break; + case '#': flag_alternateform = 1; break; + case '!': flag_altform2 = 1; break; + case '0': flag_zeropad = 1; break; + case ',': cThousand = ','; break; + default: done = 1; break; + case 'l': { + flag_long = 1; + c = *++fmt; + if( c=='l' ){ + c = *++fmt; + flag_long = 2; + } + done = 1; + break; + } + case '1': case '2': case '3': case '4': case '5': + case '6': case '7': case '8': case '9': { + unsigned wx = c - '0'; + while( (c = *++fmt)>='0' && c<='9' ){ + wx = wx*10 + c - '0'; + } + testcase( wx>0x7fffffff ); + width = wx & 0x7fffffff; +#ifdef SQLITE_PRINTF_PRECISION_LIMIT + if( width>SQLITE_PRINTF_PRECISION_LIMIT ){ + width = SQLITE_PRINTF_PRECISION_LIMIT; + } +#endif + if( c!='.' && c!='l' ){ + done = 1; + }else{ + fmt--; + } + break; + } + case '*': { + if( bArgList ){ + width = (int)getIntArg(pArgList); + }else{ + width = va_arg(ap,int); + } + if( width<0 ){ + flag_leftjustify = 1; + width = width >= -2147483647 ? -width : 0; + } +#ifdef SQLITE_PRINTF_PRECISION_LIMIT + if( width>SQLITE_PRINTF_PRECISION_LIMIT ){ + width = SQLITE_PRINTF_PRECISION_LIMIT; + } +#endif + if( (c = fmt[1])!='.' && c!='l' ){ + c = *++fmt; + done = 1; + } + break; + } + case '.': { + c = *++fmt; + if( c=='*' ){ + if( bArgList ){ + precision = (int)getIntArg(pArgList); + }else{ + precision = va_arg(ap,int); + } + if( precision<0 ){ + precision = precision >= -2147483647 ? -precision : -1; + } + c = *++fmt; + }else{ + unsigned px = 0; + while( c>='0' && c<='9' ){ + px = px*10 + c - '0'; + c = *++fmt; + } + testcase( px>0x7fffffff ); + precision = px & 0x7fffffff; + } +#ifdef SQLITE_PRINTF_PRECISION_LIMIT + if( precision>SQLITE_PRINTF_PRECISION_LIMIT ){ + precision = SQLITE_PRINTF_PRECISION_LIMIT; + } +#endif + if( c=='l' ){ + --fmt; + }else{ + done = 1; + } + break; + } + } + }while( !done && (c=(*++fmt))!=0 ); + + /* Fetch the info entry for the field */ + infop = &fmtinfo[0]; + xtype = etINVALID; + for(idx=0; idxtype; + break; + } + } + + /* + ** At this point, variables are initialized as follows: + ** + ** flag_alternateform TRUE if a '#' is present. + ** flag_altform2 TRUE if a '!' is present. + ** flag_prefix '+' or ' ' or zero + ** flag_leftjustify TRUE if a '-' is present or if the + ** field width was negative. + ** flag_zeropad TRUE if the width began with 0. + ** flag_long 1 for "l", 2 for "ll" + ** width The specified field width. This is + ** always non-negative. Zero is the default. + ** precision The specified precision. The default + ** is -1. + ** xtype The class of the conversion. + ** infop Pointer to the appropriate info struct. + */ + assert( width>=0 ); + assert( precision>=(-1) ); + switch( xtype ){ + case etPOINTER: + flag_long = sizeof(char*)==sizeof(i64) ? 2 : + sizeof(char*)==sizeof(long int) ? 1 : 0; + /* no break */ deliberate_fall_through + case etORDINAL: + case etRADIX: + cThousand = 0; + /* no break */ deliberate_fall_through + case etDECIMAL: + if( infop->flags & FLAG_SIGNED ){ + i64 v; + if( bArgList ){ + v = getIntArg(pArgList); + }else if( flag_long ){ + if( flag_long==2 ){ + v = va_arg(ap,i64) ; + }else{ + v = va_arg(ap,long int); + } + }else{ + v = va_arg(ap,int); + } + if( v<0 ){ + testcase( v==SMALLEST_INT64 ); + testcase( v==(-1) ); + longvalue = ~v; + longvalue++; + prefix = '-'; + }else{ + longvalue = v; + prefix = flag_prefix; + } + }else{ + if( bArgList ){ + longvalue = (u64)getIntArg(pArgList); + }else if( flag_long ){ + if( flag_long==2 ){ + longvalue = va_arg(ap,u64); + }else{ + longvalue = va_arg(ap,unsigned long int); + } + }else{ + longvalue = va_arg(ap,unsigned int); + } + prefix = 0; + } + if( longvalue==0 ) flag_alternateform = 0; + if( flag_zeropad && precision=4 || (longvalue/10)%10==1 ){ + x = 0; + } + *(--bufpt) = zOrd[x*2+1]; + *(--bufpt) = zOrd[x*2]; + } + { + const char *cset = &aDigits[infop->charset]; + u8 base = infop->base; + do{ /* Convert to ascii */ + *(--bufpt) = cset[longvalue%base]; + longvalue = longvalue/base; + }while( longvalue>0 ); + } + length = (int)(&zOut[nOut-1]-bufpt); + while( precision>length ){ + *(--bufpt) = '0'; /* Zero pad */ + length++; + } + if( cThousand ){ + int nn = (length - 1)/3; /* Number of "," to insert */ + int ix = (length - 1)%3 + 1; + bufpt -= nn; + for(idx=0; nn>0; idx++){ + bufpt[idx] = bufpt[idx+nn]; + ix--; + if( ix==0 ){ + bufpt[++idx] = cThousand; + nn--; + ix = 3; + } + } + } + if( prefix ) *(--bufpt) = prefix; /* Add sign */ + if( flag_alternateform && infop->prefix ){ /* Add "0" or "0x" */ + const char *pre; + char x; + pre = &aPrefix[infop->prefix]; + for(; (x=(*pre))!=0; pre++) *(--bufpt) = x; + } + length = (int)(&zOut[nOut-1]-bufpt); + break; + case etFLOAT: + case etEXP: + case etGENERIC: + if( bArgList ){ + realvalue = getDoubleArg(pArgList); + }else{ + realvalue = va_arg(ap,double); + } +#ifdef SQLITE_OMIT_FLOATING_POINT + length = 0; +#else + if( precision<0 ) precision = 6; /* Set default precision */ +#ifdef SQLITE_FP_PRECISION_LIMIT + if( precision>SQLITE_FP_PRECISION_LIMIT ){ + precision = SQLITE_FP_PRECISION_LIMIT; + } +#endif + if( realvalue<0.0 ){ + realvalue = -realvalue; + prefix = '-'; + }else{ + prefix = flag_prefix; + } + exp = 0; + if( xtype==etGENERIC && precision>0 ) precision--; + testcase( precision>0xfff ); + if( realvalue<1.0e+16 + && realvalue==(LONGDOUBLE_TYPE)(longvalue = (u64)realvalue) + ){ + /* Number is a pure integer that can be represented as u64 */ + for(msd=1; msd*10<=longvalue; msd *= 10, exp++){} + if( exp>precision && xtype!=etFLOAT ){ + u64 rnd = msd/2; + int kk = precision; + while( kk-- > 0 ){ rnd /= 10; } + longvalue += rnd; + } + }else{ + msd = 0; + longvalue = 0; /* To prevent a compiler warning */ + idx = precision & 0xfff; + rounder = arRound[idx%10]; + while( idx>=10 ){ rounder *= 1.0e-10; idx -= 10; } + if( xtype==etFLOAT ){ + double rx = (double)realvalue; + sqlite3_uint64 u; + int ex; + memcpy(&u, &rx, sizeof(u)); + ex = -1023 + (int)((u>>52)&0x7ff); + if( precision+(ex/3) < 15 ) rounder += realvalue*3e-16; + realvalue += rounder; + } + if( sqlite3IsNaN((double)realvalue) ){ + if( flag_zeropad ){ + bufpt = "null"; + length = 4; + }else{ + bufpt = "NaN"; + length = 3; + } + break; + } + + /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */ + if( ALWAYS(realvalue>0.0) ){ + LONGDOUBLE_TYPE scale = 1.0; + while( realvalue>=1e100*scale && exp<=350){ scale*=1e100;exp+=100;} + while( realvalue>=1e10*scale && exp<=350 ){ scale*=1e10; exp+=10; } + while( realvalue>=10.0*scale && exp<=350 ){ scale *= 10.0; exp++; } + realvalue /= scale; + while( realvalue<1e-8 ){ realvalue *= 1e8; exp-=8; } + while( realvalue<1.0 ){ realvalue *= 10.0; exp--; } + if( exp>350 ){ + if( flag_zeropad ){ + realvalue = 9.0; + exp = 999; + }else{ + bufpt = buf; + buf[0] = prefix; + memcpy(buf+(prefix!=0),"Inf",4); + length = 3+(prefix!=0); + break; + } + } + if( xtype!=etFLOAT ){ + realvalue += rounder; + if( realvalue>=10.0 ){ realvalue *= 0.1; exp++; } + } + } + } + + /* + ** If the field type is etGENERIC, then convert to either etEXP + ** or etFLOAT, as appropriate. + */ + if( xtype==etGENERIC ){ + flag_rtz = !flag_alternateform; + if( exp<-4 || exp>precision ){ + xtype = etEXP; + }else{ + precision = precision - exp; + xtype = etFLOAT; + } + }else{ + flag_rtz = flag_altform2; + } + if( xtype==etEXP ){ + e2 = 0; + }else{ + e2 = exp; + } + nsd = 16 + flag_altform2*10; + bufpt = buf; + { + i64 szBufNeeded; /* Size of a temporary buffer needed */ + szBufNeeded = MAX(e2,0)+(i64)precision+(i64)width+15; + if( cThousand && e2>0 ) szBufNeeded += (e2+2)/3; + if( szBufNeeded > etBUFSIZE ){ + bufpt = zExtra = printfTempBuf(pAccum, szBufNeeded); + if( bufpt==0 ) return; + } + } + zOut = bufpt; + flag_dp = (precision>0 ?1:0) | flag_alternateform | flag_altform2; + /* The sign in front of the number */ + if( prefix ){ + *(bufpt++) = prefix; + } + /* Digits prior to the decimal point */ + if( e2<0 ){ + *(bufpt++) = '0'; + }else if( msd>0 ){ + for(; e2>=0; e2--){ + *(bufpt++) = et_getdigit_int(&longvalue,&msd); + if( cThousand && (e2%3)==0 && e2>1 ) *(bufpt++) = ','; + } + }else{ + for(; e2>=0; e2--){ + *(bufpt++) = et_getdigit(&realvalue,&nsd); + if( cThousand && (e2%3)==0 && e2>1 ) *(bufpt++) = ','; + } + } + /* The decimal point */ + if( flag_dp ){ + *(bufpt++) = '.'; + } + /* "0" digits after the decimal point but before the first + ** significant digit of the number */ + for(e2++; e2<0; precision--, e2++){ + assert( precision>0 ); + *(bufpt++) = '0'; + } + /* Significant digits after the decimal point */ + if( msd>0 ){ + while( (precision--)>0 ){ + *(bufpt++) = et_getdigit_int(&longvalue,&msd); + } + }else{ + while( (precision--)>0 ){ + *(bufpt++) = et_getdigit(&realvalue,&nsd); + } + } + /* Remove trailing zeros and the "." if no digits follow the "." */ + if( flag_rtz && flag_dp ){ + while( bufpt[-1]=='0' ) *(--bufpt) = 0; + assert( bufpt>zOut ); + if( bufpt[-1]=='.' ){ + if( flag_altform2 ){ + *(bufpt++) = '0'; + }else{ + *(--bufpt) = 0; + } + } + } + /* Add the "eNNN" suffix */ + if( xtype==etEXP ){ + *(bufpt++) = aDigits[infop->charset]; + if( exp<0 ){ + *(bufpt++) = '-'; exp = -exp; + }else{ + *(bufpt++) = '+'; + } + if( exp>=100 ){ + *(bufpt++) = (char)((exp/100)+'0'); /* 100's digit */ + exp %= 100; + } + *(bufpt++) = (char)(exp/10+'0'); /* 10's digit */ + *(bufpt++) = (char)(exp%10+'0'); /* 1's digit */ + } + *bufpt = 0; + + /* The converted number is in buf[] and zero terminated. Output it. + ** Note that the number is in the usual order, not reversed as with + ** integer conversions. */ + length = (int)(bufpt-zOut); + bufpt = zOut; + + /* Special case: Add leading zeros if the flag_zeropad flag is + ** set and we are not left justified */ + if( flag_zeropad && !flag_leftjustify && length < width){ + int i; + int nPad = width - length; + for(i=width; i>=nPad; i--){ + bufpt[i] = bufpt[i-nPad]; + } + i = prefix!=0; + while( nPad-- ) bufpt[i++] = '0'; + length = width; + } +#endif /* !defined(SQLITE_OMIT_FLOATING_POINT) */ + break; + case etSIZE: + if( !bArgList ){ + *(va_arg(ap,int*)) = pAccum->nChar; + } + length = width = 0; + break; + case etPERCENT: + buf[0] = '%'; + bufpt = buf; + length = 1; + break; + case etCHARX: + if( bArgList ){ + bufpt = getTextArg(pArgList); + length = 1; + if( bufpt ){ + buf[0] = c = *(bufpt++); + if( (c&0xc0)==0xc0 ){ + while( length<4 && (bufpt[0]&0xc0)==0x80 ){ + buf[length++] = *(bufpt++); + } + } + }else{ + buf[0] = 0; + } + }else{ + unsigned int ch = va_arg(ap,unsigned int); + if( ch<0x00080 ){ + buf[0] = ch & 0xff; + length = 1; + }else if( ch<0x00800 ){ + buf[0] = 0xc0 + (u8)((ch>>6)&0x1f); + buf[1] = 0x80 + (u8)(ch & 0x3f); + length = 2; + }else if( ch<0x10000 ){ + buf[0] = 0xe0 + (u8)((ch>>12)&0x0f); + buf[1] = 0x80 + (u8)((ch>>6) & 0x3f); + buf[2] = 0x80 + (u8)(ch & 0x3f); + length = 3; + }else{ + buf[0] = 0xf0 + (u8)((ch>>18) & 0x07); + buf[1] = 0x80 + (u8)((ch>>12) & 0x3f); + buf[2] = 0x80 + (u8)((ch>>6) & 0x3f); + buf[3] = 0x80 + (u8)(ch & 0x3f); + length = 4; + } + } + if( precision>1 ){ + i64 nPrior = 1; + width -= precision-1; + if( width>1 && !flag_leftjustify ){ + sqlite3_str_appendchar(pAccum, width-1, ' '); + width = 0; + } + sqlite3_str_append(pAccum, buf, length); + precision--; + while( precision > 1 ){ + i64 nCopyBytes; + if( nPrior > precision-1 ) nPrior = precision - 1; + nCopyBytes = length*nPrior; + if( nCopyBytes + pAccum->nChar >= pAccum->nAlloc ){ + sqlite3StrAccumEnlarge(pAccum, nCopyBytes); + } + if( pAccum->accError ) break; + sqlite3_str_append(pAccum, + &pAccum->zText[pAccum->nChar-nCopyBytes], nCopyBytes); + precision -= nPrior; + nPrior *= 2; + } + } + bufpt = buf; + flag_altform2 = 1; + goto adjust_width_for_utf8; + case etSTRING: + case etDYNSTRING: + if( bArgList ){ + bufpt = getTextArg(pArgList); + xtype = etSTRING; + }else{ + bufpt = va_arg(ap,char*); + } + if( bufpt==0 ){ + bufpt = ""; + }else if( xtype==etDYNSTRING ){ + if( pAccum->nChar==0 + && pAccum->mxAlloc + && width==0 + && precision<0 + && pAccum->accError==0 + ){ + /* Special optimization for sqlite3_mprintf("%z..."): + ** Extend an existing memory allocation rather than creating + ** a new one. */ + assert( (pAccum->printfFlags&SQLITE_PRINTF_MALLOCED)==0 ); + pAccum->zText = bufpt; + pAccum->nAlloc = sqlite3DbMallocSize(pAccum->db, bufpt); + pAccum->nChar = 0x7fffffff & (int)strlen(bufpt); + pAccum->printfFlags |= SQLITE_PRINTF_MALLOCED; + length = 0; + break; + } + zExtra = bufpt; + } + if( precision>=0 ){ + if( flag_altform2 ){ + /* Set length to the number of bytes needed in order to display + ** precision characters */ + unsigned char *z = (unsigned char*)bufpt; + while( precision-- > 0 && z[0] ){ + SQLITE_SKIP_UTF8(z); + } + length = (int)(z - (unsigned char*)bufpt); + }else{ + for(length=0; length0 ){ + /* Adjust width to account for extra bytes in UTF-8 characters */ + int ii = length - 1; + while( ii>=0 ) if( (bufpt[ii--] & 0xc0)==0x80 ) width++; + } + break; + case etSQLESCAPE: /* %q: Escape ' characters */ + case etSQLESCAPE2: /* %Q: Escape ' and enclose in '...' */ + case etSQLESCAPE3: { /* %w: Escape " characters */ + i64 i, j, k, n; + int needQuote, isnull; + char ch; + char q = ((xtype==etSQLESCAPE3)?'"':'\''); /* Quote character */ + char *escarg; + + if( bArgList ){ + escarg = getTextArg(pArgList); + }else{ + escarg = va_arg(ap,char*); + } + isnull = escarg==0; + if( isnull ) escarg = (xtype==etSQLESCAPE2 ? "NULL" : "(NULL)"); + /* For %q, %Q, and %w, the precision is the number of bytes (or + ** characters if the ! flags is present) to use from the input. + ** Because of the extra quoting characters inserted, the number + ** of output characters may be larger than the precision. + */ + k = precision; + for(i=n=0; k!=0 && (ch=escarg[i])!=0; i++, k--){ + if( ch==q ) n++; + if( flag_altform2 && (ch&0xc0)==0xc0 ){ + while( (escarg[i+1]&0xc0)==0x80 ){ i++; } + } + } + needQuote = !isnull && xtype==etSQLESCAPE2; + n += i + 3; + if( n>etBUFSIZE ){ + bufpt = zExtra = printfTempBuf(pAccum, n); + if( bufpt==0 ) return; + }else{ + bufpt = buf; + } + j = 0; + if( needQuote ) bufpt[j++] = q; + k = i; + for(i=0; iprintfFlags & SQLITE_PRINTF_INTERNAL)==0 ) return; + if( flag_alternateform ){ + /* %#T means an Expr pointer that uses Expr.u.zToken */ + Expr *pExpr = va_arg(ap,Expr*); + if( ALWAYS(pExpr) && ALWAYS(!ExprHasProperty(pExpr,EP_IntValue)) ){ + sqlite3_str_appendall(pAccum, (const char*)pExpr->u.zToken); + sqlite3RecordErrorOffsetOfExpr(pAccum->db, pExpr); + } + }else{ + /* %T means a Token pointer */ + Token *pToken = va_arg(ap, Token*); + assert( bArgList==0 ); + if( pToken && pToken->n ){ + sqlite3_str_append(pAccum, (const char*)pToken->z, pToken->n); + sqlite3RecordErrorByteOffset(pAccum->db, pToken->z); + } + } + length = width = 0; + break; + } + case etSRCITEM: { + SrcItem *pItem; + if( (pAccum->printfFlags & SQLITE_PRINTF_INTERNAL)==0 ) return; + pItem = va_arg(ap, SrcItem*); + assert( bArgList==0 ); + if( pItem->zAlias && !flag_altform2 ){ + sqlite3_str_appendall(pAccum, pItem->zAlias); + }else if( pItem->zName ){ + if( pItem->zDatabase ){ + sqlite3_str_appendall(pAccum, pItem->zDatabase); + sqlite3_str_append(pAccum, ".", 1); + } + sqlite3_str_appendall(pAccum, pItem->zName); + }else if( pItem->zAlias ){ + sqlite3_str_appendall(pAccum, pItem->zAlias); + }else{ + Select *pSel = pItem->pSelect; + assert( pSel!=0 ); + if( pSel->selFlags & SF_NestedFrom ){ + sqlite3_str_appendf(pAccum, "(join-%u)", pSel->selId); + }else{ + sqlite3_str_appendf(pAccum, "(subquery-%u)", pSel->selId); + } + } + length = width = 0; + break; + } + default: { + assert( xtype==etINVALID ); + return; + } + }/* End switch over the format type */ + /* + ** The text of the conversion is pointed to by "bufpt" and is + ** "length" characters long. The field width is "width". Do + ** the output. Both length and width are in bytes, not characters, + ** at this point. If the "!" flag was present on string conversions + ** indicating that width and precision should be expressed in characters, + ** then the values have been translated prior to reaching this point. + */ + width -= length; + if( width>0 ){ + if( !flag_leftjustify ) sqlite3_str_appendchar(pAccum, width, ' '); + sqlite3_str_append(pAccum, bufpt, length); + if( flag_leftjustify ) sqlite3_str_appendchar(pAccum, width, ' '); + }else{ + sqlite3_str_append(pAccum, bufpt, length); + } + + if( zExtra ){ + sqlite3DbFree(pAccum->db, zExtra); + zExtra = 0; + } + }/* End for loop over the format string */ +} /* End of function */ + + +/* +** The z string points to the first character of a token that is +** associated with an error. If db does not already have an error +** byte offset recorded, try to compute the error byte offset for +** z and set the error byte offset in db. +*/ +SQLITE_PRIVATE void sqlite3RecordErrorByteOffset(sqlite3 *db, const char *z){ + const Parse *pParse; + const char *zText; + const char *zEnd; + assert( z!=0 ); + if( NEVER(db==0) ) return; + if( db->errByteOffset!=(-2) ) return; + pParse = db->pParse; + if( NEVER(pParse==0) ) return; + zText =pParse->zTail; + if( NEVER(zText==0) ) return; + zEnd = &zText[strlen(zText)]; + if( SQLITE_WITHIN(z,zText,zEnd) ){ + db->errByteOffset = (int)(z-zText); + } +} + +/* +** If pExpr has a byte offset for the start of a token, record that as +** as the error offset. +*/ +SQLITE_PRIVATE void sqlite3RecordErrorOffsetOfExpr(sqlite3 *db, const Expr *pExpr){ + while( pExpr + && (ExprHasProperty(pExpr,EP_OuterON|EP_InnerON) || pExpr->w.iOfst<=0) + ){ + pExpr = pExpr->pLeft; + } + if( pExpr==0 ) return; + db->errByteOffset = pExpr->w.iOfst; +} + +/* +** Enlarge the memory allocation on a StrAccum object so that it is +** able to accept at least N more bytes of text. +** +** Return the number of bytes of text that StrAccum is able to accept +** after the attempted enlargement. The value returned might be zero. +*/ +SQLITE_PRIVATE int sqlite3StrAccumEnlarge(StrAccum *p, i64 N){ + char *zNew; + assert( p->nChar+N >= p->nAlloc ); /* Only called if really needed */ + if( p->accError ){ + testcase(p->accError==SQLITE_TOOBIG); + testcase(p->accError==SQLITE_NOMEM); + return 0; + } + if( p->mxAlloc==0 ){ + sqlite3StrAccumSetError(p, SQLITE_TOOBIG); + return p->nAlloc - p->nChar - 1; + }else{ + char *zOld = isMalloced(p) ? p->zText : 0; + i64 szNew = p->nChar + N + 1; + if( szNew+p->nChar<=p->mxAlloc ){ + /* Force exponential buffer size growth as long as it does not overflow, + ** to avoid having to call this routine too often */ + szNew += p->nChar; + } + if( szNew > p->mxAlloc ){ + sqlite3_str_reset(p); + sqlite3StrAccumSetError(p, SQLITE_TOOBIG); + return 0; + }else{ + p->nAlloc = (int)szNew; + } + if( p->db ){ + zNew = sqlite3DbRealloc(p->db, zOld, p->nAlloc); + }else{ + zNew = sqlite3Realloc(zOld, p->nAlloc); + } + if( zNew ){ + assert( p->zText!=0 || p->nChar==0 ); + if( !isMalloced(p) && p->nChar>0 ) memcpy(zNew, p->zText, p->nChar); + p->zText = zNew; + p->nAlloc = sqlite3DbMallocSize(p->db, zNew); + p->printfFlags |= SQLITE_PRINTF_MALLOCED; + }else{ + sqlite3_str_reset(p); + sqlite3StrAccumSetError(p, SQLITE_NOMEM); + return 0; + } + } + assert( N>=0 && N<=0x7fffffff ); + return (int)N; +} + +/* +** Append N copies of character c to the given string buffer. +*/ +SQLITE_API void sqlite3_str_appendchar(sqlite3_str *p, int N, char c){ + testcase( p->nChar + (i64)N > 0x7fffffff ); + if( p->nChar+(i64)N >= p->nAlloc && (N = sqlite3StrAccumEnlarge(p, N))<=0 ){ + return; + } + while( (N--)>0 ) p->zText[p->nChar++] = c; +} + +/* +** The StrAccum "p" is not large enough to accept N new bytes of z[]. +** So enlarge if first, then do the append. +** +** This is a helper routine to sqlite3_str_append() that does special-case +** work (enlarging the buffer) using tail recursion, so that the +** sqlite3_str_append() routine can use fast calling semantics. +*/ +static void SQLITE_NOINLINE enlargeAndAppend(StrAccum *p, const char *z, int N){ + N = sqlite3StrAccumEnlarge(p, N); + if( N>0 ){ + memcpy(&p->zText[p->nChar], z, N); + p->nChar += N; + } +} + +/* +** Append N bytes of text from z to the StrAccum object. Increase the +** size of the memory allocation for StrAccum if necessary. +*/ +SQLITE_API void sqlite3_str_append(sqlite3_str *p, const char *z, int N){ + assert( z!=0 || N==0 ); + assert( p->zText!=0 || p->nChar==0 || p->accError ); + assert( N>=0 ); + assert( p->accError==0 || p->nAlloc==0 || p->mxAlloc==0 ); + if( p->nChar+N >= p->nAlloc ){ + enlargeAndAppend(p,z,N); + }else if( N ){ + assert( p->zText ); + p->nChar += N; + memcpy(&p->zText[p->nChar-N], z, N); + } +} + +/* +** Append the complete text of zero-terminated string z[] to the p string. +*/ +SQLITE_API void sqlite3_str_appendall(sqlite3_str *p, const char *z){ + sqlite3_str_append(p, z, sqlite3Strlen30(z)); +} + + +/* +** Finish off a string by making sure it is zero-terminated. +** Return a pointer to the resulting string. Return a NULL +** pointer if any kind of error was encountered. +*/ +static SQLITE_NOINLINE char *strAccumFinishRealloc(StrAccum *p){ + char *zText; + assert( p->mxAlloc>0 && !isMalloced(p) ); + zText = sqlite3DbMallocRaw(p->db, p->nChar+1 ); + if( zText ){ + memcpy(zText, p->zText, p->nChar+1); + p->printfFlags |= SQLITE_PRINTF_MALLOCED; + }else{ + sqlite3StrAccumSetError(p, SQLITE_NOMEM); + } + p->zText = zText; + return zText; +} +SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum *p){ + if( p->zText ){ + p->zText[p->nChar] = 0; + if( p->mxAlloc>0 && !isMalloced(p) ){ + return strAccumFinishRealloc(p); + } + } + return p->zText; +} + +/* +** Use the content of the StrAccum passed as the second argument +** as the result of an SQL function. +*/ +SQLITE_PRIVATE void sqlite3ResultStrAccum(sqlite3_context *pCtx, StrAccum *p){ + if( p->accError ){ + sqlite3_result_error_code(pCtx, p->accError); + sqlite3_str_reset(p); + }else if( isMalloced(p) ){ + sqlite3_result_text(pCtx, p->zText, p->nChar, SQLITE_DYNAMIC); + }else{ + sqlite3_result_text(pCtx, "", 0, SQLITE_STATIC); + sqlite3_str_reset(p); + } +} + +/* +** This singleton is an sqlite3_str object that is returned if +** sqlite3_malloc() fails to provide space for a real one. This +** sqlite3_str object accepts no new text and always returns +** an SQLITE_NOMEM error. +*/ +static sqlite3_str sqlite3OomStr = { + 0, 0, 0, 0, 0, SQLITE_NOMEM, 0 +}; + +/* Finalize a string created using sqlite3_str_new(). +*/ +SQLITE_API char *sqlite3_str_finish(sqlite3_str *p){ + char *z; + if( p!=0 && p!=&sqlite3OomStr ){ + z = sqlite3StrAccumFinish(p); + sqlite3_free(p); + }else{ + z = 0; + } + return z; +} + +/* Return any error code associated with p */ +SQLITE_API int sqlite3_str_errcode(sqlite3_str *p){ + return p ? p->accError : SQLITE_NOMEM; +} + +/* Return the current length of p in bytes */ +SQLITE_API int sqlite3_str_length(sqlite3_str *p){ + return p ? p->nChar : 0; +} + +/* Return the current value for p */ +SQLITE_API char *sqlite3_str_value(sqlite3_str *p){ + if( p==0 || p->nChar==0 ) return 0; + p->zText[p->nChar] = 0; + return p->zText; +} + +/* +** Reset an StrAccum string. Reclaim all malloced memory. +*/ +SQLITE_API void sqlite3_str_reset(StrAccum *p){ + if( isMalloced(p) ){ + sqlite3DbFree(p->db, p->zText); + p->printfFlags &= ~SQLITE_PRINTF_MALLOCED; + } + p->nAlloc = 0; + p->nChar = 0; + p->zText = 0; +} + +/* +** Initialize a string accumulator. +** +** p: The accumulator to be initialized. +** db: Pointer to a database connection. May be NULL. Lookaside +** memory is used if not NULL. db->mallocFailed is set appropriately +** when not NULL. +** zBase: An initial buffer. May be NULL in which case the initial buffer +** is malloced. +** n: Size of zBase in bytes. If total space requirements never exceed +** n then no memory allocations ever occur. +** mx: Maximum number of bytes to accumulate. If mx==0 then no memory +** allocations will ever occur. +*/ +SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum *p, sqlite3 *db, char *zBase, int n, int mx){ + p->zText = zBase; + p->db = db; + p->nAlloc = n; + p->mxAlloc = mx; + p->nChar = 0; + p->accError = 0; + p->printfFlags = 0; +} + +/* Allocate and initialize a new dynamic string object */ +SQLITE_API sqlite3_str *sqlite3_str_new(sqlite3 *db){ + sqlite3_str *p = sqlite3_malloc64(sizeof(*p)); + if( p ){ + sqlite3StrAccumInit(p, 0, 0, 0, + db ? db->aLimit[SQLITE_LIMIT_LENGTH] : SQLITE_MAX_LENGTH); + }else{ + p = &sqlite3OomStr; + } + return p; +} + +/* +** Print into memory obtained from sqliteMalloc(). Use the internal +** %-conversion extensions. +*/ +SQLITE_PRIVATE char *sqlite3VMPrintf(sqlite3 *db, const char *zFormat, va_list ap){ + char *z; + char zBase[SQLITE_PRINT_BUF_SIZE]; + StrAccum acc; + assert( db!=0 ); + sqlite3StrAccumInit(&acc, db, zBase, sizeof(zBase), + db->aLimit[SQLITE_LIMIT_LENGTH]); + acc.printfFlags = SQLITE_PRINTF_INTERNAL; + sqlite3_str_vappendf(&acc, zFormat, ap); + z = sqlite3StrAccumFinish(&acc); + if( acc.accError==SQLITE_NOMEM ){ + sqlite3OomFault(db); + } + return z; +} + +/* +** Print into memory obtained from sqliteMalloc(). Use the internal +** %-conversion extensions. +*/ +SQLITE_PRIVATE char *sqlite3MPrintf(sqlite3 *db, const char *zFormat, ...){ + va_list ap; + char *z; + va_start(ap, zFormat); + z = sqlite3VMPrintf(db, zFormat, ap); + va_end(ap); + return z; +} + +/* +** Print into memory obtained from sqlite3_malloc(). Omit the internal +** %-conversion extensions. +*/ +SQLITE_API char *sqlite3_vmprintf(const char *zFormat, va_list ap){ + char *z; + char zBase[SQLITE_PRINT_BUF_SIZE]; + StrAccum acc; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( zFormat==0 ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + sqlite3StrAccumInit(&acc, 0, zBase, sizeof(zBase), SQLITE_MAX_LENGTH); + sqlite3_str_vappendf(&acc, zFormat, ap); + z = sqlite3StrAccumFinish(&acc); + return z; +} + +/* +** Print into memory obtained from sqlite3_malloc()(). Omit the internal +** %-conversion extensions. +*/ +SQLITE_API char *sqlite3_mprintf(const char *zFormat, ...){ + va_list ap; + char *z; +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + va_start(ap, zFormat); + z = sqlite3_vmprintf(zFormat, ap); + va_end(ap); + return z; +} + +/* +** sqlite3_snprintf() works like snprintf() except that it ignores the +** current locale settings. This is important for SQLite because we +** are not able to use a "," as the decimal point in place of "." as +** specified by some locales. +** +** Oops: The first two arguments of sqlite3_snprintf() are backwards +** from the snprintf() standard. Unfortunately, it is too late to change +** this without breaking compatibility, so we just have to live with the +** mistake. +** +** sqlite3_vsnprintf() is the varargs version. +*/ +SQLITE_API char *sqlite3_vsnprintf(int n, char *zBuf, const char *zFormat, va_list ap){ + StrAccum acc; + if( n<=0 ) return zBuf; +#ifdef SQLITE_ENABLE_API_ARMOR + if( zBuf==0 || zFormat==0 ) { + (void)SQLITE_MISUSE_BKPT; + if( zBuf ) zBuf[0] = 0; + return zBuf; + } +#endif + sqlite3StrAccumInit(&acc, 0, zBuf, n, 0); + sqlite3_str_vappendf(&acc, zFormat, ap); + zBuf[acc.nChar] = 0; + return zBuf; +} +SQLITE_API char *sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...){ + StrAccum acc; + va_list ap; + if( n<=0 ) return zBuf; +#ifdef SQLITE_ENABLE_API_ARMOR + if( zBuf==0 || zFormat==0 ) { + (void)SQLITE_MISUSE_BKPT; + if( zBuf ) zBuf[0] = 0; + return zBuf; + } +#endif + sqlite3StrAccumInit(&acc, 0, zBuf, n, 0); + va_start(ap,zFormat); + sqlite3_str_vappendf(&acc, zFormat, ap); + va_end(ap); + zBuf[acc.nChar] = 0; + return zBuf; +} + +/* +** This is the routine that actually formats the sqlite3_log() message. +** We house it in a separate routine from sqlite3_log() to avoid using +** stack space on small-stack systems when logging is disabled. +** +** sqlite3_log() must render into a static buffer. It cannot dynamically +** allocate memory because it might be called while the memory allocator +** mutex is held. +** +** sqlite3_str_vappendf() might ask for *temporary* memory allocations for +** certain format characters (%q) or for very large precisions or widths. +** Care must be taken that any sqlite3_log() calls that occur while the +** memory mutex is held do not use these mechanisms. +*/ +static void renderLogMsg(int iErrCode, const char *zFormat, va_list ap){ + StrAccum acc; /* String accumulator */ + char zMsg[SQLITE_PRINT_BUF_SIZE*3]; /* Complete log message */ + + sqlite3StrAccumInit(&acc, 0, zMsg, sizeof(zMsg), 0); + sqlite3_str_vappendf(&acc, zFormat, ap); + sqlite3GlobalConfig.xLog(sqlite3GlobalConfig.pLogArg, iErrCode, + sqlite3StrAccumFinish(&acc)); +} + +/* +** Format and write a message to the log if logging is enabled. +*/ +SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...){ + va_list ap; /* Vararg list */ + if( sqlite3GlobalConfig.xLog ){ + va_start(ap, zFormat); + renderLogMsg(iErrCode, zFormat, ap); + va_end(ap); + } +} + +#if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE) +/* +** A version of printf() that understands %lld. Used for debugging. +** The printf() built into some versions of windows does not understand %lld +** and segfaults if you give it a long long int. +*/ +SQLITE_PRIVATE void sqlite3DebugPrintf(const char *zFormat, ...){ + va_list ap; + StrAccum acc; + char zBuf[SQLITE_PRINT_BUF_SIZE*10]; + sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0); + va_start(ap,zFormat); + sqlite3_str_vappendf(&acc, zFormat, ap); + va_end(ap); + sqlite3StrAccumFinish(&acc); +#ifdef SQLITE_OS_TRACE_PROC + { + extern void SQLITE_OS_TRACE_PROC(const char *zBuf, int nBuf); + SQLITE_OS_TRACE_PROC(zBuf, sizeof(zBuf)); + } +#else + fprintf(stdout,"%s", zBuf); + fflush(stdout); +#endif +} +#endif + + +/* +** variable-argument wrapper around sqlite3_str_vappendf(). The bFlags argument +** can contain the bit SQLITE_PRINTF_INTERNAL enable internal formats. +*/ +SQLITE_API void sqlite3_str_appendf(StrAccum *p, const char *zFormat, ...){ + va_list ap; + va_start(ap,zFormat); + sqlite3_str_vappendf(p, zFormat, ap); + va_end(ap); +} + +/************** End of printf.c **********************************************/ +/************** Begin file treeview.c ****************************************/ +/* +** 2015-06-08 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains C code to implement the TreeView debugging routines. +** These routines print a parse tree to standard output for debugging and +** analysis. +** +** The interfaces in this file is only available when compiling +** with SQLITE_DEBUG. +*/ +/* #include "sqliteInt.h" */ +#ifdef SQLITE_DEBUG + +/* +** Add a new subitem to the tree. The moreToFollow flag indicates that this +** is not the last item in the tree. +*/ +static void sqlite3TreeViewPush(TreeView **pp, u8 moreToFollow){ + TreeView *p = *pp; + if( p==0 ){ + *pp = p = sqlite3_malloc64( sizeof(*p) ); + if( p==0 ) return; + memset(p, 0, sizeof(*p)); + }else{ + p->iLevel++; + } + assert( moreToFollow==0 || moreToFollow==1 ); + if( p->iLevel<(int)sizeof(p->bLine) ) p->bLine[p->iLevel] = moreToFollow; +} + +/* +** Finished with one layer of the tree +*/ +static void sqlite3TreeViewPop(TreeView **pp){ + TreeView *p = *pp; + if( p==0 ) return; + p->iLevel--; + if( p->iLevel<0 ){ + sqlite3_free(p); + *pp = 0; + } +} + +/* +** Generate a single line of output for the tree, with a prefix that contains +** all the appropriate tree lines +*/ +SQLITE_PRIVATE void sqlite3TreeViewLine(TreeView *p, const char *zFormat, ...){ + va_list ap; + int i; + StrAccum acc; + char zBuf[1000]; + sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0); + if( p ){ + for(i=0; iiLevel && i<(int)sizeof(p->bLine)-1; i++){ + sqlite3_str_append(&acc, p->bLine[i] ? "| " : " ", 4); + } + sqlite3_str_append(&acc, p->bLine[i] ? "|-- " : "'-- ", 4); + } + if( zFormat!=0 ){ + va_start(ap, zFormat); + sqlite3_str_vappendf(&acc, zFormat, ap); + va_end(ap); + assert( acc.nChar>0 || acc.accError ); + sqlite3_str_append(&acc, "\n", 1); + } + sqlite3StrAccumFinish(&acc); + fprintf(stdout,"%s", zBuf); + fflush(stdout); +} + +/* +** Shorthand for starting a new tree item that consists of a single label +*/ +static void sqlite3TreeViewItem(TreeView *p, const char *zLabel,u8 moreFollows){ + sqlite3TreeViewPush(&p, moreFollows); + sqlite3TreeViewLine(p, "%s", zLabel); +} + +/* +** Show a list of Column objects in tree format. +*/ +SQLITE_PRIVATE void sqlite3TreeViewColumnList( + TreeView *pView, + const Column *aCol, + int nCol, + u8 moreToFollow +){ + int i; + sqlite3TreeViewPush(&pView, moreToFollow); + sqlite3TreeViewLine(pView, "COLUMNS"); + for(i=0; inCte==0 ) return; + if( pWith->pOuter ){ + sqlite3TreeViewLine(pView, "WITH (0x%p, pOuter=0x%p)",pWith,pWith->pOuter); + }else{ + sqlite3TreeViewLine(pView, "WITH (0x%p)", pWith); + } + if( pWith->nCte>0 ){ + sqlite3TreeViewPush(&pView, moreToFollow); + for(i=0; inCte; i++){ + StrAccum x; + char zLine[1000]; + const struct Cte *pCte = &pWith->a[i]; + sqlite3StrAccumInit(&x, 0, zLine, sizeof(zLine), 0); + sqlite3_str_appendf(&x, "%s", pCte->zName); + if( pCte->pCols && pCte->pCols->nExpr>0 ){ + char cSep = '('; + int j; + for(j=0; jpCols->nExpr; j++){ + sqlite3_str_appendf(&x, "%c%s", cSep, pCte->pCols->a[j].zEName); + cSep = ','; + } + sqlite3_str_appendf(&x, ")"); + } + if( pCte->eM10d!=M10d_Any ){ + sqlite3_str_appendf(&x, " %sMATERIALIZED", + pCte->eM10d==M10d_No ? "NOT " : ""); + } + if( pCte->pUse ){ + sqlite3_str_appendf(&x, " (pUse=0x%p, nUse=%d)", pCte->pUse, + pCte->pUse->nUse); + } + sqlite3StrAccumFinish(&x); + sqlite3TreeViewItem(pView, zLine, inCte-1); + sqlite3TreeViewSelect(pView, pCte->pSelect, 0); + sqlite3TreeViewPop(&pView); + } + sqlite3TreeViewPop(&pView); + } +} + +/* +** Generate a human-readable description of a SrcList object. +*/ +SQLITE_PRIVATE void sqlite3TreeViewSrcList(TreeView *pView, const SrcList *pSrc){ + int i; + if( pSrc==0 ) return; + for(i=0; inSrc; i++){ + const SrcItem *pItem = &pSrc->a[i]; + StrAccum x; + int n = 0; + char zLine[1000]; + sqlite3StrAccumInit(&x, 0, zLine, sizeof(zLine), 0); + x.printfFlags |= SQLITE_PRINTF_INTERNAL; + sqlite3_str_appendf(&x, "{%d:*} %!S", pItem->iCursor, pItem); + if( pItem->pTab ){ + sqlite3_str_appendf(&x, " tab=%Q nCol=%d ptr=%p used=%llx", + pItem->pTab->zName, pItem->pTab->nCol, pItem->pTab, pItem->colUsed); + } + if( (pItem->fg.jointype & (JT_LEFT|JT_RIGHT))==(JT_LEFT|JT_RIGHT) ){ + sqlite3_str_appendf(&x, " FULL-OUTER-JOIN"); + }else if( pItem->fg.jointype & JT_LEFT ){ + sqlite3_str_appendf(&x, " LEFT-JOIN"); + }else if( pItem->fg.jointype & JT_RIGHT ){ + sqlite3_str_appendf(&x, " RIGHT-JOIN"); + }else if( pItem->fg.jointype & JT_CROSS ){ + sqlite3_str_appendf(&x, " CROSS-JOIN"); + } + if( pItem->fg.jointype & JT_LTORJ ){ + sqlite3_str_appendf(&x, " LTORJ"); + } + if( pItem->fg.fromDDL ){ + sqlite3_str_appendf(&x, " DDL"); + } + if( pItem->fg.isCte ){ + sqlite3_str_appendf(&x, " CteUse=0x%p", pItem->u2.pCteUse); + } + if( pItem->fg.isOn || (pItem->fg.isUsing==0 && pItem->u3.pOn!=0) ){ + sqlite3_str_appendf(&x, " ON"); + } + if( pItem->fg.isTabFunc ) sqlite3_str_appendf(&x, " isTabFunc"); + if( pItem->fg.isCorrelated ) sqlite3_str_appendf(&x, " isCorrelated"); + if( pItem->fg.isMaterialized ) sqlite3_str_appendf(&x, " isMaterialized"); + if( pItem->fg.viaCoroutine ) sqlite3_str_appendf(&x, " viaCoroutine"); + if( pItem->fg.notCte ) sqlite3_str_appendf(&x, " notCte"); + if( pItem->fg.isNestedFrom ) sqlite3_str_appendf(&x, " isNestedFrom"); + + sqlite3StrAccumFinish(&x); + sqlite3TreeViewItem(pView, zLine, inSrc-1); + n = 0; + if( pItem->pSelect ) n++; + if( pItem->fg.isTabFunc ) n++; + if( pItem->fg.isUsing ) n++; + if( pItem->fg.isUsing ){ + sqlite3TreeViewIdList(pView, pItem->u3.pUsing, (--n)>0, "USING"); + } + if( pItem->pSelect ){ + if( pItem->pTab ){ + Table *pTab = pItem->pTab; + sqlite3TreeViewColumnList(pView, pTab->aCol, pTab->nCol, 1); + } + assert( (int)pItem->fg.isNestedFrom == IsNestedFrom(pItem->pSelect) ); + sqlite3TreeViewSelect(pView, pItem->pSelect, (--n)>0); + } + if( pItem->fg.isTabFunc ){ + sqlite3TreeViewExprList(pView, pItem->u1.pFuncArg, 0, "func-args:"); + } + sqlite3TreeViewPop(&pView); + } +} + +/* +** Generate a human-readable description of a Select object. +*/ +SQLITE_PRIVATE void sqlite3TreeViewSelect(TreeView *pView, const Select *p, u8 moreToFollow){ + int n = 0; + int cnt = 0; + if( p==0 ){ + sqlite3TreeViewLine(pView, "nil-SELECT"); + return; + } + sqlite3TreeViewPush(&pView, moreToFollow); + if( p->pWith ){ + sqlite3TreeViewWith(pView, p->pWith, 1); + cnt = 1; + sqlite3TreeViewPush(&pView, 1); + } + do{ + if( p->selFlags & SF_WhereBegin ){ + sqlite3TreeViewLine(pView, "sqlite3WhereBegin()"); + }else{ + sqlite3TreeViewLine(pView, + "SELECT%s%s (%u/%p) selFlags=0x%x nSelectRow=%d", + ((p->selFlags & SF_Distinct) ? " DISTINCT" : ""), + ((p->selFlags & SF_Aggregate) ? " agg_flag" : ""), + p->selId, p, p->selFlags, + (int)p->nSelectRow + ); + } + if( cnt++ ) sqlite3TreeViewPop(&pView); + if( p->pPrior ){ + n = 1000; + }else{ + n = 0; + if( p->pSrc && p->pSrc->nSrc ) n++; + if( p->pWhere ) n++; + if( p->pGroupBy ) n++; + if( p->pHaving ) n++; + if( p->pOrderBy ) n++; + if( p->pLimit ) n++; +#ifndef SQLITE_OMIT_WINDOWFUNC + if( p->pWin ) n++; + if( p->pWinDefn ) n++; +#endif + } + if( p->pEList ){ + sqlite3TreeViewExprList(pView, p->pEList, n>0, "result-set"); + } + n--; +#ifndef SQLITE_OMIT_WINDOWFUNC + if( p->pWin ){ + Window *pX; + sqlite3TreeViewPush(&pView, (n--)>0); + sqlite3TreeViewLine(pView, "window-functions"); + for(pX=p->pWin; pX; pX=pX->pNextWin){ + sqlite3TreeViewWinFunc(pView, pX, pX->pNextWin!=0); + } + sqlite3TreeViewPop(&pView); + } +#endif + if( p->pSrc && p->pSrc->nSrc ){ + sqlite3TreeViewPush(&pView, (n--)>0); + sqlite3TreeViewLine(pView, "FROM"); + sqlite3TreeViewSrcList(pView, p->pSrc); + sqlite3TreeViewPop(&pView); + } + if( p->pWhere ){ + sqlite3TreeViewItem(pView, "WHERE", (n--)>0); + sqlite3TreeViewExpr(pView, p->pWhere, 0); + sqlite3TreeViewPop(&pView); + } + if( p->pGroupBy ){ + sqlite3TreeViewExprList(pView, p->pGroupBy, (n--)>0, "GROUPBY"); + } + if( p->pHaving ){ + sqlite3TreeViewItem(pView, "HAVING", (n--)>0); + sqlite3TreeViewExpr(pView, p->pHaving, 0); + sqlite3TreeViewPop(&pView); + } +#ifndef SQLITE_OMIT_WINDOWFUNC + if( p->pWinDefn ){ + Window *pX; + sqlite3TreeViewItem(pView, "WINDOW", (n--)>0); + for(pX=p->pWinDefn; pX; pX=pX->pNextWin){ + sqlite3TreeViewWindow(pView, pX, pX->pNextWin!=0); + } + sqlite3TreeViewPop(&pView); + } +#endif + if( p->pOrderBy ){ + sqlite3TreeViewExprList(pView, p->pOrderBy, (n--)>0, "ORDERBY"); + } + if( p->pLimit ){ + sqlite3TreeViewItem(pView, "LIMIT", (n--)>0); + sqlite3TreeViewExpr(pView, p->pLimit->pLeft, p->pLimit->pRight!=0); + if( p->pLimit->pRight ){ + sqlite3TreeViewItem(pView, "OFFSET", (n--)>0); + sqlite3TreeViewExpr(pView, p->pLimit->pRight, 0); + sqlite3TreeViewPop(&pView); + } + sqlite3TreeViewPop(&pView); + } + if( p->pPrior ){ + const char *zOp = "UNION"; + switch( p->op ){ + case TK_ALL: zOp = "UNION ALL"; break; + case TK_INTERSECT: zOp = "INTERSECT"; break; + case TK_EXCEPT: zOp = "EXCEPT"; break; + } + sqlite3TreeViewItem(pView, zOp, 1); + } + p = p->pPrior; + }while( p!=0 ); + sqlite3TreeViewPop(&pView); +} + +#ifndef SQLITE_OMIT_WINDOWFUNC +/* +** Generate a description of starting or stopping bounds +*/ +SQLITE_PRIVATE void sqlite3TreeViewBound( + TreeView *pView, /* View context */ + u8 eBound, /* UNBOUNDED, CURRENT, PRECEDING, FOLLOWING */ + Expr *pExpr, /* Value for PRECEDING or FOLLOWING */ + u8 moreToFollow /* True if more to follow */ +){ + switch( eBound ){ + case TK_UNBOUNDED: { + sqlite3TreeViewItem(pView, "UNBOUNDED", moreToFollow); + sqlite3TreeViewPop(&pView); + break; + } + case TK_CURRENT: { + sqlite3TreeViewItem(pView, "CURRENT", moreToFollow); + sqlite3TreeViewPop(&pView); + break; + } + case TK_PRECEDING: { + sqlite3TreeViewItem(pView, "PRECEDING", moreToFollow); + sqlite3TreeViewExpr(pView, pExpr, 0); + sqlite3TreeViewPop(&pView); + break; + } + case TK_FOLLOWING: { + sqlite3TreeViewItem(pView, "FOLLOWING", moreToFollow); + sqlite3TreeViewExpr(pView, pExpr, 0); + sqlite3TreeViewPop(&pView); + break; + } + } +} +#endif /* SQLITE_OMIT_WINDOWFUNC */ + +#ifndef SQLITE_OMIT_WINDOWFUNC +/* +** Generate a human-readable explanation for a Window object +*/ +SQLITE_PRIVATE void sqlite3TreeViewWindow(TreeView *pView, const Window *pWin, u8 more){ + int nElement = 0; + if( pWin==0 ) return; + if( pWin->pFilter ){ + sqlite3TreeViewItem(pView, "FILTER", 1); + sqlite3TreeViewExpr(pView, pWin->pFilter, 0); + sqlite3TreeViewPop(&pView); + } + sqlite3TreeViewPush(&pView, more); + if( pWin->zName ){ + sqlite3TreeViewLine(pView, "OVER %s (%p)", pWin->zName, pWin); + }else{ + sqlite3TreeViewLine(pView, "OVER (%p)", pWin); + } + if( pWin->zBase ) nElement++; + if( pWin->pOrderBy ) nElement++; + if( pWin->eFrmType ) nElement++; + if( pWin->eExclude ) nElement++; + if( pWin->zBase ){ + sqlite3TreeViewPush(&pView, (--nElement)>0); + sqlite3TreeViewLine(pView, "window: %s", pWin->zBase); + sqlite3TreeViewPop(&pView); + } + if( pWin->pPartition ){ + sqlite3TreeViewExprList(pView, pWin->pPartition, nElement>0,"PARTITION-BY"); + } + if( pWin->pOrderBy ){ + sqlite3TreeViewExprList(pView, pWin->pOrderBy, (--nElement)>0, "ORDER-BY"); + } + if( pWin->eFrmType ){ + char zBuf[30]; + const char *zFrmType = "ROWS"; + if( pWin->eFrmType==TK_RANGE ) zFrmType = "RANGE"; + if( pWin->eFrmType==TK_GROUPS ) zFrmType = "GROUPS"; + sqlite3_snprintf(sizeof(zBuf),zBuf,"%s%s",zFrmType, + pWin->bImplicitFrame ? " (implied)" : ""); + sqlite3TreeViewItem(pView, zBuf, (--nElement)>0); + sqlite3TreeViewBound(pView, pWin->eStart, pWin->pStart, 1); + sqlite3TreeViewBound(pView, pWin->eEnd, pWin->pEnd, 0); + sqlite3TreeViewPop(&pView); + } + if( pWin->eExclude ){ + char zBuf[30]; + const char *zExclude; + switch( pWin->eExclude ){ + case TK_NO: zExclude = "NO OTHERS"; break; + case TK_CURRENT: zExclude = "CURRENT ROW"; break; + case TK_GROUP: zExclude = "GROUP"; break; + case TK_TIES: zExclude = "TIES"; break; + default: + sqlite3_snprintf(sizeof(zBuf),zBuf,"invalid(%d)", pWin->eExclude); + zExclude = zBuf; + break; + } + sqlite3TreeViewPush(&pView, 0); + sqlite3TreeViewLine(pView, "EXCLUDE %s", zExclude); + sqlite3TreeViewPop(&pView); + } + sqlite3TreeViewPop(&pView); +} +#endif /* SQLITE_OMIT_WINDOWFUNC */ + +#ifndef SQLITE_OMIT_WINDOWFUNC +/* +** Generate a human-readable explanation for a Window Function object +*/ +SQLITE_PRIVATE void sqlite3TreeViewWinFunc(TreeView *pView, const Window *pWin, u8 more){ + if( pWin==0 ) return; + sqlite3TreeViewPush(&pView, more); + sqlite3TreeViewLine(pView, "WINFUNC %s(%d)", + pWin->pWFunc->zName, pWin->pWFunc->nArg); + sqlite3TreeViewWindow(pView, pWin, 0); + sqlite3TreeViewPop(&pView); +} +#endif /* SQLITE_OMIT_WINDOWFUNC */ + +/* +** Generate a human-readable explanation of an expression tree. +*/ +SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 moreToFollow){ + const char *zBinOp = 0; /* Binary operator */ + const char *zUniOp = 0; /* Unary operator */ + char zFlgs[200]; + sqlite3TreeViewPush(&pView, moreToFollow); + if( pExpr==0 ){ + sqlite3TreeViewLine(pView, "nil"); + sqlite3TreeViewPop(&pView); + return; + } + if( pExpr->flags || pExpr->affExpr || pExpr->vvaFlags || pExpr->pAggInfo ){ + StrAccum x; + sqlite3StrAccumInit(&x, 0, zFlgs, sizeof(zFlgs), 0); + sqlite3_str_appendf(&x, " fg.af=%x.%c", + pExpr->flags, pExpr->affExpr ? pExpr->affExpr : 'n'); + if( ExprHasProperty(pExpr, EP_OuterON) ){ + sqlite3_str_appendf(&x, " outer.iJoin=%d", pExpr->w.iJoin); + } + if( ExprHasProperty(pExpr, EP_InnerON) ){ + sqlite3_str_appendf(&x, " inner.iJoin=%d", pExpr->w.iJoin); + } + if( ExprHasProperty(pExpr, EP_FromDDL) ){ + sqlite3_str_appendf(&x, " DDL"); + } + if( ExprHasVVAProperty(pExpr, EP_Immutable) ){ + sqlite3_str_appendf(&x, " IMMUTABLE"); + } + if( pExpr->pAggInfo!=0 ){ + sqlite3_str_appendf(&x, " agg-column[%d]", pExpr->iAgg); + } + sqlite3StrAccumFinish(&x); + }else{ + zFlgs[0] = 0; + } + switch( pExpr->op ){ + case TK_AGG_COLUMN: { + sqlite3TreeViewLine(pView, "AGG{%d:%d}%s", + pExpr->iTable, pExpr->iColumn, zFlgs); + break; + } + case TK_COLUMN: { + if( pExpr->iTable<0 ){ + /* This only happens when coding check constraints */ + char zOp2[16]; + if( pExpr->op2 ){ + sqlite3_snprintf(sizeof(zOp2),zOp2," op2=0x%02x",pExpr->op2); + }else{ + zOp2[0] = 0; + } + sqlite3TreeViewLine(pView, "COLUMN(%d)%s%s", + pExpr->iColumn, zFlgs, zOp2); + }else{ + assert( ExprUseYTab(pExpr) ); + sqlite3TreeViewLine(pView, "{%d:%d} pTab=%p%s", + pExpr->iTable, pExpr->iColumn, + pExpr->y.pTab, zFlgs); + } + if( ExprHasProperty(pExpr, EP_FixedCol) ){ + sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); + } + break; + } + case TK_INTEGER: { + if( pExpr->flags & EP_IntValue ){ + sqlite3TreeViewLine(pView, "%d", pExpr->u.iValue); + }else{ + sqlite3TreeViewLine(pView, "%s", pExpr->u.zToken); + } + break; + } +#ifndef SQLITE_OMIT_FLOATING_POINT + case TK_FLOAT: { + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken); + break; + } +#endif + case TK_STRING: { + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + sqlite3TreeViewLine(pView,"%Q", pExpr->u.zToken); + break; + } + case TK_NULL: { + sqlite3TreeViewLine(pView,"NULL"); + break; + } + case TK_TRUEFALSE: { + sqlite3TreeViewLine(pView,"%s%s", + sqlite3ExprTruthValue(pExpr) ? "TRUE" : "FALSE", zFlgs); + break; + } +#ifndef SQLITE_OMIT_BLOB_LITERAL + case TK_BLOB: { + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + sqlite3TreeViewLine(pView,"%s", pExpr->u.zToken); + break; + } +#endif + case TK_VARIABLE: { + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + sqlite3TreeViewLine(pView,"VARIABLE(%s,%d)", + pExpr->u.zToken, pExpr->iColumn); + break; + } + case TK_REGISTER: { + sqlite3TreeViewLine(pView,"REGISTER(%d)", pExpr->iTable); + break; + } + case TK_ID: { + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + sqlite3TreeViewLine(pView,"ID \"%w\"", pExpr->u.zToken); + break; + } +#ifndef SQLITE_OMIT_CAST + case TK_CAST: { + /* Expressions of the form: CAST(pLeft AS token) */ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + sqlite3TreeViewLine(pView,"CAST %Q", pExpr->u.zToken); + sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); + break; + } +#endif /* SQLITE_OMIT_CAST */ + case TK_LT: zBinOp = "LT"; break; + case TK_LE: zBinOp = "LE"; break; + case TK_GT: zBinOp = "GT"; break; + case TK_GE: zBinOp = "GE"; break; + case TK_NE: zBinOp = "NE"; break; + case TK_EQ: zBinOp = "EQ"; break; + case TK_IS: zBinOp = "IS"; break; + case TK_ISNOT: zBinOp = "ISNOT"; break; + case TK_AND: zBinOp = "AND"; break; + case TK_OR: zBinOp = "OR"; break; + case TK_PLUS: zBinOp = "ADD"; break; + case TK_STAR: zBinOp = "MUL"; break; + case TK_MINUS: zBinOp = "SUB"; break; + case TK_REM: zBinOp = "REM"; break; + case TK_BITAND: zBinOp = "BITAND"; break; + case TK_BITOR: zBinOp = "BITOR"; break; + case TK_SLASH: zBinOp = "DIV"; break; + case TK_LSHIFT: zBinOp = "LSHIFT"; break; + case TK_RSHIFT: zBinOp = "RSHIFT"; break; + case TK_CONCAT: zBinOp = "CONCAT"; break; + case TK_DOT: zBinOp = "DOT"; break; + case TK_LIMIT: zBinOp = "LIMIT"; break; + + case TK_UMINUS: zUniOp = "UMINUS"; break; + case TK_UPLUS: zUniOp = "UPLUS"; break; + case TK_BITNOT: zUniOp = "BITNOT"; break; + case TK_NOT: zUniOp = "NOT"; break; + case TK_ISNULL: zUniOp = "ISNULL"; break; + case TK_NOTNULL: zUniOp = "NOTNULL"; break; + + case TK_TRUTH: { + int x; + const char *azOp[] = { + "IS-FALSE", "IS-TRUE", "IS-NOT-FALSE", "IS-NOT-TRUE" + }; + assert( pExpr->op2==TK_IS || pExpr->op2==TK_ISNOT ); + assert( pExpr->pRight ); + assert( sqlite3ExprSkipCollate(pExpr->pRight)->op==TK_TRUEFALSE ); + x = (pExpr->op2==TK_ISNOT)*2 + sqlite3ExprTruthValue(pExpr->pRight); + zUniOp = azOp[x]; + break; + } + + case TK_SPAN: { + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + sqlite3TreeViewLine(pView, "SPAN %Q", pExpr->u.zToken); + sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); + break; + } + + case TK_COLLATE: { + /* COLLATE operators without the EP_Collate flag are intended to + ** emulate collation associated with a table column. These show + ** up in the treeview output as "SOFT-COLLATE". Explicit COLLATE + ** operators that appear in the original SQL always have the + ** EP_Collate bit set and appear in treeview output as just "COLLATE" */ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + sqlite3TreeViewLine(pView, "%sCOLLATE %Q%s", + !ExprHasProperty(pExpr, EP_Collate) ? "SOFT-" : "", + pExpr->u.zToken, zFlgs); + sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); + break; + } + + case TK_AGG_FUNCTION: + case TK_FUNCTION: { + ExprList *pFarg; /* List of function arguments */ + Window *pWin; + if( ExprHasProperty(pExpr, EP_TokenOnly) ){ + pFarg = 0; + pWin = 0; + }else{ + assert( ExprUseXList(pExpr) ); + pFarg = pExpr->x.pList; +#ifndef SQLITE_OMIT_WINDOWFUNC + pWin = ExprHasProperty(pExpr, EP_WinFunc) ? pExpr->y.pWin : 0; +#else + pWin = 0; +#endif + } + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + if( pExpr->op==TK_AGG_FUNCTION ){ + sqlite3TreeViewLine(pView, "AGG_FUNCTION%d %Q%s agg=%d[%d]/%p", + pExpr->op2, pExpr->u.zToken, zFlgs, + pExpr->pAggInfo ? pExpr->pAggInfo->selId : 0, + pExpr->iAgg, pExpr->pAggInfo); + }else if( pExpr->op2!=0 ){ + const char *zOp2; + char zBuf[8]; + sqlite3_snprintf(sizeof(zBuf),zBuf,"0x%02x",pExpr->op2); + zOp2 = zBuf; + if( pExpr->op2==NC_IsCheck ) zOp2 = "NC_IsCheck"; + if( pExpr->op2==NC_IdxExpr ) zOp2 = "NC_IdxExpr"; + if( pExpr->op2==NC_PartIdx ) zOp2 = "NC_PartIdx"; + if( pExpr->op2==NC_GenCol ) zOp2 = "NC_GenCol"; + sqlite3TreeViewLine(pView, "FUNCTION %Q%s op2=%s", + pExpr->u.zToken, zFlgs, zOp2); + }else{ + sqlite3TreeViewLine(pView, "FUNCTION %Q%s", pExpr->u.zToken, zFlgs); + } + if( pFarg ){ + sqlite3TreeViewExprList(pView, pFarg, pWin!=0, 0); + } +#ifndef SQLITE_OMIT_WINDOWFUNC + if( pWin ){ + sqlite3TreeViewWindow(pView, pWin, 0); + } +#endif + break; + } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_EXISTS: { + assert( ExprUseXSelect(pExpr) ); + sqlite3TreeViewLine(pView, "EXISTS-expr flags=0x%x", pExpr->flags); + sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); + break; + } + case TK_SELECT: { + assert( ExprUseXSelect(pExpr) ); + sqlite3TreeViewLine(pView, "subquery-expr flags=0x%x", pExpr->flags); + sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); + break; + } + case TK_IN: { + sqlite3_str *pStr = sqlite3_str_new(0); + char *z; + sqlite3_str_appendf(pStr, "IN flags=0x%x", pExpr->flags); + if( pExpr->iTable ) sqlite3_str_appendf(pStr, " iTable=%d",pExpr->iTable); + if( ExprHasProperty(pExpr, EP_Subrtn) ){ + sqlite3_str_appendf(pStr, " subrtn(%d,%d)", + pExpr->y.sub.regReturn, pExpr->y.sub.iAddr); + } + z = sqlite3_str_finish(pStr); + sqlite3TreeViewLine(pView, z); + sqlite3_free(z); + sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); + if( ExprUseXSelect(pExpr) ){ + sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0); + }else{ + sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0); + } + break; + } +#endif /* SQLITE_OMIT_SUBQUERY */ + + /* + ** x BETWEEN y AND z + ** + ** This is equivalent to + ** + ** x>=y AND x<=z + ** + ** X is stored in pExpr->pLeft. + ** Y is stored in pExpr->pList->a[0].pExpr. + ** Z is stored in pExpr->pList->a[1].pExpr. + */ + case TK_BETWEEN: { + const Expr *pX, *pY, *pZ; + pX = pExpr->pLeft; + assert( ExprUseXList(pExpr) ); + assert( pExpr->x.pList->nExpr==2 ); + pY = pExpr->x.pList->a[0].pExpr; + pZ = pExpr->x.pList->a[1].pExpr; + sqlite3TreeViewLine(pView, "BETWEEN"); + sqlite3TreeViewExpr(pView, pX, 1); + sqlite3TreeViewExpr(pView, pY, 1); + sqlite3TreeViewExpr(pView, pZ, 0); + break; + } + case TK_TRIGGER: { + /* If the opcode is TK_TRIGGER, then the expression is a reference + ** to a column in the new.* or old.* pseudo-tables available to + ** trigger programs. In this case Expr.iTable is set to 1 for the + ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn + ** is set to the column of the pseudo-table to read, or to -1 to + ** read the rowid field. + */ + sqlite3TreeViewLine(pView, "%s(%d)", + pExpr->iTable ? "NEW" : "OLD", pExpr->iColumn); + break; + } + case TK_CASE: { + sqlite3TreeViewLine(pView, "CASE"); + sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); + assert( ExprUseXList(pExpr) ); + sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0); + break; + } +#ifndef SQLITE_OMIT_TRIGGER + case TK_RAISE: { + const char *zType = "unk"; + switch( pExpr->affExpr ){ + case OE_Rollback: zType = "rollback"; break; + case OE_Abort: zType = "abort"; break; + case OE_Fail: zType = "fail"; break; + case OE_Ignore: zType = "ignore"; break; + } + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + sqlite3TreeViewLine(pView, "RAISE %s(%Q)", zType, pExpr->u.zToken); + break; + } +#endif + case TK_MATCH: { + sqlite3TreeViewLine(pView, "MATCH {%d:%d}%s", + pExpr->iTable, pExpr->iColumn, zFlgs); + sqlite3TreeViewExpr(pView, pExpr->pRight, 0); + break; + } + case TK_VECTOR: { + char *z = sqlite3_mprintf("VECTOR%s",zFlgs); + assert( ExprUseXList(pExpr) ); + sqlite3TreeViewBareExprList(pView, pExpr->x.pList, z); + sqlite3_free(z); + break; + } + case TK_SELECT_COLUMN: { + sqlite3TreeViewLine(pView, "SELECT-COLUMN %d of [0..%d]%s", + pExpr->iColumn, pExpr->iTable-1, + pExpr->pRight==pExpr->pLeft ? " (SELECT-owner)" : ""); + assert( ExprUseXSelect(pExpr->pLeft) ); + sqlite3TreeViewSelect(pView, pExpr->pLeft->x.pSelect, 0); + break; + } + case TK_IF_NULL_ROW: { + sqlite3TreeViewLine(pView, "IF-NULL-ROW %d", pExpr->iTable); + sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); + break; + } + case TK_ERROR: { + Expr tmp; + sqlite3TreeViewLine(pView, "ERROR"); + tmp = *pExpr; + tmp.op = pExpr->op2; + sqlite3TreeViewExpr(pView, &tmp, 0); + break; + } + case TK_ROW: { + if( pExpr->iColumn<=0 ){ + sqlite3TreeViewLine(pView, "First FROM table rowid"); + }else{ + sqlite3TreeViewLine(pView, "First FROM table column %d", + pExpr->iColumn-1); + } + break; + } + default: { + sqlite3TreeViewLine(pView, "op=%d", pExpr->op); + break; + } + } + if( zBinOp ){ + sqlite3TreeViewLine(pView, "%s%s", zBinOp, zFlgs); + sqlite3TreeViewExpr(pView, pExpr->pLeft, 1); + sqlite3TreeViewExpr(pView, pExpr->pRight, 0); + }else if( zUniOp ){ + sqlite3TreeViewLine(pView, "%s%s", zUniOp, zFlgs); + sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); + } + sqlite3TreeViewPop(&pView); +} + + +/* +** Generate a human-readable explanation of an expression list. +*/ +SQLITE_PRIVATE void sqlite3TreeViewBareExprList( + TreeView *pView, + const ExprList *pList, + const char *zLabel +){ + if( zLabel==0 || zLabel[0]==0 ) zLabel = "LIST"; + if( pList==0 ){ + sqlite3TreeViewLine(pView, "%s (empty)", zLabel); + }else{ + int i; + sqlite3TreeViewLine(pView, "%s", zLabel); + for(i=0; inExpr; i++){ + int j = pList->a[i].u.x.iOrderByCol; + char *zName = pList->a[i].zEName; + int moreToFollow = inExpr - 1; + if( j || zName ){ + sqlite3TreeViewPush(&pView, moreToFollow); + moreToFollow = 0; + sqlite3TreeViewLine(pView, 0); + if( zName ){ + switch( pList->a[i].fg.eEName ){ + default: + fprintf(stdout, "AS %s ", zName); + break; + case ENAME_TAB: + fprintf(stdout, "TABLE-ALIAS-NAME(\"%s\") ", zName); + if( pList->a[i].fg.bUsed ) fprintf(stdout, "(used) "); + if( pList->a[i].fg.bUsingTerm ) fprintf(stdout, "(USING-term) "); + if( pList->a[i].fg.bNoExpand ) fprintf(stdout, "(NoExpand) "); + break; + case ENAME_SPAN: + fprintf(stdout, "SPAN(\"%s\") ", zName); + break; + } + } + if( j ){ + fprintf(stdout, "iOrderByCol=%d", j); + } + fprintf(stdout, "\n"); + fflush(stdout); + } + sqlite3TreeViewExpr(pView, pList->a[i].pExpr, moreToFollow); + if( j || zName ){ + sqlite3TreeViewPop(&pView); + } + } + } +} +SQLITE_PRIVATE void sqlite3TreeViewExprList( + TreeView *pView, + const ExprList *pList, + u8 moreToFollow, + const char *zLabel +){ + sqlite3TreeViewPush(&pView, moreToFollow); + sqlite3TreeViewBareExprList(pView, pList, zLabel); + sqlite3TreeViewPop(&pView); +} + +/* +** Generate a human-readable explanation of an id-list. +*/ +SQLITE_PRIVATE void sqlite3TreeViewBareIdList( + TreeView *pView, + const IdList *pList, + const char *zLabel +){ + if( zLabel==0 || zLabel[0]==0 ) zLabel = "LIST"; + if( pList==0 ){ + sqlite3TreeViewLine(pView, "%s (empty)", zLabel); + }else{ + int i; + sqlite3TreeViewLine(pView, "%s", zLabel); + for(i=0; inId; i++){ + char *zName = pList->a[i].zName; + int moreToFollow = inId - 1; + if( zName==0 ) zName = "(null)"; + sqlite3TreeViewPush(&pView, moreToFollow); + sqlite3TreeViewLine(pView, 0); + if( pList->eU4==EU4_NONE ){ + fprintf(stdout, "%s\n", zName); + }else if( pList->eU4==EU4_IDX ){ + fprintf(stdout, "%s (%d)\n", zName, pList->a[i].u4.idx); + }else{ + assert( pList->eU4==EU4_EXPR ); + if( pList->a[i].u4.pExpr==0 ){ + fprintf(stdout, "%s (pExpr=NULL)\n", zName); + }else{ + fprintf(stdout, "%s\n", zName); + sqlite3TreeViewPush(&pView, inId-1); + sqlite3TreeViewExpr(pView, pList->a[i].u4.pExpr, 0); + sqlite3TreeViewPop(&pView); + } + } + sqlite3TreeViewPop(&pView); + } + } +} +SQLITE_PRIVATE void sqlite3TreeViewIdList( + TreeView *pView, + const IdList *pList, + u8 moreToFollow, + const char *zLabel +){ + sqlite3TreeViewPush(&pView, moreToFollow); + sqlite3TreeViewBareIdList(pView, pList, zLabel); + sqlite3TreeViewPop(&pView); +} + +/* +** Generate a human-readable explanation of a list of Upsert objects +*/ +SQLITE_PRIVATE void sqlite3TreeViewUpsert( + TreeView *pView, + const Upsert *pUpsert, + u8 moreToFollow +){ + if( pUpsert==0 ) return; + sqlite3TreeViewPush(&pView, moreToFollow); + while( pUpsert ){ + int n; + sqlite3TreeViewPush(&pView, pUpsert->pNextUpsert!=0 || moreToFollow); + sqlite3TreeViewLine(pView, "ON CONFLICT DO %s", + pUpsert->isDoUpdate ? "UPDATE" : "NOTHING"); + n = (pUpsert->pUpsertSet!=0) + (pUpsert->pUpsertWhere!=0); + sqlite3TreeViewExprList(pView, pUpsert->pUpsertTarget, (n--)>0, "TARGET"); + sqlite3TreeViewExprList(pView, pUpsert->pUpsertSet, (n--)>0, "SET"); + if( pUpsert->pUpsertWhere ){ + sqlite3TreeViewItem(pView, "WHERE", (n--)>0); + sqlite3TreeViewExpr(pView, pUpsert->pUpsertWhere, 0); + sqlite3TreeViewPop(&pView); + } + sqlite3TreeViewPop(&pView); + pUpsert = pUpsert->pNextUpsert; + } + sqlite3TreeViewPop(&pView); +} + +#if TREETRACE_ENABLED +/* +** Generate a human-readable diagram of the data structure that go +** into generating an DELETE statement. +*/ +SQLITE_PRIVATE void sqlite3TreeViewDelete( + const With *pWith, + const SrcList *pTabList, + const Expr *pWhere, + const ExprList *pOrderBy, + const Expr *pLimit, + const Trigger *pTrigger +){ + int n = 0; + TreeView *pView = 0; + sqlite3TreeViewPush(&pView, 0); + sqlite3TreeViewLine(pView, "DELETE"); + if( pWith ) n++; + if( pTabList ) n++; + if( pWhere ) n++; + if( pOrderBy ) n++; + if( pLimit ) n++; + if( pTrigger ) n++; + if( pWith ){ + sqlite3TreeViewPush(&pView, (--n)>0); + sqlite3TreeViewWith(pView, pWith, 0); + sqlite3TreeViewPop(&pView); + } + if( pTabList ){ + sqlite3TreeViewPush(&pView, (--n)>0); + sqlite3TreeViewLine(pView, "FROM"); + sqlite3TreeViewSrcList(pView, pTabList); + sqlite3TreeViewPop(&pView); + } + if( pWhere ){ + sqlite3TreeViewPush(&pView, (--n)>0); + sqlite3TreeViewLine(pView, "WHERE"); + sqlite3TreeViewExpr(pView, pWhere, 0); + sqlite3TreeViewPop(&pView); + } + if( pOrderBy ){ + sqlite3TreeViewExprList(pView, pOrderBy, (--n)>0, "ORDER-BY"); + } + if( pLimit ){ + sqlite3TreeViewPush(&pView, (--n)>0); + sqlite3TreeViewLine(pView, "LIMIT"); + sqlite3TreeViewExpr(pView, pLimit, 0); + sqlite3TreeViewPop(&pView); + } + if( pTrigger ){ + sqlite3TreeViewTrigger(pView, pTrigger, (--n)>0, 1); + } + sqlite3TreeViewPop(&pView); +} +#endif /* TREETRACE_ENABLED */ + +#if TREETRACE_ENABLED +/* +** Generate a human-readable diagram of the data structure that go +** into generating an INSERT statement. +*/ +SQLITE_PRIVATE void sqlite3TreeViewInsert( + const With *pWith, + const SrcList *pTabList, + const IdList *pColumnList, + const Select *pSelect, + const ExprList *pExprList, + int onError, + const Upsert *pUpsert, + const Trigger *pTrigger +){ + TreeView *pView = 0; + int n = 0; + const char *zLabel = "INSERT"; + switch( onError ){ + case OE_Replace: zLabel = "REPLACE"; break; + case OE_Ignore: zLabel = "INSERT OR IGNORE"; break; + case OE_Rollback: zLabel = "INSERT OR ROLLBACK"; break; + case OE_Abort: zLabel = "INSERT OR ABORT"; break; + case OE_Fail: zLabel = "INSERT OR FAIL"; break; + } + sqlite3TreeViewPush(&pView, 0); + sqlite3TreeViewLine(pView, zLabel); + if( pWith ) n++; + if( pTabList ) n++; + if( pColumnList ) n++; + if( pSelect ) n++; + if( pExprList ) n++; + if( pUpsert ) n++; + if( pTrigger ) n++; + if( pWith ){ + sqlite3TreeViewPush(&pView, (--n)>0); + sqlite3TreeViewWith(pView, pWith, 0); + sqlite3TreeViewPop(&pView); + } + if( pTabList ){ + sqlite3TreeViewPush(&pView, (--n)>0); + sqlite3TreeViewLine(pView, "INTO"); + sqlite3TreeViewSrcList(pView, pTabList); + sqlite3TreeViewPop(&pView); + } + if( pColumnList ){ + sqlite3TreeViewIdList(pView, pColumnList, (--n)>0, "COLUMNS"); + } + if( pSelect ){ + sqlite3TreeViewPush(&pView, (--n)>0); + sqlite3TreeViewLine(pView, "DATA-SOURCE"); + sqlite3TreeViewSelect(pView, pSelect, 0); + sqlite3TreeViewPop(&pView); + } + if( pExprList ){ + sqlite3TreeViewExprList(pView, pExprList, (--n)>0, "VALUES"); + } + if( pUpsert ){ + sqlite3TreeViewPush(&pView, (--n)>0); + sqlite3TreeViewLine(pView, "UPSERT"); + sqlite3TreeViewUpsert(pView, pUpsert, 0); + sqlite3TreeViewPop(&pView); + } + if( pTrigger ){ + sqlite3TreeViewTrigger(pView, pTrigger, (--n)>0, 1); + } + sqlite3TreeViewPop(&pView); +} +#endif /* TREETRACE_ENABLED */ + +#if TREETRACE_ENABLED +/* +** Generate a human-readable diagram of the data structure that go +** into generating an UPDATE statement. +*/ +SQLITE_PRIVATE void sqlite3TreeViewUpdate( + const With *pWith, + const SrcList *pTabList, + const ExprList *pChanges, + const Expr *pWhere, + int onError, + const ExprList *pOrderBy, + const Expr *pLimit, + const Upsert *pUpsert, + const Trigger *pTrigger +){ + int n = 0; + TreeView *pView = 0; + const char *zLabel = "UPDATE"; + switch( onError ){ + case OE_Replace: zLabel = "UPDATE OR REPLACE"; break; + case OE_Ignore: zLabel = "UPDATE OR IGNORE"; break; + case OE_Rollback: zLabel = "UPDATE OR ROLLBACK"; break; + case OE_Abort: zLabel = "UPDATE OR ABORT"; break; + case OE_Fail: zLabel = "UPDATE OR FAIL"; break; + } + sqlite3TreeViewPush(&pView, 0); + sqlite3TreeViewLine(pView, zLabel); + if( pWith ) n++; + if( pTabList ) n++; + if( pChanges ) n++; + if( pWhere ) n++; + if( pOrderBy ) n++; + if( pLimit ) n++; + if( pUpsert ) n++; + if( pTrigger ) n++; + if( pWith ){ + sqlite3TreeViewPush(&pView, (--n)>0); + sqlite3TreeViewWith(pView, pWith, 0); + sqlite3TreeViewPop(&pView); + } + if( pTabList ){ + sqlite3TreeViewPush(&pView, (--n)>0); + sqlite3TreeViewLine(pView, "FROM"); + sqlite3TreeViewSrcList(pView, pTabList); + sqlite3TreeViewPop(&pView); + } + if( pChanges ){ + sqlite3TreeViewExprList(pView, pChanges, (--n)>0, "SET"); + } + if( pWhere ){ + sqlite3TreeViewPush(&pView, (--n)>0); + sqlite3TreeViewLine(pView, "WHERE"); + sqlite3TreeViewExpr(pView, pWhere, 0); + sqlite3TreeViewPop(&pView); + } + if( pOrderBy ){ + sqlite3TreeViewExprList(pView, pOrderBy, (--n)>0, "ORDER-BY"); + } + if( pLimit ){ + sqlite3TreeViewPush(&pView, (--n)>0); + sqlite3TreeViewLine(pView, "LIMIT"); + sqlite3TreeViewExpr(pView, pLimit, 0); + sqlite3TreeViewPop(&pView); + } + if( pUpsert ){ + sqlite3TreeViewPush(&pView, (--n)>0); + sqlite3TreeViewLine(pView, "UPSERT"); + sqlite3TreeViewUpsert(pView, pUpsert, 0); + sqlite3TreeViewPop(&pView); + } + if( pTrigger ){ + sqlite3TreeViewTrigger(pView, pTrigger, (--n)>0, 1); + } + sqlite3TreeViewPop(&pView); +} +#endif /* TREETRACE_ENABLED */ + +#ifndef SQLITE_OMIT_TRIGGER +/* +** Show a human-readable graph of a TriggerStep +*/ +SQLITE_PRIVATE void sqlite3TreeViewTriggerStep( + TreeView *pView, + const TriggerStep *pStep, + u8 moreToFollow, + u8 showFullList +){ + int cnt = 0; + if( pStep==0 ) return; + sqlite3TreeViewPush(&pView, + moreToFollow || (showFullList && pStep->pNext!=0)); + do{ + if( cnt++ && pStep->pNext==0 ){ + sqlite3TreeViewPop(&pView); + sqlite3TreeViewPush(&pView, 0); + } + sqlite3TreeViewLine(pView, "%s", pStep->zSpan ? pStep->zSpan : "RETURNING"); + }while( showFullList && (pStep = pStep->pNext)!=0 ); + sqlite3TreeViewPop(&pView); +} + +/* +** Show a human-readable graph of a Trigger +*/ +SQLITE_PRIVATE void sqlite3TreeViewTrigger( + TreeView *pView, + const Trigger *pTrigger, + u8 moreToFollow, + u8 showFullList +){ + int cnt = 0; + if( pTrigger==0 ) return; + sqlite3TreeViewPush(&pView, + moreToFollow || (showFullList && pTrigger->pNext!=0)); + do{ + if( cnt++ && pTrigger->pNext==0 ){ + sqlite3TreeViewPop(&pView); + sqlite3TreeViewPush(&pView, 0); + } + sqlite3TreeViewLine(pView, "TRIGGER %s", pTrigger->zName); + sqlite3TreeViewPush(&pView, 0); + sqlite3TreeViewTriggerStep(pView, pTrigger->step_list, 0, 1); + sqlite3TreeViewPop(&pView); + }while( showFullList && (pTrigger = pTrigger->pNext)!=0 ); + sqlite3TreeViewPop(&pView); +} +#endif /* SQLITE_OMIT_TRIGGER */ + + +/* +** These simplified versions of the tree-view routines omit unnecessary +** parameters. These variants are intended to be used from a symbolic +** debugger, such as "gdb", during interactive debugging sessions. +** +** This routines are given external linkage so that they will always be +** accessible to the debugging, and to avoid warnings about unused +** functions. But these routines only exist in debugging builds, so they +** do not contaminate the interface. +*/ +SQLITE_PRIVATE void sqlite3ShowExpr(const Expr *p){ sqlite3TreeViewExpr(0,p,0); } +SQLITE_PRIVATE void sqlite3ShowExprList(const ExprList *p){ sqlite3TreeViewExprList(0,p,0,0);} +SQLITE_PRIVATE void sqlite3ShowIdList(const IdList *p){ sqlite3TreeViewIdList(0,p,0,0); } +SQLITE_PRIVATE void sqlite3ShowSrcList(const SrcList *p){ sqlite3TreeViewSrcList(0,p); } +SQLITE_PRIVATE void sqlite3ShowSelect(const Select *p){ sqlite3TreeViewSelect(0,p,0); } +SQLITE_PRIVATE void sqlite3ShowWith(const With *p){ sqlite3TreeViewWith(0,p,0); } +SQLITE_PRIVATE void sqlite3ShowUpsert(const Upsert *p){ sqlite3TreeViewUpsert(0,p,0); } +#ifndef SQLITE_OMIT_TRIGGER +SQLITE_PRIVATE void sqlite3ShowTriggerStep(const TriggerStep *p){ + sqlite3TreeViewTriggerStep(0,p,0,0); +} +SQLITE_PRIVATE void sqlite3ShowTriggerStepList(const TriggerStep *p){ + sqlite3TreeViewTriggerStep(0,p,0,1); +} +SQLITE_PRIVATE void sqlite3ShowTrigger(const Trigger *p){ sqlite3TreeViewTrigger(0,p,0,0); } +SQLITE_PRIVATE void sqlite3ShowTriggerList(const Trigger *p){ sqlite3TreeViewTrigger(0,p,0,1);} +#endif +#ifndef SQLITE_OMIT_WINDOWFUNC +SQLITE_PRIVATE void sqlite3ShowWindow(const Window *p){ sqlite3TreeViewWindow(0,p,0); } +SQLITE_PRIVATE void sqlite3ShowWinFunc(const Window *p){ sqlite3TreeViewWinFunc(0,p,0); } +#endif + +#endif /* SQLITE_DEBUG */ + +/************** End of treeview.c ********************************************/ +/************** Begin file random.c ******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code to implement a pseudo-random number +** generator (PRNG) for SQLite. +** +** Random numbers are used by some of the database backends in order +** to generate random integer keys for tables or random filenames. +*/ +/* #include "sqliteInt.h" */ + + +/* All threads share a single random number generator. +** This structure is the current state of the generator. +*/ +static SQLITE_WSD struct sqlite3PrngType { + u32 s[16]; /* 64 bytes of chacha20 state */ + u8 out[64]; /* Output bytes */ + u8 n; /* Output bytes remaining */ +} sqlite3Prng; + + +/* The RFC-7539 ChaCha20 block function +*/ +#define ROTL(a,b) (((a) << (b)) | ((a) >> (32 - (b)))) +#define QR(a, b, c, d) ( \ + a += b, d ^= a, d = ROTL(d,16), \ + c += d, b ^= c, b = ROTL(b,12), \ + a += b, d ^= a, d = ROTL(d, 8), \ + c += d, b ^= c, b = ROTL(b, 7)) +static void chacha_block(u32 *out, const u32 *in){ + int i; + u32 x[16]; + memcpy(x, in, 64); + for(i=0; i<10; i++){ + QR(x[0], x[4], x[ 8], x[12]); + QR(x[1], x[5], x[ 9], x[13]); + QR(x[2], x[6], x[10], x[14]); + QR(x[3], x[7], x[11], x[15]); + QR(x[0], x[5], x[10], x[15]); + QR(x[1], x[6], x[11], x[12]); + QR(x[2], x[7], x[ 8], x[13]); + QR(x[3], x[4], x[ 9], x[14]); + } + for(i=0; i<16; i++) out[i] = x[i]+in[i]; +} + +/* +** Return N random bytes. +*/ +SQLITE_API void sqlite3_randomness(int N, void *pBuf){ + unsigned char *zBuf = pBuf; + + /* The "wsdPrng" macro will resolve to the pseudo-random number generator + ** state vector. If writable static data is unsupported on the target, + ** we have to locate the state vector at run-time. In the more common + ** case where writable static data is supported, wsdPrng can refer directly + ** to the "sqlite3Prng" state vector declared above. + */ +#ifdef SQLITE_OMIT_WSD + struct sqlite3PrngType *p = &GLOBAL(struct sqlite3PrngType, sqlite3Prng); +# define wsdPrng p[0] +#else +# define wsdPrng sqlite3Prng +#endif + +#if SQLITE_THREADSAFE + sqlite3_mutex *mutex; +#endif + +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return; +#endif + +#if SQLITE_THREADSAFE + mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_PRNG); +#endif + + sqlite3_mutex_enter(mutex); + if( N<=0 || pBuf==0 ){ + wsdPrng.s[0] = 0; + sqlite3_mutex_leave(mutex); + return; + } + + /* Initialize the state of the random number generator once, + ** the first time this routine is called. + */ + if( wsdPrng.s[0]==0 ){ + sqlite3_vfs *pVfs = sqlite3_vfs_find(0); + static const u32 chacha20_init[] = { + 0x61707865, 0x3320646e, 0x79622d32, 0x6b206574 + }; + memcpy(&wsdPrng.s[0], chacha20_init, 16); + if( NEVER(pVfs==0) ){ + memset(&wsdPrng.s[4], 0, 44); + }else{ + sqlite3OsRandomness(pVfs, 44, (char*)&wsdPrng.s[4]); + } + wsdPrng.s[15] = wsdPrng.s[12]; + wsdPrng.s[12] = 0; + wsdPrng.n = 0; + } + + assert( N>0 ); + while( 1 /* exit by break */ ){ + if( N<=wsdPrng.n ){ + memcpy(zBuf, &wsdPrng.out[wsdPrng.n-N], N); + wsdPrng.n -= N; + break; + } + if( wsdPrng.n>0 ){ + memcpy(zBuf, wsdPrng.out, wsdPrng.n); + N -= wsdPrng.n; + zBuf += wsdPrng.n; + } + wsdPrng.s[12]++; + chacha_block((u32*)wsdPrng.out, wsdPrng.s); + wsdPrng.n = 64; + } + sqlite3_mutex_leave(mutex); +} + +#ifndef SQLITE_UNTESTABLE +/* +** For testing purposes, we sometimes want to preserve the state of +** PRNG and restore the PRNG to its saved state at a later time, or +** to reset the PRNG to its initial state. These routines accomplish +** those tasks. +** +** The sqlite3_test_control() interface calls these routines to +** control the PRNG. +*/ +static SQLITE_WSD struct sqlite3PrngType sqlite3SavedPrng; +SQLITE_PRIVATE void sqlite3PrngSaveState(void){ + memcpy( + &GLOBAL(struct sqlite3PrngType, sqlite3SavedPrng), + &GLOBAL(struct sqlite3PrngType, sqlite3Prng), + sizeof(sqlite3Prng) + ); +} +SQLITE_PRIVATE void sqlite3PrngRestoreState(void){ + memcpy( + &GLOBAL(struct sqlite3PrngType, sqlite3Prng), + &GLOBAL(struct sqlite3PrngType, sqlite3SavedPrng), + sizeof(sqlite3Prng) + ); +} +#endif /* SQLITE_UNTESTABLE */ + +/************** End of random.c **********************************************/ +/************** Begin file threads.c *****************************************/ +/* +** 2012 July 21 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file presents a simple cross-platform threading interface for +** use internally by SQLite. +** +** A "thread" can be created using sqlite3ThreadCreate(). This thread +** runs independently of its creator until it is joined using +** sqlite3ThreadJoin(), at which point it terminates. +** +** Threads do not have to be real. It could be that the work of the +** "thread" is done by the main thread at either the sqlite3ThreadCreate() +** or sqlite3ThreadJoin() call. This is, in fact, what happens in +** single threaded systems. Nothing in SQLite requires multiple threads. +** This interface exists so that applications that want to take advantage +** of multiple cores can do so, while also allowing applications to stay +** single-threaded if desired. +*/ +/* #include "sqliteInt.h" */ +#if SQLITE_OS_WIN +/* # include "os_win.h" */ +#endif + +#if SQLITE_MAX_WORKER_THREADS>0 + +/********************************* Unix Pthreads ****************************/ +#if SQLITE_OS_UNIX && defined(SQLITE_MUTEX_PTHREADS) && SQLITE_THREADSAFE>0 + +#define SQLITE_THREADS_IMPLEMENTED 1 /* Prevent the single-thread code below */ +/* #include */ + +/* A running thread */ +struct SQLiteThread { + pthread_t tid; /* Thread ID */ + int done; /* Set to true when thread finishes */ + void *pOut; /* Result returned by the thread */ + void *(*xTask)(void*); /* The thread routine */ + void *pIn; /* Argument to the thread */ +}; + +/* Create a new thread */ +SQLITE_PRIVATE int sqlite3ThreadCreate( + SQLiteThread **ppThread, /* OUT: Write the thread object here */ + void *(*xTask)(void*), /* Routine to run in a separate thread */ + void *pIn /* Argument passed into xTask() */ +){ + SQLiteThread *p; + int rc; + + assert( ppThread!=0 ); + assert( xTask!=0 ); + /* This routine is never used in single-threaded mode */ + assert( sqlite3GlobalConfig.bCoreMutex!=0 ); + + *ppThread = 0; + p = sqlite3Malloc(sizeof(*p)); + if( p==0 ) return SQLITE_NOMEM_BKPT; + memset(p, 0, sizeof(*p)); + p->xTask = xTask; + p->pIn = pIn; + /* If the SQLITE_TESTCTRL_FAULT_INSTALL callback is registered to a + ** function that returns SQLITE_ERROR when passed the argument 200, that + ** forces worker threads to run sequentially and deterministically + ** for testing purposes. */ + if( sqlite3FaultSim(200) ){ + rc = 1; + }else{ + rc = pthread_create(&p->tid, 0, xTask, pIn); + } + if( rc ){ + p->done = 1; + p->pOut = xTask(pIn); + } + *ppThread = p; + return SQLITE_OK; +} + +/* Get the results of the thread */ +SQLITE_PRIVATE int sqlite3ThreadJoin(SQLiteThread *p, void **ppOut){ + int rc; + + assert( ppOut!=0 ); + if( NEVER(p==0) ) return SQLITE_NOMEM_BKPT; + if( p->done ){ + *ppOut = p->pOut; + rc = SQLITE_OK; + }else{ + rc = pthread_join(p->tid, ppOut) ? SQLITE_ERROR : SQLITE_OK; + } + sqlite3_free(p); + return rc; +} + +#endif /* SQLITE_OS_UNIX && defined(SQLITE_MUTEX_PTHREADS) */ +/******************************** End Unix Pthreads *************************/ + + +/********************************* Win32 Threads ****************************/ +#if SQLITE_OS_WIN_THREADS + +#define SQLITE_THREADS_IMPLEMENTED 1 /* Prevent the single-thread code below */ +#include + +/* A running thread */ +struct SQLiteThread { + void *tid; /* The thread handle */ + unsigned id; /* The thread identifier */ + void *(*xTask)(void*); /* The routine to run as a thread */ + void *pIn; /* Argument to xTask */ + void *pResult; /* Result of xTask */ +}; + +/* Thread procedure Win32 compatibility shim */ +static unsigned __stdcall sqlite3ThreadProc( + void *pArg /* IN: Pointer to the SQLiteThread structure */ +){ + SQLiteThread *p = (SQLiteThread *)pArg; + + assert( p!=0 ); +#if 0 + /* + ** This assert appears to trigger spuriously on certain + ** versions of Windows, possibly due to _beginthreadex() + ** and/or CreateThread() not fully setting their thread + ** ID parameter before starting the thread. + */ + assert( p->id==GetCurrentThreadId() ); +#endif + assert( p->xTask!=0 ); + p->pResult = p->xTask(p->pIn); + + _endthreadex(0); + return 0; /* NOT REACHED */ +} + +/* Create a new thread */ +SQLITE_PRIVATE int sqlite3ThreadCreate( + SQLiteThread **ppThread, /* OUT: Write the thread object here */ + void *(*xTask)(void*), /* Routine to run in a separate thread */ + void *pIn /* Argument passed into xTask() */ +){ + SQLiteThread *p; + + assert( ppThread!=0 ); + assert( xTask!=0 ); + *ppThread = 0; + p = sqlite3Malloc(sizeof(*p)); + if( p==0 ) return SQLITE_NOMEM_BKPT; + /* If the SQLITE_TESTCTRL_FAULT_INSTALL callback is registered to a + ** function that returns SQLITE_ERROR when passed the argument 200, that + ** forces worker threads to run sequentially and deterministically + ** (via the sqlite3FaultSim() term of the conditional) for testing + ** purposes. */ + if( sqlite3GlobalConfig.bCoreMutex==0 || sqlite3FaultSim(200) ){ + memset(p, 0, sizeof(*p)); + }else{ + p->xTask = xTask; + p->pIn = pIn; + p->tid = (void*)_beginthreadex(0, 0, sqlite3ThreadProc, p, 0, &p->id); + if( p->tid==0 ){ + memset(p, 0, sizeof(*p)); + } + } + if( p->xTask==0 ){ + p->id = GetCurrentThreadId(); + p->pResult = xTask(pIn); + } + *ppThread = p; + return SQLITE_OK; +} + +SQLITE_PRIVATE DWORD sqlite3Win32Wait(HANDLE hObject); /* os_win.c */ + +/* Get the results of the thread */ +SQLITE_PRIVATE int sqlite3ThreadJoin(SQLiteThread *p, void **ppOut){ + DWORD rc; + BOOL bRc; + + assert( ppOut!=0 ); + if( NEVER(p==0) ) return SQLITE_NOMEM_BKPT; + if( p->xTask==0 ){ + /* assert( p->id==GetCurrentThreadId() ); */ + rc = WAIT_OBJECT_0; + assert( p->tid==0 ); + }else{ + assert( p->id!=0 && p->id!=GetCurrentThreadId() ); + rc = sqlite3Win32Wait((HANDLE)p->tid); + assert( rc!=WAIT_IO_COMPLETION ); + bRc = CloseHandle((HANDLE)p->tid); + assert( bRc ); + } + if( rc==WAIT_OBJECT_0 ) *ppOut = p->pResult; + sqlite3_free(p); + return (rc==WAIT_OBJECT_0) ? SQLITE_OK : SQLITE_ERROR; +} + +#endif /* SQLITE_OS_WIN_THREADS */ +/******************************** End Win32 Threads *************************/ + + +/********************************* Single-Threaded **************************/ +#ifndef SQLITE_THREADS_IMPLEMENTED +/* +** This implementation does not actually create a new thread. It does the +** work of the thread in the main thread, when either the thread is created +** or when it is joined +*/ + +/* A running thread */ +struct SQLiteThread { + void *(*xTask)(void*); /* The routine to run as a thread */ + void *pIn; /* Argument to xTask */ + void *pResult; /* Result of xTask */ +}; + +/* Create a new thread */ +SQLITE_PRIVATE int sqlite3ThreadCreate( + SQLiteThread **ppThread, /* OUT: Write the thread object here */ + void *(*xTask)(void*), /* Routine to run in a separate thread */ + void *pIn /* Argument passed into xTask() */ +){ + SQLiteThread *p; + + assert( ppThread!=0 ); + assert( xTask!=0 ); + *ppThread = 0; + p = sqlite3Malloc(sizeof(*p)); + if( p==0 ) return SQLITE_NOMEM_BKPT; + if( (SQLITE_PTR_TO_INT(p)/17)&1 ){ + p->xTask = xTask; + p->pIn = pIn; + }else{ + p->xTask = 0; + p->pResult = xTask(pIn); + } + *ppThread = p; + return SQLITE_OK; +} + +/* Get the results of the thread */ +SQLITE_PRIVATE int sqlite3ThreadJoin(SQLiteThread *p, void **ppOut){ + + assert( ppOut!=0 ); + if( NEVER(p==0) ) return SQLITE_NOMEM_BKPT; + if( p->xTask ){ + *ppOut = p->xTask(p->pIn); + }else{ + *ppOut = p->pResult; + } + sqlite3_free(p); + +#if defined(SQLITE_TEST) + { + void *pTstAlloc = sqlite3Malloc(10); + if (!pTstAlloc) return SQLITE_NOMEM_BKPT; + sqlite3_free(pTstAlloc); + } +#endif + + return SQLITE_OK; +} + +#endif /* !defined(SQLITE_THREADS_IMPLEMENTED) */ +/****************************** End Single-Threaded *************************/ +#endif /* SQLITE_MAX_WORKER_THREADS>0 */ + +/************** End of threads.c *********************************************/ +/************** Begin file utf.c *********************************************/ +/* +** 2004 April 13 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains routines used to translate between UTF-8, +** UTF-16, UTF-16BE, and UTF-16LE. +** +** Notes on UTF-8: +** +** Byte-0 Byte-1 Byte-2 Byte-3 Value +** 0xxxxxxx 00000000 00000000 0xxxxxxx +** 110yyyyy 10xxxxxx 00000000 00000yyy yyxxxxxx +** 1110zzzz 10yyyyyy 10xxxxxx 00000000 zzzzyyyy yyxxxxxx +** 11110uuu 10uuzzzz 10yyyyyy 10xxxxxx 000uuuuu zzzzyyyy yyxxxxxx +** +** +** Notes on UTF-16: (with wwww+1==uuuuu) +** +** Word-0 Word-1 Value +** 110110ww wwzzzzyy 110111yy yyxxxxxx 000uuuuu zzzzyyyy yyxxxxxx +** zzzzyyyy yyxxxxxx 00000000 zzzzyyyy yyxxxxxx +** +** +** BOM or Byte Order Mark: +** 0xff 0xfe little-endian utf-16 follows +** 0xfe 0xff big-endian utf-16 follows +** +*/ +/* #include "sqliteInt.h" */ +/* #include */ +/* #include "vdbeInt.h" */ + +#if !defined(SQLITE_AMALGAMATION) && SQLITE_BYTEORDER==0 +/* +** The following constant value is used by the SQLITE_BIGENDIAN and +** SQLITE_LITTLEENDIAN macros. +*/ +SQLITE_PRIVATE const int sqlite3one = 1; +#endif /* SQLITE_AMALGAMATION && SQLITE_BYTEORDER==0 */ + +/* +** This lookup table is used to help decode the first byte of +** a multi-byte UTF8 character. +*/ +static const unsigned char sqlite3Utf8Trans1[] = { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x00, 0x00, +}; + + +#define WRITE_UTF8(zOut, c) { \ + if( c<0x00080 ){ \ + *zOut++ = (u8)(c&0xFF); \ + } \ + else if( c<0x00800 ){ \ + *zOut++ = 0xC0 + (u8)((c>>6)&0x1F); \ + *zOut++ = 0x80 + (u8)(c & 0x3F); \ + } \ + else if( c<0x10000 ){ \ + *zOut++ = 0xE0 + (u8)((c>>12)&0x0F); \ + *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \ + *zOut++ = 0x80 + (u8)(c & 0x3F); \ + }else{ \ + *zOut++ = 0xF0 + (u8)((c>>18) & 0x07); \ + *zOut++ = 0x80 + (u8)((c>>12) & 0x3F); \ + *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \ + *zOut++ = 0x80 + (u8)(c & 0x3F); \ + } \ +} + +#define WRITE_UTF16LE(zOut, c) { \ + if( c<=0xFFFF ){ \ + *zOut++ = (u8)(c&0x00FF); \ + *zOut++ = (u8)((c>>8)&0x00FF); \ + }else{ \ + *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0)); \ + *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03)); \ + *zOut++ = (u8)(c&0x00FF); \ + *zOut++ = (u8)(0x00DC + ((c>>8)&0x03)); \ + } \ +} + +#define WRITE_UTF16BE(zOut, c) { \ + if( c<=0xFFFF ){ \ + *zOut++ = (u8)((c>>8)&0x00FF); \ + *zOut++ = (u8)(c&0x00FF); \ + }else{ \ + *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03)); \ + *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0)); \ + *zOut++ = (u8)(0x00DC + ((c>>8)&0x03)); \ + *zOut++ = (u8)(c&0x00FF); \ + } \ +} + +/* +** Translate a single UTF-8 character. Return the unicode value. +** +** During translation, assume that the byte that zTerm points +** is a 0x00. +** +** Write a pointer to the next unread byte back into *pzNext. +** +** Notes On Invalid UTF-8: +** +** * This routine never allows a 7-bit character (0x00 through 0x7f) to +** be encoded as a multi-byte character. Any multi-byte character that +** attempts to encode a value between 0x00 and 0x7f is rendered as 0xfffd. +** +** * This routine never allows a UTF16 surrogate value to be encoded. +** If a multi-byte character attempts to encode a value between +** 0xd800 and 0xe000 then it is rendered as 0xfffd. +** +** * Bytes in the range of 0x80 through 0xbf which occur as the first +** byte of a character are interpreted as single-byte characters +** and rendered as themselves even though they are technically +** invalid characters. +** +** * This routine accepts over-length UTF8 encodings +** for unicode values 0x80 and greater. It does not change over-length +** encodings to 0xfffd as some systems recommend. +*/ +#define READ_UTF8(zIn, zTerm, c) \ + c = *(zIn++); \ + if( c>=0xc0 ){ \ + c = sqlite3Utf8Trans1[c-0xc0]; \ + while( zIn!=zTerm && (*zIn & 0xc0)==0x80 ){ \ + c = (c<<6) + (0x3f & *(zIn++)); \ + } \ + if( c<0x80 \ + || (c&0xFFFFF800)==0xD800 \ + || (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; } \ + } +SQLITE_PRIVATE u32 sqlite3Utf8Read( + const unsigned char **pz /* Pointer to string from which to read char */ +){ + unsigned int c; + + /* Same as READ_UTF8() above but without the zTerm parameter. + ** For this routine, we assume the UTF8 string is always zero-terminated. + */ + c = *((*pz)++); + if( c>=0xc0 ){ + c = sqlite3Utf8Trans1[c-0xc0]; + while( (*(*pz) & 0xc0)==0x80 ){ + c = (c<<6) + (0x3f & *((*pz)++)); + } + if( c<0x80 + || (c&0xFFFFF800)==0xD800 + || (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; } + } + return c; +} + + + + +/* +** If the TRANSLATE_TRACE macro is defined, the value of each Mem is +** printed on stderr on the way into and out of sqlite3VdbeMemTranslate(). +*/ +/* #define TRANSLATE_TRACE 1 */ + +#ifndef SQLITE_OMIT_UTF16 +/* +** This routine transforms the internal text encoding used by pMem to +** desiredEnc. It is an error if the string is already of the desired +** encoding, or if *pMem does not contain a string value. +*/ +SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3VdbeMemTranslate(Mem *pMem, u8 desiredEnc){ + sqlite3_int64 len; /* Maximum length of output string in bytes */ + unsigned char *zOut; /* Output buffer */ + unsigned char *zIn; /* Input iterator */ + unsigned char *zTerm; /* End of input */ + unsigned char *z; /* Output iterator */ + unsigned int c; + + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( pMem->flags&MEM_Str ); + assert( pMem->enc!=desiredEnc ); + assert( pMem->enc!=0 ); + assert( pMem->n>=0 ); + +#if defined(TRANSLATE_TRACE) && defined(SQLITE_DEBUG) + { + StrAccum acc; + char zBuf[1000]; + sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0); + sqlite3VdbeMemPrettyPrint(pMem, &acc); + fprintf(stderr, "INPUT: %s\n", sqlite3StrAccumFinish(&acc)); + } +#endif + + /* If the translation is between UTF-16 little and big endian, then + ** all that is required is to swap the byte order. This case is handled + ** differently from the others. + */ + if( pMem->enc!=SQLITE_UTF8 && desiredEnc!=SQLITE_UTF8 ){ + u8 temp; + int rc; + rc = sqlite3VdbeMemMakeWriteable(pMem); + if( rc!=SQLITE_OK ){ + assert( rc==SQLITE_NOMEM ); + return SQLITE_NOMEM_BKPT; + } + zIn = (u8*)pMem->z; + zTerm = &zIn[pMem->n&~1]; + while( zInenc = desiredEnc; + goto translate_out; + } + + /* Set len to the maximum number of bytes required in the output buffer. */ + if( desiredEnc==SQLITE_UTF8 ){ + /* When converting from UTF-16, the maximum growth results from + ** translating a 2-byte character to a 4-byte UTF-8 character. + ** A single byte is required for the output string + ** nul-terminator. + */ + pMem->n &= ~1; + len = 2 * (sqlite3_int64)pMem->n + 1; + }else{ + /* When converting from UTF-8 to UTF-16 the maximum growth is caused + ** when a 1-byte UTF-8 character is translated into a 2-byte UTF-16 + ** character. Two bytes are required in the output buffer for the + ** nul-terminator. + */ + len = 2 * (sqlite3_int64)pMem->n + 2; + } + + /* Set zIn to point at the start of the input buffer and zTerm to point 1 + ** byte past the end. + ** + ** Variable zOut is set to point at the output buffer, space obtained + ** from sqlite3_malloc(). + */ + zIn = (u8*)pMem->z; + zTerm = &zIn[pMem->n]; + zOut = sqlite3DbMallocRaw(pMem->db, len); + if( !zOut ){ + return SQLITE_NOMEM_BKPT; + } + z = zOut; + + if( pMem->enc==SQLITE_UTF8 ){ + if( desiredEnc==SQLITE_UTF16LE ){ + /* UTF-8 -> UTF-16 Little-endian */ + while( zIn UTF-16 Big-endian */ + while( zInn = (int)(z - zOut); + *z++ = 0; + }else{ + assert( desiredEnc==SQLITE_UTF8 ); + if( pMem->enc==SQLITE_UTF16LE ){ + /* UTF-16 Little-endian -> UTF-8 */ + while( zIn=0xd800 && c<0xe000 ){ +#ifdef SQLITE_REPLACE_INVALID_UTF + if( c>=0xdc00 || zIn>=zTerm ){ + c = 0xfffd; + }else{ + int c2 = *(zIn++); + c2 += (*(zIn++))<<8; + if( c2<0xdc00 || c2>=0xe000 ){ + zIn -= 2; + c = 0xfffd; + }else{ + c = ((c&0x3ff)<<10) + (c2&0x3ff) + 0x10000; + } + } +#else + if( zIn UTF-8 */ + while( zIn=0xd800 && c<0xe000 ){ +#ifdef SQLITE_REPLACE_INVALID_UTF + if( c>=0xdc00 || zIn>=zTerm ){ + c = 0xfffd; + }else{ + int c2 = (*(zIn++))<<8; + c2 += *(zIn++); + if( c2<0xdc00 || c2>=0xe000 ){ + zIn -= 2; + c = 0xfffd; + }else{ + c = ((c&0x3ff)<<10) + (c2&0x3ff) + 0x10000; + } + } +#else + if( zInn = (int)(z - zOut); + } + *z = 0; + assert( (pMem->n+(desiredEnc==SQLITE_UTF8?1:2))<=len ); + + c = MEM_Str|MEM_Term|(pMem->flags&(MEM_AffMask|MEM_Subtype)); + sqlite3VdbeMemRelease(pMem); + pMem->flags = c; + pMem->enc = desiredEnc; + pMem->z = (char*)zOut; + pMem->zMalloc = pMem->z; + pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->z); + +translate_out: +#if defined(TRANSLATE_TRACE) && defined(SQLITE_DEBUG) + { + StrAccum acc; + char zBuf[1000]; + sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0); + sqlite3VdbeMemPrettyPrint(pMem, &acc); + fprintf(stderr, "OUTPUT: %s\n", sqlite3StrAccumFinish(&acc)); + } +#endif + return SQLITE_OK; +} +#endif /* SQLITE_OMIT_UTF16 */ + +#ifndef SQLITE_OMIT_UTF16 +/* +** This routine checks for a byte-order mark at the beginning of the +** UTF-16 string stored in *pMem. If one is present, it is removed and +** the encoding of the Mem adjusted. This routine does not do any +** byte-swapping, it just sets Mem.enc appropriately. +** +** The allocation (static, dynamic etc.) and encoding of the Mem may be +** changed by this function. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemHandleBom(Mem *pMem){ + int rc = SQLITE_OK; + u8 bom = 0; + + assert( pMem->n>=0 ); + if( pMem->n>1 ){ + u8 b1 = *(u8 *)pMem->z; + u8 b2 = *(((u8 *)pMem->z) + 1); + if( b1==0xFE && b2==0xFF ){ + bom = SQLITE_UTF16BE; + } + if( b1==0xFF && b2==0xFE ){ + bom = SQLITE_UTF16LE; + } + } + + if( bom ){ + rc = sqlite3VdbeMemMakeWriteable(pMem); + if( rc==SQLITE_OK ){ + pMem->n -= 2; + memmove(pMem->z, &pMem->z[2], pMem->n); + pMem->z[pMem->n] = '\0'; + pMem->z[pMem->n+1] = '\0'; + pMem->flags |= MEM_Term; + pMem->enc = bom; + } + } + return rc; +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** pZ is a UTF-8 encoded unicode string. If nByte is less than zero, +** return the number of unicode characters in pZ up to (but not including) +** the first 0x00 byte. If nByte is not less than zero, return the +** number of unicode characters in the first nByte of pZ (or up to +** the first 0x00, whichever comes first). +*/ +SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *zIn, int nByte){ + int r = 0; + const u8 *z = (const u8*)zIn; + const u8 *zTerm; + if( nByte>=0 ){ + zTerm = &z[nByte]; + }else{ + zTerm = (const u8*)(-1); + } + assert( z<=zTerm ); + while( *z!=0 && zmallocFailed ){ + sqlite3VdbeMemRelease(&m); + m.z = 0; + } + assert( (m.flags & MEM_Term)!=0 || db->mallocFailed ); + assert( (m.flags & MEM_Str)!=0 || db->mallocFailed ); + assert( m.z || db->mallocFailed ); + return m.z; +} + +/* +** zIn is a UTF-16 encoded unicode string at least nChar characters long. +** Return the number of bytes in the first nChar unicode characters +** in pZ. nChar must be non-negative. +*/ +SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *zIn, int nChar){ + int c; + unsigned char const *z = zIn; + int n = 0; + + if( SQLITE_UTF16NATIVE==SQLITE_UTF16LE ) z++; + while( n=0xd8 && c<0xdc && z[0]>=0xdc && z[0]<0xe0 ) z += 2; + n++; + } + return (int)(z-(unsigned char const *)zIn) + - (SQLITE_UTF16NATIVE==SQLITE_UTF16LE); +} + +#if defined(SQLITE_TEST) +/* +** This routine is called from the TCL test function "translate_selftest". +** It checks that the primitives for serializing and deserializing +** characters in each encoding are inverses of each other. +*/ +SQLITE_PRIVATE void sqlite3UtfSelfTest(void){ + unsigned int i, t; + unsigned char zBuf[20]; + unsigned char *z; + int n; + unsigned int c; + + for(i=0; i<0x00110000; i++){ + z = zBuf; + WRITE_UTF8(z, i); + n = (int)(z-zBuf); + assert( n>0 && n<=4 ); + z[0] = 0; + z = zBuf; + c = sqlite3Utf8Read((const u8**)&z); + t = i; + if( i>=0xD800 && i<=0xDFFF ) t = 0xFFFD; + if( (i&0xFFFFFFFE)==0xFFFE ) t = 0xFFFD; + assert( c==t ); + assert( (z-zBuf)==n ); + } +} +#endif /* SQLITE_TEST */ +#endif /* SQLITE_OMIT_UTF16 */ + +/************** End of utf.c *************************************************/ +/************** Begin file util.c ********************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** Utility functions used throughout sqlite. +** +** This file contains functions for allocating memory, comparing +** strings, and stuff like that. +** +*/ +/* #include "sqliteInt.h" */ +/* #include */ +#ifndef SQLITE_OMIT_FLOATING_POINT +#include +#endif + +/* +** Calls to sqlite3FaultSim() are used to simulate a failure during testing, +** or to bypass normal error detection during testing in order to let +** execute proceed futher downstream. +** +** In deployment, sqlite3FaultSim() *always* return SQLITE_OK (0). The +** sqlite3FaultSim() function only returns non-zero during testing. +** +** During testing, if the test harness has set a fault-sim callback using +** a call to sqlite3_test_control(SQLITE_TESTCTRL_FAULT_INSTALL), then +** each call to sqlite3FaultSim() is relayed to that application-supplied +** callback and the integer return value form the application-supplied +** callback is returned by sqlite3FaultSim(). +** +** The integer argument to sqlite3FaultSim() is a code to identify which +** sqlite3FaultSim() instance is being invoked. Each call to sqlite3FaultSim() +** should have a unique code. To prevent legacy testing applications from +** breaking, the codes should not be changed or reused. +*/ +#ifndef SQLITE_UNTESTABLE +SQLITE_PRIVATE int sqlite3FaultSim(int iTest){ + int (*xCallback)(int) = sqlite3GlobalConfig.xTestCallback; + return xCallback ? xCallback(iTest) : SQLITE_OK; +} +#endif + +#ifndef SQLITE_OMIT_FLOATING_POINT +/* +** Return true if the floating point value is Not a Number (NaN). +** +** Use the math library isnan() function if compiled with SQLITE_HAVE_ISNAN. +** Otherwise, we have our own implementation that works on most systems. +*/ +SQLITE_PRIVATE int sqlite3IsNaN(double x){ + int rc; /* The value return */ +#if !SQLITE_HAVE_ISNAN && !HAVE_ISNAN + u64 y; + memcpy(&y,&x,sizeof(y)); + rc = IsNaN(y); +#else + rc = isnan(x); +#endif /* HAVE_ISNAN */ + testcase( rc ); + return rc; +} +#endif /* SQLITE_OMIT_FLOATING_POINT */ + +/* +** Compute a string length that is limited to what can be stored in +** lower 30 bits of a 32-bit signed integer. +** +** The value returned will never be negative. Nor will it ever be greater +** than the actual length of the string. For very long strings (greater +** than 1GiB) the value returned might be less than the true string length. +*/ +SQLITE_PRIVATE int sqlite3Strlen30(const char *z){ + if( z==0 ) return 0; + return 0x3fffffff & (int)strlen(z); +} + +/* +** Return the declared type of a column. Or return zDflt if the column +** has no declared type. +** +** The column type is an extra string stored after the zero-terminator on +** the column name if and only if the COLFLAG_HASTYPE flag is set. +*/ +SQLITE_PRIVATE char *sqlite3ColumnType(Column *pCol, char *zDflt){ + if( pCol->colFlags & COLFLAG_HASTYPE ){ + return pCol->zCnName + strlen(pCol->zCnName) + 1; + }else if( pCol->eCType ){ + assert( pCol->eCType<=SQLITE_N_STDTYPE ); + return (char*)sqlite3StdType[pCol->eCType-1]; + }else{ + return zDflt; + } +} + +/* +** Helper function for sqlite3Error() - called rarely. Broken out into +** a separate routine to avoid unnecessary register saves on entry to +** sqlite3Error(). +*/ +static SQLITE_NOINLINE void sqlite3ErrorFinish(sqlite3 *db, int err_code){ + if( db->pErr ) sqlite3ValueSetNull(db->pErr); + sqlite3SystemError(db, err_code); +} + +/* +** Set the current error code to err_code and clear any prior error message. +** Also set iSysErrno (by calling sqlite3System) if the err_code indicates +** that would be appropriate. +*/ +SQLITE_PRIVATE void sqlite3Error(sqlite3 *db, int err_code){ + assert( db!=0 ); + db->errCode = err_code; + if( err_code || db->pErr ){ + sqlite3ErrorFinish(db, err_code); + }else{ + db->errByteOffset = -1; + } +} + +/* +** The equivalent of sqlite3Error(db, SQLITE_OK). Clear the error state +** and error message. +*/ +SQLITE_PRIVATE void sqlite3ErrorClear(sqlite3 *db){ + assert( db!=0 ); + db->errCode = SQLITE_OK; + db->errByteOffset = -1; + if( db->pErr ) sqlite3ValueSetNull(db->pErr); +} + +/* +** Load the sqlite3.iSysErrno field if that is an appropriate thing +** to do based on the SQLite error code in rc. +*/ +SQLITE_PRIVATE void sqlite3SystemError(sqlite3 *db, int rc){ + if( rc==SQLITE_IOERR_NOMEM ) return; + rc &= 0xff; + if( rc==SQLITE_CANTOPEN || rc==SQLITE_IOERR ){ + db->iSysErrno = sqlite3OsGetLastError(db->pVfs); + } +} + +/* +** Set the most recent error code and error string for the sqlite +** handle "db". The error code is set to "err_code". +** +** If it is not NULL, string zFormat specifies the format of the +** error string. zFormat and any string tokens that follow it are +** assumed to be encoded in UTF-8. +** +** To clear the most recent error for sqlite handle "db", sqlite3Error +** should be called with err_code set to SQLITE_OK and zFormat set +** to NULL. +*/ +SQLITE_PRIVATE void sqlite3ErrorWithMsg(sqlite3 *db, int err_code, const char *zFormat, ...){ + assert( db!=0 ); + db->errCode = err_code; + sqlite3SystemError(db, err_code); + if( zFormat==0 ){ + sqlite3Error(db, err_code); + }else if( db->pErr || (db->pErr = sqlite3ValueNew(db))!=0 ){ + char *z; + va_list ap; + va_start(ap, zFormat); + z = sqlite3VMPrintf(db, zFormat, ap); + va_end(ap); + sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC); + } +} + +/* +** Check for interrupts and invoke progress callback. +*/ +SQLITE_PRIVATE void sqlite3ProgressCheck(Parse *p){ + sqlite3 *db = p->db; + if( AtomicLoad(&db->u1.isInterrupted) ){ + p->nErr++; + p->rc = SQLITE_INTERRUPT; + } +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + if( db->xProgress && (++p->nProgressSteps)>=db->nProgressOps ){ + if( db->xProgress(db->pProgressArg) ){ + p->nErr++; + p->rc = SQLITE_INTERRUPT; + } + p->nProgressSteps = 0; + } +#endif +} + +/* +** Add an error message to pParse->zErrMsg and increment pParse->nErr. +** +** This function should be used to report any error that occurs while +** compiling an SQL statement (i.e. within sqlite3_prepare()). The +** last thing the sqlite3_prepare() function does is copy the error +** stored by this function into the database handle using sqlite3Error(). +** Functions sqlite3Error() or sqlite3ErrorWithMsg() should be used +** during statement execution (sqlite3_step() etc.). +*/ +SQLITE_PRIVATE void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){ + char *zMsg; + va_list ap; + sqlite3 *db = pParse->db; + assert( db!=0 ); + assert( db->pParse==pParse || db->pParse->pToplevel==pParse ); + db->errByteOffset = -2; + va_start(ap, zFormat); + zMsg = sqlite3VMPrintf(db, zFormat, ap); + va_end(ap); + if( db->errByteOffset<-1 ) db->errByteOffset = -1; + if( db->suppressErr ){ + sqlite3DbFree(db, zMsg); + if( db->mallocFailed ){ + pParse->nErr++; + pParse->rc = SQLITE_NOMEM; + } + }else{ + pParse->nErr++; + sqlite3DbFree(db, pParse->zErrMsg); + pParse->zErrMsg = zMsg; + pParse->rc = SQLITE_ERROR; + pParse->pWith = 0; + } +} + +/* +** If database connection db is currently parsing SQL, then transfer +** error code errCode to that parser if the parser has not already +** encountered some other kind of error. +*/ +SQLITE_PRIVATE int sqlite3ErrorToParser(sqlite3 *db, int errCode){ + Parse *pParse; + if( db==0 || (pParse = db->pParse)==0 ) return errCode; + pParse->rc = errCode; + pParse->nErr++; + return errCode; +} + +/* +** Convert an SQL-style quoted string into a normal string by removing +** the quote characters. The conversion is done in-place. If the +** input does not begin with a quote character, then this routine +** is a no-op. +** +** The input string must be zero-terminated. A new zero-terminator +** is added to the dequoted string. +** +** The return value is -1 if no dequoting occurs or the length of the +** dequoted string, exclusive of the zero terminator, if dequoting does +** occur. +** +** 2002-02-14: This routine is extended to remove MS-Access style +** brackets from around identifiers. For example: "[a-b-c]" becomes +** "a-b-c". +*/ +SQLITE_PRIVATE void sqlite3Dequote(char *z){ + char quote; + int i, j; + if( z==0 ) return; + quote = z[0]; + if( !sqlite3Isquote(quote) ) return; + if( quote=='[' ) quote = ']'; + for(i=1, j=0;; i++){ + assert( z[i] ); + if( z[i]==quote ){ + if( z[i+1]==quote ){ + z[j++] = quote; + i++; + }else{ + break; + } + }else{ + z[j++] = z[i]; + } + } + z[j] = 0; +} +SQLITE_PRIVATE void sqlite3DequoteExpr(Expr *p){ + assert( !ExprHasProperty(p, EP_IntValue) ); + assert( sqlite3Isquote(p->u.zToken[0]) ); + p->flags |= p->u.zToken[0]=='"' ? EP_Quoted|EP_DblQuoted : EP_Quoted; + sqlite3Dequote(p->u.zToken); +} + +/* +** If the input token p is quoted, try to adjust the token to remove +** the quotes. This is not always possible: +** +** "abc" -> abc +** "ab""cd" -> (not possible because of the interior "") +** +** Remove the quotes if possible. This is a optimization. The overall +** system should still return the correct answer even if this routine +** is always a no-op. +*/ +SQLITE_PRIVATE void sqlite3DequoteToken(Token *p){ + unsigned int i; + if( p->n<2 ) return; + if( !sqlite3Isquote(p->z[0]) ) return; + for(i=1; in-1; i++){ + if( sqlite3Isquote(p->z[i]) ) return; + } + p->n -= 2; + p->z++; +} + +/* +** Generate a Token object from a string +*/ +SQLITE_PRIVATE void sqlite3TokenInit(Token *p, char *z){ + p->z = z; + p->n = sqlite3Strlen30(z); +} + +/* Convenient short-hand */ +#define UpperToLower sqlite3UpperToLower + +/* +** Some systems have stricmp(). Others have strcasecmp(). Because +** there is no consistency, we will define our own. +** +** IMPLEMENTATION-OF: R-30243-02494 The sqlite3_stricmp() and +** sqlite3_strnicmp() APIs allow applications and extensions to compare +** the contents of two buffers containing UTF-8 strings in a +** case-independent fashion, using the same definition of "case +** independence" that SQLite uses internally when comparing identifiers. +*/ +SQLITE_API int sqlite3_stricmp(const char *zLeft, const char *zRight){ + if( zLeft==0 ){ + return zRight ? -1 : 0; + }else if( zRight==0 ){ + return 1; + } + return sqlite3StrICmp(zLeft, zRight); +} +SQLITE_PRIVATE int sqlite3StrICmp(const char *zLeft, const char *zRight){ + unsigned char *a, *b; + int c, x; + a = (unsigned char *)zLeft; + b = (unsigned char *)zRight; + for(;;){ + c = *a; + x = *b; + if( c==x ){ + if( c==0 ) break; + }else{ + c = (int)UpperToLower[c] - (int)UpperToLower[x]; + if( c ) break; + } + a++; + b++; + } + return c; +} +SQLITE_API int sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){ + register unsigned char *a, *b; + if( zLeft==0 ){ + return zRight ? -1 : 0; + }else if( zRight==0 ){ + return 1; + } + a = (unsigned char *)zLeft; + b = (unsigned char *)zRight; + while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; } + return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b]; +} + +/* +** Compute an 8-bit hash on a string that is insensitive to case differences +*/ +SQLITE_PRIVATE u8 sqlite3StrIHash(const char *z){ + u8 h = 0; + if( z==0 ) return 0; + while( z[0] ){ + h += UpperToLower[(unsigned char)z[0]]; + z++; + } + return h; +} + +/* +** Compute 10 to the E-th power. Examples: E==1 results in 10. +** E==2 results in 100. E==50 results in 1.0e50. +** +** This routine only works for values of E between 1 and 341. +*/ +static LONGDOUBLE_TYPE sqlite3Pow10(int E){ +#if defined(_MSC_VER) + static const LONGDOUBLE_TYPE x[] = { + 1.0e+001L, + 1.0e+002L, + 1.0e+004L, + 1.0e+008L, + 1.0e+016L, + 1.0e+032L, + 1.0e+064L, + 1.0e+128L, + 1.0e+256L + }; + LONGDOUBLE_TYPE r = 1.0; + int i; + assert( E>=0 && E<=307 ); + for(i=0; E!=0; i++, E >>=1){ + if( E & 1 ) r *= x[i]; + } + return r; +#else + LONGDOUBLE_TYPE x = 10.0; + LONGDOUBLE_TYPE r = 1.0; + while(1){ + if( E & 1 ) r *= x; + E >>= 1; + if( E==0 ) break; + x *= x; + } + return r; +#endif +} + +/* +** The string z[] is an text representation of a real number. +** Convert this string to a double and write it into *pResult. +** +** The string z[] is length bytes in length (bytes, not characters) and +** uses the encoding enc. The string is not necessarily zero-terminated. +** +** Return TRUE if the result is a valid real number (or integer) and FALSE +** if the string is empty or contains extraneous text. More specifically +** return +** 1 => The input string is a pure integer +** 2 or more => The input has a decimal point or eNNN clause +** 0 or less => The input string is not a valid number +** -1 => Not a valid number, but has a valid prefix which +** includes a decimal point and/or an eNNN clause +** +** Valid numbers are in one of these formats: +** +** [+-]digits[E[+-]digits] +** [+-]digits.[digits][E[+-]digits] +** [+-].digits[E[+-]digits] +** +** Leading and trailing whitespace is ignored for the purpose of determining +** validity. +** +** If some prefix of the input string is a valid number, this routine +** returns FALSE but it still converts the prefix and writes the result +** into *pResult. +*/ +#if defined(_MSC_VER) +#pragma warning(disable : 4756) +#endif +SQLITE_PRIVATE int sqlite3AtoF(const char *z, double *pResult, int length, u8 enc){ +#ifndef SQLITE_OMIT_FLOATING_POINT + int incr; + const char *zEnd; + /* sign * significand * (10 ^ (esign * exponent)) */ + int sign = 1; /* sign of significand */ + i64 s = 0; /* significand */ + int d = 0; /* adjust exponent for shifting decimal point */ + int esign = 1; /* sign of exponent */ + int e = 0; /* exponent */ + int eValid = 1; /* True exponent is either not used or is well-formed */ + double result; + int nDigit = 0; /* Number of digits processed */ + int eType = 1; /* 1: pure integer, 2+: fractional -1 or less: bad UTF16 */ + + assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE ); + *pResult = 0.0; /* Default return value, in case of an error */ + if( length==0 ) return 0; + + if( enc==SQLITE_UTF8 ){ + incr = 1; + zEnd = z + length; + }else{ + int i; + incr = 2; + length &= ~1; + assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 ); + testcase( enc==SQLITE_UTF16LE ); + testcase( enc==SQLITE_UTF16BE ); + for(i=3-enc; i=zEnd ) return 0; + + /* get sign of significand */ + if( *z=='-' ){ + sign = -1; + z+=incr; + }else if( *z=='+' ){ + z+=incr; + } + + /* copy max significant digits to significand */ + while( z=((LARGEST_INT64-9)/10) ){ + /* skip non-significant significand digits + ** (increase exponent by d to shift decimal left) */ + while( z=zEnd ) goto do_atof_calc; + + /* if decimal point is present */ + if( *z=='.' ){ + z+=incr; + eType++; + /* copy digits from after decimal to significand + ** (decrease exponent by d to shift decimal right) */ + while( z=zEnd ) goto do_atof_calc; + + /* if exponent is present */ + if( *z=='e' || *z=='E' ){ + z+=incr; + eValid = 0; + eType++; + + /* This branch is needed to avoid a (harmless) buffer overread. The + ** special comment alerts the mutation tester that the correct answer + ** is obtained even if the branch is omitted */ + if( z>=zEnd ) goto do_atof_calc; /*PREVENTS-HARMLESS-OVERREAD*/ + + /* get sign of exponent */ + if( *z=='-' ){ + esign = -1; + z+=incr; + }else if( *z=='+' ){ + z+=incr; + } + /* copy digits to exponent */ + while( z0 ){ /*OPTIMIZATION-IF-TRUE*/ + if( esign>0 ){ + if( s>=(LARGEST_INT64/10) ) break; /*OPTIMIZATION-IF-FALSE*/ + s *= 10; + }else{ + if( s%10!=0 ) break; /*OPTIMIZATION-IF-FALSE*/ + s /= 10; + } + e--; + } + + /* adjust the sign of significand */ + s = sign<0 ? -s : s; + + if( e==0 ){ /*OPTIMIZATION-IF-TRUE*/ + result = (double)s; + }else{ + /* attempt to handle extremely small/large numbers better */ + if( e>307 ){ /*OPTIMIZATION-IF-TRUE*/ + if( e<342 ){ /*OPTIMIZATION-IF-TRUE*/ + LONGDOUBLE_TYPE scale = sqlite3Pow10(e-308); + if( esign<0 ){ + result = s / scale; + result /= 1.0e+308; + }else{ + result = s * scale; + result *= 1.0e+308; + } + }else{ assert( e>=342 ); + if( esign<0 ){ + result = 0.0*s; + }else{ +#ifdef INFINITY + result = INFINITY*s; +#else + result = 1e308*1e308*s; /* Infinity */ +#endif + } + } + }else{ + LONGDOUBLE_TYPE scale = sqlite3Pow10(e); + if( esign<0 ){ + result = s / scale; + }else{ + result = s * scale; + } + } + } + } + + /* store the result */ + *pResult = result; + + /* return true if number and no extra non-whitespace chracters after */ + if( z==zEnd && nDigit>0 && eValid && eType>0 ){ + return eType; + }else if( eType>=2 && (eType==3 || eValid) && nDigit>0 ){ + return -1; + }else{ + return 0; + } +#else + return !sqlite3Atoi64(z, pResult, length, enc); +#endif /* SQLITE_OMIT_FLOATING_POINT */ +} +#if defined(_MSC_VER) +#pragma warning(default : 4756) +#endif + +/* +** Render an signed 64-bit integer as text. Store the result in zOut[] and +** return the length of the string that was stored, in bytes. The value +** returned does not include the zero terminator at the end of the output +** string. +** +** The caller must ensure that zOut[] is at least 21 bytes in size. +*/ +SQLITE_PRIVATE int sqlite3Int64ToText(i64 v, char *zOut){ + int i; + u64 x; + char zTemp[22]; + if( v<0 ){ + x = (v==SMALLEST_INT64) ? ((u64)1)<<63 : (u64)-v; + }else{ + x = v; + } + i = sizeof(zTemp)-2; + zTemp[sizeof(zTemp)-1] = 0; + while( 1 /*exit-by-break*/ ){ + zTemp[i] = (x%10) + '0'; + x = x/10; + if( x==0 ) break; + i--; + }; + if( v<0 ) zTemp[--i] = '-'; + memcpy(zOut, &zTemp[i], sizeof(zTemp)-i); + return sizeof(zTemp)-1-i; +} + +/* +** Compare the 19-character string zNum against the text representation +** value 2^63: 9223372036854775808. Return negative, zero, or positive +** if zNum is less than, equal to, or greater than the string. +** Note that zNum must contain exactly 19 characters. +** +** Unlike memcmp() this routine is guaranteed to return the difference +** in the values of the last digit if the only difference is in the +** last digit. So, for example, +** +** compare2pow63("9223372036854775800", 1) +** +** will return -8. +*/ +static int compare2pow63(const char *zNum, int incr){ + int c = 0; + int i; + /* 012345678901234567 */ + const char *pow63 = "922337203685477580"; + for(i=0; c==0 && i<18; i++){ + c = (zNum[i*incr]-pow63[i])*10; + } + if( c==0 ){ + c = zNum[18*incr] - '8'; + testcase( c==(-1) ); + testcase( c==0 ); + testcase( c==(+1) ); + } + return c; +} + +/* +** Convert zNum to a 64-bit signed integer. zNum must be decimal. This +** routine does *not* accept hexadecimal notation. +** +** Returns: +** +** -1 Not even a prefix of the input text looks like an integer +** 0 Successful transformation. Fits in a 64-bit signed integer. +** 1 Excess non-space text after the integer value +** 2 Integer too large for a 64-bit signed integer or is malformed +** 3 Special case of 9223372036854775808 +** +** length is the number of bytes in the string (bytes, not characters). +** The string is not necessarily zero-terminated. The encoding is +** given by enc. +*/ +SQLITE_PRIVATE int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc){ + int incr; + u64 u = 0; + int neg = 0; /* assume positive */ + int i; + int c = 0; + int nonNum = 0; /* True if input contains UTF16 with high byte non-zero */ + int rc; /* Baseline return code */ + const char *zStart; + const char *zEnd = zNum + length; + assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE ); + if( enc==SQLITE_UTF8 ){ + incr = 1; + }else{ + incr = 2; + length &= ~1; + assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 ); + for(i=3-enc; i='0' && c<='9'; i+=incr){ + u = u*10 + c - '0'; + } + testcase( i==18*incr ); + testcase( i==19*incr ); + testcase( i==20*incr ); + if( u>LARGEST_INT64 ){ + /* This test and assignment is needed only to suppress UB warnings + ** from clang and -fsanitize=undefined. This test and assignment make + ** the code a little larger and slower, and no harm comes from omitting + ** them, but we must appaise the undefined-behavior pharisees. */ + *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64; + }else if( neg ){ + *pNum = -(i64)u; + }else{ + *pNum = (i64)u; + } + rc = 0; + if( i==0 && zStart==zNum ){ /* No digits */ + rc = -1; + }else if( nonNum ){ /* UTF16 with high-order bytes non-zero */ + rc = 1; + }else if( &zNum[i]19*incr ? 1 : compare2pow63(zNum, incr); + if( c<0 ){ + /* zNum is less than 9223372036854775808 so it fits */ + assert( u<=LARGEST_INT64 ); + return rc; + }else{ + *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64; + if( c>0 ){ + /* zNum is greater than 9223372036854775808 so it overflows */ + return 2; + }else{ + /* zNum is exactly 9223372036854775808. Fits if negative. The + ** special case 2 overflow if positive */ + assert( u-1==LARGEST_INT64 ); + return neg ? rc : 3; + } + } + } +} + +/* +** Transform a UTF-8 integer literal, in either decimal or hexadecimal, +** into a 64-bit signed integer. This routine accepts hexadecimal literals, +** whereas sqlite3Atoi64() does not. +** +** Returns: +** +** 0 Successful transformation. Fits in a 64-bit signed integer. +** 1 Excess text after the integer value +** 2 Integer too large for a 64-bit signed integer or is malformed +** 3 Special case of 9223372036854775808 +*/ +SQLITE_PRIVATE int sqlite3DecOrHexToI64(const char *z, i64 *pOut){ +#ifndef SQLITE_OMIT_HEX_INTEGER + if( z[0]=='0' + && (z[1]=='x' || z[1]=='X') + ){ + u64 u = 0; + int i, k; + for(i=2; z[i]=='0'; i++){} + for(k=i; sqlite3Isxdigit(z[k]); k++){ + u = u*16 + sqlite3HexToInt(z[k]); + } + memcpy(pOut, &u, 8); + if( k-i>16 ) return 2; + if( z[k]!=0 ) return 1; + return 0; + }else +#endif /* SQLITE_OMIT_HEX_INTEGER */ + { + return sqlite3Atoi64(z, pOut, sqlite3Strlen30(z), SQLITE_UTF8); + } +} + +/* +** If zNum represents an integer that will fit in 32-bits, then set +** *pValue to that integer and return true. Otherwise return false. +** +** This routine accepts both decimal and hexadecimal notation for integers. +** +** Any non-numeric characters that following zNum are ignored. +** This is different from sqlite3Atoi64() which requires the +** input number to be zero-terminated. +*/ +SQLITE_PRIVATE int sqlite3GetInt32(const char *zNum, int *pValue){ + sqlite_int64 v = 0; + int i, c; + int neg = 0; + if( zNum[0]=='-' ){ + neg = 1; + zNum++; + }else if( zNum[0]=='+' ){ + zNum++; + } +#ifndef SQLITE_OMIT_HEX_INTEGER + else if( zNum[0]=='0' + && (zNum[1]=='x' || zNum[1]=='X') + && sqlite3Isxdigit(zNum[2]) + ){ + u32 u = 0; + zNum += 2; + while( zNum[0]=='0' ) zNum++; + for(i=0; i<8 && sqlite3Isxdigit(zNum[i]); i++){ + u = u*16 + sqlite3HexToInt(zNum[i]); + } + if( (u&0x80000000)==0 && sqlite3Isxdigit(zNum[i])==0 ){ + memcpy(pValue, &u, 4); + return 1; + }else{ + return 0; + } + } +#endif + if( !sqlite3Isdigit(zNum[0]) ) return 0; + while( zNum[0]=='0' ) zNum++; + for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){ + v = v*10 + c; + } + + /* The longest decimal representation of a 32 bit integer is 10 digits: + ** + ** 1234567890 + ** 2^31 -> 2147483648 + */ + testcase( i==10 ); + if( i>10 ){ + return 0; + } + testcase( v-neg==2147483647 ); + if( v-neg>2147483647 ){ + return 0; + } + if( neg ){ + v = -v; + } + *pValue = (int)v; + return 1; +} + +/* +** Return a 32-bit integer value extracted from a string. If the +** string is not an integer, just return 0. +*/ +SQLITE_PRIVATE int sqlite3Atoi(const char *z){ + int x = 0; + sqlite3GetInt32(z, &x); + return x; +} + +/* +** Try to convert z into an unsigned 32-bit integer. Return true on +** success and false if there is an error. +** +** Only decimal notation is accepted. +*/ +SQLITE_PRIVATE int sqlite3GetUInt32(const char *z, u32 *pI){ + u64 v = 0; + int i; + for(i=0; sqlite3Isdigit(z[i]); i++){ + v = v*10 + z[i] - '0'; + if( v>4294967296LL ){ *pI = 0; return 0; } + } + if( i==0 || z[i]!=0 ){ *pI = 0; return 0; } + *pI = (u32)v; + return 1; +} + +/* +** The variable-length integer encoding is as follows: +** +** KEY: +** A = 0xxxxxxx 7 bits of data and one flag bit +** B = 1xxxxxxx 7 bits of data and one flag bit +** C = xxxxxxxx 8 bits of data +** +** 7 bits - A +** 14 bits - BA +** 21 bits - BBA +** 28 bits - BBBA +** 35 bits - BBBBA +** 42 bits - BBBBBA +** 49 bits - BBBBBBA +** 56 bits - BBBBBBBA +** 64 bits - BBBBBBBBC +*/ + +/* +** Write a 64-bit variable-length integer to memory starting at p[0]. +** The length of data write will be between 1 and 9 bytes. The number +** of bytes written is returned. +** +** A variable-length integer consists of the lower 7 bits of each byte +** for all bytes that have the 8th bit set and one byte with the 8th +** bit clear. Except, if we get to the 9th byte, it stores the full +** 8 bits and is the last byte. +*/ +static int SQLITE_NOINLINE putVarint64(unsigned char *p, u64 v){ + int i, j, n; + u8 buf[10]; + if( v & (((u64)0xff000000)<<32) ){ + p[8] = (u8)v; + v >>= 8; + for(i=7; i>=0; i--){ + p[i] = (u8)((v & 0x7f) | 0x80); + v >>= 7; + } + return 9; + } + n = 0; + do{ + buf[n++] = (u8)((v & 0x7f) | 0x80); + v >>= 7; + }while( v!=0 ); + buf[0] &= 0x7f; + assert( n<=9 ); + for(i=0, j=n-1; j>=0; j--, i++){ + p[i] = buf[j]; + } + return n; +} +SQLITE_PRIVATE int sqlite3PutVarint(unsigned char *p, u64 v){ + if( v<=0x7f ){ + p[0] = v&0x7f; + return 1; + } + if( v<=0x3fff ){ + p[0] = ((v>>7)&0x7f)|0x80; + p[1] = v&0x7f; + return 2; + } + return putVarint64(p,v); +} + +/* +** Bitmasks used by sqlite3GetVarint(). These precomputed constants +** are defined here rather than simply putting the constant expressions +** inline in order to work around bugs in the RVT compiler. +** +** SLOT_2_0 A mask for (0x7f<<14) | 0x7f +** +** SLOT_4_2_0 A mask for (0x7f<<28) | SLOT_2_0 +*/ +#define SLOT_2_0 0x001fc07f +#define SLOT_4_2_0 0xf01fc07f + + +/* +** Read a 64-bit variable-length integer from memory starting at p[0]. +** Return the number of bytes read. The value is stored in *v. +*/ +SQLITE_PRIVATE u8 sqlite3GetVarint(const unsigned char *p, u64 *v){ + u32 a,b,s; + + if( ((signed char*)p)[0]>=0 ){ + *v = *p; + return 1; + } + if( ((signed char*)p)[1]>=0 ){ + *v = ((u32)(p[0]&0x7f)<<7) | p[1]; + return 2; + } + + /* Verify that constants are precomputed correctly */ + assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) ); + assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) ); + + a = ((u32)p[0])<<14; + b = p[1]; + p += 2; + a |= *p; + /* a: p0<<14 | p2 (unmasked) */ + if (!(a&0x80)) + { + a &= SLOT_2_0; + b &= 0x7f; + b = b<<7; + a |= b; + *v = a; + return 3; + } + + /* CSE1 from below */ + a &= SLOT_2_0; + p++; + b = b<<14; + b |= *p; + /* b: p1<<14 | p3 (unmasked) */ + if (!(b&0x80)) + { + b &= SLOT_2_0; + /* moved CSE1 up */ + /* a &= (0x7f<<14)|(0x7f); */ + a = a<<7; + a |= b; + *v = a; + return 4; + } + + /* a: p0<<14 | p2 (masked) */ + /* b: p1<<14 | p3 (unmasked) */ + /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */ + /* moved CSE1 up */ + /* a &= (0x7f<<14)|(0x7f); */ + b &= SLOT_2_0; + s = a; + /* s: p0<<14 | p2 (masked) */ + + p++; + a = a<<14; + a |= *p; + /* a: p0<<28 | p2<<14 | p4 (unmasked) */ + if (!(a&0x80)) + { + /* we can skip these cause they were (effectively) done above + ** while calculating s */ + /* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */ + /* b &= (0x7f<<14)|(0x7f); */ + b = b<<7; + a |= b; + s = s>>18; + *v = ((u64)s)<<32 | a; + return 5; + } + + /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */ + s = s<<7; + s |= b; + /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */ + + p++; + b = b<<14; + b |= *p; + /* b: p1<<28 | p3<<14 | p5 (unmasked) */ + if (!(b&0x80)) + { + /* we can skip this cause it was (effectively) done above in calc'ing s */ + /* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */ + a &= SLOT_2_0; + a = a<<7; + a |= b; + s = s>>18; + *v = ((u64)s)<<32 | a; + return 6; + } + + p++; + a = a<<14; + a |= *p; + /* a: p2<<28 | p4<<14 | p6 (unmasked) */ + if (!(a&0x80)) + { + a &= SLOT_4_2_0; + b &= SLOT_2_0; + b = b<<7; + a |= b; + s = s>>11; + *v = ((u64)s)<<32 | a; + return 7; + } + + /* CSE2 from below */ + a &= SLOT_2_0; + p++; + b = b<<14; + b |= *p; + /* b: p3<<28 | p5<<14 | p7 (unmasked) */ + if (!(b&0x80)) + { + b &= SLOT_4_2_0; + /* moved CSE2 up */ + /* a &= (0x7f<<14)|(0x7f); */ + a = a<<7; + a |= b; + s = s>>4; + *v = ((u64)s)<<32 | a; + return 8; + } + + p++; + a = a<<15; + a |= *p; + /* a: p4<<29 | p6<<15 | p8 (unmasked) */ + + /* moved CSE2 up */ + /* a &= (0x7f<<29)|(0x7f<<15)|(0xff); */ + b &= SLOT_2_0; + b = b<<8; + a |= b; + + s = s<<4; + b = p[-4]; + b &= 0x7f; + b = b>>3; + s |= b; + + *v = ((u64)s)<<32 | a; + + return 9; +} + +/* +** Read a 32-bit variable-length integer from memory starting at p[0]. +** Return the number of bytes read. The value is stored in *v. +** +** If the varint stored in p[0] is larger than can fit in a 32-bit unsigned +** integer, then set *v to 0xffffffff. +** +** A MACRO version, getVarint32, is provided which inlines the +** single-byte case. All code should use the MACRO version as +** this function assumes the single-byte case has already been handled. +*/ +SQLITE_PRIVATE u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){ + u32 a,b; + + /* The 1-byte case. Overwhelmingly the most common. Handled inline + ** by the getVarin32() macro */ + a = *p; + /* a: p0 (unmasked) */ +#ifndef getVarint32 + if (!(a&0x80)) + { + /* Values between 0 and 127 */ + *v = a; + return 1; + } +#endif + + /* The 2-byte case */ + p++; + b = *p; + /* b: p1 (unmasked) */ + if (!(b&0x80)) + { + /* Values between 128 and 16383 */ + a &= 0x7f; + a = a<<7; + *v = a | b; + return 2; + } + + /* The 3-byte case */ + p++; + a = a<<14; + a |= *p; + /* a: p0<<14 | p2 (unmasked) */ + if (!(a&0x80)) + { + /* Values between 16384 and 2097151 */ + a &= (0x7f<<14)|(0x7f); + b &= 0x7f; + b = b<<7; + *v = a | b; + return 3; + } + + /* A 32-bit varint is used to store size information in btrees. + ** Objects are rarely larger than 2MiB limit of a 3-byte varint. + ** A 3-byte varint is sufficient, for example, to record the size + ** of a 1048569-byte BLOB or string. + ** + ** We only unroll the first 1-, 2-, and 3- byte cases. The very + ** rare larger cases can be handled by the slower 64-bit varint + ** routine. + */ +#if 1 + { + u64 v64; + u8 n; + + n = sqlite3GetVarint(p-2, &v64); + assert( n>3 && n<=9 ); + if( (v64 & SQLITE_MAX_U32)!=v64 ){ + *v = 0xffffffff; + }else{ + *v = (u32)v64; + } + return n; + } + +#else + /* For following code (kept for historical record only) shows an + ** unrolling for the 3- and 4-byte varint cases. This code is + ** slightly faster, but it is also larger and much harder to test. + */ + p++; + b = b<<14; + b |= *p; + /* b: p1<<14 | p3 (unmasked) */ + if (!(b&0x80)) + { + /* Values between 2097152 and 268435455 */ + b &= (0x7f<<14)|(0x7f); + a &= (0x7f<<14)|(0x7f); + a = a<<7; + *v = a | b; + return 4; + } + + p++; + a = a<<14; + a |= *p; + /* a: p0<<28 | p2<<14 | p4 (unmasked) */ + if (!(a&0x80)) + { + /* Values between 268435456 and 34359738367 */ + a &= SLOT_4_2_0; + b &= SLOT_4_2_0; + b = b<<7; + *v = a | b; + return 5; + } + + /* We can only reach this point when reading a corrupt database + ** file. In that case we are not in any hurry. Use the (relatively + ** slow) general-purpose sqlite3GetVarint() routine to extract the + ** value. */ + { + u64 v64; + u8 n; + + p -= 4; + n = sqlite3GetVarint(p, &v64); + assert( n>5 && n<=9 ); + *v = (u32)v64; + return n; + } +#endif +} + +/* +** Return the number of bytes that will be needed to store the given +** 64-bit integer. +*/ +SQLITE_PRIVATE int sqlite3VarintLen(u64 v){ + int i; + for(i=1; (v >>= 7)!=0; i++){ assert( i<10 ); } + return i; +} + + +/* +** Read or write a four-byte big-endian integer value. +*/ +SQLITE_PRIVATE u32 sqlite3Get4byte(const u8 *p){ +#if SQLITE_BYTEORDER==4321 + u32 x; + memcpy(&x,p,4); + return x; +#elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000 + u32 x; + memcpy(&x,p,4); + return __builtin_bswap32(x); +#elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300 + u32 x; + memcpy(&x,p,4); + return _byteswap_ulong(x); +#else + testcase( p[0]&0x80 ); + return ((unsigned)p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3]; +#endif +} +SQLITE_PRIVATE void sqlite3Put4byte(unsigned char *p, u32 v){ +#if SQLITE_BYTEORDER==4321 + memcpy(p,&v,4); +#elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000 + u32 x = __builtin_bswap32(v); + memcpy(p,&x,4); +#elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300 + u32 x = _byteswap_ulong(v); + memcpy(p,&x,4); +#else + p[0] = (u8)(v>>24); + p[1] = (u8)(v>>16); + p[2] = (u8)(v>>8); + p[3] = (u8)v; +#endif +} + + + +/* +** Translate a single byte of Hex into an integer. +** This routine only works if h really is a valid hexadecimal +** character: 0..9a..fA..F +*/ +SQLITE_PRIVATE u8 sqlite3HexToInt(int h){ + assert( (h>='0' && h<='9') || (h>='a' && h<='f') || (h>='A' && h<='F') ); +#ifdef SQLITE_ASCII + h += 9*(1&(h>>6)); +#endif +#ifdef SQLITE_EBCDIC + h += 9*(1&~(h>>4)); +#endif + return (u8)(h & 0xf); +} + +/* BEGIN SQLCIPHER */ +#if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC) +/* +** Convert a BLOB literal of the form "x'hhhhhh'" into its binary +** value. Return a pointer to its binary value. Space to hold the +** binary value has been obtained from malloc and must be freed by +** the calling routine. +*/ +SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){ + char *zBlob; + int i; + + zBlob = (char *)sqlite3DbMallocRawNN(db, n/2 + 1); + n--; + if( zBlob ){ + for(i=0; ieOpenState; + if( eOpenState!=SQLITE_STATE_OPEN ){ + if( sqlite3SafetyCheckSickOrOk(db) ){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + logBadConnection("unopened"); + } + return 0; + }else{ + return 1; + } +} +SQLITE_PRIVATE int sqlite3SafetyCheckSickOrOk(sqlite3 *db){ + u8 eOpenState; + eOpenState = db->eOpenState; + if( eOpenState!=SQLITE_STATE_SICK && + eOpenState!=SQLITE_STATE_OPEN && + eOpenState!=SQLITE_STATE_BUSY ){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + logBadConnection("invalid"); + return 0; + }else{ + return 1; + } +} + +/* +** Attempt to add, substract, or multiply the 64-bit signed value iB against +** the other 64-bit signed integer at *pA and store the result in *pA. +** Return 0 on success. Or if the operation would have resulted in an +** overflow, leave *pA unchanged and return 1. +*/ +SQLITE_PRIVATE int sqlite3AddInt64(i64 *pA, i64 iB){ +#if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER) + return __builtin_add_overflow(*pA, iB, pA); +#else + i64 iA = *pA; + testcase( iA==0 ); testcase( iA==1 ); + testcase( iB==-1 ); testcase( iB==0 ); + if( iB>=0 ){ + testcase( iA>0 && LARGEST_INT64 - iA == iB ); + testcase( iA>0 && LARGEST_INT64 - iA == iB - 1 ); + if( iA>0 && LARGEST_INT64 - iA < iB ) return 1; + }else{ + testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 1 ); + testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 2 ); + if( iA<0 && -(iA + LARGEST_INT64) > iB + 1 ) return 1; + } + *pA += iB; + return 0; +#endif +} +SQLITE_PRIVATE int sqlite3SubInt64(i64 *pA, i64 iB){ +#if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER) + return __builtin_sub_overflow(*pA, iB, pA); +#else + testcase( iB==SMALLEST_INT64+1 ); + if( iB==SMALLEST_INT64 ){ + testcase( (*pA)==(-1) ); testcase( (*pA)==0 ); + if( (*pA)>=0 ) return 1; + *pA -= iB; + return 0; + }else{ + return sqlite3AddInt64(pA, -iB); + } +#endif +} +SQLITE_PRIVATE int sqlite3MulInt64(i64 *pA, i64 iB){ +#if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER) + return __builtin_mul_overflow(*pA, iB, pA); +#else + i64 iA = *pA; + if( iB>0 ){ + if( iA>LARGEST_INT64/iB ) return 1; + if( iA0 ){ + if( iBLARGEST_INT64/-iB ) return 1; + } + } + *pA = iA*iB; + return 0; +#endif +} + +/* +** Compute the absolute value of a 32-bit signed integer, of possible. Or +** if the integer has a value of -2147483648, return +2147483647 +*/ +SQLITE_PRIVATE int sqlite3AbsInt32(int x){ + if( x>=0 ) return x; + if( x==(int)0x80000000 ) return 0x7fffffff; + return -x; +} + +#ifdef SQLITE_ENABLE_8_3_NAMES +/* +** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database +** filename in zBaseFilename is a URI with the "8_3_names=1" parameter and +** if filename in z[] has a suffix (a.k.a. "extension") that is longer than +** three characters, then shorten the suffix on z[] to be the last three +** characters of the original suffix. +** +** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always +** do the suffix shortening regardless of URI parameter. +** +** Examples: +** +** test.db-journal => test.nal +** test.db-wal => test.wal +** test.db-shm => test.shm +** test.db-mj7f3319fa => test.9fa +*/ +SQLITE_PRIVATE void sqlite3FileSuffix3(const char *zBaseFilename, char *z){ +#if SQLITE_ENABLE_8_3_NAMES<2 + if( sqlite3_uri_boolean(zBaseFilename, "8_3_names", 0) ) +#endif + { + int i, sz; + sz = sqlite3Strlen30(z); + for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){} + if( z[i]=='.' && ALWAYS(sz>i+4) ) memmove(&z[i+1], &z[sz-3], 4); + } +} +#endif + +/* +** Find (an approximate) sum of two LogEst values. This computation is +** not a simple "+" operator because LogEst is stored as a logarithmic +** value. +** +*/ +SQLITE_PRIVATE LogEst sqlite3LogEstAdd(LogEst a, LogEst b){ + static const unsigned char x[] = { + 10, 10, /* 0,1 */ + 9, 9, /* 2,3 */ + 8, 8, /* 4,5 */ + 7, 7, 7, /* 6,7,8 */ + 6, 6, 6, /* 9,10,11 */ + 5, 5, 5, /* 12-14 */ + 4, 4, 4, 4, /* 15-18 */ + 3, 3, 3, 3, 3, 3, /* 19-24 */ + 2, 2, 2, 2, 2, 2, 2, /* 25-31 */ + }; + if( a>=b ){ + if( a>b+49 ) return a; + if( a>b+31 ) return a+1; + return a+x[a-b]; + }else{ + if( b>a+49 ) return b; + if( b>a+31 ) return b+1; + return b+x[b-a]; + } +} + +/* +** Convert an integer into a LogEst. In other words, compute an +** approximation for 10*log2(x). +*/ +SQLITE_PRIVATE LogEst sqlite3LogEst(u64 x){ + static LogEst a[] = { 0, 2, 3, 5, 6, 7, 8, 9 }; + LogEst y = 40; + if( x<8 ){ + if( x<2 ) return 0; + while( x<8 ){ y -= 10; x <<= 1; } + }else{ +#if GCC_VERSION>=5004000 + int i = 60 - __builtin_clzll(x); + y += i*10; + x >>= i; +#else + while( x>255 ){ y += 40; x >>= 4; } /*OPTIMIZATION-IF-TRUE*/ + while( x>15 ){ y += 10; x >>= 1; } +#endif + } + return a[x&7] + y - 10; +} + +/* +** Convert a double into a LogEst +** In other words, compute an approximation for 10*log2(x). +*/ +SQLITE_PRIVATE LogEst sqlite3LogEstFromDouble(double x){ + u64 a; + LogEst e; + assert( sizeof(x)==8 && sizeof(a)==8 ); + if( x<=1 ) return 0; + if( x<=2000000000 ) return sqlite3LogEst((u64)x); + memcpy(&a, &x, 8); + e = (a>>52) - 1022; + return e*10; +} + +/* +** Convert a LogEst into an integer. +*/ +SQLITE_PRIVATE u64 sqlite3LogEstToInt(LogEst x){ + u64 n; + n = x%10; + x /= 10; + if( n>=5 ) n -= 2; + else if( n>=1 ) n -= 1; + if( x>60 ) return (u64)LARGEST_INT64; + return x>=3 ? (n+8)<<(x-3) : (n+8)>>(3-x); +} + +/* +** Add a new name/number pair to a VList. This might require that the +** VList object be reallocated, so return the new VList. If an OOM +** error occurs, the original VList returned and the +** db->mallocFailed flag is set. +** +** A VList is really just an array of integers. To destroy a VList, +** simply pass it to sqlite3DbFree(). +** +** The first integer is the number of integers allocated for the whole +** VList. The second integer is the number of integers actually used. +** Each name/number pair is encoded by subsequent groups of 3 or more +** integers. +** +** Each name/number pair starts with two integers which are the numeric +** value for the pair and the size of the name/number pair, respectively. +** The text name overlays one or more following integers. The text name +** is always zero-terminated. +** +** Conceptually: +** +** struct VList { +** int nAlloc; // Number of allocated slots +** int nUsed; // Number of used slots +** struct VListEntry { +** int iValue; // Value for this entry +** int nSlot; // Slots used by this entry +** // ... variable name goes here +** } a[0]; +** } +** +** During code generation, pointers to the variable names within the +** VList are taken. When that happens, nAlloc is set to zero as an +** indication that the VList may never again be enlarged, since the +** accompanying realloc() would invalidate the pointers. +*/ +SQLITE_PRIVATE VList *sqlite3VListAdd( + sqlite3 *db, /* The database connection used for malloc() */ + VList *pIn, /* The input VList. Might be NULL */ + const char *zName, /* Name of symbol to add */ + int nName, /* Bytes of text in zName */ + int iVal /* Value to associate with zName */ +){ + int nInt; /* number of sizeof(int) objects needed for zName */ + char *z; /* Pointer to where zName will be stored */ + int i; /* Index in pIn[] where zName is stored */ + + nInt = nName/4 + 3; + assert( pIn==0 || pIn[0]>=3 ); /* Verify ok to add new elements */ + if( pIn==0 || pIn[1]+nInt > pIn[0] ){ + /* Enlarge the allocation */ + sqlite3_int64 nAlloc = (pIn ? 2*(sqlite3_int64)pIn[0] : 10) + nInt; + VList *pOut = sqlite3DbRealloc(db, pIn, nAlloc*sizeof(int)); + if( pOut==0 ) return pIn; + if( pIn==0 ) pOut[1] = 2; + pIn = pOut; + pIn[0] = nAlloc; + } + i = pIn[1]; + pIn[i] = iVal; + pIn[i+1] = nInt; + z = (char*)&pIn[i+2]; + pIn[1] = i+nInt; + assert( pIn[1]<=pIn[0] ); + memcpy(z, zName, nName); + z[nName] = 0; + return pIn; +} + +/* +** Return a pointer to the name of a variable in the given VList that +** has the value iVal. Or return a NULL if there is no such variable in +** the list +*/ +SQLITE_PRIVATE const char *sqlite3VListNumToName(VList *pIn, int iVal){ + int i, mx; + if( pIn==0 ) return 0; + mx = pIn[1]; + i = 2; + do{ + if( pIn[i]==iVal ) return (char*)&pIn[i+2]; + i += pIn[i+1]; + }while( i */ + +/* Turn bulk memory into a hash table object by initializing the +** fields of the Hash structure. +** +** "pNew" is a pointer to the hash table that is to be initialized. +*/ +SQLITE_PRIVATE void sqlite3HashInit(Hash *pNew){ + assert( pNew!=0 ); + pNew->first = 0; + pNew->count = 0; + pNew->htsize = 0; + pNew->ht = 0; +} + +/* Remove all entries from a hash table. Reclaim all memory. +** Call this routine to delete a hash table or to reset a hash table +** to the empty state. +*/ +SQLITE_PRIVATE void sqlite3HashClear(Hash *pH){ + HashElem *elem; /* For looping over all elements of the table */ + + assert( pH!=0 ); + elem = pH->first; + pH->first = 0; + sqlite3_free(pH->ht); + pH->ht = 0; + pH->htsize = 0; + while( elem ){ + HashElem *next_elem = elem->next; + sqlite3_free(elem); + elem = next_elem; + } + pH->count = 0; +} + +/* +** The hashing function. +*/ +static unsigned int strHash(const char *z){ + unsigned int h = 0; + unsigned char c; + while( (c = (unsigned char)*z++)!=0 ){ /*OPTIMIZATION-IF-TRUE*/ + /* Knuth multiplicative hashing. (Sorting & Searching, p. 510). + ** 0x9e3779b1 is 2654435761 which is the closest prime number to + ** (2**32)*golden_ratio, where golden_ratio = (sqrt(5) - 1)/2. */ + h += sqlite3UpperToLower[c]; + h *= 0x9e3779b1; + } + return h; +} + + +/* Link pNew element into the hash table pH. If pEntry!=0 then also +** insert pNew into the pEntry hash bucket. +*/ +static void insertElement( + Hash *pH, /* The complete hash table */ + struct _ht *pEntry, /* The entry into which pNew is inserted */ + HashElem *pNew /* The element to be inserted */ +){ + HashElem *pHead; /* First element already in pEntry */ + if( pEntry ){ + pHead = pEntry->count ? pEntry->chain : 0; + pEntry->count++; + pEntry->chain = pNew; + }else{ + pHead = 0; + } + if( pHead ){ + pNew->next = pHead; + pNew->prev = pHead->prev; + if( pHead->prev ){ pHead->prev->next = pNew; } + else { pH->first = pNew; } + pHead->prev = pNew; + }else{ + pNew->next = pH->first; + if( pH->first ){ pH->first->prev = pNew; } + pNew->prev = 0; + pH->first = pNew; + } +} + + +/* Resize the hash table so that it cantains "new_size" buckets. +** +** The hash table might fail to resize if sqlite3_malloc() fails or +** if the new size is the same as the prior size. +** Return TRUE if the resize occurs and false if not. +*/ +static int rehash(Hash *pH, unsigned int new_size){ + struct _ht *new_ht; /* The new hash table */ + HashElem *elem, *next_elem; /* For looping over existing elements */ + +#if SQLITE_MALLOC_SOFT_LIMIT>0 + if( new_size*sizeof(struct _ht)>SQLITE_MALLOC_SOFT_LIMIT ){ + new_size = SQLITE_MALLOC_SOFT_LIMIT/sizeof(struct _ht); + } + if( new_size==pH->htsize ) return 0; +#endif + + /* The inability to allocates space for a larger hash table is + ** a performance hit but it is not a fatal error. So mark the + ** allocation as a benign. Use sqlite3Malloc()/memset(0) instead of + ** sqlite3MallocZero() to make the allocation, as sqlite3MallocZero() + ** only zeroes the requested number of bytes whereas this module will + ** use the actual amount of space allocated for the hash table (which + ** may be larger than the requested amount). + */ + sqlite3BeginBenignMalloc(); + new_ht = (struct _ht *)sqlite3Malloc( new_size*sizeof(struct _ht) ); + sqlite3EndBenignMalloc(); + + if( new_ht==0 ) return 0; + sqlite3_free(pH->ht); + pH->ht = new_ht; + pH->htsize = new_size = sqlite3MallocSize(new_ht)/sizeof(struct _ht); + memset(new_ht, 0, new_size*sizeof(struct _ht)); + for(elem=pH->first, pH->first=0; elem; elem = next_elem){ + unsigned int h = strHash(elem->pKey) % new_size; + next_elem = elem->next; + insertElement(pH, &new_ht[h], elem); + } + return 1; +} + +/* This function (for internal use only) locates an element in an +** hash table that matches the given key. If no element is found, +** a pointer to a static null element with HashElem.data==0 is returned. +** If pH is not NULL, then the hash for this key is written to *pH. +*/ +static HashElem *findElementWithHash( + const Hash *pH, /* The pH to be searched */ + const char *pKey, /* The key we are searching for */ + unsigned int *pHash /* Write the hash value here */ +){ + HashElem *elem; /* Used to loop thru the element list */ + unsigned int count; /* Number of elements left to test */ + unsigned int h; /* The computed hash */ + static HashElem nullElement = { 0, 0, 0, 0 }; + + if( pH->ht ){ /*OPTIMIZATION-IF-TRUE*/ + struct _ht *pEntry; + h = strHash(pKey) % pH->htsize; + pEntry = &pH->ht[h]; + elem = pEntry->chain; + count = pEntry->count; + }else{ + h = 0; + elem = pH->first; + count = pH->count; + } + if( pHash ) *pHash = h; + while( count ){ + assert( elem!=0 ); + if( sqlite3StrICmp(elem->pKey,pKey)==0 ){ + return elem; + } + elem = elem->next; + count--; + } + return &nullElement; +} + +/* Remove a single entry from the hash table given a pointer to that +** element and a hash on the element's key. +*/ +static void removeElementGivenHash( + Hash *pH, /* The pH containing "elem" */ + HashElem* elem, /* The element to be removed from the pH */ + unsigned int h /* Hash value for the element */ +){ + struct _ht *pEntry; + if( elem->prev ){ + elem->prev->next = elem->next; + }else{ + pH->first = elem->next; + } + if( elem->next ){ + elem->next->prev = elem->prev; + } + if( pH->ht ){ + pEntry = &pH->ht[h]; + if( pEntry->chain==elem ){ + pEntry->chain = elem->next; + } + assert( pEntry->count>0 ); + pEntry->count--; + } + sqlite3_free( elem ); + pH->count--; + if( pH->count==0 ){ + assert( pH->first==0 ); + assert( pH->count==0 ); + sqlite3HashClear(pH); + } +} + +/* Attempt to locate an element of the hash table pH with a key +** that matches pKey. Return the data for this element if it is +** found, or NULL if there is no match. +*/ +SQLITE_PRIVATE void *sqlite3HashFind(const Hash *pH, const char *pKey){ + assert( pH!=0 ); + assert( pKey!=0 ); + return findElementWithHash(pH, pKey, 0)->data; +} + +/* Insert an element into the hash table pH. The key is pKey +** and the data is "data". +** +** If no element exists with a matching key, then a new +** element is created and NULL is returned. +** +** If another element already exists with the same key, then the +** new data replaces the old data and the old data is returned. +** The key is not copied in this instance. If a malloc fails, then +** the new data is returned and the hash table is unchanged. +** +** If the "data" parameter to this function is NULL, then the +** element corresponding to "key" is removed from the hash table. +*/ +SQLITE_PRIVATE void *sqlite3HashInsert(Hash *pH, const char *pKey, void *data){ + unsigned int h; /* the hash of the key modulo hash table size */ + HashElem *elem; /* Used to loop thru the element list */ + HashElem *new_elem; /* New element added to the pH */ + + assert( pH!=0 ); + assert( pKey!=0 ); + elem = findElementWithHash(pH,pKey,&h); + if( elem->data ){ + void *old_data = elem->data; + if( data==0 ){ + removeElementGivenHash(pH,elem,h); + }else{ + elem->data = data; + elem->pKey = pKey; + } + return old_data; + } + if( data==0 ) return 0; + new_elem = (HashElem*)sqlite3Malloc( sizeof(HashElem) ); + if( new_elem==0 ) return data; + new_elem->pKey = pKey; + new_elem->data = data; + pH->count++; + if( pH->count>=10 && pH->count > 2*pH->htsize ){ + if( rehash(pH, pH->count*2) ){ + assert( pH->htsize>0 ); + h = strHash(pKey) % pH->htsize; + } + } + insertElement(pH, pH->ht ? &pH->ht[h] : 0, new_elem); + return 0; +} + +/************** End of hash.c ************************************************/ +/************** Begin file opcodes.c *****************************************/ +/* Automatically generated. Do not edit */ +/* See the tool/mkopcodec.tcl script for details. */ +#if !defined(SQLITE_OMIT_EXPLAIN) \ + || defined(VDBE_PROFILE) \ + || defined(SQLITE_DEBUG) +#if defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) || defined(SQLITE_DEBUG) +# define OpHelp(X) "\0" X +#else +# define OpHelp(X) +#endif +SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){ + static const char *const azName[] = { + /* 0 */ "Savepoint" OpHelp(""), + /* 1 */ "AutoCommit" OpHelp(""), + /* 2 */ "Transaction" OpHelp(""), + /* 3 */ "Checkpoint" OpHelp(""), + /* 4 */ "JournalMode" OpHelp(""), + /* 5 */ "Vacuum" OpHelp(""), + /* 6 */ "VFilter" OpHelp("iplan=r[P3] zplan='P4'"), + /* 7 */ "VUpdate" OpHelp("data=r[P3@P2]"), + /* 8 */ "Init" OpHelp("Start at P2"), + /* 9 */ "Goto" OpHelp(""), + /* 10 */ "Gosub" OpHelp(""), + /* 11 */ "InitCoroutine" OpHelp(""), + /* 12 */ "Yield" OpHelp(""), + /* 13 */ "MustBeInt" OpHelp(""), + /* 14 */ "Jump" OpHelp(""), + /* 15 */ "Once" OpHelp(""), + /* 16 */ "If" OpHelp(""), + /* 17 */ "IfNot" OpHelp(""), + /* 18 */ "IsType" OpHelp("if typeof(P1.P3) in P5 goto P2"), + /* 19 */ "Not" OpHelp("r[P2]= !r[P1]"), + /* 20 */ "IfNullRow" OpHelp("if P1.nullRow then r[P3]=NULL, goto P2"), + /* 21 */ "SeekLT" OpHelp("key=r[P3@P4]"), + /* 22 */ "SeekLE" OpHelp("key=r[P3@P4]"), + /* 23 */ "SeekGE" OpHelp("key=r[P3@P4]"), + /* 24 */ "SeekGT" OpHelp("key=r[P3@P4]"), + /* 25 */ "IfNotOpen" OpHelp("if( !csr[P1] ) goto P2"), + /* 26 */ "IfNoHope" OpHelp("key=r[P3@P4]"), + /* 27 */ "NoConflict" OpHelp("key=r[P3@P4]"), + /* 28 */ "NotFound" OpHelp("key=r[P3@P4]"), + /* 29 */ "Found" OpHelp("key=r[P3@P4]"), + /* 30 */ "SeekRowid" OpHelp("intkey=r[P3]"), + /* 31 */ "NotExists" OpHelp("intkey=r[P3]"), + /* 32 */ "Last" OpHelp(""), + /* 33 */ "IfSmaller" OpHelp(""), + /* 34 */ "SorterSort" OpHelp(""), + /* 35 */ "Sort" OpHelp(""), + /* 36 */ "Rewind" OpHelp(""), + /* 37 */ "SorterNext" OpHelp(""), + /* 38 */ "Prev" OpHelp(""), + /* 39 */ "Next" OpHelp(""), + /* 40 */ "IdxLE" OpHelp("key=r[P3@P4]"), + /* 41 */ "IdxGT" OpHelp("key=r[P3@P4]"), + /* 42 */ "IdxLT" OpHelp("key=r[P3@P4]"), + /* 43 */ "Or" OpHelp("r[P3]=(r[P1] || r[P2])"), + /* 44 */ "And" OpHelp("r[P3]=(r[P1] && r[P2])"), + /* 45 */ "IdxGE" OpHelp("key=r[P3@P4]"), + /* 46 */ "RowSetRead" OpHelp("r[P3]=rowset(P1)"), + /* 47 */ "RowSetTest" OpHelp("if r[P3] in rowset(P1) goto P2"), + /* 48 */ "Program" OpHelp(""), + /* 49 */ "FkIfZero" OpHelp("if fkctr[P1]==0 goto P2"), + /* 50 */ "IsNull" OpHelp("if r[P1]==NULL goto P2"), + /* 51 */ "NotNull" OpHelp("if r[P1]!=NULL goto P2"), + /* 52 */ "Ne" OpHelp("IF r[P3]!=r[P1]"), + /* 53 */ "Eq" OpHelp("IF r[P3]==r[P1]"), + /* 54 */ "Gt" OpHelp("IF r[P3]>r[P1]"), + /* 55 */ "Le" OpHelp("IF r[P3]<=r[P1]"), + /* 56 */ "Lt" OpHelp("IF r[P3]=r[P1]"), + /* 58 */ "ElseEq" OpHelp(""), + /* 59 */ "IfPos" OpHelp("if r[P1]>0 then r[P1]-=P3, goto P2"), + /* 60 */ "IfNotZero" OpHelp("if r[P1]!=0 then r[P1]--, goto P2"), + /* 61 */ "DecrJumpZero" OpHelp("if (--r[P1])==0 goto P2"), + /* 62 */ "IncrVacuum" OpHelp(""), + /* 63 */ "VNext" OpHelp(""), + /* 64 */ "Filter" OpHelp("if key(P3@P4) not in filter(P1) goto P2"), + /* 65 */ "PureFunc" OpHelp("r[P3]=func(r[P2@NP])"), + /* 66 */ "Function" OpHelp("r[P3]=func(r[P2@NP])"), + /* 67 */ "Return" OpHelp(""), + /* 68 */ "EndCoroutine" OpHelp(""), + /* 69 */ "HaltIfNull" OpHelp("if r[P3]=null halt"), + /* 70 */ "Halt" OpHelp(""), + /* 71 */ "Integer" OpHelp("r[P2]=P1"), + /* 72 */ "Int64" OpHelp("r[P2]=P4"), + /* 73 */ "String" OpHelp("r[P2]='P4' (len=P1)"), + /* 74 */ "BeginSubrtn" OpHelp("r[P2]=NULL"), + /* 75 */ "Null" OpHelp("r[P2..P3]=NULL"), + /* 76 */ "SoftNull" OpHelp("r[P1]=NULL"), + /* 77 */ "Blob" OpHelp("r[P2]=P4 (len=P1)"), + /* 78 */ "Variable" OpHelp("r[P2]=parameter(P1,P4)"), + /* 79 */ "Move" OpHelp("r[P2@P3]=r[P1@P3]"), + /* 80 */ "Copy" OpHelp("r[P2@P3+1]=r[P1@P3+1]"), + /* 81 */ "SCopy" OpHelp("r[P2]=r[P1]"), + /* 82 */ "IntCopy" OpHelp("r[P2]=r[P1]"), + /* 83 */ "FkCheck" OpHelp(""), + /* 84 */ "ResultRow" OpHelp("output=r[P1@P2]"), + /* 85 */ "CollSeq" OpHelp(""), + /* 86 */ "AddImm" OpHelp("r[P1]=r[P1]+P2"), + /* 87 */ "RealAffinity" OpHelp(""), + /* 88 */ "Cast" OpHelp("affinity(r[P1])"), + /* 89 */ "Permutation" OpHelp(""), + /* 90 */ "Compare" OpHelp("r[P1@P3] <-> r[P2@P3]"), + /* 91 */ "IsTrue" OpHelp("r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4"), + /* 92 */ "ZeroOrNull" OpHelp("r[P2] = 0 OR NULL"), + /* 93 */ "Offset" OpHelp("r[P3] = sqlite_offset(P1)"), + /* 94 */ "Column" OpHelp("r[P3]=PX cursor P1 column P2"), + /* 95 */ "TypeCheck" OpHelp("typecheck(r[P1@P2])"), + /* 96 */ "Affinity" OpHelp("affinity(r[P1@P2])"), + /* 97 */ "MakeRecord" OpHelp("r[P3]=mkrec(r[P1@P2])"), + /* 98 */ "Count" OpHelp("r[P2]=count()"), + /* 99 */ "ReadCookie" OpHelp(""), + /* 100 */ "SetCookie" OpHelp(""), + /* 101 */ "ReopenIdx" OpHelp("root=P2 iDb=P3"), + /* 102 */ "BitAnd" OpHelp("r[P3]=r[P1]&r[P2]"), + /* 103 */ "BitOr" OpHelp("r[P3]=r[P1]|r[P2]"), + /* 104 */ "ShiftLeft" OpHelp("r[P3]=r[P2]<>r[P1]"), + /* 106 */ "Add" OpHelp("r[P3]=r[P1]+r[P2]"), + /* 107 */ "Subtract" OpHelp("r[P3]=r[P2]-r[P1]"), + /* 108 */ "Multiply" OpHelp("r[P3]=r[P1]*r[P2]"), + /* 109 */ "Divide" OpHelp("r[P3]=r[P2]/r[P1]"), + /* 110 */ "Remainder" OpHelp("r[P3]=r[P2]%r[P1]"), + /* 111 */ "Concat" OpHelp("r[P3]=r[P2]+r[P1]"), + /* 112 */ "OpenRead" OpHelp("root=P2 iDb=P3"), + /* 113 */ "OpenWrite" OpHelp("root=P2 iDb=P3"), + /* 114 */ "BitNot" OpHelp("r[P2]= ~r[P1]"), + /* 115 */ "OpenDup" OpHelp(""), + /* 116 */ "OpenAutoindex" OpHelp("nColumn=P2"), + /* 117 */ "String8" OpHelp("r[P2]='P4'"), + /* 118 */ "OpenEphemeral" OpHelp("nColumn=P2"), + /* 119 */ "SorterOpen" OpHelp(""), + /* 120 */ "SequenceTest" OpHelp("if( cursor[P1].ctr++ ) pc = P2"), + /* 121 */ "OpenPseudo" OpHelp("P3 columns in r[P2]"), + /* 122 */ "Close" OpHelp(""), + /* 123 */ "ColumnsUsed" OpHelp(""), + /* 124 */ "SeekScan" OpHelp("Scan-ahead up to P1 rows"), + /* 125 */ "SeekHit" OpHelp("set P2<=seekHit<=P3"), + /* 126 */ "Sequence" OpHelp("r[P2]=cursor[P1].ctr++"), + /* 127 */ "NewRowid" OpHelp("r[P2]=rowid"), + /* 128 */ "Insert" OpHelp("intkey=r[P3] data=r[P2]"), + /* 129 */ "RowCell" OpHelp(""), + /* 130 */ "Delete" OpHelp(""), + /* 131 */ "ResetCount" OpHelp(""), + /* 132 */ "SorterCompare" OpHelp("if key(P1)!=trim(r[P3],P4) goto P2"), + /* 133 */ "SorterData" OpHelp("r[P2]=data"), + /* 134 */ "RowData" OpHelp("r[P2]=data"), + /* 135 */ "Rowid" OpHelp("r[P2]=PX rowid of P1"), + /* 136 */ "NullRow" OpHelp(""), + /* 137 */ "SeekEnd" OpHelp(""), + /* 138 */ "IdxInsert" OpHelp("key=r[P2]"), + /* 139 */ "SorterInsert" OpHelp("key=r[P2]"), + /* 140 */ "IdxDelete" OpHelp("key=r[P2@P3]"), + /* 141 */ "DeferredSeek" OpHelp("Move P3 to P1.rowid if needed"), + /* 142 */ "IdxRowid" OpHelp("r[P2]=rowid"), + /* 143 */ "FinishSeek" OpHelp(""), + /* 144 */ "Destroy" OpHelp(""), + /* 145 */ "Clear" OpHelp(""), + /* 146 */ "ResetSorter" OpHelp(""), + /* 147 */ "CreateBtree" OpHelp("r[P2]=root iDb=P1 flags=P3"), + /* 148 */ "SqlExec" OpHelp(""), + /* 149 */ "ParseSchema" OpHelp(""), + /* 150 */ "LoadAnalysis" OpHelp(""), + /* 151 */ "DropTable" OpHelp(""), + /* 152 */ "DropIndex" OpHelp(""), + /* 153 */ "Real" OpHelp("r[P2]=P4"), + /* 154 */ "DropTrigger" OpHelp(""), + /* 155 */ "IntegrityCk" OpHelp(""), + /* 156 */ "RowSetAdd" OpHelp("rowset(P1)=r[P2]"), + /* 157 */ "Param" OpHelp(""), + /* 158 */ "FkCounter" OpHelp("fkctr[P1]+=P2"), + /* 159 */ "MemMax" OpHelp("r[P1]=max(r[P1],r[P2])"), + /* 160 */ "OffsetLimit" OpHelp("if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)"), + /* 161 */ "AggInverse" OpHelp("accum=r[P3] inverse(r[P2@P5])"), + /* 162 */ "AggStep" OpHelp("accum=r[P3] step(r[P2@P5])"), + /* 163 */ "AggStep1" OpHelp("accum=r[P3] step(r[P2@P5])"), + /* 164 */ "AggValue" OpHelp("r[P3]=value N=P2"), + /* 165 */ "AggFinal" OpHelp("accum=r[P1] N=P2"), + /* 166 */ "Expire" OpHelp(""), + /* 167 */ "CursorLock" OpHelp(""), + /* 168 */ "CursorUnlock" OpHelp(""), + /* 169 */ "TableLock" OpHelp("iDb=P1 root=P2 write=P3"), + /* 170 */ "VBegin" OpHelp(""), + /* 171 */ "VCreate" OpHelp(""), + /* 172 */ "VDestroy" OpHelp(""), + /* 173 */ "VOpen" OpHelp(""), + /* 174 */ "VInitIn" OpHelp("r[P2]=ValueList(P1,P3)"), + /* 175 */ "VColumn" OpHelp("r[P3]=vcolumn(P2)"), + /* 176 */ "VRename" OpHelp(""), + /* 177 */ "Pagecount" OpHelp(""), + /* 178 */ "MaxPgcnt" OpHelp(""), + /* 179 */ "ClrSubtype" OpHelp("r[P1].subtype = 0"), + /* 180 */ "FilterAdd" OpHelp("filter(P1) += key(P3@P4)"), + /* 181 */ "Trace" OpHelp(""), + /* 182 */ "CursorHint" OpHelp(""), + /* 183 */ "ReleaseReg" OpHelp("release r[P1@P2] mask P3"), + /* 184 */ "Noop" OpHelp(""), + /* 185 */ "Explain" OpHelp(""), + /* 186 */ "Abortable" OpHelp(""), + }; + return azName[i]; +} +#endif + +/************** End of opcodes.c *********************************************/ +/************** Begin file os_kv.c *******************************************/ +/* +** 2022-09-06 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains an experimental VFS layer that operates on a +** Key/Value storage engine where both keys and values must be pure +** text. +*/ +/* #include */ +#if SQLITE_OS_KV || (SQLITE_OS_UNIX && defined(SQLITE_OS_KV_OPTIONAL)) + +/***************************************************************************** +** Debugging logic +*/ + +/* SQLITE_KV_TRACE() is used for tracing calls to kvstorage routines. */ +#if 0 +#define SQLITE_KV_TRACE(X) printf X +#else +#define SQLITE_KV_TRACE(X) +#endif + +/* SQLITE_KV_LOG() is used for tracing calls to the VFS interface */ +#if 0 +#define SQLITE_KV_LOG(X) printf X +#else +#define SQLITE_KV_LOG(X) +#endif + + +/* +** Forward declaration of objects used by this VFS implementation +*/ +typedef struct KVVfsFile KVVfsFile; + +/* A single open file. There are only two files represented by this +** VFS - the database and the rollback journal. +*/ +struct KVVfsFile { + sqlite3_file base; /* IO methods */ + const char *zClass; /* Storage class */ + int isJournal; /* True if this is a journal file */ + unsigned int nJrnl; /* Space allocated for aJrnl[] */ + char *aJrnl; /* Journal content */ + int szPage; /* Last known page size */ + sqlite3_int64 szDb; /* Database file size. -1 means unknown */ + char *aData; /* Buffer to hold page data */ +}; +#define SQLITE_KVOS_SZ 133073 + +/* +** Methods for KVVfsFile +*/ +static int kvvfsClose(sqlite3_file*); +static int kvvfsReadDb(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); +static int kvvfsReadJrnl(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); +static int kvvfsWriteDb(sqlite3_file*,const void*,int iAmt, sqlite3_int64); +static int kvvfsWriteJrnl(sqlite3_file*,const void*,int iAmt, sqlite3_int64); +static int kvvfsTruncateDb(sqlite3_file*, sqlite3_int64 size); +static int kvvfsTruncateJrnl(sqlite3_file*, sqlite3_int64 size); +static int kvvfsSyncDb(sqlite3_file*, int flags); +static int kvvfsSyncJrnl(sqlite3_file*, int flags); +static int kvvfsFileSizeDb(sqlite3_file*, sqlite3_int64 *pSize); +static int kvvfsFileSizeJrnl(sqlite3_file*, sqlite3_int64 *pSize); +static int kvvfsLock(sqlite3_file*, int); +static int kvvfsUnlock(sqlite3_file*, int); +static int kvvfsCheckReservedLock(sqlite3_file*, int *pResOut); +static int kvvfsFileControlDb(sqlite3_file*, int op, void *pArg); +static int kvvfsFileControlJrnl(sqlite3_file*, int op, void *pArg); +static int kvvfsSectorSize(sqlite3_file*); +static int kvvfsDeviceCharacteristics(sqlite3_file*); + +/* +** Methods for sqlite3_vfs +*/ +static int kvvfsOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *); +static int kvvfsDelete(sqlite3_vfs*, const char *zName, int syncDir); +static int kvvfsAccess(sqlite3_vfs*, const char *zName, int flags, int *); +static int kvvfsFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut); +static void *kvvfsDlOpen(sqlite3_vfs*, const char *zFilename); +static int kvvfsRandomness(sqlite3_vfs*, int nByte, char *zOut); +static int kvvfsSleep(sqlite3_vfs*, int microseconds); +static int kvvfsCurrentTime(sqlite3_vfs*, double*); +static int kvvfsCurrentTimeInt64(sqlite3_vfs*, sqlite3_int64*); + +static sqlite3_vfs sqlite3OsKvvfsObject = { + 1, /* iVersion */ + sizeof(KVVfsFile), /* szOsFile */ + 1024, /* mxPathname */ + 0, /* pNext */ + "kvvfs", /* zName */ + 0, /* pAppData */ + kvvfsOpen, /* xOpen */ + kvvfsDelete, /* xDelete */ + kvvfsAccess, /* xAccess */ + kvvfsFullPathname, /* xFullPathname */ + kvvfsDlOpen, /* xDlOpen */ + 0, /* xDlError */ + 0, /* xDlSym */ + 0, /* xDlClose */ + kvvfsRandomness, /* xRandomness */ + kvvfsSleep, /* xSleep */ + kvvfsCurrentTime, /* xCurrentTime */ + 0, /* xGetLastError */ + kvvfsCurrentTimeInt64 /* xCurrentTimeInt64 */ +}; + +/* Methods for sqlite3_file objects referencing a database file +*/ +static sqlite3_io_methods kvvfs_db_io_methods = { + 1, /* iVersion */ + kvvfsClose, /* xClose */ + kvvfsReadDb, /* xRead */ + kvvfsWriteDb, /* xWrite */ + kvvfsTruncateDb, /* xTruncate */ + kvvfsSyncDb, /* xSync */ + kvvfsFileSizeDb, /* xFileSize */ + kvvfsLock, /* xLock */ + kvvfsUnlock, /* xUnlock */ + kvvfsCheckReservedLock, /* xCheckReservedLock */ + kvvfsFileControlDb, /* xFileControl */ + kvvfsSectorSize, /* xSectorSize */ + kvvfsDeviceCharacteristics, /* xDeviceCharacteristics */ + 0, /* xShmMap */ + 0, /* xShmLock */ + 0, /* xShmBarrier */ + 0, /* xShmUnmap */ + 0, /* xFetch */ + 0 /* xUnfetch */ +}; + +/* Methods for sqlite3_file objects referencing a rollback journal +*/ +static sqlite3_io_methods kvvfs_jrnl_io_methods = { + 1, /* iVersion */ + kvvfsClose, /* xClose */ + kvvfsReadJrnl, /* xRead */ + kvvfsWriteJrnl, /* xWrite */ + kvvfsTruncateJrnl, /* xTruncate */ + kvvfsSyncJrnl, /* xSync */ + kvvfsFileSizeJrnl, /* xFileSize */ + kvvfsLock, /* xLock */ + kvvfsUnlock, /* xUnlock */ + kvvfsCheckReservedLock, /* xCheckReservedLock */ + kvvfsFileControlJrnl, /* xFileControl */ + kvvfsSectorSize, /* xSectorSize */ + kvvfsDeviceCharacteristics, /* xDeviceCharacteristics */ + 0, /* xShmMap */ + 0, /* xShmLock */ + 0, /* xShmBarrier */ + 0, /* xShmUnmap */ + 0, /* xFetch */ + 0 /* xUnfetch */ +}; + +/****** Storage subsystem **************************************************/ +#include +#include +#include + +/* Forward declarations for the low-level storage engine +*/ +static int kvstorageWrite(const char*, const char *zKey, const char *zData); +static int kvstorageDelete(const char*, const char *zKey); +static int kvstorageRead(const char*, const char *zKey, char *zBuf, int nBuf); +#define KVSTORAGE_KEY_SZ 32 + +/* Expand the key name with an appropriate prefix and put the result +** zKeyOut[]. The zKeyOut[] buffer is assumed to hold at least +** KVSTORAGE_KEY_SZ bytes. +*/ +static void kvstorageMakeKey( + const char *zClass, + const char *zKeyIn, + char *zKeyOut +){ + sqlite3_snprintf(KVSTORAGE_KEY_SZ, zKeyOut, "kvvfs-%s-%s", zClass, zKeyIn); +} + +/* Write content into a key. zClass is the particular namespace of the +** underlying key/value store to use - either "local" or "session". +** +** Both zKey and zData are zero-terminated pure text strings. +** +** Return the number of errors. +*/ +static int kvstorageWrite( + const char *zClass, + const char *zKey, + const char *zData +){ + FILE *fd; + char zXKey[KVSTORAGE_KEY_SZ]; + kvstorageMakeKey(zClass, zKey, zXKey); + fd = fopen(zXKey, "wb"); + if( fd ){ + SQLITE_KV_TRACE(("KVVFS-WRITE %-15s (%d) %.50s%s\n", zXKey, + (int)strlen(zData), zData, + strlen(zData)>50 ? "..." : "")); + fputs(zData, fd); + fclose(fd); + return 0; + }else{ + return 1; + } +} + +/* Delete a key (with its corresponding data) from the key/value +** namespace given by zClass. If the key does not previously exist, +** this routine is a no-op. +*/ +static int kvstorageDelete(const char *zClass, const char *zKey){ + char zXKey[KVSTORAGE_KEY_SZ]; + kvstorageMakeKey(zClass, zKey, zXKey); + unlink(zXKey); + SQLITE_KV_TRACE(("KVVFS-DELETE %-15s\n", zXKey)); + return 0; +} + +/* Read the value associated with a zKey from the key/value namespace given +** by zClass and put the text data associated with that key in the first +** nBuf bytes of zBuf[]. The value might be truncated if zBuf is not large +** enough to hold it all. The value put into zBuf must always be zero +** terminated, even if it gets truncated because nBuf is not large enough. +** +** Return the total number of bytes in the data, without truncation, and +** not counting the final zero terminator. Return -1 if the key does +** not exist. +** +** If nBuf<=0 then this routine simply returns the size of the data without +** actually reading it. +*/ +static int kvstorageRead( + const char *zClass, + const char *zKey, + char *zBuf, + int nBuf +){ + FILE *fd; + struct stat buf; + char zXKey[KVSTORAGE_KEY_SZ]; + kvstorageMakeKey(zClass, zKey, zXKey); + if( access(zXKey, R_OK)!=0 + || stat(zXKey, &buf)!=0 + || !S_ISREG(buf.st_mode) + ){ + SQLITE_KV_TRACE(("KVVFS-READ %-15s (-1)\n", zXKey)); + return -1; + } + if( nBuf<=0 ){ + return (int)buf.st_size; + }else if( nBuf==1 ){ + zBuf[0] = 0; + SQLITE_KV_TRACE(("KVVFS-READ %-15s (%d)\n", zXKey, + (int)buf.st_size)); + return (int)buf.st_size; + } + if( nBuf > buf.st_size + 1 ){ + nBuf = buf.st_size + 1; + } + fd = fopen(zXKey, "rb"); + if( fd==0 ){ + SQLITE_KV_TRACE(("KVVFS-READ %-15s (-1)\n", zXKey)); + return -1; + }else{ + sqlite3_int64 n = fread(zBuf, 1, nBuf-1, fd); + fclose(fd); + zBuf[n] = 0; + SQLITE_KV_TRACE(("KVVFS-READ %-15s (%lld) %.50s%s\n", zXKey, + n, zBuf, n>50 ? "..." : "")); + return (int)n; + } +} + +/* +** An internal level of indirection which enables us to replace the +** kvvfs i/o methods with JavaScript implementations in WASM builds. +** Maintenance reminder: if this struct changes in any way, the JSON +** rendering of its structure must be updated in +** sqlite3_wasm_enum_json(). There are no binary compatibility +** concerns, so it does not need an iVersion member. This file is +** necessarily always compiled together with sqlite3_wasm_enum_json(), +** and JS code dynamically creates the mapping of members based on +** that JSON description. +*/ +typedef struct sqlite3_kvvfs_methods sqlite3_kvvfs_methods; +struct sqlite3_kvvfs_methods { + int (*xRead)(const char *zClass, const char *zKey, char *zBuf, int nBuf); + int (*xWrite)(const char *zClass, const char *zKey, const char *zData); + int (*xDelete)(const char *zClass, const char *zKey); + const int nKeySize; +}; + +/* +** This object holds the kvvfs I/O methods which may be swapped out +** for JavaScript-side implementations in WASM builds. In such builds +** it cannot be const, but in native builds it should be so that +** the compiler can hopefully optimize this level of indirection out. +** That said, kvvfs is intended primarily for use in WASM builds. +** +** Note that this is not explicitly flagged as static because the +** amalgamation build will tag it with SQLITE_PRIVATE. +*/ +#ifndef SQLITE_WASM +const +#endif +SQLITE_PRIVATE sqlite3_kvvfs_methods sqlite3KvvfsMethods = { +kvstorageRead, +kvstorageWrite, +kvstorageDelete, +KVSTORAGE_KEY_SZ +}; + +/****** Utility subroutines ************************************************/ + +/* +** Encode binary into the text encoded used to persist on disk. +** The output text is stored in aOut[], which must be at least +** nData+1 bytes in length. +** +** Return the actual length of the encoded text, not counting the +** zero terminator at the end. +** +** Encoding format +** --------------- +** +** * Non-zero bytes are encoded as upper-case hexadecimal +** +** * A sequence of one or more zero-bytes that are not at the +** beginning of the buffer are encoded as a little-endian +** base-26 number using a..z. "a" means 0. "b" means 1, +** "z" means 25. "ab" means 26. "ac" means 52. And so forth. +** +** * Because there is no overlap between the encoding characters +** of hexadecimal and base-26 numbers, it is always clear where +** one stops and the next begins. +*/ +static int kvvfsEncode(const char *aData, int nData, char *aOut){ + int i, j; + const unsigned char *a = (const unsigned char*)aData; + for(i=j=0; i>4]; + aOut[j++] = "0123456789ABCDEF"[c&0xf]; + }else{ + /* A sequence of 1 or more zeros is stored as a little-endian + ** base-26 number using a..z as the digits. So one zero is "b". + ** Two zeros is "c". 25 zeros is "z", 26 zeros is "ab", 27 is "bb", + ** and so forth. + */ + int k; + for(k=1; i+k0 ){ + aOut[j++] = 'a'+(k%26); + k /= 26; + } + } + } + aOut[j] = 0; + return j; +} + +static const signed char kvvfsHexValue[256] = { + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, + -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 +}; + +/* +** Decode the text encoding back to binary. The binary content is +** written into pOut, which must be at least nOut bytes in length. +** +** The return value is the number of bytes actually written into aOut[]. +*/ +static int kvvfsDecode(const char *a, char *aOut, int nOut){ + int i, j; + int c; + const unsigned char *aIn = (const unsigned char*)a; + i = 0; + j = 0; + while( 1 ){ + c = kvvfsHexValue[aIn[i]]; + if( c<0 ){ + int n = 0; + int mult = 1; + c = aIn[i]; + if( c==0 ) break; + while( c>='a' && c<='z' ){ + n += (c - 'a')*mult; + mult *= 26; + c = aIn[++i]; + } + if( j+n>nOut ) return -1; + memset(&aOut[j], 0, n); + j += n; + if( c==0 || mult==1 ) break; /* progress stalled if mult==1 */ + }else{ + aOut[j] = c<<4; + c = kvvfsHexValue[aIn[++i]]; + if( c<0 ) break; + aOut[j++] += c; + i++; + } + } + return j; +} + +/* +** Decode a complete journal file. Allocate space in pFile->aJrnl +** and store the decoding there. Or leave pFile->aJrnl set to NULL +** if an error is encountered. +** +** The first few characters of the text encoding will be a little-endian +** base-26 number (digits a..z) that is the total number of bytes +** in the decoded journal file image. This base-26 number is followed +** by a single space, then the encoding of the journal. The space +** separator is required to act as a terminator for the base-26 number. +*/ +static void kvvfsDecodeJournal( + KVVfsFile *pFile, /* Store decoding in pFile->aJrnl */ + const char *zTxt, /* Text encoding. Zero-terminated */ + int nTxt /* Bytes in zTxt, excluding zero terminator */ +){ + unsigned int n = 0; + int c, i, mult; + i = 0; + mult = 1; + while( (c = zTxt[i++])>='a' && c<='z' ){ + n += (zTxt[i] - 'a')*mult; + mult *= 26; + } + sqlite3_free(pFile->aJrnl); + pFile->aJrnl = sqlite3_malloc64( n ); + if( pFile->aJrnl==0 ){ + pFile->nJrnl = 0; + return; + } + pFile->nJrnl = n; + n = kvvfsDecode(zTxt+i, pFile->aJrnl, pFile->nJrnl); + if( nnJrnl ){ + sqlite3_free(pFile->aJrnl); + pFile->aJrnl = 0; + pFile->nJrnl = 0; + } +} + +/* +** Read or write the "sz" element, containing the database file size. +*/ +static sqlite3_int64 kvvfsReadFileSize(KVVfsFile *pFile){ + char zData[50]; + zData[0] = 0; + sqlite3KvvfsMethods.xRead(pFile->zClass, "sz", zData, sizeof(zData)-1); + return strtoll(zData, 0, 0); +} +static int kvvfsWriteFileSize(KVVfsFile *pFile, sqlite3_int64 sz){ + char zData[50]; + sqlite3_snprintf(sizeof(zData), zData, "%lld", sz); + return sqlite3KvvfsMethods.xWrite(pFile->zClass, "sz", zData); +} + +/****** sqlite3_io_methods methods ******************************************/ + +/* +** Close an kvvfs-file. +*/ +static int kvvfsClose(sqlite3_file *pProtoFile){ + KVVfsFile *pFile = (KVVfsFile *)pProtoFile; + + SQLITE_KV_LOG(("xClose %s %s\n", pFile->zClass, + pFile->isJournal ? "journal" : "db")); + sqlite3_free(pFile->aJrnl); + sqlite3_free(pFile->aData); + return SQLITE_OK; +} + +/* +** Read from the -journal file. +*/ +static int kvvfsReadJrnl( + sqlite3_file *pProtoFile, + void *zBuf, + int iAmt, + sqlite_int64 iOfst +){ + KVVfsFile *pFile = (KVVfsFile*)pProtoFile; + assert( pFile->isJournal ); + SQLITE_KV_LOG(("xRead('%s-journal',%d,%lld)\n", pFile->zClass, iAmt, iOfst)); + if( pFile->aJrnl==0 ){ + int szTxt = kvstorageRead(pFile->zClass, "jrnl", 0, 0); + char *aTxt; + if( szTxt<=4 ){ + return SQLITE_IOERR; + } + aTxt = sqlite3_malloc64( szTxt+1 ); + if( aTxt==0 ) return SQLITE_NOMEM; + kvstorageRead(pFile->zClass, "jrnl", aTxt, szTxt+1); + kvvfsDecodeJournal(pFile, aTxt, szTxt); + sqlite3_free(aTxt); + if( pFile->aJrnl==0 ) return SQLITE_IOERR; + } + if( iOfst+iAmt>pFile->nJrnl ){ + return SQLITE_IOERR_SHORT_READ; + } + memcpy(zBuf, pFile->aJrnl+iOfst, iAmt); + return SQLITE_OK; +} + +/* +** Read from the database file. +*/ +static int kvvfsReadDb( + sqlite3_file *pProtoFile, + void *zBuf, + int iAmt, + sqlite_int64 iOfst +){ + KVVfsFile *pFile = (KVVfsFile*)pProtoFile; + unsigned int pgno; + int got, n; + char zKey[30]; + char *aData = pFile->aData; + assert( iOfst>=0 ); + assert( iAmt>=0 ); + SQLITE_KV_LOG(("xRead('%s-db',%d,%lld)\n", pFile->zClass, iAmt, iOfst)); + if( iOfst+iAmt>=512 ){ + if( (iOfst % iAmt)!=0 ){ + return SQLITE_IOERR_READ; + } + if( (iAmt & (iAmt-1))!=0 || iAmt<512 || iAmt>65536 ){ + return SQLITE_IOERR_READ; + } + pFile->szPage = iAmt; + pgno = 1 + iOfst/iAmt; + }else{ + pgno = 1; + } + sqlite3_snprintf(sizeof(zKey), zKey, "%u", pgno); + got = sqlite3KvvfsMethods.xRead(pFile->zClass, zKey, + aData, SQLITE_KVOS_SZ-1); + if( got<0 ){ + n = 0; + }else{ + aData[got] = 0; + if( iOfst+iAmt<512 ){ + int k = iOfst+iAmt; + aData[k*2] = 0; + n = kvvfsDecode(aData, &aData[2000], SQLITE_KVOS_SZ-2000); + if( n>=iOfst+iAmt ){ + memcpy(zBuf, &aData[2000+iOfst], iAmt); + n = iAmt; + }else{ + n = 0; + } + }else{ + n = kvvfsDecode(aData, zBuf, iAmt); + } + } + if( nzClass, iAmt, iOfst)); + if( iEnd>=0x10000000 ) return SQLITE_FULL; + if( pFile->aJrnl==0 || pFile->nJrnlaJrnl, iEnd); + if( aNew==0 ){ + return SQLITE_IOERR_NOMEM; + } + pFile->aJrnl = aNew; + if( pFile->nJrnlaJrnl+pFile->nJrnl, 0, iOfst-pFile->nJrnl); + } + pFile->nJrnl = iEnd; + } + memcpy(pFile->aJrnl+iOfst, zBuf, iAmt); + return SQLITE_OK; +} + +/* +** Write into the database file. +*/ +static int kvvfsWriteDb( + sqlite3_file *pProtoFile, + const void *zBuf, + int iAmt, + sqlite_int64 iOfst +){ + KVVfsFile *pFile = (KVVfsFile*)pProtoFile; + unsigned int pgno; + char zKey[30]; + char *aData = pFile->aData; + SQLITE_KV_LOG(("xWrite('%s-db',%d,%lld)\n", pFile->zClass, iAmt, iOfst)); + assert( iAmt>=512 && iAmt<=65536 ); + assert( (iAmt & (iAmt-1))==0 ); + assert( pFile->szPage<0 || pFile->szPage==iAmt ); + pFile->szPage = iAmt; + pgno = 1 + iOfst/iAmt; + sqlite3_snprintf(sizeof(zKey), zKey, "%u", pgno); + kvvfsEncode(zBuf, iAmt, aData); + if( sqlite3KvvfsMethods.xWrite(pFile->zClass, zKey, aData) ){ + return SQLITE_IOERR; + } + if( iOfst+iAmt > pFile->szDb ){ + pFile->szDb = iOfst + iAmt; + } + return SQLITE_OK; +} + +/* +** Truncate an kvvfs-file. +*/ +static int kvvfsTruncateJrnl(sqlite3_file *pProtoFile, sqlite_int64 size){ + KVVfsFile *pFile = (KVVfsFile *)pProtoFile; + SQLITE_KV_LOG(("xTruncate('%s-journal',%lld)\n", pFile->zClass, size)); + assert( size==0 ); + sqlite3KvvfsMethods.xDelete(pFile->zClass, "jrnl"); + sqlite3_free(pFile->aJrnl); + pFile->aJrnl = 0; + pFile->nJrnl = 0; + return SQLITE_OK; +} +static int kvvfsTruncateDb(sqlite3_file *pProtoFile, sqlite_int64 size){ + KVVfsFile *pFile = (KVVfsFile *)pProtoFile; + if( pFile->szDb>size + && pFile->szPage>0 + && (size % pFile->szPage)==0 + ){ + char zKey[50]; + unsigned int pgno, pgnoMax; + SQLITE_KV_LOG(("xTruncate('%s-db',%lld)\n", pFile->zClass, size)); + pgno = 1 + size/pFile->szPage; + pgnoMax = 2 + pFile->szDb/pFile->szPage; + while( pgno<=pgnoMax ){ + sqlite3_snprintf(sizeof(zKey), zKey, "%u", pgno); + sqlite3KvvfsMethods.xDelete(pFile->zClass, zKey); + pgno++; + } + pFile->szDb = size; + return kvvfsWriteFileSize(pFile, size) ? SQLITE_IOERR : SQLITE_OK; + } + return SQLITE_IOERR; +} + +/* +** Sync an kvvfs-file. +*/ +static int kvvfsSyncJrnl(sqlite3_file *pProtoFile, int flags){ + int i, n; + KVVfsFile *pFile = (KVVfsFile *)pProtoFile; + char *zOut; + SQLITE_KV_LOG(("xSync('%s-journal')\n", pFile->zClass)); + if( pFile->nJrnl<=0 ){ + return kvvfsTruncateJrnl(pProtoFile, 0); + } + zOut = sqlite3_malloc64( pFile->nJrnl*2 + 50 ); + if( zOut==0 ){ + return SQLITE_IOERR_NOMEM; + } + n = pFile->nJrnl; + i = 0; + do{ + zOut[i++] = 'a' + (n%26); + n /= 26; + }while( n>0 ); + zOut[i++] = ' '; + kvvfsEncode(pFile->aJrnl, pFile->nJrnl, &zOut[i]); + i = sqlite3KvvfsMethods.xWrite(pFile->zClass, "jrnl", zOut); + sqlite3_free(zOut); + return i ? SQLITE_IOERR : SQLITE_OK; +} +static int kvvfsSyncDb(sqlite3_file *pProtoFile, int flags){ + return SQLITE_OK; +} + +/* +** Return the current file-size of an kvvfs-file. +*/ +static int kvvfsFileSizeJrnl(sqlite3_file *pProtoFile, sqlite_int64 *pSize){ + KVVfsFile *pFile = (KVVfsFile *)pProtoFile; + SQLITE_KV_LOG(("xFileSize('%s-journal')\n", pFile->zClass)); + *pSize = pFile->nJrnl; + return SQLITE_OK; +} +static int kvvfsFileSizeDb(sqlite3_file *pProtoFile, sqlite_int64 *pSize){ + KVVfsFile *pFile = (KVVfsFile *)pProtoFile; + SQLITE_KV_LOG(("xFileSize('%s-db')\n", pFile->zClass)); + if( pFile->szDb>=0 ){ + *pSize = pFile->szDb; + }else{ + *pSize = kvvfsReadFileSize(pFile); + } + return SQLITE_OK; +} + +/* +** Lock an kvvfs-file. +*/ +static int kvvfsLock(sqlite3_file *pProtoFile, int eLock){ + KVVfsFile *pFile = (KVVfsFile *)pProtoFile; + assert( !pFile->isJournal ); + SQLITE_KV_LOG(("xLock(%s,%d)\n", pFile->zClass, eLock)); + + if( eLock!=SQLITE_LOCK_NONE ){ + pFile->szDb = kvvfsReadFileSize(pFile); + } + return SQLITE_OK; +} + +/* +** Unlock an kvvfs-file. +*/ +static int kvvfsUnlock(sqlite3_file *pProtoFile, int eLock){ + KVVfsFile *pFile = (KVVfsFile *)pProtoFile; + assert( !pFile->isJournal ); + SQLITE_KV_LOG(("xUnlock(%s,%d)\n", pFile->zClass, eLock)); + if( eLock==SQLITE_LOCK_NONE ){ + pFile->szDb = -1; + } + return SQLITE_OK; +} + +/* +** Check if another file-handle holds a RESERVED lock on an kvvfs-file. +*/ +static int kvvfsCheckReservedLock(sqlite3_file *pProtoFile, int *pResOut){ + SQLITE_KV_LOG(("xCheckReservedLock\n")); + *pResOut = 0; + return SQLITE_OK; +} + +/* +** File control method. For custom operations on an kvvfs-file. +*/ +static int kvvfsFileControlJrnl(sqlite3_file *pProtoFile, int op, void *pArg){ + SQLITE_KV_LOG(("xFileControl(%d) on journal\n", op)); + return SQLITE_NOTFOUND; +} +static int kvvfsFileControlDb(sqlite3_file *pProtoFile, int op, void *pArg){ + SQLITE_KV_LOG(("xFileControl(%d) on database\n", op)); + if( op==SQLITE_FCNTL_SYNC ){ + KVVfsFile *pFile = (KVVfsFile *)pProtoFile; + int rc = SQLITE_OK; + SQLITE_KV_LOG(("xSync('%s-db')\n", pFile->zClass)); + if( pFile->szDb>0 && 0!=kvvfsWriteFileSize(pFile, pFile->szDb) ){ + rc = SQLITE_IOERR; + } + return rc; + } + return SQLITE_NOTFOUND; +} + +/* +** Return the sector-size in bytes for an kvvfs-file. +*/ +static int kvvfsSectorSize(sqlite3_file *pFile){ + return 512; +} + +/* +** Return the device characteristic flags supported by an kvvfs-file. +*/ +static int kvvfsDeviceCharacteristics(sqlite3_file *pProtoFile){ + return 0; +} + +/****** sqlite3_vfs methods *************************************************/ + +/* +** Open an kvvfs file handle. +*/ +static int kvvfsOpen( + sqlite3_vfs *pProtoVfs, + const char *zName, + sqlite3_file *pProtoFile, + int flags, + int *pOutFlags +){ + KVVfsFile *pFile = (KVVfsFile*)pProtoFile; + if( zName==0 ) zName = ""; + SQLITE_KV_LOG(("xOpen(\"%s\")\n", zName)); + if( strcmp(zName, "local")==0 + || strcmp(zName, "session")==0 + ){ + pFile->isJournal = 0; + pFile->base.pMethods = &kvvfs_db_io_methods; + }else + if( strcmp(zName, "local-journal")==0 + || strcmp(zName, "session-journal")==0 + ){ + pFile->isJournal = 1; + pFile->base.pMethods = &kvvfs_jrnl_io_methods; + }else{ + return SQLITE_CANTOPEN; + } + if( zName[0]=='s' ){ + pFile->zClass = "session"; + }else{ + pFile->zClass = "local"; + } + pFile->aData = sqlite3_malloc64(SQLITE_KVOS_SZ); + if( pFile->aData==0 ){ + return SQLITE_NOMEM; + } + pFile->aJrnl = 0; + pFile->nJrnl = 0; + pFile->szPage = -1; + pFile->szDb = -1; + return SQLITE_OK; +} + +/* +** Delete the file located at zPath. If the dirSync argument is true, +** ensure the file-system modifications are synced to disk before +** returning. +*/ +static int kvvfsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){ + if( strcmp(zPath, "local-journal")==0 ){ + sqlite3KvvfsMethods.xDelete("local", "jrnl"); + }else + if( strcmp(zPath, "session-journal")==0 ){ + sqlite3KvvfsMethods.xDelete("session", "jrnl"); + } + return SQLITE_OK; +} + +/* +** Test for access permissions. Return true if the requested permission +** is available, or false otherwise. +*/ +static int kvvfsAccess( + sqlite3_vfs *pProtoVfs, + const char *zPath, + int flags, + int *pResOut +){ + SQLITE_KV_LOG(("xAccess(\"%s\")\n", zPath)); + if( strcmp(zPath, "local-journal")==0 ){ + *pResOut = sqlite3KvvfsMethods.xRead("local", "jrnl", 0, 0)>0; + }else + if( strcmp(zPath, "session-journal")==0 ){ + *pResOut = sqlite3KvvfsMethods.xRead("session", "jrnl", 0, 0)>0; + }else + if( strcmp(zPath, "local")==0 ){ + *pResOut = sqlite3KvvfsMethods.xRead("local", "sz", 0, 0)>0; + }else + if( strcmp(zPath, "session")==0 ){ + *pResOut = sqlite3KvvfsMethods.xRead("session", "sz", 0, 0)>0; + }else + { + *pResOut = 0; + } + SQLITE_KV_LOG(("xAccess returns %d\n",*pResOut)); + return SQLITE_OK; +} + +/* +** Populate buffer zOut with the full canonical pathname corresponding +** to the pathname in zPath. zOut is guaranteed to point to a buffer +** of at least (INST_MAX_PATHNAME+1) bytes. +*/ +static int kvvfsFullPathname( + sqlite3_vfs *pVfs, + const char *zPath, + int nOut, + char *zOut +){ + size_t nPath; +#ifdef SQLITE_OS_KV_ALWAYS_LOCAL + zPath = "local"; +#endif + nPath = strlen(zPath); + SQLITE_KV_LOG(("xFullPathname(\"%s\")\n", zPath)); + if( nOut +static int kvvfsCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *pTimeOut){ + static const sqlite3_int64 unixEpoch = 24405875*(sqlite3_int64)8640000; + struct timeval sNow; + (void)gettimeofday(&sNow, 0); /* Cannot fail given valid arguments */ + *pTimeOut = unixEpoch + 1000*(sqlite3_int64)sNow.tv_sec + sNow.tv_usec/1000; + return SQLITE_OK; +} +#endif /* SQLITE_OS_KV || SQLITE_OS_UNIX */ + +#if SQLITE_OS_KV +/* +** This routine is called initialize the KV-vfs as the default VFS. +*/ +SQLITE_API int sqlite3_os_init(void){ + return sqlite3_vfs_register(&sqlite3OsKvvfsObject, 1); +} +SQLITE_API int sqlite3_os_end(void){ + return SQLITE_OK; +} +#endif /* SQLITE_OS_KV */ + +#if SQLITE_OS_UNIX && defined(SQLITE_OS_KV_OPTIONAL) +SQLITE_PRIVATE int sqlite3KvvfsInit(void){ + return sqlite3_vfs_register(&sqlite3OsKvvfsObject, 0); +} +#endif + +/************** End of os_kv.c ***********************************************/ +/************** Begin file os_unix.c *****************************************/ +/* +** 2004 May 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains the VFS implementation for unix-like operating systems +** include Linux, MacOSX, *BSD, QNX, VxWorks, AIX, HPUX, and others. +** +** There are actually several different VFS implementations in this file. +** The differences are in the way that file locking is done. The default +** implementation uses Posix Advisory Locks. Alternative implementations +** use flock(), dot-files, various proprietary locking schemas, or simply +** skip locking all together. +** +** This source file is organized into divisions where the logic for various +** subfunctions is contained within the appropriate division. PLEASE +** KEEP THE STRUCTURE OF THIS FILE INTACT. New code should be placed +** in the correct division and should be clearly labeled. +** +** The layout of divisions is as follows: +** +** * General-purpose declarations and utility functions. +** * Unique file ID logic used by VxWorks. +** * Various locking primitive implementations (all except proxy locking): +** + for Posix Advisory Locks +** + for no-op locks +** + for dot-file locks +** + for flock() locking +** + for named semaphore locks (VxWorks only) +** + for AFP filesystem locks (MacOSX only) +** * sqlite3_file methods not associated with locking. +** * Definitions of sqlite3_io_methods objects for all locking +** methods plus "finder" functions for each locking method. +** * sqlite3_vfs method implementations. +** * Locking primitives for the proxy uber-locking-method. (MacOSX only) +** * Definitions of sqlite3_vfs objects for all locking methods +** plus implementations of sqlite3_os_init() and sqlite3_os_end(). +*/ +/* #include "sqliteInt.h" */ +#if SQLITE_OS_UNIX /* This file is used on unix only */ + +/* +** There are various methods for file locking used for concurrency +** control: +** +** 1. POSIX locking (the default), +** 2. No locking, +** 3. Dot-file locking, +** 4. flock() locking, +** 5. AFP locking (OSX only), +** 6. Named POSIX semaphores (VXWorks only), +** 7. proxy locking. (OSX only) +** +** Styles 4, 5, and 7 are only available of SQLITE_ENABLE_LOCKING_STYLE +** is defined to 1. The SQLITE_ENABLE_LOCKING_STYLE also enables automatic +** selection of the appropriate locking style based on the filesystem +** where the database is located. +*/ +#if !defined(SQLITE_ENABLE_LOCKING_STYLE) +# if defined(__APPLE__) +# define SQLITE_ENABLE_LOCKING_STYLE 1 +# else +# define SQLITE_ENABLE_LOCKING_STYLE 0 +# endif +#endif + +/* Use pread() and pwrite() if they are available */ +#if defined(__APPLE__) || defined(__linux__) +# define HAVE_PREAD 1 +# define HAVE_PWRITE 1 +#endif +#if defined(HAVE_PREAD64) && defined(HAVE_PWRITE64) +# undef USE_PREAD +# define USE_PREAD64 1 +#elif defined(HAVE_PREAD) && defined(HAVE_PWRITE) +# undef USE_PREAD64 +# define USE_PREAD 1 +#endif + +/* +** standard include files. +*/ +#include /* amalgamator: keep */ +#include /* amalgamator: keep */ +#include +#include +#include /* amalgamator: keep */ +/* #include */ +#include /* amalgamator: keep */ +#include +#if (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) \ + && !defined(SQLITE_WASI) +# include +#endif + +#if SQLITE_ENABLE_LOCKING_STYLE +/* # include */ +# include +# include +#endif /* SQLITE_ENABLE_LOCKING_STYLE */ + +/* +** Try to determine if gethostuuid() is available based on standard +** macros. This might sometimes compute the wrong value for some +** obscure platforms. For those cases, simply compile with one of +** the following: +** +** -DHAVE_GETHOSTUUID=0 +** -DHAVE_GETHOSTUUID=1 +** +** None if this matters except when building on Apple products with +** -DSQLITE_ENABLE_LOCKING_STYLE. +*/ +#ifndef HAVE_GETHOSTUUID +# define HAVE_GETHOSTUUID 0 +# if defined(__APPLE__) && ((__MAC_OS_X_VERSION_MIN_REQUIRED > 1050) || \ + (__IPHONE_OS_VERSION_MIN_REQUIRED > 2000)) +# if (!defined(TARGET_OS_EMBEDDED) || (TARGET_OS_EMBEDDED==0)) \ + && (!defined(TARGET_IPHONE_SIMULATOR) || (TARGET_IPHONE_SIMULATOR==0))\ + && (!defined(TARGET_OS_MACCATALYST) || (TARGET_OS_MACCATALYST==0)) +# undef HAVE_GETHOSTUUID +# define HAVE_GETHOSTUUID 1 +# else +# warning "gethostuuid() is disabled." +# endif +# endif +#endif + + +#if OS_VXWORKS +/* # include */ +# include +# include +#endif /* OS_VXWORKS */ + +#if defined(__APPLE__) || SQLITE_ENABLE_LOCKING_STYLE +# include +#endif + +#ifdef HAVE_UTIME +# include +#endif + +/* +** Allowed values of unixFile.fsFlags +*/ +#define SQLITE_FSFLAGS_IS_MSDOS 0x1 + +/* +** If we are to be thread-safe, include the pthreads header. +*/ +#if SQLITE_THREADSAFE +/* # include */ +#endif + +/* +** Default permissions when creating a new file +*/ +#ifndef SQLITE_DEFAULT_FILE_PERMISSIONS +# define SQLITE_DEFAULT_FILE_PERMISSIONS 0644 +#endif + +/* +** Default permissions when creating auto proxy dir +*/ +#ifndef SQLITE_DEFAULT_PROXYDIR_PERMISSIONS +# define SQLITE_DEFAULT_PROXYDIR_PERMISSIONS 0755 +#endif + +/* +** Maximum supported path-length. +*/ +#define MAX_PATHNAME 512 + +/* +** Maximum supported symbolic links +*/ +#define SQLITE_MAX_SYMLINKS 100 + +/* +** Remove and stub certain info for WASI (WebAssembly System +** Interface) builds. +*/ +#ifdef SQLITE_WASI +# undef HAVE_FCHMOD +# undef HAVE_FCHOWN +# undef HAVE_MREMAP +# define HAVE_MREMAP 0 +# ifndef SQLITE_DEFAULT_UNIX_VFS +# define SQLITE_DEFAULT_UNIX_VFS "unix-dotfile" + /* ^^^ should SQLITE_DEFAULT_UNIX_VFS be "unix-none"? */ +# endif +# ifndef F_RDLCK +# define F_RDLCK 0 +# define F_WRLCK 1 +# define F_UNLCK 2 +# if __LONG_MAX == 0x7fffffffL +# define F_GETLK 12 +# define F_SETLK 13 +# define F_SETLKW 14 +# else +# define F_GETLK 5 +# define F_SETLK 6 +# define F_SETLKW 7 +# endif +# endif +#else /* !SQLITE_WASI */ +# ifndef HAVE_FCHMOD +# define HAVE_FCHMOD +# endif +#endif /* SQLITE_WASI */ + +#ifdef SQLITE_WASI +# define osGetpid(X) (pid_t)1 +#else +/* Always cast the getpid() return type for compatibility with +** kernel modules in VxWorks. */ +# define osGetpid(X) (pid_t)getpid() +#endif + +/* +** Only set the lastErrno if the error code is a real error and not +** a normal expected return code of SQLITE_BUSY or SQLITE_OK +*/ +#define IS_LOCK_ERROR(x) ((x != SQLITE_OK) && (x != SQLITE_BUSY)) + +/* Forward references */ +typedef struct unixShm unixShm; /* Connection shared memory */ +typedef struct unixShmNode unixShmNode; /* Shared memory instance */ +typedef struct unixInodeInfo unixInodeInfo; /* An i-node */ +typedef struct UnixUnusedFd UnixUnusedFd; /* An unused file descriptor */ + +/* +** Sometimes, after a file handle is closed by SQLite, the file descriptor +** cannot be closed immediately. In these cases, instances of the following +** structure are used to store the file descriptor while waiting for an +** opportunity to either close or reuse it. +*/ +struct UnixUnusedFd { + int fd; /* File descriptor to close */ + int flags; /* Flags this file descriptor was opened with */ + UnixUnusedFd *pNext; /* Next unused file descriptor on same file */ +}; + +/* +** The unixFile structure is subclass of sqlite3_file specific to the unix +** VFS implementations. +*/ +typedef struct unixFile unixFile; +struct unixFile { + sqlite3_io_methods const *pMethod; /* Always the first entry */ + sqlite3_vfs *pVfs; /* The VFS that created this unixFile */ + unixInodeInfo *pInode; /* Info about locks on this inode */ + int h; /* The file descriptor */ + unsigned char eFileLock; /* The type of lock held on this fd */ + unsigned short int ctrlFlags; /* Behavioral bits. UNIXFILE_* flags */ + int lastErrno; /* The unix errno from last I/O error */ + void *lockingContext; /* Locking style specific state */ + UnixUnusedFd *pPreallocatedUnused; /* Pre-allocated UnixUnusedFd */ + const char *zPath; /* Name of the file */ + unixShm *pShm; /* Shared memory segment information */ + int szChunk; /* Configured by FCNTL_CHUNK_SIZE */ +#if SQLITE_MAX_MMAP_SIZE>0 + int nFetchOut; /* Number of outstanding xFetch refs */ + sqlite3_int64 mmapSize; /* Usable size of mapping at pMapRegion */ + sqlite3_int64 mmapSizeActual; /* Actual size of mapping at pMapRegion */ + sqlite3_int64 mmapSizeMax; /* Configured FCNTL_MMAP_SIZE value */ + void *pMapRegion; /* Memory mapped region */ +#endif + int sectorSize; /* Device sector size */ + int deviceCharacteristics; /* Precomputed device characteristics */ +#if SQLITE_ENABLE_LOCKING_STYLE + int openFlags; /* The flags specified at open() */ +#endif +#if SQLITE_ENABLE_LOCKING_STYLE || defined(__APPLE__) + unsigned fsFlags; /* cached details from statfs() */ +#endif +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT + unsigned iBusyTimeout; /* Wait this many millisec on locks */ +#endif +#if OS_VXWORKS + struct vxworksFileId *pId; /* Unique file ID */ +#endif +#ifdef SQLITE_DEBUG + /* The next group of variables are used to track whether or not the + ** transaction counter in bytes 24-27 of database files are updated + ** whenever any part of the database changes. An assertion fault will + ** occur if a file is updated without also updating the transaction + ** counter. This test is made to avoid new problems similar to the + ** one described by ticket #3584. + */ + unsigned char transCntrChng; /* True if the transaction counter changed */ + unsigned char dbUpdate; /* True if any part of database file changed */ + unsigned char inNormalWrite; /* True if in a normal write operation */ + +#endif + +#ifdef SQLITE_TEST + /* In test mode, increase the size of this structure a bit so that + ** it is larger than the struct CrashFile defined in test6.c. + */ + char aPadding[32]; +#endif +}; + +/* This variable holds the process id (pid) from when the xRandomness() +** method was called. If xOpen() is called from a different process id, +** indicating that a fork() has occurred, the PRNG will be reset. +*/ +static pid_t randomnessPid = 0; + +/* +** Allowed values for the unixFile.ctrlFlags bitmask: +*/ +#define UNIXFILE_EXCL 0x01 /* Connections from one process only */ +#define UNIXFILE_RDONLY 0x02 /* Connection is read only */ +#define UNIXFILE_PERSIST_WAL 0x04 /* Persistent WAL mode */ +#ifndef SQLITE_DISABLE_DIRSYNC +# define UNIXFILE_DIRSYNC 0x08 /* Directory sync needed */ +#else +# define UNIXFILE_DIRSYNC 0x00 +#endif +#define UNIXFILE_PSOW 0x10 /* SQLITE_IOCAP_POWERSAFE_OVERWRITE */ +#define UNIXFILE_DELETE 0x20 /* Delete on close */ +#define UNIXFILE_URI 0x40 /* Filename might have query parameters */ +#define UNIXFILE_NOLOCK 0x80 /* Do no file locking */ + +/* +** Include code that is common to all os_*.c files +*/ +/* #include "os_common.h" */ + +/* +** Define various macros that are missing from some systems. +*/ +#ifndef O_LARGEFILE +# define O_LARGEFILE 0 +#endif +#ifdef SQLITE_DISABLE_LFS +# undef O_LARGEFILE +# define O_LARGEFILE 0 +#endif +#ifndef O_NOFOLLOW +# define O_NOFOLLOW 0 +#endif +#ifndef O_BINARY +# define O_BINARY 0 +#endif + +/* +** The threadid macro resolves to the thread-id or to 0. Used for +** testing and debugging only. +*/ +#if SQLITE_THREADSAFE +#define threadid pthread_self() +#else +#define threadid 0 +#endif + +/* +** HAVE_MREMAP defaults to true on Linux and false everywhere else. +*/ +#if !defined(HAVE_MREMAP) +# if defined(__linux__) && defined(_GNU_SOURCE) +# define HAVE_MREMAP 1 +# else +# define HAVE_MREMAP 0 +# endif +#endif + +/* +** Explicitly call the 64-bit version of lseek() on Android. Otherwise, lseek() +** is the 32-bit version, even if _FILE_OFFSET_BITS=64 is defined. +*/ +#ifdef __ANDROID__ +# define lseek lseek64 +#endif + +#ifdef __linux__ +/* +** Linux-specific IOCTL magic numbers used for controlling F2FS +*/ +#define F2FS_IOCTL_MAGIC 0xf5 +#define F2FS_IOC_START_ATOMIC_WRITE _IO(F2FS_IOCTL_MAGIC, 1) +#define F2FS_IOC_COMMIT_ATOMIC_WRITE _IO(F2FS_IOCTL_MAGIC, 2) +#define F2FS_IOC_START_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 3) +#define F2FS_IOC_ABORT_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 5) +#define F2FS_IOC_GET_FEATURES _IOR(F2FS_IOCTL_MAGIC, 12, u32) +#define F2FS_FEATURE_ATOMIC_WRITE 0x0004 +#endif /* __linux__ */ + + +/* +** Different Unix systems declare open() in different ways. Same use +** open(const char*,int,mode_t). Others use open(const char*,int,...). +** The difference is important when using a pointer to the function. +** +** The safest way to deal with the problem is to always use this wrapper +** which always has the same well-defined interface. +*/ +static int posixOpen(const char *zFile, int flags, int mode){ + return open(zFile, flags, mode); +} + +/* Forward reference */ +static int openDirectory(const char*, int*); +static int unixGetpagesize(void); + +/* +** Many system calls are accessed through pointer-to-functions so that +** they may be overridden at runtime to facilitate fault injection during +** testing and sandboxing. The following array holds the names and pointers +** to all overrideable system calls. +*/ +static struct unix_syscall { + const char *zName; /* Name of the system call */ + sqlite3_syscall_ptr pCurrent; /* Current value of the system call */ + sqlite3_syscall_ptr pDefault; /* Default value */ +} aSyscall[] = { + { "open", (sqlite3_syscall_ptr)posixOpen, 0 }, +#define osOpen ((int(*)(const char*,int,int))aSyscall[0].pCurrent) + + { "close", (sqlite3_syscall_ptr)close, 0 }, +#define osClose ((int(*)(int))aSyscall[1].pCurrent) + + { "access", (sqlite3_syscall_ptr)access, 0 }, +#define osAccess ((int(*)(const char*,int))aSyscall[2].pCurrent) + + { "getcwd", (sqlite3_syscall_ptr)getcwd, 0 }, +#define osGetcwd ((char*(*)(char*,size_t))aSyscall[3].pCurrent) + + { "stat", (sqlite3_syscall_ptr)stat, 0 }, +#define osStat ((int(*)(const char*,struct stat*))aSyscall[4].pCurrent) + +/* +** The DJGPP compiler environment looks mostly like Unix, but it +** lacks the fcntl() system call. So redefine fcntl() to be something +** that always succeeds. This means that locking does not occur under +** DJGPP. But it is DOS - what did you expect? +*/ +#ifdef __DJGPP__ + { "fstat", 0, 0 }, +#define osFstat(a,b,c) 0 +#else + { "fstat", (sqlite3_syscall_ptr)fstat, 0 }, +#define osFstat ((int(*)(int,struct stat*))aSyscall[5].pCurrent) +#endif + + { "ftruncate", (sqlite3_syscall_ptr)ftruncate, 0 }, +#define osFtruncate ((int(*)(int,off_t))aSyscall[6].pCurrent) + + { "fcntl", (sqlite3_syscall_ptr)fcntl, 0 }, +#define osFcntl ((int(*)(int,int,...))aSyscall[7].pCurrent) + + { "read", (sqlite3_syscall_ptr)read, 0 }, +#define osRead ((ssize_t(*)(int,void*,size_t))aSyscall[8].pCurrent) + +#if defined(USE_PREAD) || SQLITE_ENABLE_LOCKING_STYLE + { "pread", (sqlite3_syscall_ptr)pread, 0 }, +#else + { "pread", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osPread ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[9].pCurrent) + +#if defined(USE_PREAD64) + { "pread64", (sqlite3_syscall_ptr)pread64, 0 }, +#else + { "pread64", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osPread64 ((ssize_t(*)(int,void*,size_t,off64_t))aSyscall[10].pCurrent) + + { "write", (sqlite3_syscall_ptr)write, 0 }, +#define osWrite ((ssize_t(*)(int,const void*,size_t))aSyscall[11].pCurrent) + +#if defined(USE_PREAD) || SQLITE_ENABLE_LOCKING_STYLE + { "pwrite", (sqlite3_syscall_ptr)pwrite, 0 }, +#else + { "pwrite", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osPwrite ((ssize_t(*)(int,const void*,size_t,off_t))\ + aSyscall[12].pCurrent) + +#if defined(USE_PREAD64) + { "pwrite64", (sqlite3_syscall_ptr)pwrite64, 0 }, +#else + { "pwrite64", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osPwrite64 ((ssize_t(*)(int,const void*,size_t,off64_t))\ + aSyscall[13].pCurrent) + +#if defined(HAVE_FCHMOD) + { "fchmod", (sqlite3_syscall_ptr)fchmod, 0 }, +#else + { "fchmod", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osFchmod ((int(*)(int,mode_t))aSyscall[14].pCurrent) + +#if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE + { "fallocate", (sqlite3_syscall_ptr)posix_fallocate, 0 }, +#else + { "fallocate", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osFallocate ((int(*)(int,off_t,off_t))aSyscall[15].pCurrent) + + { "unlink", (sqlite3_syscall_ptr)unlink, 0 }, +#define osUnlink ((int(*)(const char*))aSyscall[16].pCurrent) + + { "openDirectory", (sqlite3_syscall_ptr)openDirectory, 0 }, +#define osOpenDirectory ((int(*)(const char*,int*))aSyscall[17].pCurrent) + + { "mkdir", (sqlite3_syscall_ptr)mkdir, 0 }, +#define osMkdir ((int(*)(const char*,mode_t))aSyscall[18].pCurrent) + + { "rmdir", (sqlite3_syscall_ptr)rmdir, 0 }, +#define osRmdir ((int(*)(const char*))aSyscall[19].pCurrent) + +#if defined(HAVE_FCHOWN) + { "fchown", (sqlite3_syscall_ptr)fchown, 0 }, +#else + { "fchown", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osFchown ((int(*)(int,uid_t,gid_t))aSyscall[20].pCurrent) + +#if defined(HAVE_FCHOWN) + { "geteuid", (sqlite3_syscall_ptr)geteuid, 0 }, +#else + { "geteuid", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osGeteuid ((uid_t(*)(void))aSyscall[21].pCurrent) + +#if (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) \ + && !defined(SQLITE_WASI) + { "mmap", (sqlite3_syscall_ptr)mmap, 0 }, +#else + { "mmap", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osMmap ((void*(*)(void*,size_t,int,int,int,off_t))aSyscall[22].pCurrent) + +#if (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) \ + && !defined(SQLITE_WASI) + { "munmap", (sqlite3_syscall_ptr)munmap, 0 }, +#else + { "munmap", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osMunmap ((int(*)(void*,size_t))aSyscall[23].pCurrent) + +#if HAVE_MREMAP && (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) + { "mremap", (sqlite3_syscall_ptr)mremap, 0 }, +#else + { "mremap", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osMremap ((void*(*)(void*,size_t,size_t,int,...))aSyscall[24].pCurrent) + +#if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0 + { "getpagesize", (sqlite3_syscall_ptr)unixGetpagesize, 0 }, +#else + { "getpagesize", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osGetpagesize ((int(*)(void))aSyscall[25].pCurrent) + +#if defined(HAVE_READLINK) + { "readlink", (sqlite3_syscall_ptr)readlink, 0 }, +#else + { "readlink", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osReadlink ((ssize_t(*)(const char*,char*,size_t))aSyscall[26].pCurrent) + +#if defined(HAVE_LSTAT) + { "lstat", (sqlite3_syscall_ptr)lstat, 0 }, +#else + { "lstat", (sqlite3_syscall_ptr)0, 0 }, +#endif +#define osLstat ((int(*)(const char*,struct stat*))aSyscall[27].pCurrent) + +#if defined(__linux__) && defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE) +# ifdef __ANDROID__ + { "ioctl", (sqlite3_syscall_ptr)(int(*)(int, int, ...))ioctl, 0 }, +#define osIoctl ((int(*)(int,int,...))aSyscall[28].pCurrent) +# else + { "ioctl", (sqlite3_syscall_ptr)ioctl, 0 }, +#define osIoctl ((int(*)(int,unsigned long,...))aSyscall[28].pCurrent) +# endif +#else + { "ioctl", (sqlite3_syscall_ptr)0, 0 }, +#endif + +}; /* End of the overrideable system calls */ + + +/* +** On some systems, calls to fchown() will trigger a message in a security +** log if they come from non-root processes. So avoid calling fchown() if +** we are not running as root. +*/ +static int robustFchown(int fd, uid_t uid, gid_t gid){ +#if defined(HAVE_FCHOWN) + return osGeteuid() ? 0 : osFchown(fd,uid,gid); +#else + return 0; +#endif +} + +/* +** This is the xSetSystemCall() method of sqlite3_vfs for all of the +** "unix" VFSes. Return SQLITE_OK opon successfully updating the +** system call pointer, or SQLITE_NOTFOUND if there is no configurable +** system call named zName. +*/ +static int unixSetSystemCall( + sqlite3_vfs *pNotUsed, /* The VFS pointer. Not used */ + const char *zName, /* Name of system call to override */ + sqlite3_syscall_ptr pNewFunc /* Pointer to new system call value */ +){ + unsigned int i; + int rc = SQLITE_NOTFOUND; + + UNUSED_PARAMETER(pNotUsed); + if( zName==0 ){ + /* If no zName is given, restore all system calls to their default + ** settings and return NULL + */ + rc = SQLITE_OK; + for(i=0; i=SQLITE_MINIMUM_FILE_DESCRIPTOR ) break; + if( (f & (O_EXCL|O_CREAT))==(O_EXCL|O_CREAT) ){ + (void)osUnlink(z); + } + osClose(fd); + sqlite3_log(SQLITE_WARNING, + "attempt to open \"%s\" as file descriptor %d", z, fd); + fd = -1; + if( osOpen("/dev/null", O_RDONLY, m)<0 ) break; + } + if( fd>=0 ){ + if( m!=0 ){ + struct stat statbuf; + if( osFstat(fd, &statbuf)==0 + && statbuf.st_size==0 + && (statbuf.st_mode&0777)!=m + ){ + osFchmod(fd, m); + } + } +#if defined(FD_CLOEXEC) && (!defined(O_CLOEXEC) || O_CLOEXEC==0) + osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC); +#endif + } + return fd; +} + +/* +** Helper functions to obtain and relinquish the global mutex. The +** global mutex is used to protect the unixInodeInfo and +** vxworksFileId objects used by this file, all of which may be +** shared by multiple threads. +** +** Function unixMutexHeld() is used to assert() that the global mutex +** is held when required. This function is only used as part of assert() +** statements. e.g. +** +** unixEnterMutex() +** assert( unixMutexHeld() ); +** unixEnterLeave() +** +** To prevent deadlock, the global unixBigLock must must be acquired +** before the unixInodeInfo.pLockMutex mutex, if both are held. It is +** OK to get the pLockMutex without holding unixBigLock first, but if +** that happens, the unixBigLock mutex must not be acquired until after +** pLockMutex is released. +** +** OK: enter(unixBigLock), enter(pLockInfo) +** OK: enter(unixBigLock) +** OK: enter(pLockInfo) +** ERROR: enter(pLockInfo), enter(unixBigLock) +*/ +static sqlite3_mutex *unixBigLock = 0; +static void unixEnterMutex(void){ + assert( sqlite3_mutex_notheld(unixBigLock) ); /* Not a recursive mutex */ + sqlite3_mutex_enter(unixBigLock); +} +static void unixLeaveMutex(void){ + assert( sqlite3_mutex_held(unixBigLock) ); + sqlite3_mutex_leave(unixBigLock); +} +#ifdef SQLITE_DEBUG +static int unixMutexHeld(void) { + return sqlite3_mutex_held(unixBigLock); +} +#endif + + +#ifdef SQLITE_HAVE_OS_TRACE +/* +** Helper function for printing out trace information from debugging +** binaries. This returns the string representation of the supplied +** integer lock-type. +*/ +static const char *azFileLock(int eFileLock){ + switch( eFileLock ){ + case NO_LOCK: return "NONE"; + case SHARED_LOCK: return "SHARED"; + case RESERVED_LOCK: return "RESERVED"; + case PENDING_LOCK: return "PENDING"; + case EXCLUSIVE_LOCK: return "EXCLUSIVE"; + } + return "ERROR"; +} +#endif + +#ifdef SQLITE_LOCK_TRACE +/* +** Print out information about all locking operations. +** +** This routine is used for troubleshooting locks on multithreaded +** platforms. Enable by compiling with the -DSQLITE_LOCK_TRACE +** command-line option on the compiler. This code is normally +** turned off. +*/ +static int lockTrace(int fd, int op, struct flock *p){ + char *zOpName, *zType; + int s; + int savedErrno; + if( op==F_GETLK ){ + zOpName = "GETLK"; + }else if( op==F_SETLK ){ + zOpName = "SETLK"; + }else{ + s = osFcntl(fd, op, p); + sqlite3DebugPrintf("fcntl unknown %d %d %d\n", fd, op, s); + return s; + } + if( p->l_type==F_RDLCK ){ + zType = "RDLCK"; + }else if( p->l_type==F_WRLCK ){ + zType = "WRLCK"; + }else if( p->l_type==F_UNLCK ){ + zType = "UNLCK"; + }else{ + assert( 0 ); + } + assert( p->l_whence==SEEK_SET ); + s = osFcntl(fd, op, p); + savedErrno = errno; + sqlite3DebugPrintf("fcntl %d %d %s %s %d %d %d %d\n", + threadid, fd, zOpName, zType, (int)p->l_start, (int)p->l_len, + (int)p->l_pid, s); + if( s==(-1) && op==F_SETLK && (p->l_type==F_RDLCK || p->l_type==F_WRLCK) ){ + struct flock l2; + l2 = *p; + osFcntl(fd, F_GETLK, &l2); + if( l2.l_type==F_RDLCK ){ + zType = "RDLCK"; + }else if( l2.l_type==F_WRLCK ){ + zType = "WRLCK"; + }else if( l2.l_type==F_UNLCK ){ + zType = "UNLCK"; + }else{ + assert( 0 ); + } + sqlite3DebugPrintf("fcntl-failure-reason: %s %d %d %d\n", + zType, (int)l2.l_start, (int)l2.l_len, (int)l2.l_pid); + } + errno = savedErrno; + return s; +} +#undef osFcntl +#define osFcntl lockTrace +#endif /* SQLITE_LOCK_TRACE */ + +/* +** Retry ftruncate() calls that fail due to EINTR +** +** All calls to ftruncate() within this file should be made through +** this wrapper. On the Android platform, bypassing the logic below +** could lead to a corrupt database. +*/ +static int robust_ftruncate(int h, sqlite3_int64 sz){ + int rc; +#ifdef __ANDROID__ + /* On Android, ftruncate() always uses 32-bit offsets, even if + ** _FILE_OFFSET_BITS=64 is defined. This means it is unsafe to attempt to + ** truncate a file to any size larger than 2GiB. Silently ignore any + ** such attempts. */ + if( sz>(sqlite3_int64)0x7FFFFFFF ){ + rc = SQLITE_OK; + }else +#endif + do{ rc = osFtruncate(h,sz); }while( rc<0 && errno==EINTR ); + return rc; +} + +/* +** This routine translates a standard POSIX errno code into something +** useful to the clients of the sqlite3 functions. Specifically, it is +** intended to translate a variety of "try again" errors into SQLITE_BUSY +** and a variety of "please close the file descriptor NOW" errors into +** SQLITE_IOERR +** +** Errors during initialization of locks, or file system support for locks, +** should handle ENOLCK, ENOTSUP, EOPNOTSUPP separately. +*/ +static int sqliteErrorFromPosixError(int posixError, int sqliteIOErr) { + assert( (sqliteIOErr == SQLITE_IOERR_LOCK) || + (sqliteIOErr == SQLITE_IOERR_UNLOCK) || + (sqliteIOErr == SQLITE_IOERR_RDLOCK) || + (sqliteIOErr == SQLITE_IOERR_CHECKRESERVEDLOCK) ); + switch (posixError) { + case EACCES: + case EAGAIN: + case ETIMEDOUT: + case EBUSY: + case EINTR: + case ENOLCK: + /* random NFS retry error, unless during file system support + * introspection, in which it actually means what it says */ + return SQLITE_BUSY; + + case EPERM: + return SQLITE_PERM; + + default: + return sqliteIOErr; + } +} + + +/****************************************************************************** +****************** Begin Unique File ID Utility Used By VxWorks *************** +** +** On most versions of unix, we can get a unique ID for a file by concatenating +** the device number and the inode number. But this does not work on VxWorks. +** On VxWorks, a unique file id must be based on the canonical filename. +** +** A pointer to an instance of the following structure can be used as a +** unique file ID in VxWorks. Each instance of this structure contains +** a copy of the canonical filename. There is also a reference count. +** The structure is reclaimed when the number of pointers to it drops to +** zero. +** +** There are never very many files open at one time and lookups are not +** a performance-critical path, so it is sufficient to put these +** structures on a linked list. +*/ +struct vxworksFileId { + struct vxworksFileId *pNext; /* Next in a list of them all */ + int nRef; /* Number of references to this one */ + int nName; /* Length of the zCanonicalName[] string */ + char *zCanonicalName; /* Canonical filename */ +}; + +#if OS_VXWORKS +/* +** All unique filenames are held on a linked list headed by this +** variable: +*/ +static struct vxworksFileId *vxworksFileList = 0; + +/* +** Simplify a filename into its canonical form +** by making the following changes: +** +** * removing any trailing and duplicate / +** * convert /./ into just / +** * convert /A/../ where A is any simple name into just / +** +** Changes are made in-place. Return the new name length. +** +** The original filename is in z[0..n-1]. Return the number of +** characters in the simplified name. +*/ +static int vxworksSimplifyName(char *z, int n){ + int i, j; + while( n>1 && z[n-1]=='/' ){ n--; } + for(i=j=0; i0 && z[j-1]!='/' ){ j--; } + if( j>0 ){ j--; } + i += 2; + continue; + } + } + z[j++] = z[i]; + } + z[j] = 0; + return j; +} + +/* +** Find a unique file ID for the given absolute pathname. Return +** a pointer to the vxworksFileId object. This pointer is the unique +** file ID. +** +** The nRef field of the vxworksFileId object is incremented before +** the object is returned. A new vxworksFileId object is created +** and added to the global list if necessary. +** +** If a memory allocation error occurs, return NULL. +*/ +static struct vxworksFileId *vxworksFindFileId(const char *zAbsoluteName){ + struct vxworksFileId *pNew; /* search key and new file ID */ + struct vxworksFileId *pCandidate; /* For looping over existing file IDs */ + int n; /* Length of zAbsoluteName string */ + + assert( zAbsoluteName[0]=='/' ); + n = (int)strlen(zAbsoluteName); + pNew = sqlite3_malloc64( sizeof(*pNew) + (n+1) ); + if( pNew==0 ) return 0; + pNew->zCanonicalName = (char*)&pNew[1]; + memcpy(pNew->zCanonicalName, zAbsoluteName, n+1); + n = vxworksSimplifyName(pNew->zCanonicalName, n); + + /* Search for an existing entry that matching the canonical name. + ** If found, increment the reference count and return a pointer to + ** the existing file ID. + */ + unixEnterMutex(); + for(pCandidate=vxworksFileList; pCandidate; pCandidate=pCandidate->pNext){ + if( pCandidate->nName==n + && memcmp(pCandidate->zCanonicalName, pNew->zCanonicalName, n)==0 + ){ + sqlite3_free(pNew); + pCandidate->nRef++; + unixLeaveMutex(); + return pCandidate; + } + } + + /* No match was found. We will make a new file ID */ + pNew->nRef = 1; + pNew->nName = n; + pNew->pNext = vxworksFileList; + vxworksFileList = pNew; + unixLeaveMutex(); + return pNew; +} + +/* +** Decrement the reference count on a vxworksFileId object. Free +** the object when the reference count reaches zero. +*/ +static void vxworksReleaseFileId(struct vxworksFileId *pId){ + unixEnterMutex(); + assert( pId->nRef>0 ); + pId->nRef--; + if( pId->nRef==0 ){ + struct vxworksFileId **pp; + for(pp=&vxworksFileList; *pp && *pp!=pId; pp = &((*pp)->pNext)){} + assert( *pp==pId ); + *pp = pId->pNext; + sqlite3_free(pId); + } + unixLeaveMutex(); +} +#endif /* OS_VXWORKS */ +/*************** End of Unique File ID Utility Used By VxWorks **************** +******************************************************************************/ + + +/****************************************************************************** +*************************** Posix Advisory Locking **************************** +** +** POSIX advisory locks are broken by design. ANSI STD 1003.1 (1996) +** section 6.5.2.2 lines 483 through 490 specify that when a process +** sets or clears a lock, that operation overrides any prior locks set +** by the same process. It does not explicitly say so, but this implies +** that it overrides locks set by the same process using a different +** file descriptor. Consider this test case: +** +** int fd1 = open("./file1", O_RDWR|O_CREAT, 0644); +** int fd2 = open("./file2", O_RDWR|O_CREAT, 0644); +** +** Suppose ./file1 and ./file2 are really the same file (because +** one is a hard or symbolic link to the other) then if you set +** an exclusive lock on fd1, then try to get an exclusive lock +** on fd2, it works. I would have expected the second lock to +** fail since there was already a lock on the file due to fd1. +** But not so. Since both locks came from the same process, the +** second overrides the first, even though they were on different +** file descriptors opened on different file names. +** +** This means that we cannot use POSIX locks to synchronize file access +** among competing threads of the same process. POSIX locks will work fine +** to synchronize access for threads in separate processes, but not +** threads within the same process. +** +** To work around the problem, SQLite has to manage file locks internally +** on its own. Whenever a new database is opened, we have to find the +** specific inode of the database file (the inode is determined by the +** st_dev and st_ino fields of the stat structure that fstat() fills in) +** and check for locks already existing on that inode. When locks are +** created or removed, we have to look at our own internal record of the +** locks to see if another thread has previously set a lock on that same +** inode. +** +** (Aside: The use of inode numbers as unique IDs does not work on VxWorks. +** For VxWorks, we have to use the alternative unique ID system based on +** canonical filename and implemented in the previous division.) +** +** The sqlite3_file structure for POSIX is no longer just an integer file +** descriptor. It is now a structure that holds the integer file +** descriptor and a pointer to a structure that describes the internal +** locks on the corresponding inode. There is one locking structure +** per inode, so if the same inode is opened twice, both unixFile structures +** point to the same locking structure. The locking structure keeps +** a reference count (so we will know when to delete it) and a "cnt" +** field that tells us its internal lock status. cnt==0 means the +** file is unlocked. cnt==-1 means the file has an exclusive lock. +** cnt>0 means there are cnt shared locks on the file. +** +** Any attempt to lock or unlock a file first checks the locking +** structure. The fcntl() system call is only invoked to set a +** POSIX lock if the internal lock structure transitions between +** a locked and an unlocked state. +** +** But wait: there are yet more problems with POSIX advisory locks. +** +** If you close a file descriptor that points to a file that has locks, +** all locks on that file that are owned by the current process are +** released. To work around this problem, each unixInodeInfo object +** maintains a count of the number of pending locks on tha inode. +** When an attempt is made to close an unixFile, if there are +** other unixFile open on the same inode that are holding locks, the call +** to close() the file descriptor is deferred until all of the locks clear. +** The unixInodeInfo structure keeps a list of file descriptors that need to +** be closed and that list is walked (and cleared) when the last lock +** clears. +** +** Yet another problem: LinuxThreads do not play well with posix locks. +** +** Many older versions of linux use the LinuxThreads library which is +** not posix compliant. Under LinuxThreads, a lock created by thread +** A cannot be modified or overridden by a different thread B. +** Only thread A can modify the lock. Locking behavior is correct +** if the appliation uses the newer Native Posix Thread Library (NPTL) +** on linux - with NPTL a lock created by thread A can override locks +** in thread B. But there is no way to know at compile-time which +** threading library is being used. So there is no way to know at +** compile-time whether or not thread A can override locks on thread B. +** One has to do a run-time check to discover the behavior of the +** current process. +** +** SQLite used to support LinuxThreads. But support for LinuxThreads +** was dropped beginning with version 3.7.0. SQLite will still work with +** LinuxThreads provided that (1) there is no more than one connection +** per database file in the same process and (2) database connections +** do not move across threads. +*/ + +/* +** An instance of the following structure serves as the key used +** to locate a particular unixInodeInfo object. +*/ +struct unixFileId { + dev_t dev; /* Device number */ +#if OS_VXWORKS + struct vxworksFileId *pId; /* Unique file ID for vxworks. */ +#else + /* We are told that some versions of Android contain a bug that + ** sizes ino_t at only 32-bits instead of 64-bits. (See + ** https://android-review.googlesource.com/#/c/115351/3/dist/sqlite3.c) + ** To work around this, always allocate 64-bits for the inode number. + ** On small machines that only have 32-bit inodes, this wastes 4 bytes, + ** but that should not be a big deal. */ + /* WAS: ino_t ino; */ + u64 ino; /* Inode number */ +#endif +}; + +/* +** An instance of the following structure is allocated for each open +** inode. +** +** A single inode can have multiple file descriptors, so each unixFile +** structure contains a pointer to an instance of this object and this +** object keeps a count of the number of unixFile pointing to it. +** +** Mutex rules: +** +** (1) Only the pLockMutex mutex must be held in order to read or write +** any of the locking fields: +** nShared, nLock, eFileLock, bProcessLock, pUnused +** +** (2) When nRef>0, then the following fields are unchanging and can +** be read (but not written) without holding any mutex: +** fileId, pLockMutex +** +** (3) With the exceptions above, all the fields may only be read +** or written while holding the global unixBigLock mutex. +** +** Deadlock prevention: The global unixBigLock mutex may not +** be acquired while holding the pLockMutex mutex. If both unixBigLock +** and pLockMutex are needed, then unixBigLock must be acquired first. +*/ +struct unixInodeInfo { + struct unixFileId fileId; /* The lookup key */ + sqlite3_mutex *pLockMutex; /* Hold this mutex for... */ + int nShared; /* Number of SHARED locks held */ + int nLock; /* Number of outstanding file locks */ + unsigned char eFileLock; /* One of SHARED_LOCK, RESERVED_LOCK etc. */ + unsigned char bProcessLock; /* An exclusive process lock is held */ + UnixUnusedFd *pUnused; /* Unused file descriptors to close */ + int nRef; /* Number of pointers to this structure */ + unixShmNode *pShmNode; /* Shared memory associated with this inode */ + unixInodeInfo *pNext; /* List of all unixInodeInfo objects */ + unixInodeInfo *pPrev; /* .... doubly linked */ +#if SQLITE_ENABLE_LOCKING_STYLE + unsigned long long sharedByte; /* for AFP simulated shared lock */ +#endif +#if OS_VXWORKS + sem_t *pSem; /* Named POSIX semaphore */ + char aSemName[MAX_PATHNAME+2]; /* Name of that semaphore */ +#endif +}; + +/* +** A lists of all unixInodeInfo objects. +** +** Must hold unixBigLock in order to read or write this variable. +*/ +static unixInodeInfo *inodeList = 0; /* All unixInodeInfo objects */ + +#ifdef SQLITE_DEBUG +/* +** True if the inode mutex (on the unixFile.pFileMutex field) is held, or not. +** This routine is used only within assert() to help verify correct mutex +** usage. +*/ +int unixFileMutexHeld(unixFile *pFile){ + assert( pFile->pInode ); + return sqlite3_mutex_held(pFile->pInode->pLockMutex); +} +int unixFileMutexNotheld(unixFile *pFile){ + assert( pFile->pInode ); + return sqlite3_mutex_notheld(pFile->pInode->pLockMutex); +} +#endif + +/* +** +** This function - unixLogErrorAtLine(), is only ever called via the macro +** unixLogError(). +** +** It is invoked after an error occurs in an OS function and errno has been +** set. It logs a message using sqlite3_log() containing the current value of +** errno and, if possible, the human-readable equivalent from strerror() or +** strerror_r(). +** +** The first argument passed to the macro should be the error code that +** will be returned to SQLite (e.g. SQLITE_IOERR_DELETE, SQLITE_CANTOPEN). +** The two subsequent arguments should be the name of the OS function that +** failed (e.g. "unlink", "open") and the associated file-system path, +** if any. +*/ +#define unixLogError(a,b,c) unixLogErrorAtLine(a,b,c,__LINE__) +static int unixLogErrorAtLine( + int errcode, /* SQLite error code */ + const char *zFunc, /* Name of OS function that failed */ + const char *zPath, /* File path associated with error */ + int iLine /* Source line number where error occurred */ +){ + char *zErr; /* Message from strerror() or equivalent */ + int iErrno = errno; /* Saved syscall error number */ + + /* If this is not a threadsafe build (SQLITE_THREADSAFE==0), then use + ** the strerror() function to obtain the human-readable error message + ** equivalent to errno. Otherwise, use strerror_r(). + */ +#if SQLITE_THREADSAFE && defined(HAVE_STRERROR_R) + char aErr[80]; + memset(aErr, 0, sizeof(aErr)); + zErr = aErr; + + /* If STRERROR_R_CHAR_P (set by autoconf scripts) or __USE_GNU is defined, + ** assume that the system provides the GNU version of strerror_r() that + ** returns a pointer to a buffer containing the error message. That pointer + ** may point to aErr[], or it may point to some static storage somewhere. + ** Otherwise, assume that the system provides the POSIX version of + ** strerror_r(), which always writes an error message into aErr[]. + ** + ** If the code incorrectly assumes that it is the POSIX version that is + ** available, the error message will often be an empty string. Not a + ** huge problem. Incorrectly concluding that the GNU version is available + ** could lead to a segfault though. + */ +#if defined(STRERROR_R_CHAR_P) || defined(__USE_GNU) + zErr = +# endif + strerror_r(iErrno, aErr, sizeof(aErr)-1); + +#elif SQLITE_THREADSAFE + /* This is a threadsafe build, but strerror_r() is not available. */ + zErr = ""; +#else + /* Non-threadsafe build, use strerror(). */ + zErr = strerror(iErrno); +#endif + + if( zPath==0 ) zPath = ""; + sqlite3_log(errcode, + "os_unix.c:%d: (%d) %s(%s) - %s", + iLine, iErrno, zFunc, zPath, zErr + ); + + return errcode; +} + +/* +** Close a file descriptor. +** +** We assume that close() almost always works, since it is only in a +** very sick application or on a very sick platform that it might fail. +** If it does fail, simply leak the file descriptor, but do log the +** error. +** +** Note that it is not safe to retry close() after EINTR since the +** file descriptor might have already been reused by another thread. +** So we don't even try to recover from an EINTR. Just log the error +** and move on. +*/ +static void robust_close(unixFile *pFile, int h, int lineno){ + if( osClose(h) ){ + unixLogErrorAtLine(SQLITE_IOERR_CLOSE, "close", + pFile ? pFile->zPath : 0, lineno); + } +} + +/* +** Set the pFile->lastErrno. Do this in a subroutine as that provides +** a convenient place to set a breakpoint. +*/ +static void storeLastErrno(unixFile *pFile, int error){ + pFile->lastErrno = error; +} + +/* +** Close all file descriptors accumuated in the unixInodeInfo->pUnused list. +*/ +static void closePendingFds(unixFile *pFile){ + unixInodeInfo *pInode = pFile->pInode; + UnixUnusedFd *p; + UnixUnusedFd *pNext; + assert( unixFileMutexHeld(pFile) ); + for(p=pInode->pUnused; p; p=pNext){ + pNext = p->pNext; + robust_close(pFile, p->fd, __LINE__); + sqlite3_free(p); + } + pInode->pUnused = 0; +} + +/* +** Release a unixInodeInfo structure previously allocated by findInodeInfo(). +** +** The global mutex must be held when this routine is called, but the mutex +** on the inode being deleted must NOT be held. +*/ +static void releaseInodeInfo(unixFile *pFile){ + unixInodeInfo *pInode = pFile->pInode; + assert( unixMutexHeld() ); + assert( unixFileMutexNotheld(pFile) ); + if( ALWAYS(pInode) ){ + pInode->nRef--; + if( pInode->nRef==0 ){ + assert( pInode->pShmNode==0 ); + sqlite3_mutex_enter(pInode->pLockMutex); + closePendingFds(pFile); + sqlite3_mutex_leave(pInode->pLockMutex); + if( pInode->pPrev ){ + assert( pInode->pPrev->pNext==pInode ); + pInode->pPrev->pNext = pInode->pNext; + }else{ + assert( inodeList==pInode ); + inodeList = pInode->pNext; + } + if( pInode->pNext ){ + assert( pInode->pNext->pPrev==pInode ); + pInode->pNext->pPrev = pInode->pPrev; + } + sqlite3_mutex_free(pInode->pLockMutex); + sqlite3_free(pInode); + } + } +} + +/* +** Given a file descriptor, locate the unixInodeInfo object that +** describes that file descriptor. Create a new one if necessary. The +** return value might be uninitialized if an error occurs. +** +** The global mutex must held when calling this routine. +** +** Return an appropriate error code. +*/ +static int findInodeInfo( + unixFile *pFile, /* Unix file with file desc used in the key */ + unixInodeInfo **ppInode /* Return the unixInodeInfo object here */ +){ + int rc; /* System call return code */ + int fd; /* The file descriptor for pFile */ + struct unixFileId fileId; /* Lookup key for the unixInodeInfo */ + struct stat statbuf; /* Low-level file information */ + unixInodeInfo *pInode = 0; /* Candidate unixInodeInfo object */ + + assert( unixMutexHeld() ); + + /* Get low-level information about the file that we can used to + ** create a unique name for the file. + */ + fd = pFile->h; + rc = osFstat(fd, &statbuf); + if( rc!=0 ){ + storeLastErrno(pFile, errno); +#if defined(EOVERFLOW) && defined(SQLITE_DISABLE_LFS) + if( pFile->lastErrno==EOVERFLOW ) return SQLITE_NOLFS; +#endif + return SQLITE_IOERR; + } + +#ifdef __APPLE__ + /* On OS X on an msdos filesystem, the inode number is reported + ** incorrectly for zero-size files. See ticket #3260. To work + ** around this problem (we consider it a bug in OS X, not SQLite) + ** we always increase the file size to 1 by writing a single byte + ** prior to accessing the inode number. The one byte written is + ** an ASCII 'S' character which also happens to be the first byte + ** in the header of every SQLite database. In this way, if there + ** is a race condition such that another thread has already populated + ** the first page of the database, no damage is done. + */ + if( statbuf.st_size==0 && (pFile->fsFlags & SQLITE_FSFLAGS_IS_MSDOS)!=0 ){ + do{ rc = osWrite(fd, "S", 1); }while( rc<0 && errno==EINTR ); + if( rc!=1 ){ + storeLastErrno(pFile, errno); + return SQLITE_IOERR; + } + rc = osFstat(fd, &statbuf); + if( rc!=0 ){ + storeLastErrno(pFile, errno); + return SQLITE_IOERR; + } + } +#endif + + memset(&fileId, 0, sizeof(fileId)); + fileId.dev = statbuf.st_dev; +#if OS_VXWORKS + fileId.pId = pFile->pId; +#else + fileId.ino = (u64)statbuf.st_ino; +#endif + assert( unixMutexHeld() ); + pInode = inodeList; + while( pInode && memcmp(&fileId, &pInode->fileId, sizeof(fileId)) ){ + pInode = pInode->pNext; + } + if( pInode==0 ){ + pInode = sqlite3_malloc64( sizeof(*pInode) ); + if( pInode==0 ){ + return SQLITE_NOMEM_BKPT; + } + memset(pInode, 0, sizeof(*pInode)); + memcpy(&pInode->fileId, &fileId, sizeof(fileId)); + if( sqlite3GlobalConfig.bCoreMutex ){ + pInode->pLockMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST); + if( pInode->pLockMutex==0 ){ + sqlite3_free(pInode); + return SQLITE_NOMEM_BKPT; + } + } + pInode->nRef = 1; + assert( unixMutexHeld() ); + pInode->pNext = inodeList; + pInode->pPrev = 0; + if( inodeList ) inodeList->pPrev = pInode; + inodeList = pInode; + }else{ + pInode->nRef++; + } + *ppInode = pInode; + return SQLITE_OK; +} + +/* +** Return TRUE if pFile has been renamed or unlinked since it was first opened. +*/ +static int fileHasMoved(unixFile *pFile){ +#if OS_VXWORKS + return pFile->pInode!=0 && pFile->pId!=pFile->pInode->fileId.pId; +#else + struct stat buf; + return pFile->pInode!=0 && + (osStat(pFile->zPath, &buf)!=0 + || (u64)buf.st_ino!=pFile->pInode->fileId.ino); +#endif +} + + +/* +** Check a unixFile that is a database. Verify the following: +** +** (1) There is exactly one hard link on the file +** (2) The file is not a symbolic link +** (3) The file has not been renamed or unlinked +** +** Issue sqlite3_log(SQLITE_WARNING,...) messages if anything is not right. +*/ +static void verifyDbFile(unixFile *pFile){ + struct stat buf; + int rc; + + /* These verifications occurs for the main database only */ + if( pFile->ctrlFlags & UNIXFILE_NOLOCK ) return; + + rc = osFstat(pFile->h, &buf); + if( rc!=0 ){ + sqlite3_log(SQLITE_WARNING, "cannot fstat db file %s", pFile->zPath); + return; + } + if( buf.st_nlink==0 ){ + sqlite3_log(SQLITE_WARNING, "file unlinked while open: %s", pFile->zPath); + return; + } + if( buf.st_nlink>1 ){ + sqlite3_log(SQLITE_WARNING, "multiple links to file: %s", pFile->zPath); + return; + } + if( fileHasMoved(pFile) ){ + sqlite3_log(SQLITE_WARNING, "file renamed while open: %s", pFile->zPath); + return; + } +} + + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, set *pResOut +** to a non-zero value otherwise *pResOut is set to zero. The return value +** is set to SQLITE_OK unless an I/O error occurs during lock checking. +*/ +static int unixCheckReservedLock(sqlite3_file *id, int *pResOut){ + int rc = SQLITE_OK; + int reserved = 0; + unixFile *pFile = (unixFile*)id; + + SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; ); + + assert( pFile ); + assert( pFile->eFileLock<=SHARED_LOCK ); + sqlite3_mutex_enter(pFile->pInode->pLockMutex); + + /* Check if a thread in this process holds such a lock */ + if( pFile->pInode->eFileLock>SHARED_LOCK ){ + reserved = 1; + } + + /* Otherwise see if some other process holds it. + */ +#ifndef __DJGPP__ + if( !reserved && !pFile->pInode->bProcessLock ){ + struct flock lock; + lock.l_whence = SEEK_SET; + lock.l_start = RESERVED_BYTE; + lock.l_len = 1; + lock.l_type = F_WRLCK; + if( osFcntl(pFile->h, F_GETLK, &lock) ){ + rc = SQLITE_IOERR_CHECKRESERVEDLOCK; + storeLastErrno(pFile, errno); + } else if( lock.l_type!=F_UNLCK ){ + reserved = 1; + } + } +#endif + + sqlite3_mutex_leave(pFile->pInode->pLockMutex); + OSTRACE(("TEST WR-LOCK %d %d %d (unix)\n", pFile->h, rc, reserved)); + + *pResOut = reserved; + return rc; +} + +/* Forward declaration*/ +static int unixSleep(sqlite3_vfs*,int); + +/* +** Set a posix-advisory-lock. +** +** There are two versions of this routine. If compiled with +** SQLITE_ENABLE_SETLK_TIMEOUT then the routine has an extra parameter +** which is a pointer to a unixFile. If the unixFile->iBusyTimeout +** value is set, then it is the number of milliseconds to wait before +** failing the lock. The iBusyTimeout value is always reset back to +** zero on each call. +** +** If SQLITE_ENABLE_SETLK_TIMEOUT is not defined, then do a non-blocking +** attempt to set the lock. +*/ +#ifndef SQLITE_ENABLE_SETLK_TIMEOUT +# define osSetPosixAdvisoryLock(h,x,t) osFcntl(h,F_SETLK,x) +#else +static int osSetPosixAdvisoryLock( + int h, /* The file descriptor on which to take the lock */ + struct flock *pLock, /* The description of the lock */ + unixFile *pFile /* Structure holding timeout value */ +){ + int tm = pFile->iBusyTimeout; + int rc = osFcntl(h,F_SETLK,pLock); + while( rc<0 && tm>0 ){ + /* On systems that support some kind of blocking file lock with a timeout, + ** make appropriate changes here to invoke that blocking file lock. On + ** generic posix, however, there is no such API. So we simply try the + ** lock once every millisecond until either the timeout expires, or until + ** the lock is obtained. */ + unixSleep(0,1000); + rc = osFcntl(h,F_SETLK,pLock); + tm--; + } + return rc; +} +#endif /* SQLITE_ENABLE_SETLK_TIMEOUT */ + + +/* +** Attempt to set a system-lock on the file pFile. The lock is +** described by pLock. +** +** If the pFile was opened read/write from unix-excl, then the only lock +** ever obtained is an exclusive lock, and it is obtained exactly once +** the first time any lock is attempted. All subsequent system locking +** operations become no-ops. Locking operations still happen internally, +** in order to coordinate access between separate database connections +** within this process, but all of that is handled in memory and the +** operating system does not participate. +** +** This function is a pass-through to fcntl(F_SETLK) if pFile is using +** any VFS other than "unix-excl" or if pFile is opened on "unix-excl" +** and is read-only. +** +** Zero is returned if the call completes successfully, or -1 if a call +** to fcntl() fails. In this case, errno is set appropriately (by fcntl()). +*/ +static int unixFileLock(unixFile *pFile, struct flock *pLock){ + int rc; + unixInodeInfo *pInode = pFile->pInode; + assert( pInode!=0 ); + assert( sqlite3_mutex_held(pInode->pLockMutex) ); + if( (pFile->ctrlFlags & (UNIXFILE_EXCL|UNIXFILE_RDONLY))==UNIXFILE_EXCL ){ + if( pInode->bProcessLock==0 ){ + struct flock lock; + assert( pInode->nLock==0 ); + lock.l_whence = SEEK_SET; + lock.l_start = SHARED_FIRST; + lock.l_len = SHARED_SIZE; + lock.l_type = F_WRLCK; + rc = osSetPosixAdvisoryLock(pFile->h, &lock, pFile); + if( rc<0 ) return rc; + pInode->bProcessLock = 1; + pInode->nLock++; + }else{ + rc = 0; + } + }else{ + rc = osSetPosixAdvisoryLock(pFile->h, pLock, pFile); + } + return rc; +} + +/* +** Lock the file with the lock specified by parameter eFileLock - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** This routine will only increase a lock. Use the sqlite3OsUnlock() +** routine to lower a locking level. +*/ +static int unixLock(sqlite3_file *id, int eFileLock){ + /* The following describes the implementation of the various locks and + ** lock transitions in terms of the POSIX advisory shared and exclusive + ** lock primitives (called read-locks and write-locks below, to avoid + ** confusion with SQLite lock names). The algorithms are complicated + ** slightly in order to be compatible with Windows95 systems simultaneously + ** accessing the same database file, in case that is ever required. + ** + ** Symbols defined in os.h indentify the 'pending byte' and the 'reserved + ** byte', each single bytes at well known offsets, and the 'shared byte + ** range', a range of 510 bytes at a well known offset. + ** + ** To obtain a SHARED lock, a read-lock is obtained on the 'pending + ** byte'. If this is successful, 'shared byte range' is read-locked + ** and the lock on the 'pending byte' released. (Legacy note: When + ** SQLite was first developed, Windows95 systems were still very common, + ** and Widnows95 lacks a shared-lock capability. So on Windows95, a + ** single randomly selected by from the 'shared byte range' is locked. + ** Windows95 is now pretty much extinct, but this work-around for the + ** lack of shared-locks on Windows95 lives on, for backwards + ** compatibility.) + ** + ** A process may only obtain a RESERVED lock after it has a SHARED lock. + ** A RESERVED lock is implemented by grabbing a write-lock on the + ** 'reserved byte'. + ** + ** An EXCLUSIVE lock may only be requested after either a SHARED or + ** RESERVED lock is held. An EXCLUSIVE lock is implemented by obtaining + ** a write-lock on the entire 'shared byte range'. Since all other locks + ** require a read-lock on one of the bytes within this range, this ensures + ** that no other locks are held on the database. + ** + ** If a process that holds a RESERVED lock requests an EXCLUSIVE, then + ** a PENDING lock is obtained first. A PENDING lock is implemented by + ** obtaining a write-lock on the 'pending byte'. This ensures that no new + ** SHARED locks can be obtained, but existing SHARED locks are allowed to + ** persist. If the call to this function fails to obtain the EXCLUSIVE + ** lock in this case, it holds the PENDING lock intead. The client may + ** then re-attempt the EXCLUSIVE lock later on, after existing SHARED + ** locks have cleared. + */ + int rc = SQLITE_OK; + unixFile *pFile = (unixFile*)id; + unixInodeInfo *pInode; + struct flock lock; + int tErrno = 0; + + assert( pFile ); + OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (unix)\n", pFile->h, + azFileLock(eFileLock), azFileLock(pFile->eFileLock), + azFileLock(pFile->pInode->eFileLock), pFile->pInode->nShared, + osGetpid(0))); + + /* If there is already a lock of this type or more restrictive on the + ** unixFile, do nothing. Don't use the end_lock: exit path, as + ** unixEnterMutex() hasn't been called yet. + */ + if( pFile->eFileLock>=eFileLock ){ + OSTRACE(("LOCK %d %s ok (already held) (unix)\n", pFile->h, + azFileLock(eFileLock))); + return SQLITE_OK; + } + + /* Make sure the locking sequence is correct. + ** (1) We never move from unlocked to anything higher than shared lock. + ** (2) SQLite never explicitly requests a pendig lock. + ** (3) A shared lock is always held when a reserve lock is requested. + */ + assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK ); + assert( eFileLock!=PENDING_LOCK ); + assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK ); + + /* This mutex is needed because pFile->pInode is shared across threads + */ + pInode = pFile->pInode; + sqlite3_mutex_enter(pInode->pLockMutex); + + /* If some thread using this PID has a lock via a different unixFile* + ** handle that precludes the requested lock, return BUSY. + */ + if( (pFile->eFileLock!=pInode->eFileLock && + (pInode->eFileLock>=PENDING_LOCK || eFileLock>SHARED_LOCK)) + ){ + rc = SQLITE_BUSY; + goto end_lock; + } + + /* If a SHARED lock is requested, and some thread using this PID already + ** has a SHARED or RESERVED lock, then increment reference counts and + ** return SQLITE_OK. + */ + if( eFileLock==SHARED_LOCK && + (pInode->eFileLock==SHARED_LOCK || pInode->eFileLock==RESERVED_LOCK) ){ + assert( eFileLock==SHARED_LOCK ); + assert( pFile->eFileLock==0 ); + assert( pInode->nShared>0 ); + pFile->eFileLock = SHARED_LOCK; + pInode->nShared++; + pInode->nLock++; + goto end_lock; + } + + + /* A PENDING lock is needed before acquiring a SHARED lock and before + ** acquiring an EXCLUSIVE lock. For the SHARED lock, the PENDING will + ** be released. + */ + lock.l_len = 1L; + lock.l_whence = SEEK_SET; + if( eFileLock==SHARED_LOCK + || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock==RESERVED_LOCK) + ){ + lock.l_type = (eFileLock==SHARED_LOCK?F_RDLCK:F_WRLCK); + lock.l_start = PENDING_BYTE; + if( unixFileLock(pFile, &lock) ){ + tErrno = errno; + rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK); + if( rc!=SQLITE_BUSY ){ + storeLastErrno(pFile, tErrno); + } + goto end_lock; + }else if( eFileLock==EXCLUSIVE_LOCK ){ + pFile->eFileLock = PENDING_LOCK; + pInode->eFileLock = PENDING_LOCK; + } + } + + + /* If control gets to this point, then actually go ahead and make + ** operating system calls for the specified lock. + */ + if( eFileLock==SHARED_LOCK ){ + assert( pInode->nShared==0 ); + assert( pInode->eFileLock==0 ); + assert( rc==SQLITE_OK ); + + /* Now get the read-lock */ + lock.l_start = SHARED_FIRST; + lock.l_len = SHARED_SIZE; + if( unixFileLock(pFile, &lock) ){ + tErrno = errno; + rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK); + } + + /* Drop the temporary PENDING lock */ + lock.l_start = PENDING_BYTE; + lock.l_len = 1L; + lock.l_type = F_UNLCK; + if( unixFileLock(pFile, &lock) && rc==SQLITE_OK ){ + /* This could happen with a network mount */ + tErrno = errno; + rc = SQLITE_IOERR_UNLOCK; + } + + if( rc ){ + if( rc!=SQLITE_BUSY ){ + storeLastErrno(pFile, tErrno); + } + goto end_lock; + }else{ + pFile->eFileLock = SHARED_LOCK; + pInode->nLock++; + pInode->nShared = 1; + } + }else if( eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1 ){ + /* We are trying for an exclusive lock but another thread in this + ** same process is still holding a shared lock. */ + rc = SQLITE_BUSY; + }else{ + /* The request was for a RESERVED or EXCLUSIVE lock. It is + ** assumed that there is a SHARED or greater lock on the file + ** already. + */ + assert( 0!=pFile->eFileLock ); + lock.l_type = F_WRLCK; + + assert( eFileLock==RESERVED_LOCK || eFileLock==EXCLUSIVE_LOCK ); + if( eFileLock==RESERVED_LOCK ){ + lock.l_start = RESERVED_BYTE; + lock.l_len = 1L; + }else{ + lock.l_start = SHARED_FIRST; + lock.l_len = SHARED_SIZE; + } + + if( unixFileLock(pFile, &lock) ){ + tErrno = errno; + rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK); + if( rc!=SQLITE_BUSY ){ + storeLastErrno(pFile, tErrno); + } + } + } + + +#ifdef SQLITE_DEBUG + /* Set up the transaction-counter change checking flags when + ** transitioning from a SHARED to a RESERVED lock. The change + ** from SHARED to RESERVED marks the beginning of a normal + ** write operation (not a hot journal rollback). + */ + if( rc==SQLITE_OK + && pFile->eFileLock<=SHARED_LOCK + && eFileLock==RESERVED_LOCK + ){ + pFile->transCntrChng = 0; + pFile->dbUpdate = 0; + pFile->inNormalWrite = 1; + } +#endif + + if( rc==SQLITE_OK ){ + pFile->eFileLock = eFileLock; + pInode->eFileLock = eFileLock; + } + +end_lock: + sqlite3_mutex_leave(pInode->pLockMutex); + OSTRACE(("LOCK %d %s %s (unix)\n", pFile->h, azFileLock(eFileLock), + rc==SQLITE_OK ? "ok" : "failed")); + return rc; +} + +/* +** Add the file descriptor used by file handle pFile to the corresponding +** pUnused list. +*/ +static void setPendingFd(unixFile *pFile){ + unixInodeInfo *pInode = pFile->pInode; + UnixUnusedFd *p = pFile->pPreallocatedUnused; + assert( unixFileMutexHeld(pFile) ); + p->pNext = pInode->pUnused; + pInode->pUnused = p; + pFile->h = -1; + pFile->pPreallocatedUnused = 0; +} + +/* +** Lower the locking level on file descriptor pFile to eFileLock. eFileLock +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +** +** If handleNFSUnlock is true, then on downgrading an EXCLUSIVE_LOCK to SHARED +** the byte range is divided into 2 parts and the first part is unlocked then +** set to a read lock, then the other part is simply unlocked. This works +** around a bug in BSD NFS lockd (also seen on MacOSX 10.3+) that fails to +** remove the write lock on a region when a read lock is set. +*/ +static int posixUnlock(sqlite3_file *id, int eFileLock, int handleNFSUnlock){ + unixFile *pFile = (unixFile*)id; + unixInodeInfo *pInode; + struct flock lock; + int rc = SQLITE_OK; + + assert( pFile ); + OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (unix)\n", pFile->h, eFileLock, + pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared, + osGetpid(0))); + + assert( eFileLock<=SHARED_LOCK ); + if( pFile->eFileLock<=eFileLock ){ + return SQLITE_OK; + } + pInode = pFile->pInode; + sqlite3_mutex_enter(pInode->pLockMutex); + assert( pInode->nShared!=0 ); + if( pFile->eFileLock>SHARED_LOCK ){ + assert( pInode->eFileLock==pFile->eFileLock ); + +#ifdef SQLITE_DEBUG + /* When reducing a lock such that other processes can start + ** reading the database file again, make sure that the + ** transaction counter was updated if any part of the database + ** file changed. If the transaction counter is not updated, + ** other connections to the same file might not realize that + ** the file has changed and hence might not know to flush their + ** cache. The use of a stale cache can lead to database corruption. + */ + pFile->inNormalWrite = 0; +#endif + + /* downgrading to a shared lock on NFS involves clearing the write lock + ** before establishing the readlock - to avoid a race condition we downgrade + ** the lock in 2 blocks, so that part of the range will be covered by a + ** write lock until the rest is covered by a read lock: + ** 1: [WWWWW] + ** 2: [....W] + ** 3: [RRRRW] + ** 4: [RRRR.] + */ + if( eFileLock==SHARED_LOCK ){ +#if !defined(__APPLE__) || !SQLITE_ENABLE_LOCKING_STYLE + (void)handleNFSUnlock; + assert( handleNFSUnlock==0 ); +#endif +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE + if( handleNFSUnlock ){ + int tErrno; /* Error code from system call errors */ + off_t divSize = SHARED_SIZE - 1; + + lock.l_type = F_UNLCK; + lock.l_whence = SEEK_SET; + lock.l_start = SHARED_FIRST; + lock.l_len = divSize; + if( unixFileLock(pFile, &lock)==(-1) ){ + tErrno = errno; + rc = SQLITE_IOERR_UNLOCK; + storeLastErrno(pFile, tErrno); + goto end_unlock; + } + lock.l_type = F_RDLCK; + lock.l_whence = SEEK_SET; + lock.l_start = SHARED_FIRST; + lock.l_len = divSize; + if( unixFileLock(pFile, &lock)==(-1) ){ + tErrno = errno; + rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_RDLOCK); + if( IS_LOCK_ERROR(rc) ){ + storeLastErrno(pFile, tErrno); + } + goto end_unlock; + } + lock.l_type = F_UNLCK; + lock.l_whence = SEEK_SET; + lock.l_start = SHARED_FIRST+divSize; + lock.l_len = SHARED_SIZE-divSize; + if( unixFileLock(pFile, &lock)==(-1) ){ + tErrno = errno; + rc = SQLITE_IOERR_UNLOCK; + storeLastErrno(pFile, tErrno); + goto end_unlock; + } + }else +#endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */ + { + lock.l_type = F_RDLCK; + lock.l_whence = SEEK_SET; + lock.l_start = SHARED_FIRST; + lock.l_len = SHARED_SIZE; + if( unixFileLock(pFile, &lock) ){ + /* In theory, the call to unixFileLock() cannot fail because another + ** process is holding an incompatible lock. If it does, this + ** indicates that the other process is not following the locking + ** protocol. If this happens, return SQLITE_IOERR_RDLOCK. Returning + ** SQLITE_BUSY would confuse the upper layer (in practice it causes + ** an assert to fail). */ + rc = SQLITE_IOERR_RDLOCK; + storeLastErrno(pFile, errno); + goto end_unlock; + } + } + } + lock.l_type = F_UNLCK; + lock.l_whence = SEEK_SET; + lock.l_start = PENDING_BYTE; + lock.l_len = 2L; assert( PENDING_BYTE+1==RESERVED_BYTE ); + if( unixFileLock(pFile, &lock)==0 ){ + pInode->eFileLock = SHARED_LOCK; + }else{ + rc = SQLITE_IOERR_UNLOCK; + storeLastErrno(pFile, errno); + goto end_unlock; + } + } + if( eFileLock==NO_LOCK ){ + /* Decrement the shared lock counter. Release the lock using an + ** OS call only when all threads in this same process have released + ** the lock. + */ + pInode->nShared--; + if( pInode->nShared==0 ){ + lock.l_type = F_UNLCK; + lock.l_whence = SEEK_SET; + lock.l_start = lock.l_len = 0L; + if( unixFileLock(pFile, &lock)==0 ){ + pInode->eFileLock = NO_LOCK; + }else{ + rc = SQLITE_IOERR_UNLOCK; + storeLastErrno(pFile, errno); + pInode->eFileLock = NO_LOCK; + pFile->eFileLock = NO_LOCK; + } + } + + /* Decrement the count of locks against this same file. When the + ** count reaches zero, close any other file descriptors whose close + ** was deferred because of outstanding locks. + */ + pInode->nLock--; + assert( pInode->nLock>=0 ); + if( pInode->nLock==0 ) closePendingFds(pFile); + } + +end_unlock: + sqlite3_mutex_leave(pInode->pLockMutex); + if( rc==SQLITE_OK ){ + pFile->eFileLock = eFileLock; + } + return rc; +} + +/* +** Lower the locking level on file descriptor pFile to eFileLock. eFileLock +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +*/ +static int unixUnlock(sqlite3_file *id, int eFileLock){ +#if SQLITE_MAX_MMAP_SIZE>0 + assert( eFileLock==SHARED_LOCK || ((unixFile *)id)->nFetchOut==0 ); +#endif + return posixUnlock(id, eFileLock, 0); +} + +#if SQLITE_MAX_MMAP_SIZE>0 +static int unixMapfile(unixFile *pFd, i64 nByte); +static void unixUnmapfile(unixFile *pFd); +#endif + +/* +** This function performs the parts of the "close file" operation +** common to all locking schemes. It closes the directory and file +** handles, if they are valid, and sets all fields of the unixFile +** structure to 0. +** +** It is *not* necessary to hold the mutex when this routine is called, +** even on VxWorks. A mutex will be acquired on VxWorks by the +** vxworksReleaseFileId() routine. +*/ +static int closeUnixFile(sqlite3_file *id){ + unixFile *pFile = (unixFile*)id; +#if SQLITE_MAX_MMAP_SIZE>0 + unixUnmapfile(pFile); +#endif + if( pFile->h>=0 ){ + robust_close(pFile, pFile->h, __LINE__); + pFile->h = -1; + } +#if OS_VXWORKS + if( pFile->pId ){ + if( pFile->ctrlFlags & UNIXFILE_DELETE ){ + osUnlink(pFile->pId->zCanonicalName); + } + vxworksReleaseFileId(pFile->pId); + pFile->pId = 0; + } +#endif +#ifdef SQLITE_UNLINK_AFTER_CLOSE + if( pFile->ctrlFlags & UNIXFILE_DELETE ){ + osUnlink(pFile->zPath); + sqlite3_free(*(char**)&pFile->zPath); + pFile->zPath = 0; + } +#endif + OSTRACE(("CLOSE %-3d\n", pFile->h)); + OpenCounter(-1); + sqlite3_free(pFile->pPreallocatedUnused); + memset(pFile, 0, sizeof(unixFile)); + return SQLITE_OK; +} + +/* +** Close a file. +*/ +static int unixClose(sqlite3_file *id){ + int rc = SQLITE_OK; + unixFile *pFile = (unixFile *)id; + unixInodeInfo *pInode = pFile->pInode; + + assert( pInode!=0 ); + verifyDbFile(pFile); + unixUnlock(id, NO_LOCK); + assert( unixFileMutexNotheld(pFile) ); + unixEnterMutex(); + + /* unixFile.pInode is always valid here. Otherwise, a different close + ** routine (e.g. nolockClose()) would be called instead. + */ + assert( pFile->pInode->nLock>0 || pFile->pInode->bProcessLock==0 ); + sqlite3_mutex_enter(pInode->pLockMutex); + if( pInode->nLock ){ + /* If there are outstanding locks, do not actually close the file just + ** yet because that would clear those locks. Instead, add the file + ** descriptor to pInode->pUnused list. It will be automatically closed + ** when the last lock is cleared. + */ + setPendingFd(pFile); + } + sqlite3_mutex_leave(pInode->pLockMutex); + releaseInodeInfo(pFile); + assert( pFile->pShm==0 ); + rc = closeUnixFile(id); + unixLeaveMutex(); + return rc; +} + +/************** End of the posix advisory lock implementation ***************** +******************************************************************************/ + +/****************************************************************************** +****************************** No-op Locking ********************************** +** +** Of the various locking implementations available, this is by far the +** simplest: locking is ignored. No attempt is made to lock the database +** file for reading or writing. +** +** This locking mode is appropriate for use on read-only databases +** (ex: databases that are burned into CD-ROM, for example.) It can +** also be used if the application employs some external mechanism to +** prevent simultaneous access of the same database by two or more +** database connections. But there is a serious risk of database +** corruption if this locking mode is used in situations where multiple +** database connections are accessing the same database file at the same +** time and one or more of those connections are writing. +*/ + +static int nolockCheckReservedLock(sqlite3_file *NotUsed, int *pResOut){ + UNUSED_PARAMETER(NotUsed); + *pResOut = 0; + return SQLITE_OK; +} +static int nolockLock(sqlite3_file *NotUsed, int NotUsed2){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + return SQLITE_OK; +} +static int nolockUnlock(sqlite3_file *NotUsed, int NotUsed2){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + return SQLITE_OK; +} + +/* +** Close the file. +*/ +static int nolockClose(sqlite3_file *id) { + return closeUnixFile(id); +} + +/******************* End of the no-op lock implementation ********************* +******************************************************************************/ + +/****************************************************************************** +************************* Begin dot-file Locking ****************************** +** +** The dotfile locking implementation uses the existence of separate lock +** files (really a directory) to control access to the database. This works +** on just about every filesystem imaginable. But there are serious downsides: +** +** (1) There is zero concurrency. A single reader blocks all other +** connections from reading or writing the database. +** +** (2) An application crash or power loss can leave stale lock files +** sitting around that need to be cleared manually. +** +** Nevertheless, a dotlock is an appropriate locking mode for use if no +** other locking strategy is available. +** +** Dotfile locking works by creating a subdirectory in the same directory as +** the database and with the same name but with a ".lock" extension added. +** The existence of a lock directory implies an EXCLUSIVE lock. All other +** lock types (SHARED, RESERVED, PENDING) are mapped into EXCLUSIVE. +*/ + +/* +** The file suffix added to the data base filename in order to create the +** lock directory. +*/ +#define DOTLOCK_SUFFIX ".lock" + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, set *pResOut +** to a non-zero value otherwise *pResOut is set to zero. The return value +** is set to SQLITE_OK unless an I/O error occurs during lock checking. +** +** In dotfile locking, either a lock exists or it does not. So in this +** variation of CheckReservedLock(), *pResOut is set to true if any lock +** is held on the file and false if the file is unlocked. +*/ +static int dotlockCheckReservedLock(sqlite3_file *id, int *pResOut) { + int rc = SQLITE_OK; + int reserved = 0; + unixFile *pFile = (unixFile*)id; + + SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; ); + + assert( pFile ); + reserved = osAccess((const char*)pFile->lockingContext, 0)==0; + OSTRACE(("TEST WR-LOCK %d %d %d (dotlock)\n", pFile->h, rc, reserved)); + *pResOut = reserved; + return rc; +} + +/* +** Lock the file with the lock specified by parameter eFileLock - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> (PENDING) -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** This routine will only increase a lock. Use the sqlite3OsUnlock() +** routine to lower a locking level. +** +** With dotfile locking, we really only support state (4): EXCLUSIVE. +** But we track the other locking levels internally. +*/ +static int dotlockLock(sqlite3_file *id, int eFileLock) { + unixFile *pFile = (unixFile*)id; + char *zLockFile = (char *)pFile->lockingContext; + int rc = SQLITE_OK; + + + /* If we have any lock, then the lock file already exists. All we have + ** to do is adjust our internal record of the lock level. + */ + if( pFile->eFileLock > NO_LOCK ){ + pFile->eFileLock = eFileLock; + /* Always update the timestamp on the old file */ +#ifdef HAVE_UTIME + utime(zLockFile, NULL); +#else + utimes(zLockFile, NULL); +#endif + return SQLITE_OK; + } + + /* grab an exclusive lock */ + rc = osMkdir(zLockFile, 0777); + if( rc<0 ){ + /* failed to open/create the lock directory */ + int tErrno = errno; + if( EEXIST == tErrno ){ + rc = SQLITE_BUSY; + } else { + rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK); + if( rc!=SQLITE_BUSY ){ + storeLastErrno(pFile, tErrno); + } + } + return rc; + } + + /* got it, set the type and return ok */ + pFile->eFileLock = eFileLock; + return rc; +} + +/* +** Lower the locking level on file descriptor pFile to eFileLock. eFileLock +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +** +** When the locking level reaches NO_LOCK, delete the lock file. +*/ +static int dotlockUnlock(sqlite3_file *id, int eFileLock) { + unixFile *pFile = (unixFile*)id; + char *zLockFile = (char *)pFile->lockingContext; + int rc; + + assert( pFile ); + OSTRACE(("UNLOCK %d %d was %d pid=%d (dotlock)\n", pFile->h, eFileLock, + pFile->eFileLock, osGetpid(0))); + assert( eFileLock<=SHARED_LOCK ); + + /* no-op if possible */ + if( pFile->eFileLock==eFileLock ){ + return SQLITE_OK; + } + + /* To downgrade to shared, simply update our internal notion of the + ** lock state. No need to mess with the file on disk. + */ + if( eFileLock==SHARED_LOCK ){ + pFile->eFileLock = SHARED_LOCK; + return SQLITE_OK; + } + + /* To fully unlock the database, delete the lock file */ + assert( eFileLock==NO_LOCK ); + rc = osRmdir(zLockFile); + if( rc<0 ){ + int tErrno = errno; + if( tErrno==ENOENT ){ + rc = SQLITE_OK; + }else{ + rc = SQLITE_IOERR_UNLOCK; + storeLastErrno(pFile, tErrno); + } + return rc; + } + pFile->eFileLock = NO_LOCK; + return SQLITE_OK; +} + +/* +** Close a file. Make sure the lock has been released before closing. +*/ +static int dotlockClose(sqlite3_file *id) { + unixFile *pFile = (unixFile*)id; + assert( id!=0 ); + dotlockUnlock(id, NO_LOCK); + sqlite3_free(pFile->lockingContext); + return closeUnixFile(id); +} +/****************** End of the dot-file lock implementation ******************* +******************************************************************************/ + +/****************************************************************************** +************************** Begin flock Locking ******************************** +** +** Use the flock() system call to do file locking. +** +** flock() locking is like dot-file locking in that the various +** fine-grain locking levels supported by SQLite are collapsed into +** a single exclusive lock. In other words, SHARED, RESERVED, and +** PENDING locks are the same thing as an EXCLUSIVE lock. SQLite +** still works when you do this, but concurrency is reduced since +** only a single process can be reading the database at a time. +** +** Omit this section if SQLITE_ENABLE_LOCKING_STYLE is turned off +*/ +#if SQLITE_ENABLE_LOCKING_STYLE + +/* +** Retry flock() calls that fail with EINTR +*/ +#ifdef EINTR +static int robust_flock(int fd, int op){ + int rc; + do{ rc = flock(fd,op); }while( rc<0 && errno==EINTR ); + return rc; +} +#else +# define robust_flock(a,b) flock(a,b) +#endif + + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, set *pResOut +** to a non-zero value otherwise *pResOut is set to zero. The return value +** is set to SQLITE_OK unless an I/O error occurs during lock checking. +*/ +static int flockCheckReservedLock(sqlite3_file *id, int *pResOut){ + int rc = SQLITE_OK; + int reserved = 0; + unixFile *pFile = (unixFile*)id; + + SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; ); + + assert( pFile ); + + /* Check if a thread in this process holds such a lock */ + if( pFile->eFileLock>SHARED_LOCK ){ + reserved = 1; + } + + /* Otherwise see if some other process holds it. */ + if( !reserved ){ + /* attempt to get the lock */ + int lrc = robust_flock(pFile->h, LOCK_EX | LOCK_NB); + if( !lrc ){ + /* got the lock, unlock it */ + lrc = robust_flock(pFile->h, LOCK_UN); + if ( lrc ) { + int tErrno = errno; + /* unlock failed with an error */ + lrc = SQLITE_IOERR_UNLOCK; + storeLastErrno(pFile, tErrno); + rc = lrc; + } + } else { + int tErrno = errno; + reserved = 1; + /* someone else might have it reserved */ + lrc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK); + if( IS_LOCK_ERROR(lrc) ){ + storeLastErrno(pFile, tErrno); + rc = lrc; + } + } + } + OSTRACE(("TEST WR-LOCK %d %d %d (flock)\n", pFile->h, rc, reserved)); + +#ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS + if( (rc & 0xff) == SQLITE_IOERR ){ + rc = SQLITE_OK; + reserved=1; + } +#endif /* SQLITE_IGNORE_FLOCK_LOCK_ERRORS */ + *pResOut = reserved; + return rc; +} + +/* +** Lock the file with the lock specified by parameter eFileLock - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> (PENDING) -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** flock() only really support EXCLUSIVE locks. We track intermediate +** lock states in the sqlite3_file structure, but all locks SHARED or +** above are really EXCLUSIVE locks and exclude all other processes from +** access the file. +** +** This routine will only increase a lock. Use the sqlite3OsUnlock() +** routine to lower a locking level. +*/ +static int flockLock(sqlite3_file *id, int eFileLock) { + int rc = SQLITE_OK; + unixFile *pFile = (unixFile*)id; + + assert( pFile ); + + /* if we already have a lock, it is exclusive. + ** Just adjust level and punt on outta here. */ + if (pFile->eFileLock > NO_LOCK) { + pFile->eFileLock = eFileLock; + return SQLITE_OK; + } + + /* grab an exclusive lock */ + + if (robust_flock(pFile->h, LOCK_EX | LOCK_NB)) { + int tErrno = errno; + /* didn't get, must be busy */ + rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK); + if( IS_LOCK_ERROR(rc) ){ + storeLastErrno(pFile, tErrno); + } + } else { + /* got it, set the type and return ok */ + pFile->eFileLock = eFileLock; + } + OSTRACE(("LOCK %d %s %s (flock)\n", pFile->h, azFileLock(eFileLock), + rc==SQLITE_OK ? "ok" : "failed")); +#ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS + if( (rc & 0xff) == SQLITE_IOERR ){ + rc = SQLITE_BUSY; + } +#endif /* SQLITE_IGNORE_FLOCK_LOCK_ERRORS */ + return rc; +} + + +/* +** Lower the locking level on file descriptor pFile to eFileLock. eFileLock +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +*/ +static int flockUnlock(sqlite3_file *id, int eFileLock) { + unixFile *pFile = (unixFile*)id; + + assert( pFile ); + OSTRACE(("UNLOCK %d %d was %d pid=%d (flock)\n", pFile->h, eFileLock, + pFile->eFileLock, osGetpid(0))); + assert( eFileLock<=SHARED_LOCK ); + + /* no-op if possible */ + if( pFile->eFileLock==eFileLock ){ + return SQLITE_OK; + } + + /* shared can just be set because we always have an exclusive */ + if (eFileLock==SHARED_LOCK) { + pFile->eFileLock = eFileLock; + return SQLITE_OK; + } + + /* no, really, unlock. */ + if( robust_flock(pFile->h, LOCK_UN) ){ +#ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS + return SQLITE_OK; +#endif /* SQLITE_IGNORE_FLOCK_LOCK_ERRORS */ + return SQLITE_IOERR_UNLOCK; + }else{ + pFile->eFileLock = NO_LOCK; + return SQLITE_OK; + } +} + +/* +** Close a file. +*/ +static int flockClose(sqlite3_file *id) { + assert( id!=0 ); + flockUnlock(id, NO_LOCK); + return closeUnixFile(id); +} + +#endif /* SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORK */ + +/******************* End of the flock lock implementation ********************* +******************************************************************************/ + +/****************************************************************************** +************************ Begin Named Semaphore Locking ************************ +** +** Named semaphore locking is only supported on VxWorks. +** +** Semaphore locking is like dot-lock and flock in that it really only +** supports EXCLUSIVE locking. Only a single process can read or write +** the database file at a time. This reduces potential concurrency, but +** makes the lock implementation much easier. +*/ +#if OS_VXWORKS + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, set *pResOut +** to a non-zero value otherwise *pResOut is set to zero. The return value +** is set to SQLITE_OK unless an I/O error occurs during lock checking. +*/ +static int semXCheckReservedLock(sqlite3_file *id, int *pResOut) { + int rc = SQLITE_OK; + int reserved = 0; + unixFile *pFile = (unixFile*)id; + + SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; ); + + assert( pFile ); + + /* Check if a thread in this process holds such a lock */ + if( pFile->eFileLock>SHARED_LOCK ){ + reserved = 1; + } + + /* Otherwise see if some other process holds it. */ + if( !reserved ){ + sem_t *pSem = pFile->pInode->pSem; + + if( sem_trywait(pSem)==-1 ){ + int tErrno = errno; + if( EAGAIN != tErrno ){ + rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_CHECKRESERVEDLOCK); + storeLastErrno(pFile, tErrno); + } else { + /* someone else has the lock when we are in NO_LOCK */ + reserved = (pFile->eFileLock < SHARED_LOCK); + } + }else{ + /* we could have it if we want it */ + sem_post(pSem); + } + } + OSTRACE(("TEST WR-LOCK %d %d %d (sem)\n", pFile->h, rc, reserved)); + + *pResOut = reserved; + return rc; +} + +/* +** Lock the file with the lock specified by parameter eFileLock - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> (PENDING) -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** Semaphore locks only really support EXCLUSIVE locks. We track intermediate +** lock states in the sqlite3_file structure, but all locks SHARED or +** above are really EXCLUSIVE locks and exclude all other processes from +** access the file. +** +** This routine will only increase a lock. Use the sqlite3OsUnlock() +** routine to lower a locking level. +*/ +static int semXLock(sqlite3_file *id, int eFileLock) { + unixFile *pFile = (unixFile*)id; + sem_t *pSem = pFile->pInode->pSem; + int rc = SQLITE_OK; + + /* if we already have a lock, it is exclusive. + ** Just adjust level and punt on outta here. */ + if (pFile->eFileLock > NO_LOCK) { + pFile->eFileLock = eFileLock; + rc = SQLITE_OK; + goto sem_end_lock; + } + + /* lock semaphore now but bail out when already locked. */ + if( sem_trywait(pSem)==-1 ){ + rc = SQLITE_BUSY; + goto sem_end_lock; + } + + /* got it, set the type and return ok */ + pFile->eFileLock = eFileLock; + + sem_end_lock: + return rc; +} + +/* +** Lower the locking level on file descriptor pFile to eFileLock. eFileLock +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +*/ +static int semXUnlock(sqlite3_file *id, int eFileLock) { + unixFile *pFile = (unixFile*)id; + sem_t *pSem = pFile->pInode->pSem; + + assert( pFile ); + assert( pSem ); + OSTRACE(("UNLOCK %d %d was %d pid=%d (sem)\n", pFile->h, eFileLock, + pFile->eFileLock, osGetpid(0))); + assert( eFileLock<=SHARED_LOCK ); + + /* no-op if possible */ + if( pFile->eFileLock==eFileLock ){ + return SQLITE_OK; + } + + /* shared can just be set because we always have an exclusive */ + if (eFileLock==SHARED_LOCK) { + pFile->eFileLock = eFileLock; + return SQLITE_OK; + } + + /* no, really unlock. */ + if ( sem_post(pSem)==-1 ) { + int rc, tErrno = errno; + rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_UNLOCK); + if( IS_LOCK_ERROR(rc) ){ + storeLastErrno(pFile, tErrno); + } + return rc; + } + pFile->eFileLock = NO_LOCK; + return SQLITE_OK; +} + +/* + ** Close a file. + */ +static int semXClose(sqlite3_file *id) { + if( id ){ + unixFile *pFile = (unixFile*)id; + semXUnlock(id, NO_LOCK); + assert( pFile ); + assert( unixFileMutexNotheld(pFile) ); + unixEnterMutex(); + releaseInodeInfo(pFile); + unixLeaveMutex(); + closeUnixFile(id); + } + return SQLITE_OK; +} + +#endif /* OS_VXWORKS */ +/* +** Named semaphore locking is only available on VxWorks. +** +*************** End of the named semaphore lock implementation **************** +******************************************************************************/ + + +/****************************************************************************** +*************************** Begin AFP Locking ********************************* +** +** AFP is the Apple Filing Protocol. AFP is a network filesystem found +** on Apple Macintosh computers - both OS9 and OSX. +** +** Third-party implementations of AFP are available. But this code here +** only works on OSX. +*/ + +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE +/* +** The afpLockingContext structure contains all afp lock specific state +*/ +typedef struct afpLockingContext afpLockingContext; +struct afpLockingContext { + int reserved; + const char *dbPath; /* Name of the open file */ +}; + +struct ByteRangeLockPB2 +{ + unsigned long long offset; /* offset to first byte to lock */ + unsigned long long length; /* nbr of bytes to lock */ + unsigned long long retRangeStart; /* nbr of 1st byte locked if successful */ + unsigned char unLockFlag; /* 1 = unlock, 0 = lock */ + unsigned char startEndFlag; /* 1=rel to end of fork, 0=rel to start */ + int fd; /* file desc to assoc this lock with */ +}; + +#define afpfsByteRangeLock2FSCTL _IOWR('z', 23, struct ByteRangeLockPB2) + +/* +** This is a utility for setting or clearing a bit-range lock on an +** AFP filesystem. +** +** Return SQLITE_OK on success, SQLITE_BUSY on failure. +*/ +static int afpSetLock( + const char *path, /* Name of the file to be locked or unlocked */ + unixFile *pFile, /* Open file descriptor on path */ + unsigned long long offset, /* First byte to be locked */ + unsigned long long length, /* Number of bytes to lock */ + int setLockFlag /* True to set lock. False to clear lock */ +){ + struct ByteRangeLockPB2 pb; + int err; + + pb.unLockFlag = setLockFlag ? 0 : 1; + pb.startEndFlag = 0; + pb.offset = offset; + pb.length = length; + pb.fd = pFile->h; + + OSTRACE(("AFPSETLOCK [%s] for %d%s in range %llx:%llx\n", + (setLockFlag?"ON":"OFF"), pFile->h, (pb.fd==-1?"[testval-1]":""), + offset, length)); + err = fsctl(path, afpfsByteRangeLock2FSCTL, &pb, 0); + if ( err==-1 ) { + int rc; + int tErrno = errno; + OSTRACE(("AFPSETLOCK failed to fsctl() '%s' %d %s\n", + path, tErrno, strerror(tErrno))); +#ifdef SQLITE_IGNORE_AFP_LOCK_ERRORS + rc = SQLITE_BUSY; +#else + rc = sqliteErrorFromPosixError(tErrno, + setLockFlag ? SQLITE_IOERR_LOCK : SQLITE_IOERR_UNLOCK); +#endif /* SQLITE_IGNORE_AFP_LOCK_ERRORS */ + if( IS_LOCK_ERROR(rc) ){ + storeLastErrno(pFile, tErrno); + } + return rc; + } else { + return SQLITE_OK; + } +} + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, set *pResOut +** to a non-zero value otherwise *pResOut is set to zero. The return value +** is set to SQLITE_OK unless an I/O error occurs during lock checking. +*/ +static int afpCheckReservedLock(sqlite3_file *id, int *pResOut){ + int rc = SQLITE_OK; + int reserved = 0; + unixFile *pFile = (unixFile*)id; + afpLockingContext *context; + + SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; ); + + assert( pFile ); + context = (afpLockingContext *) pFile->lockingContext; + if( context->reserved ){ + *pResOut = 1; + return SQLITE_OK; + } + sqlite3_mutex_enter(pFile->pInode->pLockMutex); + /* Check if a thread in this process holds such a lock */ + if( pFile->pInode->eFileLock>SHARED_LOCK ){ + reserved = 1; + } + + /* Otherwise see if some other process holds it. + */ + if( !reserved ){ + /* lock the RESERVED byte */ + int lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1); + if( SQLITE_OK==lrc ){ + /* if we succeeded in taking the reserved lock, unlock it to restore + ** the original state */ + lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0); + } else { + /* if we failed to get the lock then someone else must have it */ + reserved = 1; + } + if( IS_LOCK_ERROR(lrc) ){ + rc=lrc; + } + } + + sqlite3_mutex_leave(pFile->pInode->pLockMutex); + OSTRACE(("TEST WR-LOCK %d %d %d (afp)\n", pFile->h, rc, reserved)); + + *pResOut = reserved; + return rc; +} + +/* +** Lock the file with the lock specified by parameter eFileLock - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> (PENDING) -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** This routine will only increase a lock. Use the sqlite3OsUnlock() +** routine to lower a locking level. +*/ +static int afpLock(sqlite3_file *id, int eFileLock){ + int rc = SQLITE_OK; + unixFile *pFile = (unixFile*)id; + unixInodeInfo *pInode = pFile->pInode; + afpLockingContext *context = (afpLockingContext *) pFile->lockingContext; + + assert( pFile ); + OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (afp)\n", pFile->h, + azFileLock(eFileLock), azFileLock(pFile->eFileLock), + azFileLock(pInode->eFileLock), pInode->nShared , osGetpid(0))); + + /* If there is already a lock of this type or more restrictive on the + ** unixFile, do nothing. Don't use the afp_end_lock: exit path, as + ** unixEnterMutex() hasn't been called yet. + */ + if( pFile->eFileLock>=eFileLock ){ + OSTRACE(("LOCK %d %s ok (already held) (afp)\n", pFile->h, + azFileLock(eFileLock))); + return SQLITE_OK; + } + + /* Make sure the locking sequence is correct + ** (1) We never move from unlocked to anything higher than shared lock. + ** (2) SQLite never explicitly requests a pendig lock. + ** (3) A shared lock is always held when a reserve lock is requested. + */ + assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK ); + assert( eFileLock!=PENDING_LOCK ); + assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK ); + + /* This mutex is needed because pFile->pInode is shared across threads + */ + pInode = pFile->pInode; + sqlite3_mutex_enter(pInode->pLockMutex); + + /* If some thread using this PID has a lock via a different unixFile* + ** handle that precludes the requested lock, return BUSY. + */ + if( (pFile->eFileLock!=pInode->eFileLock && + (pInode->eFileLock>=PENDING_LOCK || eFileLock>SHARED_LOCK)) + ){ + rc = SQLITE_BUSY; + goto afp_end_lock; + } + + /* If a SHARED lock is requested, and some thread using this PID already + ** has a SHARED or RESERVED lock, then increment reference counts and + ** return SQLITE_OK. + */ + if( eFileLock==SHARED_LOCK && + (pInode->eFileLock==SHARED_LOCK || pInode->eFileLock==RESERVED_LOCK) ){ + assert( eFileLock==SHARED_LOCK ); + assert( pFile->eFileLock==0 ); + assert( pInode->nShared>0 ); + pFile->eFileLock = SHARED_LOCK; + pInode->nShared++; + pInode->nLock++; + goto afp_end_lock; + } + + /* A PENDING lock is needed before acquiring a SHARED lock and before + ** acquiring an EXCLUSIVE lock. For the SHARED lock, the PENDING will + ** be released. + */ + if( eFileLock==SHARED_LOCK + || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLockdbPath, pFile, PENDING_BYTE, 1, 1); + if (failed) { + rc = failed; + goto afp_end_lock; + } + } + + /* If control gets to this point, then actually go ahead and make + ** operating system calls for the specified lock. + */ + if( eFileLock==SHARED_LOCK ){ + int lrc1, lrc2, lrc1Errno = 0; + long lk, mask; + + assert( pInode->nShared==0 ); + assert( pInode->eFileLock==0 ); + + mask = (sizeof(long)==8) ? LARGEST_INT64 : 0x7fffffff; + /* Now get the read-lock SHARED_LOCK */ + /* note that the quality of the randomness doesn't matter that much */ + lk = random(); + pInode->sharedByte = (lk & mask)%(SHARED_SIZE - 1); + lrc1 = afpSetLock(context->dbPath, pFile, + SHARED_FIRST+pInode->sharedByte, 1, 1); + if( IS_LOCK_ERROR(lrc1) ){ + lrc1Errno = pFile->lastErrno; + } + /* Drop the temporary PENDING lock */ + lrc2 = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0); + + if( IS_LOCK_ERROR(lrc1) ) { + storeLastErrno(pFile, lrc1Errno); + rc = lrc1; + goto afp_end_lock; + } else if( IS_LOCK_ERROR(lrc2) ){ + rc = lrc2; + goto afp_end_lock; + } else if( lrc1 != SQLITE_OK ) { + rc = lrc1; + } else { + pFile->eFileLock = SHARED_LOCK; + pInode->nLock++; + pInode->nShared = 1; + } + }else if( eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1 ){ + /* We are trying for an exclusive lock but another thread in this + ** same process is still holding a shared lock. */ + rc = SQLITE_BUSY; + }else{ + /* The request was for a RESERVED or EXCLUSIVE lock. It is + ** assumed that there is a SHARED or greater lock on the file + ** already. + */ + int failed = 0; + assert( 0!=pFile->eFileLock ); + if (eFileLock >= RESERVED_LOCK && pFile->eFileLock < RESERVED_LOCK) { + /* Acquire a RESERVED lock */ + failed = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1); + if( !failed ){ + context->reserved = 1; + } + } + if (!failed && eFileLock == EXCLUSIVE_LOCK) { + /* Acquire an EXCLUSIVE lock */ + + /* Remove the shared lock before trying the range. we'll need to + ** reestablish the shared lock if we can't get the afpUnlock + */ + if( !(failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST + + pInode->sharedByte, 1, 0)) ){ + int failed2 = SQLITE_OK; + /* now attemmpt to get the exclusive lock range */ + failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST, + SHARED_SIZE, 1); + if( failed && (failed2 = afpSetLock(context->dbPath, pFile, + SHARED_FIRST + pInode->sharedByte, 1, 1)) ){ + /* Can't reestablish the shared lock. Sqlite can't deal, this is + ** a critical I/O error + */ + rc = ((failed & 0xff) == SQLITE_IOERR) ? failed2 : + SQLITE_IOERR_LOCK; + goto afp_end_lock; + } + }else{ + rc = failed; + } + } + if( failed ){ + rc = failed; + } + } + + if( rc==SQLITE_OK ){ + pFile->eFileLock = eFileLock; + pInode->eFileLock = eFileLock; + }else if( eFileLock==EXCLUSIVE_LOCK ){ + pFile->eFileLock = PENDING_LOCK; + pInode->eFileLock = PENDING_LOCK; + } + +afp_end_lock: + sqlite3_mutex_leave(pInode->pLockMutex); + OSTRACE(("LOCK %d %s %s (afp)\n", pFile->h, azFileLock(eFileLock), + rc==SQLITE_OK ? "ok" : "failed")); + return rc; +} + +/* +** Lower the locking level on file descriptor pFile to eFileLock. eFileLock +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +*/ +static int afpUnlock(sqlite3_file *id, int eFileLock) { + int rc = SQLITE_OK; + unixFile *pFile = (unixFile*)id; + unixInodeInfo *pInode; + afpLockingContext *context = (afpLockingContext *) pFile->lockingContext; + int skipShared = 0; +#ifdef SQLITE_TEST + int h = pFile->h; +#endif + + assert( pFile ); + OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (afp)\n", pFile->h, eFileLock, + pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared, + osGetpid(0))); + + assert( eFileLock<=SHARED_LOCK ); + if( pFile->eFileLock<=eFileLock ){ + return SQLITE_OK; + } + pInode = pFile->pInode; + sqlite3_mutex_enter(pInode->pLockMutex); + assert( pInode->nShared!=0 ); + if( pFile->eFileLock>SHARED_LOCK ){ + assert( pInode->eFileLock==pFile->eFileLock ); + SimulateIOErrorBenign(1); + SimulateIOError( h=(-1) ) + SimulateIOErrorBenign(0); + +#ifdef SQLITE_DEBUG + /* When reducing a lock such that other processes can start + ** reading the database file again, make sure that the + ** transaction counter was updated if any part of the database + ** file changed. If the transaction counter is not updated, + ** other connections to the same file might not realize that + ** the file has changed and hence might not know to flush their + ** cache. The use of a stale cache can lead to database corruption. + */ + assert( pFile->inNormalWrite==0 + || pFile->dbUpdate==0 + || pFile->transCntrChng==1 ); + pFile->inNormalWrite = 0; +#endif + + if( pFile->eFileLock==EXCLUSIVE_LOCK ){ + rc = afpSetLock(context->dbPath, pFile, SHARED_FIRST, SHARED_SIZE, 0); + if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1) ){ + /* only re-establish the shared lock if necessary */ + int sharedLockByte = SHARED_FIRST+pInode->sharedByte; + rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 1); + } else { + skipShared = 1; + } + } + if( rc==SQLITE_OK && pFile->eFileLock>=PENDING_LOCK ){ + rc = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0); + } + if( rc==SQLITE_OK && pFile->eFileLock>=RESERVED_LOCK && context->reserved ){ + rc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0); + if( !rc ){ + context->reserved = 0; + } + } + if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1)){ + pInode->eFileLock = SHARED_LOCK; + } + } + if( rc==SQLITE_OK && eFileLock==NO_LOCK ){ + + /* Decrement the shared lock counter. Release the lock using an + ** OS call only when all threads in this same process have released + ** the lock. + */ + unsigned long long sharedLockByte = SHARED_FIRST+pInode->sharedByte; + pInode->nShared--; + if( pInode->nShared==0 ){ + SimulateIOErrorBenign(1); + SimulateIOError( h=(-1) ) + SimulateIOErrorBenign(0); + if( !skipShared ){ + rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 0); + } + if( !rc ){ + pInode->eFileLock = NO_LOCK; + pFile->eFileLock = NO_LOCK; + } + } + if( rc==SQLITE_OK ){ + pInode->nLock--; + assert( pInode->nLock>=0 ); + if( pInode->nLock==0 ) closePendingFds(pFile); + } + } + + sqlite3_mutex_leave(pInode->pLockMutex); + if( rc==SQLITE_OK ){ + pFile->eFileLock = eFileLock; + } + return rc; +} + +/* +** Close a file & cleanup AFP specific locking context +*/ +static int afpClose(sqlite3_file *id) { + int rc = SQLITE_OK; + unixFile *pFile = (unixFile*)id; + assert( id!=0 ); + afpUnlock(id, NO_LOCK); + assert( unixFileMutexNotheld(pFile) ); + unixEnterMutex(); + if( pFile->pInode ){ + unixInodeInfo *pInode = pFile->pInode; + sqlite3_mutex_enter(pInode->pLockMutex); + if( pInode->nLock ){ + /* If there are outstanding locks, do not actually close the file just + ** yet because that would clear those locks. Instead, add the file + ** descriptor to pInode->aPending. It will be automatically closed when + ** the last lock is cleared. + */ + setPendingFd(pFile); + } + sqlite3_mutex_leave(pInode->pLockMutex); + } + releaseInodeInfo(pFile); + sqlite3_free(pFile->lockingContext); + rc = closeUnixFile(id); + unixLeaveMutex(); + return rc; +} + +#endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */ +/* +** The code above is the AFP lock implementation. The code is specific +** to MacOSX and does not work on other unix platforms. No alternative +** is available. If you don't compile for a mac, then the "unix-afp" +** VFS is not available. +** +********************* End of the AFP lock implementation ********************** +******************************************************************************/ + +/****************************************************************************** +*************************** Begin NFS Locking ********************************/ + +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE +/* + ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock + ** must be either NO_LOCK or SHARED_LOCK. + ** + ** If the locking level of the file descriptor is already at or below + ** the requested locking level, this routine is a no-op. + */ +static int nfsUnlock(sqlite3_file *id, int eFileLock){ + return posixUnlock(id, eFileLock, 1); +} + +#endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */ +/* +** The code above is the NFS lock implementation. The code is specific +** to MacOSX and does not work on other unix platforms. No alternative +** is available. +** +********************* End of the NFS lock implementation ********************** +******************************************************************************/ + +/****************************************************************************** +**************** Non-locking sqlite3_file methods ***************************** +** +** The next division contains implementations for all methods of the +** sqlite3_file object other than the locking methods. The locking +** methods were defined in divisions above (one locking method per +** division). Those methods that are common to all locking modes +** are gather together into this division. +*/ + +/* +** Seek to the offset passed as the second argument, then read cnt +** bytes into pBuf. Return the number of bytes actually read. +** +** To avoid stomping the errno value on a failed read the lastErrno value +** is set before returning. +*/ +static int seekAndRead(unixFile *id, sqlite3_int64 offset, void *pBuf, int cnt){ + int got; + int prior = 0; +#if (!defined(USE_PREAD) && !defined(USE_PREAD64)) + i64 newOffset; +#endif + TIMER_START; + assert( cnt==(cnt&0x1ffff) ); + assert( id->h>2 ); + do{ +#if defined(USE_PREAD) + got = osPread(id->h, pBuf, cnt, offset); + SimulateIOError( got = -1 ); +#elif defined(USE_PREAD64) + got = osPread64(id->h, pBuf, cnt, offset); + SimulateIOError( got = -1 ); +#else + newOffset = lseek(id->h, offset, SEEK_SET); + SimulateIOError( newOffset = -1 ); + if( newOffset<0 ){ + storeLastErrno((unixFile*)id, errno); + return -1; + } + got = osRead(id->h, pBuf, cnt); +#endif + if( got==cnt ) break; + if( got<0 ){ + if( errno==EINTR ){ got = 1; continue; } + prior = 0; + storeLastErrno((unixFile*)id, errno); + break; + }else if( got>0 ){ + cnt -= got; + offset += got; + prior += got; + pBuf = (void*)(got + (char*)pBuf); + } + }while( got>0 ); + TIMER_END; + OSTRACE(("READ %-3d %5d %7lld %llu\n", + id->h, got+prior, offset-prior, TIMER_ELAPSED)); + return got+prior; +} + +/* +** Read data from a file into a buffer. Return SQLITE_OK if all +** bytes were read successfully and SQLITE_IOERR if anything goes +** wrong. +*/ +static int unixRead( + sqlite3_file *id, + void *pBuf, + int amt, + sqlite3_int64 offset +){ + unixFile *pFile = (unixFile *)id; + int got; + assert( id ); + assert( offset>=0 ); + assert( amt>0 ); + + /* If this is a database file (not a journal, super-journal or temp + ** file), the bytes in the locking range should never be read or written. */ +#if 0 + assert( pFile->pPreallocatedUnused==0 + || offset>=PENDING_BYTE+512 + || offset+amt<=PENDING_BYTE + ); +#endif + +#if SQLITE_MAX_MMAP_SIZE>0 + /* Deal with as much of this read request as possible by transfering + ** data from the memory mapping using memcpy(). */ + if( offsetmmapSize ){ + if( offset+amt <= pFile->mmapSize ){ + memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt); + return SQLITE_OK; + }else{ + int nCopy = pFile->mmapSize - offset; + memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy); + pBuf = &((u8 *)pBuf)[nCopy]; + amt -= nCopy; + offset += nCopy; + } + } +#endif + + got = seekAndRead(pFile, offset, pBuf, amt); + if( got==amt ){ + return SQLITE_OK; + }else if( got<0 ){ + /* pFile->lastErrno has been set by seekAndRead(). + ** Usually we return SQLITE_IOERR_READ here, though for some + ** kinds of errors we return SQLITE_IOERR_CORRUPTFS. The + ** SQLITE_IOERR_CORRUPTFS will be converted into SQLITE_CORRUPT + ** prior to returning to the application by the sqlite3ApiExit() + ** routine. + */ + switch( pFile->lastErrno ){ + case ERANGE: + case EIO: +#ifdef ENXIO + case ENXIO: +#endif +#ifdef EDEVERR + case EDEVERR: +#endif + return SQLITE_IOERR_CORRUPTFS; + } + return SQLITE_IOERR_READ; + }else{ + storeLastErrno(pFile, 0); /* not a system error */ + /* Unread parts of the buffer must be zero-filled */ + memset(&((char*)pBuf)[got], 0, amt-got); + return SQLITE_IOERR_SHORT_READ; + } +} + +/* +** Attempt to seek the file-descriptor passed as the first argument to +** absolute offset iOff, then attempt to write nBuf bytes of data from +** pBuf to it. If an error occurs, return -1 and set *piErrno. Otherwise, +** return the actual number of bytes written (which may be less than +** nBuf). +*/ +static int seekAndWriteFd( + int fd, /* File descriptor to write to */ + i64 iOff, /* File offset to begin writing at */ + const void *pBuf, /* Copy data from this buffer to the file */ + int nBuf, /* Size of buffer pBuf in bytes */ + int *piErrno /* OUT: Error number if error occurs */ +){ + int rc = 0; /* Value returned by system call */ + + assert( nBuf==(nBuf&0x1ffff) ); + assert( fd>2 ); + assert( piErrno!=0 ); + nBuf &= 0x1ffff; + TIMER_START; + +#if defined(USE_PREAD) + do{ rc = (int)osPwrite(fd, pBuf, nBuf, iOff); }while( rc<0 && errno==EINTR ); +#elif defined(USE_PREAD64) + do{ rc = (int)osPwrite64(fd, pBuf, nBuf, iOff);}while( rc<0 && errno==EINTR); +#else + do{ + i64 iSeek = lseek(fd, iOff, SEEK_SET); + SimulateIOError( iSeek = -1 ); + if( iSeek<0 ){ + rc = -1; + break; + } + rc = osWrite(fd, pBuf, nBuf); + }while( rc<0 && errno==EINTR ); +#endif + + TIMER_END; + OSTRACE(("WRITE %-3d %5d %7lld %llu\n", fd, rc, iOff, TIMER_ELAPSED)); + + if( rc<0 ) *piErrno = errno; + return rc; +} + + +/* +** Seek to the offset in id->offset then read cnt bytes into pBuf. +** Return the number of bytes actually read. Update the offset. +** +** To avoid stomping the errno value on a failed write the lastErrno value +** is set before returning. +*/ +static int seekAndWrite(unixFile *id, i64 offset, const void *pBuf, int cnt){ + return seekAndWriteFd(id->h, offset, pBuf, cnt, &id->lastErrno); +} + + +/* +** Write data from a buffer into a file. Return SQLITE_OK on success +** or some other error code on failure. +*/ +static int unixWrite( + sqlite3_file *id, + const void *pBuf, + int amt, + sqlite3_int64 offset +){ + unixFile *pFile = (unixFile*)id; + int wrote = 0; + assert( id ); + assert( amt>0 ); + + /* If this is a database file (not a journal, super-journal or temp + ** file), the bytes in the locking range should never be read or written. */ +#if 0 + assert( pFile->pPreallocatedUnused==0 + || offset>=PENDING_BYTE+512 + || offset+amt<=PENDING_BYTE + ); +#endif + +#ifdef SQLITE_DEBUG + /* If we are doing a normal write to a database file (as opposed to + ** doing a hot-journal rollback or a write to some file other than a + ** normal database file) then record the fact that the database + ** has changed. If the transaction counter is modified, record that + ** fact too. + */ + if( pFile->inNormalWrite ){ + pFile->dbUpdate = 1; /* The database has been modified */ + if( offset<=24 && offset+amt>=27 ){ + int rc; + char oldCntr[4]; + SimulateIOErrorBenign(1); + rc = seekAndRead(pFile, 24, oldCntr, 4); + SimulateIOErrorBenign(0); + if( rc!=4 || memcmp(oldCntr, &((char*)pBuf)[24-offset], 4)!=0 ){ + pFile->transCntrChng = 1; /* The transaction counter has changed */ + } + } + } +#endif + +#if defined(SQLITE_MMAP_READWRITE) && SQLITE_MAX_MMAP_SIZE>0 + /* Deal with as much of this write request as possible by transfering + ** data from the memory mapping using memcpy(). */ + if( offsetmmapSize ){ + if( offset+amt <= pFile->mmapSize ){ + memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt); + return SQLITE_OK; + }else{ + int nCopy = pFile->mmapSize - offset; + memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy); + pBuf = &((u8 *)pBuf)[nCopy]; + amt -= nCopy; + offset += nCopy; + } + } +#endif + + while( (wrote = seekAndWrite(pFile, offset, pBuf, amt))0 ){ + amt -= wrote; + offset += wrote; + pBuf = &((char*)pBuf)[wrote]; + } + SimulateIOError(( wrote=(-1), amt=1 )); + SimulateDiskfullError(( wrote=0, amt=1 )); + + if( amt>wrote ){ + if( wrote<0 && pFile->lastErrno!=ENOSPC ){ + /* lastErrno set by seekAndWrite */ + return SQLITE_IOERR_WRITE; + }else{ + storeLastErrno(pFile, 0); /* not a system error */ + return SQLITE_FULL; + } + } + + return SQLITE_OK; +} + +#ifdef SQLITE_TEST +/* +** Count the number of fullsyncs and normal syncs. This is used to test +** that syncs and fullsyncs are occurring at the right times. +*/ +SQLITE_API int sqlite3_sync_count = 0; +SQLITE_API int sqlite3_fullsync_count = 0; +#endif + +/* +** We do not trust systems to provide a working fdatasync(). Some do. +** Others do no. To be safe, we will stick with the (slightly slower) +** fsync(). If you know that your system does support fdatasync() correctly, +** then simply compile with -Dfdatasync=fdatasync or -DHAVE_FDATASYNC +*/ +#if !defined(fdatasync) && !HAVE_FDATASYNC +# define fdatasync fsync +#endif + +/* +** Define HAVE_FULLFSYNC to 0 or 1 depending on whether or not +** the F_FULLFSYNC macro is defined. F_FULLFSYNC is currently +** only available on Mac OS X. But that could change. +*/ +#ifdef F_FULLFSYNC +# define HAVE_FULLFSYNC 1 +#else +# define HAVE_FULLFSYNC 0 +#endif + + +/* +** The fsync() system call does not work as advertised on many +** unix systems. The following procedure is an attempt to make +** it work better. +** +** The SQLITE_NO_SYNC macro disables all fsync()s. This is useful +** for testing when we want to run through the test suite quickly. +** You are strongly advised *not* to deploy with SQLITE_NO_SYNC +** enabled, however, since with SQLITE_NO_SYNC enabled, an OS crash +** or power failure will likely corrupt the database file. +** +** SQLite sets the dataOnly flag if the size of the file is unchanged. +** The idea behind dataOnly is that it should only write the file content +** to disk, not the inode. We only set dataOnly if the file size is +** unchanged since the file size is part of the inode. However, +** Ted Ts'o tells us that fdatasync() will also write the inode if the +** file size has changed. The only real difference between fdatasync() +** and fsync(), Ted tells us, is that fdatasync() will not flush the +** inode if the mtime or owner or other inode attributes have changed. +** We only care about the file size, not the other file attributes, so +** as far as SQLite is concerned, an fdatasync() is always adequate. +** So, we always use fdatasync() if it is available, regardless of +** the value of the dataOnly flag. +*/ +static int full_fsync(int fd, int fullSync, int dataOnly){ + int rc; + + /* The following "ifdef/elif/else/" block has the same structure as + ** the one below. It is replicated here solely to avoid cluttering + ** up the real code with the UNUSED_PARAMETER() macros. + */ +#ifdef SQLITE_NO_SYNC + UNUSED_PARAMETER(fd); + UNUSED_PARAMETER(fullSync); + UNUSED_PARAMETER(dataOnly); +#elif HAVE_FULLFSYNC + UNUSED_PARAMETER(dataOnly); +#else + UNUSED_PARAMETER(fullSync); + UNUSED_PARAMETER(dataOnly); +#endif + + /* Record the number of times that we do a normal fsync() and + ** FULLSYNC. This is used during testing to verify that this procedure + ** gets called with the correct arguments. + */ +#ifdef SQLITE_TEST + if( fullSync ) sqlite3_fullsync_count++; + sqlite3_sync_count++; +#endif + + /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a + ** no-op. But go ahead and call fstat() to validate the file + ** descriptor as we need a method to provoke a failure during + ** coverate testing. + */ +#ifdef SQLITE_NO_SYNC + { + struct stat buf; + rc = osFstat(fd, &buf); + } +#elif HAVE_FULLFSYNC + if( fullSync ){ + rc = osFcntl(fd, F_FULLFSYNC, 0); + }else{ + rc = 1; + } + /* If the FULLFSYNC failed, fall back to attempting an fsync(). + ** It shouldn't be possible for fullfsync to fail on the local + ** file system (on OSX), so failure indicates that FULLFSYNC + ** isn't supported for this file system. So, attempt an fsync + ** and (for now) ignore the overhead of a superfluous fcntl call. + ** It'd be better to detect fullfsync support once and avoid + ** the fcntl call every time sync is called. + */ + if( rc ) rc = fsync(fd); + +#elif defined(__APPLE__) + /* fdatasync() on HFS+ doesn't yet flush the file size if it changed correctly + ** so currently we default to the macro that redefines fdatasync to fsync + */ + rc = fsync(fd); +#else + rc = fdatasync(fd); +#if OS_VXWORKS + if( rc==-1 && errno==ENOTSUP ){ + rc = fsync(fd); + } +#endif /* OS_VXWORKS */ +#endif /* ifdef SQLITE_NO_SYNC elif HAVE_FULLFSYNC */ + + if( OS_VXWORKS && rc!= -1 ){ + rc = 0; + } + return rc; +} + +/* +** Open a file descriptor to the directory containing file zFilename. +** If successful, *pFd is set to the opened file descriptor and +** SQLITE_OK is returned. If an error occurs, either SQLITE_NOMEM +** or SQLITE_CANTOPEN is returned and *pFd is set to an undefined +** value. +** +** The directory file descriptor is used for only one thing - to +** fsync() a directory to make sure file creation and deletion events +** are flushed to disk. Such fsyncs are not needed on newer +** journaling filesystems, but are required on older filesystems. +** +** This routine can be overridden using the xSetSysCall interface. +** The ability to override this routine was added in support of the +** chromium sandbox. Opening a directory is a security risk (we are +** told) so making it overrideable allows the chromium sandbox to +** replace this routine with a harmless no-op. To make this routine +** a no-op, replace it with a stub that returns SQLITE_OK but leaves +** *pFd set to a negative number. +** +** If SQLITE_OK is returned, the caller is responsible for closing +** the file descriptor *pFd using close(). +*/ +static int openDirectory(const char *zFilename, int *pFd){ + int ii; + int fd = -1; + char zDirname[MAX_PATHNAME+1]; + + sqlite3_snprintf(MAX_PATHNAME, zDirname, "%s", zFilename); + for(ii=(int)strlen(zDirname); ii>0 && zDirname[ii]!='/'; ii--); + if( ii>0 ){ + zDirname[ii] = '\0'; + }else{ + if( zDirname[0]!='/' ) zDirname[0] = '.'; + zDirname[1] = 0; + } + fd = robust_open(zDirname, O_RDONLY|O_BINARY, 0); + if( fd>=0 ){ + OSTRACE(("OPENDIR %-3d %s\n", fd, zDirname)); + } + *pFd = fd; + if( fd>=0 ) return SQLITE_OK; + return unixLogError(SQLITE_CANTOPEN_BKPT, "openDirectory", zDirname); +} + +/* +** Make sure all writes to a particular file are committed to disk. +** +** If dataOnly==0 then both the file itself and its metadata (file +** size, access time, etc) are synced. If dataOnly!=0 then only the +** file data is synced. +** +** Under Unix, also make sure that the directory entry for the file +** has been created by fsync-ing the directory that contains the file. +** If we do not do this and we encounter a power failure, the directory +** entry for the journal might not exist after we reboot. The next +** SQLite to access the file will not know that the journal exists (because +** the directory entry for the journal was never created) and the transaction +** will not roll back - possibly leading to database corruption. +*/ +static int unixSync(sqlite3_file *id, int flags){ + int rc; + unixFile *pFile = (unixFile*)id; + + int isDataOnly = (flags&SQLITE_SYNC_DATAONLY); + int isFullsync = (flags&0x0F)==SQLITE_SYNC_FULL; + + /* Check that one of SQLITE_SYNC_NORMAL or FULL was passed */ + assert((flags&0x0F)==SQLITE_SYNC_NORMAL + || (flags&0x0F)==SQLITE_SYNC_FULL + ); + + /* Unix cannot, but some systems may return SQLITE_FULL from here. This + ** line is to test that doing so does not cause any problems. + */ + SimulateDiskfullError( return SQLITE_FULL ); + + assert( pFile ); + OSTRACE(("SYNC %-3d\n", pFile->h)); + rc = full_fsync(pFile->h, isFullsync, isDataOnly); + SimulateIOError( rc=1 ); + if( rc ){ + storeLastErrno(pFile, errno); + return unixLogError(SQLITE_IOERR_FSYNC, "full_fsync", pFile->zPath); + } + + /* Also fsync the directory containing the file if the DIRSYNC flag + ** is set. This is a one-time occurrence. Many systems (examples: AIX) + ** are unable to fsync a directory, so ignore errors on the fsync. + */ + if( pFile->ctrlFlags & UNIXFILE_DIRSYNC ){ + int dirfd; + OSTRACE(("DIRSYNC %s (have_fullfsync=%d fullsync=%d)\n", pFile->zPath, + HAVE_FULLFSYNC, isFullsync)); + rc = osOpenDirectory(pFile->zPath, &dirfd); + if( rc==SQLITE_OK ){ + full_fsync(dirfd, 0, 0); + robust_close(pFile, dirfd, __LINE__); + }else{ + assert( rc==SQLITE_CANTOPEN ); + rc = SQLITE_OK; + } + pFile->ctrlFlags &= ~UNIXFILE_DIRSYNC; + } + return rc; +} + +/* +** Truncate an open file to a specified size +*/ +static int unixTruncate(sqlite3_file *id, i64 nByte){ + unixFile *pFile = (unixFile *)id; + int rc; + assert( pFile ); + SimulateIOError( return SQLITE_IOERR_TRUNCATE ); + + /* If the user has configured a chunk-size for this file, truncate the + ** file so that it consists of an integer number of chunks (i.e. the + ** actual file size after the operation may be larger than the requested + ** size). + */ + if( pFile->szChunk>0 ){ + nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk; + } + + rc = robust_ftruncate(pFile->h, nByte); + if( rc ){ + storeLastErrno(pFile, errno); + return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath); + }else{ +#ifdef SQLITE_DEBUG + /* If we are doing a normal write to a database file (as opposed to + ** doing a hot-journal rollback or a write to some file other than a + ** normal database file) and we truncate the file to zero length, + ** that effectively updates the change counter. This might happen + ** when restoring a database using the backup API from a zero-length + ** source. + */ + if( pFile->inNormalWrite && nByte==0 ){ + pFile->transCntrChng = 1; + } +#endif + +#if SQLITE_MAX_MMAP_SIZE>0 + /* If the file was just truncated to a size smaller than the currently + ** mapped region, reduce the effective mapping size as well. SQLite will + ** use read() and write() to access data beyond this point from now on. + */ + if( nBytemmapSize ){ + pFile->mmapSize = nByte; + } +#endif + + return SQLITE_OK; + } +} + +/* +** Determine the current size of a file in bytes +*/ +static int unixFileSize(sqlite3_file *id, i64 *pSize){ + int rc; + struct stat buf; + assert( id ); + rc = osFstat(((unixFile*)id)->h, &buf); + SimulateIOError( rc=1 ); + if( rc!=0 ){ + storeLastErrno((unixFile*)id, errno); + return SQLITE_IOERR_FSTAT; + } + *pSize = buf.st_size; + + /* When opening a zero-size database, the findInodeInfo() procedure + ** writes a single byte into that file in order to work around a bug + ** in the OS-X msdos filesystem. In order to avoid problems with upper + ** layers, we need to report this file size as zero even though it is + ** really 1. Ticket #3260. + */ + if( *pSize==1 ) *pSize = 0; + + + return SQLITE_OK; +} + +#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) +/* +** Handler for proxy-locking file-control verbs. Defined below in the +** proxying locking division. +*/ +static int proxyFileControl(sqlite3_file*,int,void*); +#endif + +/* +** This function is called to handle the SQLITE_FCNTL_SIZE_HINT +** file-control operation. Enlarge the database to nBytes in size +** (rounded up to the next chunk-size). If the database is already +** nBytes or larger, this routine is a no-op. +*/ +static int fcntlSizeHint(unixFile *pFile, i64 nByte){ + if( pFile->szChunk>0 ){ + i64 nSize; /* Required file size */ + struct stat buf; /* Used to hold return values of fstat() */ + + if( osFstat(pFile->h, &buf) ){ + return SQLITE_IOERR_FSTAT; + } + + nSize = ((nByte+pFile->szChunk-1) / pFile->szChunk) * pFile->szChunk; + if( nSize>(i64)buf.st_size ){ + +#if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE + /* The code below is handling the return value of osFallocate() + ** correctly. posix_fallocate() is defined to "returns zero on success, + ** or an error number on failure". See the manpage for details. */ + int err; + do{ + err = osFallocate(pFile->h, buf.st_size, nSize-buf.st_size); + }while( err==EINTR ); + if( err && err!=EINVAL ) return SQLITE_IOERR_WRITE; +#else + /* If the OS does not have posix_fallocate(), fake it. Write a + ** single byte to the last byte in each block that falls entirely + ** within the extended region. Then, if required, a single byte + ** at offset (nSize-1), to set the size of the file correctly. + ** This is a similar technique to that used by glibc on systems + ** that do not have a real fallocate() call. + */ + int nBlk = buf.st_blksize; /* File-system block size */ + int nWrite = 0; /* Number of bytes written by seekAndWrite */ + i64 iWrite; /* Next offset to write to */ + + iWrite = (buf.st_size/nBlk)*nBlk + nBlk - 1; + assert( iWrite>=buf.st_size ); + assert( ((iWrite+1)%nBlk)==0 ); + for(/*no-op*/; iWrite=nSize ) iWrite = nSize - 1; + nWrite = seekAndWrite(pFile, iWrite, "", 1); + if( nWrite!=1 ) return SQLITE_IOERR_WRITE; + } +#endif + } + } + +#if SQLITE_MAX_MMAP_SIZE>0 + if( pFile->mmapSizeMax>0 && nByte>pFile->mmapSize ){ + int rc; + if( pFile->szChunk<=0 ){ + if( robust_ftruncate(pFile->h, nByte) ){ + storeLastErrno(pFile, errno); + return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath); + } + } + + rc = unixMapfile(pFile, nByte); + return rc; + } +#endif + + return SQLITE_OK; +} + +/* +** If *pArg is initially negative then this is a query. Set *pArg to +** 1 or 0 depending on whether or not bit mask of pFile->ctrlFlags is set. +** +** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags. +*/ +static void unixModeBit(unixFile *pFile, unsigned char mask, int *pArg){ + if( *pArg<0 ){ + *pArg = (pFile->ctrlFlags & mask)!=0; + }else if( (*pArg)==0 ){ + pFile->ctrlFlags &= ~mask; + }else{ + pFile->ctrlFlags |= mask; + } +} + +/* Forward declaration */ +static int unixGetTempname(int nBuf, char *zBuf); +#ifndef SQLITE_OMIT_WAL + static int unixFcntlExternalReader(unixFile*, int*); +#endif + +/* +** Information and control of an open file handle. +*/ +static int unixFileControl(sqlite3_file *id, int op, void *pArg){ + unixFile *pFile = (unixFile*)id; + switch( op ){ +#if defined(__linux__) && defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE) + case SQLITE_FCNTL_BEGIN_ATOMIC_WRITE: { + int rc = osIoctl(pFile->h, F2FS_IOC_START_ATOMIC_WRITE); + return rc ? SQLITE_IOERR_BEGIN_ATOMIC : SQLITE_OK; + } + case SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: { + int rc = osIoctl(pFile->h, F2FS_IOC_COMMIT_ATOMIC_WRITE); + return rc ? SQLITE_IOERR_COMMIT_ATOMIC : SQLITE_OK; + } + case SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE: { + int rc = osIoctl(pFile->h, F2FS_IOC_ABORT_VOLATILE_WRITE); + return rc ? SQLITE_IOERR_ROLLBACK_ATOMIC : SQLITE_OK; + } +#endif /* __linux__ && SQLITE_ENABLE_BATCH_ATOMIC_WRITE */ + + case SQLITE_FCNTL_LOCKSTATE: { + *(int*)pArg = pFile->eFileLock; + return SQLITE_OK; + } + case SQLITE_FCNTL_LAST_ERRNO: { + *(int*)pArg = pFile->lastErrno; + return SQLITE_OK; + } + case SQLITE_FCNTL_CHUNK_SIZE: { + pFile->szChunk = *(int *)pArg; + return SQLITE_OK; + } + case SQLITE_FCNTL_SIZE_HINT: { + int rc; + SimulateIOErrorBenign(1); + rc = fcntlSizeHint(pFile, *(i64 *)pArg); + SimulateIOErrorBenign(0); + return rc; + } + case SQLITE_FCNTL_PERSIST_WAL: { + unixModeBit(pFile, UNIXFILE_PERSIST_WAL, (int*)pArg); + return SQLITE_OK; + } + case SQLITE_FCNTL_POWERSAFE_OVERWRITE: { + unixModeBit(pFile, UNIXFILE_PSOW, (int*)pArg); + return SQLITE_OK; + } + case SQLITE_FCNTL_VFSNAME: { + *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName); + return SQLITE_OK; + } + case SQLITE_FCNTL_TEMPFILENAME: { + char *zTFile = sqlite3_malloc64( pFile->pVfs->mxPathname ); + if( zTFile ){ + unixGetTempname(pFile->pVfs->mxPathname, zTFile); + *(char**)pArg = zTFile; + } + return SQLITE_OK; + } + case SQLITE_FCNTL_HAS_MOVED: { + *(int*)pArg = fileHasMoved(pFile); + return SQLITE_OK; + } +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT + case SQLITE_FCNTL_LOCK_TIMEOUT: { + int iOld = pFile->iBusyTimeout; + pFile->iBusyTimeout = *(int*)pArg; + *(int*)pArg = iOld; + return SQLITE_OK; + } +#endif +#if SQLITE_MAX_MMAP_SIZE>0 + case SQLITE_FCNTL_MMAP_SIZE: { + i64 newLimit = *(i64*)pArg; + int rc = SQLITE_OK; + if( newLimit>sqlite3GlobalConfig.mxMmap ){ + newLimit = sqlite3GlobalConfig.mxMmap; + } + + /* The value of newLimit may be eventually cast to (size_t) and passed + ** to mmap(). Restrict its value to 2GB if (size_t) is not at least a + ** 64-bit type. */ + if( newLimit>0 && sizeof(size_t)<8 ){ + newLimit = (newLimit & 0x7FFFFFFF); + } + + *(i64*)pArg = pFile->mmapSizeMax; + if( newLimit>=0 && newLimit!=pFile->mmapSizeMax && pFile->nFetchOut==0 ){ + pFile->mmapSizeMax = newLimit; + if( pFile->mmapSize>0 ){ + unixUnmapfile(pFile); + rc = unixMapfile(pFile, -1); + } + } + return rc; + } +#endif +#ifdef SQLITE_DEBUG + /* The pager calls this method to signal that it has done + ** a rollback and that the database is therefore unchanged and + ** it hence it is OK for the transaction change counter to be + ** unchanged. + */ + case SQLITE_FCNTL_DB_UNCHANGED: { + ((unixFile*)id)->dbUpdate = 0; + return SQLITE_OK; + } +#endif +#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) + case SQLITE_FCNTL_SET_LOCKPROXYFILE: + case SQLITE_FCNTL_GET_LOCKPROXYFILE: { + return proxyFileControl(id,op,pArg); + } +#endif /* SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) */ + + case SQLITE_FCNTL_EXTERNAL_READER: { +#ifndef SQLITE_OMIT_WAL + return unixFcntlExternalReader((unixFile*)id, (int*)pArg); +#else + *(int*)pArg = 0; + return SQLITE_OK; +#endif + } + } + return SQLITE_NOTFOUND; +} + +/* +** If pFd->sectorSize is non-zero when this function is called, it is a +** no-op. Otherwise, the values of pFd->sectorSize and +** pFd->deviceCharacteristics are set according to the file-system +** characteristics. +** +** There are two versions of this function. One for QNX and one for all +** other systems. +*/ +#ifndef __QNXNTO__ +static void setDeviceCharacteristics(unixFile *pFd){ + assert( pFd->deviceCharacteristics==0 || pFd->sectorSize!=0 ); + if( pFd->sectorSize==0 ){ +#if defined(__linux__) && defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE) + int res; + u32 f = 0; + + /* Check for support for F2FS atomic batch writes. */ + res = osIoctl(pFd->h, F2FS_IOC_GET_FEATURES, &f); + if( res==0 && (f & F2FS_FEATURE_ATOMIC_WRITE) ){ + pFd->deviceCharacteristics = SQLITE_IOCAP_BATCH_ATOMIC; + } +#endif /* __linux__ && SQLITE_ENABLE_BATCH_ATOMIC_WRITE */ + + /* Set the POWERSAFE_OVERWRITE flag if requested. */ + if( pFd->ctrlFlags & UNIXFILE_PSOW ){ + pFd->deviceCharacteristics |= SQLITE_IOCAP_POWERSAFE_OVERWRITE; + } + + pFd->sectorSize = SQLITE_DEFAULT_SECTOR_SIZE; + } +} +#else +#include +#include +static void setDeviceCharacteristics(unixFile *pFile){ + if( pFile->sectorSize == 0 ){ + struct statvfs fsInfo; + + /* Set defaults for non-supported filesystems */ + pFile->sectorSize = SQLITE_DEFAULT_SECTOR_SIZE; + pFile->deviceCharacteristics = 0; + if( fstatvfs(pFile->h, &fsInfo) == -1 ) { + return; + } + + if( !strcmp(fsInfo.f_basetype, "tmp") ) { + pFile->sectorSize = fsInfo.f_bsize; + pFile->deviceCharacteristics = + SQLITE_IOCAP_ATOMIC4K | /* All ram filesystem writes are atomic */ + SQLITE_IOCAP_SAFE_APPEND | /* growing the file does not occur until + ** the write succeeds */ + SQLITE_IOCAP_SEQUENTIAL | /* The ram filesystem has no write behind + ** so it is ordered */ + 0; + }else if( strstr(fsInfo.f_basetype, "etfs") ){ + pFile->sectorSize = fsInfo.f_bsize; + pFile->deviceCharacteristics = + /* etfs cluster size writes are atomic */ + (pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) | + SQLITE_IOCAP_SAFE_APPEND | /* growing the file does not occur until + ** the write succeeds */ + SQLITE_IOCAP_SEQUENTIAL | /* The ram filesystem has no write behind + ** so it is ordered */ + 0; + }else if( !strcmp(fsInfo.f_basetype, "qnx6") ){ + pFile->sectorSize = fsInfo.f_bsize; + pFile->deviceCharacteristics = + SQLITE_IOCAP_ATOMIC | /* All filesystem writes are atomic */ + SQLITE_IOCAP_SAFE_APPEND | /* growing the file does not occur until + ** the write succeeds */ + SQLITE_IOCAP_SEQUENTIAL | /* The ram filesystem has no write behind + ** so it is ordered */ + 0; + }else if( !strcmp(fsInfo.f_basetype, "qnx4") ){ + pFile->sectorSize = fsInfo.f_bsize; + pFile->deviceCharacteristics = + /* full bitset of atomics from max sector size and smaller */ + ((pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) << 1) - 2 | + SQLITE_IOCAP_SEQUENTIAL | /* The ram filesystem has no write behind + ** so it is ordered */ + 0; + }else if( strstr(fsInfo.f_basetype, "dos") ){ + pFile->sectorSize = fsInfo.f_bsize; + pFile->deviceCharacteristics = + /* full bitset of atomics from max sector size and smaller */ + ((pFile->sectorSize / 512 * SQLITE_IOCAP_ATOMIC512) << 1) - 2 | + SQLITE_IOCAP_SEQUENTIAL | /* The ram filesystem has no write behind + ** so it is ordered */ + 0; + }else{ + pFile->deviceCharacteristics = + SQLITE_IOCAP_ATOMIC512 | /* blocks are atomic */ + SQLITE_IOCAP_SAFE_APPEND | /* growing the file does not occur until + ** the write succeeds */ + 0; + } + } + /* Last chance verification. If the sector size isn't a multiple of 512 + ** then it isn't valid.*/ + if( pFile->sectorSize % 512 != 0 ){ + pFile->deviceCharacteristics = 0; + pFile->sectorSize = SQLITE_DEFAULT_SECTOR_SIZE; + } +} +#endif + +/* +** Return the sector size in bytes of the underlying block device for +** the specified file. This is almost always 512 bytes, but may be +** larger for some devices. +** +** SQLite code assumes this function cannot fail. It also assumes that +** if two files are created in the same file-system directory (i.e. +** a database and its journal file) that the sector size will be the +** same for both. +*/ +static int unixSectorSize(sqlite3_file *id){ + unixFile *pFd = (unixFile*)id; + setDeviceCharacteristics(pFd); + return pFd->sectorSize; +} + +/* +** Return the device characteristics for the file. +** +** This VFS is set up to return SQLITE_IOCAP_POWERSAFE_OVERWRITE by default. +** However, that choice is controversial since technically the underlying +** file system does not always provide powersafe overwrites. (In other +** words, after a power-loss event, parts of the file that were never +** written might end up being altered.) However, non-PSOW behavior is very, +** very rare. And asserting PSOW makes a large reduction in the amount +** of required I/O for journaling, since a lot of padding is eliminated. +** Hence, while POWERSAFE_OVERWRITE is on by default, there is a file-control +** available to turn it off and URI query parameter available to turn it off. +*/ +static int unixDeviceCharacteristics(sqlite3_file *id){ + unixFile *pFd = (unixFile*)id; + setDeviceCharacteristics(pFd); + return pFd->deviceCharacteristics; +} + +#if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0 + +/* +** Return the system page size. +** +** This function should not be called directly by other code in this file. +** Instead, it should be called via macro osGetpagesize(). +*/ +static int unixGetpagesize(void){ +#if OS_VXWORKS + return 1024; +#elif defined(_BSD_SOURCE) + return getpagesize(); +#else + return (int)sysconf(_SC_PAGESIZE); +#endif +} + +#endif /* !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0 */ + +#ifndef SQLITE_OMIT_WAL + +/* +** Object used to represent an shared memory buffer. +** +** When multiple threads all reference the same wal-index, each thread +** has its own unixShm object, but they all point to a single instance +** of this unixShmNode object. In other words, each wal-index is opened +** only once per process. +** +** Each unixShmNode object is connected to a single unixInodeInfo object. +** We could coalesce this object into unixInodeInfo, but that would mean +** every open file that does not use shared memory (in other words, most +** open files) would have to carry around this extra information. So +** the unixInodeInfo object contains a pointer to this unixShmNode object +** and the unixShmNode object is created only when needed. +** +** unixMutexHeld() must be true when creating or destroying +** this object or while reading or writing the following fields: +** +** nRef +** +** The following fields are read-only after the object is created: +** +** hShm +** zFilename +** +** Either unixShmNode.pShmMutex must be held or unixShmNode.nRef==0 and +** unixMutexHeld() is true when reading or writing any other field +** in this structure. +*/ +struct unixShmNode { + unixInodeInfo *pInode; /* unixInodeInfo that owns this SHM node */ + sqlite3_mutex *pShmMutex; /* Mutex to access this object */ + char *zFilename; /* Name of the mmapped file */ + int hShm; /* Open file descriptor */ + int szRegion; /* Size of shared-memory regions */ + u16 nRegion; /* Size of array apRegion */ + u8 isReadonly; /* True if read-only */ + u8 isUnlocked; /* True if no DMS lock held */ + char **apRegion; /* Array of mapped shared-memory regions */ + int nRef; /* Number of unixShm objects pointing to this */ + unixShm *pFirst; /* All unixShm objects pointing to this */ + int aLock[SQLITE_SHM_NLOCK]; /* # shared locks on slot, -1==excl lock */ +#ifdef SQLITE_DEBUG + u8 exclMask; /* Mask of exclusive locks held */ + u8 sharedMask; /* Mask of shared locks held */ + u8 nextShmId; /* Next available unixShm.id value */ +#endif +}; + +/* +** Structure used internally by this VFS to record the state of an +** open shared memory connection. +** +** The following fields are initialized when this object is created and +** are read-only thereafter: +** +** unixShm.pShmNode +** unixShm.id +** +** All other fields are read/write. The unixShm.pShmNode->pShmMutex must +** be held while accessing any read/write fields. +*/ +struct unixShm { + unixShmNode *pShmNode; /* The underlying unixShmNode object */ + unixShm *pNext; /* Next unixShm with the same unixShmNode */ + u8 hasMutex; /* True if holding the unixShmNode->pShmMutex */ + u8 id; /* Id of this connection within its unixShmNode */ + u16 sharedMask; /* Mask of shared locks held */ + u16 exclMask; /* Mask of exclusive locks held */ +}; + +/* +** Constants used for locking +*/ +#define UNIX_SHM_BASE ((22+SQLITE_SHM_NLOCK)*4) /* first lock byte */ +#define UNIX_SHM_DMS (UNIX_SHM_BASE+SQLITE_SHM_NLOCK) /* deadman switch */ + +/* +** Use F_GETLK to check whether or not there are any readers with open +** wal-mode transactions in other processes on database file pFile. If +** no error occurs, return SQLITE_OK and set (*piOut) to 1 if there are +** such transactions, or 0 otherwise. If an error occurs, return an +** SQLite error code. The final value of *piOut is undefined in this +** case. +*/ +static int unixFcntlExternalReader(unixFile *pFile, int *piOut){ + int rc = SQLITE_OK; + *piOut = 0; + if( pFile->pShm){ + unixShmNode *pShmNode = pFile->pShm->pShmNode; + struct flock f; + + memset(&f, 0, sizeof(f)); + f.l_type = F_WRLCK; + f.l_whence = SEEK_SET; + f.l_start = UNIX_SHM_BASE + 3; + f.l_len = SQLITE_SHM_NLOCK - 3; + + sqlite3_mutex_enter(pShmNode->pShmMutex); + if( osFcntl(pShmNode->hShm, F_GETLK, &f)<0 ){ + rc = SQLITE_IOERR_LOCK; + }else{ + *piOut = (f.l_type!=F_UNLCK); + } + sqlite3_mutex_leave(pShmNode->pShmMutex); + } + + return rc; +} + + +/* +** Apply posix advisory locks for all bytes from ofst through ofst+n-1. +** +** Locks block if the mask is exactly UNIX_SHM_C and are non-blocking +** otherwise. +*/ +static int unixShmSystemLock( + unixFile *pFile, /* Open connection to the WAL file */ + int lockType, /* F_UNLCK, F_RDLCK, or F_WRLCK */ + int ofst, /* First byte of the locking range */ + int n /* Number of bytes to lock */ +){ + unixShmNode *pShmNode; /* Apply locks to this open shared-memory segment */ + struct flock f; /* The posix advisory locking structure */ + int rc = SQLITE_OK; /* Result code form fcntl() */ + + /* Access to the unixShmNode object is serialized by the caller */ + pShmNode = pFile->pInode->pShmNode; + assert( pShmNode->nRef==0 || sqlite3_mutex_held(pShmNode->pShmMutex) ); + assert( pShmNode->nRef>0 || unixMutexHeld() ); + + /* Shared locks never span more than one byte */ + assert( n==1 || lockType!=F_RDLCK ); + + /* Locks are within range */ + assert( n>=1 && n<=SQLITE_SHM_NLOCK ); + + if( pShmNode->hShm>=0 ){ + int res; + /* Initialize the locking parameters */ + f.l_type = lockType; + f.l_whence = SEEK_SET; + f.l_start = ofst; + f.l_len = n; + res = osSetPosixAdvisoryLock(pShmNode->hShm, &f, pFile); + if( res==-1 ){ +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT + rc = (pFile->iBusyTimeout ? SQLITE_BUSY_TIMEOUT : SQLITE_BUSY); +#else + rc = SQLITE_BUSY; +#endif + } + } + + /* Update the global lock state and do debug tracing */ +#ifdef SQLITE_DEBUG + { u16 mask; + OSTRACE(("SHM-LOCK ")); + mask = ofst>31 ? 0xffff : (1<<(ofst+n)) - (1<exclMask &= ~mask; + pShmNode->sharedMask &= ~mask; + }else if( lockType==F_RDLCK ){ + OSTRACE(("read-lock %d ok", ofst)); + pShmNode->exclMask &= ~mask; + pShmNode->sharedMask |= mask; + }else{ + assert( lockType==F_WRLCK ); + OSTRACE(("write-lock %d ok", ofst)); + pShmNode->exclMask |= mask; + pShmNode->sharedMask &= ~mask; + } + }else{ + if( lockType==F_UNLCK ){ + OSTRACE(("unlock %d failed", ofst)); + }else if( lockType==F_RDLCK ){ + OSTRACE(("read-lock failed")); + }else{ + assert( lockType==F_WRLCK ); + OSTRACE(("write-lock %d failed", ofst)); + } + } + OSTRACE((" - afterwards %03x,%03x\n", + pShmNode->sharedMask, pShmNode->exclMask)); + } +#endif + + return rc; +} + +/* +** Return the minimum number of 32KB shm regions that should be mapped at +** a time, assuming that each mapping must be an integer multiple of the +** current system page-size. +** +** Usually, this is 1. The exception seems to be systems that are configured +** to use 64KB pages - in this case each mapping must cover at least two +** shm regions. +*/ +static int unixShmRegionPerMap(void){ + int shmsz = 32*1024; /* SHM region size */ + int pgsz = osGetpagesize(); /* System page size */ + assert( ((pgsz-1)&pgsz)==0 ); /* Page size must be a power of 2 */ + if( pgszpInode->pShmNode; + assert( unixMutexHeld() ); + if( p && ALWAYS(p->nRef==0) ){ + int nShmPerMap = unixShmRegionPerMap(); + int i; + assert( p->pInode==pFd->pInode ); + sqlite3_mutex_free(p->pShmMutex); + for(i=0; inRegion; i+=nShmPerMap){ + if( p->hShm>=0 ){ + osMunmap(p->apRegion[i], p->szRegion); + }else{ + sqlite3_free(p->apRegion[i]); + } + } + sqlite3_free(p->apRegion); + if( p->hShm>=0 ){ + robust_close(pFd, p->hShm, __LINE__); + p->hShm = -1; + } + p->pInode->pShmNode = 0; + sqlite3_free(p); + } +} + +/* +** The DMS lock has not yet been taken on shm file pShmNode. Attempt to +** take it now. Return SQLITE_OK if successful, or an SQLite error +** code otherwise. +** +** If the DMS cannot be locked because this is a readonly_shm=1 +** connection and no other process already holds a lock, return +** SQLITE_READONLY_CANTINIT and set pShmNode->isUnlocked=1. +*/ +static int unixLockSharedMemory(unixFile *pDbFd, unixShmNode *pShmNode){ + struct flock lock; + int rc = SQLITE_OK; + + /* Use F_GETLK to determine the locks other processes are holding + ** on the DMS byte. If it indicates that another process is holding + ** a SHARED lock, then this process may also take a SHARED lock + ** and proceed with opening the *-shm file. + ** + ** Or, if no other process is holding any lock, then this process + ** is the first to open it. In this case take an EXCLUSIVE lock on the + ** DMS byte and truncate the *-shm file to zero bytes in size. Then + ** downgrade to a SHARED lock on the DMS byte. + ** + ** If another process is holding an EXCLUSIVE lock on the DMS byte, + ** return SQLITE_BUSY to the caller (it will try again). An earlier + ** version of this code attempted the SHARED lock at this point. But + ** this introduced a subtle race condition: if the process holding + ** EXCLUSIVE failed just before truncating the *-shm file, then this + ** process might open and use the *-shm file without truncating it. + ** And if the *-shm file has been corrupted by a power failure or + ** system crash, the database itself may also become corrupt. */ + lock.l_whence = SEEK_SET; + lock.l_start = UNIX_SHM_DMS; + lock.l_len = 1; + lock.l_type = F_WRLCK; + if( osFcntl(pShmNode->hShm, F_GETLK, &lock)!=0 ) { + rc = SQLITE_IOERR_LOCK; + }else if( lock.l_type==F_UNLCK ){ + if( pShmNode->isReadonly ){ + pShmNode->isUnlocked = 1; + rc = SQLITE_READONLY_CANTINIT; + }else{ + rc = unixShmSystemLock(pDbFd, F_WRLCK, UNIX_SHM_DMS, 1); + /* The first connection to attach must truncate the -shm file. We + ** truncate to 3 bytes (an arbitrary small number, less than the + ** -shm header size) rather than 0 as a system debugging aid, to + ** help detect if a -shm file truncation is legitimate or is the work + ** or a rogue process. */ + if( rc==SQLITE_OK && robust_ftruncate(pShmNode->hShm, 3) ){ + rc = unixLogError(SQLITE_IOERR_SHMOPEN,"ftruncate",pShmNode->zFilename); + } + } + }else if( lock.l_type==F_WRLCK ){ + rc = SQLITE_BUSY; + } + + if( rc==SQLITE_OK ){ + assert( lock.l_type==F_UNLCK || lock.l_type==F_RDLCK ); + rc = unixShmSystemLock(pDbFd, F_RDLCK, UNIX_SHM_DMS, 1); + } + return rc; +} + +/* +** Open a shared-memory area associated with open database file pDbFd. +** This particular implementation uses mmapped files. +** +** The file used to implement shared-memory is in the same directory +** as the open database file and has the same name as the open database +** file with the "-shm" suffix added. For example, if the database file +** is "/home/user1/config.db" then the file that is created and mmapped +** for shared memory will be called "/home/user1/config.db-shm". +** +** Another approach to is to use files in /dev/shm or /dev/tmp or an +** some other tmpfs mount. But if a file in a different directory +** from the database file is used, then differing access permissions +** or a chroot() might cause two different processes on the same +** database to end up using different files for shared memory - +** meaning that their memory would not really be shared - resulting +** in database corruption. Nevertheless, this tmpfs file usage +** can be enabled at compile-time using -DSQLITE_SHM_DIRECTORY="/dev/shm" +** or the equivalent. The use of the SQLITE_SHM_DIRECTORY compile-time +** option results in an incompatible build of SQLite; builds of SQLite +** that with differing SQLITE_SHM_DIRECTORY settings attempt to use the +** same database file at the same time, database corruption will likely +** result. The SQLITE_SHM_DIRECTORY compile-time option is considered +** "unsupported" and may go away in a future SQLite release. +** +** When opening a new shared-memory file, if no other instances of that +** file are currently open, in this process or in other processes, then +** the file must be truncated to zero length or have its header cleared. +** +** If the original database file (pDbFd) is using the "unix-excl" VFS +** that means that an exclusive lock is held on the database file and +** that no other processes are able to read or write the database. In +** that case, we do not really need shared memory. No shared memory +** file is created. The shared memory will be simulated with heap memory. +*/ +static int unixOpenSharedMemory(unixFile *pDbFd){ + struct unixShm *p = 0; /* The connection to be opened */ + struct unixShmNode *pShmNode; /* The underlying mmapped file */ + int rc = SQLITE_OK; /* Result code */ + unixInodeInfo *pInode; /* The inode of fd */ + char *zShm; /* Name of the file used for SHM */ + int nShmFilename; /* Size of the SHM filename in bytes */ + + /* Allocate space for the new unixShm object. */ + p = sqlite3_malloc64( sizeof(*p) ); + if( p==0 ) return SQLITE_NOMEM_BKPT; + memset(p, 0, sizeof(*p)); + assert( pDbFd->pShm==0 ); + + /* Check to see if a unixShmNode object already exists. Reuse an existing + ** one if present. Create a new one if necessary. + */ + assert( unixFileMutexNotheld(pDbFd) ); + unixEnterMutex(); + pInode = pDbFd->pInode; + pShmNode = pInode->pShmNode; + if( pShmNode==0 ){ + struct stat sStat; /* fstat() info for database file */ +#ifndef SQLITE_SHM_DIRECTORY + const char *zBasePath = pDbFd->zPath; +#endif + + /* Call fstat() to figure out the permissions on the database file. If + ** a new *-shm file is created, an attempt will be made to create it + ** with the same permissions. + */ + if( osFstat(pDbFd->h, &sStat) ){ + rc = SQLITE_IOERR_FSTAT; + goto shm_open_err; + } + +#ifdef SQLITE_SHM_DIRECTORY + nShmFilename = sizeof(SQLITE_SHM_DIRECTORY) + 31; +#else + nShmFilename = 6 + (int)strlen(zBasePath); +#endif + pShmNode = sqlite3_malloc64( sizeof(*pShmNode) + nShmFilename ); + if( pShmNode==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto shm_open_err; + } + memset(pShmNode, 0, sizeof(*pShmNode)+nShmFilename); + zShm = pShmNode->zFilename = (char*)&pShmNode[1]; +#ifdef SQLITE_SHM_DIRECTORY + sqlite3_snprintf(nShmFilename, zShm, + SQLITE_SHM_DIRECTORY "/sqlite-shm-%x-%x", + (u32)sStat.st_ino, (u32)sStat.st_dev); +#else + sqlite3_snprintf(nShmFilename, zShm, "%s-shm", zBasePath); + sqlite3FileSuffix3(pDbFd->zPath, zShm); +#endif + pShmNode->hShm = -1; + pDbFd->pInode->pShmNode = pShmNode; + pShmNode->pInode = pDbFd->pInode; + if( sqlite3GlobalConfig.bCoreMutex ){ + pShmNode->pShmMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST); + if( pShmNode->pShmMutex==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto shm_open_err; + } + } + + if( pInode->bProcessLock==0 ){ + if( 0==sqlite3_uri_boolean(pDbFd->zPath, "readonly_shm", 0) ){ + pShmNode->hShm = robust_open(zShm, O_RDWR|O_CREAT|O_NOFOLLOW, + (sStat.st_mode&0777)); + } + if( pShmNode->hShm<0 ){ + pShmNode->hShm = robust_open(zShm, O_RDONLY|O_NOFOLLOW, + (sStat.st_mode&0777)); + if( pShmNode->hShm<0 ){ + rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zShm); + goto shm_open_err; + } + pShmNode->isReadonly = 1; + } + + /* If this process is running as root, make sure that the SHM file + ** is owned by the same user that owns the original database. Otherwise, + ** the original owner will not be able to connect. + */ + robustFchown(pShmNode->hShm, sStat.st_uid, sStat.st_gid); + + rc = unixLockSharedMemory(pDbFd, pShmNode); + if( rc!=SQLITE_OK && rc!=SQLITE_READONLY_CANTINIT ) goto shm_open_err; + } + } + + /* Make the new connection a child of the unixShmNode */ + p->pShmNode = pShmNode; +#ifdef SQLITE_DEBUG + p->id = pShmNode->nextShmId++; +#endif + pShmNode->nRef++; + pDbFd->pShm = p; + unixLeaveMutex(); + + /* The reference count on pShmNode has already been incremented under + ** the cover of the unixEnterMutex() mutex and the pointer from the + ** new (struct unixShm) object to the pShmNode has been set. All that is + ** left to do is to link the new object into the linked list starting + ** at pShmNode->pFirst. This must be done while holding the + ** pShmNode->pShmMutex. + */ + sqlite3_mutex_enter(pShmNode->pShmMutex); + p->pNext = pShmNode->pFirst; + pShmNode->pFirst = p; + sqlite3_mutex_leave(pShmNode->pShmMutex); + return rc; + + /* Jump here on any error */ +shm_open_err: + unixShmPurge(pDbFd); /* This call frees pShmNode if required */ + sqlite3_free(p); + unixLeaveMutex(); + return rc; +} + +/* +** This function is called to obtain a pointer to region iRegion of the +** shared-memory associated with the database file fd. Shared-memory regions +** are numbered starting from zero. Each shared-memory region is szRegion +** bytes in size. +** +** If an error occurs, an error code is returned and *pp is set to NULL. +** +** Otherwise, if the bExtend parameter is 0 and the requested shared-memory +** region has not been allocated (by any client, including one running in a +** separate process), then *pp is set to NULL and SQLITE_OK returned. If +** bExtend is non-zero and the requested shared-memory region has not yet +** been allocated, it is allocated by this function. +** +** If the shared-memory region has already been allocated or is allocated by +** this call as described above, then it is mapped into this processes +** address space (if it is not already), *pp is set to point to the mapped +** memory and SQLITE_OK returned. +*/ +static int unixShmMap( + sqlite3_file *fd, /* Handle open on database file */ + int iRegion, /* Region to retrieve */ + int szRegion, /* Size of regions */ + int bExtend, /* True to extend file if necessary */ + void volatile **pp /* OUT: Mapped memory */ +){ + unixFile *pDbFd = (unixFile*)fd; + unixShm *p; + unixShmNode *pShmNode; + int rc = SQLITE_OK; + int nShmPerMap = unixShmRegionPerMap(); + int nReqRegion; + + /* If the shared-memory file has not yet been opened, open it now. */ + if( pDbFd->pShm==0 ){ + rc = unixOpenSharedMemory(pDbFd); + if( rc!=SQLITE_OK ) return rc; + } + + p = pDbFd->pShm; + pShmNode = p->pShmNode; + sqlite3_mutex_enter(pShmNode->pShmMutex); + if( pShmNode->isUnlocked ){ + rc = unixLockSharedMemory(pDbFd, pShmNode); + if( rc!=SQLITE_OK ) goto shmpage_out; + pShmNode->isUnlocked = 0; + } + assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 ); + assert( pShmNode->pInode==pDbFd->pInode ); + assert( pShmNode->hShm>=0 || pDbFd->pInode->bProcessLock==1 ); + assert( pShmNode->hShm<0 || pDbFd->pInode->bProcessLock==0 ); + + /* Minimum number of regions required to be mapped. */ + nReqRegion = ((iRegion+nShmPerMap) / nShmPerMap) * nShmPerMap; + + if( pShmNode->nRegionszRegion = szRegion; + + if( pShmNode->hShm>=0 ){ + /* The requested region is not mapped into this processes address space. + ** Check to see if it has been allocated (i.e. if the wal-index file is + ** large enough to contain the requested region). + */ + if( osFstat(pShmNode->hShm, &sStat) ){ + rc = SQLITE_IOERR_SHMSIZE; + goto shmpage_out; + } + + if( sStat.st_sizehShm, iPg*pgsz + pgsz-1,"",1,&x)!=1 ){ + const char *zFile = pShmNode->zFilename; + rc = unixLogError(SQLITE_IOERR_SHMSIZE, "write", zFile); + goto shmpage_out; + } + } + } + } + } + + /* Map the requested memory region into this processes address space. */ + apNew = (char **)sqlite3_realloc( + pShmNode->apRegion, nReqRegion*sizeof(char *) + ); + if( !apNew ){ + rc = SQLITE_IOERR_NOMEM_BKPT; + goto shmpage_out; + } + pShmNode->apRegion = apNew; + while( pShmNode->nRegionhShm>=0 ){ + pMem = osMmap(0, nMap, + pShmNode->isReadonly ? PROT_READ : PROT_READ|PROT_WRITE, + MAP_SHARED, pShmNode->hShm, szRegion*(i64)pShmNode->nRegion + ); + if( pMem==MAP_FAILED ){ + rc = unixLogError(SQLITE_IOERR_SHMMAP, "mmap", pShmNode->zFilename); + goto shmpage_out; + } + }else{ + pMem = sqlite3_malloc64(nMap); + if( pMem==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto shmpage_out; + } + memset(pMem, 0, nMap); + } + + for(i=0; iapRegion[pShmNode->nRegion+i] = &((char*)pMem)[szRegion*i]; + } + pShmNode->nRegion += nShmPerMap; + } + } + +shmpage_out: + if( pShmNode->nRegion>iRegion ){ + *pp = pShmNode->apRegion[iRegion]; + }else{ + *pp = 0; + } + if( pShmNode->isReadonly && rc==SQLITE_OK ) rc = SQLITE_READONLY; + sqlite3_mutex_leave(pShmNode->pShmMutex); + return rc; +} + +/* +** Check that the pShmNode->aLock[] array comports with the locking bitmasks +** held by each client. Return true if it does, or false otherwise. This +** is to be used in an assert(). e.g. +** +** assert( assertLockingArrayOk(pShmNode) ); +*/ +#ifdef SQLITE_DEBUG +static int assertLockingArrayOk(unixShmNode *pShmNode){ + unixShm *pX; + int aLock[SQLITE_SHM_NLOCK]; + assert( sqlite3_mutex_held(pShmNode->pShmMutex) ); + + memset(aLock, 0, sizeof(aLock)); + for(pX=pShmNode->pFirst; pX; pX=pX->pNext){ + int i; + for(i=0; iexclMask & (1<sharedMask & (1<=0 ); + aLock[i]++; + } + } + } + + assert( 0==memcmp(pShmNode->aLock, aLock, sizeof(aLock)) ); + return (memcmp(pShmNode->aLock, aLock, sizeof(aLock))==0); +} +#endif + +/* +** Change the lock state for a shared-memory segment. +** +** Note that the relationship between SHAREd and EXCLUSIVE locks is a little +** different here than in posix. In xShmLock(), one can go from unlocked +** to shared and back or from unlocked to exclusive and back. But one may +** not go from shared to exclusive or from exclusive to shared. +*/ +static int unixShmLock( + sqlite3_file *fd, /* Database file holding the shared memory */ + int ofst, /* First lock to acquire or release */ + int n, /* Number of locks to acquire or release */ + int flags /* What to do with the lock */ +){ + unixFile *pDbFd = (unixFile*)fd; /* Connection holding shared memory */ + unixShm *p; /* The shared memory being locked */ + unixShmNode *pShmNode; /* The underlying file iNode */ + int rc = SQLITE_OK; /* Result code */ + u16 mask; /* Mask of locks to take or release */ + int *aLock; + + p = pDbFd->pShm; + if( p==0 ) return SQLITE_IOERR_SHMLOCK; + pShmNode = p->pShmNode; + if( NEVER(pShmNode==0) ) return SQLITE_IOERR_SHMLOCK; + aLock = pShmNode->aLock; + + assert( pShmNode==pDbFd->pInode->pShmNode ); + assert( pShmNode->pInode==pDbFd->pInode ); + assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK ); + assert( n>=1 ); + assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED) + || flags==(SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE) + || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED) + || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE) ); + assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 ); + assert( pShmNode->hShm>=0 || pDbFd->pInode->bProcessLock==1 ); + assert( pShmNode->hShm<0 || pDbFd->pInode->bProcessLock==0 ); + + /* Check that, if this to be a blocking lock, no locks that occur later + ** in the following list than the lock being obtained are already held: + ** + ** 1. Checkpointer lock (ofst==1). + ** 2. Write lock (ofst==0). + ** 3. Read locks (ofst>=3 && ofstiBusyTimeout==0 || ( + (ofst!=2) /* not RECOVER */ + && (ofst!=1 || (p->exclMask|p->sharedMask)==0) + && (ofst!=0 || (p->exclMask|p->sharedMask)<3) + && (ofst<3 || (p->exclMask|p->sharedMask)<(1<1 || mask==(1<pShmMutex); + assert( assertLockingArrayOk(pShmNode) ); + if( flags & SQLITE_SHM_UNLOCK ){ + if( (p->exclMask|p->sharedMask) & mask ){ + int ii; + int bUnlock = 1; + + for(ii=ofst; ii((p->sharedMask & (1<sharedMask & (1<1 ); + aLock[ofst]--; + } + + /* Undo the local locks */ + if( rc==SQLITE_OK ){ + p->exclMask &= ~mask; + p->sharedMask &= ~mask; + } + } + }else if( flags & SQLITE_SHM_SHARED ){ + assert( n==1 ); + assert( (p->exclMask & (1<sharedMask & mask)==0 ){ + if( aLock[ofst]<0 ){ + rc = SQLITE_BUSY; + }else if( aLock[ofst]==0 ){ + rc = unixShmSystemLock(pDbFd, F_RDLCK, ofst+UNIX_SHM_BASE, n); + } + + /* Get the local shared locks */ + if( rc==SQLITE_OK ){ + p->sharedMask |= mask; + aLock[ofst]++; + } + } + }else{ + /* Make sure no sibling connections hold locks that will block this + ** lock. If any do, return SQLITE_BUSY right away. */ + int ii; + for(ii=ofst; iisharedMask & mask)==0 ); + if( ALWAYS((p->exclMask & (1<sharedMask & mask)==0 ); + p->exclMask |= mask; + for(ii=ofst; iipShmMutex); + OSTRACE(("SHM-LOCK shmid-%d, pid-%d got %03x,%03x\n", + p->id, osGetpid(0), p->sharedMask, p->exclMask)); + return rc; +} + +/* +** Implement a memory barrier or memory fence on shared memory. +** +** All loads and stores begun before the barrier must complete before +** any load or store begun after the barrier. +*/ +static void unixShmBarrier( + sqlite3_file *fd /* Database file holding the shared memory */ +){ + UNUSED_PARAMETER(fd); + sqlite3MemoryBarrier(); /* compiler-defined memory barrier */ + assert( fd->pMethods->xLock==nolockLock + || unixFileMutexNotheld((unixFile*)fd) + ); + unixEnterMutex(); /* Also mutex, for redundancy */ + unixLeaveMutex(); +} + +/* +** Close a connection to shared-memory. Delete the underlying +** storage if deleteFlag is true. +** +** If there is no shared memory associated with the connection then this +** routine is a harmless no-op. +*/ +static int unixShmUnmap( + sqlite3_file *fd, /* The underlying database file */ + int deleteFlag /* Delete shared-memory if true */ +){ + unixShm *p; /* The connection to be closed */ + unixShmNode *pShmNode; /* The underlying shared-memory file */ + unixShm **pp; /* For looping over sibling connections */ + unixFile *pDbFd; /* The underlying database file */ + + pDbFd = (unixFile*)fd; + p = pDbFd->pShm; + if( p==0 ) return SQLITE_OK; + pShmNode = p->pShmNode; + + assert( pShmNode==pDbFd->pInode->pShmNode ); + assert( pShmNode->pInode==pDbFd->pInode ); + + /* Remove connection p from the set of connections associated + ** with pShmNode */ + sqlite3_mutex_enter(pShmNode->pShmMutex); + for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){} + *pp = p->pNext; + + /* Free the connection p */ + sqlite3_free(p); + pDbFd->pShm = 0; + sqlite3_mutex_leave(pShmNode->pShmMutex); + + /* If pShmNode->nRef has reached 0, then close the underlying + ** shared-memory file, too */ + assert( unixFileMutexNotheld(pDbFd) ); + unixEnterMutex(); + assert( pShmNode->nRef>0 ); + pShmNode->nRef--; + if( pShmNode->nRef==0 ){ + if( deleteFlag && pShmNode->hShm>=0 ){ + osUnlink(pShmNode->zFilename); + } + unixShmPurge(pDbFd); + } + unixLeaveMutex(); + + return SQLITE_OK; +} + + +#else +# define unixShmMap 0 +# define unixShmLock 0 +# define unixShmBarrier 0 +# define unixShmUnmap 0 +#endif /* #ifndef SQLITE_OMIT_WAL */ + +#if SQLITE_MAX_MMAP_SIZE>0 +/* +** If it is currently memory mapped, unmap file pFd. +*/ +static void unixUnmapfile(unixFile *pFd){ + assert( pFd->nFetchOut==0 ); + if( pFd->pMapRegion ){ + osMunmap(pFd->pMapRegion, pFd->mmapSizeActual); + pFd->pMapRegion = 0; + pFd->mmapSize = 0; + pFd->mmapSizeActual = 0; + } +} + +/* +** Attempt to set the size of the memory mapping maintained by file +** descriptor pFd to nNew bytes. Any existing mapping is discarded. +** +** If successful, this function sets the following variables: +** +** unixFile.pMapRegion +** unixFile.mmapSize +** unixFile.mmapSizeActual +** +** If unsuccessful, an error message is logged via sqlite3_log() and +** the three variables above are zeroed. In this case SQLite should +** continue accessing the database using the xRead() and xWrite() +** methods. +*/ +static void unixRemapfile( + unixFile *pFd, /* File descriptor object */ + i64 nNew /* Required mapping size */ +){ + const char *zErr = "mmap"; + int h = pFd->h; /* File descriptor open on db file */ + u8 *pOrig = (u8 *)pFd->pMapRegion; /* Pointer to current file mapping */ + i64 nOrig = pFd->mmapSizeActual; /* Size of pOrig region in bytes */ + u8 *pNew = 0; /* Location of new mapping */ + int flags = PROT_READ; /* Flags to pass to mmap() */ + + assert( pFd->nFetchOut==0 ); + assert( nNew>pFd->mmapSize ); + assert( nNew<=pFd->mmapSizeMax ); + assert( nNew>0 ); + assert( pFd->mmapSizeActual>=pFd->mmapSize ); + assert( MAP_FAILED!=0 ); + +#ifdef SQLITE_MMAP_READWRITE + if( (pFd->ctrlFlags & UNIXFILE_RDONLY)==0 ) flags |= PROT_WRITE; +#endif + + if( pOrig ){ +#if HAVE_MREMAP + i64 nReuse = pFd->mmapSize; +#else + const int szSyspage = osGetpagesize(); + i64 nReuse = (pFd->mmapSize & ~(szSyspage-1)); +#endif + u8 *pReq = &pOrig[nReuse]; + + /* Unmap any pages of the existing mapping that cannot be reused. */ + if( nReuse!=nOrig ){ + osMunmap(pReq, nOrig-nReuse); + } + +#if HAVE_MREMAP + pNew = osMremap(pOrig, nReuse, nNew, MREMAP_MAYMOVE); + zErr = "mremap"; +#else + pNew = osMmap(pReq, nNew-nReuse, flags, MAP_SHARED, h, nReuse); + if( pNew!=MAP_FAILED ){ + if( pNew!=pReq ){ + osMunmap(pNew, nNew - nReuse); + pNew = 0; + }else{ + pNew = pOrig; + } + } +#endif + + /* The attempt to extend the existing mapping failed. Free it. */ + if( pNew==MAP_FAILED || pNew==0 ){ + osMunmap(pOrig, nReuse); + } + } + + /* If pNew is still NULL, try to create an entirely new mapping. */ + if( pNew==0 ){ + pNew = osMmap(0, nNew, flags, MAP_SHARED, h, 0); + } + + if( pNew==MAP_FAILED ){ + pNew = 0; + nNew = 0; + unixLogError(SQLITE_OK, zErr, pFd->zPath); + + /* If the mmap() above failed, assume that all subsequent mmap() calls + ** will probably fail too. Fall back to using xRead/xWrite exclusively + ** in this case. */ + pFd->mmapSizeMax = 0; + } + pFd->pMapRegion = (void *)pNew; + pFd->mmapSize = pFd->mmapSizeActual = nNew; +} + +/* +** Memory map or remap the file opened by file-descriptor pFd (if the file +** is already mapped, the existing mapping is replaced by the new). Or, if +** there already exists a mapping for this file, and there are still +** outstanding xFetch() references to it, this function is a no-op. +** +** If parameter nByte is non-negative, then it is the requested size of +** the mapping to create. Otherwise, if nByte is less than zero, then the +** requested size is the size of the file on disk. The actual size of the +** created mapping is either the requested size or the value configured +** using SQLITE_FCNTL_MMAP_LIMIT, whichever is smaller. +** +** SQLITE_OK is returned if no error occurs (even if the mapping is not +** recreated as a result of outstanding references) or an SQLite error +** code otherwise. +*/ +static int unixMapfile(unixFile *pFd, i64 nMap){ + assert( nMap>=0 || pFd->nFetchOut==0 ); + assert( nMap>0 || (pFd->mmapSize==0 && pFd->pMapRegion==0) ); + if( pFd->nFetchOut>0 ) return SQLITE_OK; + + if( nMap<0 ){ + struct stat statbuf; /* Low-level file information */ + if( osFstat(pFd->h, &statbuf) ){ + return SQLITE_IOERR_FSTAT; + } + nMap = statbuf.st_size; + } + if( nMap>pFd->mmapSizeMax ){ + nMap = pFd->mmapSizeMax; + } + + assert( nMap>0 || (pFd->mmapSize==0 && pFd->pMapRegion==0) ); + if( nMap!=pFd->mmapSize ){ + unixRemapfile(pFd, nMap); + } + + return SQLITE_OK; +} +#endif /* SQLITE_MAX_MMAP_SIZE>0 */ + +/* +** If possible, return a pointer to a mapping of file fd starting at offset +** iOff. The mapping must be valid for at least nAmt bytes. +** +** If such a pointer can be obtained, store it in *pp and return SQLITE_OK. +** Or, if one cannot but no error occurs, set *pp to 0 and return SQLITE_OK. +** Finally, if an error does occur, return an SQLite error code. The final +** value of *pp is undefined in this case. +** +** If this function does return a pointer, the caller must eventually +** release the reference by calling unixUnfetch(). +*/ +static int unixFetch(sqlite3_file *fd, i64 iOff, int nAmt, void **pp){ +#if SQLITE_MAX_MMAP_SIZE>0 + unixFile *pFd = (unixFile *)fd; /* The underlying database file */ +#endif + *pp = 0; + +#if SQLITE_MAX_MMAP_SIZE>0 + if( pFd->mmapSizeMax>0 ){ + if( pFd->pMapRegion==0 ){ + int rc = unixMapfile(pFd, -1); + if( rc!=SQLITE_OK ) return rc; + } + if( pFd->mmapSize >= iOff+nAmt ){ + *pp = &((u8 *)pFd->pMapRegion)[iOff]; + pFd->nFetchOut++; + } + } +#endif + return SQLITE_OK; +} + +/* +** If the third argument is non-NULL, then this function releases a +** reference obtained by an earlier call to unixFetch(). The second +** argument passed to this function must be the same as the corresponding +** argument that was passed to the unixFetch() invocation. +** +** Or, if the third argument is NULL, then this function is being called +** to inform the VFS layer that, according to POSIX, any existing mapping +** may now be invalid and should be unmapped. +*/ +static int unixUnfetch(sqlite3_file *fd, i64 iOff, void *p){ +#if SQLITE_MAX_MMAP_SIZE>0 + unixFile *pFd = (unixFile *)fd; /* The underlying database file */ + UNUSED_PARAMETER(iOff); + + /* If p==0 (unmap the entire file) then there must be no outstanding + ** xFetch references. Or, if p!=0 (meaning it is an xFetch reference), + ** then there must be at least one outstanding. */ + assert( (p==0)==(pFd->nFetchOut==0) ); + + /* If p!=0, it must match the iOff value. */ + assert( p==0 || p==&((u8 *)pFd->pMapRegion)[iOff] ); + + if( p ){ + pFd->nFetchOut--; + }else{ + unixUnmapfile(pFd); + } + + assert( pFd->nFetchOut>=0 ); +#else + UNUSED_PARAMETER(fd); + UNUSED_PARAMETER(p); + UNUSED_PARAMETER(iOff); +#endif + return SQLITE_OK; +} + +/* +** Here ends the implementation of all sqlite3_file methods. +** +********************** End sqlite3_file Methods ******************************* +******************************************************************************/ + +/* +** This division contains definitions of sqlite3_io_methods objects that +** implement various file locking strategies. It also contains definitions +** of "finder" functions. A finder-function is used to locate the appropriate +** sqlite3_io_methods object for a particular database file. The pAppData +** field of the sqlite3_vfs VFS objects are initialized to be pointers to +** the correct finder-function for that VFS. +** +** Most finder functions return a pointer to a fixed sqlite3_io_methods +** object. The only interesting finder-function is autolockIoFinder, which +** looks at the filesystem type and tries to guess the best locking +** strategy from that. +** +** For finder-function F, two objects are created: +** +** (1) The real finder-function named "FImpt()". +** +** (2) A constant pointer to this function named just "F". +** +** +** A pointer to the F pointer is used as the pAppData value for VFS +** objects. We have to do this instead of letting pAppData point +** directly at the finder-function since C90 rules prevent a void* +** from be cast into a function pointer. +** +** +** Each instance of this macro generates two objects: +** +** * A constant sqlite3_io_methods object call METHOD that has locking +** methods CLOSE, LOCK, UNLOCK, CKRESLOCK. +** +** * An I/O method finder function called FINDER that returns a pointer +** to the METHOD object in the previous bullet. +*/ +#define IOMETHODS(FINDER,METHOD,VERSION,CLOSE,LOCK,UNLOCK,CKLOCK,SHMMAP) \ +static const sqlite3_io_methods METHOD = { \ + VERSION, /* iVersion */ \ + CLOSE, /* xClose */ \ + unixRead, /* xRead */ \ + unixWrite, /* xWrite */ \ + unixTruncate, /* xTruncate */ \ + unixSync, /* xSync */ \ + unixFileSize, /* xFileSize */ \ + LOCK, /* xLock */ \ + UNLOCK, /* xUnlock */ \ + CKLOCK, /* xCheckReservedLock */ \ + unixFileControl, /* xFileControl */ \ + unixSectorSize, /* xSectorSize */ \ + unixDeviceCharacteristics, /* xDeviceCapabilities */ \ + SHMMAP, /* xShmMap */ \ + unixShmLock, /* xShmLock */ \ + unixShmBarrier, /* xShmBarrier */ \ + unixShmUnmap, /* xShmUnmap */ \ + unixFetch, /* xFetch */ \ + unixUnfetch, /* xUnfetch */ \ +}; \ +static const sqlite3_io_methods *FINDER##Impl(const char *z, unixFile *p){ \ + UNUSED_PARAMETER(z); UNUSED_PARAMETER(p); \ + return &METHOD; \ +} \ +static const sqlite3_io_methods *(*const FINDER)(const char*,unixFile *p) \ + = FINDER##Impl; + +/* +** Here are all of the sqlite3_io_methods objects for each of the +** locking strategies. Functions that return pointers to these methods +** are also created. +*/ +IOMETHODS( + posixIoFinder, /* Finder function name */ + posixIoMethods, /* sqlite3_io_methods object name */ + 3, /* shared memory and mmap are enabled */ + unixClose, /* xClose method */ + unixLock, /* xLock method */ + unixUnlock, /* xUnlock method */ + unixCheckReservedLock, /* xCheckReservedLock method */ + unixShmMap /* xShmMap method */ +) +IOMETHODS( + nolockIoFinder, /* Finder function name */ + nolockIoMethods, /* sqlite3_io_methods object name */ + 3, /* shared memory and mmap are enabled */ + nolockClose, /* xClose method */ + nolockLock, /* xLock method */ + nolockUnlock, /* xUnlock method */ + nolockCheckReservedLock, /* xCheckReservedLock method */ + 0 /* xShmMap method */ +) +IOMETHODS( + dotlockIoFinder, /* Finder function name */ + dotlockIoMethods, /* sqlite3_io_methods object name */ + 1, /* shared memory is disabled */ + dotlockClose, /* xClose method */ + dotlockLock, /* xLock method */ + dotlockUnlock, /* xUnlock method */ + dotlockCheckReservedLock, /* xCheckReservedLock method */ + 0 /* xShmMap method */ +) + +#if SQLITE_ENABLE_LOCKING_STYLE +IOMETHODS( + flockIoFinder, /* Finder function name */ + flockIoMethods, /* sqlite3_io_methods object name */ + 1, /* shared memory is disabled */ + flockClose, /* xClose method */ + flockLock, /* xLock method */ + flockUnlock, /* xUnlock method */ + flockCheckReservedLock, /* xCheckReservedLock method */ + 0 /* xShmMap method */ +) +#endif + +#if OS_VXWORKS +IOMETHODS( + semIoFinder, /* Finder function name */ + semIoMethods, /* sqlite3_io_methods object name */ + 1, /* shared memory is disabled */ + semXClose, /* xClose method */ + semXLock, /* xLock method */ + semXUnlock, /* xUnlock method */ + semXCheckReservedLock, /* xCheckReservedLock method */ + 0 /* xShmMap method */ +) +#endif + +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE +IOMETHODS( + afpIoFinder, /* Finder function name */ + afpIoMethods, /* sqlite3_io_methods object name */ + 1, /* shared memory is disabled */ + afpClose, /* xClose method */ + afpLock, /* xLock method */ + afpUnlock, /* xUnlock method */ + afpCheckReservedLock, /* xCheckReservedLock method */ + 0 /* xShmMap method */ +) +#endif + +/* +** The proxy locking method is a "super-method" in the sense that it +** opens secondary file descriptors for the conch and lock files and +** it uses proxy, dot-file, AFP, and flock() locking methods on those +** secondary files. For this reason, the division that implements +** proxy locking is located much further down in the file. But we need +** to go ahead and define the sqlite3_io_methods and finder function +** for proxy locking here. So we forward declare the I/O methods. +*/ +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE +static int proxyClose(sqlite3_file*); +static int proxyLock(sqlite3_file*, int); +static int proxyUnlock(sqlite3_file*, int); +static int proxyCheckReservedLock(sqlite3_file*, int*); +IOMETHODS( + proxyIoFinder, /* Finder function name */ + proxyIoMethods, /* sqlite3_io_methods object name */ + 1, /* shared memory is disabled */ + proxyClose, /* xClose method */ + proxyLock, /* xLock method */ + proxyUnlock, /* xUnlock method */ + proxyCheckReservedLock, /* xCheckReservedLock method */ + 0 /* xShmMap method */ +) +#endif + +/* nfs lockd on OSX 10.3+ doesn't clear write locks when a read lock is set */ +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE +IOMETHODS( + nfsIoFinder, /* Finder function name */ + nfsIoMethods, /* sqlite3_io_methods object name */ + 1, /* shared memory is disabled */ + unixClose, /* xClose method */ + unixLock, /* xLock method */ + nfsUnlock, /* xUnlock method */ + unixCheckReservedLock, /* xCheckReservedLock method */ + 0 /* xShmMap method */ +) +#endif + +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE +/* +** This "finder" function attempts to determine the best locking strategy +** for the database file "filePath". It then returns the sqlite3_io_methods +** object that implements that strategy. +** +** This is for MacOSX only. +*/ +static const sqlite3_io_methods *autolockIoFinderImpl( + const char *filePath, /* name of the database file */ + unixFile *pNew /* open file object for the database file */ +){ + static const struct Mapping { + const char *zFilesystem; /* Filesystem type name */ + const sqlite3_io_methods *pMethods; /* Appropriate locking method */ + } aMap[] = { + { "hfs", &posixIoMethods }, + { "ufs", &posixIoMethods }, + { "afpfs", &afpIoMethods }, + { "smbfs", &afpIoMethods }, + { "webdav", &nolockIoMethods }, + { 0, 0 } + }; + int i; + struct statfs fsInfo; + struct flock lockInfo; + + if( !filePath ){ + /* If filePath==NULL that means we are dealing with a transient file + ** that does not need to be locked. */ + return &nolockIoMethods; + } + if( statfs(filePath, &fsInfo) != -1 ){ + if( fsInfo.f_flags & MNT_RDONLY ){ + return &nolockIoMethods; + } + for(i=0; aMap[i].zFilesystem; i++){ + if( strcmp(fsInfo.f_fstypename, aMap[i].zFilesystem)==0 ){ + return aMap[i].pMethods; + } + } + } + + /* Default case. Handles, amongst others, "nfs". + ** Test byte-range lock using fcntl(). If the call succeeds, + ** assume that the file-system supports POSIX style locks. + */ + lockInfo.l_len = 1; + lockInfo.l_start = 0; + lockInfo.l_whence = SEEK_SET; + lockInfo.l_type = F_RDLCK; + if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) { + if( strcmp(fsInfo.f_fstypename, "nfs")==0 ){ + return &nfsIoMethods; + } else { + return &posixIoMethods; + } + }else{ + return &dotlockIoMethods; + } +} +static const sqlite3_io_methods + *(*const autolockIoFinder)(const char*,unixFile*) = autolockIoFinderImpl; + +#endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */ + +#if OS_VXWORKS +/* +** This "finder" function for VxWorks checks to see if posix advisory +** locking works. If it does, then that is what is used. If it does not +** work, then fallback to named semaphore locking. +*/ +static const sqlite3_io_methods *vxworksIoFinderImpl( + const char *filePath, /* name of the database file */ + unixFile *pNew /* the open file object */ +){ + struct flock lockInfo; + + if( !filePath ){ + /* If filePath==NULL that means we are dealing with a transient file + ** that does not need to be locked. */ + return &nolockIoMethods; + } + + /* Test if fcntl() is supported and use POSIX style locks. + ** Otherwise fall back to the named semaphore method. + */ + lockInfo.l_len = 1; + lockInfo.l_start = 0; + lockInfo.l_whence = SEEK_SET; + lockInfo.l_type = F_RDLCK; + if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) { + return &posixIoMethods; + }else{ + return &semIoMethods; + } +} +static const sqlite3_io_methods + *(*const vxworksIoFinder)(const char*,unixFile*) = vxworksIoFinderImpl; + +#endif /* OS_VXWORKS */ + +/* +** An abstract type for a pointer to an IO method finder function: +*/ +typedef const sqlite3_io_methods *(*finder_type)(const char*,unixFile*); + + +/**************************************************************************** +**************************** sqlite3_vfs methods **************************** +** +** This division contains the implementation of methods on the +** sqlite3_vfs object. +*/ + +/* +** Initialize the contents of the unixFile structure pointed to by pId. +*/ +static int fillInUnixFile( + sqlite3_vfs *pVfs, /* Pointer to vfs object */ + int h, /* Open file descriptor of file being opened */ + sqlite3_file *pId, /* Write to the unixFile structure here */ + const char *zFilename, /* Name of the file being opened */ + int ctrlFlags /* Zero or more UNIXFILE_* values */ +){ + const sqlite3_io_methods *pLockingStyle; + unixFile *pNew = (unixFile *)pId; + int rc = SQLITE_OK; + + assert( pNew->pInode==NULL ); + + /* No locking occurs in temporary files */ + assert( zFilename!=0 || (ctrlFlags & UNIXFILE_NOLOCK)!=0 ); + + OSTRACE(("OPEN %-3d %s\n", h, zFilename)); + pNew->h = h; + pNew->pVfs = pVfs; + pNew->zPath = zFilename; + pNew->ctrlFlags = (u8)ctrlFlags; +#if SQLITE_MAX_MMAP_SIZE>0 + pNew->mmapSizeMax = sqlite3GlobalConfig.szMmap; +#endif + if( sqlite3_uri_boolean(((ctrlFlags & UNIXFILE_URI) ? zFilename : 0), + "psow", SQLITE_POWERSAFE_OVERWRITE) ){ + pNew->ctrlFlags |= UNIXFILE_PSOW; + } + if( strcmp(pVfs->zName,"unix-excl")==0 ){ + pNew->ctrlFlags |= UNIXFILE_EXCL; + } + +#if OS_VXWORKS + pNew->pId = vxworksFindFileId(zFilename); + if( pNew->pId==0 ){ + ctrlFlags |= UNIXFILE_NOLOCK; + rc = SQLITE_NOMEM_BKPT; + } +#endif + + if( ctrlFlags & UNIXFILE_NOLOCK ){ + pLockingStyle = &nolockIoMethods; + }else{ + pLockingStyle = (**(finder_type*)pVfs->pAppData)(zFilename, pNew); +#if SQLITE_ENABLE_LOCKING_STYLE + /* Cache zFilename in the locking context (AFP and dotlock override) for + ** proxyLock activation is possible (remote proxy is based on db name) + ** zFilename remains valid until file is closed, to support */ + pNew->lockingContext = (void*)zFilename; +#endif + } + + if( pLockingStyle == &posixIoMethods +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE + || pLockingStyle == &nfsIoMethods +#endif + ){ + unixEnterMutex(); + rc = findInodeInfo(pNew, &pNew->pInode); + if( rc!=SQLITE_OK ){ + /* If an error occurred in findInodeInfo(), close the file descriptor + ** immediately, before releasing the mutex. findInodeInfo() may fail + ** in two scenarios: + ** + ** (a) A call to fstat() failed. + ** (b) A malloc failed. + ** + ** Scenario (b) may only occur if the process is holding no other + ** file descriptors open on the same file. If there were other file + ** descriptors on this file, then no malloc would be required by + ** findInodeInfo(). If this is the case, it is quite safe to close + ** handle h - as it is guaranteed that no posix locks will be released + ** by doing so. + ** + ** If scenario (a) caused the error then things are not so safe. The + ** implicit assumption here is that if fstat() fails, things are in + ** such bad shape that dropping a lock or two doesn't matter much. + */ + robust_close(pNew, h, __LINE__); + h = -1; + } + unixLeaveMutex(); + } + +#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) + else if( pLockingStyle == &afpIoMethods ){ + /* AFP locking uses the file path so it needs to be included in + ** the afpLockingContext. + */ + afpLockingContext *pCtx; + pNew->lockingContext = pCtx = sqlite3_malloc64( sizeof(*pCtx) ); + if( pCtx==0 ){ + rc = SQLITE_NOMEM_BKPT; + }else{ + /* NB: zFilename exists and remains valid until the file is closed + ** according to requirement F11141. So we do not need to make a + ** copy of the filename. */ + pCtx->dbPath = zFilename; + pCtx->reserved = 0; + srandomdev(); + unixEnterMutex(); + rc = findInodeInfo(pNew, &pNew->pInode); + if( rc!=SQLITE_OK ){ + sqlite3_free(pNew->lockingContext); + robust_close(pNew, h, __LINE__); + h = -1; + } + unixLeaveMutex(); + } + } +#endif + + else if( pLockingStyle == &dotlockIoMethods ){ + /* Dotfile locking uses the file path so it needs to be included in + ** the dotlockLockingContext + */ + char *zLockFile; + int nFilename; + assert( zFilename!=0 ); + nFilename = (int)strlen(zFilename) + 6; + zLockFile = (char *)sqlite3_malloc64(nFilename); + if( zLockFile==0 ){ + rc = SQLITE_NOMEM_BKPT; + }else{ + sqlite3_snprintf(nFilename, zLockFile, "%s" DOTLOCK_SUFFIX, zFilename); + } + pNew->lockingContext = zLockFile; + } + +#if OS_VXWORKS + else if( pLockingStyle == &semIoMethods ){ + /* Named semaphore locking uses the file path so it needs to be + ** included in the semLockingContext + */ + unixEnterMutex(); + rc = findInodeInfo(pNew, &pNew->pInode); + if( (rc==SQLITE_OK) && (pNew->pInode->pSem==NULL) ){ + char *zSemName = pNew->pInode->aSemName; + int n; + sqlite3_snprintf(MAX_PATHNAME, zSemName, "/%s.sem", + pNew->pId->zCanonicalName); + for( n=1; zSemName[n]; n++ ) + if( zSemName[n]=='/' ) zSemName[n] = '_'; + pNew->pInode->pSem = sem_open(zSemName, O_CREAT, 0666, 1); + if( pNew->pInode->pSem == SEM_FAILED ){ + rc = SQLITE_NOMEM_BKPT; + pNew->pInode->aSemName[0] = '\0'; + } + } + unixLeaveMutex(); + } +#endif + + storeLastErrno(pNew, 0); +#if OS_VXWORKS + if( rc!=SQLITE_OK ){ + if( h>=0 ) robust_close(pNew, h, __LINE__); + h = -1; + osUnlink(zFilename); + pNew->ctrlFlags |= UNIXFILE_DELETE; + } +#endif + if( rc!=SQLITE_OK ){ + if( h>=0 ) robust_close(pNew, h, __LINE__); + }else{ + pId->pMethods = pLockingStyle; + OpenCounter(+1); + verifyDbFile(pNew); + } + return rc; +} + +/* +** Directories to consider for temp files. +*/ +static const char *azTempDirs[] = { + 0, + 0, + "/var/tmp", + "/usr/tmp", + "/tmp", + "." +}; + +/* +** Initialize first two members of azTempDirs[] array. +*/ +static void unixTempFileInit(void){ + azTempDirs[0] = getenv("SQLITE_TMPDIR"); + azTempDirs[1] = getenv("TMPDIR"); +} + +/* +** Return the name of a directory in which to put temporary files. +** If no suitable temporary file directory can be found, return NULL. +*/ +static const char *unixTempFileDir(void){ + unsigned int i = 0; + struct stat buf; + const char *zDir = sqlite3_temp_directory; + + while(1){ + if( zDir!=0 + && osStat(zDir, &buf)==0 + && S_ISDIR(buf.st_mode) + && osAccess(zDir, 03)==0 + ){ + return zDir; + } + if( i>=sizeof(azTempDirs)/sizeof(azTempDirs[0]) ) break; + zDir = azTempDirs[i++]; + } + return 0; +} + +/* +** Create a temporary file name in zBuf. zBuf must be allocated +** by the calling process and must be big enough to hold at least +** pVfs->mxPathname bytes. +*/ +static int unixGetTempname(int nBuf, char *zBuf){ + const char *zDir; + int iLimit = 0; + int rc = SQLITE_OK; + + /* It's odd to simulate an io-error here, but really this is just + ** using the io-error infrastructure to test that SQLite handles this + ** function failing. + */ + zBuf[0] = 0; + SimulateIOError( return SQLITE_IOERR ); + + sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR)); + zDir = unixTempFileDir(); + if( zDir==0 ){ + rc = SQLITE_IOERR_GETTEMPPATH; + }else{ + do{ + u64 r; + sqlite3_randomness(sizeof(r), &r); + assert( nBuf>2 ); + zBuf[nBuf-2] = 0; + sqlite3_snprintf(nBuf, zBuf, "%s/"SQLITE_TEMP_FILE_PREFIX"%llx%c", + zDir, r, 0); + if( zBuf[nBuf-2]!=0 || (iLimit++)>10 ){ + rc = SQLITE_ERROR; + break; + } + }while( osAccess(zBuf,0)==0 ); + } + sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR)); + return rc; +} + +#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) +/* +** Routine to transform a unixFile into a proxy-locking unixFile. +** Implementation in the proxy-lock division, but used by unixOpen() +** if SQLITE_PREFER_PROXY_LOCKING is defined. +*/ +static int proxyTransformUnixFile(unixFile*, const char*); +#endif + +/* +** Search for an unused file descriptor that was opened on the database +** file (not a journal or super-journal file) identified by pathname +** zPath with SQLITE_OPEN_XXX flags matching those passed as the second +** argument to this function. +** +** Such a file descriptor may exist if a database connection was closed +** but the associated file descriptor could not be closed because some +** other file descriptor open on the same file is holding a file-lock. +** Refer to comments in the unixClose() function and the lengthy comment +** describing "Posix Advisory Locking" at the start of this file for +** further details. Also, ticket #4018. +** +** If a suitable file descriptor is found, then it is returned. If no +** such file descriptor is located, -1 is returned. +*/ +static UnixUnusedFd *findReusableFd(const char *zPath, int flags){ + UnixUnusedFd *pUnused = 0; + + /* Do not search for an unused file descriptor on vxworks. Not because + ** vxworks would not benefit from the change (it might, we're not sure), + ** but because no way to test it is currently available. It is better + ** not to risk breaking vxworks support for the sake of such an obscure + ** feature. */ +#if !OS_VXWORKS + struct stat sStat; /* Results of stat() call */ + + unixEnterMutex(); + + /* A stat() call may fail for various reasons. If this happens, it is + ** almost certain that an open() call on the same path will also fail. + ** For this reason, if an error occurs in the stat() call here, it is + ** ignored and -1 is returned. The caller will try to open a new file + ** descriptor on the same path, fail, and return an error to SQLite. + ** + ** Even if a subsequent open() call does succeed, the consequences of + ** not searching for a reusable file descriptor are not dire. */ + if( inodeList!=0 && 0==osStat(zPath, &sStat) ){ + unixInodeInfo *pInode; + + pInode = inodeList; + while( pInode && (pInode->fileId.dev!=sStat.st_dev + || pInode->fileId.ino!=(u64)sStat.st_ino) ){ + pInode = pInode->pNext; + } + if( pInode ){ + UnixUnusedFd **pp; + assert( sqlite3_mutex_notheld(pInode->pLockMutex) ); + sqlite3_mutex_enter(pInode->pLockMutex); + flags &= (SQLITE_OPEN_READONLY|SQLITE_OPEN_READWRITE); + for(pp=&pInode->pUnused; *pp && (*pp)->flags!=flags; pp=&((*pp)->pNext)); + pUnused = *pp; + if( pUnused ){ + *pp = pUnused->pNext; + } + sqlite3_mutex_leave(pInode->pLockMutex); + } + } + unixLeaveMutex(); +#endif /* if !OS_VXWORKS */ + return pUnused; +} + +/* +** Find the mode, uid and gid of file zFile. +*/ +static int getFileMode( + const char *zFile, /* File name */ + mode_t *pMode, /* OUT: Permissions of zFile */ + uid_t *pUid, /* OUT: uid of zFile. */ + gid_t *pGid /* OUT: gid of zFile. */ +){ + struct stat sStat; /* Output of stat() on database file */ + int rc = SQLITE_OK; + if( 0==osStat(zFile, &sStat) ){ + *pMode = sStat.st_mode & 0777; + *pUid = sStat.st_uid; + *pGid = sStat.st_gid; + }else{ + rc = SQLITE_IOERR_FSTAT; + } + return rc; +} + +/* +** This function is called by unixOpen() to determine the unix permissions +** to create new files with. If no error occurs, then SQLITE_OK is returned +** and a value suitable for passing as the third argument to open(2) is +** written to *pMode. If an IO error occurs, an SQLite error code is +** returned and the value of *pMode is not modified. +** +** In most cases, this routine sets *pMode to 0, which will become +** an indication to robust_open() to create the file using +** SQLITE_DEFAULT_FILE_PERMISSIONS adjusted by the umask. +** But if the file being opened is a WAL or regular journal file, then +** this function queries the file-system for the permissions on the +** corresponding database file and sets *pMode to this value. Whenever +** possible, WAL and journal files are created using the same permissions +** as the associated database file. +** +** If the SQLITE_ENABLE_8_3_NAMES option is enabled, then the +** original filename is unavailable. But 8_3_NAMES is only used for +** FAT filesystems and permissions do not matter there, so just use +** the default permissions. In 8_3_NAMES mode, leave *pMode set to zero. +*/ +static int findCreateFileMode( + const char *zPath, /* Path of file (possibly) being created */ + int flags, /* Flags passed as 4th argument to xOpen() */ + mode_t *pMode, /* OUT: Permissions to open file with */ + uid_t *pUid, /* OUT: uid to set on the file */ + gid_t *pGid /* OUT: gid to set on the file */ +){ + int rc = SQLITE_OK; /* Return Code */ + *pMode = 0; + *pUid = 0; + *pGid = 0; + if( flags & (SQLITE_OPEN_WAL|SQLITE_OPEN_MAIN_JOURNAL) ){ + char zDb[MAX_PATHNAME+1]; /* Database file path */ + int nDb; /* Number of valid bytes in zDb */ + + /* zPath is a path to a WAL or journal file. The following block derives + ** the path to the associated database file from zPath. This block handles + ** the following naming conventions: + ** + ** "-journal" + ** "-wal" + ** "-journalNN" + ** "-walNN" + ** + ** where NN is a decimal number. The NN naming schemes are + ** used by the test_multiplex.c module. + ** + ** In normal operation, the journal file name will always contain + ** a '-' character. However in 8+3 filename mode, or if a corrupt + ** rollback journal specifies a super-journal with a goofy name, then + ** the '-' might be missing or the '-' might be the first character in + ** the filename. In that case, just return SQLITE_OK with *pMode==0. + */ + nDb = sqlite3Strlen30(zPath) - 1; + while( nDb>0 && zPath[nDb]!='.' ){ + if( zPath[nDb]=='-' ){ + memcpy(zDb, zPath, nDb); + zDb[nDb] = '\0'; + rc = getFileMode(zDb, pMode, pUid, pGid); + break; + } + nDb--; + } + }else if( flags & SQLITE_OPEN_DELETEONCLOSE ){ + *pMode = 0600; + }else if( flags & SQLITE_OPEN_URI ){ + /* If this is a main database file and the file was opened using a URI + ** filename, check for the "modeof" parameter. If present, interpret + ** its value as a filename and try to copy the mode, uid and gid from + ** that file. */ + const char *z = sqlite3_uri_parameter(zPath, "modeof"); + if( z ){ + rc = getFileMode(z, pMode, pUid, pGid); + } + } + return rc; +} + +/* +** Open the file zPath. +** +** Previously, the SQLite OS layer used three functions in place of this +** one: +** +** sqlite3OsOpenReadWrite(); +** sqlite3OsOpenReadOnly(); +** sqlite3OsOpenExclusive(); +** +** These calls correspond to the following combinations of flags: +** +** ReadWrite() -> (READWRITE | CREATE) +** ReadOnly() -> (READONLY) +** OpenExclusive() -> (READWRITE | CREATE | EXCLUSIVE) +** +** The old OpenExclusive() accepted a boolean argument - "delFlag". If +** true, the file was configured to be automatically deleted when the +** file handle closed. To achieve the same effect using this new +** interface, add the DELETEONCLOSE flag to those specified above for +** OpenExclusive(). +*/ +static int unixOpen( + sqlite3_vfs *pVfs, /* The VFS for which this is the xOpen method */ + const char *zPath, /* Pathname of file to be opened */ + sqlite3_file *pFile, /* The file descriptor to be filled in */ + int flags, /* Input flags to control the opening */ + int *pOutFlags /* Output flags returned to SQLite core */ +){ + unixFile *p = (unixFile *)pFile; + int fd = -1; /* File descriptor returned by open() */ + int openFlags = 0; /* Flags to pass to open() */ + int eType = flags&0x0FFF00; /* Type of file to open */ + int noLock; /* True to omit locking primitives */ + int rc = SQLITE_OK; /* Function Return Code */ + int ctrlFlags = 0; /* UNIXFILE_* flags */ + + int isExclusive = (flags & SQLITE_OPEN_EXCLUSIVE); + int isDelete = (flags & SQLITE_OPEN_DELETEONCLOSE); + int isCreate = (flags & SQLITE_OPEN_CREATE); + int isReadonly = (flags & SQLITE_OPEN_READONLY); + int isReadWrite = (flags & SQLITE_OPEN_READWRITE); +#if SQLITE_ENABLE_LOCKING_STYLE + int isAutoProxy = (flags & SQLITE_OPEN_AUTOPROXY); +#endif +#if defined(__APPLE__) || SQLITE_ENABLE_LOCKING_STYLE + struct statfs fsInfo; +#endif + + /* If creating a super- or main-file journal, this function will open + ** a file-descriptor on the directory too. The first time unixSync() + ** is called the directory file descriptor will be fsync()ed and close()d. + */ + int isNewJrnl = (isCreate && ( + eType==SQLITE_OPEN_SUPER_JOURNAL + || eType==SQLITE_OPEN_MAIN_JOURNAL + || eType==SQLITE_OPEN_WAL + )); + + /* If argument zPath is a NULL pointer, this function is required to open + ** a temporary file. Use this buffer to store the file name in. + */ + char zTmpname[MAX_PATHNAME+2]; + const char *zName = zPath; + + /* Check the following statements are true: + ** + ** (a) Exactly one of the READWRITE and READONLY flags must be set, and + ** (b) if CREATE is set, then READWRITE must also be set, and + ** (c) if EXCLUSIVE is set, then CREATE must also be set. + ** (d) if DELETEONCLOSE is set, then CREATE must also be set. + */ + assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly)); + assert(isCreate==0 || isReadWrite); + assert(isExclusive==0 || isCreate); + assert(isDelete==0 || isCreate); + + /* The main DB, main journal, WAL file and super-journal are never + ** automatically deleted. Nor are they ever temporary files. */ + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB ); + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL ); + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_SUPER_JOURNAL ); + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL ); + + /* Assert that the upper layer has set one of the "file-type" flags. */ + assert( eType==SQLITE_OPEN_MAIN_DB || eType==SQLITE_OPEN_TEMP_DB + || eType==SQLITE_OPEN_MAIN_JOURNAL || eType==SQLITE_OPEN_TEMP_JOURNAL + || eType==SQLITE_OPEN_SUBJOURNAL || eType==SQLITE_OPEN_SUPER_JOURNAL + || eType==SQLITE_OPEN_TRANSIENT_DB || eType==SQLITE_OPEN_WAL + ); + + /* Detect a pid change and reset the PRNG. There is a race condition + ** here such that two or more threads all trying to open databases at + ** the same instant might all reset the PRNG. But multiple resets + ** are harmless. + */ + if( randomnessPid!=osGetpid(0) ){ + randomnessPid = osGetpid(0); + sqlite3_randomness(0,0); + } + memset(p, 0, sizeof(unixFile)); + +#ifdef SQLITE_ASSERT_NO_FILES + /* Applications that never read or write a persistent disk files */ + assert( zName==0 ); +#endif + + if( eType==SQLITE_OPEN_MAIN_DB ){ + UnixUnusedFd *pUnused; + pUnused = findReusableFd(zName, flags); + if( pUnused ){ + fd = pUnused->fd; + }else{ + pUnused = sqlite3_malloc64(sizeof(*pUnused)); + if( !pUnused ){ + return SQLITE_NOMEM_BKPT; + } + } + p->pPreallocatedUnused = pUnused; + + /* Database filenames are double-zero terminated if they are not + ** URIs with parameters. Hence, they can always be passed into + ** sqlite3_uri_parameter(). */ + assert( (flags & SQLITE_OPEN_URI) || zName[strlen(zName)+1]==0 ); + + }else if( !zName ){ + /* If zName is NULL, the upper layer is requesting a temp file. */ + assert(isDelete && !isNewJrnl); + rc = unixGetTempname(pVfs->mxPathname, zTmpname); + if( rc!=SQLITE_OK ){ + return rc; + } + zName = zTmpname; + + /* Generated temporary filenames are always double-zero terminated + ** for use by sqlite3_uri_parameter(). */ + assert( zName[strlen(zName)+1]==0 ); + } + + /* Determine the value of the flags parameter passed to POSIX function + ** open(). These must be calculated even if open() is not called, as + ** they may be stored as part of the file handle and used by the + ** 'conch file' locking functions later on. */ + if( isReadonly ) openFlags |= O_RDONLY; + if( isReadWrite ) openFlags |= O_RDWR; + if( isCreate ) openFlags |= O_CREAT; + if( isExclusive ) openFlags |= (O_EXCL|O_NOFOLLOW); + openFlags |= (O_LARGEFILE|O_BINARY|O_NOFOLLOW); + + if( fd<0 ){ + mode_t openMode; /* Permissions to create file with */ + uid_t uid; /* Userid for the file */ + gid_t gid; /* Groupid for the file */ + rc = findCreateFileMode(zName, flags, &openMode, &uid, &gid); + if( rc!=SQLITE_OK ){ + assert( !p->pPreallocatedUnused ); + assert( eType==SQLITE_OPEN_WAL || eType==SQLITE_OPEN_MAIN_JOURNAL ); + return rc; + } + fd = robust_open(zName, openFlags, openMode); + OSTRACE(("OPENX %-3d %s 0%o\n", fd, zName, openFlags)); + assert( !isExclusive || (openFlags & O_CREAT)!=0 ); + if( fd<0 ){ + if( isNewJrnl && errno==EACCES && osAccess(zName, F_OK) ){ + /* If unable to create a journal because the directory is not + ** writable, change the error code to indicate that. */ + rc = SQLITE_READONLY_DIRECTORY; + }else if( errno!=EISDIR && isReadWrite ){ + /* Failed to open the file for read/write access. Try read-only. */ + flags &= ~(SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE); + openFlags &= ~(O_RDWR|O_CREAT); + flags |= SQLITE_OPEN_READONLY; + openFlags |= O_RDONLY; + isReadonly = 1; + fd = robust_open(zName, openFlags, openMode); + } + } + if( fd<0 ){ + int rc2 = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName); + if( rc==SQLITE_OK ) rc = rc2; + goto open_finished; + } + + /* The owner of the rollback journal or WAL file should always be the + ** same as the owner of the database file. Try to ensure that this is + ** the case. The chown() system call will be a no-op if the current + ** process lacks root privileges, be we should at least try. Without + ** this step, if a root process opens a database file, it can leave + ** behinds a journal/WAL that is owned by root and hence make the + ** database inaccessible to unprivileged processes. + ** + ** If openMode==0, then that means uid and gid are not set correctly + ** (probably because SQLite is configured to use 8+3 filename mode) and + ** in that case we do not want to attempt the chown(). + */ + if( openMode && (flags & (SQLITE_OPEN_WAL|SQLITE_OPEN_MAIN_JOURNAL))!=0 ){ + robustFchown(fd, uid, gid); + } + } + assert( fd>=0 ); + if( pOutFlags ){ + *pOutFlags = flags; + } + + if( p->pPreallocatedUnused ){ + p->pPreallocatedUnused->fd = fd; + p->pPreallocatedUnused->flags = + flags & (SQLITE_OPEN_READONLY|SQLITE_OPEN_READWRITE); + } + + if( isDelete ){ +#if OS_VXWORKS + zPath = zName; +#elif defined(SQLITE_UNLINK_AFTER_CLOSE) + zPath = sqlite3_mprintf("%s", zName); + if( zPath==0 ){ + robust_close(p, fd, __LINE__); + return SQLITE_NOMEM_BKPT; + } +#else + osUnlink(zName); +#endif + } +#if SQLITE_ENABLE_LOCKING_STYLE + else{ + p->openFlags = openFlags; + } +#endif + +#if defined(__APPLE__) || SQLITE_ENABLE_LOCKING_STYLE + if( fstatfs(fd, &fsInfo) == -1 ){ + storeLastErrno(p, errno); + robust_close(p, fd, __LINE__); + return SQLITE_IOERR_ACCESS; + } + if (0 == strncmp("msdos", fsInfo.f_fstypename, 5)) { + ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS; + } + if (0 == strncmp("exfat", fsInfo.f_fstypename, 5)) { + ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS; + } +#endif + + /* Set up appropriate ctrlFlags */ + if( isDelete ) ctrlFlags |= UNIXFILE_DELETE; + if( isReadonly ) ctrlFlags |= UNIXFILE_RDONLY; + noLock = eType!=SQLITE_OPEN_MAIN_DB; + if( noLock ) ctrlFlags |= UNIXFILE_NOLOCK; + if( isNewJrnl ) ctrlFlags |= UNIXFILE_DIRSYNC; + if( flags & SQLITE_OPEN_URI ) ctrlFlags |= UNIXFILE_URI; + +#if SQLITE_ENABLE_LOCKING_STYLE +#if SQLITE_PREFER_PROXY_LOCKING + isAutoProxy = 1; +#endif + if( isAutoProxy && (zPath!=NULL) && (!noLock) && pVfs->xOpen ){ + char *envforce = getenv("SQLITE_FORCE_PROXY_LOCKING"); + int useProxy = 0; + + /* SQLITE_FORCE_PROXY_LOCKING==1 means force always use proxy, 0 means + ** never use proxy, NULL means use proxy for non-local files only. */ + if( envforce!=NULL ){ + useProxy = atoi(envforce)>0; + }else{ + useProxy = !(fsInfo.f_flags&MNT_LOCAL); + } + if( useProxy ){ + rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags); + if( rc==SQLITE_OK ){ + rc = proxyTransformUnixFile((unixFile*)pFile, ":auto:"); + if( rc!=SQLITE_OK ){ + /* Use unixClose to clean up the resources added in fillInUnixFile + ** and clear all the structure's references. Specifically, + ** pFile->pMethods will be NULL so sqlite3OsClose will be a no-op + */ + unixClose(pFile); + return rc; + } + } + goto open_finished; + } + } +#endif + + assert( zPath==0 || zPath[0]=='/' + || eType==SQLITE_OPEN_SUPER_JOURNAL || eType==SQLITE_OPEN_MAIN_JOURNAL + ); + rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags); + +open_finished: + if( rc!=SQLITE_OK ){ + sqlite3_free(p->pPreallocatedUnused); + } + return rc; +} + + +/* +** Delete the file at zPath. If the dirSync argument is true, fsync() +** the directory after deleting the file. +*/ +static int unixDelete( + sqlite3_vfs *NotUsed, /* VFS containing this as the xDelete method */ + const char *zPath, /* Name of file to be deleted */ + int dirSync /* If true, fsync() directory after deleting file */ +){ + int rc = SQLITE_OK; + UNUSED_PARAMETER(NotUsed); + SimulateIOError(return SQLITE_IOERR_DELETE); + if( osUnlink(zPath)==(-1) ){ + if( errno==ENOENT +#if OS_VXWORKS + || osAccess(zPath,0)!=0 +#endif + ){ + rc = SQLITE_IOERR_DELETE_NOENT; + }else{ + rc = unixLogError(SQLITE_IOERR_DELETE, "unlink", zPath); + } + return rc; + } +#ifndef SQLITE_DISABLE_DIRSYNC + if( (dirSync & 1)!=0 ){ + int fd; + rc = osOpenDirectory(zPath, &fd); + if( rc==SQLITE_OK ){ + if( full_fsync(fd,0,0) ){ + rc = unixLogError(SQLITE_IOERR_DIR_FSYNC, "fsync", zPath); + } + robust_close(0, fd, __LINE__); + }else{ + assert( rc==SQLITE_CANTOPEN ); + rc = SQLITE_OK; + } + } +#endif + return rc; +} + +/* +** Test the existence of or access permissions of file zPath. The +** test performed depends on the value of flags: +** +** SQLITE_ACCESS_EXISTS: Return 1 if the file exists +** SQLITE_ACCESS_READWRITE: Return 1 if the file is read and writable. +** SQLITE_ACCESS_READONLY: Return 1 if the file is readable. +** +** Otherwise return 0. +*/ +static int unixAccess( + sqlite3_vfs *NotUsed, /* The VFS containing this xAccess method */ + const char *zPath, /* Path of the file to examine */ + int flags, /* What do we want to learn about the zPath file? */ + int *pResOut /* Write result boolean here */ +){ + UNUSED_PARAMETER(NotUsed); + SimulateIOError( return SQLITE_IOERR_ACCESS; ); + assert( pResOut!=0 ); + + /* The spec says there are three possible values for flags. But only + ** two of them are actually used */ + assert( flags==SQLITE_ACCESS_EXISTS || flags==SQLITE_ACCESS_READWRITE ); + + if( flags==SQLITE_ACCESS_EXISTS ){ + struct stat buf; + *pResOut = 0==osStat(zPath, &buf) && + (!S_ISREG(buf.st_mode) || buf.st_size>0); + }else{ + *pResOut = osAccess(zPath, W_OK|R_OK)==0; + } + return SQLITE_OK; +} + +/* +** A pathname under construction +*/ +typedef struct DbPath DbPath; +struct DbPath { + int rc; /* Non-zero following any error */ + int nSymlink; /* Number of symlinks resolved */ + char *zOut; /* Write the pathname here */ + int nOut; /* Bytes of space available to zOut[] */ + int nUsed; /* Bytes of zOut[] currently being used */ +}; + +/* Forward reference */ +static void appendAllPathElements(DbPath*,const char*); + +/* +** Append a single path element to the DbPath under construction +*/ +static void appendOnePathElement( + DbPath *pPath, /* Path under construction, to which to append zName */ + const char *zName, /* Name to append to pPath. Not zero-terminated */ + int nName /* Number of significant bytes in zName */ +){ + assert( nName>0 ); + assert( zName!=0 ); + if( zName[0]=='.' ){ + if( nName==1 ) return; + if( zName[1]=='.' && nName==2 ){ + if( pPath->nUsed>1 ){ + assert( pPath->zOut[0]=='/' ); + while( pPath->zOut[--pPath->nUsed]!='/' ){} + } + return; + } + } + if( pPath->nUsed + nName + 2 >= pPath->nOut ){ + pPath->rc = SQLITE_ERROR; + return; + } + pPath->zOut[pPath->nUsed++] = '/'; + memcpy(&pPath->zOut[pPath->nUsed], zName, nName); + pPath->nUsed += nName; +#if defined(HAVE_READLINK) && defined(HAVE_LSTAT) + if( pPath->rc==SQLITE_OK ){ + const char *zIn; + struct stat buf; + pPath->zOut[pPath->nUsed] = 0; + zIn = pPath->zOut; + if( osLstat(zIn, &buf)!=0 ){ + if( errno!=ENOENT ){ + pPath->rc = unixLogError(SQLITE_CANTOPEN_BKPT, "lstat", zIn); + } + }else if( S_ISLNK(buf.st_mode) ){ + ssize_t got; + char zLnk[SQLITE_MAX_PATHLEN+2]; + if( pPath->nSymlink++ > SQLITE_MAX_SYMLINK ){ + pPath->rc = SQLITE_CANTOPEN_BKPT; + return; + } + got = osReadlink(zIn, zLnk, sizeof(zLnk)-2); + if( got<=0 || got>=(ssize_t)sizeof(zLnk)-2 ){ + pPath->rc = unixLogError(SQLITE_CANTOPEN_BKPT, "readlink", zIn); + return; + } + zLnk[got] = 0; + if( zLnk[0]=='/' ){ + pPath->nUsed = 0; + }else{ + pPath->nUsed -= nName + 1; + } + appendAllPathElements(pPath, zLnk); + } + } +#endif +} + +/* +** Append all path elements in zPath to the DbPath under construction. +*/ +static void appendAllPathElements( + DbPath *pPath, /* Path under construction, to which to append zName */ + const char *zPath /* Path to append to pPath. Is zero-terminated */ +){ + int i = 0; + int j = 0; + do{ + while( zPath[i] && zPath[i]!='/' ){ i++; } + if( i>j ){ + appendOnePathElement(pPath, &zPath[j], i-j); + } + j = i+1; + }while( zPath[i++] ); +} + +/* +** Turn a relative pathname into a full pathname. The relative path +** is stored as a nul-terminated string in the buffer pointed to by +** zPath. +** +** zOut points to a buffer of at least sqlite3_vfs.mxPathname bytes +** (in this case, MAX_PATHNAME bytes). The full-path is written to +** this buffer before returning. +*/ +static int unixFullPathname( + sqlite3_vfs *pVfs, /* Pointer to vfs object */ + const char *zPath, /* Possibly relative input path */ + int nOut, /* Size of output buffer in bytes */ + char *zOut /* Output buffer */ +){ + DbPath path; + UNUSED_PARAMETER(pVfs); + path.rc = 0; + path.nUsed = 0; + path.nSymlink = 0; + path.nOut = nOut; + path.zOut = zOut; + if( zPath[0]!='/' ){ + char zPwd[SQLITE_MAX_PATHLEN+2]; + if( osGetcwd(zPwd, sizeof(zPwd)-2)==0 ){ + return unixLogError(SQLITE_CANTOPEN_BKPT, "getcwd", zPath); + } + appendAllPathElements(&path, zPwd); + } + appendAllPathElements(&path, zPath); + zOut[path.nUsed] = 0; + if( path.rc || path.nUsed<2 ) return SQLITE_CANTOPEN_BKPT; + if( path.nSymlink ) return SQLITE_OK_SYMLINK; + return SQLITE_OK; +} + +#ifndef SQLITE_OMIT_LOAD_EXTENSION +/* +** Interfaces for opening a shared library, finding entry points +** within the shared library, and closing the shared library. +*/ +#include +static void *unixDlOpen(sqlite3_vfs *NotUsed, const char *zFilename){ + UNUSED_PARAMETER(NotUsed); + return dlopen(zFilename, RTLD_NOW | RTLD_GLOBAL); +} + +/* +** SQLite calls this function immediately after a call to unixDlSym() or +** unixDlOpen() fails (returns a null pointer). If a more detailed error +** message is available, it is written to zBufOut. If no error message +** is available, zBufOut is left unmodified and SQLite uses a default +** error message. +*/ +static void unixDlError(sqlite3_vfs *NotUsed, int nBuf, char *zBufOut){ + const char *zErr; + UNUSED_PARAMETER(NotUsed); + unixEnterMutex(); + zErr = dlerror(); + if( zErr ){ + sqlite3_snprintf(nBuf, zBufOut, "%s", zErr); + } + unixLeaveMutex(); +} +static void (*unixDlSym(sqlite3_vfs *NotUsed, void *p, const char*zSym))(void){ + /* + ** GCC with -pedantic-errors says that C90 does not allow a void* to be + ** cast into a pointer to a function. And yet the library dlsym() routine + ** returns a void* which is really a pointer to a function. So how do we + ** use dlsym() with -pedantic-errors? + ** + ** Variable x below is defined to be a pointer to a function taking + ** parameters void* and const char* and returning a pointer to a function. + ** We initialize x by assigning it a pointer to the dlsym() function. + ** (That assignment requires a cast.) Then we call the function that + ** x points to. + ** + ** This work-around is unlikely to work correctly on any system where + ** you really cannot cast a function pointer into void*. But then, on the + ** other hand, dlsym() will not work on such a system either, so we have + ** not really lost anything. + */ + void (*(*x)(void*,const char*))(void); + UNUSED_PARAMETER(NotUsed); + x = (void(*(*)(void*,const char*))(void))dlsym; + return (*x)(p, zSym); +} +static void unixDlClose(sqlite3_vfs *NotUsed, void *pHandle){ + UNUSED_PARAMETER(NotUsed); + dlclose(pHandle); +} +#else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */ + #define unixDlOpen 0 + #define unixDlError 0 + #define unixDlSym 0 + #define unixDlClose 0 +#endif + +/* +** Write nBuf bytes of random data to the supplied buffer zBuf. +*/ +static int unixRandomness(sqlite3_vfs *NotUsed, int nBuf, char *zBuf){ + UNUSED_PARAMETER(NotUsed); + assert((size_t)nBuf>=(sizeof(time_t)+sizeof(int))); + + /* We have to initialize zBuf to prevent valgrind from reporting + ** errors. The reports issued by valgrind are incorrect - we would + ** prefer that the randomness be increased by making use of the + ** uninitialized space in zBuf - but valgrind errors tend to worry + ** some users. Rather than argue, it seems easier just to initialize + ** the whole array and silence valgrind, even if that means less randomness + ** in the random seed. + ** + ** When testing, initializing zBuf[] to zero is all we do. That means + ** that we always use the same random number sequence. This makes the + ** tests repeatable. + */ + memset(zBuf, 0, nBuf); + randomnessPid = osGetpid(0); +#if !defined(SQLITE_TEST) && !defined(SQLITE_OMIT_RANDOMNESS) + { + int fd, got; + fd = robust_open("/dev/urandom", O_RDONLY, 0); + if( fd<0 ){ + time_t t; + time(&t); + memcpy(zBuf, &t, sizeof(t)); + memcpy(&zBuf[sizeof(t)], &randomnessPid, sizeof(randomnessPid)); + assert( sizeof(t)+sizeof(randomnessPid)<=(size_t)nBuf ); + nBuf = sizeof(t) + sizeof(randomnessPid); + }else{ + do{ got = osRead(fd, zBuf, nBuf); }while( got<0 && errno==EINTR ); + robust_close(0, fd, __LINE__); + } + } +#endif + return nBuf; +} + + +/* +** Sleep for a little while. Return the amount of time slept. +** The argument is the number of microseconds we want to sleep. +** The return value is the number of microseconds of sleep actually +** requested from the underlying operating system, a number which +** might be greater than or equal to the argument, but not less +** than the argument. +*/ +static int unixSleep(sqlite3_vfs *NotUsed, int microseconds){ +#if OS_VXWORKS || _POSIX_C_SOURCE >= 199309L + struct timespec sp; + + sp.tv_sec = microseconds / 1000000; + sp.tv_nsec = (microseconds % 1000000) * 1000; + nanosleep(&sp, NULL); + UNUSED_PARAMETER(NotUsed); + return microseconds; +#elif defined(HAVE_USLEEP) && HAVE_USLEEP + if( microseconds>=1000000 ) sleep(microseconds/1000000); + if( microseconds%1000000 ) usleep(microseconds%1000000); + UNUSED_PARAMETER(NotUsed); + return microseconds; +#else + int seconds = (microseconds+999999)/1000000; + sleep(seconds); + UNUSED_PARAMETER(NotUsed); + return seconds*1000000; +#endif +} + +/* +** The following variable, if set to a non-zero value, is interpreted as +** the number of seconds since 1970 and is used to set the result of +** sqlite3OsCurrentTime() during testing. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_current_time = 0; /* Fake system time in seconds since 1970. */ +#endif + +/* +** Find the current time (in Universal Coordinated Time). Write into *piNow +** the current time and date as a Julian Day number times 86_400_000. In +** other words, write into *piNow the number of milliseconds since the Julian +** epoch of noon in Greenwich on November 24, 4714 B.C according to the +** proleptic Gregorian calendar. +** +** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date +** cannot be found. +*/ +static int unixCurrentTimeInt64(sqlite3_vfs *NotUsed, sqlite3_int64 *piNow){ + static const sqlite3_int64 unixEpoch = 24405875*(sqlite3_int64)8640000; + int rc = SQLITE_OK; +#if defined(NO_GETTOD) + time_t t; + time(&t); + *piNow = ((sqlite3_int64)t)*1000 + unixEpoch; +#elif OS_VXWORKS + struct timespec sNow; + clock_gettime(CLOCK_REALTIME, &sNow); + *piNow = unixEpoch + 1000*(sqlite3_int64)sNow.tv_sec + sNow.tv_nsec/1000000; +#else + struct timeval sNow; + (void)gettimeofday(&sNow, 0); /* Cannot fail given valid arguments */ + *piNow = unixEpoch + 1000*(sqlite3_int64)sNow.tv_sec + sNow.tv_usec/1000; +#endif + +#ifdef SQLITE_TEST + if( sqlite3_current_time ){ + *piNow = 1000*(sqlite3_int64)sqlite3_current_time + unixEpoch; + } +#endif + UNUSED_PARAMETER(NotUsed); + return rc; +} + +#ifndef SQLITE_OMIT_DEPRECATED +/* +** Find the current time (in Universal Coordinated Time). Write the +** current time and date as a Julian Day number into *prNow and +** return 0. Return 1 if the time and date cannot be found. +*/ +static int unixCurrentTime(sqlite3_vfs *NotUsed, double *prNow){ + sqlite3_int64 i = 0; + int rc; + UNUSED_PARAMETER(NotUsed); + rc = unixCurrentTimeInt64(0, &i); + *prNow = i/86400000.0; + return rc; +} +#else +# define unixCurrentTime 0 +#endif + +/* +** The xGetLastError() method is designed to return a better +** low-level error message when operating-system problems come up +** during SQLite operation. Only the integer return code is currently +** used. +*/ +static int unixGetLastError(sqlite3_vfs *NotUsed, int NotUsed2, char *NotUsed3){ + UNUSED_PARAMETER(NotUsed); + UNUSED_PARAMETER(NotUsed2); + UNUSED_PARAMETER(NotUsed3); + return errno; +} + + +/* +************************ End of sqlite3_vfs methods *************************** +******************************************************************************/ + +/****************************************************************************** +************************** Begin Proxy Locking ******************************** +** +** Proxy locking is a "uber-locking-method" in this sense: It uses the +** other locking methods on secondary lock files. Proxy locking is a +** meta-layer over top of the primitive locking implemented above. For +** this reason, the division that implements of proxy locking is deferred +** until late in the file (here) after all of the other I/O methods have +** been defined - so that the primitive locking methods are available +** as services to help with the implementation of proxy locking. +** +**** +** +** The default locking schemes in SQLite use byte-range locks on the +** database file to coordinate safe, concurrent access by multiple readers +** and writers [http://sqlite.org/lockingv3.html]. The five file locking +** states (UNLOCKED, PENDING, SHARED, RESERVED, EXCLUSIVE) are implemented +** as POSIX read & write locks over fixed set of locations (via fsctl), +** on AFP and SMB only exclusive byte-range locks are available via fsctl +** with _IOWR('z', 23, struct ByteRangeLockPB2) to track the same 5 states. +** To simulate a F_RDLCK on the shared range, on AFP a randomly selected +** address in the shared range is taken for a SHARED lock, the entire +** shared range is taken for an EXCLUSIVE lock): +** +** PENDING_BYTE 0x40000000 +** RESERVED_BYTE 0x40000001 +** SHARED_RANGE 0x40000002 -> 0x40000200 +** +** This works well on the local file system, but shows a nearly 100x +** slowdown in read performance on AFP because the AFP client disables +** the read cache when byte-range locks are present. Enabling the read +** cache exposes a cache coherency problem that is present on all OS X +** supported network file systems. NFS and AFP both observe the +** close-to-open semantics for ensuring cache coherency +** [http://nfs.sourceforge.net/#faq_a8], which does not effectively +** address the requirements for concurrent database access by multiple +** readers and writers +** [http://www.nabble.com/SQLite-on-NFS-cache-coherency-td15655701.html]. +** +** To address the performance and cache coherency issues, proxy file locking +** changes the way database access is controlled by limiting access to a +** single host at a time and moving file locks off of the database file +** and onto a proxy file on the local file system. +** +** +** Using proxy locks +** ----------------- +** +** C APIs +** +** sqlite3_file_control(db, dbname, SQLITE_FCNTL_SET_LOCKPROXYFILE, +** | ":auto:"); +** sqlite3_file_control(db, dbname, SQLITE_FCNTL_GET_LOCKPROXYFILE, +** &); +** +** +** SQL pragmas +** +** PRAGMA [database.]lock_proxy_file= | :auto: +** PRAGMA [database.]lock_proxy_file +** +** Specifying ":auto:" means that if there is a conch file with a matching +** host ID in it, the proxy path in the conch file will be used, otherwise +** a proxy path based on the user's temp dir +** (via confstr(_CS_DARWIN_USER_TEMP_DIR,...)) will be used and the +** actual proxy file name is generated from the name and path of the +** database file. For example: +** +** For database path "/Users/me/foo.db" +** The lock path will be "/sqliteplocks/_Users_me_foo.db:auto:") +** +** Once a lock proxy is configured for a database connection, it can not +** be removed, however it may be switched to a different proxy path via +** the above APIs (assuming the conch file is not being held by another +** connection or process). +** +** +** How proxy locking works +** ----------------------- +** +** Proxy file locking relies primarily on two new supporting files: +** +** * conch file to limit access to the database file to a single host +** at a time +** +** * proxy file to act as a proxy for the advisory locks normally +** taken on the database +** +** The conch file - to use a proxy file, sqlite must first "hold the conch" +** by taking an sqlite-style shared lock on the conch file, reading the +** contents and comparing the host's unique host ID (see below) and lock +** proxy path against the values stored in the conch. The conch file is +** stored in the same directory as the database file and the file name +** is patterned after the database file name as ".-conch". +** If the conch file does not exist, or its contents do not match the +** host ID and/or proxy path, then the lock is escalated to an exclusive +** lock and the conch file contents is updated with the host ID and proxy +** path and the lock is downgraded to a shared lock again. If the conch +** is held by another process (with a shared lock), the exclusive lock +** will fail and SQLITE_BUSY is returned. +** +** The proxy file - a single-byte file used for all advisory file locks +** normally taken on the database file. This allows for safe sharing +** of the database file for multiple readers and writers on the same +** host (the conch ensures that they all use the same local lock file). +** +** Requesting the lock proxy does not immediately take the conch, it is +** only taken when the first request to lock database file is made. +** This matches the semantics of the traditional locking behavior, where +** opening a connection to a database file does not take a lock on it. +** The shared lock and an open file descriptor are maintained until +** the connection to the database is closed. +** +** The proxy file and the lock file are never deleted so they only need +** to be created the first time they are used. +** +** Configuration options +** --------------------- +** +** SQLITE_PREFER_PROXY_LOCKING +** +** Database files accessed on non-local file systems are +** automatically configured for proxy locking, lock files are +** named automatically using the same logic as +** PRAGMA lock_proxy_file=":auto:" +** +** SQLITE_PROXY_DEBUG +** +** Enables the logging of error messages during host id file +** retrieval and creation +** +** LOCKPROXYDIR +** +** Overrides the default directory used for lock proxy files that +** are named automatically via the ":auto:" setting +** +** SQLITE_DEFAULT_PROXYDIR_PERMISSIONS +** +** Permissions to use when creating a directory for storing the +** lock proxy files, only used when LOCKPROXYDIR is not set. +** +** +** As mentioned above, when compiled with SQLITE_PREFER_PROXY_LOCKING, +** setting the environment variable SQLITE_FORCE_PROXY_LOCKING to 1 will +** force proxy locking to be used for every database file opened, and 0 +** will force automatic proxy locking to be disabled for all database +** files (explicitly calling the SQLITE_FCNTL_SET_LOCKPROXYFILE pragma or +** sqlite_file_control API is not affected by SQLITE_FORCE_PROXY_LOCKING). +*/ + +/* +** Proxy locking is only available on MacOSX +*/ +#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE + +/* +** The proxyLockingContext has the path and file structures for the remote +** and local proxy files in it +*/ +typedef struct proxyLockingContext proxyLockingContext; +struct proxyLockingContext { + unixFile *conchFile; /* Open conch file */ + char *conchFilePath; /* Name of the conch file */ + unixFile *lockProxy; /* Open proxy lock file */ + char *lockProxyPath; /* Name of the proxy lock file */ + char *dbPath; /* Name of the open file */ + int conchHeld; /* 1 if the conch is held, -1 if lockless */ + int nFails; /* Number of conch taking failures */ + void *oldLockingContext; /* Original lockingcontext to restore on close */ + sqlite3_io_methods const *pOldMethod; /* Original I/O methods for close */ +}; + +/* +** The proxy lock file path for the database at dbPath is written into lPath, +** which must point to valid, writable memory large enough for a maxLen length +** file path. +*/ +static int proxyGetLockPath(const char *dbPath, char *lPath, size_t maxLen){ + int len; + int dbLen; + int i; + +#ifdef LOCKPROXYDIR + len = strlcpy(lPath, LOCKPROXYDIR, maxLen); +#else +# ifdef _CS_DARWIN_USER_TEMP_DIR + { + if( !confstr(_CS_DARWIN_USER_TEMP_DIR, lPath, maxLen) ){ + OSTRACE(("GETLOCKPATH failed %s errno=%d pid=%d\n", + lPath, errno, osGetpid(0))); + return SQLITE_IOERR_LOCK; + } + len = strlcat(lPath, "sqliteplocks", maxLen); + } +# else + len = strlcpy(lPath, "/tmp/", maxLen); +# endif +#endif + + if( lPath[len-1]!='/' ){ + len = strlcat(lPath, "/", maxLen); + } + + /* transform the db path to a unique cache name */ + dbLen = (int)strlen(dbPath); + for( i=0; i 0) ){ + /* only mkdir if leaf dir != "." or "/" or ".." */ + if( i-start>2 || (i-start==1 && buf[start] != '.' && buf[start] != '/') + || (i-start==2 && buf[start] != '.' && buf[start+1] != '.') ){ + buf[i]='\0'; + if( osMkdir(buf, SQLITE_DEFAULT_PROXYDIR_PERMISSIONS) ){ + int err=errno; + if( err!=EEXIST ) { + OSTRACE(("CREATELOCKPATH FAILED creating %s, " + "'%s' proxy lock path=%s pid=%d\n", + buf, strerror(err), lockPath, osGetpid(0))); + return err; + } + } + } + start=i+1; + } + buf[i] = lockPath[i]; + } + OSTRACE(("CREATELOCKPATH proxy lock path=%s pid=%d\n",lockPath,osGetpid(0))); + return 0; +} + +/* +** Create a new VFS file descriptor (stored in memory obtained from +** sqlite3_malloc) and open the file named "path" in the file descriptor. +** +** The caller is responsible not only for closing the file descriptor +** but also for freeing the memory associated with the file descriptor. +*/ +static int proxyCreateUnixFile( + const char *path, /* path for the new unixFile */ + unixFile **ppFile, /* unixFile created and returned by ref */ + int islockfile /* if non zero missing dirs will be created */ +) { + int fd = -1; + unixFile *pNew; + int rc = SQLITE_OK; + int openFlags = O_RDWR | O_CREAT | O_NOFOLLOW; + sqlite3_vfs dummyVfs; + int terrno = 0; + UnixUnusedFd *pUnused = NULL; + + /* 1. first try to open/create the file + ** 2. if that fails, and this is a lock file (not-conch), try creating + ** the parent directories and then try again. + ** 3. if that fails, try to open the file read-only + ** otherwise return BUSY (if lock file) or CANTOPEN for the conch file + */ + pUnused = findReusableFd(path, openFlags); + if( pUnused ){ + fd = pUnused->fd; + }else{ + pUnused = sqlite3_malloc64(sizeof(*pUnused)); + if( !pUnused ){ + return SQLITE_NOMEM_BKPT; + } + } + if( fd<0 ){ + fd = robust_open(path, openFlags, 0); + terrno = errno; + if( fd<0 && errno==ENOENT && islockfile ){ + if( proxyCreateLockPath(path) == SQLITE_OK ){ + fd = robust_open(path, openFlags, 0); + } + } + } + if( fd<0 ){ + openFlags = O_RDONLY | O_NOFOLLOW; + fd = robust_open(path, openFlags, 0); + terrno = errno; + } + if( fd<0 ){ + if( islockfile ){ + return SQLITE_BUSY; + } + switch (terrno) { + case EACCES: + return SQLITE_PERM; + case EIO: + return SQLITE_IOERR_LOCK; /* even though it is the conch */ + default: + return SQLITE_CANTOPEN_BKPT; + } + } + + pNew = (unixFile *)sqlite3_malloc64(sizeof(*pNew)); + if( pNew==NULL ){ + rc = SQLITE_NOMEM_BKPT; + goto end_create_proxy; + } + memset(pNew, 0, sizeof(unixFile)); + pNew->openFlags = openFlags; + memset(&dummyVfs, 0, sizeof(dummyVfs)); + dummyVfs.pAppData = (void*)&autolockIoFinder; + dummyVfs.zName = "dummy"; + pUnused->fd = fd; + pUnused->flags = openFlags; + pNew->pPreallocatedUnused = pUnused; + + rc = fillInUnixFile(&dummyVfs, fd, (sqlite3_file*)pNew, path, 0); + if( rc==SQLITE_OK ){ + *ppFile = pNew; + return SQLITE_OK; + } +end_create_proxy: + robust_close(pNew, fd, __LINE__); + sqlite3_free(pNew); + sqlite3_free(pUnused); + return rc; +} + +#ifdef SQLITE_TEST +/* simulate multiple hosts by creating unique hostid file paths */ +SQLITE_API int sqlite3_hostid_num = 0; +#endif + +#define PROXY_HOSTIDLEN 16 /* conch file host id length */ + +#if HAVE_GETHOSTUUID +/* Not always defined in the headers as it ought to be */ +extern int gethostuuid(uuid_t id, const struct timespec *wait); +#endif + +/* get the host ID via gethostuuid(), pHostID must point to PROXY_HOSTIDLEN +** bytes of writable memory. +*/ +static int proxyGetHostID(unsigned char *pHostID, int *pError){ + assert(PROXY_HOSTIDLEN == sizeof(uuid_t)); + memset(pHostID, 0, PROXY_HOSTIDLEN); +#if HAVE_GETHOSTUUID + { + struct timespec timeout = {1, 0}; /* 1 sec timeout */ + if( gethostuuid(pHostID, &timeout) ){ + int err = errno; + if( pError ){ + *pError = err; + } + return SQLITE_IOERR; + } + } +#else + UNUSED_PARAMETER(pError); +#endif +#ifdef SQLITE_TEST + /* simulate multiple hosts by creating unique hostid file paths */ + if( sqlite3_hostid_num != 0){ + pHostID[0] = (char)(pHostID[0] + (char)(sqlite3_hostid_num & 0xFF)); + } +#endif + + return SQLITE_OK; +} + +/* The conch file contains the header, host id and lock file path + */ +#define PROXY_CONCHVERSION 2 /* 1-byte header, 16-byte host id, path */ +#define PROXY_HEADERLEN 1 /* conch file header length */ +#define PROXY_PATHINDEX (PROXY_HEADERLEN+PROXY_HOSTIDLEN) +#define PROXY_MAXCONCHLEN (PROXY_HEADERLEN+PROXY_HOSTIDLEN+MAXPATHLEN) + +/* +** Takes an open conch file, copies the contents to a new path and then moves +** it back. The newly created file's file descriptor is assigned to the +** conch file structure and finally the original conch file descriptor is +** closed. Returns zero if successful. +*/ +static int proxyBreakConchLock(unixFile *pFile, uuid_t myHostID){ + proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; + unixFile *conchFile = pCtx->conchFile; + char tPath[MAXPATHLEN]; + char buf[PROXY_MAXCONCHLEN]; + char *cPath = pCtx->conchFilePath; + size_t readLen = 0; + size_t pathLen = 0; + char errmsg[64] = ""; + int fd = -1; + int rc = -1; + UNUSED_PARAMETER(myHostID); + + /* create a new path by replace the trailing '-conch' with '-break' */ + pathLen = strlcpy(tPath, cPath, MAXPATHLEN); + if( pathLen>MAXPATHLEN || pathLen<6 || + (strlcpy(&tPath[pathLen-5], "break", 6) != 5) ){ + sqlite3_snprintf(sizeof(errmsg),errmsg,"path error (len %d)",(int)pathLen); + goto end_breaklock; + } + /* read the conch content */ + readLen = osPread(conchFile->h, buf, PROXY_MAXCONCHLEN, 0); + if( readLenh, __LINE__); + conchFile->h = fd; + conchFile->openFlags = O_RDWR | O_CREAT; + +end_breaklock: + if( rc ){ + if( fd>=0 ){ + osUnlink(tPath); + robust_close(pFile, fd, __LINE__); + } + fprintf(stderr, "failed to break stale lock on %s, %s\n", cPath, errmsg); + } + return rc; +} + +/* Take the requested lock on the conch file and break a stale lock if the +** host id matches. +*/ +static int proxyConchLock(unixFile *pFile, uuid_t myHostID, int lockType){ + proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; + unixFile *conchFile = pCtx->conchFile; + int rc = SQLITE_OK; + int nTries = 0; + struct timespec conchModTime; + + memset(&conchModTime, 0, sizeof(conchModTime)); + do { + rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, lockType); + nTries ++; + if( rc==SQLITE_BUSY ){ + /* If the lock failed (busy): + * 1st try: get the mod time of the conch, wait 0.5s and try again. + * 2nd try: fail if the mod time changed or host id is different, wait + * 10 sec and try again + * 3rd try: break the lock unless the mod time has changed. + */ + struct stat buf; + if( osFstat(conchFile->h, &buf) ){ + storeLastErrno(pFile, errno); + return SQLITE_IOERR_LOCK; + } + + if( nTries==1 ){ + conchModTime = buf.st_mtimespec; + unixSleep(0,500000); /* wait 0.5 sec and try the lock again*/ + continue; + } + + assert( nTries>1 ); + if( conchModTime.tv_sec != buf.st_mtimespec.tv_sec || + conchModTime.tv_nsec != buf.st_mtimespec.tv_nsec ){ + return SQLITE_BUSY; + } + + if( nTries==2 ){ + char tBuf[PROXY_MAXCONCHLEN]; + int len = osPread(conchFile->h, tBuf, PROXY_MAXCONCHLEN, 0); + if( len<0 ){ + storeLastErrno(pFile, errno); + return SQLITE_IOERR_LOCK; + } + if( len>PROXY_PATHINDEX && tBuf[0]==(char)PROXY_CONCHVERSION){ + /* don't break the lock if the host id doesn't match */ + if( 0!=memcmp(&tBuf[PROXY_HEADERLEN], myHostID, PROXY_HOSTIDLEN) ){ + return SQLITE_BUSY; + } + }else{ + /* don't break the lock on short read or a version mismatch */ + return SQLITE_BUSY; + } + unixSleep(0,10000000); /* wait 10 sec and try the lock again */ + continue; + } + + assert( nTries==3 ); + if( 0==proxyBreakConchLock(pFile, myHostID) ){ + rc = SQLITE_OK; + if( lockType==EXCLUSIVE_LOCK ){ + rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, SHARED_LOCK); + } + if( !rc ){ + rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, lockType); + } + } + } + } while( rc==SQLITE_BUSY && nTries<3 ); + + return rc; +} + +/* Takes the conch by taking a shared lock and read the contents conch, if +** lockPath is non-NULL, the host ID and lock file path must match. A NULL +** lockPath means that the lockPath in the conch file will be used if the +** host IDs match, or a new lock path will be generated automatically +** and written to the conch file. +*/ +static int proxyTakeConch(unixFile *pFile){ + proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; + + if( pCtx->conchHeld!=0 ){ + return SQLITE_OK; + }else{ + unixFile *conchFile = pCtx->conchFile; + uuid_t myHostID; + int pError = 0; + char readBuf[PROXY_MAXCONCHLEN]; + char lockPath[MAXPATHLEN]; + char *tempLockPath = NULL; + int rc = SQLITE_OK; + int createConch = 0; + int hostIdMatch = 0; + int readLen = 0; + int tryOldLockPath = 0; + int forceNewLockPath = 0; + + OSTRACE(("TAKECONCH %d for %s pid=%d\n", conchFile->h, + (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"), + osGetpid(0))); + + rc = proxyGetHostID(myHostID, &pError); + if( (rc&0xff)==SQLITE_IOERR ){ + storeLastErrno(pFile, pError); + goto end_takeconch; + } + rc = proxyConchLock(pFile, myHostID, SHARED_LOCK); + if( rc!=SQLITE_OK ){ + goto end_takeconch; + } + /* read the existing conch file */ + readLen = seekAndRead((unixFile*)conchFile, 0, readBuf, PROXY_MAXCONCHLEN); + if( readLen<0 ){ + /* I/O error: lastErrno set by seekAndRead */ + storeLastErrno(pFile, conchFile->lastErrno); + rc = SQLITE_IOERR_READ; + goto end_takeconch; + }else if( readLen<=(PROXY_HEADERLEN+PROXY_HOSTIDLEN) || + readBuf[0]!=(char)PROXY_CONCHVERSION ){ + /* a short read or version format mismatch means we need to create a new + ** conch file. + */ + createConch = 1; + } + /* if the host id matches and the lock path already exists in the conch + ** we'll try to use the path there, if we can't open that path, we'll + ** retry with a new auto-generated path + */ + do { /* in case we need to try again for an :auto: named lock file */ + + if( !createConch && !forceNewLockPath ){ + hostIdMatch = !memcmp(&readBuf[PROXY_HEADERLEN], myHostID, + PROXY_HOSTIDLEN); + /* if the conch has data compare the contents */ + if( !pCtx->lockProxyPath ){ + /* for auto-named local lock file, just check the host ID and we'll + ** use the local lock file path that's already in there + */ + if( hostIdMatch ){ + size_t pathLen = (readLen - PROXY_PATHINDEX); + + if( pathLen>=MAXPATHLEN ){ + pathLen=MAXPATHLEN-1; + } + memcpy(lockPath, &readBuf[PROXY_PATHINDEX], pathLen); + lockPath[pathLen] = 0; + tempLockPath = lockPath; + tryOldLockPath = 1; + /* create a copy of the lock path if the conch is taken */ + goto end_takeconch; + } + }else if( hostIdMatch + && !strncmp(pCtx->lockProxyPath, &readBuf[PROXY_PATHINDEX], + readLen-PROXY_PATHINDEX) + ){ + /* conch host and lock path match */ + goto end_takeconch; + } + } + + /* if the conch isn't writable and doesn't match, we can't take it */ + if( (conchFile->openFlags&O_RDWR) == 0 ){ + rc = SQLITE_BUSY; + goto end_takeconch; + } + + /* either the conch didn't match or we need to create a new one */ + if( !pCtx->lockProxyPath ){ + proxyGetLockPath(pCtx->dbPath, lockPath, MAXPATHLEN); + tempLockPath = lockPath; + /* create a copy of the lock path _only_ if the conch is taken */ + } + + /* update conch with host and path (this will fail if other process + ** has a shared lock already), if the host id matches, use the big + ** stick. + */ + futimes(conchFile->h, NULL); + if( hostIdMatch && !createConch ){ + if( conchFile->pInode && conchFile->pInode->nShared>1 ){ + /* We are trying for an exclusive lock but another thread in this + ** same process is still holding a shared lock. */ + rc = SQLITE_BUSY; + } else { + rc = proxyConchLock(pFile, myHostID, EXCLUSIVE_LOCK); + } + }else{ + rc = proxyConchLock(pFile, myHostID, EXCLUSIVE_LOCK); + } + if( rc==SQLITE_OK ){ + char writeBuffer[PROXY_MAXCONCHLEN]; + int writeSize = 0; + + writeBuffer[0] = (char)PROXY_CONCHVERSION; + memcpy(&writeBuffer[PROXY_HEADERLEN], myHostID, PROXY_HOSTIDLEN); + if( pCtx->lockProxyPath!=NULL ){ + strlcpy(&writeBuffer[PROXY_PATHINDEX], pCtx->lockProxyPath, + MAXPATHLEN); + }else{ + strlcpy(&writeBuffer[PROXY_PATHINDEX], tempLockPath, MAXPATHLEN); + } + writeSize = PROXY_PATHINDEX + strlen(&writeBuffer[PROXY_PATHINDEX]); + robust_ftruncate(conchFile->h, writeSize); + rc = unixWrite((sqlite3_file *)conchFile, writeBuffer, writeSize, 0); + full_fsync(conchFile->h,0,0); + /* If we created a new conch file (not just updated the contents of a + ** valid conch file), try to match the permissions of the database + */ + if( rc==SQLITE_OK && createConch ){ + struct stat buf; + int err = osFstat(pFile->h, &buf); + if( err==0 ){ + mode_t cmode = buf.st_mode&(S_IRUSR|S_IWUSR | S_IRGRP|S_IWGRP | + S_IROTH|S_IWOTH); + /* try to match the database file R/W permissions, ignore failure */ +#ifndef SQLITE_PROXY_DEBUG + osFchmod(conchFile->h, cmode); +#else + do{ + rc = osFchmod(conchFile->h, cmode); + }while( rc==(-1) && errno==EINTR ); + if( rc!=0 ){ + int code = errno; + fprintf(stderr, "fchmod %o FAILED with %d %s\n", + cmode, code, strerror(code)); + } else { + fprintf(stderr, "fchmod %o SUCCEDED\n",cmode); + } + }else{ + int code = errno; + fprintf(stderr, "STAT FAILED[%d] with %d %s\n", + err, code, strerror(code)); +#endif + } + } + } + conchFile->pMethod->xUnlock((sqlite3_file*)conchFile, SHARED_LOCK); + + end_takeconch: + OSTRACE(("TRANSPROXY: CLOSE %d\n", pFile->h)); + if( rc==SQLITE_OK && pFile->openFlags ){ + int fd; + if( pFile->h>=0 ){ + robust_close(pFile, pFile->h, __LINE__); + } + pFile->h = -1; + fd = robust_open(pCtx->dbPath, pFile->openFlags, 0); + OSTRACE(("TRANSPROXY: OPEN %d\n", fd)); + if( fd>=0 ){ + pFile->h = fd; + }else{ + rc=SQLITE_CANTOPEN_BKPT; /* SQLITE_BUSY? proxyTakeConch called + during locking */ + } + } + if( rc==SQLITE_OK && !pCtx->lockProxy ){ + char *path = tempLockPath ? tempLockPath : pCtx->lockProxyPath; + rc = proxyCreateUnixFile(path, &pCtx->lockProxy, 1); + if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM && tryOldLockPath ){ + /* we couldn't create the proxy lock file with the old lock file path + ** so try again via auto-naming + */ + forceNewLockPath = 1; + tryOldLockPath = 0; + continue; /* go back to the do {} while start point, try again */ + } + } + if( rc==SQLITE_OK ){ + /* Need to make a copy of path if we extracted the value + ** from the conch file or the path was allocated on the stack + */ + if( tempLockPath ){ + pCtx->lockProxyPath = sqlite3DbStrDup(0, tempLockPath); + if( !pCtx->lockProxyPath ){ + rc = SQLITE_NOMEM_BKPT; + } + } + } + if( rc==SQLITE_OK ){ + pCtx->conchHeld = 1; + + if( pCtx->lockProxy->pMethod == &afpIoMethods ){ + afpLockingContext *afpCtx; + afpCtx = (afpLockingContext *)pCtx->lockProxy->lockingContext; + afpCtx->dbPath = pCtx->lockProxyPath; + } + } else { + conchFile->pMethod->xUnlock((sqlite3_file*)conchFile, NO_LOCK); + } + OSTRACE(("TAKECONCH %d %s\n", conchFile->h, + rc==SQLITE_OK?"ok":"failed")); + return rc; + } while (1); /* in case we need to retry the :auto: lock file - + ** we should never get here except via the 'continue' call. */ + } +} + +/* +** If pFile holds a lock on a conch file, then release that lock. +*/ +static int proxyReleaseConch(unixFile *pFile){ + int rc = SQLITE_OK; /* Subroutine return code */ + proxyLockingContext *pCtx; /* The locking context for the proxy lock */ + unixFile *conchFile; /* Name of the conch file */ + + pCtx = (proxyLockingContext *)pFile->lockingContext; + conchFile = pCtx->conchFile; + OSTRACE(("RELEASECONCH %d for %s pid=%d\n", conchFile->h, + (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"), + osGetpid(0))); + if( pCtx->conchHeld>0 ){ + rc = conchFile->pMethod->xUnlock((sqlite3_file*)conchFile, NO_LOCK); + } + pCtx->conchHeld = 0; + OSTRACE(("RELEASECONCH %d %s\n", conchFile->h, + (rc==SQLITE_OK ? "ok" : "failed"))); + return rc; +} + +/* +** Given the name of a database file, compute the name of its conch file. +** Store the conch filename in memory obtained from sqlite3_malloc64(). +** Make *pConchPath point to the new name. Return SQLITE_OK on success +** or SQLITE_NOMEM if unable to obtain memory. +** +** The caller is responsible for ensuring that the allocated memory +** space is eventually freed. +** +** *pConchPath is set to NULL if a memory allocation error occurs. +*/ +static int proxyCreateConchPathname(char *dbPath, char **pConchPath){ + int i; /* Loop counter */ + int len = (int)strlen(dbPath); /* Length of database filename - dbPath */ + char *conchPath; /* buffer in which to construct conch name */ + + /* Allocate space for the conch filename and initialize the name to + ** the name of the original database file. */ + *pConchPath = conchPath = (char *)sqlite3_malloc64(len + 8); + if( conchPath==0 ){ + return SQLITE_NOMEM_BKPT; + } + memcpy(conchPath, dbPath, len+1); + + /* now insert a "." before the last / character */ + for( i=(len-1); i>=0; i-- ){ + if( conchPath[i]=='/' ){ + i++; + break; + } + } + conchPath[i]='.'; + while ( ilockingContext; + char *oldPath = pCtx->lockProxyPath; + int rc = SQLITE_OK; + + if( pFile->eFileLock!=NO_LOCK ){ + return SQLITE_BUSY; + } + + /* nothing to do if the path is NULL, :auto: or matches the existing path */ + if( !path || path[0]=='\0' || !strcmp(path, ":auto:") || + (oldPath && !strncmp(oldPath, path, MAXPATHLEN)) ){ + return SQLITE_OK; + }else{ + unixFile *lockProxy = pCtx->lockProxy; + pCtx->lockProxy=NULL; + pCtx->conchHeld = 0; + if( lockProxy!=NULL ){ + rc=lockProxy->pMethod->xClose((sqlite3_file *)lockProxy); + if( rc ) return rc; + sqlite3_free(lockProxy); + } + sqlite3_free(oldPath); + pCtx->lockProxyPath = sqlite3DbStrDup(0, path); + } + + return rc; +} + +/* +** pFile is a file that has been opened by a prior xOpen call. dbPath +** is a string buffer at least MAXPATHLEN+1 characters in size. +** +** This routine find the filename associated with pFile and writes it +** int dbPath. +*/ +static int proxyGetDbPathForUnixFile(unixFile *pFile, char *dbPath){ +#if defined(__APPLE__) + if( pFile->pMethod == &afpIoMethods ){ + /* afp style keeps a reference to the db path in the filePath field + ** of the struct */ + assert( (int)strlen((char*)pFile->lockingContext)<=MAXPATHLEN ); + strlcpy(dbPath, ((afpLockingContext *)pFile->lockingContext)->dbPath, + MAXPATHLEN); + } else +#endif + if( pFile->pMethod == &dotlockIoMethods ){ + /* dot lock style uses the locking context to store the dot lock + ** file path */ + int len = strlen((char *)pFile->lockingContext) - strlen(DOTLOCK_SUFFIX); + memcpy(dbPath, (char *)pFile->lockingContext, len + 1); + }else{ + /* all other styles use the locking context to store the db file path */ + assert( strlen((char*)pFile->lockingContext)<=MAXPATHLEN ); + strlcpy(dbPath, (char *)pFile->lockingContext, MAXPATHLEN); + } + return SQLITE_OK; +} + +/* +** Takes an already filled in unix file and alters it so all file locking +** will be performed on the local proxy lock file. The following fields +** are preserved in the locking context so that they can be restored and +** the unix structure properly cleaned up at close time: +** ->lockingContext +** ->pMethod +*/ +static int proxyTransformUnixFile(unixFile *pFile, const char *path) { + proxyLockingContext *pCtx; + char dbPath[MAXPATHLEN+1]; /* Name of the database file */ + char *lockPath=NULL; + int rc = SQLITE_OK; + + if( pFile->eFileLock!=NO_LOCK ){ + return SQLITE_BUSY; + } + proxyGetDbPathForUnixFile(pFile, dbPath); + if( !path || path[0]=='\0' || !strcmp(path, ":auto:") ){ + lockPath=NULL; + }else{ + lockPath=(char *)path; + } + + OSTRACE(("TRANSPROXY %d for %s pid=%d\n", pFile->h, + (lockPath ? lockPath : ":auto:"), osGetpid(0))); + + pCtx = sqlite3_malloc64( sizeof(*pCtx) ); + if( pCtx==0 ){ + return SQLITE_NOMEM_BKPT; + } + memset(pCtx, 0, sizeof(*pCtx)); + + rc = proxyCreateConchPathname(dbPath, &pCtx->conchFilePath); + if( rc==SQLITE_OK ){ + rc = proxyCreateUnixFile(pCtx->conchFilePath, &pCtx->conchFile, 0); + if( rc==SQLITE_CANTOPEN && ((pFile->openFlags&O_RDWR) == 0) ){ + /* if (a) the open flags are not O_RDWR, (b) the conch isn't there, and + ** (c) the file system is read-only, then enable no-locking access. + ** Ugh, since O_RDONLY==0x0000 we test for !O_RDWR since unixOpen asserts + ** that openFlags will have only one of O_RDONLY or O_RDWR. + */ + struct statfs fsInfo; + struct stat conchInfo; + int goLockless = 0; + + if( osStat(pCtx->conchFilePath, &conchInfo) == -1 ) { + int err = errno; + if( (err==ENOENT) && (statfs(dbPath, &fsInfo) != -1) ){ + goLockless = (fsInfo.f_flags&MNT_RDONLY) == MNT_RDONLY; + } + } + if( goLockless ){ + pCtx->conchHeld = -1; /* read only FS/ lockless */ + rc = SQLITE_OK; + } + } + } + if( rc==SQLITE_OK && lockPath ){ + pCtx->lockProxyPath = sqlite3DbStrDup(0, lockPath); + } + + if( rc==SQLITE_OK ){ + pCtx->dbPath = sqlite3DbStrDup(0, dbPath); + if( pCtx->dbPath==NULL ){ + rc = SQLITE_NOMEM_BKPT; + } + } + if( rc==SQLITE_OK ){ + /* all memory is allocated, proxys are created and assigned, + ** switch the locking context and pMethod then return. + */ + pCtx->oldLockingContext = pFile->lockingContext; + pFile->lockingContext = pCtx; + pCtx->pOldMethod = pFile->pMethod; + pFile->pMethod = &proxyIoMethods; + }else{ + if( pCtx->conchFile ){ + pCtx->conchFile->pMethod->xClose((sqlite3_file *)pCtx->conchFile); + sqlite3_free(pCtx->conchFile); + } + sqlite3DbFree(0, pCtx->lockProxyPath); + sqlite3_free(pCtx->conchFilePath); + sqlite3_free(pCtx); + } + OSTRACE(("TRANSPROXY %d %s\n", pFile->h, + (rc==SQLITE_OK ? "ok" : "failed"))); + return rc; +} + + +/* +** This routine handles sqlite3_file_control() calls that are specific +** to proxy locking. +*/ +static int proxyFileControl(sqlite3_file *id, int op, void *pArg){ + switch( op ){ + case SQLITE_FCNTL_GET_LOCKPROXYFILE: { + unixFile *pFile = (unixFile*)id; + if( pFile->pMethod == &proxyIoMethods ){ + proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext; + proxyTakeConch(pFile); + if( pCtx->lockProxyPath ){ + *(const char **)pArg = pCtx->lockProxyPath; + }else{ + *(const char **)pArg = ":auto: (not held)"; + } + } else { + *(const char **)pArg = NULL; + } + return SQLITE_OK; + } + case SQLITE_FCNTL_SET_LOCKPROXYFILE: { + unixFile *pFile = (unixFile*)id; + int rc = SQLITE_OK; + int isProxyStyle = (pFile->pMethod == &proxyIoMethods); + if( pArg==NULL || (const char *)pArg==0 ){ + if( isProxyStyle ){ + /* turn off proxy locking - not supported. If support is added for + ** switching proxy locking mode off then it will need to fail if + ** the journal mode is WAL mode. + */ + rc = SQLITE_ERROR /*SQLITE_PROTOCOL? SQLITE_MISUSE?*/; + }else{ + /* turn off proxy locking - already off - NOOP */ + rc = SQLITE_OK; + } + }else{ + const char *proxyPath = (const char *)pArg; + if( isProxyStyle ){ + proxyLockingContext *pCtx = + (proxyLockingContext*)pFile->lockingContext; + if( !strcmp(pArg, ":auto:") + || (pCtx->lockProxyPath && + !strncmp(pCtx->lockProxyPath, proxyPath, MAXPATHLEN)) + ){ + rc = SQLITE_OK; + }else{ + rc = switchLockProxyPath(pFile, proxyPath); + } + }else{ + /* turn on proxy file locking */ + rc = proxyTransformUnixFile(pFile, proxyPath); + } + } + return rc; + } + default: { + assert( 0 ); /* The call assures that only valid opcodes are sent */ + } + } + /*NOTREACHED*/ assert(0); + return SQLITE_ERROR; +} + +/* +** Within this division (the proxying locking implementation) the procedures +** above this point are all utilities. The lock-related methods of the +** proxy-locking sqlite3_io_method object follow. +*/ + + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, set *pResOut +** to a non-zero value otherwise *pResOut is set to zero. The return value +** is set to SQLITE_OK unless an I/O error occurs during lock checking. +*/ +static int proxyCheckReservedLock(sqlite3_file *id, int *pResOut) { + unixFile *pFile = (unixFile*)id; + int rc = proxyTakeConch(pFile); + if( rc==SQLITE_OK ){ + proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; + if( pCtx->conchHeld>0 ){ + unixFile *proxy = pCtx->lockProxy; + return proxy->pMethod->xCheckReservedLock((sqlite3_file*)proxy, pResOut); + }else{ /* conchHeld < 0 is lockless */ + pResOut=0; + } + } + return rc; +} + +/* +** Lock the file with the lock specified by parameter eFileLock - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> (PENDING) -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** This routine will only increase a lock. Use the sqlite3OsUnlock() +** routine to lower a locking level. +*/ +static int proxyLock(sqlite3_file *id, int eFileLock) { + unixFile *pFile = (unixFile*)id; + int rc = proxyTakeConch(pFile); + if( rc==SQLITE_OK ){ + proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; + if( pCtx->conchHeld>0 ){ + unixFile *proxy = pCtx->lockProxy; + rc = proxy->pMethod->xLock((sqlite3_file*)proxy, eFileLock); + pFile->eFileLock = proxy->eFileLock; + }else{ + /* conchHeld < 0 is lockless */ + } + } + return rc; +} + + +/* +** Lower the locking level on file descriptor pFile to eFileLock. eFileLock +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +*/ +static int proxyUnlock(sqlite3_file *id, int eFileLock) { + unixFile *pFile = (unixFile*)id; + int rc = proxyTakeConch(pFile); + if( rc==SQLITE_OK ){ + proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; + if( pCtx->conchHeld>0 ){ + unixFile *proxy = pCtx->lockProxy; + rc = proxy->pMethod->xUnlock((sqlite3_file*)proxy, eFileLock); + pFile->eFileLock = proxy->eFileLock; + }else{ + /* conchHeld < 0 is lockless */ + } + } + return rc; +} + +/* +** Close a file that uses proxy locks. +*/ +static int proxyClose(sqlite3_file *id) { + if( ALWAYS(id) ){ + unixFile *pFile = (unixFile*)id; + proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext; + unixFile *lockProxy = pCtx->lockProxy; + unixFile *conchFile = pCtx->conchFile; + int rc = SQLITE_OK; + + if( lockProxy ){ + rc = lockProxy->pMethod->xUnlock((sqlite3_file*)lockProxy, NO_LOCK); + if( rc ) return rc; + rc = lockProxy->pMethod->xClose((sqlite3_file*)lockProxy); + if( rc ) return rc; + sqlite3_free(lockProxy); + pCtx->lockProxy = 0; + } + if( conchFile ){ + if( pCtx->conchHeld ){ + rc = proxyReleaseConch(pFile); + if( rc ) return rc; + } + rc = conchFile->pMethod->xClose((sqlite3_file*)conchFile); + if( rc ) return rc; + sqlite3_free(conchFile); + } + sqlite3DbFree(0, pCtx->lockProxyPath); + sqlite3_free(pCtx->conchFilePath); + sqlite3DbFree(0, pCtx->dbPath); + /* restore the original locking context and pMethod then close it */ + pFile->lockingContext = pCtx->oldLockingContext; + pFile->pMethod = pCtx->pOldMethod; + sqlite3_free(pCtx); + return pFile->pMethod->xClose(id); + } + return SQLITE_OK; +} + + + +#endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */ +/* +** The proxy locking style is intended for use with AFP filesystems. +** And since AFP is only supported on MacOSX, the proxy locking is also +** restricted to MacOSX. +** +** +******************* End of the proxy lock implementation ********************** +******************************************************************************/ + +/* +** Initialize the operating system interface. +** +** This routine registers all VFS implementations for unix-like operating +** systems. This routine, and the sqlite3_os_end() routine that follows, +** should be the only routines in this file that are visible from other +** files. +** +** This routine is called once during SQLite initialization and by a +** single thread. The memory allocation and mutex subsystems have not +** necessarily been initialized when this routine is called, and so they +** should not be used. +*/ +SQLITE_API int sqlite3_os_init(void){ + /* + ** The following macro defines an initializer for an sqlite3_vfs object. + ** The name of the VFS is NAME. The pAppData is a pointer to a pointer + ** to the "finder" function. (pAppData is a pointer to a pointer because + ** silly C90 rules prohibit a void* from being cast to a function pointer + ** and so we have to go through the intermediate pointer to avoid problems + ** when compiling with -pedantic-errors on GCC.) + ** + ** The FINDER parameter to this macro is the name of the pointer to the + ** finder-function. The finder-function returns a pointer to the + ** sqlite_io_methods object that implements the desired locking + ** behaviors. See the division above that contains the IOMETHODS + ** macro for addition information on finder-functions. + ** + ** Most finders simply return a pointer to a fixed sqlite3_io_methods + ** object. But the "autolockIoFinder" available on MacOSX does a little + ** more than that; it looks at the filesystem type that hosts the + ** database file and tries to choose an locking method appropriate for + ** that filesystem time. + */ + #define UNIXVFS(VFSNAME, FINDER) { \ + 3, /* iVersion */ \ + sizeof(unixFile), /* szOsFile */ \ + MAX_PATHNAME, /* mxPathname */ \ + 0, /* pNext */ \ + VFSNAME, /* zName */ \ + (void*)&FINDER, /* pAppData */ \ + unixOpen, /* xOpen */ \ + unixDelete, /* xDelete */ \ + unixAccess, /* xAccess */ \ + unixFullPathname, /* xFullPathname */ \ + unixDlOpen, /* xDlOpen */ \ + unixDlError, /* xDlError */ \ + unixDlSym, /* xDlSym */ \ + unixDlClose, /* xDlClose */ \ + unixRandomness, /* xRandomness */ \ + unixSleep, /* xSleep */ \ + unixCurrentTime, /* xCurrentTime */ \ + unixGetLastError, /* xGetLastError */ \ + unixCurrentTimeInt64, /* xCurrentTimeInt64 */ \ + unixSetSystemCall, /* xSetSystemCall */ \ + unixGetSystemCall, /* xGetSystemCall */ \ + unixNextSystemCall, /* xNextSystemCall */ \ + } + + /* + ** All default VFSes for unix are contained in the following array. + ** + ** Note that the sqlite3_vfs.pNext field of the VFS object is modified + ** by the SQLite core when the VFS is registered. So the following + ** array cannot be const. + */ + static sqlite3_vfs aVfs[] = { +#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) + UNIXVFS("unix", autolockIoFinder ), +#elif OS_VXWORKS + UNIXVFS("unix", vxworksIoFinder ), +#else + UNIXVFS("unix", posixIoFinder ), +#endif + UNIXVFS("unix-none", nolockIoFinder ), + UNIXVFS("unix-dotfile", dotlockIoFinder ), + UNIXVFS("unix-excl", posixIoFinder ), +#if OS_VXWORKS + UNIXVFS("unix-namedsem", semIoFinder ), +#endif +#if SQLITE_ENABLE_LOCKING_STYLE || OS_VXWORKS + UNIXVFS("unix-posix", posixIoFinder ), +#endif +#if SQLITE_ENABLE_LOCKING_STYLE + UNIXVFS("unix-flock", flockIoFinder ), +#endif +#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) + UNIXVFS("unix-afp", afpIoFinder ), + UNIXVFS("unix-nfs", nfsIoFinder ), + UNIXVFS("unix-proxy", proxyIoFinder ), +#endif + }; + unsigned int i; /* Loop counter */ + + /* Double-check that the aSyscall[] array has been constructed + ** correctly. See ticket [bb3a86e890c8e96ab] */ + assert( ArraySize(aSyscall)==29 ); + + /* Register all VFSes defined in the aVfs[] array */ + for(i=0; i<(sizeof(aVfs)/sizeof(sqlite3_vfs)); i++){ +#ifdef SQLITE_DEFAULT_UNIX_VFS + sqlite3_vfs_register(&aVfs[i], + 0==strcmp(aVfs[i].zName,SQLITE_DEFAULT_UNIX_VFS)); +#else + sqlite3_vfs_register(&aVfs[i], i==0); +#endif + } +#ifdef SQLITE_OS_KV_OPTIONAL + sqlite3KvvfsInit(); +#endif + unixBigLock = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1); + +#ifndef SQLITE_OMIT_WAL + /* Validate lock assumptions */ + assert( SQLITE_SHM_NLOCK==8 ); /* Number of available locks */ + assert( UNIX_SHM_BASE==120 ); /* Start of locking area */ + /* Locks: + ** WRITE UNIX_SHM_BASE 120 + ** CKPT UNIX_SHM_BASE+1 121 + ** RECOVER UNIX_SHM_BASE+2 122 + ** READ-0 UNIX_SHM_BASE+3 123 + ** READ-1 UNIX_SHM_BASE+4 124 + ** READ-2 UNIX_SHM_BASE+5 125 + ** READ-3 UNIX_SHM_BASE+6 126 + ** READ-4 UNIX_SHM_BASE+7 127 + ** DMS UNIX_SHM_BASE+8 128 + */ + assert( UNIX_SHM_DMS==128 ); /* Byte offset of the deadman-switch */ +#endif + + /* Initialize temp file dir array. */ + unixTempFileInit(); + + return SQLITE_OK; +} + +/* +** Shutdown the operating system interface. +** +** Some operating systems might need to do some cleanup in this routine, +** to release dynamically allocated objects. But not on unix. +** This routine is a no-op for unix. +*/ +SQLITE_API int sqlite3_os_end(void){ + unixBigLock = 0; + return SQLITE_OK; +} + +#endif /* SQLITE_OS_UNIX */ + +/************** End of os_unix.c *********************************************/ +/************** Begin file os_win.c ******************************************/ +/* +** 2004 May 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains code that is specific to Windows. +*/ +/* #include "sqliteInt.h" */ +#if SQLITE_OS_WIN /* This file is used for Windows only */ + +/* +** Include code that is common to all os_*.c files +*/ +/* #include "os_common.h" */ + +/* +** Include the header file for the Windows VFS. +*/ +/* #include "os_win.h" */ + +/* +** Compiling and using WAL mode requires several APIs that are only +** available in Windows platforms based on the NT kernel. +*/ +#if !SQLITE_OS_WINNT && !defined(SQLITE_OMIT_WAL) +# error "WAL mode requires support from the Windows NT kernel, compile\ + with SQLITE_OMIT_WAL." +#endif + +#if !SQLITE_OS_WINNT && SQLITE_MAX_MMAP_SIZE>0 +# error "Memory mapped files require support from the Windows NT kernel,\ + compile with SQLITE_MAX_MMAP_SIZE=0." +#endif + +/* +** Are most of the Win32 ANSI APIs available (i.e. with certain exceptions +** based on the sub-platform)? +*/ +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && !defined(SQLITE_WIN32_NO_ANSI) +# define SQLITE_WIN32_HAS_ANSI +#endif + +/* +** Are most of the Win32 Unicode APIs available (i.e. with certain exceptions +** based on the sub-platform)? +*/ +#if (SQLITE_OS_WINCE || SQLITE_OS_WINNT || SQLITE_OS_WINRT) && \ + !defined(SQLITE_WIN32_NO_WIDE) +# define SQLITE_WIN32_HAS_WIDE +#endif + +/* +** Make sure at least one set of Win32 APIs is available. +*/ +#if !defined(SQLITE_WIN32_HAS_ANSI) && !defined(SQLITE_WIN32_HAS_WIDE) +# error "At least one of SQLITE_WIN32_HAS_ANSI and SQLITE_WIN32_HAS_WIDE\ + must be defined." +#endif + +/* +** Define the required Windows SDK version constants if they are not +** already available. +*/ +#ifndef NTDDI_WIN8 +# define NTDDI_WIN8 0x06020000 +#endif + +#ifndef NTDDI_WINBLUE +# define NTDDI_WINBLUE 0x06030000 +#endif + +#ifndef NTDDI_WINTHRESHOLD +# define NTDDI_WINTHRESHOLD 0x06040000 +#endif + +/* +** Check to see if the GetVersionEx[AW] functions are deprecated on the +** target system. GetVersionEx was first deprecated in Win8.1. +*/ +#ifndef SQLITE_WIN32_GETVERSIONEX +# if defined(NTDDI_VERSION) && NTDDI_VERSION >= NTDDI_WINBLUE +# define SQLITE_WIN32_GETVERSIONEX 0 /* GetVersionEx() is deprecated */ +# else +# define SQLITE_WIN32_GETVERSIONEX 1 /* GetVersionEx() is current */ +# endif +#endif + +/* +** Check to see if the CreateFileMappingA function is supported on the +** target system. It is unavailable when using "mincore.lib" on Win10. +** When compiling for Windows 10, always assume "mincore.lib" is in use. +*/ +#ifndef SQLITE_WIN32_CREATEFILEMAPPINGA +# if defined(NTDDI_VERSION) && NTDDI_VERSION >= NTDDI_WINTHRESHOLD +# define SQLITE_WIN32_CREATEFILEMAPPINGA 0 +# else +# define SQLITE_WIN32_CREATEFILEMAPPINGA 1 +# endif +#endif + +/* +** This constant should already be defined (in the "WinDef.h" SDK file). +*/ +#ifndef MAX_PATH +# define MAX_PATH (260) +#endif + +/* +** Maximum pathname length (in chars) for Win32. This should normally be +** MAX_PATH. +*/ +#ifndef SQLITE_WIN32_MAX_PATH_CHARS +# define SQLITE_WIN32_MAX_PATH_CHARS (MAX_PATH) +#endif + +/* +** This constant should already be defined (in the "WinNT.h" SDK file). +*/ +#ifndef UNICODE_STRING_MAX_CHARS +# define UNICODE_STRING_MAX_CHARS (32767) +#endif + +/* +** Maximum pathname length (in chars) for WinNT. This should normally be +** UNICODE_STRING_MAX_CHARS. +*/ +#ifndef SQLITE_WINNT_MAX_PATH_CHARS +# define SQLITE_WINNT_MAX_PATH_CHARS (UNICODE_STRING_MAX_CHARS) +#endif + +/* +** Maximum pathname length (in bytes) for Win32. The MAX_PATH macro is in +** characters, so we allocate 4 bytes per character assuming worst-case of +** 4-bytes-per-character for UTF8. +*/ +#ifndef SQLITE_WIN32_MAX_PATH_BYTES +# define SQLITE_WIN32_MAX_PATH_BYTES (SQLITE_WIN32_MAX_PATH_CHARS*4) +#endif + +/* +** Maximum pathname length (in bytes) for WinNT. This should normally be +** UNICODE_STRING_MAX_CHARS * sizeof(WCHAR). +*/ +#ifndef SQLITE_WINNT_MAX_PATH_BYTES +# define SQLITE_WINNT_MAX_PATH_BYTES \ + (sizeof(WCHAR) * SQLITE_WINNT_MAX_PATH_CHARS) +#endif + +/* +** Maximum error message length (in chars) for WinRT. +*/ +#ifndef SQLITE_WIN32_MAX_ERRMSG_CHARS +# define SQLITE_WIN32_MAX_ERRMSG_CHARS (1024) +#endif + +/* +** Returns non-zero if the character should be treated as a directory +** separator. +*/ +#ifndef winIsDirSep +# define winIsDirSep(a) (((a) == '/') || ((a) == '\\')) +#endif + +/* +** This macro is used when a local variable is set to a value that is +** [sometimes] not used by the code (e.g. via conditional compilation). +*/ +#ifndef UNUSED_VARIABLE_VALUE +# define UNUSED_VARIABLE_VALUE(x) (void)(x) +#endif + +/* +** Returns the character that should be used as the directory separator. +*/ +#ifndef winGetDirSep +# define winGetDirSep() '\\' +#endif + +/* +** Do we need to manually define the Win32 file mapping APIs for use with WAL +** mode or memory mapped files (e.g. these APIs are available in the Windows +** CE SDK; however, they are not present in the header file)? +*/ +#if SQLITE_WIN32_FILEMAPPING_API && \ + (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) +/* +** Two of the file mapping APIs are different under WinRT. Figure out which +** set we need. +*/ +#if SQLITE_OS_WINRT +WINBASEAPI HANDLE WINAPI CreateFileMappingFromApp(HANDLE, \ + LPSECURITY_ATTRIBUTES, ULONG, ULONG64, LPCWSTR); + +WINBASEAPI LPVOID WINAPI MapViewOfFileFromApp(HANDLE, ULONG, ULONG64, SIZE_T); +#else +#if defined(SQLITE_WIN32_HAS_ANSI) +WINBASEAPI HANDLE WINAPI CreateFileMappingA(HANDLE, LPSECURITY_ATTRIBUTES, \ + DWORD, DWORD, DWORD, LPCSTR); +#endif /* defined(SQLITE_WIN32_HAS_ANSI) */ + +#if defined(SQLITE_WIN32_HAS_WIDE) +WINBASEAPI HANDLE WINAPI CreateFileMappingW(HANDLE, LPSECURITY_ATTRIBUTES, \ + DWORD, DWORD, DWORD, LPCWSTR); +#endif /* defined(SQLITE_WIN32_HAS_WIDE) */ + +WINBASEAPI LPVOID WINAPI MapViewOfFile(HANDLE, DWORD, DWORD, DWORD, SIZE_T); +#endif /* SQLITE_OS_WINRT */ + +/* +** These file mapping APIs are common to both Win32 and WinRT. +*/ + +WINBASEAPI BOOL WINAPI FlushViewOfFile(LPCVOID, SIZE_T); +WINBASEAPI BOOL WINAPI UnmapViewOfFile(LPCVOID); +#endif /* SQLITE_WIN32_FILEMAPPING_API */ + +/* +** Some Microsoft compilers lack this definition. +*/ +#ifndef INVALID_FILE_ATTRIBUTES +# define INVALID_FILE_ATTRIBUTES ((DWORD)-1) +#endif + +#ifndef FILE_FLAG_MASK +# define FILE_FLAG_MASK (0xFF3C0000) +#endif + +#ifndef FILE_ATTRIBUTE_MASK +# define FILE_ATTRIBUTE_MASK (0x0003FFF7) +#endif + +#ifndef SQLITE_OMIT_WAL +/* Forward references to structures used for WAL */ +typedef struct winShm winShm; /* A connection to shared-memory */ +typedef struct winShmNode winShmNode; /* A region of shared-memory */ +#endif + +/* +** WinCE lacks native support for file locking so we have to fake it +** with some code of our own. +*/ +#if SQLITE_OS_WINCE +typedef struct winceLock { + int nReaders; /* Number of reader locks obtained */ + BOOL bPending; /* Indicates a pending lock has been obtained */ + BOOL bReserved; /* Indicates a reserved lock has been obtained */ + BOOL bExclusive; /* Indicates an exclusive lock has been obtained */ +} winceLock; +#endif + +/* +** The winFile structure is a subclass of sqlite3_file* specific to the win32 +** portability layer. +*/ +typedef struct winFile winFile; +struct winFile { + const sqlite3_io_methods *pMethod; /*** Must be first ***/ + sqlite3_vfs *pVfs; /* The VFS used to open this file */ + HANDLE h; /* Handle for accessing the file */ + u8 locktype; /* Type of lock currently held on this file */ + short sharedLockByte; /* Randomly chosen byte used as a shared lock */ + u8 ctrlFlags; /* Flags. See WINFILE_* below */ + DWORD lastErrno; /* The Windows errno from the last I/O error */ +#ifndef SQLITE_OMIT_WAL + winShm *pShm; /* Instance of shared memory on this file */ +#endif + const char *zPath; /* Full pathname of this file */ + int szChunk; /* Chunk size configured by FCNTL_CHUNK_SIZE */ +#if SQLITE_OS_WINCE + LPWSTR zDeleteOnClose; /* Name of file to delete when closing */ + HANDLE hMutex; /* Mutex used to control access to shared lock */ + HANDLE hShared; /* Shared memory segment used for locking */ + winceLock local; /* Locks obtained by this instance of winFile */ + winceLock *shared; /* Global shared lock memory for the file */ +#endif +#if SQLITE_MAX_MMAP_SIZE>0 + int nFetchOut; /* Number of outstanding xFetch references */ + HANDLE hMap; /* Handle for accessing memory mapping */ + void *pMapRegion; /* Area memory mapped */ + sqlite3_int64 mmapSize; /* Size of mapped region */ + sqlite3_int64 mmapSizeMax; /* Configured FCNTL_MMAP_SIZE value */ +#endif +}; + +/* +** The winVfsAppData structure is used for the pAppData member for all of the +** Win32 VFS variants. +*/ +typedef struct winVfsAppData winVfsAppData; +struct winVfsAppData { + const sqlite3_io_methods *pMethod; /* The file I/O methods to use. */ + void *pAppData; /* The extra pAppData, if any. */ + BOOL bNoLock; /* Non-zero if locking is disabled. */ +}; + +/* +** Allowed values for winFile.ctrlFlags +*/ +#define WINFILE_RDONLY 0x02 /* Connection is read only */ +#define WINFILE_PERSIST_WAL 0x04 /* Persistent WAL mode */ +#define WINFILE_PSOW 0x10 /* SQLITE_IOCAP_POWERSAFE_OVERWRITE */ + +/* + * The size of the buffer used by sqlite3_win32_write_debug(). + */ +#ifndef SQLITE_WIN32_DBG_BUF_SIZE +# define SQLITE_WIN32_DBG_BUF_SIZE ((int)(4096-sizeof(DWORD))) +#endif + +/* + * If compiled with SQLITE_WIN32_MALLOC on Windows, we will use the + * various Win32 API heap functions instead of our own. + */ +#ifdef SQLITE_WIN32_MALLOC + +/* + * If this is non-zero, an isolated heap will be created by the native Win32 + * allocator subsystem; otherwise, the default process heap will be used. This + * setting has no effect when compiling for WinRT. By default, this is enabled + * and an isolated heap will be created to store all allocated data. + * + ****************************************************************************** + * WARNING: It is important to note that when this setting is non-zero and the + * winMemShutdown function is called (e.g. by the sqlite3_shutdown + * function), all data that was allocated using the isolated heap will + * be freed immediately and any attempt to access any of that freed + * data will almost certainly result in an immediate access violation. + ****************************************************************************** + */ +#ifndef SQLITE_WIN32_HEAP_CREATE +# define SQLITE_WIN32_HEAP_CREATE (TRUE) +#endif + +/* + * This is the maximum possible initial size of the Win32-specific heap, in + * bytes. + */ +#ifndef SQLITE_WIN32_HEAP_MAX_INIT_SIZE +# define SQLITE_WIN32_HEAP_MAX_INIT_SIZE (4294967295U) +#endif + +/* + * This is the extra space for the initial size of the Win32-specific heap, + * in bytes. This value may be zero. + */ +#ifndef SQLITE_WIN32_HEAP_INIT_EXTRA +# define SQLITE_WIN32_HEAP_INIT_EXTRA (4194304) +#endif + +/* + * Calculate the maximum legal cache size, in pages, based on the maximum + * possible initial heap size and the default page size, setting aside the + * needed extra space. + */ +#ifndef SQLITE_WIN32_MAX_CACHE_SIZE +# define SQLITE_WIN32_MAX_CACHE_SIZE (((SQLITE_WIN32_HEAP_MAX_INIT_SIZE) - \ + (SQLITE_WIN32_HEAP_INIT_EXTRA)) / \ + (SQLITE_DEFAULT_PAGE_SIZE)) +#endif + +/* + * This is cache size used in the calculation of the initial size of the + * Win32-specific heap. It cannot be negative. + */ +#ifndef SQLITE_WIN32_CACHE_SIZE +# if SQLITE_DEFAULT_CACHE_SIZE>=0 +# define SQLITE_WIN32_CACHE_SIZE (SQLITE_DEFAULT_CACHE_SIZE) +# else +# define SQLITE_WIN32_CACHE_SIZE (-(SQLITE_DEFAULT_CACHE_SIZE)) +# endif +#endif + +/* + * Make sure that the calculated cache size, in pages, cannot cause the + * initial size of the Win32-specific heap to exceed the maximum amount + * of memory that can be specified in the call to HeapCreate. + */ +#if SQLITE_WIN32_CACHE_SIZE>SQLITE_WIN32_MAX_CACHE_SIZE +# undef SQLITE_WIN32_CACHE_SIZE +# define SQLITE_WIN32_CACHE_SIZE (2000) +#endif + +/* + * The initial size of the Win32-specific heap. This value may be zero. + */ +#ifndef SQLITE_WIN32_HEAP_INIT_SIZE +# define SQLITE_WIN32_HEAP_INIT_SIZE ((SQLITE_WIN32_CACHE_SIZE) * \ + (SQLITE_DEFAULT_PAGE_SIZE) + \ + (SQLITE_WIN32_HEAP_INIT_EXTRA)) +#endif + +/* + * The maximum size of the Win32-specific heap. This value may be zero. + */ +#ifndef SQLITE_WIN32_HEAP_MAX_SIZE +# define SQLITE_WIN32_HEAP_MAX_SIZE (0) +#endif + +/* + * The extra flags to use in calls to the Win32 heap APIs. This value may be + * zero for the default behavior. + */ +#ifndef SQLITE_WIN32_HEAP_FLAGS +# define SQLITE_WIN32_HEAP_FLAGS (0) +#endif + + +/* +** The winMemData structure stores information required by the Win32-specific +** sqlite3_mem_methods implementation. +*/ +typedef struct winMemData winMemData; +struct winMemData { +#ifndef NDEBUG + u32 magic1; /* Magic number to detect structure corruption. */ +#endif + HANDLE hHeap; /* The handle to our heap. */ + BOOL bOwned; /* Do we own the heap (i.e. destroy it on shutdown)? */ +#ifndef NDEBUG + u32 magic2; /* Magic number to detect structure corruption. */ +#endif +}; + +#ifndef NDEBUG +#define WINMEM_MAGIC1 0x42b2830b +#define WINMEM_MAGIC2 0xbd4d7cf4 +#endif + +static struct winMemData win_mem_data = { +#ifndef NDEBUG + WINMEM_MAGIC1, +#endif + NULL, FALSE +#ifndef NDEBUG + ,WINMEM_MAGIC2 +#endif +}; + +#ifndef NDEBUG +#define winMemAssertMagic1() assert( win_mem_data.magic1==WINMEM_MAGIC1 ) +#define winMemAssertMagic2() assert( win_mem_data.magic2==WINMEM_MAGIC2 ) +#define winMemAssertMagic() winMemAssertMagic1(); winMemAssertMagic2(); +#else +#define winMemAssertMagic() +#endif + +#define winMemGetDataPtr() &win_mem_data +#define winMemGetHeap() win_mem_data.hHeap +#define winMemGetOwned() win_mem_data.bOwned + +static void *winMemMalloc(int nBytes); +static void winMemFree(void *pPrior); +static void *winMemRealloc(void *pPrior, int nBytes); +static int winMemSize(void *p); +static int winMemRoundup(int n); +static int winMemInit(void *pAppData); +static void winMemShutdown(void *pAppData); + +SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetWin32(void); +#endif /* SQLITE_WIN32_MALLOC */ + +/* +** The following variable is (normally) set once and never changes +** thereafter. It records whether the operating system is Win9x +** or WinNT. +** +** 0: Operating system unknown. +** 1: Operating system is Win9x. +** 2: Operating system is WinNT. +** +** In order to facilitate testing on a WinNT system, the test fixture +** can manually set this value to 1 to emulate Win98 behavior. +*/ +#ifdef SQLITE_TEST +SQLITE_API LONG SQLITE_WIN32_VOLATILE sqlite3_os_type = 0; +#else +static LONG SQLITE_WIN32_VOLATILE sqlite3_os_type = 0; +#endif + +#ifndef SYSCALL +# define SYSCALL sqlite3_syscall_ptr +#endif + +/* +** This function is not available on Windows CE or WinRT. + */ + +#if SQLITE_OS_WINCE || SQLITE_OS_WINRT +# define osAreFileApisANSI() 1 +#endif + +/* +** Many system calls are accessed through pointer-to-functions so that +** they may be overridden at runtime to facilitate fault injection during +** testing and sandboxing. The following array holds the names and pointers +** to all overrideable system calls. +*/ +static struct win_syscall { + const char *zName; /* Name of the system call */ + sqlite3_syscall_ptr pCurrent; /* Current value of the system call */ + sqlite3_syscall_ptr pDefault; /* Default value */ +} aSyscall[] = { +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT + { "AreFileApisANSI", (SYSCALL)AreFileApisANSI, 0 }, +#else + { "AreFileApisANSI", (SYSCALL)0, 0 }, +#endif + +#ifndef osAreFileApisANSI +#define osAreFileApisANSI ((BOOL(WINAPI*)(VOID))aSyscall[0].pCurrent) +#endif + +#if SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_WIDE) + { "CharLowerW", (SYSCALL)CharLowerW, 0 }, +#else + { "CharLowerW", (SYSCALL)0, 0 }, +#endif + +#define osCharLowerW ((LPWSTR(WINAPI*)(LPWSTR))aSyscall[1].pCurrent) + +#if SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_WIDE) + { "CharUpperW", (SYSCALL)CharUpperW, 0 }, +#else + { "CharUpperW", (SYSCALL)0, 0 }, +#endif + +#define osCharUpperW ((LPWSTR(WINAPI*)(LPWSTR))aSyscall[2].pCurrent) + + { "CloseHandle", (SYSCALL)CloseHandle, 0 }, + +#define osCloseHandle ((BOOL(WINAPI*)(HANDLE))aSyscall[3].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) + { "CreateFileA", (SYSCALL)CreateFileA, 0 }, +#else + { "CreateFileA", (SYSCALL)0, 0 }, +#endif + +#define osCreateFileA ((HANDLE(WINAPI*)(LPCSTR,DWORD,DWORD, \ + LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE))aSyscall[4].pCurrent) + +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) + { "CreateFileW", (SYSCALL)CreateFileW, 0 }, +#else + { "CreateFileW", (SYSCALL)0, 0 }, +#endif + +#define osCreateFileW ((HANDLE(WINAPI*)(LPCWSTR,DWORD,DWORD, \ + LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE))aSyscall[5].pCurrent) + +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_ANSI) && \ + (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) && \ + SQLITE_WIN32_CREATEFILEMAPPINGA + { "CreateFileMappingA", (SYSCALL)CreateFileMappingA, 0 }, +#else + { "CreateFileMappingA", (SYSCALL)0, 0 }, +#endif + +#define osCreateFileMappingA ((HANDLE(WINAPI*)(HANDLE,LPSECURITY_ATTRIBUTES, \ + DWORD,DWORD,DWORD,LPCSTR))aSyscall[6].pCurrent) + +#if SQLITE_OS_WINCE || (!SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) && \ + (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0)) + { "CreateFileMappingW", (SYSCALL)CreateFileMappingW, 0 }, +#else + { "CreateFileMappingW", (SYSCALL)0, 0 }, +#endif + +#define osCreateFileMappingW ((HANDLE(WINAPI*)(HANDLE,LPSECURITY_ATTRIBUTES, \ + DWORD,DWORD,DWORD,LPCWSTR))aSyscall[7].pCurrent) + +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) + { "CreateMutexW", (SYSCALL)CreateMutexW, 0 }, +#else + { "CreateMutexW", (SYSCALL)0, 0 }, +#endif + +#define osCreateMutexW ((HANDLE(WINAPI*)(LPSECURITY_ATTRIBUTES,BOOL, \ + LPCWSTR))aSyscall[8].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) + { "DeleteFileA", (SYSCALL)DeleteFileA, 0 }, +#else + { "DeleteFileA", (SYSCALL)0, 0 }, +#endif + +#define osDeleteFileA ((BOOL(WINAPI*)(LPCSTR))aSyscall[9].pCurrent) + +#if defined(SQLITE_WIN32_HAS_WIDE) + { "DeleteFileW", (SYSCALL)DeleteFileW, 0 }, +#else + { "DeleteFileW", (SYSCALL)0, 0 }, +#endif + +#define osDeleteFileW ((BOOL(WINAPI*)(LPCWSTR))aSyscall[10].pCurrent) + +#if SQLITE_OS_WINCE + { "FileTimeToLocalFileTime", (SYSCALL)FileTimeToLocalFileTime, 0 }, +#else + { "FileTimeToLocalFileTime", (SYSCALL)0, 0 }, +#endif + +#define osFileTimeToLocalFileTime ((BOOL(WINAPI*)(CONST FILETIME*, \ + LPFILETIME))aSyscall[11].pCurrent) + +#if SQLITE_OS_WINCE + { "FileTimeToSystemTime", (SYSCALL)FileTimeToSystemTime, 0 }, +#else + { "FileTimeToSystemTime", (SYSCALL)0, 0 }, +#endif + +#define osFileTimeToSystemTime ((BOOL(WINAPI*)(CONST FILETIME*, \ + LPSYSTEMTIME))aSyscall[12].pCurrent) + + { "FlushFileBuffers", (SYSCALL)FlushFileBuffers, 0 }, + +#define osFlushFileBuffers ((BOOL(WINAPI*)(HANDLE))aSyscall[13].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) + { "FormatMessageA", (SYSCALL)FormatMessageA, 0 }, +#else + { "FormatMessageA", (SYSCALL)0, 0 }, +#endif + +#define osFormatMessageA ((DWORD(WINAPI*)(DWORD,LPCVOID,DWORD,DWORD,LPSTR, \ + DWORD,va_list*))aSyscall[14].pCurrent) + +#if defined(SQLITE_WIN32_HAS_WIDE) + { "FormatMessageW", (SYSCALL)FormatMessageW, 0 }, +#else + { "FormatMessageW", (SYSCALL)0, 0 }, +#endif + +#define osFormatMessageW ((DWORD(WINAPI*)(DWORD,LPCVOID,DWORD,DWORD,LPWSTR, \ + DWORD,va_list*))aSyscall[15].pCurrent) + +#if !defined(SQLITE_OMIT_LOAD_EXTENSION) + { "FreeLibrary", (SYSCALL)FreeLibrary, 0 }, +#else + { "FreeLibrary", (SYSCALL)0, 0 }, +#endif + +#define osFreeLibrary ((BOOL(WINAPI*)(HMODULE))aSyscall[16].pCurrent) + + { "GetCurrentProcessId", (SYSCALL)GetCurrentProcessId, 0 }, + +#define osGetCurrentProcessId ((DWORD(WINAPI*)(VOID))aSyscall[17].pCurrent) + +#if !SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_ANSI) + { "GetDiskFreeSpaceA", (SYSCALL)GetDiskFreeSpaceA, 0 }, +#else + { "GetDiskFreeSpaceA", (SYSCALL)0, 0 }, +#endif + +#define osGetDiskFreeSpaceA ((BOOL(WINAPI*)(LPCSTR,LPDWORD,LPDWORD,LPDWORD, \ + LPDWORD))aSyscall[18].pCurrent) + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) + { "GetDiskFreeSpaceW", (SYSCALL)GetDiskFreeSpaceW, 0 }, +#else + { "GetDiskFreeSpaceW", (SYSCALL)0, 0 }, +#endif + +#define osGetDiskFreeSpaceW ((BOOL(WINAPI*)(LPCWSTR,LPDWORD,LPDWORD,LPDWORD, \ + LPDWORD))aSyscall[19].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) + { "GetFileAttributesA", (SYSCALL)GetFileAttributesA, 0 }, +#else + { "GetFileAttributesA", (SYSCALL)0, 0 }, +#endif + +#define osGetFileAttributesA ((DWORD(WINAPI*)(LPCSTR))aSyscall[20].pCurrent) + +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) + { "GetFileAttributesW", (SYSCALL)GetFileAttributesW, 0 }, +#else + { "GetFileAttributesW", (SYSCALL)0, 0 }, +#endif + +#define osGetFileAttributesW ((DWORD(WINAPI*)(LPCWSTR))aSyscall[21].pCurrent) + +#if defined(SQLITE_WIN32_HAS_WIDE) + { "GetFileAttributesExW", (SYSCALL)GetFileAttributesExW, 0 }, +#else + { "GetFileAttributesExW", (SYSCALL)0, 0 }, +#endif + +#define osGetFileAttributesExW ((BOOL(WINAPI*)(LPCWSTR,GET_FILEEX_INFO_LEVELS, \ + LPVOID))aSyscall[22].pCurrent) + +#if !SQLITE_OS_WINRT + { "GetFileSize", (SYSCALL)GetFileSize, 0 }, +#else + { "GetFileSize", (SYSCALL)0, 0 }, +#endif + +#define osGetFileSize ((DWORD(WINAPI*)(HANDLE,LPDWORD))aSyscall[23].pCurrent) + +#if !SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_ANSI) + { "GetFullPathNameA", (SYSCALL)GetFullPathNameA, 0 }, +#else + { "GetFullPathNameA", (SYSCALL)0, 0 }, +#endif + +#define osGetFullPathNameA ((DWORD(WINAPI*)(LPCSTR,DWORD,LPSTR, \ + LPSTR*))aSyscall[24].pCurrent) + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) + { "GetFullPathNameW", (SYSCALL)GetFullPathNameW, 0 }, +#else + { "GetFullPathNameW", (SYSCALL)0, 0 }, +#endif + +#define osGetFullPathNameW ((DWORD(WINAPI*)(LPCWSTR,DWORD,LPWSTR, \ + LPWSTR*))aSyscall[25].pCurrent) + + { "GetLastError", (SYSCALL)GetLastError, 0 }, + +#define osGetLastError ((DWORD(WINAPI*)(VOID))aSyscall[26].pCurrent) + +#if !defined(SQLITE_OMIT_LOAD_EXTENSION) +#if SQLITE_OS_WINCE + /* The GetProcAddressA() routine is only available on Windows CE. */ + { "GetProcAddressA", (SYSCALL)GetProcAddressA, 0 }, +#else + /* All other Windows platforms expect GetProcAddress() to take + ** an ANSI string regardless of the _UNICODE setting */ + { "GetProcAddressA", (SYSCALL)GetProcAddress, 0 }, +#endif +#else + { "GetProcAddressA", (SYSCALL)0, 0 }, +#endif + +#define osGetProcAddressA ((FARPROC(WINAPI*)(HMODULE, \ + LPCSTR))aSyscall[27].pCurrent) + +#if !SQLITE_OS_WINRT + { "GetSystemInfo", (SYSCALL)GetSystemInfo, 0 }, +#else + { "GetSystemInfo", (SYSCALL)0, 0 }, +#endif + +#define osGetSystemInfo ((VOID(WINAPI*)(LPSYSTEM_INFO))aSyscall[28].pCurrent) + + { "GetSystemTime", (SYSCALL)GetSystemTime, 0 }, + +#define osGetSystemTime ((VOID(WINAPI*)(LPSYSTEMTIME))aSyscall[29].pCurrent) + +#if !SQLITE_OS_WINCE + { "GetSystemTimeAsFileTime", (SYSCALL)GetSystemTimeAsFileTime, 0 }, +#else + { "GetSystemTimeAsFileTime", (SYSCALL)0, 0 }, +#endif + +#define osGetSystemTimeAsFileTime ((VOID(WINAPI*)( \ + LPFILETIME))aSyscall[30].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) + { "GetTempPathA", (SYSCALL)GetTempPathA, 0 }, +#else + { "GetTempPathA", (SYSCALL)0, 0 }, +#endif + +#define osGetTempPathA ((DWORD(WINAPI*)(DWORD,LPSTR))aSyscall[31].pCurrent) + +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) + { "GetTempPathW", (SYSCALL)GetTempPathW, 0 }, +#else + { "GetTempPathW", (SYSCALL)0, 0 }, +#endif + +#define osGetTempPathW ((DWORD(WINAPI*)(DWORD,LPWSTR))aSyscall[32].pCurrent) + +#if !SQLITE_OS_WINRT + { "GetTickCount", (SYSCALL)GetTickCount, 0 }, +#else + { "GetTickCount", (SYSCALL)0, 0 }, +#endif + +#define osGetTickCount ((DWORD(WINAPI*)(VOID))aSyscall[33].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) && SQLITE_WIN32_GETVERSIONEX + { "GetVersionExA", (SYSCALL)GetVersionExA, 0 }, +#else + { "GetVersionExA", (SYSCALL)0, 0 }, +#endif + +#define osGetVersionExA ((BOOL(WINAPI*)( \ + LPOSVERSIONINFOA))aSyscall[34].pCurrent) + +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) && \ + SQLITE_WIN32_GETVERSIONEX + { "GetVersionExW", (SYSCALL)GetVersionExW, 0 }, +#else + { "GetVersionExW", (SYSCALL)0, 0 }, +#endif + +#define osGetVersionExW ((BOOL(WINAPI*)( \ + LPOSVERSIONINFOW))aSyscall[35].pCurrent) + + { "HeapAlloc", (SYSCALL)HeapAlloc, 0 }, + +#define osHeapAlloc ((LPVOID(WINAPI*)(HANDLE,DWORD, \ + SIZE_T))aSyscall[36].pCurrent) + +#if !SQLITE_OS_WINRT + { "HeapCreate", (SYSCALL)HeapCreate, 0 }, +#else + { "HeapCreate", (SYSCALL)0, 0 }, +#endif + +#define osHeapCreate ((HANDLE(WINAPI*)(DWORD,SIZE_T, \ + SIZE_T))aSyscall[37].pCurrent) + +#if !SQLITE_OS_WINRT + { "HeapDestroy", (SYSCALL)HeapDestroy, 0 }, +#else + { "HeapDestroy", (SYSCALL)0, 0 }, +#endif + +#define osHeapDestroy ((BOOL(WINAPI*)(HANDLE))aSyscall[38].pCurrent) + + { "HeapFree", (SYSCALL)HeapFree, 0 }, + +#define osHeapFree ((BOOL(WINAPI*)(HANDLE,DWORD,LPVOID))aSyscall[39].pCurrent) + + { "HeapReAlloc", (SYSCALL)HeapReAlloc, 0 }, + +#define osHeapReAlloc ((LPVOID(WINAPI*)(HANDLE,DWORD,LPVOID, \ + SIZE_T))aSyscall[40].pCurrent) + + { "HeapSize", (SYSCALL)HeapSize, 0 }, + +#define osHeapSize ((SIZE_T(WINAPI*)(HANDLE,DWORD, \ + LPCVOID))aSyscall[41].pCurrent) + +#if !SQLITE_OS_WINRT + { "HeapValidate", (SYSCALL)HeapValidate, 0 }, +#else + { "HeapValidate", (SYSCALL)0, 0 }, +#endif + +#define osHeapValidate ((BOOL(WINAPI*)(HANDLE,DWORD, \ + LPCVOID))aSyscall[42].pCurrent) + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT + { "HeapCompact", (SYSCALL)HeapCompact, 0 }, +#else + { "HeapCompact", (SYSCALL)0, 0 }, +#endif + +#define osHeapCompact ((UINT(WINAPI*)(HANDLE,DWORD))aSyscall[43].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) && !defined(SQLITE_OMIT_LOAD_EXTENSION) + { "LoadLibraryA", (SYSCALL)LoadLibraryA, 0 }, +#else + { "LoadLibraryA", (SYSCALL)0, 0 }, +#endif + +#define osLoadLibraryA ((HMODULE(WINAPI*)(LPCSTR))aSyscall[44].pCurrent) + +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) && \ + !defined(SQLITE_OMIT_LOAD_EXTENSION) + { "LoadLibraryW", (SYSCALL)LoadLibraryW, 0 }, +#else + { "LoadLibraryW", (SYSCALL)0, 0 }, +#endif + +#define osLoadLibraryW ((HMODULE(WINAPI*)(LPCWSTR))aSyscall[45].pCurrent) + +#if !SQLITE_OS_WINRT + { "LocalFree", (SYSCALL)LocalFree, 0 }, +#else + { "LocalFree", (SYSCALL)0, 0 }, +#endif + +#define osLocalFree ((HLOCAL(WINAPI*)(HLOCAL))aSyscall[46].pCurrent) + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT + { "LockFile", (SYSCALL)LockFile, 0 }, +#else + { "LockFile", (SYSCALL)0, 0 }, +#endif + +#ifndef osLockFile +#define osLockFile ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \ + DWORD))aSyscall[47].pCurrent) +#endif + +#if !SQLITE_OS_WINCE + { "LockFileEx", (SYSCALL)LockFileEx, 0 }, +#else + { "LockFileEx", (SYSCALL)0, 0 }, +#endif + +#ifndef osLockFileEx +#define osLockFileEx ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD,DWORD, \ + LPOVERLAPPED))aSyscall[48].pCurrent) +#endif + +#if SQLITE_OS_WINCE || (!SQLITE_OS_WINRT && \ + (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0)) + { "MapViewOfFile", (SYSCALL)MapViewOfFile, 0 }, +#else + { "MapViewOfFile", (SYSCALL)0, 0 }, +#endif + +#define osMapViewOfFile ((LPVOID(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \ + SIZE_T))aSyscall[49].pCurrent) + + { "MultiByteToWideChar", (SYSCALL)MultiByteToWideChar, 0 }, + +#define osMultiByteToWideChar ((int(WINAPI*)(UINT,DWORD,LPCSTR,int,LPWSTR, \ + int))aSyscall[50].pCurrent) + + { "QueryPerformanceCounter", (SYSCALL)QueryPerformanceCounter, 0 }, + +#define osQueryPerformanceCounter ((BOOL(WINAPI*)( \ + LARGE_INTEGER*))aSyscall[51].pCurrent) + + { "ReadFile", (SYSCALL)ReadFile, 0 }, + +#define osReadFile ((BOOL(WINAPI*)(HANDLE,LPVOID,DWORD,LPDWORD, \ + LPOVERLAPPED))aSyscall[52].pCurrent) + + { "SetEndOfFile", (SYSCALL)SetEndOfFile, 0 }, + +#define osSetEndOfFile ((BOOL(WINAPI*)(HANDLE))aSyscall[53].pCurrent) + +#if !SQLITE_OS_WINRT + { "SetFilePointer", (SYSCALL)SetFilePointer, 0 }, +#else + { "SetFilePointer", (SYSCALL)0, 0 }, +#endif + +#define osSetFilePointer ((DWORD(WINAPI*)(HANDLE,LONG,PLONG, \ + DWORD))aSyscall[54].pCurrent) + +#if !SQLITE_OS_WINRT + { "Sleep", (SYSCALL)Sleep, 0 }, +#else + { "Sleep", (SYSCALL)0, 0 }, +#endif + +#define osSleep ((VOID(WINAPI*)(DWORD))aSyscall[55].pCurrent) + + { "SystemTimeToFileTime", (SYSCALL)SystemTimeToFileTime, 0 }, + +#define osSystemTimeToFileTime ((BOOL(WINAPI*)(CONST SYSTEMTIME*, \ + LPFILETIME))aSyscall[56].pCurrent) + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT + { "UnlockFile", (SYSCALL)UnlockFile, 0 }, +#else + { "UnlockFile", (SYSCALL)0, 0 }, +#endif + +#ifndef osUnlockFile +#define osUnlockFile ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \ + DWORD))aSyscall[57].pCurrent) +#endif + +#if !SQLITE_OS_WINCE + { "UnlockFileEx", (SYSCALL)UnlockFileEx, 0 }, +#else + { "UnlockFileEx", (SYSCALL)0, 0 }, +#endif + +#define osUnlockFileEx ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \ + LPOVERLAPPED))aSyscall[58].pCurrent) + +#if SQLITE_OS_WINCE || !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0 + { "UnmapViewOfFile", (SYSCALL)UnmapViewOfFile, 0 }, +#else + { "UnmapViewOfFile", (SYSCALL)0, 0 }, +#endif + +#define osUnmapViewOfFile ((BOOL(WINAPI*)(LPCVOID))aSyscall[59].pCurrent) + + { "WideCharToMultiByte", (SYSCALL)WideCharToMultiByte, 0 }, + +#define osWideCharToMultiByte ((int(WINAPI*)(UINT,DWORD,LPCWSTR,int,LPSTR,int, \ + LPCSTR,LPBOOL))aSyscall[60].pCurrent) + + { "WriteFile", (SYSCALL)WriteFile, 0 }, + +#define osWriteFile ((BOOL(WINAPI*)(HANDLE,LPCVOID,DWORD,LPDWORD, \ + LPOVERLAPPED))aSyscall[61].pCurrent) + +#if SQLITE_OS_WINRT + { "CreateEventExW", (SYSCALL)CreateEventExW, 0 }, +#else + { "CreateEventExW", (SYSCALL)0, 0 }, +#endif + +#define osCreateEventExW ((HANDLE(WINAPI*)(LPSECURITY_ATTRIBUTES,LPCWSTR, \ + DWORD,DWORD))aSyscall[62].pCurrent) + +#if !SQLITE_OS_WINRT + { "WaitForSingleObject", (SYSCALL)WaitForSingleObject, 0 }, +#else + { "WaitForSingleObject", (SYSCALL)0, 0 }, +#endif + +#define osWaitForSingleObject ((DWORD(WINAPI*)(HANDLE, \ + DWORD))aSyscall[63].pCurrent) + +#if !SQLITE_OS_WINCE + { "WaitForSingleObjectEx", (SYSCALL)WaitForSingleObjectEx, 0 }, +#else + { "WaitForSingleObjectEx", (SYSCALL)0, 0 }, +#endif + +#define osWaitForSingleObjectEx ((DWORD(WINAPI*)(HANDLE,DWORD, \ + BOOL))aSyscall[64].pCurrent) + +#if SQLITE_OS_WINRT + { "SetFilePointerEx", (SYSCALL)SetFilePointerEx, 0 }, +#else + { "SetFilePointerEx", (SYSCALL)0, 0 }, +#endif + +#define osSetFilePointerEx ((BOOL(WINAPI*)(HANDLE,LARGE_INTEGER, \ + PLARGE_INTEGER,DWORD))aSyscall[65].pCurrent) + +#if SQLITE_OS_WINRT + { "GetFileInformationByHandleEx", (SYSCALL)GetFileInformationByHandleEx, 0 }, +#else + { "GetFileInformationByHandleEx", (SYSCALL)0, 0 }, +#endif + +#define osGetFileInformationByHandleEx ((BOOL(WINAPI*)(HANDLE, \ + FILE_INFO_BY_HANDLE_CLASS,LPVOID,DWORD))aSyscall[66].pCurrent) + +#if SQLITE_OS_WINRT && (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) + { "MapViewOfFileFromApp", (SYSCALL)MapViewOfFileFromApp, 0 }, +#else + { "MapViewOfFileFromApp", (SYSCALL)0, 0 }, +#endif + +#define osMapViewOfFileFromApp ((LPVOID(WINAPI*)(HANDLE,ULONG,ULONG64, \ + SIZE_T))aSyscall[67].pCurrent) + +#if SQLITE_OS_WINRT + { "CreateFile2", (SYSCALL)CreateFile2, 0 }, +#else + { "CreateFile2", (SYSCALL)0, 0 }, +#endif + +#define osCreateFile2 ((HANDLE(WINAPI*)(LPCWSTR,DWORD,DWORD,DWORD, \ + LPCREATEFILE2_EXTENDED_PARAMETERS))aSyscall[68].pCurrent) + +#if SQLITE_OS_WINRT && !defined(SQLITE_OMIT_LOAD_EXTENSION) + { "LoadPackagedLibrary", (SYSCALL)LoadPackagedLibrary, 0 }, +#else + { "LoadPackagedLibrary", (SYSCALL)0, 0 }, +#endif + +#define osLoadPackagedLibrary ((HMODULE(WINAPI*)(LPCWSTR, \ + DWORD))aSyscall[69].pCurrent) + +#if SQLITE_OS_WINRT + { "GetTickCount64", (SYSCALL)GetTickCount64, 0 }, +#else + { "GetTickCount64", (SYSCALL)0, 0 }, +#endif + +#define osGetTickCount64 ((ULONGLONG(WINAPI*)(VOID))aSyscall[70].pCurrent) + +#if SQLITE_OS_WINRT + { "GetNativeSystemInfo", (SYSCALL)GetNativeSystemInfo, 0 }, +#else + { "GetNativeSystemInfo", (SYSCALL)0, 0 }, +#endif + +#define osGetNativeSystemInfo ((VOID(WINAPI*)( \ + LPSYSTEM_INFO))aSyscall[71].pCurrent) + +#if defined(SQLITE_WIN32_HAS_ANSI) + { "OutputDebugStringA", (SYSCALL)OutputDebugStringA, 0 }, +#else + { "OutputDebugStringA", (SYSCALL)0, 0 }, +#endif + +#define osOutputDebugStringA ((VOID(WINAPI*)(LPCSTR))aSyscall[72].pCurrent) + +#if defined(SQLITE_WIN32_HAS_WIDE) + { "OutputDebugStringW", (SYSCALL)OutputDebugStringW, 0 }, +#else + { "OutputDebugStringW", (SYSCALL)0, 0 }, +#endif + +#define osOutputDebugStringW ((VOID(WINAPI*)(LPCWSTR))aSyscall[73].pCurrent) + + { "GetProcessHeap", (SYSCALL)GetProcessHeap, 0 }, + +#define osGetProcessHeap ((HANDLE(WINAPI*)(VOID))aSyscall[74].pCurrent) + +#if SQLITE_OS_WINRT && (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) + { "CreateFileMappingFromApp", (SYSCALL)CreateFileMappingFromApp, 0 }, +#else + { "CreateFileMappingFromApp", (SYSCALL)0, 0 }, +#endif + +#define osCreateFileMappingFromApp ((HANDLE(WINAPI*)(HANDLE, \ + LPSECURITY_ATTRIBUTES,ULONG,ULONG64,LPCWSTR))aSyscall[75].pCurrent) + +/* +** NOTE: On some sub-platforms, the InterlockedCompareExchange "function" +** is really just a macro that uses a compiler intrinsic (e.g. x64). +** So do not try to make this is into a redefinable interface. +*/ +#if defined(InterlockedCompareExchange) + { "InterlockedCompareExchange", (SYSCALL)0, 0 }, + +#define osInterlockedCompareExchange InterlockedCompareExchange +#else + { "InterlockedCompareExchange", (SYSCALL)InterlockedCompareExchange, 0 }, + +#define osInterlockedCompareExchange ((LONG(WINAPI*)(LONG \ + SQLITE_WIN32_VOLATILE*, LONG,LONG))aSyscall[76].pCurrent) +#endif /* defined(InterlockedCompareExchange) */ + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && SQLITE_WIN32_USE_UUID + { "UuidCreate", (SYSCALL)UuidCreate, 0 }, +#else + { "UuidCreate", (SYSCALL)0, 0 }, +#endif + +#define osUuidCreate ((RPC_STATUS(RPC_ENTRY*)(UUID*))aSyscall[77].pCurrent) + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && SQLITE_WIN32_USE_UUID + { "UuidCreateSequential", (SYSCALL)UuidCreateSequential, 0 }, +#else + { "UuidCreateSequential", (SYSCALL)0, 0 }, +#endif + +#define osUuidCreateSequential \ + ((RPC_STATUS(RPC_ENTRY*)(UUID*))aSyscall[78].pCurrent) + +#if !defined(SQLITE_NO_SYNC) && SQLITE_MAX_MMAP_SIZE>0 + { "FlushViewOfFile", (SYSCALL)FlushViewOfFile, 0 }, +#else + { "FlushViewOfFile", (SYSCALL)0, 0 }, +#endif + +#define osFlushViewOfFile \ + ((BOOL(WINAPI*)(LPCVOID,SIZE_T))aSyscall[79].pCurrent) + +}; /* End of the overrideable system calls */ + +/* +** This is the xSetSystemCall() method of sqlite3_vfs for all of the +** "win32" VFSes. Return SQLITE_OK opon successfully updating the +** system call pointer, or SQLITE_NOTFOUND if there is no configurable +** system call named zName. +*/ +static int winSetSystemCall( + sqlite3_vfs *pNotUsed, /* The VFS pointer. Not used */ + const char *zName, /* Name of system call to override */ + sqlite3_syscall_ptr pNewFunc /* Pointer to new system call value */ +){ + unsigned int i; + int rc = SQLITE_NOTFOUND; + + UNUSED_PARAMETER(pNotUsed); + if( zName==0 ){ + /* If no zName is given, restore all system calls to their default + ** settings and return NULL + */ + rc = SQLITE_OK; + for(i=0; i0 ){ + memset(zDbgBuf, 0, SQLITE_WIN32_DBG_BUF_SIZE); + memcpy(zDbgBuf, zBuf, nMin); + osOutputDebugStringA(zDbgBuf); + }else{ + osOutputDebugStringA(zBuf); + } +#elif defined(SQLITE_WIN32_HAS_WIDE) + memset(zDbgBuf, 0, SQLITE_WIN32_DBG_BUF_SIZE); + if ( osMultiByteToWideChar( + osAreFileApisANSI() ? CP_ACP : CP_OEMCP, 0, zBuf, + nMin, (LPWSTR)zDbgBuf, SQLITE_WIN32_DBG_BUF_SIZE/sizeof(WCHAR))<=0 ){ + return; + } + osOutputDebugStringW((LPCWSTR)zDbgBuf); +#else + if( nMin>0 ){ + memset(zDbgBuf, 0, SQLITE_WIN32_DBG_BUF_SIZE); + memcpy(zDbgBuf, zBuf, nMin); + fprintf(stderr, "%s", zDbgBuf); + }else{ + fprintf(stderr, "%s", zBuf); + } +#endif +} + +/* +** The following routine suspends the current thread for at least ms +** milliseconds. This is equivalent to the Win32 Sleep() interface. +*/ +#if SQLITE_OS_WINRT +static HANDLE sleepObj = NULL; +#endif + +SQLITE_API void sqlite3_win32_sleep(DWORD milliseconds){ +#if SQLITE_OS_WINRT + if ( sleepObj==NULL ){ + sleepObj = osCreateEventExW(NULL, NULL, CREATE_EVENT_MANUAL_RESET, + SYNCHRONIZE); + } + assert( sleepObj!=NULL ); + osWaitForSingleObjectEx(sleepObj, milliseconds, FALSE); +#else + osSleep(milliseconds); +#endif +} + +#if SQLITE_MAX_WORKER_THREADS>0 && !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && \ + SQLITE_THREADSAFE>0 +SQLITE_PRIVATE DWORD sqlite3Win32Wait(HANDLE hObject){ + DWORD rc; + while( (rc = osWaitForSingleObjectEx(hObject, INFINITE, + TRUE))==WAIT_IO_COMPLETION ){} + return rc; +} +#endif + +/* +** Return true (non-zero) if we are running under WinNT, Win2K, WinXP, +** or WinCE. Return false (zero) for Win95, Win98, or WinME. +** +** Here is an interesting observation: Win95, Win98, and WinME lack +** the LockFileEx() API. But we can still statically link against that +** API as long as we don't call it when running Win95/98/ME. A call to +** this routine is used to determine if the host is Win95/98/ME or +** WinNT/2K/XP so that we will know whether or not we can safely call +** the LockFileEx() API. +*/ + +#if !SQLITE_WIN32_GETVERSIONEX +# define osIsNT() (1) +#elif SQLITE_OS_WINCE || SQLITE_OS_WINRT || !defined(SQLITE_WIN32_HAS_ANSI) +# define osIsNT() (1) +#elif !defined(SQLITE_WIN32_HAS_WIDE) +# define osIsNT() (0) +#else +# define osIsNT() ((sqlite3_os_type==2) || sqlite3_win32_is_nt()) +#endif + +/* +** This function determines if the machine is running a version of Windows +** based on the NT kernel. +*/ +SQLITE_API int sqlite3_win32_is_nt(void){ +#if SQLITE_OS_WINRT + /* + ** NOTE: The WinRT sub-platform is always assumed to be based on the NT + ** kernel. + */ + return 1; +#elif SQLITE_WIN32_GETVERSIONEX + if( osInterlockedCompareExchange(&sqlite3_os_type, 0, 0)==0 ){ +#if defined(SQLITE_WIN32_HAS_ANSI) + OSVERSIONINFOA sInfo; + sInfo.dwOSVersionInfoSize = sizeof(sInfo); + osGetVersionExA(&sInfo); + osInterlockedCompareExchange(&sqlite3_os_type, + (sInfo.dwPlatformId == VER_PLATFORM_WIN32_NT) ? 2 : 1, 0); +#elif defined(SQLITE_WIN32_HAS_WIDE) + OSVERSIONINFOW sInfo; + sInfo.dwOSVersionInfoSize = sizeof(sInfo); + osGetVersionExW(&sInfo); + osInterlockedCompareExchange(&sqlite3_os_type, + (sInfo.dwPlatformId == VER_PLATFORM_WIN32_NT) ? 2 : 1, 0); +#endif + } + return osInterlockedCompareExchange(&sqlite3_os_type, 2, 2)==2; +#elif SQLITE_TEST + return osInterlockedCompareExchange(&sqlite3_os_type, 2, 2)==2; +#else + /* + ** NOTE: All sub-platforms where the GetVersionEx[AW] functions are + ** deprecated are always assumed to be based on the NT kernel. + */ + return 1; +#endif +} + +#ifdef SQLITE_WIN32_MALLOC +/* +** Allocate nBytes of memory. +*/ +static void *winMemMalloc(int nBytes){ + HANDLE hHeap; + void *p; + + winMemAssertMagic(); + hHeap = winMemGetHeap(); + assert( hHeap!=0 ); + assert( hHeap!=INVALID_HANDLE_VALUE ); +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE) + assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) ); +#endif + assert( nBytes>=0 ); + p = osHeapAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, (SIZE_T)nBytes); + if( !p ){ + sqlite3_log(SQLITE_NOMEM, "failed to HeapAlloc %u bytes (%lu), heap=%p", + nBytes, osGetLastError(), (void*)hHeap); + } + return p; +} + +/* +** Free memory. +*/ +static void winMemFree(void *pPrior){ + HANDLE hHeap; + + winMemAssertMagic(); + hHeap = winMemGetHeap(); + assert( hHeap!=0 ); + assert( hHeap!=INVALID_HANDLE_VALUE ); +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE) + assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) ); +#endif + if( !pPrior ) return; /* Passing NULL to HeapFree is undefined. */ + if( !osHeapFree(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) ){ + sqlite3_log(SQLITE_NOMEM, "failed to HeapFree block %p (%lu), heap=%p", + pPrior, osGetLastError(), (void*)hHeap); + } +} + +/* +** Change the size of an existing memory allocation +*/ +static void *winMemRealloc(void *pPrior, int nBytes){ + HANDLE hHeap; + void *p; + + winMemAssertMagic(); + hHeap = winMemGetHeap(); + assert( hHeap!=0 ); + assert( hHeap!=INVALID_HANDLE_VALUE ); +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE) + assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) ); +#endif + assert( nBytes>=0 ); + if( !pPrior ){ + p = osHeapAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, (SIZE_T)nBytes); + }else{ + p = osHeapReAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior, (SIZE_T)nBytes); + } + if( !p ){ + sqlite3_log(SQLITE_NOMEM, "failed to %s %u bytes (%lu), heap=%p", + pPrior ? "HeapReAlloc" : "HeapAlloc", nBytes, osGetLastError(), + (void*)hHeap); + } + return p; +} + +/* +** Return the size of an outstanding allocation, in bytes. +*/ +static int winMemSize(void *p){ + HANDLE hHeap; + SIZE_T n; + + winMemAssertMagic(); + hHeap = winMemGetHeap(); + assert( hHeap!=0 ); + assert( hHeap!=INVALID_HANDLE_VALUE ); +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE) + assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, p) ); +#endif + if( !p ) return 0; + n = osHeapSize(hHeap, SQLITE_WIN32_HEAP_FLAGS, p); + if( n==(SIZE_T)-1 ){ + sqlite3_log(SQLITE_NOMEM, "failed to HeapSize block %p (%lu), heap=%p", + p, osGetLastError(), (void*)hHeap); + return 0; + } + return (int)n; +} + +/* +** Round up a request size to the next valid allocation size. +*/ +static int winMemRoundup(int n){ + return n; +} + +/* +** Initialize this module. +*/ +static int winMemInit(void *pAppData){ + winMemData *pWinMemData = (winMemData *)pAppData; + + if( !pWinMemData ) return SQLITE_ERROR; + assert( pWinMemData->magic1==WINMEM_MAGIC1 ); + assert( pWinMemData->magic2==WINMEM_MAGIC2 ); + +#if !SQLITE_OS_WINRT && SQLITE_WIN32_HEAP_CREATE + if( !pWinMemData->hHeap ){ + DWORD dwInitialSize = SQLITE_WIN32_HEAP_INIT_SIZE; + DWORD dwMaximumSize = (DWORD)sqlite3GlobalConfig.nHeap; + if( dwMaximumSize==0 ){ + dwMaximumSize = SQLITE_WIN32_HEAP_MAX_SIZE; + }else if( dwInitialSize>dwMaximumSize ){ + dwInitialSize = dwMaximumSize; + } + pWinMemData->hHeap = osHeapCreate(SQLITE_WIN32_HEAP_FLAGS, + dwInitialSize, dwMaximumSize); + if( !pWinMemData->hHeap ){ + sqlite3_log(SQLITE_NOMEM, + "failed to HeapCreate (%lu), flags=%u, initSize=%lu, maxSize=%lu", + osGetLastError(), SQLITE_WIN32_HEAP_FLAGS, dwInitialSize, + dwMaximumSize); + return SQLITE_NOMEM_BKPT; + } + pWinMemData->bOwned = TRUE; + assert( pWinMemData->bOwned ); + } +#else + pWinMemData->hHeap = osGetProcessHeap(); + if( !pWinMemData->hHeap ){ + sqlite3_log(SQLITE_NOMEM, + "failed to GetProcessHeap (%lu)", osGetLastError()); + return SQLITE_NOMEM_BKPT; + } + pWinMemData->bOwned = FALSE; + assert( !pWinMemData->bOwned ); +#endif + assert( pWinMemData->hHeap!=0 ); + assert( pWinMemData->hHeap!=INVALID_HANDLE_VALUE ); +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE) + assert( osHeapValidate(pWinMemData->hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) ); +#endif + return SQLITE_OK; +} + +/* +** Deinitialize this module. +*/ +static void winMemShutdown(void *pAppData){ + winMemData *pWinMemData = (winMemData *)pAppData; + + if( !pWinMemData ) return; + assert( pWinMemData->magic1==WINMEM_MAGIC1 ); + assert( pWinMemData->magic2==WINMEM_MAGIC2 ); + + if( pWinMemData->hHeap ){ + assert( pWinMemData->hHeap!=INVALID_HANDLE_VALUE ); +#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE) + assert( osHeapValidate(pWinMemData->hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) ); +#endif + if( pWinMemData->bOwned ){ + if( !osHeapDestroy(pWinMemData->hHeap) ){ + sqlite3_log(SQLITE_NOMEM, "failed to HeapDestroy (%lu), heap=%p", + osGetLastError(), (void*)pWinMemData->hHeap); + } + pWinMemData->bOwned = FALSE; + } + pWinMemData->hHeap = NULL; + } +} + +/* +** Populate the low-level memory allocation function pointers in +** sqlite3GlobalConfig.m with pointers to the routines in this file. The +** arguments specify the block of memory to manage. +** +** This routine is only called by sqlite3_config(), and therefore +** is not required to be threadsafe (it is not). +*/ +SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetWin32(void){ + static const sqlite3_mem_methods winMemMethods = { + winMemMalloc, + winMemFree, + winMemRealloc, + winMemSize, + winMemRoundup, + winMemInit, + winMemShutdown, + &win_mem_data + }; + return &winMemMethods; +} + +SQLITE_PRIVATE void sqlite3MemSetDefault(void){ + sqlite3_config(SQLITE_CONFIG_MALLOC, sqlite3MemGetWin32()); +} +#endif /* SQLITE_WIN32_MALLOC */ + +/* +** Convert a UTF-8 string to Microsoft Unicode. +** +** Space to hold the returned string is obtained from sqlite3_malloc(). +*/ +static LPWSTR winUtf8ToUnicode(const char *zText){ + int nChar; + LPWSTR zWideText; + + nChar = osMultiByteToWideChar(CP_UTF8, 0, zText, -1, NULL, 0); + if( nChar==0 ){ + return 0; + } + zWideText = sqlite3MallocZero( nChar*sizeof(WCHAR) ); + if( zWideText==0 ){ + return 0; + } + nChar = osMultiByteToWideChar(CP_UTF8, 0, zText, -1, zWideText, + nChar); + if( nChar==0 ){ + sqlite3_free(zWideText); + zWideText = 0; + } + return zWideText; +} + +/* +** Convert a Microsoft Unicode string to UTF-8. +** +** Space to hold the returned string is obtained from sqlite3_malloc(). +*/ +static char *winUnicodeToUtf8(LPCWSTR zWideText){ + int nByte; + char *zText; + + nByte = osWideCharToMultiByte(CP_UTF8, 0, zWideText, -1, 0, 0, 0, 0); + if( nByte == 0 ){ + return 0; + } + zText = sqlite3MallocZero( nByte ); + if( zText==0 ){ + return 0; + } + nByte = osWideCharToMultiByte(CP_UTF8, 0, zWideText, -1, zText, nByte, + 0, 0); + if( nByte == 0 ){ + sqlite3_free(zText); + zText = 0; + } + return zText; +} + +/* +** Convert an ANSI string to Microsoft Unicode, using the ANSI or OEM +** code page. +** +** Space to hold the returned string is obtained from sqlite3_malloc(). +*/ +static LPWSTR winMbcsToUnicode(const char *zText, int useAnsi){ + int nByte; + LPWSTR zMbcsText; + int codepage = useAnsi ? CP_ACP : CP_OEMCP; + + nByte = osMultiByteToWideChar(codepage, 0, zText, -1, NULL, + 0)*sizeof(WCHAR); + if( nByte==0 ){ + return 0; + } + zMbcsText = sqlite3MallocZero( nByte*sizeof(WCHAR) ); + if( zMbcsText==0 ){ + return 0; + } + nByte = osMultiByteToWideChar(codepage, 0, zText, -1, zMbcsText, + nByte); + if( nByte==0 ){ + sqlite3_free(zMbcsText); + zMbcsText = 0; + } + return zMbcsText; +} + +/* +** Convert a Microsoft Unicode string to a multi-byte character string, +** using the ANSI or OEM code page. +** +** Space to hold the returned string is obtained from sqlite3_malloc(). +*/ +static char *winUnicodeToMbcs(LPCWSTR zWideText, int useAnsi){ + int nByte; + char *zText; + int codepage = useAnsi ? CP_ACP : CP_OEMCP; + + nByte = osWideCharToMultiByte(codepage, 0, zWideText, -1, 0, 0, 0, 0); + if( nByte == 0 ){ + return 0; + } + zText = sqlite3MallocZero( nByte ); + if( zText==0 ){ + return 0; + } + nByte = osWideCharToMultiByte(codepage, 0, zWideText, -1, zText, + nByte, 0, 0); + if( nByte == 0 ){ + sqlite3_free(zText); + zText = 0; + } + return zText; +} + +/* +** Convert a multi-byte character string to UTF-8. +** +** Space to hold the returned string is obtained from sqlite3_malloc(). +*/ +static char *winMbcsToUtf8(const char *zText, int useAnsi){ + char *zTextUtf8; + LPWSTR zTmpWide; + + zTmpWide = winMbcsToUnicode(zText, useAnsi); + if( zTmpWide==0 ){ + return 0; + } + zTextUtf8 = winUnicodeToUtf8(zTmpWide); + sqlite3_free(zTmpWide); + return zTextUtf8; +} + +/* +** Convert a UTF-8 string to a multi-byte character string. +** +** Space to hold the returned string is obtained from sqlite3_malloc(). +*/ +static char *winUtf8ToMbcs(const char *zText, int useAnsi){ + char *zTextMbcs; + LPWSTR zTmpWide; + + zTmpWide = winUtf8ToUnicode(zText); + if( zTmpWide==0 ){ + return 0; + } + zTextMbcs = winUnicodeToMbcs(zTmpWide, useAnsi); + sqlite3_free(zTmpWide); + return zTextMbcs; +} + +/* +** This is a public wrapper for the winUtf8ToUnicode() function. +*/ +SQLITE_API LPWSTR sqlite3_win32_utf8_to_unicode(const char *zText){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !zText ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + return winUtf8ToUnicode(zText); +} + +/* +** This is a public wrapper for the winUnicodeToUtf8() function. +*/ +SQLITE_API char *sqlite3_win32_unicode_to_utf8(LPCWSTR zWideText){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !zWideText ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + return winUnicodeToUtf8(zWideText); +} + +/* +** This is a public wrapper for the winMbcsToUtf8() function. +*/ +SQLITE_API char *sqlite3_win32_mbcs_to_utf8(const char *zText){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !zText ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + return winMbcsToUtf8(zText, osAreFileApisANSI()); +} + +/* +** This is a public wrapper for the winMbcsToUtf8() function. +*/ +SQLITE_API char *sqlite3_win32_mbcs_to_utf8_v2(const char *zText, int useAnsi){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !zText ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + return winMbcsToUtf8(zText, useAnsi); +} + +/* +** This is a public wrapper for the winUtf8ToMbcs() function. +*/ +SQLITE_API char *sqlite3_win32_utf8_to_mbcs(const char *zText){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !zText ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + return winUtf8ToMbcs(zText, osAreFileApisANSI()); +} + +/* +** This is a public wrapper for the winUtf8ToMbcs() function. +*/ +SQLITE_API char *sqlite3_win32_utf8_to_mbcs_v2(const char *zText, int useAnsi){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !zText ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize() ) return 0; +#endif + return winUtf8ToMbcs(zText, useAnsi); +} + +/* +** This function is the same as sqlite3_win32_set_directory (below); however, +** it accepts a UTF-8 string. +*/ +SQLITE_API int sqlite3_win32_set_directory8( + unsigned long type, /* Identifier for directory being set or reset */ + const char *zValue /* New value for directory being set or reset */ +){ + char **ppDirectory = 0; + int rc; +#ifndef SQLITE_OMIT_AUTOINIT + rc = sqlite3_initialize(); + if( rc ) return rc; +#endif + sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR)); + if( type==SQLITE_WIN32_DATA_DIRECTORY_TYPE ){ + ppDirectory = &sqlite3_data_directory; + }else if( type==SQLITE_WIN32_TEMP_DIRECTORY_TYPE ){ + ppDirectory = &sqlite3_temp_directory; + } + assert( !ppDirectory || type==SQLITE_WIN32_DATA_DIRECTORY_TYPE + || type==SQLITE_WIN32_TEMP_DIRECTORY_TYPE + ); + assert( !ppDirectory || sqlite3MemdebugHasType(*ppDirectory, MEMTYPE_HEAP) ); + if( ppDirectory ){ + char *zCopy = 0; + if( zValue && zValue[0] ){ + zCopy = sqlite3_mprintf("%s", zValue); + if ( zCopy==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto set_directory8_done; + } + } + sqlite3_free(*ppDirectory); + *ppDirectory = zCopy; + rc = SQLITE_OK; + }else{ + rc = SQLITE_ERROR; + } +set_directory8_done: + sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR)); + return rc; +} + +/* +** This function is the same as sqlite3_win32_set_directory (below); however, +** it accepts a UTF-16 string. +*/ +SQLITE_API int sqlite3_win32_set_directory16( + unsigned long type, /* Identifier for directory being set or reset */ + const void *zValue /* New value for directory being set or reset */ +){ + int rc; + char *zUtf8 = 0; + if( zValue ){ + zUtf8 = sqlite3_win32_unicode_to_utf8(zValue); + if( zUtf8==0 ) return SQLITE_NOMEM_BKPT; + } + rc = sqlite3_win32_set_directory8(type, zUtf8); + if( zUtf8 ) sqlite3_free(zUtf8); + return rc; +} + +/* +** This function sets the data directory or the temporary directory based on +** the provided arguments. The type argument must be 1 in order to set the +** data directory or 2 in order to set the temporary directory. The zValue +** argument is the name of the directory to use. The return value will be +** SQLITE_OK if successful. +*/ +SQLITE_API int sqlite3_win32_set_directory( + unsigned long type, /* Identifier for directory being set or reset */ + void *zValue /* New value for directory being set or reset */ +){ + return sqlite3_win32_set_directory16(type, zValue); +} + +/* +** The return value of winGetLastErrorMsg +** is zero if the error message fits in the buffer, or non-zero +** otherwise (if the message was truncated). +*/ +static int winGetLastErrorMsg(DWORD lastErrno, int nBuf, char *zBuf){ + /* FormatMessage returns 0 on failure. Otherwise it + ** returns the number of TCHARs written to the output + ** buffer, excluding the terminating null char. + */ + DWORD dwLen = 0; + char *zOut = 0; + + if( osIsNT() ){ +#if SQLITE_OS_WINRT + WCHAR zTempWide[SQLITE_WIN32_MAX_ERRMSG_CHARS+1]; + dwLen = osFormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + lastErrno, + 0, + zTempWide, + SQLITE_WIN32_MAX_ERRMSG_CHARS, + 0); +#else + LPWSTR zTempWide = NULL; + dwLen = osFormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + lastErrno, + 0, + (LPWSTR) &zTempWide, + 0, + 0); +#endif + if( dwLen > 0 ){ + /* allocate a buffer and convert to UTF8 */ + sqlite3BeginBenignMalloc(); + zOut = winUnicodeToUtf8(zTempWide); + sqlite3EndBenignMalloc(); +#if !SQLITE_OS_WINRT + /* free the system buffer allocated by FormatMessage */ + osLocalFree(zTempWide); +#endif + } + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + char *zTemp = NULL; + dwLen = osFormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + lastErrno, + 0, + (LPSTR) &zTemp, + 0, + 0); + if( dwLen > 0 ){ + /* allocate a buffer and convert to UTF8 */ + sqlite3BeginBenignMalloc(); + zOut = winMbcsToUtf8(zTemp, osAreFileApisANSI()); + sqlite3EndBenignMalloc(); + /* free the system buffer allocated by FormatMessage */ + osLocalFree(zTemp); + } + } +#endif + if( 0 == dwLen ){ + sqlite3_snprintf(nBuf, zBuf, "OsError 0x%lx (%lu)", lastErrno, lastErrno); + }else{ + /* copy a maximum of nBuf chars to output buffer */ + sqlite3_snprintf(nBuf, zBuf, "%s", zOut); + /* free the UTF8 buffer */ + sqlite3_free(zOut); + } + return 0; +} + +/* +** +** This function - winLogErrorAtLine() - is only ever called via the macro +** winLogError(). +** +** This routine is invoked after an error occurs in an OS function. +** It logs a message using sqlite3_log() containing the current value of +** error code and, if possible, the human-readable equivalent from +** FormatMessage. +** +** The first argument passed to the macro should be the error code that +** will be returned to SQLite (e.g. SQLITE_IOERR_DELETE, SQLITE_CANTOPEN). +** The two subsequent arguments should be the name of the OS function that +** failed and the associated file-system path, if any. +*/ +#define winLogError(a,b,c,d) winLogErrorAtLine(a,b,c,d,__LINE__) +static int winLogErrorAtLine( + int errcode, /* SQLite error code */ + DWORD lastErrno, /* Win32 last error */ + const char *zFunc, /* Name of OS function that failed */ + const char *zPath, /* File path associated with error */ + int iLine /* Source line number where error occurred */ +){ + char zMsg[500]; /* Human readable error text */ + int i; /* Loop counter */ + + zMsg[0] = 0; + winGetLastErrorMsg(lastErrno, sizeof(zMsg), zMsg); + assert( errcode!=SQLITE_OK ); + if( zPath==0 ) zPath = ""; + for(i=0; zMsg[i] && zMsg[i]!='\r' && zMsg[i]!='\n'; i++){} + zMsg[i] = 0; + sqlite3_log(errcode, + "os_win.c:%d: (%lu) %s(%s) - %s", + iLine, lastErrno, zFunc, zPath, zMsg + ); + + return errcode; +} + +/* +** The number of times that a ReadFile(), WriteFile(), and DeleteFile() +** will be retried following a locking error - probably caused by +** antivirus software. Also the initial delay before the first retry. +** The delay increases linearly with each retry. +*/ +#ifndef SQLITE_WIN32_IOERR_RETRY +# define SQLITE_WIN32_IOERR_RETRY 10 +#endif +#ifndef SQLITE_WIN32_IOERR_RETRY_DELAY +# define SQLITE_WIN32_IOERR_RETRY_DELAY 25 +#endif +static int winIoerrRetry = SQLITE_WIN32_IOERR_RETRY; +static int winIoerrRetryDelay = SQLITE_WIN32_IOERR_RETRY_DELAY; + +/* +** The "winIoerrCanRetry1" macro is used to determine if a particular I/O +** error code obtained via GetLastError() is eligible to be retried. It +** must accept the error code DWORD as its only argument and should return +** non-zero if the error code is transient in nature and the operation +** responsible for generating the original error might succeed upon being +** retried. The argument to this macro should be a variable. +** +** Additionally, a macro named "winIoerrCanRetry2" may be defined. If it +** is defined, it will be consulted only when the macro "winIoerrCanRetry1" +** returns zero. The "winIoerrCanRetry2" macro is completely optional and +** may be used to include additional error codes in the set that should +** result in the failing I/O operation being retried by the caller. If +** defined, the "winIoerrCanRetry2" macro must exhibit external semantics +** identical to those of the "winIoerrCanRetry1" macro. +*/ +#if !defined(winIoerrCanRetry1) +#define winIoerrCanRetry1(a) (((a)==ERROR_ACCESS_DENIED) || \ + ((a)==ERROR_SHARING_VIOLATION) || \ + ((a)==ERROR_LOCK_VIOLATION) || \ + ((a)==ERROR_DEV_NOT_EXIST) || \ + ((a)==ERROR_NETNAME_DELETED) || \ + ((a)==ERROR_SEM_TIMEOUT) || \ + ((a)==ERROR_NETWORK_UNREACHABLE)) +#endif + +/* +** If a ReadFile() or WriteFile() error occurs, invoke this routine +** to see if it should be retried. Return TRUE to retry. Return FALSE +** to give up with an error. +*/ +static int winRetryIoerr(int *pnRetry, DWORD *pError){ + DWORD e = osGetLastError(); + if( *pnRetry>=winIoerrRetry ){ + if( pError ){ + *pError = e; + } + return 0; + } + if( winIoerrCanRetry1(e) ){ + sqlite3_win32_sleep(winIoerrRetryDelay*(1+*pnRetry)); + ++*pnRetry; + return 1; + } +#if defined(winIoerrCanRetry2) + else if( winIoerrCanRetry2(e) ){ + sqlite3_win32_sleep(winIoerrRetryDelay*(1+*pnRetry)); + ++*pnRetry; + return 1; + } +#endif + if( pError ){ + *pError = e; + } + return 0; +} + +/* +** Log a I/O error retry episode. +*/ +static void winLogIoerr(int nRetry, int lineno){ + if( nRetry ){ + sqlite3_log(SQLITE_NOTICE, + "delayed %dms for lock/sharing conflict at line %d", + winIoerrRetryDelay*nRetry*(nRetry+1)/2, lineno + ); + } +} + +/* +** This #if does not rely on the SQLITE_OS_WINCE define because the +** corresponding section in "date.c" cannot use it. +*/ +#if !defined(SQLITE_OMIT_LOCALTIME) && defined(_WIN32_WCE) && \ + (!defined(SQLITE_MSVC_LOCALTIME_API) || !SQLITE_MSVC_LOCALTIME_API) +/* +** The MSVC CRT on Windows CE may not have a localtime() function. +** So define a substitute. +*/ +/* # include */ +struct tm *__cdecl localtime(const time_t *t) +{ + static struct tm y; + FILETIME uTm, lTm; + SYSTEMTIME pTm; + sqlite3_int64 t64; + t64 = *t; + t64 = (t64 + 11644473600)*10000000; + uTm.dwLowDateTime = (DWORD)(t64 & 0xFFFFFFFF); + uTm.dwHighDateTime= (DWORD)(t64 >> 32); + osFileTimeToLocalFileTime(&uTm,&lTm); + osFileTimeToSystemTime(&lTm,&pTm); + y.tm_year = pTm.wYear - 1900; + y.tm_mon = pTm.wMonth - 1; + y.tm_wday = pTm.wDayOfWeek; + y.tm_mday = pTm.wDay; + y.tm_hour = pTm.wHour; + y.tm_min = pTm.wMinute; + y.tm_sec = pTm.wSecond; + return &y; +} +#endif + +#if SQLITE_OS_WINCE +/************************************************************************* +** This section contains code for WinCE only. +*/ +#define HANDLE_TO_WINFILE(a) (winFile*)&((char*)a)[-(int)offsetof(winFile,h)] + +/* +** Acquire a lock on the handle h +*/ +static void winceMutexAcquire(HANDLE h){ + DWORD dwErr; + do { + dwErr = osWaitForSingleObject(h, INFINITE); + } while (dwErr != WAIT_OBJECT_0 && dwErr != WAIT_ABANDONED); +} +/* +** Release a lock acquired by winceMutexAcquire() +*/ +#define winceMutexRelease(h) ReleaseMutex(h) + +/* +** Create the mutex and shared memory used for locking in the file +** descriptor pFile +*/ +static int winceCreateLock(const char *zFilename, winFile *pFile){ + LPWSTR zTok; + LPWSTR zName; + DWORD lastErrno; + BOOL bLogged = FALSE; + BOOL bInit = TRUE; + + zName = winUtf8ToUnicode(zFilename); + if( zName==0 ){ + /* out of memory */ + return SQLITE_IOERR_NOMEM_BKPT; + } + + /* Initialize the local lockdata */ + memset(&pFile->local, 0, sizeof(pFile->local)); + + /* Replace the backslashes from the filename and lowercase it + ** to derive a mutex name. */ + zTok = osCharLowerW(zName); + for (;*zTok;zTok++){ + if (*zTok == '\\') *zTok = '_'; + } + + /* Create/open the named mutex */ + pFile->hMutex = osCreateMutexW(NULL, FALSE, zName); + if (!pFile->hMutex){ + pFile->lastErrno = osGetLastError(); + sqlite3_free(zName); + return winLogError(SQLITE_IOERR, pFile->lastErrno, + "winceCreateLock1", zFilename); + } + + /* Acquire the mutex before continuing */ + winceMutexAcquire(pFile->hMutex); + + /* Since the names of named mutexes, semaphores, file mappings etc are + ** case-sensitive, take advantage of that by uppercasing the mutex name + ** and using that as the shared filemapping name. + */ + osCharUpperW(zName); + pFile->hShared = osCreateFileMappingW(INVALID_HANDLE_VALUE, NULL, + PAGE_READWRITE, 0, sizeof(winceLock), + zName); + + /* Set a flag that indicates we're the first to create the memory so it + ** must be zero-initialized */ + lastErrno = osGetLastError(); + if (lastErrno == ERROR_ALREADY_EXISTS){ + bInit = FALSE; + } + + sqlite3_free(zName); + + /* If we succeeded in making the shared memory handle, map it. */ + if( pFile->hShared ){ + pFile->shared = (winceLock*)osMapViewOfFile(pFile->hShared, + FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, sizeof(winceLock)); + /* If mapping failed, close the shared memory handle and erase it */ + if( !pFile->shared ){ + pFile->lastErrno = osGetLastError(); + winLogError(SQLITE_IOERR, pFile->lastErrno, + "winceCreateLock2", zFilename); + bLogged = TRUE; + osCloseHandle(pFile->hShared); + pFile->hShared = NULL; + } + } + + /* If shared memory could not be created, then close the mutex and fail */ + if( pFile->hShared==NULL ){ + if( !bLogged ){ + pFile->lastErrno = lastErrno; + winLogError(SQLITE_IOERR, pFile->lastErrno, + "winceCreateLock3", zFilename); + bLogged = TRUE; + } + winceMutexRelease(pFile->hMutex); + osCloseHandle(pFile->hMutex); + pFile->hMutex = NULL; + return SQLITE_IOERR; + } + + /* Initialize the shared memory if we're supposed to */ + if( bInit ){ + memset(pFile->shared, 0, sizeof(winceLock)); + } + + winceMutexRelease(pFile->hMutex); + return SQLITE_OK; +} + +/* +** Destroy the part of winFile that deals with wince locks +*/ +static void winceDestroyLock(winFile *pFile){ + if (pFile->hMutex){ + /* Acquire the mutex */ + winceMutexAcquire(pFile->hMutex); + + /* The following blocks should probably assert in debug mode, but they + are to cleanup in case any locks remained open */ + if (pFile->local.nReaders){ + pFile->shared->nReaders --; + } + if (pFile->local.bReserved){ + pFile->shared->bReserved = FALSE; + } + if (pFile->local.bPending){ + pFile->shared->bPending = FALSE; + } + if (pFile->local.bExclusive){ + pFile->shared->bExclusive = FALSE; + } + + /* De-reference and close our copy of the shared memory handle */ + osUnmapViewOfFile(pFile->shared); + osCloseHandle(pFile->hShared); + + /* Done with the mutex */ + winceMutexRelease(pFile->hMutex); + osCloseHandle(pFile->hMutex); + pFile->hMutex = NULL; + } +} + +/* +** An implementation of the LockFile() API of Windows for CE +*/ +static BOOL winceLockFile( + LPHANDLE phFile, + DWORD dwFileOffsetLow, + DWORD dwFileOffsetHigh, + DWORD nNumberOfBytesToLockLow, + DWORD nNumberOfBytesToLockHigh +){ + winFile *pFile = HANDLE_TO_WINFILE(phFile); + BOOL bReturn = FALSE; + + UNUSED_PARAMETER(dwFileOffsetHigh); + UNUSED_PARAMETER(nNumberOfBytesToLockHigh); + + if (!pFile->hMutex) return TRUE; + winceMutexAcquire(pFile->hMutex); + + /* Wanting an exclusive lock? */ + if (dwFileOffsetLow == (DWORD)SHARED_FIRST + && nNumberOfBytesToLockLow == (DWORD)SHARED_SIZE){ + if (pFile->shared->nReaders == 0 && pFile->shared->bExclusive == 0){ + pFile->shared->bExclusive = TRUE; + pFile->local.bExclusive = TRUE; + bReturn = TRUE; + } + } + + /* Want a read-only lock? */ + else if (dwFileOffsetLow == (DWORD)SHARED_FIRST && + nNumberOfBytesToLockLow == 1){ + if (pFile->shared->bExclusive == 0){ + pFile->local.nReaders ++; + if (pFile->local.nReaders == 1){ + pFile->shared->nReaders ++; + } + bReturn = TRUE; + } + } + + /* Want a pending lock? */ + else if (dwFileOffsetLow == (DWORD)PENDING_BYTE + && nNumberOfBytesToLockLow == 1){ + /* If no pending lock has been acquired, then acquire it */ + if (pFile->shared->bPending == 0) { + pFile->shared->bPending = TRUE; + pFile->local.bPending = TRUE; + bReturn = TRUE; + } + } + + /* Want a reserved lock? */ + else if (dwFileOffsetLow == (DWORD)RESERVED_BYTE + && nNumberOfBytesToLockLow == 1){ + if (pFile->shared->bReserved == 0) { + pFile->shared->bReserved = TRUE; + pFile->local.bReserved = TRUE; + bReturn = TRUE; + } + } + + winceMutexRelease(pFile->hMutex); + return bReturn; +} + +/* +** An implementation of the UnlockFile API of Windows for CE +*/ +static BOOL winceUnlockFile( + LPHANDLE phFile, + DWORD dwFileOffsetLow, + DWORD dwFileOffsetHigh, + DWORD nNumberOfBytesToUnlockLow, + DWORD nNumberOfBytesToUnlockHigh +){ + winFile *pFile = HANDLE_TO_WINFILE(phFile); + BOOL bReturn = FALSE; + + UNUSED_PARAMETER(dwFileOffsetHigh); + UNUSED_PARAMETER(nNumberOfBytesToUnlockHigh); + + if (!pFile->hMutex) return TRUE; + winceMutexAcquire(pFile->hMutex); + + /* Releasing a reader lock or an exclusive lock */ + if (dwFileOffsetLow == (DWORD)SHARED_FIRST){ + /* Did we have an exclusive lock? */ + if (pFile->local.bExclusive){ + assert(nNumberOfBytesToUnlockLow == (DWORD)SHARED_SIZE); + pFile->local.bExclusive = FALSE; + pFile->shared->bExclusive = FALSE; + bReturn = TRUE; + } + + /* Did we just have a reader lock? */ + else if (pFile->local.nReaders){ + assert(nNumberOfBytesToUnlockLow == (DWORD)SHARED_SIZE + || nNumberOfBytesToUnlockLow == 1); + pFile->local.nReaders --; + if (pFile->local.nReaders == 0) + { + pFile->shared->nReaders --; + } + bReturn = TRUE; + } + } + + /* Releasing a pending lock */ + else if (dwFileOffsetLow == (DWORD)PENDING_BYTE + && nNumberOfBytesToUnlockLow == 1){ + if (pFile->local.bPending){ + pFile->local.bPending = FALSE; + pFile->shared->bPending = FALSE; + bReturn = TRUE; + } + } + /* Releasing a reserved lock */ + else if (dwFileOffsetLow == (DWORD)RESERVED_BYTE + && nNumberOfBytesToUnlockLow == 1){ + if (pFile->local.bReserved) { + pFile->local.bReserved = FALSE; + pFile->shared->bReserved = FALSE; + bReturn = TRUE; + } + } + + winceMutexRelease(pFile->hMutex); + return bReturn; +} +/* +** End of the special code for wince +*****************************************************************************/ +#endif /* SQLITE_OS_WINCE */ + +/* +** Lock a file region. +*/ +static BOOL winLockFile( + LPHANDLE phFile, + DWORD flags, + DWORD offsetLow, + DWORD offsetHigh, + DWORD numBytesLow, + DWORD numBytesHigh +){ +#if SQLITE_OS_WINCE + /* + ** NOTE: Windows CE is handled differently here due its lack of the Win32 + ** API LockFile. + */ + return winceLockFile(phFile, offsetLow, offsetHigh, + numBytesLow, numBytesHigh); +#else + if( osIsNT() ){ + OVERLAPPED ovlp; + memset(&ovlp, 0, sizeof(OVERLAPPED)); + ovlp.Offset = offsetLow; + ovlp.OffsetHigh = offsetHigh; + return osLockFileEx(*phFile, flags, 0, numBytesLow, numBytesHigh, &ovlp); + }else{ + return osLockFile(*phFile, offsetLow, offsetHigh, numBytesLow, + numBytesHigh); + } +#endif +} + +/* +** Unlock a file region. + */ +static BOOL winUnlockFile( + LPHANDLE phFile, + DWORD offsetLow, + DWORD offsetHigh, + DWORD numBytesLow, + DWORD numBytesHigh +){ +#if SQLITE_OS_WINCE + /* + ** NOTE: Windows CE is handled differently here due its lack of the Win32 + ** API UnlockFile. + */ + return winceUnlockFile(phFile, offsetLow, offsetHigh, + numBytesLow, numBytesHigh); +#else + if( osIsNT() ){ + OVERLAPPED ovlp; + memset(&ovlp, 0, sizeof(OVERLAPPED)); + ovlp.Offset = offsetLow; + ovlp.OffsetHigh = offsetHigh; + return osUnlockFileEx(*phFile, 0, numBytesLow, numBytesHigh, &ovlp); + }else{ + return osUnlockFile(*phFile, offsetLow, offsetHigh, numBytesLow, + numBytesHigh); + } +#endif +} + +/***************************************************************************** +** The next group of routines implement the I/O methods specified +** by the sqlite3_io_methods object. +******************************************************************************/ + +/* +** Some Microsoft compilers lack this definition. +*/ +#ifndef INVALID_SET_FILE_POINTER +# define INVALID_SET_FILE_POINTER ((DWORD)-1) +#endif + +/* +** Move the current position of the file handle passed as the first +** argument to offset iOffset within the file. If successful, return 0. +** Otherwise, set pFile->lastErrno and return non-zero. +*/ +static int winSeekFile(winFile *pFile, sqlite3_int64 iOffset){ +#if !SQLITE_OS_WINRT + LONG upperBits; /* Most sig. 32 bits of new offset */ + LONG lowerBits; /* Least sig. 32 bits of new offset */ + DWORD dwRet; /* Value returned by SetFilePointer() */ + DWORD lastErrno; /* Value returned by GetLastError() */ + + OSTRACE(("SEEK file=%p, offset=%lld\n", pFile->h, iOffset)); + + upperBits = (LONG)((iOffset>>32) & 0x7fffffff); + lowerBits = (LONG)(iOffset & 0xffffffff); + + /* API oddity: If successful, SetFilePointer() returns a dword + ** containing the lower 32-bits of the new file-offset. Or, if it fails, + ** it returns INVALID_SET_FILE_POINTER. However according to MSDN, + ** INVALID_SET_FILE_POINTER may also be a valid new offset. So to determine + ** whether an error has actually occurred, it is also necessary to call + ** GetLastError(). + */ + dwRet = osSetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN); + + if( (dwRet==INVALID_SET_FILE_POINTER + && ((lastErrno = osGetLastError())!=NO_ERROR)) ){ + pFile->lastErrno = lastErrno; + winLogError(SQLITE_IOERR_SEEK, pFile->lastErrno, + "winSeekFile", pFile->zPath); + OSTRACE(("SEEK file=%p, rc=SQLITE_IOERR_SEEK\n", pFile->h)); + return 1; + } + + OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h)); + return 0; +#else + /* + ** Same as above, except that this implementation works for WinRT. + */ + + LARGE_INTEGER x; /* The new offset */ + BOOL bRet; /* Value returned by SetFilePointerEx() */ + + x.QuadPart = iOffset; + bRet = osSetFilePointerEx(pFile->h, x, 0, FILE_BEGIN); + + if(!bRet){ + pFile->lastErrno = osGetLastError(); + winLogError(SQLITE_IOERR_SEEK, pFile->lastErrno, + "winSeekFile", pFile->zPath); + OSTRACE(("SEEK file=%p, rc=SQLITE_IOERR_SEEK\n", pFile->h)); + return 1; + } + + OSTRACE(("SEEK file=%p, rc=SQLITE_OK\n", pFile->h)); + return 0; +#endif +} + +#if SQLITE_MAX_MMAP_SIZE>0 +/* Forward references to VFS helper methods used for memory mapped files */ +static int winMapfile(winFile*, sqlite3_int64); +static int winUnmapfile(winFile*); +#endif + +/* +** Close a file. +** +** It is reported that an attempt to close a handle might sometimes +** fail. This is a very unreasonable result, but Windows is notorious +** for being unreasonable so I do not doubt that it might happen. If +** the close fails, we pause for 100 milliseconds and try again. As +** many as MX_CLOSE_ATTEMPT attempts to close the handle are made before +** giving up and returning an error. +*/ +#define MX_CLOSE_ATTEMPT 3 +static int winClose(sqlite3_file *id){ + int rc, cnt = 0; + winFile *pFile = (winFile*)id; + + assert( id!=0 ); +#ifndef SQLITE_OMIT_WAL + assert( pFile->pShm==0 ); +#endif + assert( pFile->h!=NULL && pFile->h!=INVALID_HANDLE_VALUE ); + OSTRACE(("CLOSE pid=%lu, pFile=%p, file=%p\n", + osGetCurrentProcessId(), pFile, pFile->h)); + +#if SQLITE_MAX_MMAP_SIZE>0 + winUnmapfile(pFile); +#endif + + do{ + rc = osCloseHandle(pFile->h); + /* SimulateIOError( rc=0; cnt=MX_CLOSE_ATTEMPT; ); */ + }while( rc==0 && ++cnt < MX_CLOSE_ATTEMPT && (sqlite3_win32_sleep(100), 1) ); +#if SQLITE_OS_WINCE +#define WINCE_DELETION_ATTEMPTS 3 + { + winVfsAppData *pAppData = (winVfsAppData*)pFile->pVfs->pAppData; + if( pAppData==NULL || !pAppData->bNoLock ){ + winceDestroyLock(pFile); + } + } + if( pFile->zDeleteOnClose ){ + int cnt = 0; + while( + osDeleteFileW(pFile->zDeleteOnClose)==0 + && osGetFileAttributesW(pFile->zDeleteOnClose)!=0xffffffff + && cnt++ < WINCE_DELETION_ATTEMPTS + ){ + sqlite3_win32_sleep(100); /* Wait a little before trying again */ + } + sqlite3_free(pFile->zDeleteOnClose); + } +#endif + if( rc ){ + pFile->h = NULL; + } + OpenCounter(-1); + OSTRACE(("CLOSE pid=%lu, pFile=%p, file=%p, rc=%s\n", + osGetCurrentProcessId(), pFile, pFile->h, rc ? "ok" : "failed")); + return rc ? SQLITE_OK + : winLogError(SQLITE_IOERR_CLOSE, osGetLastError(), + "winClose", pFile->zPath); +} + +/* +** Read data from a file into a buffer. Return SQLITE_OK if all +** bytes were read successfully and SQLITE_IOERR if anything goes +** wrong. +*/ +static int winRead( + sqlite3_file *id, /* File to read from */ + void *pBuf, /* Write content into this buffer */ + int amt, /* Number of bytes to read */ + sqlite3_int64 offset /* Begin reading at this offset */ +){ +#if !SQLITE_OS_WINCE && !defined(SQLITE_WIN32_NO_OVERLAPPED) + OVERLAPPED overlapped; /* The offset for ReadFile. */ +#endif + winFile *pFile = (winFile*)id; /* file handle */ + DWORD nRead; /* Number of bytes actually read from file */ + int nRetry = 0; /* Number of retrys */ + + assert( id!=0 ); + assert( amt>0 ); + assert( offset>=0 ); + SimulateIOError(return SQLITE_IOERR_READ); + OSTRACE(("READ pid=%lu, pFile=%p, file=%p, buffer=%p, amount=%d, " + "offset=%lld, lock=%d\n", osGetCurrentProcessId(), pFile, + pFile->h, pBuf, amt, offset, pFile->locktype)); + +#if SQLITE_MAX_MMAP_SIZE>0 + /* Deal with as much of this read request as possible by transfering + ** data from the memory mapping using memcpy(). */ + if( offsetmmapSize ){ + if( offset+amt <= pFile->mmapSize ){ + memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt); + OSTRACE(("READ-MMAP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_OK; + }else{ + int nCopy = (int)(pFile->mmapSize - offset); + memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy); + pBuf = &((u8 *)pBuf)[nCopy]; + amt -= nCopy; + offset += nCopy; + } + } +#endif + +#if SQLITE_OS_WINCE || defined(SQLITE_WIN32_NO_OVERLAPPED) + if( winSeekFile(pFile, offset) ){ + OSTRACE(("READ pid=%lu, pFile=%p, file=%p, rc=SQLITE_FULL\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_FULL; + } + while( !osReadFile(pFile->h, pBuf, amt, &nRead, 0) ){ +#else + memset(&overlapped, 0, sizeof(OVERLAPPED)); + overlapped.Offset = (LONG)(offset & 0xffffffff); + overlapped.OffsetHigh = (LONG)((offset>>32) & 0x7fffffff); + while( !osReadFile(pFile->h, pBuf, amt, &nRead, &overlapped) && + osGetLastError()!=ERROR_HANDLE_EOF ){ +#endif + DWORD lastErrno; + if( winRetryIoerr(&nRetry, &lastErrno) ) continue; + pFile->lastErrno = lastErrno; + OSTRACE(("READ pid=%lu, pFile=%p, file=%p, rc=SQLITE_IOERR_READ\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return winLogError(SQLITE_IOERR_READ, pFile->lastErrno, + "winRead", pFile->zPath); + } + winLogIoerr(nRetry, __LINE__); + if( nRead<(DWORD)amt ){ + /* Unread parts of the buffer must be zero-filled */ + memset(&((char*)pBuf)[nRead], 0, amt-nRead); + OSTRACE(("READ pid=%lu, pFile=%p, file=%p, rc=SQLITE_IOERR_SHORT_READ\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_IOERR_SHORT_READ; + } + + OSTRACE(("READ pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_OK; +} + +/* +** Write data from a buffer into a file. Return SQLITE_OK on success +** or some other error code on failure. +*/ +static int winWrite( + sqlite3_file *id, /* File to write into */ + const void *pBuf, /* The bytes to be written */ + int amt, /* Number of bytes to write */ + sqlite3_int64 offset /* Offset into the file to begin writing at */ +){ + int rc = 0; /* True if error has occurred, else false */ + winFile *pFile = (winFile*)id; /* File handle */ + int nRetry = 0; /* Number of retries */ + + assert( amt>0 ); + assert( pFile ); + SimulateIOError(return SQLITE_IOERR_WRITE); + SimulateDiskfullError(return SQLITE_FULL); + + OSTRACE(("WRITE pid=%lu, pFile=%p, file=%p, buffer=%p, amount=%d, " + "offset=%lld, lock=%d\n", osGetCurrentProcessId(), pFile, + pFile->h, pBuf, amt, offset, pFile->locktype)); + +#if defined(SQLITE_MMAP_READWRITE) && SQLITE_MAX_MMAP_SIZE>0 + /* Deal with as much of this write request as possible by transfering + ** data from the memory mapping using memcpy(). */ + if( offsetmmapSize ){ + if( offset+amt <= pFile->mmapSize ){ + memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt); + OSTRACE(("WRITE-MMAP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_OK; + }else{ + int nCopy = (int)(pFile->mmapSize - offset); + memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy); + pBuf = &((u8 *)pBuf)[nCopy]; + amt -= nCopy; + offset += nCopy; + } + } +#endif + +#if SQLITE_OS_WINCE || defined(SQLITE_WIN32_NO_OVERLAPPED) + rc = winSeekFile(pFile, offset); + if( rc==0 ){ +#else + { +#endif +#if !SQLITE_OS_WINCE && !defined(SQLITE_WIN32_NO_OVERLAPPED) + OVERLAPPED overlapped; /* The offset for WriteFile. */ +#endif + u8 *aRem = (u8 *)pBuf; /* Data yet to be written */ + int nRem = amt; /* Number of bytes yet to be written */ + DWORD nWrite; /* Bytes written by each WriteFile() call */ + DWORD lastErrno = NO_ERROR; /* Value returned by GetLastError() */ + +#if !SQLITE_OS_WINCE && !defined(SQLITE_WIN32_NO_OVERLAPPED) + memset(&overlapped, 0, sizeof(OVERLAPPED)); + overlapped.Offset = (LONG)(offset & 0xffffffff); + overlapped.OffsetHigh = (LONG)((offset>>32) & 0x7fffffff); +#endif + + while( nRem>0 ){ +#if SQLITE_OS_WINCE || defined(SQLITE_WIN32_NO_OVERLAPPED) + if( !osWriteFile(pFile->h, aRem, nRem, &nWrite, 0) ){ +#else + if( !osWriteFile(pFile->h, aRem, nRem, &nWrite, &overlapped) ){ +#endif + if( winRetryIoerr(&nRetry, &lastErrno) ) continue; + break; + } + assert( nWrite==0 || nWrite<=(DWORD)nRem ); + if( nWrite==0 || nWrite>(DWORD)nRem ){ + lastErrno = osGetLastError(); + break; + } +#if !SQLITE_OS_WINCE && !defined(SQLITE_WIN32_NO_OVERLAPPED) + offset += nWrite; + overlapped.Offset = (LONG)(offset & 0xffffffff); + overlapped.OffsetHigh = (LONG)((offset>>32) & 0x7fffffff); +#endif + aRem += nWrite; + nRem -= nWrite; + } + if( nRem>0 ){ + pFile->lastErrno = lastErrno; + rc = 1; + } + } + + if( rc ){ + if( ( pFile->lastErrno==ERROR_HANDLE_DISK_FULL ) + || ( pFile->lastErrno==ERROR_DISK_FULL )){ + OSTRACE(("WRITE pid=%lu, pFile=%p, file=%p, rc=SQLITE_FULL\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return winLogError(SQLITE_FULL, pFile->lastErrno, + "winWrite1", pFile->zPath); + } + OSTRACE(("WRITE pid=%lu, pFile=%p, file=%p, rc=SQLITE_IOERR_WRITE\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return winLogError(SQLITE_IOERR_WRITE, pFile->lastErrno, + "winWrite2", pFile->zPath); + }else{ + winLogIoerr(nRetry, __LINE__); + } + OSTRACE(("WRITE pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_OK; +} + +/* +** Truncate an open file to a specified size +*/ +static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){ + winFile *pFile = (winFile*)id; /* File handle object */ + int rc = SQLITE_OK; /* Return code for this function */ + DWORD lastErrno; +#if SQLITE_MAX_MMAP_SIZE>0 + sqlite3_int64 oldMmapSize; + if( pFile->nFetchOut>0 ){ + /* File truncation is a no-op if there are outstanding memory mapped + ** pages. This is because truncating the file means temporarily unmapping + ** the file, and that might delete memory out from under existing cursors. + ** + ** This can result in incremental vacuum not truncating the file, + ** if there is an active read cursor when the incremental vacuum occurs. + ** No real harm comes of this - the database file is not corrupted, + ** though some folks might complain that the file is bigger than it + ** needs to be. + ** + ** The only feasible work-around is to defer the truncation until after + ** all references to memory-mapped content are closed. That is doable, + ** but involves adding a few branches in the common write code path which + ** could slow down normal operations slightly. Hence, we have decided for + ** now to simply make trancations a no-op if there are pending reads. We + ** can maybe revisit this decision in the future. + */ + return SQLITE_OK; + } +#endif + + assert( pFile ); + SimulateIOError(return SQLITE_IOERR_TRUNCATE); + OSTRACE(("TRUNCATE pid=%lu, pFile=%p, file=%p, size=%lld, lock=%d\n", + osGetCurrentProcessId(), pFile, pFile->h, nByte, pFile->locktype)); + + /* If the user has configured a chunk-size for this file, truncate the + ** file so that it consists of an integer number of chunks (i.e. the + ** actual file size after the operation may be larger than the requested + ** size). + */ + if( pFile->szChunk>0 ){ + nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk; + } + +#if SQLITE_MAX_MMAP_SIZE>0 + if( pFile->pMapRegion ){ + oldMmapSize = pFile->mmapSize; + }else{ + oldMmapSize = 0; + } + winUnmapfile(pFile); +#endif + + /* SetEndOfFile() returns non-zero when successful, or zero when it fails. */ + if( winSeekFile(pFile, nByte) ){ + rc = winLogError(SQLITE_IOERR_TRUNCATE, pFile->lastErrno, + "winTruncate1", pFile->zPath); + }else if( 0==osSetEndOfFile(pFile->h) && + ((lastErrno = osGetLastError())!=ERROR_USER_MAPPED_FILE) ){ + pFile->lastErrno = lastErrno; + rc = winLogError(SQLITE_IOERR_TRUNCATE, pFile->lastErrno, + "winTruncate2", pFile->zPath); + } + +#if SQLITE_MAX_MMAP_SIZE>0 + if( rc==SQLITE_OK && oldMmapSize>0 ){ + if( oldMmapSize>nByte ){ + winMapfile(pFile, -1); + }else{ + winMapfile(pFile, oldMmapSize); + } + } +#endif + + OSTRACE(("TRUNCATE pid=%lu, pFile=%p, file=%p, rc=%s\n", + osGetCurrentProcessId(), pFile, pFile->h, sqlite3ErrName(rc))); + return rc; +} + +#ifdef SQLITE_TEST +/* +** Count the number of fullsyncs and normal syncs. This is used to test +** that syncs and fullsyncs are occuring at the right times. +*/ +SQLITE_API int sqlite3_sync_count = 0; +SQLITE_API int sqlite3_fullsync_count = 0; +#endif + +/* +** Make sure all writes to a particular file are committed to disk. +*/ +static int winSync(sqlite3_file *id, int flags){ +#ifndef SQLITE_NO_SYNC + /* + ** Used only when SQLITE_NO_SYNC is not defined. + */ + BOOL rc; +#endif +#if !defined(NDEBUG) || !defined(SQLITE_NO_SYNC) || \ + defined(SQLITE_HAVE_OS_TRACE) + /* + ** Used when SQLITE_NO_SYNC is not defined and by the assert() and/or + ** OSTRACE() macros. + */ + winFile *pFile = (winFile*)id; +#else + UNUSED_PARAMETER(id); +#endif + + assert( pFile ); + /* Check that one of SQLITE_SYNC_NORMAL or FULL was passed */ + assert((flags&0x0F)==SQLITE_SYNC_NORMAL + || (flags&0x0F)==SQLITE_SYNC_FULL + ); + + /* Unix cannot, but some systems may return SQLITE_FULL from here. This + ** line is to test that doing so does not cause any problems. + */ + SimulateDiskfullError( return SQLITE_FULL ); + + OSTRACE(("SYNC pid=%lu, pFile=%p, file=%p, flags=%x, lock=%d\n", + osGetCurrentProcessId(), pFile, pFile->h, flags, + pFile->locktype)); + +#ifndef SQLITE_TEST + UNUSED_PARAMETER(flags); +#else + if( (flags&0x0F)==SQLITE_SYNC_FULL ){ + sqlite3_fullsync_count++; + } + sqlite3_sync_count++; +#endif + + /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a + ** no-op + */ +#ifdef SQLITE_NO_SYNC + OSTRACE(("SYNC-NOP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_OK; +#else +#if SQLITE_MAX_MMAP_SIZE>0 + if( pFile->pMapRegion ){ + if( osFlushViewOfFile(pFile->pMapRegion, 0) ){ + OSTRACE(("SYNC-MMAP pid=%lu, pFile=%p, pMapRegion=%p, " + "rc=SQLITE_OK\n", osGetCurrentProcessId(), + pFile, pFile->pMapRegion)); + }else{ + pFile->lastErrno = osGetLastError(); + OSTRACE(("SYNC-MMAP pid=%lu, pFile=%p, pMapRegion=%p, " + "rc=SQLITE_IOERR_MMAP\n", osGetCurrentProcessId(), + pFile, pFile->pMapRegion)); + return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno, + "winSync1", pFile->zPath); + } + } +#endif + rc = osFlushFileBuffers(pFile->h); + SimulateIOError( rc=FALSE ); + if( rc ){ + OSTRACE(("SYNC pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return SQLITE_OK; + }else{ + pFile->lastErrno = osGetLastError(); + OSTRACE(("SYNC pid=%lu, pFile=%p, file=%p, rc=SQLITE_IOERR_FSYNC\n", + osGetCurrentProcessId(), pFile, pFile->h)); + return winLogError(SQLITE_IOERR_FSYNC, pFile->lastErrno, + "winSync2", pFile->zPath); + } +#endif +} + +/* +** Determine the current size of a file in bytes +*/ +static int winFileSize(sqlite3_file *id, sqlite3_int64 *pSize){ + winFile *pFile = (winFile*)id; + int rc = SQLITE_OK; + + assert( id!=0 ); + assert( pSize!=0 ); + SimulateIOError(return SQLITE_IOERR_FSTAT); + OSTRACE(("SIZE file=%p, pSize=%p\n", pFile->h, pSize)); + +#if SQLITE_OS_WINRT + { + FILE_STANDARD_INFO info; + if( osGetFileInformationByHandleEx(pFile->h, FileStandardInfo, + &info, sizeof(info)) ){ + *pSize = info.EndOfFile.QuadPart; + }else{ + pFile->lastErrno = osGetLastError(); + rc = winLogError(SQLITE_IOERR_FSTAT, pFile->lastErrno, + "winFileSize", pFile->zPath); + } + } +#else + { + DWORD upperBits; + DWORD lowerBits; + DWORD lastErrno; + + lowerBits = osGetFileSize(pFile->h, &upperBits); + *pSize = (((sqlite3_int64)upperBits)<<32) + lowerBits; + if( (lowerBits == INVALID_FILE_SIZE) + && ((lastErrno = osGetLastError())!=NO_ERROR) ){ + pFile->lastErrno = lastErrno; + rc = winLogError(SQLITE_IOERR_FSTAT, pFile->lastErrno, + "winFileSize", pFile->zPath); + } + } +#endif + OSTRACE(("SIZE file=%p, pSize=%p, *pSize=%lld, rc=%s\n", + pFile->h, pSize, *pSize, sqlite3ErrName(rc))); + return rc; +} + +/* +** LOCKFILE_FAIL_IMMEDIATELY is undefined on some Windows systems. +*/ +#ifndef LOCKFILE_FAIL_IMMEDIATELY +# define LOCKFILE_FAIL_IMMEDIATELY 1 +#endif + +#ifndef LOCKFILE_EXCLUSIVE_LOCK +# define LOCKFILE_EXCLUSIVE_LOCK 2 +#endif + +/* +** Historically, SQLite has used both the LockFile and LockFileEx functions. +** When the LockFile function was used, it was always expected to fail +** immediately if the lock could not be obtained. Also, it always expected to +** obtain an exclusive lock. These flags are used with the LockFileEx function +** and reflect those expectations; therefore, they should not be changed. +*/ +#ifndef SQLITE_LOCKFILE_FLAGS +# define SQLITE_LOCKFILE_FLAGS (LOCKFILE_FAIL_IMMEDIATELY | \ + LOCKFILE_EXCLUSIVE_LOCK) +#endif + +/* +** Currently, SQLite never calls the LockFileEx function without wanting the +** call to fail immediately if the lock cannot be obtained. +*/ +#ifndef SQLITE_LOCKFILEEX_FLAGS +# define SQLITE_LOCKFILEEX_FLAGS (LOCKFILE_FAIL_IMMEDIATELY) +#endif + +/* +** Acquire a reader lock. +** Different API routines are called depending on whether or not this +** is Win9x or WinNT. +*/ +static int winGetReadLock(winFile *pFile){ + int res; + OSTRACE(("READ-LOCK file=%p, lock=%d\n", pFile->h, pFile->locktype)); + if( osIsNT() ){ +#if SQLITE_OS_WINCE + /* + ** NOTE: Windows CE is handled differently here due its lack of the Win32 + ** API LockFileEx. + */ + res = winceLockFile(&pFile->h, SHARED_FIRST, 0, 1, 0); +#else + res = winLockFile(&pFile->h, SQLITE_LOCKFILEEX_FLAGS, SHARED_FIRST, 0, + SHARED_SIZE, 0); +#endif + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + int lk; + sqlite3_randomness(sizeof(lk), &lk); + pFile->sharedLockByte = (short)((lk & 0x7fffffff)%(SHARED_SIZE - 1)); + res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, + SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0); + } +#endif + if( res == 0 ){ + pFile->lastErrno = osGetLastError(); + /* No need to log a failure to lock */ + } + OSTRACE(("READ-LOCK file=%p, result=%d\n", pFile->h, res)); + return res; +} + +/* +** Undo a readlock +*/ +static int winUnlockReadLock(winFile *pFile){ + int res; + DWORD lastErrno; + OSTRACE(("READ-UNLOCK file=%p, lock=%d\n", pFile->h, pFile->locktype)); + if( osIsNT() ){ + res = winUnlockFile(&pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0); + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + res = winUnlockFile(&pFile->h, SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0); + } +#endif + if( res==0 && ((lastErrno = osGetLastError())!=ERROR_NOT_LOCKED) ){ + pFile->lastErrno = lastErrno; + winLogError(SQLITE_IOERR_UNLOCK, pFile->lastErrno, + "winUnlockReadLock", pFile->zPath); + } + OSTRACE(("READ-UNLOCK file=%p, result=%d\n", pFile->h, res)); + return res; +} + +/* +** Lock the file with the lock specified by parameter locktype - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> (PENDING) -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** This routine will only increase a lock. The winUnlock() routine +** erases all locks at once and returns us immediately to locking level 0. +** It is not possible to lower the locking level one step at a time. You +** must go straight to locking level 0. +*/ +static int winLock(sqlite3_file *id, int locktype){ + int rc = SQLITE_OK; /* Return code from subroutines */ + int res = 1; /* Result of a Windows lock call */ + int newLocktype; /* Set pFile->locktype to this value before exiting */ + int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */ + winFile *pFile = (winFile*)id; + DWORD lastErrno = NO_ERROR; + + assert( id!=0 ); + OSTRACE(("LOCK file=%p, oldLock=%d(%d), newLock=%d\n", + pFile->h, pFile->locktype, pFile->sharedLockByte, locktype)); + + /* If there is already a lock of this type or more restrictive on the + ** OsFile, do nothing. Don't use the end_lock: exit path, as + ** sqlite3OsEnterMutex() hasn't been called yet. + */ + if( pFile->locktype>=locktype ){ + OSTRACE(("LOCK-HELD file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + + /* Do not allow any kind of write-lock on a read-only database + */ + if( (pFile->ctrlFlags & WINFILE_RDONLY)!=0 && locktype>=RESERVED_LOCK ){ + return SQLITE_IOERR_LOCK; + } + + /* Make sure the locking sequence is correct + */ + assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK ); + assert( locktype!=PENDING_LOCK ); + assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK ); + + /* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or + ** a SHARED lock. If we are acquiring a SHARED lock, the acquisition of + ** the PENDING_LOCK byte is temporary. + */ + newLocktype = pFile->locktype; + if( pFile->locktype==NO_LOCK + || (locktype==EXCLUSIVE_LOCK && pFile->locktype<=RESERVED_LOCK) + ){ + int cnt = 3; + while( cnt-->0 && (res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, + PENDING_BYTE, 0, 1, 0))==0 ){ + /* Try 3 times to get the pending lock. This is needed to work + ** around problems caused by indexing and/or anti-virus software on + ** Windows systems. + ** If you are using this code as a model for alternative VFSes, do not + ** copy this retry logic. It is a hack intended for Windows only. + */ + lastErrno = osGetLastError(); + OSTRACE(("LOCK-PENDING-FAIL file=%p, count=%d, result=%d\n", + pFile->h, cnt, res)); + if( lastErrno==ERROR_INVALID_HANDLE ){ + pFile->lastErrno = lastErrno; + rc = SQLITE_IOERR_LOCK; + OSTRACE(("LOCK-FAIL file=%p, count=%d, rc=%s\n", + pFile->h, cnt, sqlite3ErrName(rc))); + return rc; + } + if( cnt ) sqlite3_win32_sleep(1); + } + gotPendingLock = res; + if( !res ){ + lastErrno = osGetLastError(); + } + } + + /* Acquire a shared lock + */ + if( locktype==SHARED_LOCK && res ){ + assert( pFile->locktype==NO_LOCK ); + res = winGetReadLock(pFile); + if( res ){ + newLocktype = SHARED_LOCK; + }else{ + lastErrno = osGetLastError(); + } + } + + /* Acquire a RESERVED lock + */ + if( locktype==RESERVED_LOCK && res ){ + assert( pFile->locktype==SHARED_LOCK ); + res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, RESERVED_BYTE, 0, 1, 0); + if( res ){ + newLocktype = RESERVED_LOCK; + }else{ + lastErrno = osGetLastError(); + } + } + + /* Acquire a PENDING lock + */ + if( locktype==EXCLUSIVE_LOCK && res ){ + newLocktype = PENDING_LOCK; + gotPendingLock = 0; + } + + /* Acquire an EXCLUSIVE lock + */ + if( locktype==EXCLUSIVE_LOCK && res ){ + assert( pFile->locktype>=SHARED_LOCK ); + res = winUnlockReadLock(pFile); + res = winLockFile(&pFile->h, SQLITE_LOCKFILE_FLAGS, SHARED_FIRST, 0, + SHARED_SIZE, 0); + if( res ){ + newLocktype = EXCLUSIVE_LOCK; + }else{ + lastErrno = osGetLastError(); + winGetReadLock(pFile); + } + } + + /* If we are holding a PENDING lock that ought to be released, then + ** release it now. + */ + if( gotPendingLock && locktype==SHARED_LOCK ){ + winUnlockFile(&pFile->h, PENDING_BYTE, 0, 1, 0); + } + + /* Update the state of the lock has held in the file descriptor then + ** return the appropriate result code. + */ + if( res ){ + rc = SQLITE_OK; + }else{ + pFile->lastErrno = lastErrno; + rc = SQLITE_BUSY; + OSTRACE(("LOCK-FAIL file=%p, wanted=%d, got=%d\n", + pFile->h, locktype, newLocktype)); + } + pFile->locktype = (u8)newLocktype; + OSTRACE(("LOCK file=%p, lock=%d, rc=%s\n", + pFile->h, pFile->locktype, sqlite3ErrName(rc))); + return rc; +} + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, return +** non-zero, otherwise zero. +*/ +static int winCheckReservedLock(sqlite3_file *id, int *pResOut){ + int res; + winFile *pFile = (winFile*)id; + + SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; ); + OSTRACE(("TEST-WR-LOCK file=%p, pResOut=%p\n", pFile->h, pResOut)); + + assert( id!=0 ); + if( pFile->locktype>=RESERVED_LOCK ){ + res = 1; + OSTRACE(("TEST-WR-LOCK file=%p, result=%d (local)\n", pFile->h, res)); + }else{ + res = winLockFile(&pFile->h, SQLITE_LOCKFILEEX_FLAGS,RESERVED_BYTE,0,1,0); + if( res ){ + winUnlockFile(&pFile->h, RESERVED_BYTE, 0, 1, 0); + } + res = !res; + OSTRACE(("TEST-WR-LOCK file=%p, result=%d (remote)\n", pFile->h, res)); + } + *pResOut = res; + OSTRACE(("TEST-WR-LOCK file=%p, pResOut=%p, *pResOut=%d, rc=SQLITE_OK\n", + pFile->h, pResOut, *pResOut)); + return SQLITE_OK; +} + +/* +** Lower the locking level on file descriptor id to locktype. locktype +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +** +** It is not possible for this routine to fail if the second argument +** is NO_LOCK. If the second argument is SHARED_LOCK then this routine +** might return SQLITE_IOERR; +*/ +static int winUnlock(sqlite3_file *id, int locktype){ + int type; + winFile *pFile = (winFile*)id; + int rc = SQLITE_OK; + assert( pFile!=0 ); + assert( locktype<=SHARED_LOCK ); + OSTRACE(("UNLOCK file=%p, oldLock=%d(%d), newLock=%d\n", + pFile->h, pFile->locktype, pFile->sharedLockByte, locktype)); + type = pFile->locktype; + if( type>=EXCLUSIVE_LOCK ){ + winUnlockFile(&pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0); + if( locktype==SHARED_LOCK && !winGetReadLock(pFile) ){ + /* This should never happen. We should always be able to + ** reacquire the read lock */ + rc = winLogError(SQLITE_IOERR_UNLOCK, osGetLastError(), + "winUnlock", pFile->zPath); + } + } + if( type>=RESERVED_LOCK ){ + winUnlockFile(&pFile->h, RESERVED_BYTE, 0, 1, 0); + } + if( locktype==NO_LOCK && type>=SHARED_LOCK ){ + winUnlockReadLock(pFile); + } + if( type>=PENDING_LOCK ){ + winUnlockFile(&pFile->h, PENDING_BYTE, 0, 1, 0); + } + pFile->locktype = (u8)locktype; + OSTRACE(("UNLOCK file=%p, lock=%d, rc=%s\n", + pFile->h, pFile->locktype, sqlite3ErrName(rc))); + return rc; +} + +/****************************************************************************** +****************************** No-op Locking ********************************** +** +** Of the various locking implementations available, this is by far the +** simplest: locking is ignored. No attempt is made to lock the database +** file for reading or writing. +** +** This locking mode is appropriate for use on read-only databases +** (ex: databases that are burned into CD-ROM, for example.) It can +** also be used if the application employs some external mechanism to +** prevent simultaneous access of the same database by two or more +** database connections. But there is a serious risk of database +** corruption if this locking mode is used in situations where multiple +** database connections are accessing the same database file at the same +** time and one or more of those connections are writing. +*/ + +static int winNolockLock(sqlite3_file *id, int locktype){ + UNUSED_PARAMETER(id); + UNUSED_PARAMETER(locktype); + return SQLITE_OK; +} + +static int winNolockCheckReservedLock(sqlite3_file *id, int *pResOut){ + UNUSED_PARAMETER(id); + UNUSED_PARAMETER(pResOut); + return SQLITE_OK; +} + +static int winNolockUnlock(sqlite3_file *id, int locktype){ + UNUSED_PARAMETER(id); + UNUSED_PARAMETER(locktype); + return SQLITE_OK; +} + +/******************* End of the no-op lock implementation ********************* +******************************************************************************/ + +/* +** If *pArg is initially negative then this is a query. Set *pArg to +** 1 or 0 depending on whether or not bit mask of pFile->ctrlFlags is set. +** +** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags. +*/ +static void winModeBit(winFile *pFile, unsigned char mask, int *pArg){ + if( *pArg<0 ){ + *pArg = (pFile->ctrlFlags & mask)!=0; + }else if( (*pArg)==0 ){ + pFile->ctrlFlags &= ~mask; + }else{ + pFile->ctrlFlags |= mask; + } +} + +/* Forward references to VFS helper methods used for temporary files */ +static int winGetTempname(sqlite3_vfs *, char **); +static int winIsDir(const void *); +static BOOL winIsLongPathPrefix(const char *); +static BOOL winIsDriveLetterAndColon(const char *); + +/* +** Control and query of the open file handle. +*/ +static int winFileControl(sqlite3_file *id, int op, void *pArg){ + winFile *pFile = (winFile*)id; + OSTRACE(("FCNTL file=%p, op=%d, pArg=%p\n", pFile->h, op, pArg)); + switch( op ){ + case SQLITE_FCNTL_LOCKSTATE: { + *(int*)pArg = pFile->locktype; + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + case SQLITE_FCNTL_LAST_ERRNO: { + *(int*)pArg = (int)pFile->lastErrno; + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + case SQLITE_FCNTL_CHUNK_SIZE: { + pFile->szChunk = *(int *)pArg; + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + case SQLITE_FCNTL_SIZE_HINT: { + if( pFile->szChunk>0 ){ + sqlite3_int64 oldSz; + int rc = winFileSize(id, &oldSz); + if( rc==SQLITE_OK ){ + sqlite3_int64 newSz = *(sqlite3_int64*)pArg; + if( newSz>oldSz ){ + SimulateIOErrorBenign(1); + rc = winTruncate(id, newSz); + SimulateIOErrorBenign(0); + } + } + OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc))); + return rc; + } + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + case SQLITE_FCNTL_PERSIST_WAL: { + winModeBit(pFile, WINFILE_PERSIST_WAL, (int*)pArg); + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + case SQLITE_FCNTL_POWERSAFE_OVERWRITE: { + winModeBit(pFile, WINFILE_PSOW, (int*)pArg); + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + case SQLITE_FCNTL_VFSNAME: { + *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName); + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + case SQLITE_FCNTL_WIN32_AV_RETRY: { + int *a = (int*)pArg; + if( a[0]>0 ){ + winIoerrRetry = a[0]; + }else{ + a[0] = winIoerrRetry; + } + if( a[1]>0 ){ + winIoerrRetryDelay = a[1]; + }else{ + a[1] = winIoerrRetryDelay; + } + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } + case SQLITE_FCNTL_WIN32_GET_HANDLE: { + LPHANDLE phFile = (LPHANDLE)pArg; + *phFile = pFile->h; + OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); + return SQLITE_OK; + } +#ifdef SQLITE_TEST + case SQLITE_FCNTL_WIN32_SET_HANDLE: { + LPHANDLE phFile = (LPHANDLE)pArg; + HANDLE hOldFile = pFile->h; + pFile->h = *phFile; + *phFile = hOldFile; + OSTRACE(("FCNTL oldFile=%p, newFile=%p, rc=SQLITE_OK\n", + hOldFile, pFile->h)); + return SQLITE_OK; + } +#endif + case SQLITE_FCNTL_TEMPFILENAME: { + char *zTFile = 0; + int rc = winGetTempname(pFile->pVfs, &zTFile); + if( rc==SQLITE_OK ){ + *(char**)pArg = zTFile; + } + OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc))); + return rc; + } +#if SQLITE_MAX_MMAP_SIZE>0 + case SQLITE_FCNTL_MMAP_SIZE: { + i64 newLimit = *(i64*)pArg; + int rc = SQLITE_OK; + if( newLimit>sqlite3GlobalConfig.mxMmap ){ + newLimit = sqlite3GlobalConfig.mxMmap; + } + + /* The value of newLimit may be eventually cast to (SIZE_T) and passed + ** to MapViewOfFile(). Restrict its value to 2GB if (SIZE_T) is not at + ** least a 64-bit type. */ + if( newLimit>0 && sizeof(SIZE_T)<8 ){ + newLimit = (newLimit & 0x7FFFFFFF); + } + + *(i64*)pArg = pFile->mmapSizeMax; + if( newLimit>=0 && newLimit!=pFile->mmapSizeMax && pFile->nFetchOut==0 ){ + pFile->mmapSizeMax = newLimit; + if( pFile->mmapSize>0 ){ + winUnmapfile(pFile); + rc = winMapfile(pFile, -1); + } + } + OSTRACE(("FCNTL file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc))); + return rc; + } +#endif + } + OSTRACE(("FCNTL file=%p, rc=SQLITE_NOTFOUND\n", pFile->h)); + return SQLITE_NOTFOUND; +} + +/* +** Return the sector size in bytes of the underlying block device for +** the specified file. This is almost always 512 bytes, but may be +** larger for some devices. +** +** SQLite code assumes this function cannot fail. It also assumes that +** if two files are created in the same file-system directory (i.e. +** a database and its journal file) that the sector size will be the +** same for both. +*/ +static int winSectorSize(sqlite3_file *id){ + (void)id; + return SQLITE_DEFAULT_SECTOR_SIZE; +} + +/* +** Return a vector of device characteristics. +*/ +static int winDeviceCharacteristics(sqlite3_file *id){ + winFile *p = (winFile*)id; + return SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN | + ((p->ctrlFlags & WINFILE_PSOW)?SQLITE_IOCAP_POWERSAFE_OVERWRITE:0); +} + +/* +** Windows will only let you create file view mappings +** on allocation size granularity boundaries. +** During sqlite3_os_init() we do a GetSystemInfo() +** to get the granularity size. +*/ +static SYSTEM_INFO winSysInfo; + +#ifndef SQLITE_OMIT_WAL + +/* +** Helper functions to obtain and relinquish the global mutex. The +** global mutex is used to protect the winLockInfo objects used by +** this file, all of which may be shared by multiple threads. +** +** Function winShmMutexHeld() is used to assert() that the global mutex +** is held when required. This function is only used as part of assert() +** statements. e.g. +** +** winShmEnterMutex() +** assert( winShmMutexHeld() ); +** winShmLeaveMutex() +*/ +static sqlite3_mutex *winBigLock = 0; +static void winShmEnterMutex(void){ + sqlite3_mutex_enter(winBigLock); +} +static void winShmLeaveMutex(void){ + sqlite3_mutex_leave(winBigLock); +} +#ifndef NDEBUG +static int winShmMutexHeld(void) { + return sqlite3_mutex_held(winBigLock); +} +#endif + +/* +** Object used to represent a single file opened and mmapped to provide +** shared memory. When multiple threads all reference the same +** log-summary, each thread has its own winFile object, but they all +** point to a single instance of this object. In other words, each +** log-summary is opened only once per process. +** +** winShmMutexHeld() must be true when creating or destroying +** this object or while reading or writing the following fields: +** +** nRef +** pNext +** +** The following fields are read-only after the object is created: +** +** fid +** zFilename +** +** Either winShmNode.mutex must be held or winShmNode.nRef==0 and +** winShmMutexHeld() is true when reading or writing any other field +** in this structure. +** +*/ +struct winShmNode { + sqlite3_mutex *mutex; /* Mutex to access this object */ + char *zFilename; /* Name of the file */ + winFile hFile; /* File handle from winOpen */ + + int szRegion; /* Size of shared-memory regions */ + int nRegion; /* Size of array apRegion */ + u8 isReadonly; /* True if read-only */ + u8 isUnlocked; /* True if no DMS lock held */ + + struct ShmRegion { + HANDLE hMap; /* File handle from CreateFileMapping */ + void *pMap; + } *aRegion; + DWORD lastErrno; /* The Windows errno from the last I/O error */ + + int nRef; /* Number of winShm objects pointing to this */ + winShm *pFirst; /* All winShm objects pointing to this */ + winShmNode *pNext; /* Next in list of all winShmNode objects */ +#if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE) + u8 nextShmId; /* Next available winShm.id value */ +#endif +}; + +/* +** A global array of all winShmNode objects. +** +** The winShmMutexHeld() must be true while reading or writing this list. +*/ +static winShmNode *winShmNodeList = 0; + +/* +** Structure used internally by this VFS to record the state of an +** open shared memory connection. +** +** The following fields are initialized when this object is created and +** are read-only thereafter: +** +** winShm.pShmNode +** winShm.id +** +** All other fields are read/write. The winShm.pShmNode->mutex must be held +** while accessing any read/write fields. +*/ +struct winShm { + winShmNode *pShmNode; /* The underlying winShmNode object */ + winShm *pNext; /* Next winShm with the same winShmNode */ + u8 hasMutex; /* True if holding the winShmNode mutex */ + u16 sharedMask; /* Mask of shared locks held */ + u16 exclMask; /* Mask of exclusive locks held */ +#if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE) + u8 id; /* Id of this connection with its winShmNode */ +#endif +}; + +/* +** Constants used for locking +*/ +#define WIN_SHM_BASE ((22+SQLITE_SHM_NLOCK)*4) /* first lock byte */ +#define WIN_SHM_DMS (WIN_SHM_BASE+SQLITE_SHM_NLOCK) /* deadman switch */ + +/* +** Apply advisory locks for all n bytes beginning at ofst. +*/ +#define WINSHM_UNLCK 1 +#define WINSHM_RDLCK 2 +#define WINSHM_WRLCK 3 +static int winShmSystemLock( + winShmNode *pFile, /* Apply locks to this open shared-memory segment */ + int lockType, /* WINSHM_UNLCK, WINSHM_RDLCK, or WINSHM_WRLCK */ + int ofst, /* Offset to first byte to be locked/unlocked */ + int nByte /* Number of bytes to lock or unlock */ +){ + int rc = 0; /* Result code form Lock/UnlockFileEx() */ + + /* Access to the winShmNode object is serialized by the caller */ + assert( pFile->nRef==0 || sqlite3_mutex_held(pFile->mutex) ); + + OSTRACE(("SHM-LOCK file=%p, lock=%d, offset=%d, size=%d\n", + pFile->hFile.h, lockType, ofst, nByte)); + + /* Release/Acquire the system-level lock */ + if( lockType==WINSHM_UNLCK ){ + rc = winUnlockFile(&pFile->hFile.h, ofst, 0, nByte, 0); + }else{ + /* Initialize the locking parameters */ + DWORD dwFlags = LOCKFILE_FAIL_IMMEDIATELY; + if( lockType == WINSHM_WRLCK ) dwFlags |= LOCKFILE_EXCLUSIVE_LOCK; + rc = winLockFile(&pFile->hFile.h, dwFlags, ofst, 0, nByte, 0); + } + + if( rc!= 0 ){ + rc = SQLITE_OK; + }else{ + pFile->lastErrno = osGetLastError(); + rc = SQLITE_BUSY; + } + + OSTRACE(("SHM-LOCK file=%p, func=%s, errno=%lu, rc=%s\n", + pFile->hFile.h, (lockType == WINSHM_UNLCK) ? "winUnlockFile" : + "winLockFile", pFile->lastErrno, sqlite3ErrName(rc))); + + return rc; +} + +/* Forward references to VFS methods */ +static int winOpen(sqlite3_vfs*,const char*,sqlite3_file*,int,int*); +static int winDelete(sqlite3_vfs *,const char*,int); + +/* +** Purge the winShmNodeList list of all entries with winShmNode.nRef==0. +** +** This is not a VFS shared-memory method; it is a utility function called +** by VFS shared-memory methods. +*/ +static void winShmPurge(sqlite3_vfs *pVfs, int deleteFlag){ + winShmNode **pp; + winShmNode *p; + assert( winShmMutexHeld() ); + OSTRACE(("SHM-PURGE pid=%lu, deleteFlag=%d\n", + osGetCurrentProcessId(), deleteFlag)); + pp = &winShmNodeList; + while( (p = *pp)!=0 ){ + if( p->nRef==0 ){ + int i; + if( p->mutex ){ sqlite3_mutex_free(p->mutex); } + for(i=0; inRegion; i++){ + BOOL bRc = osUnmapViewOfFile(p->aRegion[i].pMap); + OSTRACE(("SHM-PURGE-UNMAP pid=%lu, region=%d, rc=%s\n", + osGetCurrentProcessId(), i, bRc ? "ok" : "failed")); + UNUSED_VARIABLE_VALUE(bRc); + bRc = osCloseHandle(p->aRegion[i].hMap); + OSTRACE(("SHM-PURGE-CLOSE pid=%lu, region=%d, rc=%s\n", + osGetCurrentProcessId(), i, bRc ? "ok" : "failed")); + UNUSED_VARIABLE_VALUE(bRc); + } + if( p->hFile.h!=NULL && p->hFile.h!=INVALID_HANDLE_VALUE ){ + SimulateIOErrorBenign(1); + winClose((sqlite3_file *)&p->hFile); + SimulateIOErrorBenign(0); + } + if( deleteFlag ){ + SimulateIOErrorBenign(1); + sqlite3BeginBenignMalloc(); + winDelete(pVfs, p->zFilename, 0); + sqlite3EndBenignMalloc(); + SimulateIOErrorBenign(0); + } + *pp = p->pNext; + sqlite3_free(p->aRegion); + sqlite3_free(p); + }else{ + pp = &p->pNext; + } + } +} + +/* +** The DMS lock has not yet been taken on shm file pShmNode. Attempt to +** take it now. Return SQLITE_OK if successful, or an SQLite error +** code otherwise. +** +** If the DMS cannot be locked because this is a readonly_shm=1 +** connection and no other process already holds a lock, return +** SQLITE_READONLY_CANTINIT and set pShmNode->isUnlocked=1. +*/ +static int winLockSharedMemory(winShmNode *pShmNode){ + int rc = winShmSystemLock(pShmNode, WINSHM_WRLCK, WIN_SHM_DMS, 1); + + if( rc==SQLITE_OK ){ + if( pShmNode->isReadonly ){ + pShmNode->isUnlocked = 1; + winShmSystemLock(pShmNode, WINSHM_UNLCK, WIN_SHM_DMS, 1); + return SQLITE_READONLY_CANTINIT; + }else if( winTruncate((sqlite3_file*)&pShmNode->hFile, 0) ){ + winShmSystemLock(pShmNode, WINSHM_UNLCK, WIN_SHM_DMS, 1); + return winLogError(SQLITE_IOERR_SHMOPEN, osGetLastError(), + "winLockSharedMemory", pShmNode->zFilename); + } + } + + if( rc==SQLITE_OK ){ + winShmSystemLock(pShmNode, WINSHM_UNLCK, WIN_SHM_DMS, 1); + } + + return winShmSystemLock(pShmNode, WINSHM_RDLCK, WIN_SHM_DMS, 1); +} + +/* +** Open the shared-memory area associated with database file pDbFd. +** +** When opening a new shared-memory file, if no other instances of that +** file are currently open, in this process or in other processes, then +** the file must be truncated to zero length or have its header cleared. +*/ +static int winOpenSharedMemory(winFile *pDbFd){ + struct winShm *p; /* The connection to be opened */ + winShmNode *pShmNode = 0; /* The underlying mmapped file */ + int rc = SQLITE_OK; /* Result code */ + winShmNode *pNew; /* Newly allocated winShmNode */ + int nName; /* Size of zName in bytes */ + + assert( pDbFd->pShm==0 ); /* Not previously opened */ + + /* Allocate space for the new sqlite3_shm object. Also speculatively + ** allocate space for a new winShmNode and filename. + */ + p = sqlite3MallocZero( sizeof(*p) ); + if( p==0 ) return SQLITE_IOERR_NOMEM_BKPT; + nName = sqlite3Strlen30(pDbFd->zPath); + pNew = sqlite3MallocZero( sizeof(*pShmNode) + nName + 17 ); + if( pNew==0 ){ + sqlite3_free(p); + return SQLITE_IOERR_NOMEM_BKPT; + } + pNew->zFilename = (char*)&pNew[1]; + sqlite3_snprintf(nName+15, pNew->zFilename, "%s-shm", pDbFd->zPath); + sqlite3FileSuffix3(pDbFd->zPath, pNew->zFilename); + + /* Look to see if there is an existing winShmNode that can be used. + ** If no matching winShmNode currently exists, create a new one. + */ + winShmEnterMutex(); + for(pShmNode = winShmNodeList; pShmNode; pShmNode=pShmNode->pNext){ + /* TBD need to come up with better match here. Perhaps + ** use FILE_ID_BOTH_DIR_INFO Structure. + */ + if( sqlite3StrICmp(pShmNode->zFilename, pNew->zFilename)==0 ) break; + } + if( pShmNode ){ + sqlite3_free(pNew); + }else{ + int inFlags = SQLITE_OPEN_WAL; + int outFlags = 0; + + pShmNode = pNew; + pNew = 0; + ((winFile*)(&pShmNode->hFile))->h = INVALID_HANDLE_VALUE; + pShmNode->pNext = winShmNodeList; + winShmNodeList = pShmNode; + + if( sqlite3GlobalConfig.bCoreMutex ){ + pShmNode->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST); + if( pShmNode->mutex==0 ){ + rc = SQLITE_IOERR_NOMEM_BKPT; + goto shm_open_err; + } + } + + if( 0==sqlite3_uri_boolean(pDbFd->zPath, "readonly_shm", 0) ){ + inFlags |= SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE; + }else{ + inFlags |= SQLITE_OPEN_READONLY; + } + rc = winOpen(pDbFd->pVfs, pShmNode->zFilename, + (sqlite3_file*)&pShmNode->hFile, + inFlags, &outFlags); + if( rc!=SQLITE_OK ){ + rc = winLogError(rc, osGetLastError(), "winOpenShm", + pShmNode->zFilename); + goto shm_open_err; + } + if( outFlags==SQLITE_OPEN_READONLY ) pShmNode->isReadonly = 1; + + rc = winLockSharedMemory(pShmNode); + if( rc!=SQLITE_OK && rc!=SQLITE_READONLY_CANTINIT ) goto shm_open_err; + } + + /* Make the new connection a child of the winShmNode */ + p->pShmNode = pShmNode; +#if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE) + p->id = pShmNode->nextShmId++; +#endif + pShmNode->nRef++; + pDbFd->pShm = p; + winShmLeaveMutex(); + + /* The reference count on pShmNode has already been incremented under + ** the cover of the winShmEnterMutex() mutex and the pointer from the + ** new (struct winShm) object to the pShmNode has been set. All that is + ** left to do is to link the new object into the linked list starting + ** at pShmNode->pFirst. This must be done while holding the pShmNode->mutex + ** mutex. + */ + sqlite3_mutex_enter(pShmNode->mutex); + p->pNext = pShmNode->pFirst; + pShmNode->pFirst = p; + sqlite3_mutex_leave(pShmNode->mutex); + return rc; + + /* Jump here on any error */ +shm_open_err: + winShmSystemLock(pShmNode, WINSHM_UNLCK, WIN_SHM_DMS, 1); + winShmPurge(pDbFd->pVfs, 0); /* This call frees pShmNode if required */ + sqlite3_free(p); + sqlite3_free(pNew); + winShmLeaveMutex(); + return rc; +} + +/* +** Close a connection to shared-memory. Delete the underlying +** storage if deleteFlag is true. +*/ +static int winShmUnmap( + sqlite3_file *fd, /* Database holding shared memory */ + int deleteFlag /* Delete after closing if true */ +){ + winFile *pDbFd; /* Database holding shared-memory */ + winShm *p; /* The connection to be closed */ + winShmNode *pShmNode; /* The underlying shared-memory file */ + winShm **pp; /* For looping over sibling connections */ + + pDbFd = (winFile*)fd; + p = pDbFd->pShm; + if( p==0 ) return SQLITE_OK; + pShmNode = p->pShmNode; + + /* Remove connection p from the set of connections associated + ** with pShmNode */ + sqlite3_mutex_enter(pShmNode->mutex); + for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){} + *pp = p->pNext; + + /* Free the connection p */ + sqlite3_free(p); + pDbFd->pShm = 0; + sqlite3_mutex_leave(pShmNode->mutex); + + /* If pShmNode->nRef has reached 0, then close the underlying + ** shared-memory file, too */ + winShmEnterMutex(); + assert( pShmNode->nRef>0 ); + pShmNode->nRef--; + if( pShmNode->nRef==0 ){ + winShmPurge(pDbFd->pVfs, deleteFlag); + } + winShmLeaveMutex(); + + return SQLITE_OK; +} + +/* +** Change the lock state for a shared-memory segment. +*/ +static int winShmLock( + sqlite3_file *fd, /* Database file holding the shared memory */ + int ofst, /* First lock to acquire or release */ + int n, /* Number of locks to acquire or release */ + int flags /* What to do with the lock */ +){ + winFile *pDbFd = (winFile*)fd; /* Connection holding shared memory */ + winShm *p = pDbFd->pShm; /* The shared memory being locked */ + winShm *pX; /* For looping over all siblings */ + winShmNode *pShmNode; + int rc = SQLITE_OK; /* Result code */ + u16 mask; /* Mask of locks to take or release */ + + if( p==0 ) return SQLITE_IOERR_SHMLOCK; + pShmNode = p->pShmNode; + if( NEVER(pShmNode==0) ) return SQLITE_IOERR_SHMLOCK; + + assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK ); + assert( n>=1 ); + assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED) + || flags==(SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE) + || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED) + || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE) ); + assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 ); + + mask = (u16)((1U<<(ofst+n)) - (1U<1 || mask==(1<mutex); + if( flags & SQLITE_SHM_UNLOCK ){ + u16 allMask = 0; /* Mask of locks held by siblings */ + + /* See if any siblings hold this same lock */ + for(pX=pShmNode->pFirst; pX; pX=pX->pNext){ + if( pX==p ) continue; + assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 ); + allMask |= pX->sharedMask; + } + + /* Unlock the system-level locks */ + if( (mask & allMask)==0 ){ + rc = winShmSystemLock(pShmNode, WINSHM_UNLCK, ofst+WIN_SHM_BASE, n); + }else{ + rc = SQLITE_OK; + } + + /* Undo the local locks */ + if( rc==SQLITE_OK ){ + p->exclMask &= ~mask; + p->sharedMask &= ~mask; + } + }else if( flags & SQLITE_SHM_SHARED ){ + u16 allShared = 0; /* Union of locks held by connections other than "p" */ + + /* Find out which shared locks are already held by sibling connections. + ** If any sibling already holds an exclusive lock, go ahead and return + ** SQLITE_BUSY. + */ + for(pX=pShmNode->pFirst; pX; pX=pX->pNext){ + if( (pX->exclMask & mask)!=0 ){ + rc = SQLITE_BUSY; + break; + } + allShared |= pX->sharedMask; + } + + /* Get shared locks at the system level, if necessary */ + if( rc==SQLITE_OK ){ + if( (allShared & mask)==0 ){ + rc = winShmSystemLock(pShmNode, WINSHM_RDLCK, ofst+WIN_SHM_BASE, n); + }else{ + rc = SQLITE_OK; + } + } + + /* Get the local shared locks */ + if( rc==SQLITE_OK ){ + p->sharedMask |= mask; + } + }else{ + /* Make sure no sibling connections hold locks that will block this + ** lock. If any do, return SQLITE_BUSY right away. + */ + for(pX=pShmNode->pFirst; pX; pX=pX->pNext){ + if( (pX->exclMask & mask)!=0 || (pX->sharedMask & mask)!=0 ){ + rc = SQLITE_BUSY; + break; + } + } + + /* Get the exclusive locks at the system level. Then if successful + ** also mark the local connection as being locked. + */ + if( rc==SQLITE_OK ){ + rc = winShmSystemLock(pShmNode, WINSHM_WRLCK, ofst+WIN_SHM_BASE, n); + if( rc==SQLITE_OK ){ + assert( (p->sharedMask & mask)==0 ); + p->exclMask |= mask; + } + } + } + sqlite3_mutex_leave(pShmNode->mutex); + OSTRACE(("SHM-LOCK pid=%lu, id=%d, sharedMask=%03x, exclMask=%03x, rc=%s\n", + osGetCurrentProcessId(), p->id, p->sharedMask, p->exclMask, + sqlite3ErrName(rc))); + return rc; +} + +/* +** Implement a memory barrier or memory fence on shared memory. +** +** All loads and stores begun before the barrier must complete before +** any load or store begun after the barrier. +*/ +static void winShmBarrier( + sqlite3_file *fd /* Database holding the shared memory */ +){ + UNUSED_PARAMETER(fd); + sqlite3MemoryBarrier(); /* compiler-defined memory barrier */ + winShmEnterMutex(); /* Also mutex, for redundancy */ + winShmLeaveMutex(); +} + +/* +** This function is called to obtain a pointer to region iRegion of the +** shared-memory associated with the database file fd. Shared-memory regions +** are numbered starting from zero. Each shared-memory region is szRegion +** bytes in size. +** +** If an error occurs, an error code is returned and *pp is set to NULL. +** +** Otherwise, if the isWrite parameter is 0 and the requested shared-memory +** region has not been allocated (by any client, including one running in a +** separate process), then *pp is set to NULL and SQLITE_OK returned. If +** isWrite is non-zero and the requested shared-memory region has not yet +** been allocated, it is allocated by this function. +** +** If the shared-memory region has already been allocated or is allocated by +** this call as described above, then it is mapped into this processes +** address space (if it is not already), *pp is set to point to the mapped +** memory and SQLITE_OK returned. +*/ +static int winShmMap( + sqlite3_file *fd, /* Handle open on database file */ + int iRegion, /* Region to retrieve */ + int szRegion, /* Size of regions */ + int isWrite, /* True to extend file if necessary */ + void volatile **pp /* OUT: Mapped memory */ +){ + winFile *pDbFd = (winFile*)fd; + winShm *pShm = pDbFd->pShm; + winShmNode *pShmNode; + DWORD protect = PAGE_READWRITE; + DWORD flags = FILE_MAP_WRITE | FILE_MAP_READ; + int rc = SQLITE_OK; + + if( !pShm ){ + rc = winOpenSharedMemory(pDbFd); + if( rc!=SQLITE_OK ) return rc; + pShm = pDbFd->pShm; + assert( pShm!=0 ); + } + pShmNode = pShm->pShmNode; + + sqlite3_mutex_enter(pShmNode->mutex); + if( pShmNode->isUnlocked ){ + rc = winLockSharedMemory(pShmNode); + if( rc!=SQLITE_OK ) goto shmpage_out; + pShmNode->isUnlocked = 0; + } + assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 ); + + if( pShmNode->nRegion<=iRegion ){ + struct ShmRegion *apNew; /* New aRegion[] array */ + int nByte = (iRegion+1)*szRegion; /* Minimum required file size */ + sqlite3_int64 sz; /* Current size of wal-index file */ + + pShmNode->szRegion = szRegion; + + /* The requested region is not mapped into this processes address space. + ** Check to see if it has been allocated (i.e. if the wal-index file is + ** large enough to contain the requested region). + */ + rc = winFileSize((sqlite3_file *)&pShmNode->hFile, &sz); + if( rc!=SQLITE_OK ){ + rc = winLogError(SQLITE_IOERR_SHMSIZE, osGetLastError(), + "winShmMap1", pDbFd->zPath); + goto shmpage_out; + } + + if( szhFile, nByte); + if( rc!=SQLITE_OK ){ + rc = winLogError(SQLITE_IOERR_SHMSIZE, osGetLastError(), + "winShmMap2", pDbFd->zPath); + goto shmpage_out; + } + } + + /* Map the requested memory region into this processes address space. */ + apNew = (struct ShmRegion *)sqlite3_realloc64( + pShmNode->aRegion, (iRegion+1)*sizeof(apNew[0]) + ); + if( !apNew ){ + rc = SQLITE_IOERR_NOMEM_BKPT; + goto shmpage_out; + } + pShmNode->aRegion = apNew; + + if( pShmNode->isReadonly ){ + protect = PAGE_READONLY; + flags = FILE_MAP_READ; + } + + while( pShmNode->nRegion<=iRegion ){ + HANDLE hMap = NULL; /* file-mapping handle */ + void *pMap = 0; /* Mapped memory region */ + +#if SQLITE_OS_WINRT + hMap = osCreateFileMappingFromApp(pShmNode->hFile.h, + NULL, protect, nByte, NULL + ); +#elif defined(SQLITE_WIN32_HAS_WIDE) + hMap = osCreateFileMappingW(pShmNode->hFile.h, + NULL, protect, 0, nByte, NULL + ); +#elif defined(SQLITE_WIN32_HAS_ANSI) && SQLITE_WIN32_CREATEFILEMAPPINGA + hMap = osCreateFileMappingA(pShmNode->hFile.h, + NULL, protect, 0, nByte, NULL + ); +#endif + OSTRACE(("SHM-MAP-CREATE pid=%lu, region=%d, size=%d, rc=%s\n", + osGetCurrentProcessId(), pShmNode->nRegion, nByte, + hMap ? "ok" : "failed")); + if( hMap ){ + int iOffset = pShmNode->nRegion*szRegion; + int iOffsetShift = iOffset % winSysInfo.dwAllocationGranularity; +#if SQLITE_OS_WINRT + pMap = osMapViewOfFileFromApp(hMap, flags, + iOffset - iOffsetShift, szRegion + iOffsetShift + ); +#else + pMap = osMapViewOfFile(hMap, flags, + 0, iOffset - iOffsetShift, szRegion + iOffsetShift + ); +#endif + OSTRACE(("SHM-MAP-MAP pid=%lu, region=%d, offset=%d, size=%d, rc=%s\n", + osGetCurrentProcessId(), pShmNode->nRegion, iOffset, + szRegion, pMap ? "ok" : "failed")); + } + if( !pMap ){ + pShmNode->lastErrno = osGetLastError(); + rc = winLogError(SQLITE_IOERR_SHMMAP, pShmNode->lastErrno, + "winShmMap3", pDbFd->zPath); + if( hMap ) osCloseHandle(hMap); + goto shmpage_out; + } + + pShmNode->aRegion[pShmNode->nRegion].pMap = pMap; + pShmNode->aRegion[pShmNode->nRegion].hMap = hMap; + pShmNode->nRegion++; + } + } + +shmpage_out: + if( pShmNode->nRegion>iRegion ){ + int iOffset = iRegion*szRegion; + int iOffsetShift = iOffset % winSysInfo.dwAllocationGranularity; + char *p = (char *)pShmNode->aRegion[iRegion].pMap; + *pp = (void *)&p[iOffsetShift]; + }else{ + *pp = 0; + } + if( pShmNode->isReadonly && rc==SQLITE_OK ) rc = SQLITE_READONLY; + sqlite3_mutex_leave(pShmNode->mutex); + return rc; +} + +#else +# define winShmMap 0 +# define winShmLock 0 +# define winShmBarrier 0 +# define winShmUnmap 0 +#endif /* #ifndef SQLITE_OMIT_WAL */ + +/* +** Cleans up the mapped region of the specified file, if any. +*/ +#if SQLITE_MAX_MMAP_SIZE>0 +static int winUnmapfile(winFile *pFile){ + assert( pFile!=0 ); + OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, hMap=%p, pMapRegion=%p, " + "mmapSize=%lld, mmapSizeMax=%lld\n", + osGetCurrentProcessId(), pFile, pFile->hMap, pFile->pMapRegion, + pFile->mmapSize, pFile->mmapSizeMax)); + if( pFile->pMapRegion ){ + if( !osUnmapViewOfFile(pFile->pMapRegion) ){ + pFile->lastErrno = osGetLastError(); + OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, pMapRegion=%p, " + "rc=SQLITE_IOERR_MMAP\n", osGetCurrentProcessId(), pFile, + pFile->pMapRegion)); + return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno, + "winUnmapfile1", pFile->zPath); + } + pFile->pMapRegion = 0; + pFile->mmapSize = 0; + } + if( pFile->hMap!=NULL ){ + if( !osCloseHandle(pFile->hMap) ){ + pFile->lastErrno = osGetLastError(); + OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, hMap=%p, rc=SQLITE_IOERR_MMAP\n", + osGetCurrentProcessId(), pFile, pFile->hMap)); + return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno, + "winUnmapfile2", pFile->zPath); + } + pFile->hMap = NULL; + } + OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFile)); + return SQLITE_OK; +} + +/* +** Memory map or remap the file opened by file-descriptor pFd (if the file +** is already mapped, the existing mapping is replaced by the new). Or, if +** there already exists a mapping for this file, and there are still +** outstanding xFetch() references to it, this function is a no-op. +** +** If parameter nByte is non-negative, then it is the requested size of +** the mapping to create. Otherwise, if nByte is less than zero, then the +** requested size is the size of the file on disk. The actual size of the +** created mapping is either the requested size or the value configured +** using SQLITE_FCNTL_MMAP_SIZE, whichever is smaller. +** +** SQLITE_OK is returned if no error occurs (even if the mapping is not +** recreated as a result of outstanding references) or an SQLite error +** code otherwise. +*/ +static int winMapfile(winFile *pFd, sqlite3_int64 nByte){ + sqlite3_int64 nMap = nByte; + int rc; + + assert( nMap>=0 || pFd->nFetchOut==0 ); + OSTRACE(("MAP-FILE pid=%lu, pFile=%p, size=%lld\n", + osGetCurrentProcessId(), pFd, nByte)); + + if( pFd->nFetchOut>0 ) return SQLITE_OK; + + if( nMap<0 ){ + rc = winFileSize((sqlite3_file*)pFd, &nMap); + if( rc ){ + OSTRACE(("MAP-FILE pid=%lu, pFile=%p, rc=SQLITE_IOERR_FSTAT\n", + osGetCurrentProcessId(), pFd)); + return SQLITE_IOERR_FSTAT; + } + } + if( nMap>pFd->mmapSizeMax ){ + nMap = pFd->mmapSizeMax; + } + nMap &= ~(sqlite3_int64)(winSysInfo.dwPageSize - 1); + + if( nMap==0 && pFd->mmapSize>0 ){ + winUnmapfile(pFd); + } + if( nMap!=pFd->mmapSize ){ + void *pNew = 0; + DWORD protect = PAGE_READONLY; + DWORD flags = FILE_MAP_READ; + + winUnmapfile(pFd); +#ifdef SQLITE_MMAP_READWRITE + if( (pFd->ctrlFlags & WINFILE_RDONLY)==0 ){ + protect = PAGE_READWRITE; + flags |= FILE_MAP_WRITE; + } +#endif +#if SQLITE_OS_WINRT + pFd->hMap = osCreateFileMappingFromApp(pFd->h, NULL, protect, nMap, NULL); +#elif defined(SQLITE_WIN32_HAS_WIDE) + pFd->hMap = osCreateFileMappingW(pFd->h, NULL, protect, + (DWORD)((nMap>>32) & 0xffffffff), + (DWORD)(nMap & 0xffffffff), NULL); +#elif defined(SQLITE_WIN32_HAS_ANSI) && SQLITE_WIN32_CREATEFILEMAPPINGA + pFd->hMap = osCreateFileMappingA(pFd->h, NULL, protect, + (DWORD)((nMap>>32) & 0xffffffff), + (DWORD)(nMap & 0xffffffff), NULL); +#endif + if( pFd->hMap==NULL ){ + pFd->lastErrno = osGetLastError(); + rc = winLogError(SQLITE_IOERR_MMAP, pFd->lastErrno, + "winMapfile1", pFd->zPath); + /* Log the error, but continue normal operation using xRead/xWrite */ + OSTRACE(("MAP-FILE-CREATE pid=%lu, pFile=%p, rc=%s\n", + osGetCurrentProcessId(), pFd, sqlite3ErrName(rc))); + return SQLITE_OK; + } + assert( (nMap % winSysInfo.dwPageSize)==0 ); + assert( sizeof(SIZE_T)==sizeof(sqlite3_int64) || nMap<=0xffffffff ); +#if SQLITE_OS_WINRT + pNew = osMapViewOfFileFromApp(pFd->hMap, flags, 0, (SIZE_T)nMap); +#else + pNew = osMapViewOfFile(pFd->hMap, flags, 0, 0, (SIZE_T)nMap); +#endif + if( pNew==NULL ){ + osCloseHandle(pFd->hMap); + pFd->hMap = NULL; + pFd->lastErrno = osGetLastError(); + rc = winLogError(SQLITE_IOERR_MMAP, pFd->lastErrno, + "winMapfile2", pFd->zPath); + /* Log the error, but continue normal operation using xRead/xWrite */ + OSTRACE(("MAP-FILE-MAP pid=%lu, pFile=%p, rc=%s\n", + osGetCurrentProcessId(), pFd, sqlite3ErrName(rc))); + return SQLITE_OK; + } + pFd->pMapRegion = pNew; + pFd->mmapSize = nMap; + } + + OSTRACE(("MAP-FILE pid=%lu, pFile=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), pFd)); + return SQLITE_OK; +} +#endif /* SQLITE_MAX_MMAP_SIZE>0 */ + +/* +** If possible, return a pointer to a mapping of file fd starting at offset +** iOff. The mapping must be valid for at least nAmt bytes. +** +** If such a pointer can be obtained, store it in *pp and return SQLITE_OK. +** Or, if one cannot but no error occurs, set *pp to 0 and return SQLITE_OK. +** Finally, if an error does occur, return an SQLite error code. The final +** value of *pp is undefined in this case. +** +** If this function does return a pointer, the caller must eventually +** release the reference by calling winUnfetch(). +*/ +static int winFetch(sqlite3_file *fd, i64 iOff, int nAmt, void **pp){ +#if SQLITE_MAX_MMAP_SIZE>0 + winFile *pFd = (winFile*)fd; /* The underlying database file */ +#endif + *pp = 0; + + OSTRACE(("FETCH pid=%lu, pFile=%p, offset=%lld, amount=%d, pp=%p\n", + osGetCurrentProcessId(), fd, iOff, nAmt, pp)); + +#if SQLITE_MAX_MMAP_SIZE>0 + if( pFd->mmapSizeMax>0 ){ + if( pFd->pMapRegion==0 ){ + int rc = winMapfile(pFd, -1); + if( rc!=SQLITE_OK ){ + OSTRACE(("FETCH pid=%lu, pFile=%p, rc=%s\n", + osGetCurrentProcessId(), pFd, sqlite3ErrName(rc))); + return rc; + } + } + if( pFd->mmapSize >= iOff+nAmt ){ + assert( pFd->pMapRegion!=0 ); + *pp = &((u8 *)pFd->pMapRegion)[iOff]; + pFd->nFetchOut++; + } + } +#endif + + OSTRACE(("FETCH pid=%lu, pFile=%p, pp=%p, *pp=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), fd, pp, *pp)); + return SQLITE_OK; +} + +/* +** If the third argument is non-NULL, then this function releases a +** reference obtained by an earlier call to winFetch(). The second +** argument passed to this function must be the same as the corresponding +** argument that was passed to the winFetch() invocation. +** +** Or, if the third argument is NULL, then this function is being called +** to inform the VFS layer that, according to POSIX, any existing mapping +** may now be invalid and should be unmapped. +*/ +static int winUnfetch(sqlite3_file *fd, i64 iOff, void *p){ +#if SQLITE_MAX_MMAP_SIZE>0 + winFile *pFd = (winFile*)fd; /* The underlying database file */ + + /* If p==0 (unmap the entire file) then there must be no outstanding + ** xFetch references. Or, if p!=0 (meaning it is an xFetch reference), + ** then there must be at least one outstanding. */ + assert( (p==0)==(pFd->nFetchOut==0) ); + + /* If p!=0, it must match the iOff value. */ + assert( p==0 || p==&((u8 *)pFd->pMapRegion)[iOff] ); + + OSTRACE(("UNFETCH pid=%lu, pFile=%p, offset=%lld, p=%p\n", + osGetCurrentProcessId(), pFd, iOff, p)); + + if( p ){ + pFd->nFetchOut--; + }else{ + /* FIXME: If Windows truly always prevents truncating or deleting a + ** file while a mapping is held, then the following winUnmapfile() call + ** is unnecessary can be omitted - potentially improving + ** performance. */ + winUnmapfile(pFd); + } + + assert( pFd->nFetchOut>=0 ); +#endif + + OSTRACE(("UNFETCH pid=%lu, pFile=%p, rc=SQLITE_OK\n", + osGetCurrentProcessId(), fd)); + return SQLITE_OK; +} + +/* +** Here ends the implementation of all sqlite3_file methods. +** +********************** End sqlite3_file Methods ******************************* +******************************************************************************/ + +/* +** This vector defines all the methods that can operate on an +** sqlite3_file for win32. +*/ +static const sqlite3_io_methods winIoMethod = { + 3, /* iVersion */ + winClose, /* xClose */ + winRead, /* xRead */ + winWrite, /* xWrite */ + winTruncate, /* xTruncate */ + winSync, /* xSync */ + winFileSize, /* xFileSize */ + winLock, /* xLock */ + winUnlock, /* xUnlock */ + winCheckReservedLock, /* xCheckReservedLock */ + winFileControl, /* xFileControl */ + winSectorSize, /* xSectorSize */ + winDeviceCharacteristics, /* xDeviceCharacteristics */ + winShmMap, /* xShmMap */ + winShmLock, /* xShmLock */ + winShmBarrier, /* xShmBarrier */ + winShmUnmap, /* xShmUnmap */ + winFetch, /* xFetch */ + winUnfetch /* xUnfetch */ +}; + +/* +** This vector defines all the methods that can operate on an +** sqlite3_file for win32 without performing any locking. +*/ +static const sqlite3_io_methods winIoNolockMethod = { + 3, /* iVersion */ + winClose, /* xClose */ + winRead, /* xRead */ + winWrite, /* xWrite */ + winTruncate, /* xTruncate */ + winSync, /* xSync */ + winFileSize, /* xFileSize */ + winNolockLock, /* xLock */ + winNolockUnlock, /* xUnlock */ + winNolockCheckReservedLock, /* xCheckReservedLock */ + winFileControl, /* xFileControl */ + winSectorSize, /* xSectorSize */ + winDeviceCharacteristics, /* xDeviceCharacteristics */ + winShmMap, /* xShmMap */ + winShmLock, /* xShmLock */ + winShmBarrier, /* xShmBarrier */ + winShmUnmap, /* xShmUnmap */ + winFetch, /* xFetch */ + winUnfetch /* xUnfetch */ +}; + +static winVfsAppData winAppData = { + &winIoMethod, /* pMethod */ + 0, /* pAppData */ + 0 /* bNoLock */ +}; + +static winVfsAppData winNolockAppData = { + &winIoNolockMethod, /* pMethod */ + 0, /* pAppData */ + 1 /* bNoLock */ +}; + +/**************************************************************************** +**************************** sqlite3_vfs methods **************************** +** +** This division contains the implementation of methods on the +** sqlite3_vfs object. +*/ + +#if defined(__CYGWIN__) +/* +** Convert a filename from whatever the underlying operating system +** supports for filenames into UTF-8. Space to hold the result is +** obtained from malloc and must be freed by the calling function. +*/ +static char *winConvertToUtf8Filename(const void *zFilename){ + char *zConverted = 0; + if( osIsNT() ){ + zConverted = winUnicodeToUtf8(zFilename); + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + zConverted = winMbcsToUtf8(zFilename, osAreFileApisANSI()); + } +#endif + /* caller will handle out of memory */ + return zConverted; +} +#endif + +/* +** Convert a UTF-8 filename into whatever form the underlying +** operating system wants filenames in. Space to hold the result +** is obtained from malloc and must be freed by the calling +** function. +*/ +static void *winConvertFromUtf8Filename(const char *zFilename){ + void *zConverted = 0; + if( osIsNT() ){ + zConverted = winUtf8ToUnicode(zFilename); + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + zConverted = winUtf8ToMbcs(zFilename, osAreFileApisANSI()); + } +#endif + /* caller will handle out of memory */ + return zConverted; +} + +/* +** This function returns non-zero if the specified UTF-8 string buffer +** ends with a directory separator character or one was successfully +** added to it. +*/ +static int winMakeEndInDirSep(int nBuf, char *zBuf){ + if( zBuf ){ + int nLen = sqlite3Strlen30(zBuf); + if( nLen>0 ){ + if( winIsDirSep(zBuf[nLen-1]) ){ + return 1; + }else if( nLen+1mxPathname; nBuf = nMax + 2; + zBuf = sqlite3MallocZero( nBuf ); + if( !zBuf ){ + OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n")); + return SQLITE_IOERR_NOMEM_BKPT; + } + + /* Figure out the effective temporary directory. First, check if one + ** has been explicitly set by the application; otherwise, use the one + ** configured by the operating system. + */ + nDir = nMax - (nPre + 15); + assert( nDir>0 ); + if( winTempDirDefined() ){ + int nDirLen = sqlite3Strlen30(sqlite3_temp_directory); + if( nDirLen>0 ){ + if( !winIsDirSep(sqlite3_temp_directory[nDirLen-1]) ){ + nDirLen++; + } + if( nDirLen>nDir ){ + sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR)); + sqlite3_free(zBuf); + OSTRACE(("TEMP-FILENAME rc=SQLITE_ERROR\n")); + return winLogError(SQLITE_ERROR, 0, "winGetTempname1", 0); + } + sqlite3_snprintf(nMax, zBuf, "%s", sqlite3_temp_directory); + } + sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR)); + } + +#if defined(__CYGWIN__) + else{ + static const char *azDirs[] = { + 0, /* getenv("SQLITE_TMPDIR") */ + 0, /* getenv("TMPDIR") */ + 0, /* getenv("TMP") */ + 0, /* getenv("TEMP") */ + 0, /* getenv("USERPROFILE") */ + "/var/tmp", + "/usr/tmp", + "/tmp", + ".", + 0 /* List terminator */ + }; + unsigned int i; + const char *zDir = 0; + + if( !azDirs[0] ) azDirs[0] = getenv("SQLITE_TMPDIR"); + if( !azDirs[1] ) azDirs[1] = getenv("TMPDIR"); + if( !azDirs[2] ) azDirs[2] = getenv("TMP"); + if( !azDirs[3] ) azDirs[3] = getenv("TEMP"); + if( !azDirs[4] ) azDirs[4] = getenv("USERPROFILE"); + for(i=0; i/etilqs_XXXXXXXXXXXXXXX\0\0" + ** + ** If not, return SQLITE_ERROR. The number 17 is used here in order to + ** account for the space used by the 15 character random suffix and the + ** two trailing NUL characters. The final directory separator character + ** has already added if it was not already present. + */ + nLen = sqlite3Strlen30(zBuf); + if( (nLen + nPre + 17) > nBuf ){ + sqlite3_free(zBuf); + OSTRACE(("TEMP-FILENAME rc=SQLITE_ERROR\n")); + return winLogError(SQLITE_ERROR, 0, "winGetTempname5", 0); + } + + sqlite3_snprintf(nBuf-16-nLen, zBuf+nLen, SQLITE_TEMP_FILE_PREFIX); + + j = sqlite3Strlen30(zBuf); + sqlite3_randomness(15, &zBuf[j]); + for(i=0; i<15; i++, j++){ + zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ]; + } + zBuf[j] = 0; + zBuf[j+1] = 0; + *pzBuf = zBuf; + + OSTRACE(("TEMP-FILENAME name=%s, rc=SQLITE_OK\n", zBuf)); + return SQLITE_OK; +} + +/* +** Return TRUE if the named file is really a directory. Return false if +** it is something other than a directory, or if there is any kind of memory +** allocation failure. +*/ +static int winIsDir(const void *zConverted){ + DWORD attr; + int rc = 0; + DWORD lastErrno; + + if( osIsNT() ){ + int cnt = 0; + WIN32_FILE_ATTRIBUTE_DATA sAttrData; + memset(&sAttrData, 0, sizeof(sAttrData)); + while( !(rc = osGetFileAttributesExW((LPCWSTR)zConverted, + GetFileExInfoStandard, + &sAttrData)) && winRetryIoerr(&cnt, &lastErrno) ){} + if( !rc ){ + return 0; /* Invalid name? */ + } + attr = sAttrData.dwFileAttributes; +#if SQLITE_OS_WINCE==0 + }else{ + attr = osGetFileAttributesA((char*)zConverted); +#endif + } + return (attr!=INVALID_FILE_ATTRIBUTES) && (attr&FILE_ATTRIBUTE_DIRECTORY); +} + +/* forward reference */ +static int winAccess( + sqlite3_vfs *pVfs, /* Not used on win32 */ + const char *zFilename, /* Name of file to check */ + int flags, /* Type of test to make on this file */ + int *pResOut /* OUT: Result */ +); + +/* +** Open a file. +*/ +static int winOpen( + sqlite3_vfs *pVfs, /* Used to get maximum path length and AppData */ + const char *zName, /* Name of the file (UTF-8) */ + sqlite3_file *id, /* Write the SQLite file handle here */ + int flags, /* Open mode flags */ + int *pOutFlags /* Status return flags */ +){ + HANDLE h; + DWORD lastErrno = 0; + DWORD dwDesiredAccess; + DWORD dwShareMode; + DWORD dwCreationDisposition; + DWORD dwFlagsAndAttributes = 0; +#if SQLITE_OS_WINCE + int isTemp = 0; +#endif + winVfsAppData *pAppData; + winFile *pFile = (winFile*)id; + void *zConverted; /* Filename in OS encoding */ + const char *zUtf8Name = zName; /* Filename in UTF-8 encoding */ + int cnt = 0; + + /* If argument zPath is a NULL pointer, this function is required to open + ** a temporary file. Use this buffer to store the file name in. + */ + char *zTmpname = 0; /* For temporary filename, if necessary. */ + + int rc = SQLITE_OK; /* Function Return Code */ +#if !defined(NDEBUG) || SQLITE_OS_WINCE + int eType = flags&0xFFFFFF00; /* Type of file to open */ +#endif + + int isExclusive = (flags & SQLITE_OPEN_EXCLUSIVE); + int isDelete = (flags & SQLITE_OPEN_DELETEONCLOSE); + int isCreate = (flags & SQLITE_OPEN_CREATE); + int isReadonly = (flags & SQLITE_OPEN_READONLY); + int isReadWrite = (flags & SQLITE_OPEN_READWRITE); + +#ifndef NDEBUG + int isOpenJournal = (isCreate && ( + eType==SQLITE_OPEN_SUPER_JOURNAL + || eType==SQLITE_OPEN_MAIN_JOURNAL + || eType==SQLITE_OPEN_WAL + )); +#endif + + OSTRACE(("OPEN name=%s, pFile=%p, flags=%x, pOutFlags=%p\n", + zUtf8Name, id, flags, pOutFlags)); + + /* Check the following statements are true: + ** + ** (a) Exactly one of the READWRITE and READONLY flags must be set, and + ** (b) if CREATE is set, then READWRITE must also be set, and + ** (c) if EXCLUSIVE is set, then CREATE must also be set. + ** (d) if DELETEONCLOSE is set, then CREATE must also be set. + */ + assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly)); + assert(isCreate==0 || isReadWrite); + assert(isExclusive==0 || isCreate); + assert(isDelete==0 || isCreate); + + /* The main DB, main journal, WAL file and super-journal are never + ** automatically deleted. Nor are they ever temporary files. */ + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB ); + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL ); + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_SUPER_JOURNAL ); + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL ); + + /* Assert that the upper layer has set one of the "file-type" flags. */ + assert( eType==SQLITE_OPEN_MAIN_DB || eType==SQLITE_OPEN_TEMP_DB + || eType==SQLITE_OPEN_MAIN_JOURNAL || eType==SQLITE_OPEN_TEMP_JOURNAL + || eType==SQLITE_OPEN_SUBJOURNAL || eType==SQLITE_OPEN_SUPER_JOURNAL + || eType==SQLITE_OPEN_TRANSIENT_DB || eType==SQLITE_OPEN_WAL + ); + + assert( pFile!=0 ); + memset(pFile, 0, sizeof(winFile)); + pFile->h = INVALID_HANDLE_VALUE; + +#if SQLITE_OS_WINRT + if( !zUtf8Name && !sqlite3_temp_directory ){ + sqlite3_log(SQLITE_ERROR, + "sqlite3_temp_directory variable should be set for WinRT"); + } +#endif + + /* If the second argument to this function is NULL, generate a + ** temporary file name to use + */ + if( !zUtf8Name ){ + assert( isDelete && !isOpenJournal ); + rc = winGetTempname(pVfs, &zTmpname); + if( rc!=SQLITE_OK ){ + OSTRACE(("OPEN name=%s, rc=%s", zUtf8Name, sqlite3ErrName(rc))); + return rc; + } + zUtf8Name = zTmpname; + } + + /* Database filenames are double-zero terminated if they are not + ** URIs with parameters. Hence, they can always be passed into + ** sqlite3_uri_parameter(). + */ + assert( (eType!=SQLITE_OPEN_MAIN_DB) || (flags & SQLITE_OPEN_URI) || + zUtf8Name[sqlite3Strlen30(zUtf8Name)+1]==0 ); + + /* Convert the filename to the system encoding. */ + zConverted = winConvertFromUtf8Filename(zUtf8Name); + if( zConverted==0 ){ + sqlite3_free(zTmpname); + OSTRACE(("OPEN name=%s, rc=SQLITE_IOERR_NOMEM", zUtf8Name)); + return SQLITE_IOERR_NOMEM_BKPT; + } + + if( winIsDir(zConverted) ){ + sqlite3_free(zConverted); + sqlite3_free(zTmpname); + OSTRACE(("OPEN name=%s, rc=SQLITE_CANTOPEN_ISDIR", zUtf8Name)); + return SQLITE_CANTOPEN_ISDIR; + } + + if( isReadWrite ){ + dwDesiredAccess = GENERIC_READ | GENERIC_WRITE; + }else{ + dwDesiredAccess = GENERIC_READ; + } + + /* SQLITE_OPEN_EXCLUSIVE is used to make sure that a new file is + ** created. SQLite doesn't use it to indicate "exclusive access" + ** as it is usually understood. + */ + if( isExclusive ){ + /* Creates a new file, only if it does not already exist. */ + /* If the file exists, it fails. */ + dwCreationDisposition = CREATE_NEW; + }else if( isCreate ){ + /* Open existing file, or create if it doesn't exist */ + dwCreationDisposition = OPEN_ALWAYS; + }else{ + /* Opens a file, only if it exists. */ + dwCreationDisposition = OPEN_EXISTING; + } + + if( 0==sqlite3_uri_boolean(zName, "exclusive", 0) ){ + dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE; + }else{ + dwShareMode = 0; + } + + if( isDelete ){ +#if SQLITE_OS_WINCE + dwFlagsAndAttributes = FILE_ATTRIBUTE_HIDDEN; + isTemp = 1; +#else + dwFlagsAndAttributes = FILE_ATTRIBUTE_TEMPORARY + | FILE_ATTRIBUTE_HIDDEN + | FILE_FLAG_DELETE_ON_CLOSE; +#endif + }else{ + dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL; + } + /* Reports from the internet are that performance is always + ** better if FILE_FLAG_RANDOM_ACCESS is used. Ticket #2699. */ +#if SQLITE_OS_WINCE + dwFlagsAndAttributes |= FILE_FLAG_RANDOM_ACCESS; +#endif + + if( osIsNT() ){ +#if SQLITE_OS_WINRT + CREATEFILE2_EXTENDED_PARAMETERS extendedParameters; + extendedParameters.dwSize = sizeof(CREATEFILE2_EXTENDED_PARAMETERS); + extendedParameters.dwFileAttributes = + dwFlagsAndAttributes & FILE_ATTRIBUTE_MASK; + extendedParameters.dwFileFlags = dwFlagsAndAttributes & FILE_FLAG_MASK; + extendedParameters.dwSecurityQosFlags = SECURITY_ANONYMOUS; + extendedParameters.lpSecurityAttributes = NULL; + extendedParameters.hTemplateFile = NULL; + do{ + h = osCreateFile2((LPCWSTR)zConverted, + dwDesiredAccess, + dwShareMode, + dwCreationDisposition, + &extendedParameters); + if( h!=INVALID_HANDLE_VALUE ) break; + if( isReadWrite ){ + int rc2, isRO = 0; + sqlite3BeginBenignMalloc(); + rc2 = winAccess(pVfs, zUtf8Name, SQLITE_ACCESS_READ, &isRO); + sqlite3EndBenignMalloc(); + if( rc2==SQLITE_OK && isRO ) break; + } + }while( winRetryIoerr(&cnt, &lastErrno) ); +#else + do{ + h = osCreateFileW((LPCWSTR)zConverted, + dwDesiredAccess, + dwShareMode, NULL, + dwCreationDisposition, + dwFlagsAndAttributes, + NULL); + if( h!=INVALID_HANDLE_VALUE ) break; + if( isReadWrite ){ + int rc2, isRO = 0; + sqlite3BeginBenignMalloc(); + rc2 = winAccess(pVfs, zUtf8Name, SQLITE_ACCESS_READ, &isRO); + sqlite3EndBenignMalloc(); + if( rc2==SQLITE_OK && isRO ) break; + } + }while( winRetryIoerr(&cnt, &lastErrno) ); +#endif + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + do{ + h = osCreateFileA((LPCSTR)zConverted, + dwDesiredAccess, + dwShareMode, NULL, + dwCreationDisposition, + dwFlagsAndAttributes, + NULL); + if( h!=INVALID_HANDLE_VALUE ) break; + if( isReadWrite ){ + int rc2, isRO = 0; + sqlite3BeginBenignMalloc(); + rc2 = winAccess(pVfs, zUtf8Name, SQLITE_ACCESS_READ, &isRO); + sqlite3EndBenignMalloc(); + if( rc2==SQLITE_OK && isRO ) break; + } + }while( winRetryIoerr(&cnt, &lastErrno) ); + } +#endif + winLogIoerr(cnt, __LINE__); + + OSTRACE(("OPEN file=%p, name=%s, access=%lx, rc=%s\n", h, zUtf8Name, + dwDesiredAccess, (h==INVALID_HANDLE_VALUE) ? "failed" : "ok")); + + if( h==INVALID_HANDLE_VALUE ){ + sqlite3_free(zConverted); + sqlite3_free(zTmpname); + if( isReadWrite && !isExclusive ){ + return winOpen(pVfs, zName, id, + ((flags|SQLITE_OPEN_READONLY) & + ~(SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE)), + pOutFlags); + }else{ + pFile->lastErrno = lastErrno; + winLogError(SQLITE_CANTOPEN, pFile->lastErrno, "winOpen", zUtf8Name); + return SQLITE_CANTOPEN_BKPT; + } + } + + if( pOutFlags ){ + if( isReadWrite ){ + *pOutFlags = SQLITE_OPEN_READWRITE; + }else{ + *pOutFlags = SQLITE_OPEN_READONLY; + } + } + + OSTRACE(("OPEN file=%p, name=%s, access=%lx, pOutFlags=%p, *pOutFlags=%d, " + "rc=%s\n", h, zUtf8Name, dwDesiredAccess, pOutFlags, pOutFlags ? + *pOutFlags : 0, (h==INVALID_HANDLE_VALUE) ? "failed" : "ok")); + + pAppData = (winVfsAppData*)pVfs->pAppData; + +#if SQLITE_OS_WINCE + { + if( isReadWrite && eType==SQLITE_OPEN_MAIN_DB + && ((pAppData==NULL) || !pAppData->bNoLock) + && (rc = winceCreateLock(zName, pFile))!=SQLITE_OK + ){ + osCloseHandle(h); + sqlite3_free(zConverted); + sqlite3_free(zTmpname); + OSTRACE(("OPEN-CE-LOCK name=%s, rc=%s\n", zName, sqlite3ErrName(rc))); + return rc; + } + } + if( isTemp ){ + pFile->zDeleteOnClose = zConverted; + }else +#endif + { + sqlite3_free(zConverted); + } + + sqlite3_free(zTmpname); + id->pMethods = pAppData ? pAppData->pMethod : &winIoMethod; + pFile->pVfs = pVfs; + pFile->h = h; + if( isReadonly ){ + pFile->ctrlFlags |= WINFILE_RDONLY; + } + if( (flags & SQLITE_OPEN_MAIN_DB) + && sqlite3_uri_boolean(zName, "psow", SQLITE_POWERSAFE_OVERWRITE) + ){ + pFile->ctrlFlags |= WINFILE_PSOW; + } + pFile->lastErrno = NO_ERROR; + pFile->zPath = zName; +#if SQLITE_MAX_MMAP_SIZE>0 + pFile->hMap = NULL; + pFile->pMapRegion = 0; + pFile->mmapSize = 0; + pFile->mmapSizeMax = sqlite3GlobalConfig.szMmap; +#endif + + OpenCounter(+1); + return rc; +} + +/* +** Delete the named file. +** +** Note that Windows does not allow a file to be deleted if some other +** process has it open. Sometimes a virus scanner or indexing program +** will open a journal file shortly after it is created in order to do +** whatever it does. While this other process is holding the +** file open, we will be unable to delete it. To work around this +** problem, we delay 100 milliseconds and try to delete again. Up +** to MX_DELETION_ATTEMPTs deletion attempts are run before giving +** up and returning an error. +*/ +static int winDelete( + sqlite3_vfs *pVfs, /* Not used on win32 */ + const char *zFilename, /* Name of file to delete */ + int syncDir /* Not used on win32 */ +){ + int cnt = 0; + int rc; + DWORD attr; + DWORD lastErrno = 0; + void *zConverted; + UNUSED_PARAMETER(pVfs); + UNUSED_PARAMETER(syncDir); + + SimulateIOError(return SQLITE_IOERR_DELETE); + OSTRACE(("DELETE name=%s, syncDir=%d\n", zFilename, syncDir)); + + zConverted = winConvertFromUtf8Filename(zFilename); + if( zConverted==0 ){ + OSTRACE(("DELETE name=%s, rc=SQLITE_IOERR_NOMEM\n", zFilename)); + return SQLITE_IOERR_NOMEM_BKPT; + } + if( osIsNT() ){ + do { +#if SQLITE_OS_WINRT + WIN32_FILE_ATTRIBUTE_DATA sAttrData; + memset(&sAttrData, 0, sizeof(sAttrData)); + if ( osGetFileAttributesExW(zConverted, GetFileExInfoStandard, + &sAttrData) ){ + attr = sAttrData.dwFileAttributes; + }else{ + lastErrno = osGetLastError(); + if( lastErrno==ERROR_FILE_NOT_FOUND + || lastErrno==ERROR_PATH_NOT_FOUND ){ + rc = SQLITE_IOERR_DELETE_NOENT; /* Already gone? */ + }else{ + rc = SQLITE_ERROR; + } + break; + } +#else + attr = osGetFileAttributesW(zConverted); +#endif + if ( attr==INVALID_FILE_ATTRIBUTES ){ + lastErrno = osGetLastError(); + if( lastErrno==ERROR_FILE_NOT_FOUND + || lastErrno==ERROR_PATH_NOT_FOUND ){ + rc = SQLITE_IOERR_DELETE_NOENT; /* Already gone? */ + }else{ + rc = SQLITE_ERROR; + } + break; + } + if ( attr&FILE_ATTRIBUTE_DIRECTORY ){ + rc = SQLITE_ERROR; /* Files only. */ + break; + } + if ( osDeleteFileW(zConverted) ){ + rc = SQLITE_OK; /* Deleted OK. */ + break; + } + if ( !winRetryIoerr(&cnt, &lastErrno) ){ + rc = SQLITE_ERROR; /* No more retries. */ + break; + } + } while(1); + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + do { + attr = osGetFileAttributesA(zConverted); + if ( attr==INVALID_FILE_ATTRIBUTES ){ + lastErrno = osGetLastError(); + if( lastErrno==ERROR_FILE_NOT_FOUND + || lastErrno==ERROR_PATH_NOT_FOUND ){ + rc = SQLITE_IOERR_DELETE_NOENT; /* Already gone? */ + }else{ + rc = SQLITE_ERROR; + } + break; + } + if ( attr&FILE_ATTRIBUTE_DIRECTORY ){ + rc = SQLITE_ERROR; /* Files only. */ + break; + } + if ( osDeleteFileA(zConverted) ){ + rc = SQLITE_OK; /* Deleted OK. */ + break; + } + if ( !winRetryIoerr(&cnt, &lastErrno) ){ + rc = SQLITE_ERROR; /* No more retries. */ + break; + } + } while(1); + } +#endif + if( rc && rc!=SQLITE_IOERR_DELETE_NOENT ){ + rc = winLogError(SQLITE_IOERR_DELETE, lastErrno, "winDelete", zFilename); + }else{ + winLogIoerr(cnt, __LINE__); + } + sqlite3_free(zConverted); + OSTRACE(("DELETE name=%s, rc=%s\n", zFilename, sqlite3ErrName(rc))); + return rc; +} + +/* +** Check the existence and status of a file. +*/ +static int winAccess( + sqlite3_vfs *pVfs, /* Not used on win32 */ + const char *zFilename, /* Name of file to check */ + int flags, /* Type of test to make on this file */ + int *pResOut /* OUT: Result */ +){ + DWORD attr; + int rc = 0; + DWORD lastErrno = 0; + void *zConverted; + UNUSED_PARAMETER(pVfs); + + SimulateIOError( return SQLITE_IOERR_ACCESS; ); + OSTRACE(("ACCESS name=%s, flags=%x, pResOut=%p\n", + zFilename, flags, pResOut)); + + if( zFilename==0 ){ + *pResOut = 0; + OSTRACE(("ACCESS name=%s, pResOut=%p, *pResOut=%d, rc=SQLITE_OK\n", + zFilename, pResOut, *pResOut)); + return SQLITE_OK; + } + + zConverted = winConvertFromUtf8Filename(zFilename); + if( zConverted==0 ){ + OSTRACE(("ACCESS name=%s, rc=SQLITE_IOERR_NOMEM\n", zFilename)); + return SQLITE_IOERR_NOMEM_BKPT; + } + if( osIsNT() ){ + int cnt = 0; + WIN32_FILE_ATTRIBUTE_DATA sAttrData; + memset(&sAttrData, 0, sizeof(sAttrData)); + while( !(rc = osGetFileAttributesExW((LPCWSTR)zConverted, + GetFileExInfoStandard, + &sAttrData)) && winRetryIoerr(&cnt, &lastErrno) ){} + if( rc ){ + /* For an SQLITE_ACCESS_EXISTS query, treat a zero-length file + ** as if it does not exist. + */ + if( flags==SQLITE_ACCESS_EXISTS + && sAttrData.nFileSizeHigh==0 + && sAttrData.nFileSizeLow==0 ){ + attr = INVALID_FILE_ATTRIBUTES; + }else{ + attr = sAttrData.dwFileAttributes; + } + }else{ + winLogIoerr(cnt, __LINE__); + if( lastErrno!=ERROR_FILE_NOT_FOUND && lastErrno!=ERROR_PATH_NOT_FOUND ){ + sqlite3_free(zConverted); + return winLogError(SQLITE_IOERR_ACCESS, lastErrno, "winAccess", + zFilename); + }else{ + attr = INVALID_FILE_ATTRIBUTES; + } + } + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + attr = osGetFileAttributesA((char*)zConverted); + } +#endif + sqlite3_free(zConverted); + switch( flags ){ + case SQLITE_ACCESS_READ: + case SQLITE_ACCESS_EXISTS: + rc = attr!=INVALID_FILE_ATTRIBUTES; + break; + case SQLITE_ACCESS_READWRITE: + rc = attr!=INVALID_FILE_ATTRIBUTES && + (attr & FILE_ATTRIBUTE_READONLY)==0; + break; + default: + assert(!"Invalid flags argument"); + } + *pResOut = rc; + OSTRACE(("ACCESS name=%s, pResOut=%p, *pResOut=%d, rc=SQLITE_OK\n", + zFilename, pResOut, *pResOut)); + return SQLITE_OK; +} + +/* +** Returns non-zero if the specified path name starts with the "long path" +** prefix. +*/ +static BOOL winIsLongPathPrefix( + const char *zPathname +){ + return ( zPathname[0]=='\\' && zPathname[1]=='\\' + && zPathname[2]=='?' && zPathname[3]=='\\' ); +} + +/* +** Returns non-zero if the specified path name starts with a drive letter +** followed by a colon character. +*/ +static BOOL winIsDriveLetterAndColon( + const char *zPathname +){ + return ( sqlite3Isalpha(zPathname[0]) && zPathname[1]==':' ); +} + +/* +** Returns non-zero if the specified path name should be used verbatim. If +** non-zero is returned from this function, the calling function must simply +** use the provided path name verbatim -OR- resolve it into a full path name +** using the GetFullPathName Win32 API function (if available). +*/ +static BOOL winIsVerbatimPathname( + const char *zPathname +){ + /* + ** If the path name starts with a forward slash or a backslash, it is either + ** a legal UNC name, a volume relative path, or an absolute path name in the + ** "Unix" format on Windows. There is no easy way to differentiate between + ** the final two cases; therefore, we return the safer return value of TRUE + ** so that callers of this function will simply use it verbatim. + */ + if ( winIsDirSep(zPathname[0]) ){ + return TRUE; + } + + /* + ** If the path name starts with a letter and a colon it is either a volume + ** relative path or an absolute path. Callers of this function must not + ** attempt to treat it as a relative path name (i.e. they should simply use + ** it verbatim). + */ + if ( winIsDriveLetterAndColon(zPathname) ){ + return TRUE; + } + + /* + ** If we get to this point, the path name should almost certainly be a purely + ** relative one (i.e. not a UNC name, not absolute, and not volume relative). + */ + return FALSE; +} + +/* +** Turn a relative pathname into a full pathname. Write the full +** pathname into zOut[]. zOut[] will be at least pVfs->mxPathname +** bytes in size. +*/ +static int winFullPathnameNoMutex( + sqlite3_vfs *pVfs, /* Pointer to vfs object */ + const char *zRelative, /* Possibly relative input path */ + int nFull, /* Size of output buffer in bytes */ + char *zFull /* Output buffer */ +){ +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && !defined(__CYGWIN__) + DWORD nByte; + void *zConverted; + char *zOut; +#endif + + /* If this path name begins with "/X:" or "\\?\", where "X" is any + ** alphabetic character, discard the initial "/" from the pathname. + */ + if( zRelative[0]=='/' && (winIsDriveLetterAndColon(zRelative+1) + || winIsLongPathPrefix(zRelative+1)) ){ + zRelative++; + } + +#if defined(__CYGWIN__) + SimulateIOError( return SQLITE_ERROR ); + UNUSED_PARAMETER(nFull); + assert( nFull>=pVfs->mxPathname ); + if ( sqlite3_data_directory && !winIsVerbatimPathname(zRelative) ){ + /* + ** NOTE: We are dealing with a relative path name and the data + ** directory has been set. Therefore, use it as the basis + ** for converting the relative path name to an absolute + ** one by prepending the data directory and a slash. + */ + char *zOut = sqlite3MallocZero( pVfs->mxPathname+1 ); + if( !zOut ){ + return SQLITE_IOERR_NOMEM_BKPT; + } + if( cygwin_conv_path( + (osIsNT() ? CCP_POSIX_TO_WIN_W : CCP_POSIX_TO_WIN_A) | + CCP_RELATIVE, zRelative, zOut, pVfs->mxPathname+1)<0 ){ + sqlite3_free(zOut); + return winLogError(SQLITE_CANTOPEN_CONVPATH, (DWORD)errno, + "winFullPathname1", zRelative); + }else{ + char *zUtf8 = winConvertToUtf8Filename(zOut); + if( !zUtf8 ){ + sqlite3_free(zOut); + return SQLITE_IOERR_NOMEM_BKPT; + } + sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%c%s", + sqlite3_data_directory, winGetDirSep(), zUtf8); + sqlite3_free(zUtf8); + sqlite3_free(zOut); + } + }else{ + char *zOut = sqlite3MallocZero( pVfs->mxPathname+1 ); + if( !zOut ){ + return SQLITE_IOERR_NOMEM_BKPT; + } + if( cygwin_conv_path( + (osIsNT() ? CCP_POSIX_TO_WIN_W : CCP_POSIX_TO_WIN_A), + zRelative, zOut, pVfs->mxPathname+1)<0 ){ + sqlite3_free(zOut); + return winLogError(SQLITE_CANTOPEN_CONVPATH, (DWORD)errno, + "winFullPathname2", zRelative); + }else{ + char *zUtf8 = winConvertToUtf8Filename(zOut); + if( !zUtf8 ){ + sqlite3_free(zOut); + return SQLITE_IOERR_NOMEM_BKPT; + } + sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zUtf8); + sqlite3_free(zUtf8); + sqlite3_free(zOut); + } + } + return SQLITE_OK; +#endif + +#if (SQLITE_OS_WINCE || SQLITE_OS_WINRT) && !defined(__CYGWIN__) + SimulateIOError( return SQLITE_ERROR ); + /* WinCE has no concept of a relative pathname, or so I am told. */ + /* WinRT has no way to convert a relative path to an absolute one. */ + if ( sqlite3_data_directory && !winIsVerbatimPathname(zRelative) ){ + /* + ** NOTE: We are dealing with a relative path name and the data + ** directory has been set. Therefore, use it as the basis + ** for converting the relative path name to an absolute + ** one by prepending the data directory and a backslash. + */ + sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%c%s", + sqlite3_data_directory, winGetDirSep(), zRelative); + }else{ + sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zRelative); + } + return SQLITE_OK; +#endif + +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && !defined(__CYGWIN__) + /* It's odd to simulate an io-error here, but really this is just + ** using the io-error infrastructure to test that SQLite handles this + ** function failing. This function could fail if, for example, the + ** current working directory has been unlinked. + */ + SimulateIOError( return SQLITE_ERROR ); + if ( sqlite3_data_directory && !winIsVerbatimPathname(zRelative) ){ + /* + ** NOTE: We are dealing with a relative path name and the data + ** directory has been set. Therefore, use it as the basis + ** for converting the relative path name to an absolute + ** one by prepending the data directory and a backslash. + */ + sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%c%s", + sqlite3_data_directory, winGetDirSep(), zRelative); + return SQLITE_OK; + } + zConverted = winConvertFromUtf8Filename(zRelative); + if( zConverted==0 ){ + return SQLITE_IOERR_NOMEM_BKPT; + } + if( osIsNT() ){ + LPWSTR zTemp; + nByte = osGetFullPathNameW((LPCWSTR)zConverted, 0, 0, 0); + if( nByte==0 ){ + sqlite3_free(zConverted); + return winLogError(SQLITE_CANTOPEN_FULLPATH, osGetLastError(), + "winFullPathname1", zRelative); + } + nByte += 3; + zTemp = sqlite3MallocZero( nByte*sizeof(zTemp[0]) ); + if( zTemp==0 ){ + sqlite3_free(zConverted); + return SQLITE_IOERR_NOMEM_BKPT; + } + nByte = osGetFullPathNameW((LPCWSTR)zConverted, nByte, zTemp, 0); + if( nByte==0 ){ + sqlite3_free(zConverted); + sqlite3_free(zTemp); + return winLogError(SQLITE_CANTOPEN_FULLPATH, osGetLastError(), + "winFullPathname2", zRelative); + } + sqlite3_free(zConverted); + zOut = winUnicodeToUtf8(zTemp); + sqlite3_free(zTemp); + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + char *zTemp; + nByte = osGetFullPathNameA((char*)zConverted, 0, 0, 0); + if( nByte==0 ){ + sqlite3_free(zConverted); + return winLogError(SQLITE_CANTOPEN_FULLPATH, osGetLastError(), + "winFullPathname3", zRelative); + } + nByte += 3; + zTemp = sqlite3MallocZero( nByte*sizeof(zTemp[0]) ); + if( zTemp==0 ){ + sqlite3_free(zConverted); + return SQLITE_IOERR_NOMEM_BKPT; + } + nByte = osGetFullPathNameA((char*)zConverted, nByte, zTemp, 0); + if( nByte==0 ){ + sqlite3_free(zConverted); + sqlite3_free(zTemp); + return winLogError(SQLITE_CANTOPEN_FULLPATH, osGetLastError(), + "winFullPathname4", zRelative); + } + sqlite3_free(zConverted); + zOut = winMbcsToUtf8(zTemp, osAreFileApisANSI()); + sqlite3_free(zTemp); + } +#endif + if( zOut ){ + sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zOut); + sqlite3_free(zOut); + return SQLITE_OK; + }else{ + return SQLITE_IOERR_NOMEM_BKPT; + } +#endif +} +static int winFullPathname( + sqlite3_vfs *pVfs, /* Pointer to vfs object */ + const char *zRelative, /* Possibly relative input path */ + int nFull, /* Size of output buffer in bytes */ + char *zFull /* Output buffer */ +){ + int rc; + MUTEX_LOGIC( sqlite3_mutex *pMutex; ) + MUTEX_LOGIC( pMutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR); ) + sqlite3_mutex_enter(pMutex); + rc = winFullPathnameNoMutex(pVfs, zRelative, nFull, zFull); + sqlite3_mutex_leave(pMutex); + return rc; +} + +#ifndef SQLITE_OMIT_LOAD_EXTENSION +/* +** Interfaces for opening a shared library, finding entry points +** within the shared library, and closing the shared library. +*/ +static void *winDlOpen(sqlite3_vfs *pVfs, const char *zFilename){ + HANDLE h; +#if defined(__CYGWIN__) + int nFull = pVfs->mxPathname+1; + char *zFull = sqlite3MallocZero( nFull ); + void *zConverted = 0; + if( zFull==0 ){ + OSTRACE(("DLOPEN name=%s, handle=%p\n", zFilename, (void*)0)); + return 0; + } + if( winFullPathname(pVfs, zFilename, nFull, zFull)!=SQLITE_OK ){ + sqlite3_free(zFull); + OSTRACE(("DLOPEN name=%s, handle=%p\n", zFilename, (void*)0)); + return 0; + } + zConverted = winConvertFromUtf8Filename(zFull); + sqlite3_free(zFull); +#else + void *zConverted = winConvertFromUtf8Filename(zFilename); + UNUSED_PARAMETER(pVfs); +#endif + if( zConverted==0 ){ + OSTRACE(("DLOPEN name=%s, handle=%p\n", zFilename, (void*)0)); + return 0; + } + if( osIsNT() ){ +#if SQLITE_OS_WINRT + h = osLoadPackagedLibrary((LPCWSTR)zConverted, 0); +#else + h = osLoadLibraryW((LPCWSTR)zConverted); +#endif + } +#ifdef SQLITE_WIN32_HAS_ANSI + else{ + h = osLoadLibraryA((char*)zConverted); + } +#endif + OSTRACE(("DLOPEN name=%s, handle=%p\n", zFilename, (void*)h)); + sqlite3_free(zConverted); + return (void*)h; +} +static void winDlError(sqlite3_vfs *pVfs, int nBuf, char *zBufOut){ + UNUSED_PARAMETER(pVfs); + winGetLastErrorMsg(osGetLastError(), nBuf, zBufOut); +} +static void (*winDlSym(sqlite3_vfs *pVfs,void *pH,const char *zSym))(void){ + FARPROC proc; + UNUSED_PARAMETER(pVfs); + proc = osGetProcAddressA((HANDLE)pH, zSym); + OSTRACE(("DLSYM handle=%p, symbol=%s, address=%p\n", + (void*)pH, zSym, (void*)proc)); + return (void(*)(void))proc; +} +static void winDlClose(sqlite3_vfs *pVfs, void *pHandle){ + UNUSED_PARAMETER(pVfs); + osFreeLibrary((HANDLE)pHandle); + OSTRACE(("DLCLOSE handle=%p\n", (void*)pHandle)); +} +#else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */ + #define winDlOpen 0 + #define winDlError 0 + #define winDlSym 0 + #define winDlClose 0 +#endif + +/* State information for the randomness gatherer. */ +typedef struct EntropyGatherer EntropyGatherer; +struct EntropyGatherer { + unsigned char *a; /* Gather entropy into this buffer */ + int na; /* Size of a[] in bytes */ + int i; /* XOR next input into a[i] */ + int nXor; /* Number of XOR operations done */ +}; + +#if !defined(SQLITE_TEST) && !defined(SQLITE_OMIT_RANDOMNESS) +/* Mix sz bytes of entropy into p. */ +static void xorMemory(EntropyGatherer *p, unsigned char *x, int sz){ + int j, k; + for(j=0, k=p->i; ja[k++] ^= x[j]; + if( k>=p->na ) k = 0; + } + p->i = k; + p->nXor += sz; +} +#endif /* !defined(SQLITE_TEST) && !defined(SQLITE_OMIT_RANDOMNESS) */ + +/* +** Write up to nBuf bytes of randomness into zBuf. +*/ +static int winRandomness(sqlite3_vfs *pVfs, int nBuf, char *zBuf){ +#if defined(SQLITE_TEST) || defined(SQLITE_OMIT_RANDOMNESS) + UNUSED_PARAMETER(pVfs); + memset(zBuf, 0, nBuf); + return nBuf; +#else + EntropyGatherer e; + UNUSED_PARAMETER(pVfs); + memset(zBuf, 0, nBuf); + e.a = (unsigned char*)zBuf; + e.na = nBuf; + e.nXor = 0; + e.i = 0; + { + SYSTEMTIME x; + osGetSystemTime(&x); + xorMemory(&e, (unsigned char*)&x, sizeof(SYSTEMTIME)); + } + { + DWORD pid = osGetCurrentProcessId(); + xorMemory(&e, (unsigned char*)&pid, sizeof(DWORD)); + } +#if SQLITE_OS_WINRT + { + ULONGLONG cnt = osGetTickCount64(); + xorMemory(&e, (unsigned char*)&cnt, sizeof(ULONGLONG)); + } +#else + { + DWORD cnt = osGetTickCount(); + xorMemory(&e, (unsigned char*)&cnt, sizeof(DWORD)); + } +#endif /* SQLITE_OS_WINRT */ + { + LARGE_INTEGER i; + osQueryPerformanceCounter(&i); + xorMemory(&e, (unsigned char*)&i, sizeof(LARGE_INTEGER)); + } +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && SQLITE_WIN32_USE_UUID + { + UUID id; + memset(&id, 0, sizeof(UUID)); + osUuidCreate(&id); + xorMemory(&e, (unsigned char*)&id, sizeof(UUID)); + memset(&id, 0, sizeof(UUID)); + osUuidCreateSequential(&id); + xorMemory(&e, (unsigned char*)&id, sizeof(UUID)); + } +#endif /* !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && SQLITE_WIN32_USE_UUID */ + return e.nXor>nBuf ? nBuf : e.nXor; +#endif /* defined(SQLITE_TEST) || defined(SQLITE_OMIT_RANDOMNESS) */ +} + + +/* +** Sleep for a little while. Return the amount of time slept. +*/ +static int winSleep(sqlite3_vfs *pVfs, int microsec){ + sqlite3_win32_sleep((microsec+999)/1000); + UNUSED_PARAMETER(pVfs); + return ((microsec+999)/1000)*1000; +} + +/* +** The following variable, if set to a non-zero value, is interpreted as +** the number of seconds since 1970 and is used to set the result of +** sqlite3OsCurrentTime() during testing. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_current_time = 0; /* Fake system time in seconds since 1970. */ +#endif + +/* +** Find the current time (in Universal Coordinated Time). Write into *piNow +** the current time and date as a Julian Day number times 86_400_000. In +** other words, write into *piNow the number of milliseconds since the Julian +** epoch of noon in Greenwich on November 24, 4714 B.C according to the +** proleptic Gregorian calendar. +** +** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date +** cannot be found. +*/ +static int winCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *piNow){ + /* FILETIME structure is a 64-bit value representing the number of + 100-nanosecond intervals since January 1, 1601 (= JD 2305813.5). + */ + FILETIME ft; + static const sqlite3_int64 winFiletimeEpoch = 23058135*(sqlite3_int64)8640000; +#ifdef SQLITE_TEST + static const sqlite3_int64 unixEpoch = 24405875*(sqlite3_int64)8640000; +#endif + /* 2^32 - to avoid use of LL and warnings in gcc */ + static const sqlite3_int64 max32BitValue = + (sqlite3_int64)2000000000 + (sqlite3_int64)2000000000 + + (sqlite3_int64)294967296; + +#if SQLITE_OS_WINCE + SYSTEMTIME time; + osGetSystemTime(&time); + /* if SystemTimeToFileTime() fails, it returns zero. */ + if (!osSystemTimeToFileTime(&time,&ft)){ + return SQLITE_ERROR; + } +#else + osGetSystemTimeAsFileTime( &ft ); +#endif + + *piNow = winFiletimeEpoch + + ((((sqlite3_int64)ft.dwHighDateTime)*max32BitValue) + + (sqlite3_int64)ft.dwLowDateTime)/(sqlite3_int64)10000; + +#ifdef SQLITE_TEST + if( sqlite3_current_time ){ + *piNow = 1000*(sqlite3_int64)sqlite3_current_time + unixEpoch; + } +#endif + UNUSED_PARAMETER(pVfs); + return SQLITE_OK; +} + +/* +** Find the current time (in Universal Coordinated Time). Write the +** current time and date as a Julian Day number into *prNow and +** return 0. Return 1 if the time and date cannot be found. +*/ +static int winCurrentTime(sqlite3_vfs *pVfs, double *prNow){ + int rc; + sqlite3_int64 i; + rc = winCurrentTimeInt64(pVfs, &i); + if( !rc ){ + *prNow = i/86400000.0; + } + return rc; +} + +/* +** The idea is that this function works like a combination of +** GetLastError() and FormatMessage() on Windows (or errno and +** strerror_r() on Unix). After an error is returned by an OS +** function, SQLite calls this function with zBuf pointing to +** a buffer of nBuf bytes. The OS layer should populate the +** buffer with a nul-terminated UTF-8 encoded error message +** describing the last IO error to have occurred within the calling +** thread. +** +** If the error message is too large for the supplied buffer, +** it should be truncated. The return value of xGetLastError +** is zero if the error message fits in the buffer, or non-zero +** otherwise (if the message was truncated). If non-zero is returned, +** then it is not necessary to include the nul-terminator character +** in the output buffer. +** +** Not supplying an error message will have no adverse effect +** on SQLite. It is fine to have an implementation that never +** returns an error message: +** +** int xGetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){ +** assert(zBuf[0]=='\0'); +** return 0; +** } +** +** However if an error message is supplied, it will be incorporated +** by sqlite into the error message available to the user using +** sqlite3_errmsg(), possibly making IO errors easier to debug. +*/ +static int winGetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){ + DWORD e = osGetLastError(); + UNUSED_PARAMETER(pVfs); + if( nBuf>0 ) winGetLastErrorMsg(e, nBuf, zBuf); + return e; +} + +/* +** Initialize and deinitialize the operating system interface. +*/ +SQLITE_API int sqlite3_os_init(void){ + static sqlite3_vfs winVfs = { + 3, /* iVersion */ + sizeof(winFile), /* szOsFile */ + SQLITE_WIN32_MAX_PATH_BYTES, /* mxPathname */ + 0, /* pNext */ + "win32", /* zName */ + &winAppData, /* pAppData */ + winOpen, /* xOpen */ + winDelete, /* xDelete */ + winAccess, /* xAccess */ + winFullPathname, /* xFullPathname */ + winDlOpen, /* xDlOpen */ + winDlError, /* xDlError */ + winDlSym, /* xDlSym */ + winDlClose, /* xDlClose */ + winRandomness, /* xRandomness */ + winSleep, /* xSleep */ + winCurrentTime, /* xCurrentTime */ + winGetLastError, /* xGetLastError */ + winCurrentTimeInt64, /* xCurrentTimeInt64 */ + winSetSystemCall, /* xSetSystemCall */ + winGetSystemCall, /* xGetSystemCall */ + winNextSystemCall, /* xNextSystemCall */ + }; +#if defined(SQLITE_WIN32_HAS_WIDE) + static sqlite3_vfs winLongPathVfs = { + 3, /* iVersion */ + sizeof(winFile), /* szOsFile */ + SQLITE_WINNT_MAX_PATH_BYTES, /* mxPathname */ + 0, /* pNext */ + "win32-longpath", /* zName */ + &winAppData, /* pAppData */ + winOpen, /* xOpen */ + winDelete, /* xDelete */ + winAccess, /* xAccess */ + winFullPathname, /* xFullPathname */ + winDlOpen, /* xDlOpen */ + winDlError, /* xDlError */ + winDlSym, /* xDlSym */ + winDlClose, /* xDlClose */ + winRandomness, /* xRandomness */ + winSleep, /* xSleep */ + winCurrentTime, /* xCurrentTime */ + winGetLastError, /* xGetLastError */ + winCurrentTimeInt64, /* xCurrentTimeInt64 */ + winSetSystemCall, /* xSetSystemCall */ + winGetSystemCall, /* xGetSystemCall */ + winNextSystemCall, /* xNextSystemCall */ + }; +#endif + static sqlite3_vfs winNolockVfs = { + 3, /* iVersion */ + sizeof(winFile), /* szOsFile */ + SQLITE_WIN32_MAX_PATH_BYTES, /* mxPathname */ + 0, /* pNext */ + "win32-none", /* zName */ + &winNolockAppData, /* pAppData */ + winOpen, /* xOpen */ + winDelete, /* xDelete */ + winAccess, /* xAccess */ + winFullPathname, /* xFullPathname */ + winDlOpen, /* xDlOpen */ + winDlError, /* xDlError */ + winDlSym, /* xDlSym */ + winDlClose, /* xDlClose */ + winRandomness, /* xRandomness */ + winSleep, /* xSleep */ + winCurrentTime, /* xCurrentTime */ + winGetLastError, /* xGetLastError */ + winCurrentTimeInt64, /* xCurrentTimeInt64 */ + winSetSystemCall, /* xSetSystemCall */ + winGetSystemCall, /* xGetSystemCall */ + winNextSystemCall, /* xNextSystemCall */ + }; +#if defined(SQLITE_WIN32_HAS_WIDE) + static sqlite3_vfs winLongPathNolockVfs = { + 3, /* iVersion */ + sizeof(winFile), /* szOsFile */ + SQLITE_WINNT_MAX_PATH_BYTES, /* mxPathname */ + 0, /* pNext */ + "win32-longpath-none", /* zName */ + &winNolockAppData, /* pAppData */ + winOpen, /* xOpen */ + winDelete, /* xDelete */ + winAccess, /* xAccess */ + winFullPathname, /* xFullPathname */ + winDlOpen, /* xDlOpen */ + winDlError, /* xDlError */ + winDlSym, /* xDlSym */ + winDlClose, /* xDlClose */ + winRandomness, /* xRandomness */ + winSleep, /* xSleep */ + winCurrentTime, /* xCurrentTime */ + winGetLastError, /* xGetLastError */ + winCurrentTimeInt64, /* xCurrentTimeInt64 */ + winSetSystemCall, /* xSetSystemCall */ + winGetSystemCall, /* xGetSystemCall */ + winNextSystemCall, /* xNextSystemCall */ + }; +#endif + + /* Double-check that the aSyscall[] array has been constructed + ** correctly. See ticket [bb3a86e890c8e96ab] */ + assert( ArraySize(aSyscall)==80 ); + + /* get memory map allocation granularity */ + memset(&winSysInfo, 0, sizeof(SYSTEM_INFO)); +#if SQLITE_OS_WINRT + osGetNativeSystemInfo(&winSysInfo); +#else + osGetSystemInfo(&winSysInfo); +#endif + assert( winSysInfo.dwAllocationGranularity>0 ); + assert( winSysInfo.dwPageSize>0 ); + + sqlite3_vfs_register(&winVfs, 1); + +#if defined(SQLITE_WIN32_HAS_WIDE) + sqlite3_vfs_register(&winLongPathVfs, 0); +#endif + + sqlite3_vfs_register(&winNolockVfs, 0); + +#if defined(SQLITE_WIN32_HAS_WIDE) + sqlite3_vfs_register(&winLongPathNolockVfs, 0); +#endif + +#ifndef SQLITE_OMIT_WAL + winBigLock = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1); +#endif + + return SQLITE_OK; +} + +SQLITE_API int sqlite3_os_end(void){ +#if SQLITE_OS_WINRT + if( sleepObj!=NULL ){ + osCloseHandle(sleepObj); + sleepObj = NULL; + } +#endif + +#ifndef SQLITE_OMIT_WAL + winBigLock = 0; +#endif + + return SQLITE_OK; +} + +#endif /* SQLITE_OS_WIN */ + +/************** End of os_win.c **********************************************/ +/************** Begin file memdb.c *******************************************/ +/* +** 2016-09-07 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file implements an in-memory VFS. A database is held as a contiguous +** block of memory. +** +** This file also implements interface sqlite3_serialize() and +** sqlite3_deserialize(). +*/ +/* #include "sqliteInt.h" */ +#ifndef SQLITE_OMIT_DESERIALIZE + +/* +** Forward declaration of objects used by this utility +*/ +typedef struct sqlite3_vfs MemVfs; +typedef struct MemFile MemFile; +typedef struct MemStore MemStore; + +/* Access to a lower-level VFS that (might) implement dynamic loading, +** access to randomness, etc. +*/ +#define ORIGVFS(p) ((sqlite3_vfs*)((p)->pAppData)) + +/* Storage for a memdb file. +** +** An memdb object can be shared or separate. Shared memdb objects can be +** used by more than one database connection. Mutexes are used by shared +** memdb objects to coordinate access. Separate memdb objects are only +** connected to a single database connection and do not require additional +** mutexes. +** +** Shared memdb objects have .zFName!=0 and .pMutex!=0. They are created +** using "file:/name?vfs=memdb". The first character of the name must be +** "/" or else the object will be a separate memdb object. All shared +** memdb objects are stored in memdb_g.apMemStore[] in an arbitrary order. +** +** Separate memdb objects are created using a name that does not begin +** with "/" or using sqlite3_deserialize(). +** +** Access rules for shared MemStore objects: +** +** * .zFName is initialized when the object is created and afterwards +** is unchanged until the object is destroyed. So it can be accessed +** at any time as long as we know the object is not being destroyed, +** which means while either the SQLITE_MUTEX_STATIC_VFS1 or +** .pMutex is held or the object is not part of memdb_g.apMemStore[]. +** +** * Can .pMutex can only be changed while holding the +** SQLITE_MUTEX_STATIC_VFS1 mutex or while the object is not part +** of memdb_g.apMemStore[]. +** +** * Other fields can only be changed while holding the .pMutex mutex +** or when the .nRef is less than zero and the object is not part of +** memdb_g.apMemStore[]. +** +** * The .aData pointer has the added requirement that it can can only +** be changed (for resizing) when nMmap is zero. +** +*/ +struct MemStore { + sqlite3_int64 sz; /* Size of the file */ + sqlite3_int64 szAlloc; /* Space allocated to aData */ + sqlite3_int64 szMax; /* Maximum allowed size of the file */ + unsigned char *aData; /* content of the file */ + sqlite3_mutex *pMutex; /* Used by shared stores only */ + int nMmap; /* Number of memory mapped pages */ + unsigned mFlags; /* Flags */ + int nRdLock; /* Number of readers */ + int nWrLock; /* Number of writers. (Always 0 or 1) */ + int nRef; /* Number of users of this MemStore */ + char *zFName; /* The filename for shared stores */ +}; + +/* An open file */ +struct MemFile { + sqlite3_file base; /* IO methods */ + MemStore *pStore; /* The storage */ + int eLock; /* Most recent lock against this file */ +}; + +/* +** File-scope variables for holding the memdb files that are accessible +** to multiple database connections in separate threads. +** +** Must hold SQLITE_MUTEX_STATIC_VFS1 to access any part of this object. +*/ +static struct MemFS { + int nMemStore; /* Number of shared MemStore objects */ + MemStore **apMemStore; /* Array of all shared MemStore objects */ +} memdb_g; + +/* +** Methods for MemFile +*/ +static int memdbClose(sqlite3_file*); +static int memdbRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); +static int memdbWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst); +static int memdbTruncate(sqlite3_file*, sqlite3_int64 size); +static int memdbSync(sqlite3_file*, int flags); +static int memdbFileSize(sqlite3_file*, sqlite3_int64 *pSize); +static int memdbLock(sqlite3_file*, int); +static int memdbUnlock(sqlite3_file*, int); +/* static int memdbCheckReservedLock(sqlite3_file*, int *pResOut);// not used */ +static int memdbFileControl(sqlite3_file*, int op, void *pArg); +/* static int memdbSectorSize(sqlite3_file*); // not used */ +static int memdbDeviceCharacteristics(sqlite3_file*); +static int memdbFetch(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp); +static int memdbUnfetch(sqlite3_file*, sqlite3_int64 iOfst, void *p); + +/* +** Methods for MemVfs +*/ +static int memdbOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *); +/* static int memdbDelete(sqlite3_vfs*, const char *zName, int syncDir); */ +static int memdbAccess(sqlite3_vfs*, const char *zName, int flags, int *); +static int memdbFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut); +static void *memdbDlOpen(sqlite3_vfs*, const char *zFilename); +static void memdbDlError(sqlite3_vfs*, int nByte, char *zErrMsg); +static void (*memdbDlSym(sqlite3_vfs *pVfs, void *p, const char*zSym))(void); +static void memdbDlClose(sqlite3_vfs*, void*); +static int memdbRandomness(sqlite3_vfs*, int nByte, char *zOut); +static int memdbSleep(sqlite3_vfs*, int microseconds); +/* static int memdbCurrentTime(sqlite3_vfs*, double*); */ +static int memdbGetLastError(sqlite3_vfs*, int, char *); +static int memdbCurrentTimeInt64(sqlite3_vfs*, sqlite3_int64*); + +static sqlite3_vfs memdb_vfs = { + 2, /* iVersion */ + 0, /* szOsFile (set when registered) */ + 1024, /* mxPathname */ + 0, /* pNext */ + "memdb", /* zName */ + 0, /* pAppData (set when registered) */ + memdbOpen, /* xOpen */ + 0, /* memdbDelete, */ /* xDelete */ + memdbAccess, /* xAccess */ + memdbFullPathname, /* xFullPathname */ + memdbDlOpen, /* xDlOpen */ + memdbDlError, /* xDlError */ + memdbDlSym, /* xDlSym */ + memdbDlClose, /* xDlClose */ + memdbRandomness, /* xRandomness */ + memdbSleep, /* xSleep */ + 0, /* memdbCurrentTime, */ /* xCurrentTime */ + memdbGetLastError, /* xGetLastError */ + memdbCurrentTimeInt64, /* xCurrentTimeInt64 */ + 0, /* xSetSystemCall */ + 0, /* xGetSystemCall */ + 0, /* xNextSystemCall */ +}; + +static const sqlite3_io_methods memdb_io_methods = { + 3, /* iVersion */ + memdbClose, /* xClose */ + memdbRead, /* xRead */ + memdbWrite, /* xWrite */ + memdbTruncate, /* xTruncate */ + memdbSync, /* xSync */ + memdbFileSize, /* xFileSize */ + memdbLock, /* xLock */ + memdbUnlock, /* xUnlock */ + 0, /* memdbCheckReservedLock, */ /* xCheckReservedLock */ + memdbFileControl, /* xFileControl */ + 0, /* memdbSectorSize,*/ /* xSectorSize */ + memdbDeviceCharacteristics, /* xDeviceCharacteristics */ + 0, /* xShmMap */ + 0, /* xShmLock */ + 0, /* xShmBarrier */ + 0, /* xShmUnmap */ + memdbFetch, /* xFetch */ + memdbUnfetch /* xUnfetch */ +}; + +/* +** Enter/leave the mutex on a MemStore +*/ +#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE==0 +static void memdbEnter(MemStore *p){ + UNUSED_PARAMETER(p); +} +static void memdbLeave(MemStore *p){ + UNUSED_PARAMETER(p); +} +#else +static void memdbEnter(MemStore *p){ + sqlite3_mutex_enter(p->pMutex); +} +static void memdbLeave(MemStore *p){ + sqlite3_mutex_leave(p->pMutex); +} +#endif + + + +/* +** Close an memdb-file. +** Free the underlying MemStore object when its refcount drops to zero +** or less. +*/ +static int memdbClose(sqlite3_file *pFile){ + MemStore *p = ((MemFile*)pFile)->pStore; + if( p->zFName ){ + int i; +#ifndef SQLITE_MUTEX_OMIT + sqlite3_mutex *pVfsMutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1); +#endif + sqlite3_mutex_enter(pVfsMutex); + for(i=0; ALWAYS(inRef==1 ){ + memdb_g.apMemStore[i] = memdb_g.apMemStore[--memdb_g.nMemStore]; + if( memdb_g.nMemStore==0 ){ + sqlite3_free(memdb_g.apMemStore); + memdb_g.apMemStore = 0; + } + } + break; + } + } + sqlite3_mutex_leave(pVfsMutex); + }else{ + memdbEnter(p); + } + p->nRef--; + if( p->nRef<=0 ){ + if( p->mFlags & SQLITE_DESERIALIZE_FREEONCLOSE ){ + sqlite3_free(p->aData); + } + memdbLeave(p); + sqlite3_mutex_free(p->pMutex); + sqlite3_free(p); + }else{ + memdbLeave(p); + } + return SQLITE_OK; +} + +/* +** Read data from an memdb-file. +*/ +static int memdbRead( + sqlite3_file *pFile, + void *zBuf, + int iAmt, + sqlite_int64 iOfst +){ + MemStore *p = ((MemFile*)pFile)->pStore; + memdbEnter(p); + if( iOfst+iAmt>p->sz ){ + memset(zBuf, 0, iAmt); + if( iOfstsz ) memcpy(zBuf, p->aData+iOfst, p->sz - iOfst); + memdbLeave(p); + return SQLITE_IOERR_SHORT_READ; + } + memcpy(zBuf, p->aData+iOfst, iAmt); + memdbLeave(p); + return SQLITE_OK; +} + +/* +** Try to enlarge the memory allocation to hold at least sz bytes +*/ +static int memdbEnlarge(MemStore *p, sqlite3_int64 newSz){ + unsigned char *pNew; + if( (p->mFlags & SQLITE_DESERIALIZE_RESIZEABLE)==0 || NEVER(p->nMmap>0) ){ + return SQLITE_FULL; + } + if( newSz>p->szMax ){ + return SQLITE_FULL; + } + newSz *= 2; + if( newSz>p->szMax ) newSz = p->szMax; + pNew = sqlite3Realloc(p->aData, newSz); + if( pNew==0 ) return SQLITE_IOERR_NOMEM; + p->aData = pNew; + p->szAlloc = newSz; + return SQLITE_OK; +} + +/* +** Write data to an memdb-file. +*/ +static int memdbWrite( + sqlite3_file *pFile, + const void *z, + int iAmt, + sqlite_int64 iOfst +){ + MemStore *p = ((MemFile*)pFile)->pStore; + memdbEnter(p); + if( NEVER(p->mFlags & SQLITE_DESERIALIZE_READONLY) ){ + /* Can't happen: memdbLock() will return SQLITE_READONLY before + ** reaching this point */ + memdbLeave(p); + return SQLITE_IOERR_WRITE; + } + if( iOfst+iAmt>p->sz ){ + int rc; + if( iOfst+iAmt>p->szAlloc + && (rc = memdbEnlarge(p, iOfst+iAmt))!=SQLITE_OK + ){ + memdbLeave(p); + return rc; + } + if( iOfst>p->sz ) memset(p->aData+p->sz, 0, iOfst-p->sz); + p->sz = iOfst+iAmt; + } + memcpy(p->aData+iOfst, z, iAmt); + memdbLeave(p); + return SQLITE_OK; +} + +/* +** Truncate an memdb-file. +** +** In rollback mode (which is always the case for memdb, as it does not +** support WAL mode) the truncate() method is only used to reduce +** the size of a file, never to increase the size. +*/ +static int memdbTruncate(sqlite3_file *pFile, sqlite_int64 size){ + MemStore *p = ((MemFile*)pFile)->pStore; + int rc = SQLITE_OK; + memdbEnter(p); + if( size>p->sz ){ + /* This can only happen with a corrupt wal mode db */ + rc = SQLITE_CORRUPT; + }else{ + p->sz = size; + } + memdbLeave(p); + return rc; +} + +/* +** Sync an memdb-file. +*/ +static int memdbSync(sqlite3_file *pFile, int flags){ + UNUSED_PARAMETER(pFile); + UNUSED_PARAMETER(flags); + return SQLITE_OK; +} + +/* +** Return the current file-size of an memdb-file. +*/ +static int memdbFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){ + MemStore *p = ((MemFile*)pFile)->pStore; + memdbEnter(p); + *pSize = p->sz; + memdbLeave(p); + return SQLITE_OK; +} + +/* +** Lock an memdb-file. +*/ +static int memdbLock(sqlite3_file *pFile, int eLock){ + MemFile *pThis = (MemFile*)pFile; + MemStore *p = pThis->pStore; + int rc = SQLITE_OK; + if( eLock<=pThis->eLock ) return SQLITE_OK; + memdbEnter(p); + + assert( p->nWrLock==0 || p->nWrLock==1 ); + assert( pThis->eLock<=SQLITE_LOCK_SHARED || p->nWrLock==1 ); + assert( pThis->eLock==SQLITE_LOCK_NONE || p->nRdLock>=1 ); + + if( eLock>SQLITE_LOCK_SHARED && (p->mFlags & SQLITE_DESERIALIZE_READONLY) ){ + rc = SQLITE_READONLY; + }else{ + switch( eLock ){ + case SQLITE_LOCK_SHARED: { + assert( pThis->eLock==SQLITE_LOCK_NONE ); + if( p->nWrLock>0 ){ + rc = SQLITE_BUSY; + }else{ + p->nRdLock++; + } + break; + }; + + case SQLITE_LOCK_RESERVED: + case SQLITE_LOCK_PENDING: { + assert( pThis->eLock>=SQLITE_LOCK_SHARED ); + if( ALWAYS(pThis->eLock==SQLITE_LOCK_SHARED) ){ + if( p->nWrLock>0 ){ + rc = SQLITE_BUSY; + }else{ + p->nWrLock = 1; + } + } + break; + } + + default: { + assert( eLock==SQLITE_LOCK_EXCLUSIVE ); + assert( pThis->eLock>=SQLITE_LOCK_SHARED ); + if( p->nRdLock>1 ){ + rc = SQLITE_BUSY; + }else if( pThis->eLock==SQLITE_LOCK_SHARED ){ + p->nWrLock = 1; + } + break; + } + } + } + if( rc==SQLITE_OK ) pThis->eLock = eLock; + memdbLeave(p); + return rc; +} + +/* +** Unlock an memdb-file. +*/ +static int memdbUnlock(sqlite3_file *pFile, int eLock){ + MemFile *pThis = (MemFile*)pFile; + MemStore *p = pThis->pStore; + if( eLock>=pThis->eLock ) return SQLITE_OK; + memdbEnter(p); + + assert( eLock==SQLITE_LOCK_SHARED || eLock==SQLITE_LOCK_NONE ); + if( eLock==SQLITE_LOCK_SHARED ){ + if( ALWAYS(pThis->eLock>SQLITE_LOCK_SHARED) ){ + p->nWrLock--; + } + }else{ + if( pThis->eLock>SQLITE_LOCK_SHARED ){ + p->nWrLock--; + } + p->nRdLock--; + } + + pThis->eLock = eLock; + memdbLeave(p); + return SQLITE_OK; +} + +#if 0 +/* +** This interface is only used for crash recovery, which does not +** occur on an in-memory database. +*/ +static int memdbCheckReservedLock(sqlite3_file *pFile, int *pResOut){ + *pResOut = 0; + return SQLITE_OK; +} +#endif + + +/* +** File control method. For custom operations on an memdb-file. +*/ +static int memdbFileControl(sqlite3_file *pFile, int op, void *pArg){ + MemStore *p = ((MemFile*)pFile)->pStore; + int rc = SQLITE_NOTFOUND; + memdbEnter(p); + if( op==SQLITE_FCNTL_VFSNAME ){ + *(char**)pArg = sqlite3_mprintf("memdb(%p,%lld)", p->aData, p->sz); + rc = SQLITE_OK; + } + if( op==SQLITE_FCNTL_SIZE_LIMIT ){ + sqlite3_int64 iLimit = *(sqlite3_int64*)pArg; + if( iLimitsz ){ + if( iLimit<0 ){ + iLimit = p->szMax; + }else{ + iLimit = p->sz; + } + } + p->szMax = iLimit; + *(sqlite3_int64*)pArg = iLimit; + rc = SQLITE_OK; + } + memdbLeave(p); + return rc; +} + +#if 0 /* Not used because of SQLITE_IOCAP_POWERSAFE_OVERWRITE */ +/* +** Return the sector-size in bytes for an memdb-file. +*/ +static int memdbSectorSize(sqlite3_file *pFile){ + return 1024; +} +#endif + +/* +** Return the device characteristic flags supported by an memdb-file. +*/ +static int memdbDeviceCharacteristics(sqlite3_file *pFile){ + UNUSED_PARAMETER(pFile); + return SQLITE_IOCAP_ATOMIC | + SQLITE_IOCAP_POWERSAFE_OVERWRITE | + SQLITE_IOCAP_SAFE_APPEND | + SQLITE_IOCAP_SEQUENTIAL; +} + +/* Fetch a page of a memory-mapped file */ +static int memdbFetch( + sqlite3_file *pFile, + sqlite3_int64 iOfst, + int iAmt, + void **pp +){ + MemStore *p = ((MemFile*)pFile)->pStore; + memdbEnter(p); + if( iOfst+iAmt>p->sz || (p->mFlags & SQLITE_DESERIALIZE_RESIZEABLE)!=0 ){ + *pp = 0; + }else{ + p->nMmap++; + *pp = (void*)(p->aData + iOfst); + } + memdbLeave(p); + return SQLITE_OK; +} + +/* Release a memory-mapped page */ +static int memdbUnfetch(sqlite3_file *pFile, sqlite3_int64 iOfst, void *pPage){ + MemStore *p = ((MemFile*)pFile)->pStore; + UNUSED_PARAMETER(iOfst); + UNUSED_PARAMETER(pPage); + memdbEnter(p); + p->nMmap--; + memdbLeave(p); + return SQLITE_OK; +} + +/* +** Open an mem file handle. +*/ +static int memdbOpen( + sqlite3_vfs *pVfs, + const char *zName, + sqlite3_file *pFd, + int flags, + int *pOutFlags +){ + MemFile *pFile = (MemFile*)pFd; + MemStore *p = 0; + int szName; + UNUSED_PARAMETER(pVfs); + + memset(pFile, 0, sizeof(*pFile)); + szName = sqlite3Strlen30(zName); + if( szName>1 && (zName[0]=='/' || zName[0]=='\\') ){ + int i; +#ifndef SQLITE_MUTEX_OMIT + sqlite3_mutex *pVfsMutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1); +#endif + sqlite3_mutex_enter(pVfsMutex); + for(i=0; izFName,zName)==0 ){ + p = memdb_g.apMemStore[i]; + break; + } + } + if( p==0 ){ + MemStore **apNew; + p = sqlite3Malloc( sizeof(*p) + szName + 3 ); + if( p==0 ){ + sqlite3_mutex_leave(pVfsMutex); + return SQLITE_NOMEM; + } + apNew = sqlite3Realloc(memdb_g.apMemStore, + sizeof(apNew[0])*(memdb_g.nMemStore+1) ); + if( apNew==0 ){ + sqlite3_free(p); + sqlite3_mutex_leave(pVfsMutex); + return SQLITE_NOMEM; + } + apNew[memdb_g.nMemStore++] = p; + memdb_g.apMemStore = apNew; + memset(p, 0, sizeof(*p)); + p->mFlags = SQLITE_DESERIALIZE_RESIZEABLE|SQLITE_DESERIALIZE_FREEONCLOSE; + p->szMax = sqlite3GlobalConfig.mxMemdbSize; + p->zFName = (char*)&p[1]; + memcpy(p->zFName, zName, szName+1); + p->pMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST); + if( p->pMutex==0 ){ + memdb_g.nMemStore--; + sqlite3_free(p); + sqlite3_mutex_leave(pVfsMutex); + return SQLITE_NOMEM; + } + p->nRef = 1; + memdbEnter(p); + }else{ + memdbEnter(p); + p->nRef++; + } + sqlite3_mutex_leave(pVfsMutex); + }else{ + p = sqlite3Malloc( sizeof(*p) ); + if( p==0 ){ + return SQLITE_NOMEM; + } + memset(p, 0, sizeof(*p)); + p->mFlags = SQLITE_DESERIALIZE_RESIZEABLE | SQLITE_DESERIALIZE_FREEONCLOSE; + p->szMax = sqlite3GlobalConfig.mxMemdbSize; + } + pFile->pStore = p; + if( pOutFlags!=0 ){ + *pOutFlags = flags | SQLITE_OPEN_MEMORY; + } + pFd->pMethods = &memdb_io_methods; + memdbLeave(p); + return SQLITE_OK; +} + +#if 0 /* Only used to delete rollback journals, super-journals, and WAL + ** files, none of which exist in memdb. So this routine is never used */ +/* +** Delete the file located at zPath. If the dirSync argument is true, +** ensure the file-system modifications are synced to disk before +** returning. +*/ +static int memdbDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){ + return SQLITE_IOERR_DELETE; +} +#endif + +/* +** Test for access permissions. Return true if the requested permission +** is available, or false otherwise. +** +** With memdb, no files ever exist on disk. So always return false. +*/ +static int memdbAccess( + sqlite3_vfs *pVfs, + const char *zPath, + int flags, + int *pResOut +){ + UNUSED_PARAMETER(pVfs); + UNUSED_PARAMETER(zPath); + UNUSED_PARAMETER(flags); + *pResOut = 0; + return SQLITE_OK; +} + +/* +** Populate buffer zOut with the full canonical pathname corresponding +** to the pathname in zPath. zOut is guaranteed to point to a buffer +** of at least (INST_MAX_PATHNAME+1) bytes. +*/ +static int memdbFullPathname( + sqlite3_vfs *pVfs, + const char *zPath, + int nOut, + char *zOut +){ + UNUSED_PARAMETER(pVfs); + sqlite3_snprintf(nOut, zOut, "%s", zPath); + return SQLITE_OK; +} + +/* +** Open the dynamic library located at zPath and return a handle. +*/ +static void *memdbDlOpen(sqlite3_vfs *pVfs, const char *zPath){ + return ORIGVFS(pVfs)->xDlOpen(ORIGVFS(pVfs), zPath); +} + +/* +** Populate the buffer zErrMsg (size nByte bytes) with a human readable +** utf-8 string describing the most recent error encountered associated +** with dynamic libraries. +*/ +static void memdbDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){ + ORIGVFS(pVfs)->xDlError(ORIGVFS(pVfs), nByte, zErrMsg); +} + +/* +** Return a pointer to the symbol zSymbol in the dynamic library pHandle. +*/ +static void (*memdbDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){ + return ORIGVFS(pVfs)->xDlSym(ORIGVFS(pVfs), p, zSym); +} + +/* +** Close the dynamic library handle pHandle. +*/ +static void memdbDlClose(sqlite3_vfs *pVfs, void *pHandle){ + ORIGVFS(pVfs)->xDlClose(ORIGVFS(pVfs), pHandle); +} + +/* +** Populate the buffer pointed to by zBufOut with nByte bytes of +** random data. +*/ +static int memdbRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ + return ORIGVFS(pVfs)->xRandomness(ORIGVFS(pVfs), nByte, zBufOut); +} + +/* +** Sleep for nMicro microseconds. Return the number of microseconds +** actually slept. +*/ +static int memdbSleep(sqlite3_vfs *pVfs, int nMicro){ + return ORIGVFS(pVfs)->xSleep(ORIGVFS(pVfs), nMicro); +} + +#if 0 /* Never used. Modern cores only call xCurrentTimeInt64() */ +/* +** Return the current time as a Julian Day number in *pTimeOut. +*/ +static int memdbCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){ + return ORIGVFS(pVfs)->xCurrentTime(ORIGVFS(pVfs), pTimeOut); +} +#endif + +static int memdbGetLastError(sqlite3_vfs *pVfs, int a, char *b){ + return ORIGVFS(pVfs)->xGetLastError(ORIGVFS(pVfs), a, b); +} +static int memdbCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *p){ + return ORIGVFS(pVfs)->xCurrentTimeInt64(ORIGVFS(pVfs), p); +} + +/* +** Translate a database connection pointer and schema name into a +** MemFile pointer. +*/ +static MemFile *memdbFromDbSchema(sqlite3 *db, const char *zSchema){ + MemFile *p = 0; + MemStore *pStore; + int rc = sqlite3_file_control(db, zSchema, SQLITE_FCNTL_FILE_POINTER, &p); + if( rc ) return 0; + if( p->base.pMethods!=&memdb_io_methods ) return 0; + pStore = p->pStore; + memdbEnter(pStore); + if( pStore->zFName!=0 ) p = 0; + memdbLeave(pStore); + return p; +} + +/* +** Return the serialization of a database +*/ +SQLITE_API unsigned char *sqlite3_serialize( + sqlite3 *db, /* The database connection */ + const char *zSchema, /* Which database within the connection */ + sqlite3_int64 *piSize, /* Write size here, if not NULL */ + unsigned int mFlags /* Maybe SQLITE_SERIALIZE_NOCOPY */ +){ + MemFile *p; + int iDb; + Btree *pBt; + sqlite3_int64 sz; + int szPage = 0; + sqlite3_stmt *pStmt = 0; + unsigned char *pOut; + char *zSql; + int rc; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + + if( zSchema==0 ) zSchema = db->aDb[0].zDbSName; + p = memdbFromDbSchema(db, zSchema); + iDb = sqlite3FindDbName(db, zSchema); + if( piSize ) *piSize = -1; + if( iDb<0 ) return 0; + if( p ){ + MemStore *pStore = p->pStore; + assert( pStore->pMutex==0 ); + if( piSize ) *piSize = pStore->sz; + if( mFlags & SQLITE_SERIALIZE_NOCOPY ){ + pOut = pStore->aData; + }else{ + pOut = sqlite3_malloc64( pStore->sz ); + if( pOut ) memcpy(pOut, pStore->aData, pStore->sz); + } + return pOut; + } + pBt = db->aDb[iDb].pBt; + if( pBt==0 ) return 0; + szPage = sqlite3BtreeGetPageSize(pBt); + zSql = sqlite3_mprintf("PRAGMA \"%w\".page_count", zSchema); + rc = zSql ? sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0) : SQLITE_NOMEM; + sqlite3_free(zSql); + if( rc ) return 0; + rc = sqlite3_step(pStmt); + if( rc!=SQLITE_ROW ){ + pOut = 0; + }else{ + sz = sqlite3_column_int64(pStmt, 0)*szPage; + if( piSize ) *piSize = sz; + if( mFlags & SQLITE_SERIALIZE_NOCOPY ){ + pOut = 0; + }else{ + pOut = sqlite3_malloc64( sz ); + if( pOut ){ + int nPage = sqlite3_column_int(pStmt, 0); + Pager *pPager = sqlite3BtreePager(pBt); + int pgno; + for(pgno=1; pgno<=nPage; pgno++){ + DbPage *pPage = 0; + unsigned char *pTo = pOut + szPage*(sqlite3_int64)(pgno-1); + rc = sqlite3PagerGet(pPager, pgno, (DbPage**)&pPage, 0); + if( rc==SQLITE_OK ){ + memcpy(pTo, sqlite3PagerGetData(pPage), szPage); + }else{ + memset(pTo, 0, szPage); + } + sqlite3PagerUnref(pPage); + } + } + } + } + sqlite3_finalize(pStmt); + return pOut; +} + +/* Convert zSchema to a MemDB and initialize its content. +*/ +SQLITE_API int sqlite3_deserialize( + sqlite3 *db, /* The database connection */ + const char *zSchema, /* Which DB to reopen with the deserialization */ + unsigned char *pData, /* The serialized database content */ + sqlite3_int64 szDb, /* Number bytes in the deserialization */ + sqlite3_int64 szBuf, /* Total size of buffer pData[] */ + unsigned mFlags /* Zero or more SQLITE_DESERIALIZE_* flags */ +){ + MemFile *p; + char *zSql; + sqlite3_stmt *pStmt = 0; + int rc; + int iDb; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + return SQLITE_MISUSE_BKPT; + } + if( szDb<0 ) return SQLITE_MISUSE_BKPT; + if( szBuf<0 ) return SQLITE_MISUSE_BKPT; +#endif + + sqlite3_mutex_enter(db->mutex); + if( zSchema==0 ) zSchema = db->aDb[0].zDbSName; + iDb = sqlite3FindDbName(db, zSchema); + testcase( iDb==1 ); + if( iDb<2 && iDb!=0 ){ + rc = SQLITE_ERROR; + goto end_deserialize; + } + zSql = sqlite3_mprintf("ATTACH x AS %Q", zSchema); + if( zSql==0 ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); + sqlite3_free(zSql); + } + if( rc ) goto end_deserialize; + db->init.iDb = (u8)iDb; + db->init.reopenMemdb = 1; + rc = sqlite3_step(pStmt); + db->init.reopenMemdb = 0; + if( rc!=SQLITE_DONE ){ + rc = SQLITE_ERROR; + goto end_deserialize; + } + p = memdbFromDbSchema(db, zSchema); + if( p==0 ){ + rc = SQLITE_ERROR; + }else{ + MemStore *pStore = p->pStore; + pStore->aData = pData; + pData = 0; + pStore->sz = szDb; + pStore->szAlloc = szBuf; + pStore->szMax = szBuf; + if( pStore->szMaxszMax = sqlite3GlobalConfig.mxMemdbSize; + } + pStore->mFlags = mFlags; + rc = SQLITE_OK; + } + +end_deserialize: + sqlite3_finalize(pStmt); + if( pData && (mFlags & SQLITE_DESERIALIZE_FREEONCLOSE)!=0 ){ + sqlite3_free(pData); + } + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Return true if the VFS is the memvfs. +*/ +SQLITE_PRIVATE int sqlite3IsMemdb(const sqlite3_vfs *pVfs){ + return pVfs==&memdb_vfs; +} + +/* +** This routine is called when the extension is loaded. +** Register the new VFS. +*/ +SQLITE_PRIVATE int sqlite3MemdbInit(void){ + sqlite3_vfs *pLower = sqlite3_vfs_find(0); + unsigned int sz; + if( NEVER(pLower==0) ) return SQLITE_ERROR; + sz = pLower->szOsFile; + memdb_vfs.pAppData = pLower; + /* The following conditional can only be true when compiled for + ** Windows x86 and SQLITE_MAX_MMAP_SIZE=0. We always leave + ** it in, to be safe, but it is marked as NO_TEST since there + ** is no way to reach it under most builds. */ + if( szBITVEC_NBIT and iDivisor==0 then Bitvec.u.aHash[] is +** a hash table that will hold up to BITVEC_MXHASH distinct values. +** +** Otherwise, the value i is redirected into one of BITVEC_NPTR +** sub-bitmaps pointed to by Bitvec.u.apSub[]. Each subbitmap +** handles up to iDivisor separate values of i. apSub[0] holds +** values between 1 and iDivisor. apSub[1] holds values between +** iDivisor+1 and 2*iDivisor. apSub[N] holds values between +** N*iDivisor+1 and (N+1)*iDivisor. Each subbitmap is normalized +** to hold deal with values between 1 and iDivisor. +*/ +struct Bitvec { + u32 iSize; /* Maximum bit index. Max iSize is 4,294,967,296. */ + u32 nSet; /* Number of bits that are set - only valid for aHash + ** element. Max is BITVEC_NINT. For BITVEC_SZ of 512, + ** this would be 125. */ + u32 iDivisor; /* Number of bits handled by each apSub[] entry. */ + /* Should >=0 for apSub element. */ + /* Max iDivisor is max(u32) / BITVEC_NPTR + 1. */ + /* For a BITVEC_SZ of 512, this would be 34,359,739. */ + union { + BITVEC_TELEM aBitmap[BITVEC_NELEM]; /* Bitmap representation */ + u32 aHash[BITVEC_NINT]; /* Hash table representation */ + Bitvec *apSub[BITVEC_NPTR]; /* Recursive representation */ + } u; +}; + +/* +** Create a new bitmap object able to handle bits between 0 and iSize, +** inclusive. Return a pointer to the new object. Return NULL if +** malloc fails. +*/ +SQLITE_PRIVATE Bitvec *sqlite3BitvecCreate(u32 iSize){ + Bitvec *p; + assert( sizeof(*p)==BITVEC_SZ ); + p = sqlite3MallocZero( sizeof(*p) ); + if( p ){ + p->iSize = iSize; + } + return p; +} + +/* +** Check to see if the i-th bit is set. Return true or false. +** If p is NULL (if the bitmap has not been created) or if +** i is out of range, then return false. +*/ +SQLITE_PRIVATE int sqlite3BitvecTestNotNull(Bitvec *p, u32 i){ + assert( p!=0 ); + i--; + if( i>=p->iSize ) return 0; + while( p->iDivisor ){ + u32 bin = i/p->iDivisor; + i = i%p->iDivisor; + p = p->u.apSub[bin]; + if (!p) { + return 0; + } + } + if( p->iSize<=BITVEC_NBIT ){ + return (p->u.aBitmap[i/BITVEC_SZELEM] & (1<<(i&(BITVEC_SZELEM-1))))!=0; + } else{ + u32 h = BITVEC_HASH(i++); + while( p->u.aHash[h] ){ + if( p->u.aHash[h]==i ) return 1; + h = (h+1) % BITVEC_NINT; + } + return 0; + } +} +SQLITE_PRIVATE int sqlite3BitvecTest(Bitvec *p, u32 i){ + return p!=0 && sqlite3BitvecTestNotNull(p,i); +} + +/* +** Set the i-th bit. Return 0 on success and an error code if +** anything goes wrong. +** +** This routine might cause sub-bitmaps to be allocated. Failing +** to get the memory needed to hold the sub-bitmap is the only +** that can go wrong with an insert, assuming p and i are valid. +** +** The calling function must ensure that p is a valid Bitvec object +** and that the value for "i" is within range of the Bitvec object. +** Otherwise the behavior is undefined. +*/ +SQLITE_PRIVATE int sqlite3BitvecSet(Bitvec *p, u32 i){ + u32 h; + if( p==0 ) return SQLITE_OK; + assert( i>0 ); + assert( i<=p->iSize ); + i--; + while((p->iSize > BITVEC_NBIT) && p->iDivisor) { + u32 bin = i/p->iDivisor; + i = i%p->iDivisor; + if( p->u.apSub[bin]==0 ){ + p->u.apSub[bin] = sqlite3BitvecCreate( p->iDivisor ); + if( p->u.apSub[bin]==0 ) return SQLITE_NOMEM_BKPT; + } + p = p->u.apSub[bin]; + } + if( p->iSize<=BITVEC_NBIT ){ + p->u.aBitmap[i/BITVEC_SZELEM] |= 1 << (i&(BITVEC_SZELEM-1)); + return SQLITE_OK; + } + h = BITVEC_HASH(i++); + /* if there wasn't a hash collision, and this doesn't */ + /* completely fill the hash, then just add it without */ + /* worring about sub-dividing and re-hashing. */ + if( !p->u.aHash[h] ){ + if (p->nSet<(BITVEC_NINT-1)) { + goto bitvec_set_end; + } else { + goto bitvec_set_rehash; + } + } + /* there was a collision, check to see if it's already */ + /* in hash, if not, try to find a spot for it */ + do { + if( p->u.aHash[h]==i ) return SQLITE_OK; + h++; + if( h>=BITVEC_NINT ) h = 0; + } while( p->u.aHash[h] ); + /* we didn't find it in the hash. h points to the first */ + /* available free spot. check to see if this is going to */ + /* make our hash too "full". */ +bitvec_set_rehash: + if( p->nSet>=BITVEC_MXHASH ){ + unsigned int j; + int rc; + u32 *aiValues = sqlite3StackAllocRaw(0, sizeof(p->u.aHash)); + if( aiValues==0 ){ + return SQLITE_NOMEM_BKPT; + }else{ + memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash)); + memset(p->u.apSub, 0, sizeof(p->u.apSub)); + p->iDivisor = (p->iSize + BITVEC_NPTR - 1)/BITVEC_NPTR; + rc = sqlite3BitvecSet(p, i); + for(j=0; jnSet++; + p->u.aHash[h] = i; + return SQLITE_OK; +} + +/* +** Clear the i-th bit. +** +** pBuf must be a pointer to at least BITVEC_SZ bytes of temporary storage +** that BitvecClear can use to rebuilt its hash table. +*/ +SQLITE_PRIVATE void sqlite3BitvecClear(Bitvec *p, u32 i, void *pBuf){ + if( p==0 ) return; + assert( i>0 ); + i--; + while( p->iDivisor ){ + u32 bin = i/p->iDivisor; + i = i%p->iDivisor; + p = p->u.apSub[bin]; + if (!p) { + return; + } + } + if( p->iSize<=BITVEC_NBIT ){ + p->u.aBitmap[i/BITVEC_SZELEM] &= ~(1 << (i&(BITVEC_SZELEM-1))); + }else{ + unsigned int j; + u32 *aiValues = pBuf; + memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash)); + memset(p->u.aHash, 0, sizeof(p->u.aHash)); + p->nSet = 0; + for(j=0; jnSet++; + while( p->u.aHash[h] ){ + h++; + if( h>=BITVEC_NINT ) h = 0; + } + p->u.aHash[h] = aiValues[j]; + } + } + } +} + +/* +** Destroy a bitmap object. Reclaim all memory used. +*/ +SQLITE_PRIVATE void sqlite3BitvecDestroy(Bitvec *p){ + if( p==0 ) return; + if( p->iDivisor ){ + unsigned int i; + for(i=0; iu.apSub[i]); + } + } + sqlite3_free(p); +} + +/* +** Return the value of the iSize parameter specified when Bitvec *p +** was created. +*/ +SQLITE_PRIVATE u32 sqlite3BitvecSize(Bitvec *p){ + return p->iSize; +} + +#ifndef SQLITE_UNTESTABLE +/* +** Let V[] be an array of unsigned characters sufficient to hold +** up to N bits. Let I be an integer between 0 and N. 0<=I>3] |= (1<<(I&7)) +#define CLEARBIT(V,I) V[I>>3] &= ~(1<<(I&7)) +#define TESTBIT(V,I) (V[I>>3]&(1<<(I&7)))!=0 + +/* +** This routine runs an extensive test of the Bitvec code. +** +** The input is an array of integers that acts as a program +** to test the Bitvec. The integers are opcodes followed +** by 0, 1, or 3 operands, depending on the opcode. Another +** opcode follows immediately after the last operand. +** +** There are 6 opcodes numbered from 0 through 5. 0 is the +** "halt" opcode and causes the test to end. +** +** 0 Halt and return the number of errors +** 1 N S X Set N bits beginning with S and incrementing by X +** 2 N S X Clear N bits beginning with S and incrementing by X +** 3 N Set N randomly chosen bits +** 4 N Clear N randomly chosen bits +** 5 N S X Set N bits from S increment X in array only, not in bitvec +** +** The opcodes 1 through 4 perform set and clear operations are performed +** on both a Bitvec object and on a linear array of bits obtained from malloc. +** Opcode 5 works on the linear array only, not on the Bitvec. +** Opcode 5 is used to deliberately induce a fault in order to +** confirm that error detection works. +** +** At the conclusion of the test the linear array is compared +** against the Bitvec object. If there are any differences, +** an error is returned. If they are the same, zero is returned. +** +** If a memory allocation error occurs, return -1. +*/ +SQLITE_PRIVATE int sqlite3BitvecBuiltinTest(int sz, int *aOp){ + Bitvec *pBitvec = 0; + unsigned char *pV = 0; + int rc = -1; + int i, nx, pc, op; + void *pTmpSpace; + + /* Allocate the Bitvec to be tested and a linear array of + ** bits to act as the reference */ + pBitvec = sqlite3BitvecCreate( sz ); + pV = sqlite3MallocZero( (sz+7)/8 + 1 ); + pTmpSpace = sqlite3_malloc64(BITVEC_SZ); + if( pBitvec==0 || pV==0 || pTmpSpace==0 ) goto bitvec_end; + + /* NULL pBitvec tests */ + sqlite3BitvecSet(0, 1); + sqlite3BitvecClear(0, 1, pTmpSpace); + + /* Run the program */ + pc = i = 0; + while( (op = aOp[pc])!=0 ){ + switch( op ){ + case 1: + case 2: + case 5: { + nx = 4; + i = aOp[pc+2] - 1; + aOp[pc+2] += aOp[pc+3]; + break; + } + case 3: + case 4: + default: { + nx = 2; + sqlite3_randomness(sizeof(i), &i); + break; + } + } + if( (--aOp[pc+1]) > 0 ) nx = 0; + pc += nx; + i = (i & 0x7fffffff)%sz; + if( (op & 1)!=0 ){ + SETBIT(pV, (i+1)); + if( op!=5 ){ + if( sqlite3BitvecSet(pBitvec, i+1) ) goto bitvec_end; + } + }else{ + CLEARBIT(pV, (i+1)); + sqlite3BitvecClear(pBitvec, i+1, pTmpSpace); + } + } + + /* Test to make sure the linear array exactly matches the + ** Bitvec object. Start with the assumption that they do + ** match (rc==0). Change rc to non-zero if a discrepancy + ** is found. + */ + rc = sqlite3BitvecTest(0,0) + sqlite3BitvecTest(pBitvec, sz+1) + + sqlite3BitvecTest(pBitvec, 0) + + (sqlite3BitvecSize(pBitvec) - sz); + for(i=1; i<=sz; i++){ + if( (TESTBIT(pV,i))!=sqlite3BitvecTest(pBitvec,i) ){ + rc = i; + break; + } + } + + /* Free allocated structure */ +bitvec_end: + sqlite3_free(pTmpSpace); + sqlite3_free(pV); + sqlite3BitvecDestroy(pBitvec); + return rc; +} +#endif /* SQLITE_UNTESTABLE */ + +/************** End of bitvec.c **********************************************/ +/************** Begin file pcache.c ******************************************/ +/* +** 2008 August 05 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file implements that page cache. +*/ +/* #include "sqliteInt.h" */ + +/* +** A complete page cache is an instance of this structure. Every +** entry in the cache holds a single page of the database file. The +** btree layer only operates on the cached copy of the database pages. +** +** A page cache entry is "clean" if it exactly matches what is currently +** on disk. A page is "dirty" if it has been modified and needs to be +** persisted to disk. +** +** pDirty, pDirtyTail, pSynced: +** All dirty pages are linked into the doubly linked list using +** PgHdr.pDirtyNext and pDirtyPrev. The list is maintained in LRU order +** such that p was added to the list more recently than p->pDirtyNext. +** PCache.pDirty points to the first (newest) element in the list and +** pDirtyTail to the last (oldest). +** +** The PCache.pSynced variable is used to optimize searching for a dirty +** page to eject from the cache mid-transaction. It is better to eject +** a page that does not require a journal sync than one that does. +** Therefore, pSynced is maintained so that it *almost* always points +** to either the oldest page in the pDirty/pDirtyTail list that has a +** clear PGHDR_NEED_SYNC flag or to a page that is older than this one +** (so that the right page to eject can be found by following pDirtyPrev +** pointers). +*/ +struct PCache { + PgHdr *pDirty, *pDirtyTail; /* List of dirty pages in LRU order */ + PgHdr *pSynced; /* Last synced page in dirty page list */ + i64 nRefSum; /* Sum of ref counts over all pages */ + int szCache; /* Configured cache size */ + int szSpill; /* Size before spilling occurs */ + int szPage; /* Size of every page in this cache */ + int szExtra; /* Size of extra space for each page */ + u8 bPurgeable; /* True if pages are on backing store */ + u8 eCreate; /* eCreate value for for xFetch() */ + int (*xStress)(void*,PgHdr*); /* Call to try make a page clean */ + void *pStress; /* Argument to xStress */ + sqlite3_pcache *pCache; /* Pluggable cache module */ +}; + +/********************************** Test and Debug Logic **********************/ +/* +** Debug tracing macros. Enable by by changing the "0" to "1" and +** recompiling. +** +** When sqlite3PcacheTrace is 1, single line trace messages are issued. +** When sqlite3PcacheTrace is 2, a dump of the pcache showing all cache entries +** is displayed for many operations, resulting in a lot of output. +*/ +#if defined(SQLITE_DEBUG) && 0 + int sqlite3PcacheTrace = 2; /* 0: off 1: simple 2: cache dumps */ + int sqlite3PcacheMxDump = 9999; /* Max cache entries for pcacheDump() */ +# define pcacheTrace(X) if(sqlite3PcacheTrace){sqlite3DebugPrintf X;} + static void pcachePageTrace(int i, sqlite3_pcache_page *pLower){ + PgHdr *pPg; + unsigned char *a; + int j; + if( pLower==0 ){ + printf("%3d: NULL\n", i); + }else{ + pPg = (PgHdr*)pLower->pExtra; + printf("%3d: nRef %2lld flgs %02x data ", i, pPg->nRef, pPg->flags); + a = (unsigned char *)pLower->pBuf; + for(j=0; j<12; j++) printf("%02x", a[j]); + printf(" ptr %p\n", pPg); + } + } + static void pcacheDump(PCache *pCache){ + int N; + int i; + sqlite3_pcache_page *pLower; + + if( sqlite3PcacheTrace<2 ) return; + if( pCache->pCache==0 ) return; + N = sqlite3PcachePagecount(pCache); + if( N>sqlite3PcacheMxDump ) N = sqlite3PcacheMxDump; + for(i=1; i<=N; i++){ + pLower = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, i, 0); + pcachePageTrace(i, pLower); + if( pLower && ((PgHdr*)pLower)->pPage==0 ){ + sqlite3GlobalConfig.pcache2.xUnpin(pCache->pCache, pLower, 0); + } + } + } +#else +# define pcacheTrace(X) +# define pcachePageTrace(PGNO, X) +# define pcacheDump(X) +#endif + +/* +** Return 1 if pPg is on the dirty list for pCache. Return 0 if not. +** This routine runs inside of assert() statements only. +*/ +#ifdef SQLITE_DEBUG +static int pageOnDirtyList(PCache *pCache, PgHdr *pPg){ + PgHdr *p; + for(p=pCache->pDirty; p; p=p->pDirtyNext){ + if( p==pPg ) return 1; + } + return 0; +} +#endif + +/* +** Check invariants on a PgHdr entry. Return true if everything is OK. +** Return false if any invariant is violated. +** +** This routine is for use inside of assert() statements only. For +** example: +** +** assert( sqlite3PcachePageSanity(pPg) ); +*/ +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3PcachePageSanity(PgHdr *pPg){ + PCache *pCache; + assert( pPg!=0 ); + assert( pPg->pgno>0 || pPg->pPager==0 ); /* Page number is 1 or more */ + pCache = pPg->pCache; + assert( pCache!=0 ); /* Every page has an associated PCache */ + if( pPg->flags & PGHDR_CLEAN ){ + assert( (pPg->flags & PGHDR_DIRTY)==0 );/* Cannot be both CLEAN and DIRTY */ + assert( !pageOnDirtyList(pCache, pPg) );/* CLEAN pages not on dirty list */ + }else{ + assert( (pPg->flags & PGHDR_DIRTY)!=0 );/* If not CLEAN must be DIRTY */ + assert( pPg->pDirtyNext==0 || pPg->pDirtyNext->pDirtyPrev==pPg ); + assert( pPg->pDirtyPrev==0 || pPg->pDirtyPrev->pDirtyNext==pPg ); + assert( pPg->pDirtyPrev!=0 || pCache->pDirty==pPg ); + assert( pageOnDirtyList(pCache, pPg) ); + } + /* WRITEABLE pages must also be DIRTY */ + if( pPg->flags & PGHDR_WRITEABLE ){ + assert( pPg->flags & PGHDR_DIRTY ); /* WRITEABLE implies DIRTY */ + } + /* NEED_SYNC can be set independently of WRITEABLE. This can happen, + ** for example, when using the sqlite3PagerDontWrite() optimization: + ** (1) Page X is journalled, and gets WRITEABLE and NEED_SEEK. + ** (2) Page X moved to freelist, WRITEABLE is cleared + ** (3) Page X reused, WRITEABLE is set again + ** If NEED_SYNC had been cleared in step 2, then it would not be reset + ** in step 3, and page might be written into the database without first + ** syncing the rollback journal, which might cause corruption on a power + ** loss. + ** + ** Another example is when the database page size is smaller than the + ** disk sector size. When any page of a sector is journalled, all pages + ** in that sector are marked NEED_SYNC even if they are still CLEAN, just + ** in case they are later modified, since all pages in the same sector + ** must be journalled and synced before any of those pages can be safely + ** written. + */ + return 1; +} +#endif /* SQLITE_DEBUG */ + + +/********************************** Linked List Management ********************/ + +/* Allowed values for second argument to pcacheManageDirtyList() */ +#define PCACHE_DIRTYLIST_REMOVE 1 /* Remove pPage from dirty list */ +#define PCACHE_DIRTYLIST_ADD 2 /* Add pPage to the dirty list */ +#define PCACHE_DIRTYLIST_FRONT 3 /* Move pPage to the front of the list */ + +/* +** Manage pPage's participation on the dirty list. Bits of the addRemove +** argument determines what operation to do. The 0x01 bit means first +** remove pPage from the dirty list. The 0x02 means add pPage back to +** the dirty list. Doing both moves pPage to the front of the dirty list. +*/ +static void pcacheManageDirtyList(PgHdr *pPage, u8 addRemove){ + PCache *p = pPage->pCache; + + pcacheTrace(("%p.DIRTYLIST.%s %d\n", p, + addRemove==1 ? "REMOVE" : addRemove==2 ? "ADD" : "FRONT", + pPage->pgno)); + if( addRemove & PCACHE_DIRTYLIST_REMOVE ){ + assert( pPage->pDirtyNext || pPage==p->pDirtyTail ); + assert( pPage->pDirtyPrev || pPage==p->pDirty ); + + /* Update the PCache1.pSynced variable if necessary. */ + if( p->pSynced==pPage ){ + p->pSynced = pPage->pDirtyPrev; + } + + if( pPage->pDirtyNext ){ + pPage->pDirtyNext->pDirtyPrev = pPage->pDirtyPrev; + }else{ + assert( pPage==p->pDirtyTail ); + p->pDirtyTail = pPage->pDirtyPrev; + } + if( pPage->pDirtyPrev ){ + pPage->pDirtyPrev->pDirtyNext = pPage->pDirtyNext; + }else{ + /* If there are now no dirty pages in the cache, set eCreate to 2. + ** This is an optimization that allows sqlite3PcacheFetch() to skip + ** searching for a dirty page to eject from the cache when it might + ** otherwise have to. */ + assert( pPage==p->pDirty ); + p->pDirty = pPage->pDirtyNext; + assert( p->bPurgeable || p->eCreate==2 ); + if( p->pDirty==0 ){ /*OPTIMIZATION-IF-TRUE*/ + assert( p->bPurgeable==0 || p->eCreate==1 ); + p->eCreate = 2; + } + } + } + if( addRemove & PCACHE_DIRTYLIST_ADD ){ + pPage->pDirtyPrev = 0; + pPage->pDirtyNext = p->pDirty; + if( pPage->pDirtyNext ){ + assert( pPage->pDirtyNext->pDirtyPrev==0 ); + pPage->pDirtyNext->pDirtyPrev = pPage; + }else{ + p->pDirtyTail = pPage; + if( p->bPurgeable ){ + assert( p->eCreate==2 ); + p->eCreate = 1; + } + } + p->pDirty = pPage; + + /* If pSynced is NULL and this page has a clear NEED_SYNC flag, set + ** pSynced to point to it. Checking the NEED_SYNC flag is an + ** optimization, as if pSynced points to a page with the NEED_SYNC + ** flag set sqlite3PcacheFetchStress() searches through all newer + ** entries of the dirty-list for a page with NEED_SYNC clear anyway. */ + if( !p->pSynced + && 0==(pPage->flags&PGHDR_NEED_SYNC) /*OPTIMIZATION-IF-FALSE*/ + ){ + p->pSynced = pPage; + } + } + pcacheDump(p); +} + +/* +** Wrapper around the pluggable caches xUnpin method. If the cache is +** being used for an in-memory database, this function is a no-op. +*/ +static void pcacheUnpin(PgHdr *p){ + if( p->pCache->bPurgeable ){ + pcacheTrace(("%p.UNPIN %d\n", p->pCache, p->pgno)); + sqlite3GlobalConfig.pcache2.xUnpin(p->pCache->pCache, p->pPage, 0); + pcacheDump(p->pCache); + } +} + +/* +** Compute the number of pages of cache requested. p->szCache is the +** cache size requested by the "PRAGMA cache_size" statement. +*/ +static int numberOfCachePages(PCache *p){ + if( p->szCache>=0 ){ + /* IMPLEMENTATION-OF: R-42059-47211 If the argument N is positive then the + ** suggested cache size is set to N. */ + return p->szCache; + }else{ + i64 n; + /* IMPLEMANTATION-OF: R-59858-46238 If the argument N is negative, then the + ** number of cache pages is adjusted to be a number of pages that would + ** use approximately abs(N*1024) bytes of memory based on the current + ** page size. */ + n = ((-1024*(i64)p->szCache)/(p->szPage+p->szExtra)); + if( n>1000000000 ) n = 1000000000; + return (int)n; + } +} + +/*************************************************** General Interfaces ****** +** +** Initialize and shutdown the page cache subsystem. Neither of these +** functions are threadsafe. +*/ +SQLITE_PRIVATE int sqlite3PcacheInitialize(void){ + if( sqlite3GlobalConfig.pcache2.xInit==0 ){ + /* IMPLEMENTATION-OF: R-26801-64137 If the xInit() method is NULL, then the + ** built-in default page cache is used instead of the application defined + ** page cache. */ + sqlite3PCacheSetDefault(); + assert( sqlite3GlobalConfig.pcache2.xInit!=0 ); + } + return sqlite3GlobalConfig.pcache2.xInit(sqlite3GlobalConfig.pcache2.pArg); +} +SQLITE_PRIVATE void sqlite3PcacheShutdown(void){ + if( sqlite3GlobalConfig.pcache2.xShutdown ){ + /* IMPLEMENTATION-OF: R-26000-56589 The xShutdown() method may be NULL. */ + sqlite3GlobalConfig.pcache2.xShutdown(sqlite3GlobalConfig.pcache2.pArg); + } +} + +/* +** Return the size in bytes of a PCache object. +*/ +SQLITE_PRIVATE int sqlite3PcacheSize(void){ return sizeof(PCache); } + +/* +** Create a new PCache object. Storage space to hold the object +** has already been allocated and is passed in as the p pointer. +** The caller discovers how much space needs to be allocated by +** calling sqlite3PcacheSize(). +** +** szExtra is some extra space allocated for each page. The first +** 8 bytes of the extra space will be zeroed as the page is allocated, +** but remaining content will be uninitialized. Though it is opaque +** to this module, the extra space really ends up being the MemPage +** structure in the pager. +*/ +SQLITE_PRIVATE int sqlite3PcacheOpen( + int szPage, /* Size of every page */ + int szExtra, /* Extra space associated with each page */ + int bPurgeable, /* True if pages are on backing store */ + int (*xStress)(void*,PgHdr*),/* Call to try to make pages clean */ + void *pStress, /* Argument to xStress */ + PCache *p /* Preallocated space for the PCache */ +){ + memset(p, 0, sizeof(PCache)); + p->szPage = 1; + p->szExtra = szExtra; + assert( szExtra>=8 ); /* First 8 bytes will be zeroed */ + p->bPurgeable = bPurgeable; + p->eCreate = 2; + p->xStress = xStress; + p->pStress = pStress; + p->szCache = 100; + p->szSpill = 1; + pcacheTrace(("%p.OPEN szPage %d bPurgeable %d\n",p,szPage,bPurgeable)); + return sqlite3PcacheSetPageSize(p, szPage); +} + +/* +** Change the page size for PCache object. The caller must ensure that there +** are no outstanding page references when this function is called. +*/ +SQLITE_PRIVATE int sqlite3PcacheSetPageSize(PCache *pCache, int szPage){ + assert( pCache->nRefSum==0 && pCache->pDirty==0 ); + if( pCache->szPage ){ + sqlite3_pcache *pNew; + pNew = sqlite3GlobalConfig.pcache2.xCreate( + szPage, pCache->szExtra + ROUND8(sizeof(PgHdr)), + pCache->bPurgeable + ); + if( pNew==0 ) return SQLITE_NOMEM_BKPT; + sqlite3GlobalConfig.pcache2.xCachesize(pNew, numberOfCachePages(pCache)); + if( pCache->pCache ){ + sqlite3GlobalConfig.pcache2.xDestroy(pCache->pCache); + } + pCache->pCache = pNew; + pCache->szPage = szPage; + pcacheTrace(("%p.PAGESIZE %d\n",pCache,szPage)); + } + return SQLITE_OK; +} + +/* +** Try to obtain a page from the cache. +** +** This routine returns a pointer to an sqlite3_pcache_page object if +** such an object is already in cache, or if a new one is created. +** This routine returns a NULL pointer if the object was not in cache +** and could not be created. +** +** The createFlags should be 0 to check for existing pages and should +** be 3 (not 1, but 3) to try to create a new page. +** +** If the createFlag is 0, then NULL is always returned if the page +** is not already in the cache. If createFlag is 1, then a new page +** is created only if that can be done without spilling dirty pages +** and without exceeding the cache size limit. +** +** The caller needs to invoke sqlite3PcacheFetchFinish() to properly +** initialize the sqlite3_pcache_page object and convert it into a +** PgHdr object. The sqlite3PcacheFetch() and sqlite3PcacheFetchFinish() +** routines are split this way for performance reasons. When separated +** they can both (usually) operate without having to push values to +** the stack on entry and pop them back off on exit, which saves a +** lot of pushing and popping. +*/ +SQLITE_PRIVATE sqlite3_pcache_page *sqlite3PcacheFetch( + PCache *pCache, /* Obtain the page from this cache */ + Pgno pgno, /* Page number to obtain */ + int createFlag /* If true, create page if it does not exist already */ +){ + int eCreate; + sqlite3_pcache_page *pRes; + + assert( pCache!=0 ); + assert( pCache->pCache!=0 ); + assert( createFlag==3 || createFlag==0 ); + assert( pCache->eCreate==((pCache->bPurgeable && pCache->pDirty) ? 1 : 2) ); + + /* eCreate defines what to do if the page does not exist. + ** 0 Do not allocate a new page. (createFlag==0) + ** 1 Allocate a new page if doing so is inexpensive. + ** (createFlag==1 AND bPurgeable AND pDirty) + ** 2 Allocate a new page even it doing so is difficult. + ** (createFlag==1 AND !(bPurgeable AND pDirty) + */ + eCreate = createFlag & pCache->eCreate; + assert( eCreate==0 || eCreate==1 || eCreate==2 ); + assert( createFlag==0 || pCache->eCreate==eCreate ); + assert( createFlag==0 || eCreate==1+(!pCache->bPurgeable||!pCache->pDirty) ); + pRes = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, pgno, eCreate); + pcacheTrace(("%p.FETCH %d%s (result: %p) ",pCache,pgno, + createFlag?" create":"",pRes)); + pcachePageTrace(pgno, pRes); + return pRes; +} + +/* +** If the sqlite3PcacheFetch() routine is unable to allocate a new +** page because no clean pages are available for reuse and the cache +** size limit has been reached, then this routine can be invoked to +** try harder to allocate a page. This routine might invoke the stress +** callback to spill dirty pages to the journal. It will then try to +** allocate the new page and will only fail to allocate a new page on +** an OOM error. +** +** This routine should be invoked only after sqlite3PcacheFetch() fails. +*/ +SQLITE_PRIVATE int sqlite3PcacheFetchStress( + PCache *pCache, /* Obtain the page from this cache */ + Pgno pgno, /* Page number to obtain */ + sqlite3_pcache_page **ppPage /* Write result here */ +){ + PgHdr *pPg; + if( pCache->eCreate==2 ) return 0; + + if( sqlite3PcachePagecount(pCache)>pCache->szSpill ){ + /* Find a dirty page to write-out and recycle. First try to find a + ** page that does not require a journal-sync (one with PGHDR_NEED_SYNC + ** cleared), but if that is not possible settle for any other + ** unreferenced dirty page. + ** + ** If the LRU page in the dirty list that has a clear PGHDR_NEED_SYNC + ** flag is currently referenced, then the following may leave pSynced + ** set incorrectly (pointing to other than the LRU page with NEED_SYNC + ** cleared). This is Ok, as pSynced is just an optimization. */ + for(pPg=pCache->pSynced; + pPg && (pPg->nRef || (pPg->flags&PGHDR_NEED_SYNC)); + pPg=pPg->pDirtyPrev + ); + pCache->pSynced = pPg; + if( !pPg ){ + for(pPg=pCache->pDirtyTail; pPg && pPg->nRef; pPg=pPg->pDirtyPrev); + } + if( pPg ){ + int rc; +#ifdef SQLITE_LOG_CACHE_SPILL + sqlite3_log(SQLITE_FULL, + "spill page %d making room for %d - cache used: %d/%d", + pPg->pgno, pgno, + sqlite3GlobalConfig.pcache2.xPagecount(pCache->pCache), + numberOfCachePages(pCache)); +#endif + pcacheTrace(("%p.SPILL %d\n",pCache,pPg->pgno)); + rc = pCache->xStress(pCache->pStress, pPg); + pcacheDump(pCache); + if( rc!=SQLITE_OK && rc!=SQLITE_BUSY ){ + return rc; + } + } + } + *ppPage = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, pgno, 2); + return *ppPage==0 ? SQLITE_NOMEM_BKPT : SQLITE_OK; +} + +/* +** This is a helper routine for sqlite3PcacheFetchFinish() +** +** In the uncommon case where the page being fetched has not been +** initialized, this routine is invoked to do the initialization. +** This routine is broken out into a separate function since it +** requires extra stack manipulation that can be avoided in the common +** case. +*/ +static SQLITE_NOINLINE PgHdr *pcacheFetchFinishWithInit( + PCache *pCache, /* Obtain the page from this cache */ + Pgno pgno, /* Page number obtained */ + sqlite3_pcache_page *pPage /* Page obtained by prior PcacheFetch() call */ +){ + PgHdr *pPgHdr; + assert( pPage!=0 ); + pPgHdr = (PgHdr*)pPage->pExtra; + assert( pPgHdr->pPage==0 ); + memset(&pPgHdr->pDirty, 0, sizeof(PgHdr) - offsetof(PgHdr,pDirty)); + pPgHdr->pPage = pPage; + pPgHdr->pData = pPage->pBuf; + pPgHdr->pExtra = (void *)&pPgHdr[1]; + memset(pPgHdr->pExtra, 0, 8); + pPgHdr->pCache = pCache; + pPgHdr->pgno = pgno; + pPgHdr->flags = PGHDR_CLEAN; + return sqlite3PcacheFetchFinish(pCache,pgno,pPage); +} + +/* +** This routine converts the sqlite3_pcache_page object returned by +** sqlite3PcacheFetch() into an initialized PgHdr object. This routine +** must be called after sqlite3PcacheFetch() in order to get a usable +** result. +*/ +SQLITE_PRIVATE PgHdr *sqlite3PcacheFetchFinish( + PCache *pCache, /* Obtain the page from this cache */ + Pgno pgno, /* Page number obtained */ + sqlite3_pcache_page *pPage /* Page obtained by prior PcacheFetch() call */ +){ + PgHdr *pPgHdr; + + assert( pPage!=0 ); + pPgHdr = (PgHdr *)pPage->pExtra; + + if( !pPgHdr->pPage ){ + return pcacheFetchFinishWithInit(pCache, pgno, pPage); + } + pCache->nRefSum++; + pPgHdr->nRef++; + assert( sqlite3PcachePageSanity(pPgHdr) ); + return pPgHdr; +} + +/* +** Decrement the reference count on a page. If the page is clean and the +** reference count drops to 0, then it is made eligible for recycling. +*/ +SQLITE_PRIVATE void SQLITE_NOINLINE sqlite3PcacheRelease(PgHdr *p){ + assert( p->nRef>0 ); + p->pCache->nRefSum--; + if( (--p->nRef)==0 ){ + if( p->flags&PGHDR_CLEAN ){ + pcacheUnpin(p); + }else{ + pcacheManageDirtyList(p, PCACHE_DIRTYLIST_FRONT); + assert( sqlite3PcachePageSanity(p) ); + } + } +} + +/* +** Increase the reference count of a supplied page by 1. +*/ +SQLITE_PRIVATE void sqlite3PcacheRef(PgHdr *p){ + assert(p->nRef>0); + assert( sqlite3PcachePageSanity(p) ); + p->nRef++; + p->pCache->nRefSum++; +} + +/* +** Drop a page from the cache. There must be exactly one reference to the +** page. This function deletes that reference, so after it returns the +** page pointed to by p is invalid. +*/ +SQLITE_PRIVATE void sqlite3PcacheDrop(PgHdr *p){ + assert( p->nRef==1 ); + assert( sqlite3PcachePageSanity(p) ); + if( p->flags&PGHDR_DIRTY ){ + pcacheManageDirtyList(p, PCACHE_DIRTYLIST_REMOVE); + } + p->pCache->nRefSum--; + sqlite3GlobalConfig.pcache2.xUnpin(p->pCache->pCache, p->pPage, 1); +} + +/* +** Make sure the page is marked as dirty. If it isn't dirty already, +** make it so. +*/ +SQLITE_PRIVATE void sqlite3PcacheMakeDirty(PgHdr *p){ + assert( p->nRef>0 ); + assert( sqlite3PcachePageSanity(p) ); + if( p->flags & (PGHDR_CLEAN|PGHDR_DONT_WRITE) ){ /*OPTIMIZATION-IF-FALSE*/ + p->flags &= ~PGHDR_DONT_WRITE; + if( p->flags & PGHDR_CLEAN ){ + p->flags ^= (PGHDR_DIRTY|PGHDR_CLEAN); + pcacheTrace(("%p.DIRTY %d\n",p->pCache,p->pgno)); + assert( (p->flags & (PGHDR_DIRTY|PGHDR_CLEAN))==PGHDR_DIRTY ); + pcacheManageDirtyList(p, PCACHE_DIRTYLIST_ADD); + assert( sqlite3PcachePageSanity(p) ); + } + assert( sqlite3PcachePageSanity(p) ); + } +} + +/* +** Make sure the page is marked as clean. If it isn't clean already, +** make it so. +*/ +SQLITE_PRIVATE void sqlite3PcacheMakeClean(PgHdr *p){ + assert( sqlite3PcachePageSanity(p) ); + assert( (p->flags & PGHDR_DIRTY)!=0 ); + assert( (p->flags & PGHDR_CLEAN)==0 ); + pcacheManageDirtyList(p, PCACHE_DIRTYLIST_REMOVE); + p->flags &= ~(PGHDR_DIRTY|PGHDR_NEED_SYNC|PGHDR_WRITEABLE); + p->flags |= PGHDR_CLEAN; + pcacheTrace(("%p.CLEAN %d\n",p->pCache,p->pgno)); + assert( sqlite3PcachePageSanity(p) ); + if( p->nRef==0 ){ + pcacheUnpin(p); + } +} + +/* +** Make every page in the cache clean. +*/ +SQLITE_PRIVATE void sqlite3PcacheCleanAll(PCache *pCache){ + PgHdr *p; + pcacheTrace(("%p.CLEAN-ALL\n",pCache)); + while( (p = pCache->pDirty)!=0 ){ + sqlite3PcacheMakeClean(p); + } +} + +/* +** Clear the PGHDR_NEED_SYNC and PGHDR_WRITEABLE flag from all dirty pages. +*/ +SQLITE_PRIVATE void sqlite3PcacheClearWritable(PCache *pCache){ + PgHdr *p; + pcacheTrace(("%p.CLEAR-WRITEABLE\n",pCache)); + for(p=pCache->pDirty; p; p=p->pDirtyNext){ + p->flags &= ~(PGHDR_NEED_SYNC|PGHDR_WRITEABLE); + } + pCache->pSynced = pCache->pDirtyTail; +} + +/* +** Clear the PGHDR_NEED_SYNC flag from all dirty pages. +*/ +SQLITE_PRIVATE void sqlite3PcacheClearSyncFlags(PCache *pCache){ + PgHdr *p; + for(p=pCache->pDirty; p; p=p->pDirtyNext){ + p->flags &= ~PGHDR_NEED_SYNC; + } + pCache->pSynced = pCache->pDirtyTail; +} + +/* +** Change the page number of page p to newPgno. +*/ +SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr *p, Pgno newPgno){ + PCache *pCache = p->pCache; + sqlite3_pcache_page *pOther; + assert( p->nRef>0 ); + assert( newPgno>0 ); + assert( sqlite3PcachePageSanity(p) ); + pcacheTrace(("%p.MOVE %d -> %d\n",pCache,p->pgno,newPgno)); + pOther = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, newPgno, 0); + if( pOther ){ + PgHdr *pXPage = (PgHdr*)pOther->pExtra; + assert( pXPage->nRef==0 ); + pXPage->nRef++; + pCache->nRefSum++; + sqlite3PcacheDrop(pXPage); + } + sqlite3GlobalConfig.pcache2.xRekey(pCache->pCache, p->pPage, p->pgno,newPgno); + p->pgno = newPgno; + if( (p->flags&PGHDR_DIRTY) && (p->flags&PGHDR_NEED_SYNC) ){ + pcacheManageDirtyList(p, PCACHE_DIRTYLIST_FRONT); + assert( sqlite3PcachePageSanity(p) ); + } +} + +/* +** Drop every cache entry whose page number is greater than "pgno". The +** caller must ensure that there are no outstanding references to any pages +** other than page 1 with a page number greater than pgno. +** +** If there is a reference to page 1 and the pgno parameter passed to this +** function is 0, then the data area associated with page 1 is zeroed, but +** the page object is not dropped. +*/ +SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache *pCache, Pgno pgno){ + if( pCache->pCache ){ + PgHdr *p; + PgHdr *pNext; + pcacheTrace(("%p.TRUNCATE %d\n",pCache,pgno)); + for(p=pCache->pDirty; p; p=pNext){ + pNext = p->pDirtyNext; + /* This routine never gets call with a positive pgno except right + ** after sqlite3PcacheCleanAll(). So if there are dirty pages, + ** it must be that pgno==0. + */ + assert( p->pgno>0 ); + if( p->pgno>pgno ){ + assert( p->flags&PGHDR_DIRTY ); + sqlite3PcacheMakeClean(p); + } + } + if( pgno==0 && pCache->nRefSum ){ + sqlite3_pcache_page *pPage1; + pPage1 = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache,1,0); + if( ALWAYS(pPage1) ){ /* Page 1 is always available in cache, because + ** pCache->nRefSum>0 */ + memset(pPage1->pBuf, 0, pCache->szPage); + pgno = 1; + } + } + sqlite3GlobalConfig.pcache2.xTruncate(pCache->pCache, pgno+1); + } +} + +/* +** Close a cache. +*/ +SQLITE_PRIVATE void sqlite3PcacheClose(PCache *pCache){ + assert( pCache->pCache!=0 ); + pcacheTrace(("%p.CLOSE\n",pCache)); + sqlite3GlobalConfig.pcache2.xDestroy(pCache->pCache); +} + +/* +** Discard the contents of the cache. +*/ +SQLITE_PRIVATE void sqlite3PcacheClear(PCache *pCache){ + sqlite3PcacheTruncate(pCache, 0); +} + +/* +** Merge two lists of pages connected by pDirty and in pgno order. +** Do not bother fixing the pDirtyPrev pointers. +*/ +static PgHdr *pcacheMergeDirtyList(PgHdr *pA, PgHdr *pB){ + PgHdr result, *pTail; + pTail = &result; + assert( pA!=0 && pB!=0 ); + for(;;){ + if( pA->pgnopgno ){ + pTail->pDirty = pA; + pTail = pA; + pA = pA->pDirty; + if( pA==0 ){ + pTail->pDirty = pB; + break; + } + }else{ + pTail->pDirty = pB; + pTail = pB; + pB = pB->pDirty; + if( pB==0 ){ + pTail->pDirty = pA; + break; + } + } + } + return result.pDirty; +} + +/* +** Sort the list of pages in accending order by pgno. Pages are +** connected by pDirty pointers. The pDirtyPrev pointers are +** corrupted by this sort. +** +** Since there cannot be more than 2^31 distinct pages in a database, +** there cannot be more than 31 buckets required by the merge sorter. +** One extra bucket is added to catch overflow in case something +** ever changes to make the previous sentence incorrect. +*/ +#define N_SORT_BUCKET 32 +static PgHdr *pcacheSortDirtyList(PgHdr *pIn){ + PgHdr *a[N_SORT_BUCKET], *p; + int i; + memset(a, 0, sizeof(a)); + while( pIn ){ + p = pIn; + pIn = p->pDirty; + p->pDirty = 0; + for(i=0; ALWAYS(ipDirty; p; p=p->pDirtyNext){ + p->pDirty = p->pDirtyNext; + } + return pcacheSortDirtyList(pCache->pDirty); +} + +/* +** Return the total number of references to all pages held by the cache. +** +** This is not the total number of pages referenced, but the sum of the +** reference count for all pages. +*/ +SQLITE_PRIVATE i64 sqlite3PcacheRefCount(PCache *pCache){ + return pCache->nRefSum; +} + +/* +** Return the number of references to the page supplied as an argument. +*/ +SQLITE_PRIVATE i64 sqlite3PcachePageRefcount(PgHdr *p){ + return p->nRef; +} + +/* +** Return the total number of pages in the cache. +*/ +SQLITE_PRIVATE int sqlite3PcachePagecount(PCache *pCache){ + assert( pCache->pCache!=0 ); + return sqlite3GlobalConfig.pcache2.xPagecount(pCache->pCache); +} + +#ifdef SQLITE_TEST +/* +** Get the suggested cache-size value. +*/ +SQLITE_PRIVATE int sqlite3PcacheGetCachesize(PCache *pCache){ + return numberOfCachePages(pCache); +} +#endif + +/* +** Set the suggested cache-size value. +*/ +SQLITE_PRIVATE void sqlite3PcacheSetCachesize(PCache *pCache, int mxPage){ + assert( pCache->pCache!=0 ); + pCache->szCache = mxPage; + sqlite3GlobalConfig.pcache2.xCachesize(pCache->pCache, + numberOfCachePages(pCache)); +} + +/* +** Set the suggested cache-spill value. Make no changes if if the +** argument is zero. Return the effective cache-spill size, which will +** be the larger of the szSpill and szCache. +*/ +SQLITE_PRIVATE int sqlite3PcacheSetSpillsize(PCache *p, int mxPage){ + int res; + assert( p->pCache!=0 ); + if( mxPage ){ + if( mxPage<0 ){ + mxPage = (int)((-1024*(i64)mxPage)/(p->szPage+p->szExtra)); + } + p->szSpill = mxPage; + } + res = numberOfCachePages(p); + if( resszSpill ) res = p->szSpill; + return res; +} + +/* +** Free up as much memory as possible from the page cache. +*/ +SQLITE_PRIVATE void sqlite3PcacheShrink(PCache *pCache){ + assert( pCache->pCache!=0 ); + sqlite3GlobalConfig.pcache2.xShrink(pCache->pCache); +} + +/* +** Return the size of the header added by this middleware layer +** in the page-cache hierarchy. +*/ +SQLITE_PRIVATE int sqlite3HeaderSizePcache(void){ return ROUND8(sizeof(PgHdr)); } + +/* +** Return the number of dirty pages currently in the cache, as a percentage +** of the configured cache size. +*/ +SQLITE_PRIVATE int sqlite3PCachePercentDirty(PCache *pCache){ + PgHdr *pDirty; + int nDirty = 0; + int nCache = numberOfCachePages(pCache); + for(pDirty=pCache->pDirty; pDirty; pDirty=pDirty->pDirtyNext) nDirty++; + return nCache ? (int)(((i64)nDirty * 100) / nCache) : 0; +} + +#ifdef SQLITE_DIRECT_OVERFLOW_READ +/* +** Return true if there are one or more dirty pages in the cache. Else false. +*/ +SQLITE_PRIVATE int sqlite3PCacheIsDirty(PCache *pCache){ + return (pCache->pDirty!=0); +} +#endif + +#if defined(SQLITE_CHECK_PAGES) || defined(SQLITE_DEBUG) +/* +** For all dirty pages currently in the cache, invoke the specified +** callback. This is only used if the SQLITE_CHECK_PAGES macro is +** defined. +*/ +SQLITE_PRIVATE void sqlite3PcacheIterateDirty(PCache *pCache, void (*xIter)(PgHdr *)){ + PgHdr *pDirty; + for(pDirty=pCache->pDirty; pDirty; pDirty=pDirty->pDirtyNext){ + xIter(pDirty); + } +} +#endif + +/************** End of pcache.c **********************************************/ +/************** Begin file pcache1.c *****************************************/ +/* +** 2008 November 05 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file implements the default page cache implementation (the +** sqlite3_pcache interface). It also contains part of the implementation +** of the SQLITE_CONFIG_PAGECACHE and sqlite3_release_memory() features. +** If the default page cache implementation is overridden, then neither of +** these two features are available. +** +** A Page cache line looks like this: +** +** ------------------------------------------------------------- +** | database page content | PgHdr1 | MemPage | PgHdr | +** ------------------------------------------------------------- +** +** The database page content is up front (so that buffer overreads tend to +** flow harmlessly into the PgHdr1, MemPage, and PgHdr extensions). MemPage +** is the extension added by the btree.c module containing information such +** as the database page number and how that database page is used. PgHdr +** is added by the pcache.c layer and contains information used to keep track +** of which pages are "dirty". PgHdr1 is an extension added by this +** module (pcache1.c). The PgHdr1 header is a subclass of sqlite3_pcache_page. +** PgHdr1 contains information needed to look up a page by its page number. +** The superclass sqlite3_pcache_page.pBuf points to the start of the +** database page content and sqlite3_pcache_page.pExtra points to PgHdr. +** +** The size of the extension (MemPage+PgHdr+PgHdr1) can be determined at +** runtime using sqlite3_config(SQLITE_CONFIG_PCACHE_HDRSZ, &size). The +** sizes of the extensions sum to 272 bytes on x64 for 3.8.10, but this +** size can vary according to architecture, compile-time options, and +** SQLite library version number. +** +** Historical note: It used to be that if the SQLITE_PCACHE_SEPARATE_HEADER +** was defined, then the page content would be held in a separate memory +** allocation from the PgHdr1. This was intended to avoid clownshoe memory +** allocations. However, the btree layer needs a small (16-byte) overrun +** area after the page content buffer. The header serves as that overrun +** area. Therefore SQLITE_PCACHE_SEPARATE_HEADER was discontinued to avoid +** any possibility of a memory error. +** +** This module tracks pointers to PgHdr1 objects. Only pcache.c communicates +** with this module. Information is passed back and forth as PgHdr1 pointers. +** +** The pcache.c and pager.c modules deal pointers to PgHdr objects. +** The btree.c module deals with pointers to MemPage objects. +** +** SOURCE OF PAGE CACHE MEMORY: +** +** Memory for a page might come from any of three sources: +** +** (1) The general-purpose memory allocator - sqlite3Malloc() +** (2) Global page-cache memory provided using sqlite3_config() with +** SQLITE_CONFIG_PAGECACHE. +** (3) PCache-local bulk allocation. +** +** The third case is a chunk of heap memory (defaulting to 100 pages worth) +** that is allocated when the page cache is created. The size of the local +** bulk allocation can be adjusted using +** +** sqlite3_config(SQLITE_CONFIG_PAGECACHE, (void*)0, 0, N). +** +** If N is positive, then N pages worth of memory are allocated using a single +** sqlite3Malloc() call and that memory is used for the first N pages allocated. +** Or if N is negative, then -1024*N bytes of memory are allocated and used +** for as many pages as can be accomodated. +** +** Only one of (2) or (3) can be used. Once the memory available to (2) or +** (3) is exhausted, subsequent allocations fail over to the general-purpose +** memory allocator (1). +** +** Earlier versions of SQLite used only methods (1) and (2). But experiments +** show that method (3) with N==100 provides about a 5% performance boost for +** common workloads. +*/ +/* #include "sqliteInt.h" */ + +typedef struct PCache1 PCache1; +typedef struct PgHdr1 PgHdr1; +typedef struct PgFreeslot PgFreeslot; +typedef struct PGroup PGroup; + +/* +** Each cache entry is represented by an instance of the following +** structure. A buffer of PgHdr1.pCache->szPage bytes is allocated +** directly before this structure and is used to cache the page content. +** +** When reading a corrupt database file, it is possible that SQLite might +** read a few bytes (no more than 16 bytes) past the end of the page buffer. +** It will only read past the end of the page buffer, never write. This +** object is positioned immediately after the page buffer to serve as an +** overrun area, so that overreads are harmless. +** +** Variables isBulkLocal and isAnchor were once type "u8". That works, +** but causes a 2-byte gap in the structure for most architectures (since +** pointers must be either 4 or 8-byte aligned). As this structure is located +** in memory directly after the associated page data, if the database is +** corrupt, code at the b-tree layer may overread the page buffer and +** read part of this structure before the corruption is detected. This +** can cause a valgrind error if the unitialized gap is accessed. Using u16 +** ensures there is no such gap, and therefore no bytes of uninitialized +** memory in the structure. +** +** The pLruNext and pLruPrev pointers form a double-linked circular list +** of all pages that are unpinned. The PGroup.lru element (which should be +** the only element on the list with PgHdr1.isAnchor set to 1) forms the +** beginning and the end of the list. +*/ +struct PgHdr1 { + sqlite3_pcache_page page; /* Base class. Must be first. pBuf & pExtra */ + unsigned int iKey; /* Key value (page number) */ + u16 isBulkLocal; /* This page from bulk local storage */ + u16 isAnchor; /* This is the PGroup.lru element */ + PgHdr1 *pNext; /* Next in hash table chain */ + PCache1 *pCache; /* Cache that currently owns this page */ + PgHdr1 *pLruNext; /* Next in circular LRU list of unpinned pages */ + PgHdr1 *pLruPrev; /* Previous in LRU list of unpinned pages */ + /* NB: pLruPrev is only valid if pLruNext!=0 */ +}; + +/* +** A page is pinned if it is not on the LRU list. To be "pinned" means +** that the page is in active use and must not be deallocated. +*/ +#define PAGE_IS_PINNED(p) ((p)->pLruNext==0) +#define PAGE_IS_UNPINNED(p) ((p)->pLruNext!=0) + +/* Each page cache (or PCache) belongs to a PGroup. A PGroup is a set +** of one or more PCaches that are able to recycle each other's unpinned +** pages when they are under memory pressure. A PGroup is an instance of +** the following object. +** +** This page cache implementation works in one of two modes: +** +** (1) Every PCache is the sole member of its own PGroup. There is +** one PGroup per PCache. +** +** (2) There is a single global PGroup that all PCaches are a member +** of. +** +** Mode 1 uses more memory (since PCache instances are not able to rob +** unused pages from other PCaches) but it also operates without a mutex, +** and is therefore often faster. Mode 2 requires a mutex in order to be +** threadsafe, but recycles pages more efficiently. +** +** For mode (1), PGroup.mutex is NULL. For mode (2) there is only a single +** PGroup which is the pcache1.grp global variable and its mutex is +** SQLITE_MUTEX_STATIC_LRU. +*/ +struct PGroup { + sqlite3_mutex *mutex; /* MUTEX_STATIC_LRU or NULL */ + unsigned int nMaxPage; /* Sum of nMax for purgeable caches */ + unsigned int nMinPage; /* Sum of nMin for purgeable caches */ + unsigned int mxPinned; /* nMaxpage + 10 - nMinPage */ + unsigned int nPurgeable; /* Number of purgeable pages allocated */ + PgHdr1 lru; /* The beginning and end of the LRU list */ +}; + +/* Each page cache is an instance of the following object. Every +** open database file (including each in-memory database and each +** temporary or transient database) has a single page cache which +** is an instance of this object. +** +** Pointers to structures of this type are cast and returned as +** opaque sqlite3_pcache* handles. +*/ +struct PCache1 { + /* Cache configuration parameters. Page size (szPage) and the purgeable + ** flag (bPurgeable) and the pnPurgeable pointer are all set when the + ** cache is created and are never changed thereafter. nMax may be + ** modified at any time by a call to the pcache1Cachesize() method. + ** The PGroup mutex must be held when accessing nMax. + */ + PGroup *pGroup; /* PGroup this cache belongs to */ + unsigned int *pnPurgeable; /* Pointer to pGroup->nPurgeable */ + int szPage; /* Size of database content section */ + int szExtra; /* sizeof(MemPage)+sizeof(PgHdr) */ + int szAlloc; /* Total size of one pcache line */ + int bPurgeable; /* True if cache is purgeable */ + unsigned int nMin; /* Minimum number of pages reserved */ + unsigned int nMax; /* Configured "cache_size" value */ + unsigned int n90pct; /* nMax*9/10 */ + unsigned int iMaxKey; /* Largest key seen since xTruncate() */ + unsigned int nPurgeableDummy; /* pnPurgeable points here when not used*/ + + /* Hash table of all pages. The following variables may only be accessed + ** when the accessor is holding the PGroup mutex. + */ + unsigned int nRecyclable; /* Number of pages in the LRU list */ + unsigned int nPage; /* Total number of pages in apHash */ + unsigned int nHash; /* Number of slots in apHash[] */ + PgHdr1 **apHash; /* Hash table for fast lookup by key */ + PgHdr1 *pFree; /* List of unused pcache-local pages */ + void *pBulk; /* Bulk memory used by pcache-local */ +}; + +/* +** Free slots in the allocator used to divide up the global page cache +** buffer provided using the SQLITE_CONFIG_PAGECACHE mechanism. +*/ +struct PgFreeslot { + PgFreeslot *pNext; /* Next free slot */ +}; + +/* +** Global data used by this cache. +*/ +static SQLITE_WSD struct PCacheGlobal { + PGroup grp; /* The global PGroup for mode (2) */ + + /* Variables related to SQLITE_CONFIG_PAGECACHE settings. The + ** szSlot, nSlot, pStart, pEnd, nReserve, and isInit values are all + ** fixed at sqlite3_initialize() time and do not require mutex protection. + ** The nFreeSlot and pFree values do require mutex protection. + */ + int isInit; /* True if initialized */ + int separateCache; /* Use a new PGroup for each PCache */ + int nInitPage; /* Initial bulk allocation size */ + int szSlot; /* Size of each free slot */ + int nSlot; /* The number of pcache slots */ + int nReserve; /* Try to keep nFreeSlot above this */ + void *pStart, *pEnd; /* Bounds of global page cache memory */ + /* Above requires no mutex. Use mutex below for variable that follow. */ + sqlite3_mutex *mutex; /* Mutex for accessing the following: */ + PgFreeslot *pFree; /* Free page blocks */ + int nFreeSlot; /* Number of unused pcache slots */ + /* The following value requires a mutex to change. We skip the mutex on + ** reading because (1) most platforms read a 32-bit integer atomically and + ** (2) even if an incorrect value is read, no great harm is done since this + ** is really just an optimization. */ + int bUnderPressure; /* True if low on PAGECACHE memory */ +} pcache1_g; + +/* +** All code in this file should access the global structure above via the +** alias "pcache1". This ensures that the WSD emulation is used when +** compiling for systems that do not support real WSD. +*/ +#define pcache1 (GLOBAL(struct PCacheGlobal, pcache1_g)) + +/* +** Macros to enter and leave the PCache LRU mutex. +*/ +#if !defined(SQLITE_ENABLE_MEMORY_MANAGEMENT) || SQLITE_THREADSAFE==0 +# define pcache1EnterMutex(X) assert((X)->mutex==0) +# define pcache1LeaveMutex(X) assert((X)->mutex==0) +# define PCACHE1_MIGHT_USE_GROUP_MUTEX 0 +#else +# define pcache1EnterMutex(X) sqlite3_mutex_enter((X)->mutex) +# define pcache1LeaveMutex(X) sqlite3_mutex_leave((X)->mutex) +# define PCACHE1_MIGHT_USE_GROUP_MUTEX 1 +#endif + +/******************************************************************************/ +/******** Page Allocation/SQLITE_CONFIG_PCACHE Related Functions **************/ + + +/* +** This function is called during initialization if a static buffer is +** supplied to use for the page-cache by passing the SQLITE_CONFIG_PAGECACHE +** verb to sqlite3_config(). Parameter pBuf points to an allocation large +** enough to contain 'n' buffers of 'sz' bytes each. +** +** This routine is called from sqlite3_initialize() and so it is guaranteed +** to be serialized already. There is no need for further mutexing. +*/ +SQLITE_PRIVATE void sqlite3PCacheBufferSetup(void *pBuf, int sz, int n){ + if( pcache1.isInit ){ + PgFreeslot *p; + if( pBuf==0 ) sz = n = 0; + if( n==0 ) sz = 0; + sz = ROUNDDOWN8(sz); + pcache1.szSlot = sz; + pcache1.nSlot = pcache1.nFreeSlot = n; + pcache1.nReserve = n>90 ? 10 : (n/10 + 1); + pcache1.pStart = pBuf; + pcache1.pFree = 0; + pcache1.bUnderPressure = 0; + while( n-- ){ + p = (PgFreeslot*)pBuf; + p->pNext = pcache1.pFree; + pcache1.pFree = p; + pBuf = (void*)&((char*)pBuf)[sz]; + } + pcache1.pEnd = pBuf; + } +} + +/* +** Try to initialize the pCache->pFree and pCache->pBulk fields. Return +** true if pCache->pFree ends up containing one or more free pages. +*/ +static int pcache1InitBulk(PCache1 *pCache){ + i64 szBulk; + char *zBulk; + if( pcache1.nInitPage==0 ) return 0; + /* Do not bother with a bulk allocation if the cache size very small */ + if( pCache->nMax<3 ) return 0; + sqlite3BeginBenignMalloc(); + if( pcache1.nInitPage>0 ){ + szBulk = pCache->szAlloc * (i64)pcache1.nInitPage; + }else{ + szBulk = -1024 * (i64)pcache1.nInitPage; + } + if( szBulk > pCache->szAlloc*(i64)pCache->nMax ){ + szBulk = pCache->szAlloc*(i64)pCache->nMax; + } + zBulk = pCache->pBulk = sqlite3Malloc( szBulk ); + sqlite3EndBenignMalloc(); + if( zBulk ){ + int nBulk = sqlite3MallocSize(zBulk)/pCache->szAlloc; + do{ + PgHdr1 *pX = (PgHdr1*)&zBulk[pCache->szPage]; + pX->page.pBuf = zBulk; + pX->page.pExtra = &pX[1]; + pX->isBulkLocal = 1; + pX->isAnchor = 0; + pX->pNext = pCache->pFree; + pX->pLruPrev = 0; /* Initializing this saves a valgrind error */ + pCache->pFree = pX; + zBulk += pCache->szAlloc; + }while( --nBulk ); + } + return pCache->pFree!=0; +} + +/* +** Malloc function used within this file to allocate space from the buffer +** configured using sqlite3_config(SQLITE_CONFIG_PAGECACHE) option. If no +** such buffer exists or there is no space left in it, this function falls +** back to sqlite3Malloc(). +** +** Multiple threads can run this routine at the same time. Global variables +** in pcache1 need to be protected via mutex. +*/ +static void *pcache1Alloc(int nByte){ + void *p = 0; + assert( sqlite3_mutex_notheld(pcache1.grp.mutex) ); + if( nByte<=pcache1.szSlot ){ + sqlite3_mutex_enter(pcache1.mutex); + p = (PgHdr1 *)pcache1.pFree; + if( p ){ + pcache1.pFree = pcache1.pFree->pNext; + pcache1.nFreeSlot--; + pcache1.bUnderPressure = pcache1.nFreeSlot=0 ); + sqlite3StatusHighwater(SQLITE_STATUS_PAGECACHE_SIZE, nByte); + sqlite3StatusUp(SQLITE_STATUS_PAGECACHE_USED, 1); + } + sqlite3_mutex_leave(pcache1.mutex); + } + if( p==0 ){ + /* Memory is not available in the SQLITE_CONFIG_PAGECACHE pool. Get + ** it from sqlite3Malloc instead. + */ + p = sqlite3Malloc(nByte); +#ifndef SQLITE_DISABLE_PAGECACHE_OVERFLOW_STATS + if( p ){ + int sz = sqlite3MallocSize(p); + sqlite3_mutex_enter(pcache1.mutex); + sqlite3StatusHighwater(SQLITE_STATUS_PAGECACHE_SIZE, nByte); + sqlite3StatusUp(SQLITE_STATUS_PAGECACHE_OVERFLOW, sz); + sqlite3_mutex_leave(pcache1.mutex); + } +#endif + sqlite3MemdebugSetType(p, MEMTYPE_PCACHE); + } + return p; +} + +/* +** Free an allocated buffer obtained from pcache1Alloc(). +*/ +static void pcache1Free(void *p){ + if( p==0 ) return; + if( SQLITE_WITHIN(p, pcache1.pStart, pcache1.pEnd) ){ + PgFreeslot *pSlot; + sqlite3_mutex_enter(pcache1.mutex); + sqlite3StatusDown(SQLITE_STATUS_PAGECACHE_USED, 1); + pSlot = (PgFreeslot*)p; + pSlot->pNext = pcache1.pFree; + pcache1.pFree = pSlot; + pcache1.nFreeSlot++; + pcache1.bUnderPressure = pcache1.nFreeSlot=pcache1.pStart && ppGroup->mutex) ); + if( pCache->pFree || (pCache->nPage==0 && pcache1InitBulk(pCache)) ){ + assert( pCache->pFree!=0 ); + p = pCache->pFree; + pCache->pFree = p->pNext; + p->pNext = 0; + }else{ +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + /* The group mutex must be released before pcache1Alloc() is called. This + ** is because it might call sqlite3_release_memory(), which assumes that + ** this mutex is not held. */ + assert( pcache1.separateCache==0 ); + assert( pCache->pGroup==&pcache1.grp ); + pcache1LeaveMutex(pCache->pGroup); +#endif + if( benignMalloc ){ sqlite3BeginBenignMalloc(); } + pPg = pcache1Alloc(pCache->szAlloc); + if( benignMalloc ){ sqlite3EndBenignMalloc(); } +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + pcache1EnterMutex(pCache->pGroup); +#endif + if( pPg==0 ) return 0; + p = (PgHdr1 *)&((u8 *)pPg)[pCache->szPage]; + p->page.pBuf = pPg; + p->page.pExtra = &p[1]; + p->isBulkLocal = 0; + p->isAnchor = 0; + p->pLruPrev = 0; /* Initializing this saves a valgrind error */ + } + (*pCache->pnPurgeable)++; + return p; +} + +/* +** Free a page object allocated by pcache1AllocPage(). +*/ +static void pcache1FreePage(PgHdr1 *p){ + PCache1 *pCache; + assert( p!=0 ); + pCache = p->pCache; + assert( sqlite3_mutex_held(p->pCache->pGroup->mutex) ); + if( p->isBulkLocal ){ + p->pNext = pCache->pFree; + pCache->pFree = p; + }else{ + pcache1Free(p->page.pBuf); + } + (*pCache->pnPurgeable)--; +} + +/* +** Malloc function used by SQLite to obtain space from the buffer configured +** using sqlite3_config(SQLITE_CONFIG_PAGECACHE) option. If no such buffer +** exists, this function falls back to sqlite3Malloc(). +*/ +SQLITE_PRIVATE void *sqlite3PageMalloc(int sz){ + assert( sz<=65536+8 ); /* These allocations are never very large */ + return pcache1Alloc(sz); +} + +/* +** Free an allocated buffer obtained from sqlite3PageMalloc(). +*/ +SQLITE_PRIVATE void sqlite3PageFree(void *p){ + pcache1Free(p); +} + + +/* +** Return true if it desirable to avoid allocating a new page cache +** entry. +** +** If memory was allocated specifically to the page cache using +** SQLITE_CONFIG_PAGECACHE but that memory has all been used, then +** it is desirable to avoid allocating a new page cache entry because +** presumably SQLITE_CONFIG_PAGECACHE was suppose to be sufficient +** for all page cache needs and we should not need to spill the +** allocation onto the heap. +** +** Or, the heap is used for all page cache memory but the heap is +** under memory pressure, then again it is desirable to avoid +** allocating a new page cache entry in order to avoid stressing +** the heap even further. +*/ +static int pcache1UnderMemoryPressure(PCache1 *pCache){ + if( pcache1.nSlot && (pCache->szPage+pCache->szExtra)<=pcache1.szSlot ){ + return pcache1.bUnderPressure; + }else{ + return sqlite3HeapNearlyFull(); + } +} + +/******************************************************************************/ +/******** General Implementation Functions ************************************/ + +/* +** This function is used to resize the hash table used by the cache passed +** as the first argument. +** +** The PCache mutex must be held when this function is called. +*/ +static void pcache1ResizeHash(PCache1 *p){ + PgHdr1 **apNew; + unsigned int nNew; + unsigned int i; + + assert( sqlite3_mutex_held(p->pGroup->mutex) ); + + nNew = p->nHash*2; + if( nNew<256 ){ + nNew = 256; + } + + pcache1LeaveMutex(p->pGroup); + if( p->nHash ){ sqlite3BeginBenignMalloc(); } + apNew = (PgHdr1 **)sqlite3MallocZero(sizeof(PgHdr1 *)*nNew); + if( p->nHash ){ sqlite3EndBenignMalloc(); } + pcache1EnterMutex(p->pGroup); + if( apNew ){ + for(i=0; inHash; i++){ + PgHdr1 *pPage; + PgHdr1 *pNext = p->apHash[i]; + while( (pPage = pNext)!=0 ){ + unsigned int h = pPage->iKey % nNew; + pNext = pPage->pNext; + pPage->pNext = apNew[h]; + apNew[h] = pPage; + } + } + sqlite3_free(p->apHash); + p->apHash = apNew; + p->nHash = nNew; + } +} + +/* +** This function is used internally to remove the page pPage from the +** PGroup LRU list, if is part of it. If pPage is not part of the PGroup +** LRU list, then this function is a no-op. +** +** The PGroup mutex must be held when this function is called. +*/ +static PgHdr1 *pcache1PinPage(PgHdr1 *pPage){ + assert( pPage!=0 ); + assert( PAGE_IS_UNPINNED(pPage) ); + assert( pPage->pLruNext ); + assert( pPage->pLruPrev ); + assert( sqlite3_mutex_held(pPage->pCache->pGroup->mutex) ); + pPage->pLruPrev->pLruNext = pPage->pLruNext; + pPage->pLruNext->pLruPrev = pPage->pLruPrev; + pPage->pLruNext = 0; + /* pPage->pLruPrev = 0; + ** No need to clear pLruPrev as it is never accessed if pLruNext is 0 */ + assert( pPage->isAnchor==0 ); + assert( pPage->pCache->pGroup->lru.isAnchor==1 ); + pPage->pCache->nRecyclable--; + return pPage; +} + + +/* +** Remove the page supplied as an argument from the hash table +** (PCache1.apHash structure) that it is currently stored in. +** Also free the page if freePage is true. +** +** The PGroup mutex must be held when this function is called. +*/ +static void pcache1RemoveFromHash(PgHdr1 *pPage, int freeFlag){ + unsigned int h; + PCache1 *pCache = pPage->pCache; + PgHdr1 **pp; + + assert( sqlite3_mutex_held(pCache->pGroup->mutex) ); + h = pPage->iKey % pCache->nHash; + for(pp=&pCache->apHash[h]; (*pp)!=pPage; pp=&(*pp)->pNext); + *pp = (*pp)->pNext; + + pCache->nPage--; + if( freeFlag ) pcache1FreePage(pPage); +} + +/* +** If there are currently more than nMaxPage pages allocated, try +** to recycle pages to reduce the number allocated to nMaxPage. +*/ +static void pcache1EnforceMaxPage(PCache1 *pCache){ + PGroup *pGroup = pCache->pGroup; + PgHdr1 *p; + assert( sqlite3_mutex_held(pGroup->mutex) ); + while( pGroup->nPurgeable>pGroup->nMaxPage + && (p=pGroup->lru.pLruPrev)->isAnchor==0 + ){ + assert( p->pCache->pGroup==pGroup ); + assert( PAGE_IS_UNPINNED(p) ); + pcache1PinPage(p); + pcache1RemoveFromHash(p, 1); + } + if( pCache->nPage==0 && pCache->pBulk ){ + sqlite3_free(pCache->pBulk); + pCache->pBulk = pCache->pFree = 0; + } +} + +/* +** Discard all pages from cache pCache with a page number (key value) +** greater than or equal to iLimit. Any pinned pages that meet this +** criteria are unpinned before they are discarded. +** +** The PCache mutex must be held when this function is called. +*/ +static void pcache1TruncateUnsafe( + PCache1 *pCache, /* The cache to truncate */ + unsigned int iLimit /* Drop pages with this pgno or larger */ +){ + TESTONLY( int nPage = 0; ) /* To assert pCache->nPage is correct */ + unsigned int h, iStop; + assert( sqlite3_mutex_held(pCache->pGroup->mutex) ); + assert( pCache->iMaxKey >= iLimit ); + assert( pCache->nHash > 0 ); + if( pCache->iMaxKey - iLimit < pCache->nHash ){ + /* If we are just shaving the last few pages off the end of the + ** cache, then there is no point in scanning the entire hash table. + ** Only scan those hash slots that might contain pages that need to + ** be removed. */ + h = iLimit % pCache->nHash; + iStop = pCache->iMaxKey % pCache->nHash; + TESTONLY( nPage = -10; ) /* Disable the pCache->nPage validity check */ + }else{ + /* This is the general case where many pages are being removed. + ** It is necessary to scan the entire hash table */ + h = pCache->nHash/2; + iStop = h - 1; + } + for(;;){ + PgHdr1 **pp; + PgHdr1 *pPage; + assert( hnHash ); + pp = &pCache->apHash[h]; + while( (pPage = *pp)!=0 ){ + if( pPage->iKey>=iLimit ){ + pCache->nPage--; + *pp = pPage->pNext; + if( PAGE_IS_UNPINNED(pPage) ) pcache1PinPage(pPage); + pcache1FreePage(pPage); + }else{ + pp = &pPage->pNext; + TESTONLY( if( nPage>=0 ) nPage++; ) + } + } + if( h==iStop ) break; + h = (h+1) % pCache->nHash; + } + assert( nPage<0 || pCache->nPage==(unsigned)nPage ); +} + +/******************************************************************************/ +/******** sqlite3_pcache Methods **********************************************/ + +/* +** Implementation of the sqlite3_pcache.xInit method. +*/ +static int pcache1Init(void *NotUsed){ + UNUSED_PARAMETER(NotUsed); + assert( pcache1.isInit==0 ); + memset(&pcache1, 0, sizeof(pcache1)); + + + /* + ** The pcache1.separateCache variable is true if each PCache has its own + ** private PGroup (mode-1). pcache1.separateCache is false if the single + ** PGroup in pcache1.grp is used for all page caches (mode-2). + ** + ** * Always use a unified cache (mode-2) if ENABLE_MEMORY_MANAGEMENT + ** + ** * Use a unified cache in single-threaded applications that have + ** configured a start-time buffer for use as page-cache memory using + ** sqlite3_config(SQLITE_CONFIG_PAGECACHE, pBuf, sz, N) with non-NULL + ** pBuf argument. + ** + ** * Otherwise use separate caches (mode-1) + */ +#if defined(SQLITE_ENABLE_MEMORY_MANAGEMENT) + pcache1.separateCache = 0; +#elif SQLITE_THREADSAFE + pcache1.separateCache = sqlite3GlobalConfig.pPage==0 + || sqlite3GlobalConfig.bCoreMutex>0; +#else + pcache1.separateCache = sqlite3GlobalConfig.pPage==0; +#endif + +#if SQLITE_THREADSAFE + if( sqlite3GlobalConfig.bCoreMutex ){ + pcache1.grp.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU); + pcache1.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_PMEM); + } +#endif + if( pcache1.separateCache + && sqlite3GlobalConfig.nPage!=0 + && sqlite3GlobalConfig.pPage==0 + ){ + pcache1.nInitPage = sqlite3GlobalConfig.nPage; + }else{ + pcache1.nInitPage = 0; + } + pcache1.grp.mxPinned = 10; + pcache1.isInit = 1; + return SQLITE_OK; +} + +/* +** Implementation of the sqlite3_pcache.xShutdown method. +** Note that the static mutex allocated in xInit does +** not need to be freed. +*/ +static void pcache1Shutdown(void *NotUsed){ + UNUSED_PARAMETER(NotUsed); + assert( pcache1.isInit!=0 ); + memset(&pcache1, 0, sizeof(pcache1)); +} + +/* forward declaration */ +static void pcache1Destroy(sqlite3_pcache *p); + +/* +** Implementation of the sqlite3_pcache.xCreate method. +** +** Allocate a new cache. +*/ +static sqlite3_pcache *pcache1Create(int szPage, int szExtra, int bPurgeable){ + PCache1 *pCache; /* The newly created page cache */ + PGroup *pGroup; /* The group the new page cache will belong to */ + int sz; /* Bytes of memory required to allocate the new cache */ + + assert( (szPage & (szPage-1))==0 && szPage>=512 && szPage<=65536 ); + assert( szExtra < 300 ); + + sz = sizeof(PCache1) + sizeof(PGroup)*pcache1.separateCache; + pCache = (PCache1 *)sqlite3MallocZero(sz); + if( pCache ){ + if( pcache1.separateCache ){ + pGroup = (PGroup*)&pCache[1]; + pGroup->mxPinned = 10; + }else{ + pGroup = &pcache1.grp; + } + pcache1EnterMutex(pGroup); + if( pGroup->lru.isAnchor==0 ){ + pGroup->lru.isAnchor = 1; + pGroup->lru.pLruPrev = pGroup->lru.pLruNext = &pGroup->lru; + } + pCache->pGroup = pGroup; + pCache->szPage = szPage; + pCache->szExtra = szExtra; + pCache->szAlloc = szPage + szExtra + ROUND8(sizeof(PgHdr1)); + pCache->bPurgeable = (bPurgeable ? 1 : 0); + pcache1ResizeHash(pCache); + if( bPurgeable ){ + pCache->nMin = 10; + pGroup->nMinPage += pCache->nMin; + pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage; + pCache->pnPurgeable = &pGroup->nPurgeable; + }else{ + pCache->pnPurgeable = &pCache->nPurgeableDummy; + } + pcache1LeaveMutex(pGroup); + if( pCache->nHash==0 ){ + pcache1Destroy((sqlite3_pcache*)pCache); + pCache = 0; + } + } + return (sqlite3_pcache *)pCache; +} + +/* +** Implementation of the sqlite3_pcache.xCachesize method. +** +** Configure the cache_size limit for a cache. +*/ +static void pcache1Cachesize(sqlite3_pcache *p, int nMax){ + PCache1 *pCache = (PCache1 *)p; + u32 n; + assert( nMax>=0 ); + if( pCache->bPurgeable ){ + PGroup *pGroup = pCache->pGroup; + pcache1EnterMutex(pGroup); + n = (u32)nMax; + if( n > 0x7fff0000 - pGroup->nMaxPage + pCache->nMax ){ + n = 0x7fff0000 - pGroup->nMaxPage + pCache->nMax; + } + pGroup->nMaxPage += (n - pCache->nMax); + pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage; + pCache->nMax = n; + pCache->n90pct = pCache->nMax*9/10; + pcache1EnforceMaxPage(pCache); + pcache1LeaveMutex(pGroup); + } +} + +/* +** Implementation of the sqlite3_pcache.xShrink method. +** +** Free up as much memory as possible. +*/ +static void pcache1Shrink(sqlite3_pcache *p){ + PCache1 *pCache = (PCache1*)p; + if( pCache->bPurgeable ){ + PGroup *pGroup = pCache->pGroup; + unsigned int savedMaxPage; + pcache1EnterMutex(pGroup); + savedMaxPage = pGroup->nMaxPage; + pGroup->nMaxPage = 0; + pcache1EnforceMaxPage(pCache); + pGroup->nMaxPage = savedMaxPage; + pcache1LeaveMutex(pGroup); + } +} + +/* +** Implementation of the sqlite3_pcache.xPagecount method. +*/ +static int pcache1Pagecount(sqlite3_pcache *p){ + int n; + PCache1 *pCache = (PCache1*)p; + pcache1EnterMutex(pCache->pGroup); + n = pCache->nPage; + pcache1LeaveMutex(pCache->pGroup); + return n; +} + + +/* +** Implement steps 3, 4, and 5 of the pcache1Fetch() algorithm described +** in the header of the pcache1Fetch() procedure. +** +** This steps are broken out into a separate procedure because they are +** usually not needed, and by avoiding the stack initialization required +** for these steps, the main pcache1Fetch() procedure can run faster. +*/ +static SQLITE_NOINLINE PgHdr1 *pcache1FetchStage2( + PCache1 *pCache, + unsigned int iKey, + int createFlag +){ + unsigned int nPinned; + PGroup *pGroup = pCache->pGroup; + PgHdr1 *pPage = 0; + + /* Step 3: Abort if createFlag is 1 but the cache is nearly full */ + assert( pCache->nPage >= pCache->nRecyclable ); + nPinned = pCache->nPage - pCache->nRecyclable; + assert( pGroup->mxPinned == pGroup->nMaxPage + 10 - pGroup->nMinPage ); + assert( pCache->n90pct == pCache->nMax*9/10 ); + if( createFlag==1 && ( + nPinned>=pGroup->mxPinned + || nPinned>=pCache->n90pct + || (pcache1UnderMemoryPressure(pCache) && pCache->nRecyclablenPage>=pCache->nHash ) pcache1ResizeHash(pCache); + assert( pCache->nHash>0 && pCache->apHash ); + + /* Step 4. Try to recycle a page. */ + if( pCache->bPurgeable + && !pGroup->lru.pLruPrev->isAnchor + && ((pCache->nPage+1>=pCache->nMax) || pcache1UnderMemoryPressure(pCache)) + ){ + PCache1 *pOther; + pPage = pGroup->lru.pLruPrev; + assert( PAGE_IS_UNPINNED(pPage) ); + pcache1RemoveFromHash(pPage, 0); + pcache1PinPage(pPage); + pOther = pPage->pCache; + if( pOther->szAlloc != pCache->szAlloc ){ + pcache1FreePage(pPage); + pPage = 0; + }else{ + pGroup->nPurgeable -= (pOther->bPurgeable - pCache->bPurgeable); + } + } + + /* Step 5. If a usable page buffer has still not been found, + ** attempt to allocate a new one. + */ + if( !pPage ){ + pPage = pcache1AllocPage(pCache, createFlag==1); + } + + if( pPage ){ + unsigned int h = iKey % pCache->nHash; + pCache->nPage++; + pPage->iKey = iKey; + pPage->pNext = pCache->apHash[h]; + pPage->pCache = pCache; + pPage->pLruNext = 0; + /* pPage->pLruPrev = 0; + ** No need to clear pLruPrev since it is not accessed when pLruNext==0 */ + *(void **)pPage->page.pExtra = 0; + pCache->apHash[h] = pPage; + if( iKey>pCache->iMaxKey ){ + pCache->iMaxKey = iKey; + } + } + return pPage; +} + +/* +** Implementation of the sqlite3_pcache.xFetch method. +** +** Fetch a page by key value. +** +** Whether or not a new page may be allocated by this function depends on +** the value of the createFlag argument. 0 means do not allocate a new +** page. 1 means allocate a new page if space is easily available. 2 +** means to try really hard to allocate a new page. +** +** For a non-purgeable cache (a cache used as the storage for an in-memory +** database) there is really no difference between createFlag 1 and 2. So +** the calling function (pcache.c) will never have a createFlag of 1 on +** a non-purgeable cache. +** +** There are three different approaches to obtaining space for a page, +** depending on the value of parameter createFlag (which may be 0, 1 or 2). +** +** 1. Regardless of the value of createFlag, the cache is searched for a +** copy of the requested page. If one is found, it is returned. +** +** 2. If createFlag==0 and the page is not already in the cache, NULL is +** returned. +** +** 3. If createFlag is 1, and the page is not already in the cache, then +** return NULL (do not allocate a new page) if any of the following +** conditions are true: +** +** (a) the number of pages pinned by the cache is greater than +** PCache1.nMax, or +** +** (b) the number of pages pinned by the cache is greater than +** the sum of nMax for all purgeable caches, less the sum of +** nMin for all other purgeable caches, or +** +** 4. If none of the first three conditions apply and the cache is marked +** as purgeable, and if one of the following is true: +** +** (a) The number of pages allocated for the cache is already +** PCache1.nMax, or +** +** (b) The number of pages allocated for all purgeable caches is +** already equal to or greater than the sum of nMax for all +** purgeable caches, +** +** (c) The system is under memory pressure and wants to avoid +** unnecessary pages cache entry allocations +** +** then attempt to recycle a page from the LRU list. If it is the right +** size, return the recycled buffer. Otherwise, free the buffer and +** proceed to step 5. +** +** 5. Otherwise, allocate and return a new page buffer. +** +** There are two versions of this routine. pcache1FetchWithMutex() is +** the general case. pcache1FetchNoMutex() is a faster implementation for +** the common case where pGroup->mutex is NULL. The pcache1Fetch() wrapper +** invokes the appropriate routine. +*/ +static PgHdr1 *pcache1FetchNoMutex( + sqlite3_pcache *p, + unsigned int iKey, + int createFlag +){ + PCache1 *pCache = (PCache1 *)p; + PgHdr1 *pPage = 0; + + /* Step 1: Search the hash table for an existing entry. */ + pPage = pCache->apHash[iKey % pCache->nHash]; + while( pPage && pPage->iKey!=iKey ){ pPage = pPage->pNext; } + + /* Step 2: If the page was found in the hash table, then return it. + ** If the page was not in the hash table and createFlag is 0, abort. + ** Otherwise (page not in hash and createFlag!=0) continue with + ** subsequent steps to try to create the page. */ + if( pPage ){ + if( PAGE_IS_UNPINNED(pPage) ){ + return pcache1PinPage(pPage); + }else{ + return pPage; + } + }else if( createFlag ){ + /* Steps 3, 4, and 5 implemented by this subroutine */ + return pcache1FetchStage2(pCache, iKey, createFlag); + }else{ + return 0; + } +} +#if PCACHE1_MIGHT_USE_GROUP_MUTEX +static PgHdr1 *pcache1FetchWithMutex( + sqlite3_pcache *p, + unsigned int iKey, + int createFlag +){ + PCache1 *pCache = (PCache1 *)p; + PgHdr1 *pPage; + + pcache1EnterMutex(pCache->pGroup); + pPage = pcache1FetchNoMutex(p, iKey, createFlag); + assert( pPage==0 || pCache->iMaxKey>=iKey ); + pcache1LeaveMutex(pCache->pGroup); + return pPage; +} +#endif +static sqlite3_pcache_page *pcache1Fetch( + sqlite3_pcache *p, + unsigned int iKey, + int createFlag +){ +#if PCACHE1_MIGHT_USE_GROUP_MUTEX || defined(SQLITE_DEBUG) + PCache1 *pCache = (PCache1 *)p; +#endif + + assert( offsetof(PgHdr1,page)==0 ); + assert( pCache->bPurgeable || createFlag!=1 ); + assert( pCache->bPurgeable || pCache->nMin==0 ); + assert( pCache->bPurgeable==0 || pCache->nMin==10 ); + assert( pCache->nMin==0 || pCache->bPurgeable ); + assert( pCache->nHash>0 ); +#if PCACHE1_MIGHT_USE_GROUP_MUTEX + if( pCache->pGroup->mutex ){ + return (sqlite3_pcache_page*)pcache1FetchWithMutex(p, iKey, createFlag); + }else +#endif + { + return (sqlite3_pcache_page*)pcache1FetchNoMutex(p, iKey, createFlag); + } +} + + +/* +** Implementation of the sqlite3_pcache.xUnpin method. +** +** Mark a page as unpinned (eligible for asynchronous recycling). +*/ +static void pcache1Unpin( + sqlite3_pcache *p, + sqlite3_pcache_page *pPg, + int reuseUnlikely +){ + PCache1 *pCache = (PCache1 *)p; + PgHdr1 *pPage = (PgHdr1 *)pPg; + PGroup *pGroup = pCache->pGroup; + + assert( pPage->pCache==pCache ); + pcache1EnterMutex(pGroup); + + /* It is an error to call this function if the page is already + ** part of the PGroup LRU list. + */ + assert( pPage->pLruNext==0 ); + assert( PAGE_IS_PINNED(pPage) ); + + if( reuseUnlikely || pGroup->nPurgeable>pGroup->nMaxPage ){ + pcache1RemoveFromHash(pPage, 1); + }else{ + /* Add the page to the PGroup LRU list. */ + PgHdr1 **ppFirst = &pGroup->lru.pLruNext; + pPage->pLruPrev = &pGroup->lru; + (pPage->pLruNext = *ppFirst)->pLruPrev = pPage; + *ppFirst = pPage; + pCache->nRecyclable++; + } + + pcache1LeaveMutex(pCache->pGroup); +} + +/* +** Implementation of the sqlite3_pcache.xRekey method. +*/ +static void pcache1Rekey( + sqlite3_pcache *p, + sqlite3_pcache_page *pPg, + unsigned int iOld, + unsigned int iNew +){ + PCache1 *pCache = (PCache1 *)p; + PgHdr1 *pPage = (PgHdr1 *)pPg; + PgHdr1 **pp; + unsigned int hOld, hNew; + assert( pPage->iKey==iOld ); + assert( pPage->pCache==pCache ); + assert( iOld!=iNew ); /* The page number really is changing */ + + pcache1EnterMutex(pCache->pGroup); + + assert( pcache1FetchNoMutex(p, iOld, 0)==pPage ); /* pPg really is iOld */ + hOld = iOld%pCache->nHash; + pp = &pCache->apHash[hOld]; + while( (*pp)!=pPage ){ + pp = &(*pp)->pNext; + } + *pp = pPage->pNext; + + assert( pcache1FetchNoMutex(p, iNew, 0)==0 ); /* iNew not in cache */ + hNew = iNew%pCache->nHash; + pPage->iKey = iNew; + pPage->pNext = pCache->apHash[hNew]; + pCache->apHash[hNew] = pPage; + if( iNew>pCache->iMaxKey ){ + pCache->iMaxKey = iNew; + } + + pcache1LeaveMutex(pCache->pGroup); +} + +/* +** Implementation of the sqlite3_pcache.xTruncate method. +** +** Discard all unpinned pages in the cache with a page number equal to +** or greater than parameter iLimit. Any pinned pages with a page number +** equal to or greater than iLimit are implicitly unpinned. +*/ +static void pcache1Truncate(sqlite3_pcache *p, unsigned int iLimit){ + PCache1 *pCache = (PCache1 *)p; + pcache1EnterMutex(pCache->pGroup); + if( iLimit<=pCache->iMaxKey ){ + pcache1TruncateUnsafe(pCache, iLimit); + pCache->iMaxKey = iLimit-1; + } + pcache1LeaveMutex(pCache->pGroup); +} + +/* +** Implementation of the sqlite3_pcache.xDestroy method. +** +** Destroy a cache allocated using pcache1Create(). +*/ +static void pcache1Destroy(sqlite3_pcache *p){ + PCache1 *pCache = (PCache1 *)p; + PGroup *pGroup = pCache->pGroup; + assert( pCache->bPurgeable || (pCache->nMax==0 && pCache->nMin==0) ); + pcache1EnterMutex(pGroup); + if( pCache->nPage ) pcache1TruncateUnsafe(pCache, 0); + assert( pGroup->nMaxPage >= pCache->nMax ); + pGroup->nMaxPage -= pCache->nMax; + assert( pGroup->nMinPage >= pCache->nMin ); + pGroup->nMinPage -= pCache->nMin; + pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage; + pcache1EnforceMaxPage(pCache); + pcache1LeaveMutex(pGroup); + sqlite3_free(pCache->pBulk); + sqlite3_free(pCache->apHash); + sqlite3_free(pCache); +} + +/* +** This function is called during initialization (sqlite3_initialize()) to +** install the default pluggable cache module, assuming the user has not +** already provided an alternative. +*/ +SQLITE_PRIVATE void sqlite3PCacheSetDefault(void){ + static const sqlite3_pcache_methods2 defaultMethods = { + 1, /* iVersion */ + 0, /* pArg */ + pcache1Init, /* xInit */ + pcache1Shutdown, /* xShutdown */ + pcache1Create, /* xCreate */ + pcache1Cachesize, /* xCachesize */ + pcache1Pagecount, /* xPagecount */ + pcache1Fetch, /* xFetch */ + pcache1Unpin, /* xUnpin */ + pcache1Rekey, /* xRekey */ + pcache1Truncate, /* xTruncate */ + pcache1Destroy, /* xDestroy */ + pcache1Shrink /* xShrink */ + }; + sqlite3_config(SQLITE_CONFIG_PCACHE2, &defaultMethods); +} + +/* +** Return the size of the header on each page of this PCACHE implementation. +*/ +SQLITE_PRIVATE int sqlite3HeaderSizePcache1(void){ return ROUND8(sizeof(PgHdr1)); } + +/* +** Return the global mutex used by this PCACHE implementation. The +** sqlite3_status() routine needs access to this mutex. +*/ +SQLITE_PRIVATE sqlite3_mutex *sqlite3Pcache1Mutex(void){ + return pcache1.mutex; +} + +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT +/* +** This function is called to free superfluous dynamically allocated memory +** held by the pager system. Memory in use by any SQLite pager allocated +** by the current thread may be sqlite3_free()ed. +** +** nReq is the number of bytes of memory required. Once this much has +** been released, the function returns. The return value is the total number +** of bytes of memory released. +*/ +SQLITE_PRIVATE int sqlite3PcacheReleaseMemory(int nReq){ + int nFree = 0; + assert( sqlite3_mutex_notheld(pcache1.grp.mutex) ); + assert( sqlite3_mutex_notheld(pcache1.mutex) ); + if( sqlite3GlobalConfig.pPage==0 ){ + PgHdr1 *p; + pcache1EnterMutex(&pcache1.grp); + while( (nReq<0 || nFreeisAnchor==0 + ){ + nFree += pcache1MemSize(p->page.pBuf); + assert( PAGE_IS_UNPINNED(p) ); + pcache1PinPage(p); + pcache1RemoveFromHash(p, 1); + } + pcache1LeaveMutex(&pcache1.grp); + } + return nFree; +} +#endif /* SQLITE_ENABLE_MEMORY_MANAGEMENT */ + +#ifdef SQLITE_TEST +/* +** This function is used by test procedures to inspect the internal state +** of the global cache. +*/ +SQLITE_PRIVATE void sqlite3PcacheStats( + int *pnCurrent, /* OUT: Total number of pages cached */ + int *pnMax, /* OUT: Global maximum cache size */ + int *pnMin, /* OUT: Sum of PCache1.nMin for purgeable caches */ + int *pnRecyclable /* OUT: Total number of pages available for recycling */ +){ + PgHdr1 *p; + int nRecyclable = 0; + for(p=pcache1.grp.lru.pLruNext; p && !p->isAnchor; p=p->pLruNext){ + assert( PAGE_IS_UNPINNED(p) ); + nRecyclable++; + } + *pnCurrent = pcache1.grp.nPurgeable; + *pnMax = (int)pcache1.grp.nMaxPage; + *pnMin = (int)pcache1.grp.nMinPage; + *pnRecyclable = nRecyclable; +} +#endif + +/************** End of pcache1.c *********************************************/ +/************** Begin file rowset.c ******************************************/ +/* +** 2008 December 3 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This module implements an object we call a "RowSet". +** +** The RowSet object is a collection of rowids. Rowids +** are inserted into the RowSet in an arbitrary order. Inserts +** can be intermixed with tests to see if a given rowid has been +** previously inserted into the RowSet. +** +** After all inserts are finished, it is possible to extract the +** elements of the RowSet in sorted order. Once this extraction +** process has started, no new elements may be inserted. +** +** Hence, the primitive operations for a RowSet are: +** +** CREATE +** INSERT +** TEST +** SMALLEST +** DESTROY +** +** The CREATE and DESTROY primitives are the constructor and destructor, +** obviously. The INSERT primitive adds a new element to the RowSet. +** TEST checks to see if an element is already in the RowSet. SMALLEST +** extracts the least value from the RowSet. +** +** The INSERT primitive might allocate additional memory. Memory is +** allocated in chunks so most INSERTs do no allocation. There is an +** upper bound on the size of allocated memory. No memory is freed +** until DESTROY. +** +** The TEST primitive includes a "batch" number. The TEST primitive +** will only see elements that were inserted before the last change +** in the batch number. In other words, if an INSERT occurs between +** two TESTs where the TESTs have the same batch nubmer, then the +** value added by the INSERT will not be visible to the second TEST. +** The initial batch number is zero, so if the very first TEST contains +** a non-zero batch number, it will see all prior INSERTs. +** +** No INSERTs may occurs after a SMALLEST. An assertion will fail if +** that is attempted. +** +** The cost of an INSERT is roughly constant. (Sometimes new memory +** has to be allocated on an INSERT.) The cost of a TEST with a new +** batch number is O(NlogN) where N is the number of elements in the RowSet. +** The cost of a TEST using the same batch number is O(logN). The cost +** of the first SMALLEST is O(NlogN). Second and subsequent SMALLEST +** primitives are constant time. The cost of DESTROY is O(N). +** +** TEST and SMALLEST may not be used by the same RowSet. This used to +** be possible, but the feature was not used, so it was removed in order +** to simplify the code. +*/ +/* #include "sqliteInt.h" */ + + +/* +** Target size for allocation chunks. +*/ +#define ROWSET_ALLOCATION_SIZE 1024 + +/* +** The number of rowset entries per allocation chunk. +*/ +#define ROWSET_ENTRY_PER_CHUNK \ + ((ROWSET_ALLOCATION_SIZE-8)/sizeof(struct RowSetEntry)) + +/* +** Each entry in a RowSet is an instance of the following object. +** +** This same object is reused to store a linked list of trees of RowSetEntry +** objects. In that alternative use, pRight points to the next entry +** in the list, pLeft points to the tree, and v is unused. The +** RowSet.pForest value points to the head of this forest list. +*/ +struct RowSetEntry { + i64 v; /* ROWID value for this entry */ + struct RowSetEntry *pRight; /* Right subtree (larger entries) or list */ + struct RowSetEntry *pLeft; /* Left subtree (smaller entries) */ +}; + +/* +** RowSetEntry objects are allocated in large chunks (instances of the +** following structure) to reduce memory allocation overhead. The +** chunks are kept on a linked list so that they can be deallocated +** when the RowSet is destroyed. +*/ +struct RowSetChunk { + struct RowSetChunk *pNextChunk; /* Next chunk on list of them all */ + struct RowSetEntry aEntry[ROWSET_ENTRY_PER_CHUNK]; /* Allocated entries */ +}; + +/* +** A RowSet in an instance of the following structure. +** +** A typedef of this structure if found in sqliteInt.h. +*/ +struct RowSet { + struct RowSetChunk *pChunk; /* List of all chunk allocations */ + sqlite3 *db; /* The database connection */ + struct RowSetEntry *pEntry; /* List of entries using pRight */ + struct RowSetEntry *pLast; /* Last entry on the pEntry list */ + struct RowSetEntry *pFresh; /* Source of new entry objects */ + struct RowSetEntry *pForest; /* List of binary trees of entries */ + u16 nFresh; /* Number of objects on pFresh */ + u16 rsFlags; /* Various flags */ + int iBatch; /* Current insert batch */ +}; + +/* +** Allowed values for RowSet.rsFlags +*/ +#define ROWSET_SORTED 0x01 /* True if RowSet.pEntry is sorted */ +#define ROWSET_NEXT 0x02 /* True if sqlite3RowSetNext() has been called */ + +/* +** Allocate a RowSet object. Return NULL if a memory allocation +** error occurs. +*/ +SQLITE_PRIVATE RowSet *sqlite3RowSetInit(sqlite3 *db){ + RowSet *p = sqlite3DbMallocRawNN(db, sizeof(*p)); + if( p ){ + int N = sqlite3DbMallocSize(db, p); + p->pChunk = 0; + p->db = db; + p->pEntry = 0; + p->pLast = 0; + p->pForest = 0; + p->pFresh = (struct RowSetEntry*)(ROUND8(sizeof(*p)) + (char*)p); + p->nFresh = (u16)((N - ROUND8(sizeof(*p)))/sizeof(struct RowSetEntry)); + p->rsFlags = ROWSET_SORTED; + p->iBatch = 0; + } + return p; +} + +/* +** Deallocate all chunks from a RowSet. This frees all memory that +** the RowSet has allocated over its lifetime. This routine is +** the destructor for the RowSet. +*/ +SQLITE_PRIVATE void sqlite3RowSetClear(void *pArg){ + RowSet *p = (RowSet*)pArg; + struct RowSetChunk *pChunk, *pNextChunk; + for(pChunk=p->pChunk; pChunk; pChunk = pNextChunk){ + pNextChunk = pChunk->pNextChunk; + sqlite3DbFree(p->db, pChunk); + } + p->pChunk = 0; + p->nFresh = 0; + p->pEntry = 0; + p->pLast = 0; + p->pForest = 0; + p->rsFlags = ROWSET_SORTED; +} + +/* +** Deallocate all chunks from a RowSet. This frees all memory that +** the RowSet has allocated over its lifetime. This routine is +** the destructor for the RowSet. +*/ +SQLITE_PRIVATE void sqlite3RowSetDelete(void *pArg){ + sqlite3RowSetClear(pArg); + sqlite3DbFree(((RowSet*)pArg)->db, pArg); +} + +/* +** Allocate a new RowSetEntry object that is associated with the +** given RowSet. Return a pointer to the new and completely uninitialized +** object. +** +** In an OOM situation, the RowSet.db->mallocFailed flag is set and this +** routine returns NULL. +*/ +static struct RowSetEntry *rowSetEntryAlloc(RowSet *p){ + assert( p!=0 ); + if( p->nFresh==0 ){ /*OPTIMIZATION-IF-FALSE*/ + /* We could allocate a fresh RowSetEntry each time one is needed, but it + ** is more efficient to pull a preallocated entry from the pool */ + struct RowSetChunk *pNew; + pNew = sqlite3DbMallocRawNN(p->db, sizeof(*pNew)); + if( pNew==0 ){ + return 0; + } + pNew->pNextChunk = p->pChunk; + p->pChunk = pNew; + p->pFresh = pNew->aEntry; + p->nFresh = ROWSET_ENTRY_PER_CHUNK; + } + p->nFresh--; + return p->pFresh++; +} + +/* +** Insert a new value into a RowSet. +** +** The mallocFailed flag of the database connection is set if a +** memory allocation fails. +*/ +SQLITE_PRIVATE void sqlite3RowSetInsert(RowSet *p, i64 rowid){ + struct RowSetEntry *pEntry; /* The new entry */ + struct RowSetEntry *pLast; /* The last prior entry */ + + /* This routine is never called after sqlite3RowSetNext() */ + assert( p!=0 && (p->rsFlags & ROWSET_NEXT)==0 ); + + pEntry = rowSetEntryAlloc(p); + if( pEntry==0 ) return; + pEntry->v = rowid; + pEntry->pRight = 0; + pLast = p->pLast; + if( pLast ){ + if( rowid<=pLast->v ){ /*OPTIMIZATION-IF-FALSE*/ + /* Avoid unnecessary sorts by preserving the ROWSET_SORTED flags + ** where possible */ + p->rsFlags &= ~ROWSET_SORTED; + } + pLast->pRight = pEntry; + }else{ + p->pEntry = pEntry; + } + p->pLast = pEntry; +} + +/* +** Merge two lists of RowSetEntry objects. Remove duplicates. +** +** The input lists are connected via pRight pointers and are +** assumed to each already be in sorted order. +*/ +static struct RowSetEntry *rowSetEntryMerge( + struct RowSetEntry *pA, /* First sorted list to be merged */ + struct RowSetEntry *pB /* Second sorted list to be merged */ +){ + struct RowSetEntry head; + struct RowSetEntry *pTail; + + pTail = &head; + assert( pA!=0 && pB!=0 ); + for(;;){ + assert( pA->pRight==0 || pA->v<=pA->pRight->v ); + assert( pB->pRight==0 || pB->v<=pB->pRight->v ); + if( pA->v<=pB->v ){ + if( pA->vv ) pTail = pTail->pRight = pA; + pA = pA->pRight; + if( pA==0 ){ + pTail->pRight = pB; + break; + } + }else{ + pTail = pTail->pRight = pB; + pB = pB->pRight; + if( pB==0 ){ + pTail->pRight = pA; + break; + } + } + } + return head.pRight; +} + +/* +** Sort all elements on the list of RowSetEntry objects into order of +** increasing v. +*/ +static struct RowSetEntry *rowSetEntrySort(struct RowSetEntry *pIn){ + unsigned int i; + struct RowSetEntry *pNext, *aBucket[40]; + + memset(aBucket, 0, sizeof(aBucket)); + while( pIn ){ + pNext = pIn->pRight; + pIn->pRight = 0; + for(i=0; aBucket[i]; i++){ + pIn = rowSetEntryMerge(aBucket[i], pIn); + aBucket[i] = 0; + } + aBucket[i] = pIn; + pIn = pNext; + } + pIn = aBucket[0]; + for(i=1; ipLeft ){ + struct RowSetEntry *p; + rowSetTreeToList(pIn->pLeft, ppFirst, &p); + p->pRight = pIn; + }else{ + *ppFirst = pIn; + } + if( pIn->pRight ){ + rowSetTreeToList(pIn->pRight, &pIn->pRight, ppLast); + }else{ + *ppLast = pIn; + } + assert( (*ppLast)->pRight==0 ); +} + + +/* +** Convert a sorted list of elements (connected by pRight) into a binary +** tree with depth of iDepth. A depth of 1 means the tree contains a single +** node taken from the head of *ppList. A depth of 2 means a tree with +** three nodes. And so forth. +** +** Use as many entries from the input list as required and update the +** *ppList to point to the unused elements of the list. If the input +** list contains too few elements, then construct an incomplete tree +** and leave *ppList set to NULL. +** +** Return a pointer to the root of the constructed binary tree. +*/ +static struct RowSetEntry *rowSetNDeepTree( + struct RowSetEntry **ppList, + int iDepth +){ + struct RowSetEntry *p; /* Root of the new tree */ + struct RowSetEntry *pLeft; /* Left subtree */ + if( *ppList==0 ){ /*OPTIMIZATION-IF-TRUE*/ + /* Prevent unnecessary deep recursion when we run out of entries */ + return 0; + } + if( iDepth>1 ){ /*OPTIMIZATION-IF-TRUE*/ + /* This branch causes a *balanced* tree to be generated. A valid tree + ** is still generated without this branch, but the tree is wildly + ** unbalanced and inefficient. */ + pLeft = rowSetNDeepTree(ppList, iDepth-1); + p = *ppList; + if( p==0 ){ /*OPTIMIZATION-IF-FALSE*/ + /* It is safe to always return here, but the resulting tree + ** would be unbalanced */ + return pLeft; + } + p->pLeft = pLeft; + *ppList = p->pRight; + p->pRight = rowSetNDeepTree(ppList, iDepth-1); + }else{ + p = *ppList; + *ppList = p->pRight; + p->pLeft = p->pRight = 0; + } + return p; +} + +/* +** Convert a sorted list of elements into a binary tree. Make the tree +** as deep as it needs to be in order to contain the entire list. +*/ +static struct RowSetEntry *rowSetListToTree(struct RowSetEntry *pList){ + int iDepth; /* Depth of the tree so far */ + struct RowSetEntry *p; /* Current tree root */ + struct RowSetEntry *pLeft; /* Left subtree */ + + assert( pList!=0 ); + p = pList; + pList = p->pRight; + p->pLeft = p->pRight = 0; + for(iDepth=1; pList; iDepth++){ + pLeft = p; + p = pList; + pList = p->pRight; + p->pLeft = pLeft; + p->pRight = rowSetNDeepTree(&pList, iDepth); + } + return p; +} + +/* +** Extract the smallest element from the RowSet. +** Write the element into *pRowid. Return 1 on success. Return +** 0 if the RowSet is already empty. +** +** After this routine has been called, the sqlite3RowSetInsert() +** routine may not be called again. +** +** This routine may not be called after sqlite3RowSetTest() has +** been used. Older versions of RowSet allowed that, but as the +** capability was not used by the code generator, it was removed +** for code economy. +*/ +SQLITE_PRIVATE int sqlite3RowSetNext(RowSet *p, i64 *pRowid){ + assert( p!=0 ); + assert( p->pForest==0 ); /* Cannot be used with sqlite3RowSetText() */ + + /* Merge the forest into a single sorted list on first call */ + if( (p->rsFlags & ROWSET_NEXT)==0 ){ /*OPTIMIZATION-IF-FALSE*/ + if( (p->rsFlags & ROWSET_SORTED)==0 ){ /*OPTIMIZATION-IF-FALSE*/ + p->pEntry = rowSetEntrySort(p->pEntry); + } + p->rsFlags |= ROWSET_SORTED|ROWSET_NEXT; + } + + /* Return the next entry on the list */ + if( p->pEntry ){ + *pRowid = p->pEntry->v; + p->pEntry = p->pEntry->pRight; + if( p->pEntry==0 ){ /*OPTIMIZATION-IF-TRUE*/ + /* Free memory immediately, rather than waiting on sqlite3_finalize() */ + sqlite3RowSetClear(p); + } + return 1; + }else{ + return 0; + } +} + +/* +** Check to see if element iRowid was inserted into the rowset as +** part of any insert batch prior to iBatch. Return 1 or 0. +** +** If this is the first test of a new batch and if there exist entries +** on pRowSet->pEntry, then sort those entries into the forest at +** pRowSet->pForest so that they can be tested. +*/ +SQLITE_PRIVATE int sqlite3RowSetTest(RowSet *pRowSet, int iBatch, sqlite3_int64 iRowid){ + struct RowSetEntry *p, *pTree; + + /* This routine is never called after sqlite3RowSetNext() */ + assert( pRowSet!=0 && (pRowSet->rsFlags & ROWSET_NEXT)==0 ); + + /* Sort entries into the forest on the first test of a new batch. + ** To save unnecessary work, only do this when the batch number changes. + */ + if( iBatch!=pRowSet->iBatch ){ /*OPTIMIZATION-IF-FALSE*/ + p = pRowSet->pEntry; + if( p ){ + struct RowSetEntry **ppPrevTree = &pRowSet->pForest; + if( (pRowSet->rsFlags & ROWSET_SORTED)==0 ){ /*OPTIMIZATION-IF-FALSE*/ + /* Only sort the current set of entries if they need it */ + p = rowSetEntrySort(p); + } + for(pTree = pRowSet->pForest; pTree; pTree=pTree->pRight){ + ppPrevTree = &pTree->pRight; + if( pTree->pLeft==0 ){ + pTree->pLeft = rowSetListToTree(p); + break; + }else{ + struct RowSetEntry *pAux, *pTail; + rowSetTreeToList(pTree->pLeft, &pAux, &pTail); + pTree->pLeft = 0; + p = rowSetEntryMerge(pAux, p); + } + } + if( pTree==0 ){ + *ppPrevTree = pTree = rowSetEntryAlloc(pRowSet); + if( pTree ){ + pTree->v = 0; + pTree->pRight = 0; + pTree->pLeft = rowSetListToTree(p); + } + } + pRowSet->pEntry = 0; + pRowSet->pLast = 0; + pRowSet->rsFlags |= ROWSET_SORTED; + } + pRowSet->iBatch = iBatch; + } + + /* Test to see if the iRowid value appears anywhere in the forest. + ** Return 1 if it does and 0 if not. + */ + for(pTree = pRowSet->pForest; pTree; pTree=pTree->pRight){ + p = pTree->pLeft; + while( p ){ + if( p->vpRight; + }else if( p->v>iRowid ){ + p = p->pLeft; + }else{ + return 1; + } + } + } + return 0; +} + +/************** End of rowset.c **********************************************/ +/************** Begin file pager.c *******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This is the implementation of the page cache subsystem or "pager". +** +** The pager is used to access a database disk file. It implements +** atomic commit and rollback through the use of a journal file that +** is separate from the database file. The pager also implements file +** locking to prevent two processes from writing the same database +** file simultaneously, or one process from reading the database while +** another is writing. +*/ +#ifndef SQLITE_OMIT_DISKIO +/* #include "sqliteInt.h" */ +/************** Include wal.h in the middle of pager.c ***********************/ +/************** Begin file wal.h *********************************************/ +/* +** 2010 February 1 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This header file defines the interface to the write-ahead logging +** system. Refer to the comments below and the header comment attached to +** the implementation of each function in log.c for further details. +*/ + +#ifndef SQLITE_WAL_H +#define SQLITE_WAL_H + +/* #include "sqliteInt.h" */ + +/* Macros for extracting appropriate sync flags for either transaction +** commits (WAL_SYNC_FLAGS(X)) or for checkpoint ops (CKPT_SYNC_FLAGS(X)): +*/ +#define WAL_SYNC_FLAGS(X) ((X)&0x03) +#define CKPT_SYNC_FLAGS(X) (((X)>>2)&0x03) + +#ifdef SQLITE_OMIT_WAL +# define sqlite3WalOpen(x,y,z) 0 +# define sqlite3WalLimit(x,y) +# define sqlite3WalClose(v,w,x,y,z) 0 +# define sqlite3WalBeginReadTransaction(y,z) 0 +# define sqlite3WalEndReadTransaction(z) +# define sqlite3WalDbsize(y) 0 +# define sqlite3WalBeginWriteTransaction(y) 0 +# define sqlite3WalEndWriteTransaction(x) 0 +# define sqlite3WalUndo(x,y,z) 0 +# define sqlite3WalSavepoint(y,z) +# define sqlite3WalSavepointUndo(y,z) 0 +# define sqlite3WalFrames(u,v,w,x,y,z) 0 +# define sqlite3WalCheckpoint(q,r,s,t,u,v,w,x,y,z) 0 +# define sqlite3WalCallback(z) 0 +# define sqlite3WalExclusiveMode(y,z) 0 +# define sqlite3WalHeapMemory(z) 0 +# define sqlite3WalFramesize(z) 0 +# define sqlite3WalFindFrame(x,y,z) 0 +# define sqlite3WalFile(x) 0 +#else + +#define WAL_SAVEPOINT_NDATA 4 + +/* Connection to a write-ahead log (WAL) file. +** There is one object of this type for each pager. +*/ +typedef struct Wal Wal; + +/* Open and close a connection to a write-ahead log. */ +SQLITE_PRIVATE int sqlite3WalOpen(sqlite3_vfs*, sqlite3_file*, const char *, int, i64, Wal**); +SQLITE_PRIVATE int sqlite3WalClose(Wal *pWal, sqlite3*, int sync_flags, int, u8 *); + +/* Set the limiting size of a WAL file. */ +SQLITE_PRIVATE void sqlite3WalLimit(Wal*, i64); + +/* Used by readers to open (lock) and close (unlock) a snapshot. A +** snapshot is like a read-transaction. It is the state of the database +** at an instant in time. sqlite3WalOpenSnapshot gets a read lock and +** preserves the current state even if the other threads or processes +** write to or checkpoint the WAL. sqlite3WalCloseSnapshot() closes the +** transaction and releases the lock. +*/ +SQLITE_PRIVATE int sqlite3WalBeginReadTransaction(Wal *pWal, int *); +SQLITE_PRIVATE void sqlite3WalEndReadTransaction(Wal *pWal); + +/* Read a page from the write-ahead log, if it is present. */ +SQLITE_PRIVATE int sqlite3WalFindFrame(Wal *, Pgno, u32 *); +SQLITE_PRIVATE int sqlite3WalReadFrame(Wal *, u32, int, u8 *); + +/* If the WAL is not empty, return the size of the database. */ +SQLITE_PRIVATE Pgno sqlite3WalDbsize(Wal *pWal); + +/* Obtain or release the WRITER lock. */ +SQLITE_PRIVATE int sqlite3WalBeginWriteTransaction(Wal *pWal); +SQLITE_PRIVATE int sqlite3WalEndWriteTransaction(Wal *pWal); + +/* Undo any frames written (but not committed) to the log */ +SQLITE_PRIVATE int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx); + +/* Return an integer that records the current (uncommitted) write +** position in the WAL */ +SQLITE_PRIVATE void sqlite3WalSavepoint(Wal *pWal, u32 *aWalData); + +/* Move the write position of the WAL back to iFrame. Called in +** response to a ROLLBACK TO command. */ +SQLITE_PRIVATE int sqlite3WalSavepointUndo(Wal *pWal, u32 *aWalData); + +/* Write a frame or frames to the log. */ +SQLITE_PRIVATE int sqlite3WalFrames(Wal *pWal, int, PgHdr *, Pgno, int, int); + +/* Copy pages from the log to the database file */ +SQLITE_PRIVATE int sqlite3WalCheckpoint( + Wal *pWal, /* Write-ahead log connection */ + sqlite3 *db, /* Check this handle's interrupt flag */ + int eMode, /* One of PASSIVE, FULL and RESTART */ + int (*xBusy)(void*), /* Function to call when busy */ + void *pBusyArg, /* Context argument for xBusyHandler */ + int sync_flags, /* Flags to sync db file with (or 0) */ + int nBuf, /* Size of buffer nBuf */ + u8 *zBuf, /* Temporary buffer to use */ + int *pnLog, /* OUT: Number of frames in WAL */ + int *pnCkpt /* OUT: Number of backfilled frames in WAL */ +); + +/* Return the value to pass to a sqlite3_wal_hook callback, the +** number of frames in the WAL at the point of the last commit since +** sqlite3WalCallback() was called. If no commits have occurred since +** the last call, then return 0. +*/ +SQLITE_PRIVATE int sqlite3WalCallback(Wal *pWal); + +/* Tell the wal layer that an EXCLUSIVE lock has been obtained (or released) +** by the pager layer on the database file. +*/ +SQLITE_PRIVATE int sqlite3WalExclusiveMode(Wal *pWal, int op); + +/* Return true if the argument is non-NULL and the WAL module is using +** heap-memory for the wal-index. Otherwise, if the argument is NULL or the +** WAL module is using shared-memory, return false. +*/ +SQLITE_PRIVATE int sqlite3WalHeapMemory(Wal *pWal); + +#ifdef SQLITE_ENABLE_SNAPSHOT +SQLITE_PRIVATE int sqlite3WalSnapshotGet(Wal *pWal, sqlite3_snapshot **ppSnapshot); +SQLITE_PRIVATE void sqlite3WalSnapshotOpen(Wal *pWal, sqlite3_snapshot *pSnapshot); +SQLITE_PRIVATE int sqlite3WalSnapshotRecover(Wal *pWal); +SQLITE_PRIVATE int sqlite3WalSnapshotCheck(Wal *pWal, sqlite3_snapshot *pSnapshot); +SQLITE_PRIVATE void sqlite3WalSnapshotUnlock(Wal *pWal); +#endif + +#ifdef SQLITE_ENABLE_ZIPVFS +/* If the WAL file is not empty, return the number of bytes of content +** stored in each frame (i.e. the db page-size when the WAL was created). +*/ +SQLITE_PRIVATE int sqlite3WalFramesize(Wal *pWal); +#endif + +/* Return the sqlite3_file object for the WAL file */ +SQLITE_PRIVATE sqlite3_file *sqlite3WalFile(Wal *pWal); + +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT +SQLITE_PRIVATE int sqlite3WalWriteLock(Wal *pWal, int bLock); +SQLITE_PRIVATE void sqlite3WalDb(Wal *pWal, sqlite3 *db); +#endif + +#endif /* ifndef SQLITE_OMIT_WAL */ +#endif /* SQLITE_WAL_H */ + +/************** End of wal.h *************************************************/ +/************** Continuing where we left off in pager.c **********************/ + + +/******************* NOTES ON THE DESIGN OF THE PAGER ************************ +** +** This comment block describes invariants that hold when using a rollback +** journal. These invariants do not apply for journal_mode=WAL, +** journal_mode=MEMORY, or journal_mode=OFF. +** +** Within this comment block, a page is deemed to have been synced +** automatically as soon as it is written when PRAGMA synchronous=OFF. +** Otherwise, the page is not synced until the xSync method of the VFS +** is called successfully on the file containing the page. +** +** Definition: A page of the database file is said to be "overwriteable" if +** one or more of the following are true about the page: +** +** (a) The original content of the page as it was at the beginning of +** the transaction has been written into the rollback journal and +** synced. +** +** (b) The page was a freelist leaf page at the start of the transaction. +** +** (c) The page number is greater than the largest page that existed in +** the database file at the start of the transaction. +** +** (1) A page of the database file is never overwritten unless one of the +** following are true: +** +** (a) The page and all other pages on the same sector are overwriteable. +** +** (b) The atomic page write optimization is enabled, and the entire +** transaction other than the update of the transaction sequence +** number consists of a single page change. +** +** (2) The content of a page written into the rollback journal exactly matches +** both the content in the database when the rollback journal was written +** and the content in the database at the beginning of the current +** transaction. +** +** (3) Writes to the database file are an integer multiple of the page size +** in length and are aligned on a page boundary. +** +** (4) Reads from the database file are either aligned on a page boundary and +** an integer multiple of the page size in length or are taken from the +** first 100 bytes of the database file. +** +** (5) All writes to the database file are synced prior to the rollback journal +** being deleted, truncated, or zeroed. +** +** (6) If a super-journal file is used, then all writes to the database file +** are synced prior to the super-journal being deleted. +** +** Definition: Two databases (or the same database at two points it time) +** are said to be "logically equivalent" if they give the same answer to +** all queries. Note in particular the content of freelist leaf +** pages can be changed arbitrarily without affecting the logical equivalence +** of the database. +** +** (7) At any time, if any subset, including the empty set and the total set, +** of the unsynced changes to a rollback journal are removed and the +** journal is rolled back, the resulting database file will be logically +** equivalent to the database file at the beginning of the transaction. +** +** (8) When a transaction is rolled back, the xTruncate method of the VFS +** is called to restore the database file to the same size it was at +** the beginning of the transaction. (In some VFSes, the xTruncate +** method is a no-op, but that does not change the fact the SQLite will +** invoke it.) +** +** (9) Whenever the database file is modified, at least one bit in the range +** of bytes from 24 through 39 inclusive will be changed prior to releasing +** the EXCLUSIVE lock, thus signaling other connections on the same +** database to flush their caches. +** +** (10) The pattern of bits in bytes 24 through 39 shall not repeat in less +** than one billion transactions. +** +** (11) A database file is well-formed at the beginning and at the conclusion +** of every transaction. +** +** (12) An EXCLUSIVE lock is held on the database file when writing to +** the database file. +** +** (13) A SHARED lock is held on the database file while reading any +** content out of the database file. +** +******************************************************************************/ + +/* +** Macros for troubleshooting. Normally turned off +*/ +#if 0 +int sqlite3PagerTrace=1; /* True to enable tracing */ +#define sqlite3DebugPrintf printf +#define PAGERTRACE(X) if( sqlite3PagerTrace ){ sqlite3DebugPrintf X; } +#else +#define PAGERTRACE(X) +#endif + +/* +** The following two macros are used within the PAGERTRACE() macros above +** to print out file-descriptors. +** +** PAGERID() takes a pointer to a Pager struct as its argument. The +** associated file-descriptor is returned. FILEHANDLEID() takes an sqlite3_file +** struct as its argument. +*/ +#define PAGERID(p) (SQLITE_PTR_TO_INT(p->fd)) +#define FILEHANDLEID(fd) (SQLITE_PTR_TO_INT(fd)) + +/* +** The Pager.eState variable stores the current 'state' of a pager. A +** pager may be in any one of the seven states shown in the following +** state diagram. +** +** OPEN <------+------+ +** | | | +** V | | +** +---------> READER-------+ | +** | | | +** | V | +** |<-------WRITER_LOCKED------> ERROR +** | | ^ +** | V | +** |<------WRITER_CACHEMOD-------->| +** | | | +** | V | +** |<-------WRITER_DBMOD---------->| +** | | | +** | V | +** +<------WRITER_FINISHED-------->+ +** +** +** List of state transitions and the C [function] that performs each: +** +** OPEN -> READER [sqlite3PagerSharedLock] +** READER -> OPEN [pager_unlock] +** +** READER -> WRITER_LOCKED [sqlite3PagerBegin] +** WRITER_LOCKED -> WRITER_CACHEMOD [pager_open_journal] +** WRITER_CACHEMOD -> WRITER_DBMOD [syncJournal] +** WRITER_DBMOD -> WRITER_FINISHED [sqlite3PagerCommitPhaseOne] +** WRITER_*** -> READER [pager_end_transaction] +** +** WRITER_*** -> ERROR [pager_error] +** ERROR -> OPEN [pager_unlock] +** +** +** OPEN: +** +** The pager starts up in this state. Nothing is guaranteed in this +** state - the file may or may not be locked and the database size is +** unknown. The database may not be read or written. +** +** * No read or write transaction is active. +** * Any lock, or no lock at all, may be held on the database file. +** * The dbSize, dbOrigSize and dbFileSize variables may not be trusted. +** +** READER: +** +** In this state all the requirements for reading the database in +** rollback (non-WAL) mode are met. Unless the pager is (or recently +** was) in exclusive-locking mode, a user-level read transaction is +** open. The database size is known in this state. +** +** A connection running with locking_mode=normal enters this state when +** it opens a read-transaction on the database and returns to state +** OPEN after the read-transaction is completed. However a connection +** running in locking_mode=exclusive (including temp databases) remains in +** this state even after the read-transaction is closed. The only way +** a locking_mode=exclusive connection can transition from READER to OPEN +** is via the ERROR state (see below). +** +** * A read transaction may be active (but a write-transaction cannot). +** * A SHARED or greater lock is held on the database file. +** * The dbSize variable may be trusted (even if a user-level read +** transaction is not active). The dbOrigSize and dbFileSize variables +** may not be trusted at this point. +** * If the database is a WAL database, then the WAL connection is open. +** * Even if a read-transaction is not open, it is guaranteed that +** there is no hot-journal in the file-system. +** +** WRITER_LOCKED: +** +** The pager moves to this state from READER when a write-transaction +** is first opened on the database. In WRITER_LOCKED state, all locks +** required to start a write-transaction are held, but no actual +** modifications to the cache or database have taken place. +** +** In rollback mode, a RESERVED or (if the transaction was opened with +** BEGIN EXCLUSIVE) EXCLUSIVE lock is obtained on the database file when +** moving to this state, but the journal file is not written to or opened +** to in this state. If the transaction is committed or rolled back while +** in WRITER_LOCKED state, all that is required is to unlock the database +** file. +** +** IN WAL mode, WalBeginWriteTransaction() is called to lock the log file. +** If the connection is running with locking_mode=exclusive, an attempt +** is made to obtain an EXCLUSIVE lock on the database file. +** +** * A write transaction is active. +** * If the connection is open in rollback-mode, a RESERVED or greater +** lock is held on the database file. +** * If the connection is open in WAL-mode, a WAL write transaction +** is open (i.e. sqlite3WalBeginWriteTransaction() has been successfully +** called). +** * The dbSize, dbOrigSize and dbFileSize variables are all valid. +** * The contents of the pager cache have not been modified. +** * The journal file may or may not be open. +** * Nothing (not even the first header) has been written to the journal. +** +** WRITER_CACHEMOD: +** +** A pager moves from WRITER_LOCKED state to this state when a page is +** first modified by the upper layer. In rollback mode the journal file +** is opened (if it is not already open) and a header written to the +** start of it. The database file on disk has not been modified. +** +** * A write transaction is active. +** * A RESERVED or greater lock is held on the database file. +** * The journal file is open and the first header has been written +** to it, but the header has not been synced to disk. +** * The contents of the page cache have been modified. +** +** WRITER_DBMOD: +** +** The pager transitions from WRITER_CACHEMOD into WRITER_DBMOD state +** when it modifies the contents of the database file. WAL connections +** never enter this state (since they do not modify the database file, +** just the log file). +** +** * A write transaction is active. +** * An EXCLUSIVE or greater lock is held on the database file. +** * The journal file is open and the first header has been written +** and synced to disk. +** * The contents of the page cache have been modified (and possibly +** written to disk). +** +** WRITER_FINISHED: +** +** It is not possible for a WAL connection to enter this state. +** +** A rollback-mode pager changes to WRITER_FINISHED state from WRITER_DBMOD +** state after the entire transaction has been successfully written into the +** database file. In this state the transaction may be committed simply +** by finalizing the journal file. Once in WRITER_FINISHED state, it is +** not possible to modify the database further. At this point, the upper +** layer must either commit or rollback the transaction. +** +** * A write transaction is active. +** * An EXCLUSIVE or greater lock is held on the database file. +** * All writing and syncing of journal and database data has finished. +** If no error occurred, all that remains is to finalize the journal to +** commit the transaction. If an error did occur, the caller will need +** to rollback the transaction. +** +** ERROR: +** +** The ERROR state is entered when an IO or disk-full error (including +** SQLITE_IOERR_NOMEM) occurs at a point in the code that makes it +** difficult to be sure that the in-memory pager state (cache contents, +** db size etc.) are consistent with the contents of the file-system. +** +** Temporary pager files may enter the ERROR state, but in-memory pagers +** cannot. +** +** For example, if an IO error occurs while performing a rollback, +** the contents of the page-cache may be left in an inconsistent state. +** At this point it would be dangerous to change back to READER state +** (as usually happens after a rollback). Any subsequent readers might +** report database corruption (due to the inconsistent cache), and if +** they upgrade to writers, they may inadvertently corrupt the database +** file. To avoid this hazard, the pager switches into the ERROR state +** instead of READER following such an error. +** +** Once it has entered the ERROR state, any attempt to use the pager +** to read or write data returns an error. Eventually, once all +** outstanding transactions have been abandoned, the pager is able to +** transition back to OPEN state, discarding the contents of the +** page-cache and any other in-memory state at the same time. Everything +** is reloaded from disk (and, if necessary, hot-journal rollback peformed) +** when a read-transaction is next opened on the pager (transitioning +** the pager into READER state). At that point the system has recovered +** from the error. +** +** Specifically, the pager jumps into the ERROR state if: +** +** 1. An error occurs while attempting a rollback. This happens in +** function sqlite3PagerRollback(). +** +** 2. An error occurs while attempting to finalize a journal file +** following a commit in function sqlite3PagerCommitPhaseTwo(). +** +** 3. An error occurs while attempting to write to the journal or +** database file in function pagerStress() in order to free up +** memory. +** +** In other cases, the error is returned to the b-tree layer. The b-tree +** layer then attempts a rollback operation. If the error condition +** persists, the pager enters the ERROR state via condition (1) above. +** +** Condition (3) is necessary because it can be triggered by a read-only +** statement executed within a transaction. In this case, if the error +** code were simply returned to the user, the b-tree layer would not +** automatically attempt a rollback, as it assumes that an error in a +** read-only statement cannot leave the pager in an internally inconsistent +** state. +** +** * The Pager.errCode variable is set to something other than SQLITE_OK. +** * There are one or more outstanding references to pages (after the +** last reference is dropped the pager should move back to OPEN state). +** * The pager is not an in-memory pager. +** +** +** Notes: +** +** * A pager is never in WRITER_DBMOD or WRITER_FINISHED state if the +** connection is open in WAL mode. A WAL connection is always in one +** of the first four states. +** +** * Normally, a connection open in exclusive mode is never in PAGER_OPEN +** state. There are two exceptions: immediately after exclusive-mode has +** been turned on (and before any read or write transactions are +** executed), and when the pager is leaving the "error state". +** +** * See also: assert_pager_state(). +*/ +#define PAGER_OPEN 0 +#define PAGER_READER 1 +#define PAGER_WRITER_LOCKED 2 +#define PAGER_WRITER_CACHEMOD 3 +#define PAGER_WRITER_DBMOD 4 +#define PAGER_WRITER_FINISHED 5 +#define PAGER_ERROR 6 + +/* +** The Pager.eLock variable is almost always set to one of the +** following locking-states, according to the lock currently held on +** the database file: NO_LOCK, SHARED_LOCK, RESERVED_LOCK or EXCLUSIVE_LOCK. +** This variable is kept up to date as locks are taken and released by +** the pagerLockDb() and pagerUnlockDb() wrappers. +** +** If the VFS xLock() or xUnlock() returns an error other than SQLITE_BUSY +** (i.e. one of the SQLITE_IOERR subtypes), it is not clear whether or not +** the operation was successful. In these circumstances pagerLockDb() and +** pagerUnlockDb() take a conservative approach - eLock is always updated +** when unlocking the file, and only updated when locking the file if the +** VFS call is successful. This way, the Pager.eLock variable may be set +** to a less exclusive (lower) value than the lock that is actually held +** at the system level, but it is never set to a more exclusive value. +** +** This is usually safe. If an xUnlock fails or appears to fail, there may +** be a few redundant xLock() calls or a lock may be held for longer than +** required, but nothing really goes wrong. +** +** The exception is when the database file is unlocked as the pager moves +** from ERROR to OPEN state. At this point there may be a hot-journal file +** in the file-system that needs to be rolled back (as part of an OPEN->SHARED +** transition, by the same pager or any other). If the call to xUnlock() +** fails at this point and the pager is left holding an EXCLUSIVE lock, this +** can confuse the call to xCheckReservedLock() call made later as part +** of hot-journal detection. +** +** xCheckReservedLock() is defined as returning true "if there is a RESERVED +** lock held by this process or any others". So xCheckReservedLock may +** return true because the caller itself is holding an EXCLUSIVE lock (but +** doesn't know it because of a previous error in xUnlock). If this happens +** a hot-journal may be mistaken for a journal being created by an active +** transaction in another process, causing SQLite to read from the database +** without rolling it back. +** +** To work around this, if a call to xUnlock() fails when unlocking the +** database in the ERROR state, Pager.eLock is set to UNKNOWN_LOCK. It +** is only changed back to a real locking state after a successful call +** to xLock(EXCLUSIVE). Also, the code to do the OPEN->SHARED state transition +** omits the check for a hot-journal if Pager.eLock is set to UNKNOWN_LOCK +** lock. Instead, it assumes a hot-journal exists and obtains an EXCLUSIVE +** lock on the database file before attempting to roll it back. See function +** PagerSharedLock() for more detail. +** +** Pager.eLock may only be set to UNKNOWN_LOCK when the pager is in +** PAGER_OPEN state. +*/ +#define UNKNOWN_LOCK (EXCLUSIVE_LOCK+1) + +/* +** A macro used for invoking the codec if there is one +*/ +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC +# define CODEC1(P,D,N,X,E) \ + if( P->xCodec && P->xCodec(P->pCodec,D,N,X)==0 ){ E; } +# define CODEC2(P,D,N,X,E,O) \ + if( P->xCodec==0 ){ O=(char*)D; }else \ + if( (O=(char*)(P->xCodec(P->pCodec,D,N,X)))==0 ){ E; } +#else +# define CODEC1(P,D,N,X,E) /* NO-OP */ +# define CODEC2(P,D,N,X,E,O) O=(char*)D +#endif +/* END SQLCIPHER */ + +/* +** The maximum allowed sector size. 64KiB. If the xSectorsize() method +** returns a value larger than this, then MAX_SECTOR_SIZE is used instead. +** This could conceivably cause corruption following a power failure on +** such a system. This is currently an undocumented limit. +*/ +#define MAX_SECTOR_SIZE 0x10000 + + +/* +** An instance of the following structure is allocated for each active +** savepoint and statement transaction in the system. All such structures +** are stored in the Pager.aSavepoint[] array, which is allocated and +** resized using sqlite3Realloc(). +** +** When a savepoint is created, the PagerSavepoint.iHdrOffset field is +** set to 0. If a journal-header is written into the main journal while +** the savepoint is active, then iHdrOffset is set to the byte offset +** immediately following the last journal record written into the main +** journal before the journal-header. This is required during savepoint +** rollback (see pagerPlaybackSavepoint()). +*/ +typedef struct PagerSavepoint PagerSavepoint; +struct PagerSavepoint { + i64 iOffset; /* Starting offset in main journal */ + i64 iHdrOffset; /* See above */ + Bitvec *pInSavepoint; /* Set of pages in this savepoint */ + Pgno nOrig; /* Original number of pages in file */ + Pgno iSubRec; /* Index of first record in sub-journal */ + int bTruncateOnRelease; /* If stmt journal may be truncated on RELEASE */ +#ifndef SQLITE_OMIT_WAL + u32 aWalData[WAL_SAVEPOINT_NDATA]; /* WAL savepoint context */ +#endif +}; + +/* +** Bits of the Pager.doNotSpill flag. See further description below. +*/ +#define SPILLFLAG_OFF 0x01 /* Never spill cache. Set via pragma */ +#define SPILLFLAG_ROLLBACK 0x02 /* Current rolling back, so do not spill */ +#define SPILLFLAG_NOSYNC 0x04 /* Spill is ok, but do not sync */ + +/* +** An open page cache is an instance of struct Pager. A description of +** some of the more important member variables follows: +** +** eState +** +** The current 'state' of the pager object. See the comment and state +** diagram above for a description of the pager state. +** +** eLock +** +** For a real on-disk database, the current lock held on the database file - +** NO_LOCK, SHARED_LOCK, RESERVED_LOCK or EXCLUSIVE_LOCK. +** +** For a temporary or in-memory database (neither of which require any +** locks), this variable is always set to EXCLUSIVE_LOCK. Since such +** databases always have Pager.exclusiveMode==1, this tricks the pager +** logic into thinking that it already has all the locks it will ever +** need (and no reason to release them). +** +** In some (obscure) circumstances, this variable may also be set to +** UNKNOWN_LOCK. See the comment above the #define of UNKNOWN_LOCK for +** details. +** +** changeCountDone +** +** This boolean variable is used to make sure that the change-counter +** (the 4-byte header field at byte offset 24 of the database file) is +** not updated more often than necessary. +** +** It is set to true when the change-counter field is updated, which +** can only happen if an exclusive lock is held on the database file. +** It is cleared (set to false) whenever an exclusive lock is +** relinquished on the database file. Each time a transaction is committed, +** The changeCountDone flag is inspected. If it is true, the work of +** updating the change-counter is omitted for the current transaction. +** +** This mechanism means that when running in exclusive mode, a connection +** need only update the change-counter once, for the first transaction +** committed. +** +** setSuper +** +** When PagerCommitPhaseOne() is called to commit a transaction, it may +** (or may not) specify a super-journal name to be written into the +** journal file before it is synced to disk. +** +** Whether or not a journal file contains a super-journal pointer affects +** the way in which the journal file is finalized after the transaction is +** committed or rolled back when running in "journal_mode=PERSIST" mode. +** If a journal file does not contain a super-journal pointer, it is +** finalized by overwriting the first journal header with zeroes. If +** it does contain a super-journal pointer the journal file is finalized +** by truncating it to zero bytes, just as if the connection were +** running in "journal_mode=truncate" mode. +** +** Journal files that contain super-journal pointers cannot be finalized +** simply by overwriting the first journal-header with zeroes, as the +** super-journal pointer could interfere with hot-journal rollback of any +** subsequently interrupted transaction that reuses the journal file. +** +** The flag is cleared as soon as the journal file is finalized (either +** by PagerCommitPhaseTwo or PagerRollback). If an IO error prevents the +** journal file from being successfully finalized, the setSuper flag +** is cleared anyway (and the pager will move to ERROR state). +** +** doNotSpill +** +** This variables control the behavior of cache-spills (calls made by +** the pcache module to the pagerStress() routine to write cached data +** to the file-system in order to free up memory). +** +** When bits SPILLFLAG_OFF or SPILLFLAG_ROLLBACK of doNotSpill are set, +** writing to the database from pagerStress() is disabled altogether. +** The SPILLFLAG_ROLLBACK case is done in a very obscure case that +** comes up during savepoint rollback that requires the pcache module +** to allocate a new page to prevent the journal file from being written +** while it is being traversed by code in pager_playback(). The SPILLFLAG_OFF +** case is a user preference. +** +** If the SPILLFLAG_NOSYNC bit is set, writing to the database from +** pagerStress() is permitted, but syncing the journal file is not. +** This flag is set by sqlite3PagerWrite() when the file-system sector-size +** is larger than the database page-size in order to prevent a journal sync +** from happening in between the journalling of two pages on the same sector. +** +** subjInMemory +** +** This is a boolean variable. If true, then any required sub-journal +** is opened as an in-memory journal file. If false, then in-memory +** sub-journals are only used for in-memory pager files. +** +** This variable is updated by the upper layer each time a new +** write-transaction is opened. +** +** dbSize, dbOrigSize, dbFileSize +** +** Variable dbSize is set to the number of pages in the database file. +** It is valid in PAGER_READER and higher states (all states except for +** OPEN and ERROR). +** +** dbSize is set based on the size of the database file, which may be +** larger than the size of the database (the value stored at offset +** 28 of the database header by the btree). If the size of the file +** is not an integer multiple of the page-size, the value stored in +** dbSize is rounded down (i.e. a 5KB file with 2K page-size has dbSize==2). +** Except, any file that is greater than 0 bytes in size is considered +** to have at least one page. (i.e. a 1KB file with 2K page-size leads +** to dbSize==1). +** +** During a write-transaction, if pages with page-numbers greater than +** dbSize are modified in the cache, dbSize is updated accordingly. +** Similarly, if the database is truncated using PagerTruncateImage(), +** dbSize is updated. +** +** Variables dbOrigSize and dbFileSize are valid in states +** PAGER_WRITER_LOCKED and higher. dbOrigSize is a copy of the dbSize +** variable at the start of the transaction. It is used during rollback, +** and to determine whether or not pages need to be journalled before +** being modified. +** +** Throughout a write-transaction, dbFileSize contains the size of +** the file on disk in pages. It is set to a copy of dbSize when the +** write-transaction is first opened, and updated when VFS calls are made +** to write or truncate the database file on disk. +** +** The only reason the dbFileSize variable is required is to suppress +** unnecessary calls to xTruncate() after committing a transaction. If, +** when a transaction is committed, the dbFileSize variable indicates +** that the database file is larger than the database image (Pager.dbSize), +** pager_truncate() is called. The pager_truncate() call uses xFilesize() +** to measure the database file on disk, and then truncates it if required. +** dbFileSize is not used when rolling back a transaction. In this case +** pager_truncate() is called unconditionally (which means there may be +** a call to xFilesize() that is not strictly required). In either case, +** pager_truncate() may cause the file to become smaller or larger. +** +** dbHintSize +** +** The dbHintSize variable is used to limit the number of calls made to +** the VFS xFileControl(FCNTL_SIZE_HINT) method. +** +** dbHintSize is set to a copy of the dbSize variable when a +** write-transaction is opened (at the same time as dbFileSize and +** dbOrigSize). If the xFileControl(FCNTL_SIZE_HINT) method is called, +** dbHintSize is increased to the number of pages that correspond to the +** size-hint passed to the method call. See pager_write_pagelist() for +** details. +** +** errCode +** +** The Pager.errCode variable is only ever used in PAGER_ERROR state. It +** is set to zero in all other states. In PAGER_ERROR state, Pager.errCode +** is always set to SQLITE_FULL, SQLITE_IOERR or one of the SQLITE_IOERR_XXX +** sub-codes. +** +** syncFlags, walSyncFlags +** +** syncFlags is either SQLITE_SYNC_NORMAL (0x02) or SQLITE_SYNC_FULL (0x03). +** syncFlags is used for rollback mode. walSyncFlags is used for WAL mode +** and contains the flags used to sync the checkpoint operations in the +** lower two bits, and sync flags used for transaction commits in the WAL +** file in bits 0x04 and 0x08. In other words, to get the correct sync flags +** for checkpoint operations, use (walSyncFlags&0x03) and to get the correct +** sync flags for transaction commit, use ((walSyncFlags>>2)&0x03). Note +** that with synchronous=NORMAL in WAL mode, transaction commit is not synced +** meaning that the 0x04 and 0x08 bits are both zero. +*/ +struct Pager { + sqlite3_vfs *pVfs; /* OS functions to use for IO */ + u8 exclusiveMode; /* Boolean. True if locking_mode==EXCLUSIVE */ + u8 journalMode; /* One of the PAGER_JOURNALMODE_* values */ + u8 useJournal; /* Use a rollback journal on this file */ + u8 noSync; /* Do not sync the journal if true */ + u8 fullSync; /* Do extra syncs of the journal for robustness */ + u8 extraSync; /* sync directory after journal delete */ + u8 syncFlags; /* SYNC_NORMAL or SYNC_FULL otherwise */ + u8 walSyncFlags; /* See description above */ + u8 tempFile; /* zFilename is a temporary or immutable file */ + u8 noLock; /* Do not lock (except in WAL mode) */ + u8 readOnly; /* True for a read-only database */ + u8 memDb; /* True to inhibit all file I/O */ + u8 memVfs; /* VFS-implemented memory database */ + + /************************************************************************** + ** The following block contains those class members that change during + ** routine operation. Class members not in this block are either fixed + ** when the pager is first created or else only change when there is a + ** significant mode change (such as changing the page_size, locking_mode, + ** or the journal_mode). From another view, these class members describe + ** the "state" of the pager, while other class members describe the + ** "configuration" of the pager. + */ + u8 eState; /* Pager state (OPEN, READER, WRITER_LOCKED..) */ + u8 eLock; /* Current lock held on database file */ + u8 changeCountDone; /* Set after incrementing the change-counter */ + u8 setSuper; /* Super-jrnl name is written into jrnl */ + u8 doNotSpill; /* Do not spill the cache when non-zero */ + u8 subjInMemory; /* True to use in-memory sub-journals */ + u8 bUseFetch; /* True to use xFetch() */ + u8 hasHeldSharedLock; /* True if a shared lock has ever been held */ + Pgno dbSize; /* Number of pages in the database */ + Pgno dbOrigSize; /* dbSize before the current transaction */ + Pgno dbFileSize; /* Number of pages in the database file */ + Pgno dbHintSize; /* Value passed to FCNTL_SIZE_HINT call */ + int errCode; /* One of several kinds of errors */ + int nRec; /* Pages journalled since last j-header written */ + u32 cksumInit; /* Quasi-random value added to every checksum */ + u32 nSubRec; /* Number of records written to sub-journal */ + Bitvec *pInJournal; /* One bit for each page in the database file */ + sqlite3_file *fd; /* File descriptor for database */ + sqlite3_file *jfd; /* File descriptor for main journal */ + sqlite3_file *sjfd; /* File descriptor for sub-journal */ + i64 journalOff; /* Current write offset in the journal file */ + i64 journalHdr; /* Byte offset to previous journal header */ + sqlite3_backup *pBackup; /* Pointer to list of ongoing backup processes */ + PagerSavepoint *aSavepoint; /* Array of active savepoints */ + int nSavepoint; /* Number of elements in aSavepoint[] */ + u32 iDataVersion; /* Changes whenever database content changes */ + char dbFileVers[16]; /* Changes whenever database file changes */ + + int nMmapOut; /* Number of mmap pages currently outstanding */ + sqlite3_int64 szMmap; /* Desired maximum mmap size */ + PgHdr *pMmapFreelist; /* List of free mmap page headers (pDirty) */ + /* + ** End of the routinely-changing class members + ***************************************************************************/ + + u16 nExtra; /* Add this many bytes to each in-memory page */ + i16 nReserve; /* Number of unused bytes at end of each page */ + u32 vfsFlags; /* Flags for sqlite3_vfs.xOpen() */ + u32 sectorSize; /* Assumed sector size during rollback */ + Pgno mxPgno; /* Maximum allowed size of the database */ + Pgno lckPgno; /* Page number for the locking page */ + i64 pageSize; /* Number of bytes in a page */ + i64 journalSizeLimit; /* Size limit for persistent journal files */ + char *zFilename; /* Name of the database file */ + char *zJournal; /* Name of the journal file */ + int (*xBusyHandler)(void*); /* Function to call when busy */ + void *pBusyHandlerArg; /* Context argument for xBusyHandler */ + int aStat[4]; /* Total cache hits, misses, writes, spills */ +#ifdef SQLITE_TEST + int nRead; /* Database pages read */ +#endif + void (*xReiniter)(DbPage*); /* Call this routine when reloading pages */ + int (*xGet)(Pager*,Pgno,DbPage**,int); /* Routine to fetch a patch */ +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC + void *(*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */ + void (*xCodecSizeChng)(void*,int,int); /* Notify of page size changes */ + void (*xCodecFree)(void*); /* Destructor for the codec */ + void *pCodec; /* First argument to xCodec... methods */ +#endif +/* END SQLCIPHER */ + char *pTmpSpace; /* Pager.pageSize bytes of space for tmp use */ + PCache *pPCache; /* Pointer to page cache object */ +#ifndef SQLITE_OMIT_WAL + Wal *pWal; /* Write-ahead log used by "journal_mode=wal" */ + char *zWal; /* File name for write-ahead log */ +#endif +}; + +/* +** Indexes for use with Pager.aStat[]. The Pager.aStat[] array contains +** the values accessed by passing SQLITE_DBSTATUS_CACHE_HIT, CACHE_MISS +** or CACHE_WRITE to sqlite3_db_status(). +*/ +#define PAGER_STAT_HIT 0 +#define PAGER_STAT_MISS 1 +#define PAGER_STAT_WRITE 2 +#define PAGER_STAT_SPILL 3 + +/* +** The following global variables hold counters used for +** testing purposes only. These variables do not exist in +** a non-testing build. These variables are not thread-safe. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_pager_readdb_count = 0; /* Number of full pages read from DB */ +SQLITE_API int sqlite3_pager_writedb_count = 0; /* Number of full pages written to DB */ +SQLITE_API int sqlite3_pager_writej_count = 0; /* Number of pages written to journal */ +# define PAGER_INCR(v) v++ +#else +# define PAGER_INCR(v) +#endif + + + +/* +** Journal files begin with the following magic string. The data +** was obtained from /dev/random. It is used only as a sanity check. +** +** Since version 2.8.0, the journal format contains additional sanity +** checking information. If the power fails while the journal is being +** written, semi-random garbage data might appear in the journal +** file after power is restored. If an attempt is then made +** to roll the journal back, the database could be corrupted. The additional +** sanity checking data is an attempt to discover the garbage in the +** journal and ignore it. +** +** The sanity checking information for the new journal format consists +** of a 32-bit checksum on each page of data. The checksum covers both +** the page number and the pPager->pageSize bytes of data for the page. +** This cksum is initialized to a 32-bit random value that appears in the +** journal file right after the header. The random initializer is important, +** because garbage data that appears at the end of a journal is likely +** data that was once in other files that have now been deleted. If the +** garbage data came from an obsolete journal file, the checksums might +** be correct. But by initializing the checksum to random value which +** is different for every journal, we minimize that risk. +*/ +static const unsigned char aJournalMagic[] = { + 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd7, +}; + +/* +** The size of the of each page record in the journal is given by +** the following macro. +*/ +#define JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8) + +/* +** The journal header size for this pager. This is usually the same +** size as a single disk sector. See also setSectorSize(). +*/ +#define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize) + +/* +** The macro MEMDB is true if we are dealing with an in-memory database. +** We do this as a macro so that if the SQLITE_OMIT_MEMORYDB macro is set, +** the value of MEMDB will be a constant and the compiler will optimize +** out code that would never execute. +*/ +#ifdef SQLITE_OMIT_MEMORYDB +# define MEMDB 0 +#else +# define MEMDB pPager->memDb +#endif + +/* +** The macro USEFETCH is true if we are allowed to use the xFetch and xUnfetch +** interfaces to access the database using memory-mapped I/O. +*/ +#if SQLITE_MAX_MMAP_SIZE>0 +# define USEFETCH(x) ((x)->bUseFetch) +#else +# define USEFETCH(x) 0 +#endif + +/* +** The argument to this macro is a file descriptor (type sqlite3_file*). +** Return 0 if it is not open, or non-zero (but not 1) if it is. +** +** This is so that expressions can be written as: +** +** if( isOpen(pPager->jfd) ){ ... +** +** instead of +** +** if( pPager->jfd->pMethods ){ ... +*/ +#define isOpen(pFd) ((pFd)->pMethods!=0) + +#ifdef SQLITE_DIRECT_OVERFLOW_READ +/* +** Return true if page pgno can be read directly from the database file +** by the b-tree layer. This is the case if: +** +** * the database file is open, +** * there are no dirty pages in the cache, and +** * the desired page is not currently in the wal file. +*/ +SQLITE_PRIVATE int sqlite3PagerDirectReadOk(Pager *pPager, Pgno pgno){ + if( pPager->fd->pMethods==0 ) return 0; + if( sqlite3PCacheIsDirty(pPager->pPCache) ) return 0; +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC + if( pPager->xCodec!=0 ) return 0; +#endif +/* END SQLCIPHER */ +#ifndef SQLITE_OMIT_WAL + if( pPager->pWal ){ + u32 iRead = 0; + int rc; + rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iRead); + return (rc==SQLITE_OK && iRead==0); + } +#endif + return 1; +} +#endif + +#ifndef SQLITE_OMIT_WAL +# define pagerUseWal(x) ((x)->pWal!=0) +#else +# define pagerUseWal(x) 0 +# define pagerRollbackWal(x) 0 +# define pagerWalFrames(v,w,x,y) 0 +# define pagerOpenWalIfPresent(z) SQLITE_OK +# define pagerBeginReadTransaction(z) SQLITE_OK +#endif + +#ifndef NDEBUG +/* +** Usage: +** +** assert( assert_pager_state(pPager) ); +** +** This function runs many asserts to try to find inconsistencies in +** the internal state of the Pager object. +*/ +static int assert_pager_state(Pager *p){ + Pager *pPager = p; + + /* State must be valid. */ + assert( p->eState==PAGER_OPEN + || p->eState==PAGER_READER + || p->eState==PAGER_WRITER_LOCKED + || p->eState==PAGER_WRITER_CACHEMOD + || p->eState==PAGER_WRITER_DBMOD + || p->eState==PAGER_WRITER_FINISHED + || p->eState==PAGER_ERROR + ); + + /* Regardless of the current state, a temp-file connection always behaves + ** as if it has an exclusive lock on the database file. It never updates + ** the change-counter field, so the changeCountDone flag is always set. + */ + assert( p->tempFile==0 || p->eLock==EXCLUSIVE_LOCK ); + assert( p->tempFile==0 || pPager->changeCountDone ); + + /* If the useJournal flag is clear, the journal-mode must be "OFF". + ** And if the journal-mode is "OFF", the journal file must not be open. + */ + assert( p->journalMode==PAGER_JOURNALMODE_OFF || p->useJournal ); + assert( p->journalMode!=PAGER_JOURNALMODE_OFF || !isOpen(p->jfd) ); + + /* Check that MEMDB implies noSync. And an in-memory journal. Since + ** this means an in-memory pager performs no IO at all, it cannot encounter + ** either SQLITE_IOERR or SQLITE_FULL during rollback or while finalizing + ** a journal file. (although the in-memory journal implementation may + ** return SQLITE_IOERR_NOMEM while the journal file is being written). It + ** is therefore not possible for an in-memory pager to enter the ERROR + ** state. + */ + if( MEMDB ){ + assert( !isOpen(p->fd) ); + assert( p->noSync ); + assert( p->journalMode==PAGER_JOURNALMODE_OFF + || p->journalMode==PAGER_JOURNALMODE_MEMORY + ); + assert( p->eState!=PAGER_ERROR && p->eState!=PAGER_OPEN ); + assert( pagerUseWal(p)==0 ); + } + + /* If changeCountDone is set, a RESERVED lock or greater must be held + ** on the file. + */ + assert( pPager->changeCountDone==0 || pPager->eLock>=RESERVED_LOCK ); + assert( p->eLock!=PENDING_LOCK ); + + switch( p->eState ){ + case PAGER_OPEN: + assert( !MEMDB ); + assert( pPager->errCode==SQLITE_OK ); + assert( sqlite3PcacheRefCount(pPager->pPCache)==0 || pPager->tempFile ); + break; + + case PAGER_READER: + assert( pPager->errCode==SQLITE_OK ); + assert( p->eLock!=UNKNOWN_LOCK ); + assert( p->eLock>=SHARED_LOCK ); + break; + + case PAGER_WRITER_LOCKED: + assert( p->eLock!=UNKNOWN_LOCK ); + assert( pPager->errCode==SQLITE_OK ); + if( !pagerUseWal(pPager) ){ + assert( p->eLock>=RESERVED_LOCK ); + } + assert( pPager->dbSize==pPager->dbOrigSize ); + assert( pPager->dbOrigSize==pPager->dbFileSize ); + assert( pPager->dbOrigSize==pPager->dbHintSize ); + assert( pPager->setSuper==0 ); + break; + + case PAGER_WRITER_CACHEMOD: + assert( p->eLock!=UNKNOWN_LOCK ); + assert( pPager->errCode==SQLITE_OK ); + if( !pagerUseWal(pPager) ){ + /* It is possible that if journal_mode=wal here that neither the + ** journal file nor the WAL file are open. This happens during + ** a rollback transaction that switches from journal_mode=off + ** to journal_mode=wal. + */ + assert( p->eLock>=RESERVED_LOCK ); + assert( isOpen(p->jfd) + || p->journalMode==PAGER_JOURNALMODE_OFF + || p->journalMode==PAGER_JOURNALMODE_WAL + ); + } + assert( pPager->dbOrigSize==pPager->dbFileSize ); + assert( pPager->dbOrigSize==pPager->dbHintSize ); + break; + + case PAGER_WRITER_DBMOD: + assert( p->eLock==EXCLUSIVE_LOCK ); + assert( pPager->errCode==SQLITE_OK ); + assert( !pagerUseWal(pPager) ); + assert( p->eLock>=EXCLUSIVE_LOCK ); + assert( isOpen(p->jfd) + || p->journalMode==PAGER_JOURNALMODE_OFF + || p->journalMode==PAGER_JOURNALMODE_WAL + || (sqlite3OsDeviceCharacteristics(p->fd)&SQLITE_IOCAP_BATCH_ATOMIC) + ); + assert( pPager->dbOrigSize<=pPager->dbHintSize ); + break; + + case PAGER_WRITER_FINISHED: + assert( p->eLock==EXCLUSIVE_LOCK ); + assert( pPager->errCode==SQLITE_OK ); + assert( !pagerUseWal(pPager) ); + assert( isOpen(p->jfd) + || p->journalMode==PAGER_JOURNALMODE_OFF + || p->journalMode==PAGER_JOURNALMODE_WAL + || (sqlite3OsDeviceCharacteristics(p->fd)&SQLITE_IOCAP_BATCH_ATOMIC) + ); + break; + + case PAGER_ERROR: + /* There must be at least one outstanding reference to the pager if + ** in ERROR state. Otherwise the pager should have already dropped + ** back to OPEN state. + */ + assert( pPager->errCode!=SQLITE_OK ); + assert( sqlite3PcacheRefCount(pPager->pPCache)>0 || pPager->tempFile ); + break; + } + + return 1; +} +#endif /* ifndef NDEBUG */ + +#ifdef SQLITE_DEBUG +/* +** Return a pointer to a human readable string in a static buffer +** containing the state of the Pager object passed as an argument. This +** is intended to be used within debuggers. For example, as an alternative +** to "print *pPager" in gdb: +** +** (gdb) printf "%s", print_pager_state(pPager) +** +** This routine has external linkage in order to suppress compiler warnings +** about an unused function. It is enclosed within SQLITE_DEBUG and so does +** not appear in normal builds. +*/ +char *print_pager_state(Pager *p){ + static char zRet[1024]; + + sqlite3_snprintf(1024, zRet, + "Filename: %s\n" + "State: %s errCode=%d\n" + "Lock: %s\n" + "Locking mode: locking_mode=%s\n" + "Journal mode: journal_mode=%s\n" + "Backing store: tempFile=%d memDb=%d useJournal=%d\n" + "Journal: journalOff=%lld journalHdr=%lld\n" + "Size: dbsize=%d dbOrigSize=%d dbFileSize=%d\n" + , p->zFilename + , p->eState==PAGER_OPEN ? "OPEN" : + p->eState==PAGER_READER ? "READER" : + p->eState==PAGER_WRITER_LOCKED ? "WRITER_LOCKED" : + p->eState==PAGER_WRITER_CACHEMOD ? "WRITER_CACHEMOD" : + p->eState==PAGER_WRITER_DBMOD ? "WRITER_DBMOD" : + p->eState==PAGER_WRITER_FINISHED ? "WRITER_FINISHED" : + p->eState==PAGER_ERROR ? "ERROR" : "?error?" + , (int)p->errCode + , p->eLock==NO_LOCK ? "NO_LOCK" : + p->eLock==RESERVED_LOCK ? "RESERVED" : + p->eLock==EXCLUSIVE_LOCK ? "EXCLUSIVE" : + p->eLock==SHARED_LOCK ? "SHARED" : + p->eLock==UNKNOWN_LOCK ? "UNKNOWN" : "?error?" + , p->exclusiveMode ? "exclusive" : "normal" + , p->journalMode==PAGER_JOURNALMODE_MEMORY ? "memory" : + p->journalMode==PAGER_JOURNALMODE_OFF ? "off" : + p->journalMode==PAGER_JOURNALMODE_DELETE ? "delete" : + p->journalMode==PAGER_JOURNALMODE_PERSIST ? "persist" : + p->journalMode==PAGER_JOURNALMODE_TRUNCATE ? "truncate" : + p->journalMode==PAGER_JOURNALMODE_WAL ? "wal" : "?error?" + , (int)p->tempFile, (int)p->memDb, (int)p->useJournal + , p->journalOff, p->journalHdr + , (int)p->dbSize, (int)p->dbOrigSize, (int)p->dbFileSize + ); + + return zRet; +} +#endif + +/* Forward references to the various page getters */ +static int getPageNormal(Pager*,Pgno,DbPage**,int); +static int getPageError(Pager*,Pgno,DbPage**,int); +#if SQLITE_MAX_MMAP_SIZE>0 +static int getPageMMap(Pager*,Pgno,DbPage**,int); +#endif + +/* +** Set the Pager.xGet method for the appropriate routine used to fetch +** content from the pager. +*/ +static void setGetterMethod(Pager *pPager){ + if( pPager->errCode ){ + pPager->xGet = getPageError; +#if SQLITE_MAX_MMAP_SIZE>0 + }else if( USEFETCH(pPager) +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC + && pPager->xCodec==0 +#endif +/* END SQLCIPHER */ + ){ + pPager->xGet = getPageMMap; +#endif /* SQLITE_MAX_MMAP_SIZE>0 */ + }else{ + pPager->xGet = getPageNormal; + } +} + +/* +** Return true if it is necessary to write page *pPg into the sub-journal. +** A page needs to be written into the sub-journal if there exists one +** or more open savepoints for which: +** +** * The page-number is less than or equal to PagerSavepoint.nOrig, and +** * The bit corresponding to the page-number is not set in +** PagerSavepoint.pInSavepoint. +*/ +static int subjRequiresPage(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + PagerSavepoint *p; + Pgno pgno = pPg->pgno; + int i; + for(i=0; inSavepoint; i++){ + p = &pPager->aSavepoint[i]; + if( p->nOrig>=pgno && 0==sqlite3BitvecTestNotNull(p->pInSavepoint, pgno) ){ + for(i=i+1; inSavepoint; i++){ + pPager->aSavepoint[i].bTruncateOnRelease = 0; + } + return 1; + } + } + return 0; +} + +#ifdef SQLITE_DEBUG +/* +** Return true if the page is already in the journal file. +*/ +static int pageInJournal(Pager *pPager, PgHdr *pPg){ + return sqlite3BitvecTest(pPager->pInJournal, pPg->pgno); +} +#endif + +/* +** Read a 32-bit integer from the given file descriptor. Store the integer +** that is read in *pRes. Return SQLITE_OK if everything worked, or an +** error code is something goes wrong. +** +** All values are stored on disk as big-endian. +*/ +static int read32bits(sqlite3_file *fd, i64 offset, u32 *pRes){ + unsigned char ac[4]; + int rc = sqlite3OsRead(fd, ac, sizeof(ac), offset); + if( rc==SQLITE_OK ){ + *pRes = sqlite3Get4byte(ac); + } + return rc; +} + +/* +** Write a 32-bit integer into a string buffer in big-endian byte order. +*/ +#define put32bits(A,B) sqlite3Put4byte((u8*)A,B) + + +/* +** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK +** on success or an error code is something goes wrong. +*/ +static int write32bits(sqlite3_file *fd, i64 offset, u32 val){ + char ac[4]; + put32bits(ac, val); + return sqlite3OsWrite(fd, ac, 4, offset); +} + +/* +** Unlock the database file to level eLock, which must be either NO_LOCK +** or SHARED_LOCK. Regardless of whether or not the call to xUnlock() +** succeeds, set the Pager.eLock variable to match the (attempted) new lock. +** +** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is +** called, do not modify it. See the comment above the #define of +** UNKNOWN_LOCK for an explanation of this. +*/ +static int pagerUnlockDb(Pager *pPager, int eLock){ + int rc = SQLITE_OK; + + assert( !pPager->exclusiveMode || pPager->eLock==eLock ); + assert( eLock==NO_LOCK || eLock==SHARED_LOCK ); + assert( eLock!=NO_LOCK || pagerUseWal(pPager)==0 ); + if( isOpen(pPager->fd) ){ + assert( pPager->eLock>=eLock ); + rc = pPager->noLock ? SQLITE_OK : sqlite3OsUnlock(pPager->fd, eLock); + if( pPager->eLock!=UNKNOWN_LOCK ){ + pPager->eLock = (u8)eLock; + } + IOTRACE(("UNLOCK %p %d\n", pPager, eLock)) + } + pPager->changeCountDone = pPager->tempFile; /* ticket fb3b3024ea238d5c */ + return rc; +} + +/* +** Lock the database file to level eLock, which must be either SHARED_LOCK, +** RESERVED_LOCK or EXCLUSIVE_LOCK. If the caller is successful, set the +** Pager.eLock variable to the new locking state. +** +** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is +** called, do not modify it unless the new locking state is EXCLUSIVE_LOCK. +** See the comment above the #define of UNKNOWN_LOCK for an explanation +** of this. +*/ +static int pagerLockDb(Pager *pPager, int eLock){ + int rc = SQLITE_OK; + + assert( eLock==SHARED_LOCK || eLock==RESERVED_LOCK || eLock==EXCLUSIVE_LOCK ); + if( pPager->eLockeLock==UNKNOWN_LOCK ){ + rc = pPager->noLock ? SQLITE_OK : sqlite3OsLock(pPager->fd, eLock); + if( rc==SQLITE_OK && (pPager->eLock!=UNKNOWN_LOCK||eLock==EXCLUSIVE_LOCK) ){ + pPager->eLock = (u8)eLock; + IOTRACE(("LOCK %p %d\n", pPager, eLock)) + } + } + return rc; +} + +/* +** This function determines whether or not the atomic-write or +** atomic-batch-write optimizations can be used with this pager. The +** atomic-write optimization can be used if: +** +** (a) the value returned by OsDeviceCharacteristics() indicates that +** a database page may be written atomically, and +** (b) the value returned by OsSectorSize() is less than or equal +** to the page size. +** +** If it can be used, then the value returned is the size of the journal +** file when it contains rollback data for exactly one page. +** +** The atomic-batch-write optimization can be used if OsDeviceCharacteristics() +** returns a value with the SQLITE_IOCAP_BATCH_ATOMIC bit set. -1 is +** returned in this case. +** +** If neither optimization can be used, 0 is returned. +*/ +static int jrnlBufferSize(Pager *pPager){ + assert( !MEMDB ); + +#if defined(SQLITE_ENABLE_ATOMIC_WRITE) \ + || defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE) + int dc; /* Device characteristics */ + + assert( isOpen(pPager->fd) ); + dc = sqlite3OsDeviceCharacteristics(pPager->fd); +#else + UNUSED_PARAMETER(pPager); +#endif + +#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE + if( pPager->dbSize>0 && (dc&SQLITE_IOCAP_BATCH_ATOMIC) ){ + return -1; + } +#endif + +#ifdef SQLITE_ENABLE_ATOMIC_WRITE + { + int nSector = pPager->sectorSize; + int szPage = pPager->pageSize; + + assert(SQLITE_IOCAP_ATOMIC512==(512>>8)); + assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8)); + if( 0==(dc&(SQLITE_IOCAP_ATOMIC|(szPage>>8)) || nSector>szPage) ){ + return 0; + } + } + + return JOURNAL_HDR_SZ(pPager) + JOURNAL_PG_SZ(pPager); +#endif + + return 0; +} + +/* +** If SQLITE_CHECK_PAGES is defined then we do some sanity checking +** on the cache using a hash function. This is used for testing +** and debugging only. +*/ +#ifdef SQLITE_CHECK_PAGES +/* +** Return a 32-bit hash of the page data for pPage. +*/ +static u32 pager_datahash(int nByte, unsigned char *pData){ + u32 hash = 0; + int i; + for(i=0; ipPager->pageSize, (unsigned char *)pPage->pData); +} +static void pager_set_pagehash(PgHdr *pPage){ + pPage->pageHash = pager_pagehash(pPage); +} + +/* +** The CHECK_PAGE macro takes a PgHdr* as an argument. If SQLITE_CHECK_PAGES +** is defined, and NDEBUG is not defined, an assert() statement checks +** that the page is either dirty or still matches the calculated page-hash. +*/ +#define CHECK_PAGE(x) checkPage(x) +static void checkPage(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + assert( pPager->eState!=PAGER_ERROR ); + assert( (pPg->flags&PGHDR_DIRTY) || pPg->pageHash==pager_pagehash(pPg) ); +} + +#else +#define pager_datahash(X,Y) 0 +#define pager_pagehash(X) 0 +#define pager_set_pagehash(X) +#define CHECK_PAGE(x) +#endif /* SQLITE_CHECK_PAGES */ + +/* +** When this is called the journal file for pager pPager must be open. +** This function attempts to read a super-journal file name from the +** end of the file and, if successful, copies it into memory supplied +** by the caller. See comments above writeSuperJournal() for the format +** used to store a super-journal file name at the end of a journal file. +** +** zSuper must point to a buffer of at least nSuper bytes allocated by +** the caller. This should be sqlite3_vfs.mxPathname+1 (to ensure there is +** enough space to write the super-journal name). If the super-journal +** name in the journal is longer than nSuper bytes (including a +** nul-terminator), then this is handled as if no super-journal name +** were present in the journal. +** +** If a super-journal file name is present at the end of the journal +** file, then it is copied into the buffer pointed to by zSuper. A +** nul-terminator byte is appended to the buffer following the +** super-journal file name. +** +** If it is determined that no super-journal file name is present +** zSuper[0] is set to 0 and SQLITE_OK returned. +** +** If an error occurs while reading from the journal file, an SQLite +** error code is returned. +*/ +static int readSuperJournal(sqlite3_file *pJrnl, char *zSuper, u32 nSuper){ + int rc; /* Return code */ + u32 len; /* Length in bytes of super-journal name */ + i64 szJ; /* Total size in bytes of journal file pJrnl */ + u32 cksum; /* MJ checksum value read from journal */ + u32 u; /* Unsigned loop counter */ + unsigned char aMagic[8]; /* A buffer to hold the magic header */ + zSuper[0] = '\0'; + + if( SQLITE_OK!=(rc = sqlite3OsFileSize(pJrnl, &szJ)) + || szJ<16 + || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-16, &len)) + || len>=nSuper + || len>szJ-16 + || len==0 + || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-12, &cksum)) + || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, aMagic, 8, szJ-8)) + || memcmp(aMagic, aJournalMagic, 8) + || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, zSuper, len, szJ-16-len)) + ){ + return rc; + } + + /* See if the checksum matches the super-journal name */ + for(u=0; ujournalOff, assuming a sector +** size of pPager->sectorSize bytes. +** +** i.e for a sector size of 512: +** +** Pager.journalOff Return value +** --------------------------------------- +** 0 0 +** 512 512 +** 100 512 +** 2000 2048 +** +*/ +static i64 journalHdrOffset(Pager *pPager){ + i64 offset = 0; + i64 c = pPager->journalOff; + if( c ){ + offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager); + } + assert( offset%JOURNAL_HDR_SZ(pPager)==0 ); + assert( offset>=c ); + assert( (offset-c)jfd) ); + assert( !sqlite3JournalIsInMemory(pPager->jfd) ); + if( pPager->journalOff ){ + const i64 iLimit = pPager->journalSizeLimit; /* Local cache of jsl */ + + IOTRACE(("JZEROHDR %p\n", pPager)) + if( doTruncate || iLimit==0 ){ + rc = sqlite3OsTruncate(pPager->jfd, 0); + }else{ + static const char zeroHdr[28] = {0}; + rc = sqlite3OsWrite(pPager->jfd, zeroHdr, sizeof(zeroHdr), 0); + } + if( rc==SQLITE_OK && !pPager->noSync ){ + rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_DATAONLY|pPager->syncFlags); + } + + /* At this point the transaction is committed but the write lock + ** is still held on the file. If there is a size limit configured for + ** the persistent journal and the journal file currently consumes more + ** space than that limit allows for, truncate it now. There is no need + ** to sync the file following this operation. + */ + if( rc==SQLITE_OK && iLimit>0 ){ + i64 sz; + rc = sqlite3OsFileSize(pPager->jfd, &sz); + if( rc==SQLITE_OK && sz>iLimit ){ + rc = sqlite3OsTruncate(pPager->jfd, iLimit); + } + } + } + return rc; +} + +/* +** The journal file must be open when this routine is called. A journal +** header (JOURNAL_HDR_SZ bytes) is written into the journal file at the +** current location. +** +** The format for the journal header is as follows: +** - 8 bytes: Magic identifying journal format. +** - 4 bytes: Number of records in journal, or -1 no-sync mode is on. +** - 4 bytes: Random number used for page hash. +** - 4 bytes: Initial database page count. +** - 4 bytes: Sector size used by the process that wrote this journal. +** - 4 bytes: Database page size. +** +** Followed by (JOURNAL_HDR_SZ - 28) bytes of unused space. +*/ +static int writeJournalHdr(Pager *pPager){ + int rc = SQLITE_OK; /* Return code */ + char *zHeader = pPager->pTmpSpace; /* Temporary space used to build header */ + u32 nHeader = (u32)pPager->pageSize;/* Size of buffer pointed to by zHeader */ + u32 nWrite; /* Bytes of header sector written */ + int ii; /* Loop counter */ + + assert( isOpen(pPager->jfd) ); /* Journal file must be open. */ + + if( nHeader>JOURNAL_HDR_SZ(pPager) ){ + nHeader = JOURNAL_HDR_SZ(pPager); + } + + /* If there are active savepoints and any of them were created + ** since the most recent journal header was written, update the + ** PagerSavepoint.iHdrOffset fields now. + */ + for(ii=0; iinSavepoint; ii++){ + if( pPager->aSavepoint[ii].iHdrOffset==0 ){ + pPager->aSavepoint[ii].iHdrOffset = pPager->journalOff; + } + } + + pPager->journalHdr = pPager->journalOff = journalHdrOffset(pPager); + + /* + ** Write the nRec Field - the number of page records that follow this + ** journal header. Normally, zero is written to this value at this time. + ** After the records are added to the journal (and the journal synced, + ** if in full-sync mode), the zero is overwritten with the true number + ** of records (see syncJournal()). + ** + ** A faster alternative is to write 0xFFFFFFFF to the nRec field. When + ** reading the journal this value tells SQLite to assume that the + ** rest of the journal file contains valid page records. This assumption + ** is dangerous, as if a failure occurred whilst writing to the journal + ** file it may contain some garbage data. There are two scenarios + ** where this risk can be ignored: + ** + ** * When the pager is in no-sync mode. Corruption can follow a + ** power failure in this case anyway. + ** + ** * When the SQLITE_IOCAP_SAFE_APPEND flag is set. This guarantees + ** that garbage data is never appended to the journal file. + */ + assert( isOpen(pPager->fd) || pPager->noSync ); + if( pPager->noSync || (pPager->journalMode==PAGER_JOURNALMODE_MEMORY) + || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND) + ){ + memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic)); + put32bits(&zHeader[sizeof(aJournalMagic)], 0xffffffff); + }else{ + memset(zHeader, 0, sizeof(aJournalMagic)+4); + } + + /* The random check-hash initializer */ + sqlite3_randomness(sizeof(pPager->cksumInit), &pPager->cksumInit); + put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit); + /* The initial database size */ + put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbOrigSize); + /* The assumed sector size for this process */ + put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize); + + /* The page size */ + put32bits(&zHeader[sizeof(aJournalMagic)+16], pPager->pageSize); + + /* Initializing the tail of the buffer is not necessary. Everything + ** works find if the following memset() is omitted. But initializing + ** the memory prevents valgrind from complaining, so we are willing to + ** take the performance hit. + */ + memset(&zHeader[sizeof(aJournalMagic)+20], 0, + nHeader-(sizeof(aJournalMagic)+20)); + + /* In theory, it is only necessary to write the 28 bytes that the + ** journal header consumes to the journal file here. Then increment the + ** Pager.journalOff variable by JOURNAL_HDR_SZ so that the next + ** record is written to the following sector (leaving a gap in the file + ** that will be implicitly filled in by the OS). + ** + ** However it has been discovered that on some systems this pattern can + ** be significantly slower than contiguously writing data to the file, + ** even if that means explicitly writing data to the block of + ** (JOURNAL_HDR_SZ - 28) bytes that will not be used. So that is what + ** is done. + ** + ** The loop is required here in case the sector-size is larger than the + ** database page size. Since the zHeader buffer is only Pager.pageSize + ** bytes in size, more than one call to sqlite3OsWrite() may be required + ** to populate the entire journal header sector. + */ + for(nWrite=0; rc==SQLITE_OK&&nWritejournalHdr, nHeader)) + rc = sqlite3OsWrite(pPager->jfd, zHeader, nHeader, pPager->journalOff); + assert( pPager->journalHdr <= pPager->journalOff ); + pPager->journalOff += nHeader; + } + + return rc; +} + +/* +** The journal file must be open when this is called. A journal header file +** (JOURNAL_HDR_SZ bytes) is read from the current location in the journal +** file. The current location in the journal file is given by +** pPager->journalOff. See comments above function writeJournalHdr() for +** a description of the journal header format. +** +** If the header is read successfully, *pNRec is set to the number of +** page records following this header and *pDbSize is set to the size of the +** database before the transaction began, in pages. Also, pPager->cksumInit +** is set to the value read from the journal header. SQLITE_OK is returned +** in this case. +** +** If the journal header file appears to be corrupted, SQLITE_DONE is +** returned and *pNRec and *PDbSize are undefined. If JOURNAL_HDR_SZ bytes +** cannot be read from the journal file an error code is returned. +*/ +static int readJournalHdr( + Pager *pPager, /* Pager object */ + int isHot, + i64 journalSize, /* Size of the open journal file in bytes */ + u32 *pNRec, /* OUT: Value read from the nRec field */ + u32 *pDbSize /* OUT: Value of original database size field */ +){ + int rc; /* Return code */ + unsigned char aMagic[8]; /* A buffer to hold the magic header */ + i64 iHdrOff; /* Offset of journal header being read */ + + assert( isOpen(pPager->jfd) ); /* Journal file must be open. */ + + /* Advance Pager.journalOff to the start of the next sector. If the + ** journal file is too small for there to be a header stored at this + ** point, return SQLITE_DONE. + */ + pPager->journalOff = journalHdrOffset(pPager); + if( pPager->journalOff+JOURNAL_HDR_SZ(pPager) > journalSize ){ + return SQLITE_DONE; + } + iHdrOff = pPager->journalOff; + + /* Read in the first 8 bytes of the journal header. If they do not match + ** the magic string found at the start of each journal header, return + ** SQLITE_DONE. If an IO error occurs, return an error code. Otherwise, + ** proceed. + */ + if( isHot || iHdrOff!=pPager->journalHdr ){ + rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic), iHdrOff); + if( rc ){ + return rc; + } + if( memcmp(aMagic, aJournalMagic, sizeof(aMagic))!=0 ){ + return SQLITE_DONE; + } + } + + /* Read the first three 32-bit fields of the journal header: The nRec + ** field, the checksum-initializer and the database size at the start + ** of the transaction. Return an error code if anything goes wrong. + */ + if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+8, pNRec)) + || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+12, &pPager->cksumInit)) + || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+16, pDbSize)) + ){ + return rc; + } + + if( pPager->journalOff==0 ){ + u32 iPageSize; /* Page-size field of journal header */ + u32 iSectorSize; /* Sector-size field of journal header */ + + /* Read the page-size and sector-size journal header fields. */ + if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+20, &iSectorSize)) + || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+24, &iPageSize)) + ){ + return rc; + } + + /* Versions of SQLite prior to 3.5.8 set the page-size field of the + ** journal header to zero. In this case, assume that the Pager.pageSize + ** variable is already set to the correct page size. + */ + if( iPageSize==0 ){ + iPageSize = pPager->pageSize; + } + + /* Check that the values read from the page-size and sector-size fields + ** are within range. To be 'in range', both values need to be a power + ** of two greater than or equal to 512 or 32, and not greater than their + ** respective compile time maximum limits. + */ + if( iPageSize<512 || iSectorSize<32 + || iPageSize>SQLITE_MAX_PAGE_SIZE || iSectorSize>MAX_SECTOR_SIZE + || ((iPageSize-1)&iPageSize)!=0 || ((iSectorSize-1)&iSectorSize)!=0 + ){ + /* If the either the page-size or sector-size in the journal-header is + ** invalid, then the process that wrote the journal-header must have + ** crashed before the header was synced. In this case stop reading + ** the journal file here. + */ + return SQLITE_DONE; + } + + /* Update the page-size to match the value read from the journal. + ** Use a testcase() macro to make sure that malloc failure within + ** PagerSetPagesize() is tested. + */ + rc = sqlite3PagerSetPagesize(pPager, &iPageSize, -1); + testcase( rc!=SQLITE_OK ); + + /* Update the assumed sector-size to match the value used by + ** the process that created this journal. If this journal was + ** created by a process other than this one, then this routine + ** is being called from within pager_playback(). The local value + ** of Pager.sectorSize is restored at the end of that routine. + */ + pPager->sectorSize = iSectorSize; + } + + pPager->journalOff += JOURNAL_HDR_SZ(pPager); + return rc; +} + + +/* +** Write the supplied super-journal name into the journal file for pager +** pPager at the current location. The super-journal name must be the last +** thing written to a journal file. If the pager is in full-sync mode, the +** journal file descriptor is advanced to the next sector boundary before +** anything is written. The format is: +** +** + 4 bytes: PAGER_SJ_PGNO. +** + N bytes: super-journal filename in utf-8. +** + 4 bytes: N (length of super-journal name in bytes, no nul-terminator). +** + 4 bytes: super-journal name checksum. +** + 8 bytes: aJournalMagic[]. +** +** The super-journal page checksum is the sum of the bytes in thesuper-journal +** name, where each byte is interpreted as a signed 8-bit integer. +** +** If zSuper is a NULL pointer (occurs for a single database transaction), +** this call is a no-op. +*/ +static int writeSuperJournal(Pager *pPager, const char *zSuper){ + int rc; /* Return code */ + int nSuper; /* Length of string zSuper */ + i64 iHdrOff; /* Offset of header in journal file */ + i64 jrnlSize; /* Size of journal file on disk */ + u32 cksum = 0; /* Checksum of string zSuper */ + + assert( pPager->setSuper==0 ); + assert( !pagerUseWal(pPager) ); + + if( !zSuper + || pPager->journalMode==PAGER_JOURNALMODE_MEMORY + || !isOpen(pPager->jfd) + ){ + return SQLITE_OK; + } + pPager->setSuper = 1; + assert( pPager->journalHdr <= pPager->journalOff ); + + /* Calculate the length in bytes and the checksum of zSuper */ + for(nSuper=0; zSuper[nSuper]; nSuper++){ + cksum += zSuper[nSuper]; + } + + /* If in full-sync mode, advance to the next disk sector before writing + ** the super-journal name. This is in case the previous page written to + ** the journal has already been synced. + */ + if( pPager->fullSync ){ + pPager->journalOff = journalHdrOffset(pPager); + } + iHdrOff = pPager->journalOff; + + /* Write the super-journal data to the end of the journal file. If + ** an error occurs, return the error code to the caller. + */ + if( (0 != (rc = write32bits(pPager->jfd, iHdrOff, PAGER_SJ_PGNO(pPager)))) + || (0 != (rc = sqlite3OsWrite(pPager->jfd, zSuper, nSuper, iHdrOff+4))) + || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nSuper, nSuper))) + || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nSuper+4, cksum))) + || (0 != (rc = sqlite3OsWrite(pPager->jfd, aJournalMagic, 8, + iHdrOff+4+nSuper+8))) + ){ + return rc; + } + pPager->journalOff += (nSuper+20); + + /* If the pager is in peristent-journal mode, then the physical + ** journal-file may extend past the end of the super-journal name + ** and 8 bytes of magic data just written to the file. This is + ** dangerous because the code to rollback a hot-journal file + ** will not be able to find the super-journal name to determine + ** whether or not the journal is hot. + ** + ** Easiest thing to do in this scenario is to truncate the journal + ** file to the required size. + */ + if( SQLITE_OK==(rc = sqlite3OsFileSize(pPager->jfd, &jrnlSize)) + && jrnlSize>pPager->journalOff + ){ + rc = sqlite3OsTruncate(pPager->jfd, pPager->journalOff); + } + return rc; +} + +/* +** Discard the entire contents of the in-memory page-cache. +*/ +static void pager_reset(Pager *pPager){ + pPager->iDataVersion++; + sqlite3BackupRestart(pPager->pBackup); + sqlite3PcacheClear(pPager->pPCache); +} + +/* +** Return the pPager->iDataVersion value +*/ +SQLITE_PRIVATE u32 sqlite3PagerDataVersion(Pager *pPager){ + return pPager->iDataVersion; +} + +/* +** Free all structures in the Pager.aSavepoint[] array and set both +** Pager.aSavepoint and Pager.nSavepoint to zero. Close the sub-journal +** if it is open and the pager is not in exclusive mode. +*/ +static void releaseAllSavepoints(Pager *pPager){ + int ii; /* Iterator for looping through Pager.aSavepoint */ + for(ii=0; iinSavepoint; ii++){ + sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint); + } + if( !pPager->exclusiveMode || sqlite3JournalIsInMemory(pPager->sjfd) ){ + sqlite3OsClose(pPager->sjfd); + } + sqlite3_free(pPager->aSavepoint); + pPager->aSavepoint = 0; + pPager->nSavepoint = 0; + pPager->nSubRec = 0; +} + +/* +** Set the bit number pgno in the PagerSavepoint.pInSavepoint +** bitvecs of all open savepoints. Return SQLITE_OK if successful +** or SQLITE_NOMEM if a malloc failure occurs. +*/ +static int addToSavepointBitvecs(Pager *pPager, Pgno pgno){ + int ii; /* Loop counter */ + int rc = SQLITE_OK; /* Result code */ + + for(ii=0; iinSavepoint; ii++){ + PagerSavepoint *p = &pPager->aSavepoint[ii]; + if( pgno<=p->nOrig ){ + rc |= sqlite3BitvecSet(p->pInSavepoint, pgno); + testcase( rc==SQLITE_NOMEM ); + assert( rc==SQLITE_OK || rc==SQLITE_NOMEM ); + } + } + return rc; +} + +/* +** This function is a no-op if the pager is in exclusive mode and not +** in the ERROR state. Otherwise, it switches the pager to PAGER_OPEN +** state. +** +** If the pager is not in exclusive-access mode, the database file is +** completely unlocked. If the file is unlocked and the file-system does +** not exhibit the UNDELETABLE_WHEN_OPEN property, the journal file is +** closed (if it is open). +** +** If the pager is in ERROR state when this function is called, the +** contents of the pager cache are discarded before switching back to +** the OPEN state. Regardless of whether the pager is in exclusive-mode +** or not, any journal file left in the file-system will be treated +** as a hot-journal and rolled back the next time a read-transaction +** is opened (by this or by any other connection). +*/ +static void pager_unlock(Pager *pPager){ + + assert( pPager->eState==PAGER_READER + || pPager->eState==PAGER_OPEN + || pPager->eState==PAGER_ERROR + ); + + sqlite3BitvecDestroy(pPager->pInJournal); + pPager->pInJournal = 0; + releaseAllSavepoints(pPager); + + if( pagerUseWal(pPager) ){ + assert( !isOpen(pPager->jfd) ); + sqlite3WalEndReadTransaction(pPager->pWal); + pPager->eState = PAGER_OPEN; + }else if( !pPager->exclusiveMode ){ + int rc; /* Error code returned by pagerUnlockDb() */ + int iDc = isOpen(pPager->fd)?sqlite3OsDeviceCharacteristics(pPager->fd):0; + + /* If the operating system support deletion of open files, then + ** close the journal file when dropping the database lock. Otherwise + ** another connection with journal_mode=delete might delete the file + ** out from under us. + */ + assert( (PAGER_JOURNALMODE_MEMORY & 5)!=1 ); + assert( (PAGER_JOURNALMODE_OFF & 5)!=1 ); + assert( (PAGER_JOURNALMODE_WAL & 5)!=1 ); + assert( (PAGER_JOURNALMODE_DELETE & 5)!=1 ); + assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 ); + assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 ); + if( 0==(iDc & SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN) + || 1!=(pPager->journalMode & 5) + ){ + sqlite3OsClose(pPager->jfd); + } + + /* If the pager is in the ERROR state and the call to unlock the database + ** file fails, set the current lock to UNKNOWN_LOCK. See the comment + ** above the #define for UNKNOWN_LOCK for an explanation of why this + ** is necessary. + */ + rc = pagerUnlockDb(pPager, NO_LOCK); + if( rc!=SQLITE_OK && pPager->eState==PAGER_ERROR ){ + pPager->eLock = UNKNOWN_LOCK; + } + + /* The pager state may be changed from PAGER_ERROR to PAGER_OPEN here + ** without clearing the error code. This is intentional - the error + ** code is cleared and the cache reset in the block below. + */ + assert( pPager->errCode || pPager->eState!=PAGER_ERROR ); + pPager->eState = PAGER_OPEN; + } + + /* If Pager.errCode is set, the contents of the pager cache cannot be + ** trusted. Now that there are no outstanding references to the pager, + ** it can safely move back to PAGER_OPEN state. This happens in both + ** normal and exclusive-locking mode. + */ + assert( pPager->errCode==SQLITE_OK || !MEMDB ); + if( pPager->errCode ){ + if( pPager->tempFile==0 ){ + pager_reset(pPager); + pPager->changeCountDone = 0; + pPager->eState = PAGER_OPEN; + }else{ + pPager->eState = (isOpen(pPager->jfd) ? PAGER_OPEN : PAGER_READER); + } + if( USEFETCH(pPager) ) sqlite3OsUnfetch(pPager->fd, 0, 0); + pPager->errCode = SQLITE_OK; + setGetterMethod(pPager); + } + + pPager->journalOff = 0; + pPager->journalHdr = 0; + pPager->setSuper = 0; +} + +/* +** This function is called whenever an IOERR or FULL error that requires +** the pager to transition into the ERROR state may ahve occurred. +** The first argument is a pointer to the pager structure, the second +** the error-code about to be returned by a pager API function. The +** value returned is a copy of the second argument to this function. +** +** If the second argument is SQLITE_FULL, SQLITE_IOERR or one of the +** IOERR sub-codes, the pager enters the ERROR state and the error code +** is stored in Pager.errCode. While the pager remains in the ERROR state, +** all major API calls on the Pager will immediately return Pager.errCode. +** +** The ERROR state indicates that the contents of the pager-cache +** cannot be trusted. This state can be cleared by completely discarding +** the contents of the pager-cache. If a transaction was active when +** the persistent error occurred, then the rollback journal may need +** to be replayed to restore the contents of the database file (as if +** it were a hot-journal). +*/ +static int pager_error(Pager *pPager, int rc){ + int rc2 = rc & 0xff; + assert( rc==SQLITE_OK || !MEMDB ); + assert( + pPager->errCode==SQLITE_FULL || + pPager->errCode==SQLITE_OK || + (pPager->errCode & 0xff)==SQLITE_IOERR + ); + if( rc2==SQLITE_FULL || rc2==SQLITE_IOERR ){ + pPager->errCode = rc; + pPager->eState = PAGER_ERROR; + setGetterMethod(pPager); + } + return rc; +} + +static int pager_truncate(Pager *pPager, Pgno nPage); + +/* +** The write transaction open on pPager is being committed (bCommit==1) +** or rolled back (bCommit==0). +** +** Return TRUE if and only if all dirty pages should be flushed to disk. +** +** Rules: +** +** * For non-TEMP databases, always sync to disk. This is necessary +** for transactions to be durable. +** +** * Sync TEMP database only on a COMMIT (not a ROLLBACK) when the backing +** file has been created already (via a spill on pagerStress()) and +** when the number of dirty pages in memory exceeds 25% of the total +** cache size. +*/ +static int pagerFlushOnCommit(Pager *pPager, int bCommit){ + if( pPager->tempFile==0 ) return 1; + if( !bCommit ) return 0; + if( !isOpen(pPager->fd) ) return 0; + return (sqlite3PCachePercentDirty(pPager->pPCache)>=25); +} + +/* +** This routine ends a transaction. A transaction is usually ended by +** either a COMMIT or a ROLLBACK operation. This routine may be called +** after rollback of a hot-journal, or if an error occurs while opening +** the journal file or writing the very first journal-header of a +** database transaction. +** +** This routine is never called in PAGER_ERROR state. If it is called +** in PAGER_NONE or PAGER_SHARED state and the lock held is less +** exclusive than a RESERVED lock, it is a no-op. +** +** Otherwise, any active savepoints are released. +** +** If the journal file is open, then it is "finalized". Once a journal +** file has been finalized it is not possible to use it to roll back a +** transaction. Nor will it be considered to be a hot-journal by this +** or any other database connection. Exactly how a journal is finalized +** depends on whether or not the pager is running in exclusive mode and +** the current journal-mode (Pager.journalMode value), as follows: +** +** journalMode==MEMORY +** Journal file descriptor is simply closed. This destroys an +** in-memory journal. +** +** journalMode==TRUNCATE +** Journal file is truncated to zero bytes in size. +** +** journalMode==PERSIST +** The first 28 bytes of the journal file are zeroed. This invalidates +** the first journal header in the file, and hence the entire journal +** file. An invalid journal file cannot be rolled back. +** +** journalMode==DELETE +** The journal file is closed and deleted using sqlite3OsDelete(). +** +** If the pager is running in exclusive mode, this method of finalizing +** the journal file is never used. Instead, if the journalMode is +** DELETE and the pager is in exclusive mode, the method described under +** journalMode==PERSIST is used instead. +** +** After the journal is finalized, the pager moves to PAGER_READER state. +** If running in non-exclusive rollback mode, the lock on the file is +** downgraded to a SHARED_LOCK. +** +** SQLITE_OK is returned if no error occurs. If an error occurs during +** any of the IO operations to finalize the journal file or unlock the +** database then the IO error code is returned to the user. If the +** operation to finalize the journal file fails, then the code still +** tries to unlock the database file if not in exclusive mode. If the +** unlock operation fails as well, then the first error code related +** to the first error encountered (the journal finalization one) is +** returned. +*/ +static int pager_end_transaction(Pager *pPager, int hasSuper, int bCommit){ + int rc = SQLITE_OK; /* Error code from journal finalization operation */ + int rc2 = SQLITE_OK; /* Error code from db file unlock operation */ + + /* Do nothing if the pager does not have an open write transaction + ** or at least a RESERVED lock. This function may be called when there + ** is no write-transaction active but a RESERVED or greater lock is + ** held under two circumstances: + ** + ** 1. After a successful hot-journal rollback, it is called with + ** eState==PAGER_NONE and eLock==EXCLUSIVE_LOCK. + ** + ** 2. If a connection with locking_mode=exclusive holding an EXCLUSIVE + ** lock switches back to locking_mode=normal and then executes a + ** read-transaction, this function is called with eState==PAGER_READER + ** and eLock==EXCLUSIVE_LOCK when the read-transaction is closed. + */ + assert( assert_pager_state(pPager) ); + assert( pPager->eState!=PAGER_ERROR ); + if( pPager->eStateeLockjfd) || pPager->pInJournal==0 + || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_BATCH_ATOMIC) + ); + if( isOpen(pPager->jfd) ){ + assert( !pagerUseWal(pPager) ); + + /* Finalize the journal file. */ + if( sqlite3JournalIsInMemory(pPager->jfd) ){ + /* assert( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ); */ + sqlite3OsClose(pPager->jfd); + }else if( pPager->journalMode==PAGER_JOURNALMODE_TRUNCATE ){ + if( pPager->journalOff==0 ){ + rc = SQLITE_OK; + }else{ + rc = sqlite3OsTruncate(pPager->jfd, 0); + if( rc==SQLITE_OK && pPager->fullSync ){ + /* Make sure the new file size is written into the inode right away. + ** Otherwise the journal might resurrect following a power loss and + ** cause the last transaction to roll back. See + ** https://bugzilla.mozilla.org/show_bug.cgi?id=1072773 + */ + rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags); + } + } + pPager->journalOff = 0; + }else if( pPager->journalMode==PAGER_JOURNALMODE_PERSIST + || (pPager->exclusiveMode && pPager->journalMode!=PAGER_JOURNALMODE_WAL) + ){ + rc = zeroJournalHdr(pPager, hasSuper||pPager->tempFile); + pPager->journalOff = 0; + }else{ + /* This branch may be executed with Pager.journalMode==MEMORY if + ** a hot-journal was just rolled back. In this case the journal + ** file should be closed and deleted. If this connection writes to + ** the database file, it will do so using an in-memory journal. + */ + int bDelete = !pPager->tempFile; + assert( sqlite3JournalIsInMemory(pPager->jfd)==0 ); + assert( pPager->journalMode==PAGER_JOURNALMODE_DELETE + || pPager->journalMode==PAGER_JOURNALMODE_MEMORY + || pPager->journalMode==PAGER_JOURNALMODE_WAL + ); + sqlite3OsClose(pPager->jfd); + if( bDelete ){ + rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, pPager->extraSync); + } + } + } + +#ifdef SQLITE_CHECK_PAGES + sqlite3PcacheIterateDirty(pPager->pPCache, pager_set_pagehash); + if( pPager->dbSize==0 && sqlite3PcacheRefCount(pPager->pPCache)>0 ){ + PgHdr *p = sqlite3PagerLookup(pPager, 1); + if( p ){ + p->pageHash = 0; + sqlite3PagerUnrefNotNull(p); + } + } +#endif + + sqlite3BitvecDestroy(pPager->pInJournal); + pPager->pInJournal = 0; + pPager->nRec = 0; + if( rc==SQLITE_OK ){ + if( MEMDB || pagerFlushOnCommit(pPager, bCommit) ){ + sqlite3PcacheCleanAll(pPager->pPCache); + }else{ + sqlite3PcacheClearWritable(pPager->pPCache); + } + sqlite3PcacheTruncate(pPager->pPCache, pPager->dbSize); + } + + if( pagerUseWal(pPager) ){ + /* Drop the WAL write-lock, if any. Also, if the connection was in + ** locking_mode=exclusive mode but is no longer, drop the EXCLUSIVE + ** lock held on the database file. + */ + rc2 = sqlite3WalEndWriteTransaction(pPager->pWal); + assert( rc2==SQLITE_OK ); + }else if( rc==SQLITE_OK && bCommit && pPager->dbFileSize>pPager->dbSize ){ + /* This branch is taken when committing a transaction in rollback-journal + ** mode if the database file on disk is larger than the database image. + ** At this point the journal has been finalized and the transaction + ** successfully committed, but the EXCLUSIVE lock is still held on the + ** file. So it is safe to truncate the database file to its minimum + ** required size. */ + assert( pPager->eLock==EXCLUSIVE_LOCK ); + rc = pager_truncate(pPager, pPager->dbSize); + } + + if( rc==SQLITE_OK && bCommit ){ + rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_COMMIT_PHASETWO, 0); + if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK; + } + + if( !pPager->exclusiveMode + && (!pagerUseWal(pPager) || sqlite3WalExclusiveMode(pPager->pWal, 0)) + ){ + rc2 = pagerUnlockDb(pPager, SHARED_LOCK); + } + pPager->eState = PAGER_READER; + pPager->setSuper = 0; + + return (rc==SQLITE_OK?rc2:rc); +} + +/* +** Execute a rollback if a transaction is active and unlock the +** database file. +** +** If the pager has already entered the ERROR state, do not attempt +** the rollback at this time. Instead, pager_unlock() is called. The +** call to pager_unlock() will discard all in-memory pages, unlock +** the database file and move the pager back to OPEN state. If this +** means that there is a hot-journal left in the file-system, the next +** connection to obtain a shared lock on the pager (which may be this one) +** will roll it back. +** +** If the pager has not already entered the ERROR state, but an IO or +** malloc error occurs during a rollback, then this will itself cause +** the pager to enter the ERROR state. Which will be cleared by the +** call to pager_unlock(), as described above. +*/ +static void pagerUnlockAndRollback(Pager *pPager){ + if( pPager->eState!=PAGER_ERROR && pPager->eState!=PAGER_OPEN ){ + assert( assert_pager_state(pPager) ); + if( pPager->eState>=PAGER_WRITER_LOCKED ){ + sqlite3BeginBenignMalloc(); + sqlite3PagerRollback(pPager); + sqlite3EndBenignMalloc(); + }else if( !pPager->exclusiveMode ){ + assert( pPager->eState==PAGER_READER ); + pager_end_transaction(pPager, 0, 0); + } + } + pager_unlock(pPager); +} + +/* +** Parameter aData must point to a buffer of pPager->pageSize bytes +** of data. Compute and return a checksum based ont the contents of the +** page of data and the current value of pPager->cksumInit. +** +** This is not a real checksum. It is really just the sum of the +** random initial value (pPager->cksumInit) and every 200th byte +** of the page data, starting with byte offset (pPager->pageSize%200). +** Each byte is interpreted as an 8-bit unsigned integer. +** +** Changing the formula used to compute this checksum results in an +** incompatible journal file format. +** +** If journal corruption occurs due to a power failure, the most likely +** scenario is that one end or the other of the record will be changed. +** It is much less likely that the two ends of the journal record will be +** correct and the middle be corrupt. Thus, this "checksum" scheme, +** though fast and simple, catches the mostly likely kind of corruption. +*/ +static u32 pager_cksum(Pager *pPager, const u8 *aData){ + u32 cksum = pPager->cksumInit; /* Checksum value to return */ + int i = pPager->pageSize-200; /* Loop counter */ + while( i>0 ){ + cksum += aData[i]; + i -= 200; + } + return cksum; +} + +/* +** Report the current page size and number of reserved bytes back +** to the codec. +*/ +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC +static void pagerReportSize(Pager *pPager){ + if( pPager->xCodecSizeChng ){ + pPager->xCodecSizeChng(pPager->pCodec, pPager->pageSize, + (int)pPager->nReserve); + } +} +#else +# define pagerReportSize(X) /* No-op if we do not support a codec */ +#endif +/* END SQLCIPHER */ + +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC +/* +** Make sure the number of reserved bits is the same in the destination +** pager as it is in the source. This comes up when a VACUUM changes the +** number of reserved bits to the "optimal" amount. +*/ +SQLITE_PRIVATE void sqlite3PagerAlignReserve(Pager *pDest, Pager *pSrc){ + if( pDest->nReserve!=pSrc->nReserve ){ + pDest->nReserve = pSrc->nReserve; + pagerReportSize(pDest); + } +} +#endif +/* END SQLCIPHER */ + +/* +** Read a single page from either the journal file (if isMainJrnl==1) or +** from the sub-journal (if isMainJrnl==0) and playback that page. +** The page begins at offset *pOffset into the file. The *pOffset +** value is increased to the start of the next page in the journal. +** +** The main rollback journal uses checksums - the statement journal does +** not. +** +** If the page number of the page record read from the (sub-)journal file +** is greater than the current value of Pager.dbSize, then playback is +** skipped and SQLITE_OK is returned. +** +** If pDone is not NULL, then it is a record of pages that have already +** been played back. If the page at *pOffset has already been played back +** (if the corresponding pDone bit is set) then skip the playback. +** Make sure the pDone bit corresponding to the *pOffset page is set +** prior to returning. +** +** If the page record is successfully read from the (sub-)journal file +** and played back, then SQLITE_OK is returned. If an IO error occurs +** while reading the record from the (sub-)journal file or while writing +** to the database file, then the IO error code is returned. If data +** is successfully read from the (sub-)journal file but appears to be +** corrupted, SQLITE_DONE is returned. Data is considered corrupted in +** two circumstances: +** +** * If the record page-number is illegal (0 or PAGER_SJ_PGNO), or +** * If the record is being rolled back from the main journal file +** and the checksum field does not match the record content. +** +** Neither of these two scenarios are possible during a savepoint rollback. +** +** If this is a savepoint rollback, then memory may have to be dynamically +** allocated by this function. If this is the case and an allocation fails, +** SQLITE_NOMEM is returned. +*/ +static int pager_playback_one_page( + Pager *pPager, /* The pager being played back */ + i64 *pOffset, /* Offset of record to playback */ + Bitvec *pDone, /* Bitvec of pages already played back */ + int isMainJrnl, /* 1 -> main journal. 0 -> sub-journal. */ + int isSavepnt /* True for a savepoint rollback */ +){ + int rc; + PgHdr *pPg; /* An existing page in the cache */ + Pgno pgno; /* The page number of a page in journal */ + u32 cksum; /* Checksum used for sanity checking */ + char *aData; /* Temporary storage for the page */ + sqlite3_file *jfd; /* The file descriptor for the journal file */ + int isSynced; /* True if journal page is synced */ +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC + /* The jrnlEnc flag is true if Journal pages should be passed through + ** the codec. It is false for pure in-memory journals. */ + const int jrnlEnc = (isMainJrnl || pPager->subjInMemory==0); +#endif +/* END SQLCIPHER */ + + assert( (isMainJrnl&~1)==0 ); /* isMainJrnl is 0 or 1 */ + assert( (isSavepnt&~1)==0 ); /* isSavepnt is 0 or 1 */ + assert( isMainJrnl || pDone ); /* pDone always used on sub-journals */ + assert( isSavepnt || pDone==0 ); /* pDone never used on non-savepoint */ + + aData = pPager->pTmpSpace; + assert( aData ); /* Temp storage must have already been allocated */ + assert( pagerUseWal(pPager)==0 || (!isMainJrnl && isSavepnt) ); + + /* Either the state is greater than PAGER_WRITER_CACHEMOD (a transaction + ** or savepoint rollback done at the request of the caller) or this is + ** a hot-journal rollback. If it is a hot-journal rollback, the pager + ** is in state OPEN and holds an EXCLUSIVE lock. Hot-journal rollback + ** only reads from the main journal, not the sub-journal. + */ + assert( pPager->eState>=PAGER_WRITER_CACHEMOD + || (pPager->eState==PAGER_OPEN && pPager->eLock==EXCLUSIVE_LOCK) + ); + assert( pPager->eState>=PAGER_WRITER_CACHEMOD || isMainJrnl ); + + /* Read the page number and page data from the journal or sub-journal + ** file. Return an error code to the caller if an IO error occurs. + */ + jfd = isMainJrnl ? pPager->jfd : pPager->sjfd; + rc = read32bits(jfd, *pOffset, &pgno); + if( rc!=SQLITE_OK ) return rc; + rc = sqlite3OsRead(jfd, (u8*)aData, pPager->pageSize, (*pOffset)+4); + if( rc!=SQLITE_OK ) return rc; + *pOffset += pPager->pageSize + 4 + isMainJrnl*4; + + /* Sanity checking on the page. This is more important that I originally + ** thought. If a power failure occurs while the journal is being written, + ** it could cause invalid data to be written into the journal. We need to + ** detect this invalid data (with high probability) and ignore it. + */ + if( pgno==0 || pgno==PAGER_SJ_PGNO(pPager) ){ + assert( !isSavepnt ); + return SQLITE_DONE; + } + if( pgno>(Pgno)pPager->dbSize || sqlite3BitvecTest(pDone, pgno) ){ + return SQLITE_OK; + } + if( isMainJrnl ){ + rc = read32bits(jfd, (*pOffset)-4, &cksum); + if( rc ) return rc; + if( !isSavepnt && pager_cksum(pPager, (u8*)aData)!=cksum ){ + return SQLITE_DONE; + } + } + + /* If this page has already been played back before during the current + ** rollback, then don't bother to play it back again. + */ + if( pDone && (rc = sqlite3BitvecSet(pDone, pgno))!=SQLITE_OK ){ + return rc; + } + + /* When playing back page 1, restore the nReserve setting + */ + if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){ + pPager->nReserve = ((u8*)aData)[20]; + pagerReportSize(pPager); + } + + /* If the pager is in CACHEMOD state, then there must be a copy of this + ** page in the pager cache. In this case just update the pager cache, + ** not the database file. The page is left marked dirty in this case. + ** + ** An exception to the above rule: If the database is in no-sync mode + ** and a page is moved during an incremental vacuum then the page may + ** not be in the pager cache. Later: if a malloc() or IO error occurs + ** during a Movepage() call, then the page may not be in the cache + ** either. So the condition described in the above paragraph is not + ** assert()able. + ** + ** If in WRITER_DBMOD, WRITER_FINISHED or OPEN state, then we update the + ** pager cache if it exists and the main file. The page is then marked + ** not dirty. Since this code is only executed in PAGER_OPEN state for + ** a hot-journal rollback, it is guaranteed that the page-cache is empty + ** if the pager is in OPEN state. + ** + ** Ticket #1171: The statement journal might contain page content that is + ** different from the page content at the start of the transaction. + ** This occurs when a page is changed prior to the start of a statement + ** then changed again within the statement. When rolling back such a + ** statement we must not write to the original database unless we know + ** for certain that original page contents are synced into the main rollback + ** journal. Otherwise, a power loss might leave modified data in the + ** database file without an entry in the rollback journal that can + ** restore the database to its original form. Two conditions must be + ** met before writing to the database files. (1) the database must be + ** locked. (2) we know that the original page content is fully synced + ** in the main journal either because the page is not in cache or else + ** the page is marked as needSync==0. + ** + ** 2008-04-14: When attempting to vacuum a corrupt database file, it + ** is possible to fail a statement on a database that does not yet exist. + ** Do not attempt to write if database file has never been opened. + */ + if( pagerUseWal(pPager) ){ + pPg = 0; + }else{ + pPg = sqlite3PagerLookup(pPager, pgno); + } + assert( pPg || !MEMDB ); + assert( pPager->eState!=PAGER_OPEN || pPg==0 || pPager->tempFile ); + PAGERTRACE(("PLAYBACK %d page %d hash(%08x) %s\n", + PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData), + (isMainJrnl?"main-journal":"sub-journal") + )); + if( isMainJrnl ){ + isSynced = pPager->noSync || (*pOffset <= pPager->journalHdr); + }else{ + isSynced = (pPg==0 || 0==(pPg->flags & PGHDR_NEED_SYNC)); + } + if( isOpen(pPager->fd) + && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN) + && isSynced + ){ + i64 ofst = (pgno-1)*(i64)pPager->pageSize; + testcase( !isSavepnt && pPg!=0 && (pPg->flags&PGHDR_NEED_SYNC)!=0 ); + assert( !pagerUseWal(pPager) ); + + /* Write the data read from the journal back into the database file. + ** This is usually safe even for an encrypted database - as the data + ** was encrypted before it was written to the journal file. The exception + ** is if the data was just read from an in-memory sub-journal. In that + ** case it must be encrypted here before it is copied into the database + ** file. */ +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC + if( !jrnlEnc ){ + CODEC2(pPager, aData, pgno, 7, rc=SQLITE_NOMEM_BKPT, aData); + rc = sqlite3OsWrite(pPager->fd, (u8 *)aData, pPager->pageSize, ofst); + CODEC1(pPager, aData, pgno, 3, rc=SQLITE_NOMEM_BKPT); + }else +#endif +/* END SQLCIPHER */ + rc = sqlite3OsWrite(pPager->fd, (u8 *)aData, pPager->pageSize, ofst); + + if( pgno>pPager->dbFileSize ){ + pPager->dbFileSize = pgno; + } + if( pPager->pBackup ){ +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC + if( jrnlEnc ){ + CODEC1(pPager, aData, pgno, 3, rc=SQLITE_NOMEM_BKPT); + sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData); + CODEC2(pPager, aData, pgno, 7, rc=SQLITE_NOMEM_BKPT,aData); + }else +#endif +/* END SQLCIPHER */ + sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData); + } + }else if( !isMainJrnl && pPg==0 ){ + /* If this is a rollback of a savepoint and data was not written to + ** the database and the page is not in-memory, there is a potential + ** problem. When the page is next fetched by the b-tree layer, it + ** will be read from the database file, which may or may not be + ** current. + ** + ** There are a couple of different ways this can happen. All are quite + ** obscure. When running in synchronous mode, this can only happen + ** if the page is on the free-list at the start of the transaction, then + ** populated, then moved using sqlite3PagerMovepage(). + ** + ** The solution is to add an in-memory page to the cache containing + ** the data just read from the sub-journal. Mark the page as dirty + ** and if the pager requires a journal-sync, then mark the page as + ** requiring a journal-sync before it is written. + */ + assert( isSavepnt ); + assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)==0 ); + pPager->doNotSpill |= SPILLFLAG_ROLLBACK; + rc = sqlite3PagerGet(pPager, pgno, &pPg, 1); + assert( (pPager->doNotSpill & SPILLFLAG_ROLLBACK)!=0 ); + pPager->doNotSpill &= ~SPILLFLAG_ROLLBACK; + if( rc!=SQLITE_OK ) return rc; + sqlite3PcacheMakeDirty(pPg); + } + if( pPg ){ + /* No page should ever be explicitly rolled back that is in use, except + ** for page 1 which is held in use in order to keep the lock on the + ** database active. However such a page may be rolled back as a result + ** of an internal error resulting in an automatic call to + ** sqlite3PagerRollback(). + */ + void *pData; + pData = pPg->pData; + memcpy(pData, (u8*)aData, pPager->pageSize); + pPager->xReiniter(pPg); + /* It used to be that sqlite3PcacheMakeClean(pPg) was called here. But + ** that call was dangerous and had no detectable benefit since the cache + ** is normally cleaned by sqlite3PcacheCleanAll() after rollback and so + ** has been removed. */ + pager_set_pagehash(pPg); + + /* If this was page 1, then restore the value of Pager.dbFileVers. + ** Do this before any decoding. */ + if( pgno==1 ){ + memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers)); + } + + /* Decode the page just read from disk */ +/* BEGIN SQLCIPHER */ +#if SQLITE_HAS_CODEC + if( jrnlEnc ){ CODEC1(pPager, pData, pPg->pgno, 3, rc=SQLITE_NOMEM_BKPT); } +#endif +/* END SQLCIPHER */ + sqlite3PcacheRelease(pPg); + } + return rc; +} + +/* +** Parameter zSuper is the name of a super-journal file. A single journal +** file that referred to the super-journal file has just been rolled back. +** This routine checks if it is possible to delete the super-journal file, +** and does so if it is. +** +** Argument zSuper may point to Pager.pTmpSpace. So that buffer is not +** available for use within this function. +** +** When a super-journal file is created, it is populated with the names +** of all of its child journals, one after another, formatted as utf-8 +** encoded text. The end of each child journal file is marked with a +** nul-terminator byte (0x00). i.e. the entire contents of a super-journal +** file for a transaction involving two databases might be: +** +** "/home/bill/a.db-journal\x00/home/bill/b.db-journal\x00" +** +** A super-journal file may only be deleted once all of its child +** journals have been rolled back. +** +** This function reads the contents of the super-journal file into +** memory and loops through each of the child journal names. For +** each child journal, it checks if: +** +** * if the child journal exists, and if so +** * if the child journal contains a reference to super-journal +** file zSuper +** +** If a child journal can be found that matches both of the criteria +** above, this function returns without doing anything. Otherwise, if +** no such child journal can be found, file zSuper is deleted from +** the file-system using sqlite3OsDelete(). +** +** If an IO error within this function, an error code is returned. This +** function allocates memory by calling sqlite3Malloc(). If an allocation +** fails, SQLITE_NOMEM is returned. Otherwise, if no IO or malloc errors +** occur, SQLITE_OK is returned. +** +** TODO: This function allocates a single block of memory to load +** the entire contents of the super-journal file. This could be +** a couple of kilobytes or so - potentially larger than the page +** size. +*/ +static int pager_delsuper(Pager *pPager, const char *zSuper){ + sqlite3_vfs *pVfs = pPager->pVfs; + int rc; /* Return code */ + sqlite3_file *pSuper; /* Malloc'd super-journal file descriptor */ + sqlite3_file *pJournal; /* Malloc'd child-journal file descriptor */ + char *zSuperJournal = 0; /* Contents of super-journal file */ + i64 nSuperJournal; /* Size of super-journal file */ + char *zJournal; /* Pointer to one journal within MJ file */ + char *zSuperPtr; /* Space to hold super-journal filename */ + char *zFree = 0; /* Free this buffer */ + int nSuperPtr; /* Amount of space allocated to zSuperPtr[] */ + + /* Allocate space for both the pJournal and pSuper file descriptors. + ** If successful, open the super-journal file for reading. + */ + pSuper = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile * 2); + if( !pSuper ){ + rc = SQLITE_NOMEM_BKPT; + pJournal = 0; + }else{ + const int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_SUPER_JOURNAL); + rc = sqlite3OsOpen(pVfs, zSuper, pSuper, flags, 0); + pJournal = (sqlite3_file *)(((u8 *)pSuper) + pVfs->szOsFile); + } + if( rc!=SQLITE_OK ) goto delsuper_out; + + /* Load the entire super-journal file into space obtained from + ** sqlite3_malloc() and pointed to by zSuperJournal. Also obtain + ** sufficient space (in zSuperPtr) to hold the names of super-journal + ** files extracted from regular rollback-journals. + */ + rc = sqlite3OsFileSize(pSuper, &nSuperJournal); + if( rc!=SQLITE_OK ) goto delsuper_out; + nSuperPtr = pVfs->mxPathname+1; + zFree = sqlite3Malloc(4 + nSuperJournal + nSuperPtr + 2); + if( !zFree ){ + rc = SQLITE_NOMEM_BKPT; + goto delsuper_out; + } + zFree[0] = zFree[1] = zFree[2] = zFree[3] = 0; + zSuperJournal = &zFree[4]; + zSuperPtr = &zSuperJournal[nSuperJournal+2]; + rc = sqlite3OsRead(pSuper, zSuperJournal, (int)nSuperJournal, 0); + if( rc!=SQLITE_OK ) goto delsuper_out; + zSuperJournal[nSuperJournal] = 0; + zSuperJournal[nSuperJournal+1] = 0; + + zJournal = zSuperJournal; + while( (zJournal-zSuperJournal)pageSize bytes). +** If the file on disk is currently larger than nPage pages, then use the VFS +** xTruncate() method to truncate it. +** +** Or, it might be the case that the file on disk is smaller than +** nPage pages. Some operating system implementations can get confused if +** you try to truncate a file to some size that is larger than it +** currently is, so detect this case and write a single zero byte to +** the end of the new file instead. +** +** If successful, return SQLITE_OK. If an IO error occurs while modifying +** the database file, return the error code to the caller. +*/ +static int pager_truncate(Pager *pPager, Pgno nPage){ + int rc = SQLITE_OK; + assert( pPager->eState!=PAGER_ERROR ); + assert( pPager->eState!=PAGER_READER ); + PAGERTRACE(("Truncate %d npage %u\n", PAGERID(pPager), nPage)); + + + if( isOpen(pPager->fd) + && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN) + ){ + i64 currentSize, newSize; + int szPage = pPager->pageSize; + assert( pPager->eLock==EXCLUSIVE_LOCK ); + /* TODO: Is it safe to use Pager.dbFileSize here? */ + rc = sqlite3OsFileSize(pPager->fd, ¤tSize); + newSize = szPage*(i64)nPage; + if( rc==SQLITE_OK && currentSize!=newSize ){ + if( currentSize>newSize ){ + rc = sqlite3OsTruncate(pPager->fd, newSize); + }else if( (currentSize+szPage)<=newSize ){ + char *pTmp = pPager->pTmpSpace; + memset(pTmp, 0, szPage); + testcase( (newSize-szPage) == currentSize ); + testcase( (newSize-szPage) > currentSize ); + sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_SIZE_HINT, &newSize); + rc = sqlite3OsWrite(pPager->fd, pTmp, szPage, newSize-szPage); + } + if( rc==SQLITE_OK ){ + pPager->dbFileSize = nPage; + } + } + } + return rc; +} + +/* +** Return a sanitized version of the sector-size of OS file pFile. The +** return value is guaranteed to lie between 32 and MAX_SECTOR_SIZE. +*/ +SQLITE_PRIVATE int sqlite3SectorSize(sqlite3_file *pFile){ + int iRet = sqlite3OsSectorSize(pFile); + if( iRet<32 ){ + iRet = 512; + }else if( iRet>MAX_SECTOR_SIZE ){ + assert( MAX_SECTOR_SIZE>=512 ); + iRet = MAX_SECTOR_SIZE; + } + return iRet; +} + +/* +** Set the value of the Pager.sectorSize variable for the given +** pager based on the value returned by the xSectorSize method +** of the open database file. The sector size will be used +** to determine the size and alignment of journal header and +** super-journal pointers within created journal files. +** +** For temporary files the effective sector size is always 512 bytes. +** +** Otherwise, for non-temporary files, the effective sector size is +** the value returned by the xSectorSize() method rounded up to 32 if +** it is less than 32, or rounded down to MAX_SECTOR_SIZE if it +** is greater than MAX_SECTOR_SIZE. +** +** If the file has the SQLITE_IOCAP_POWERSAFE_OVERWRITE property, then set +** the effective sector size to its minimum value (512). The purpose of +** pPager->sectorSize is to define the "blast radius" of bytes that +** might change if a crash occurs while writing to a single byte in +** that range. But with POWERSAFE_OVERWRITE, the blast radius is zero +** (that is what POWERSAFE_OVERWRITE means), so we minimize the sector +** size. For backwards compatibility of the rollback journal file format, +** we cannot reduce the effective sector size below 512. +*/ +static void setSectorSize(Pager *pPager){ + assert( isOpen(pPager->fd) || pPager->tempFile ); + + if( pPager->tempFile + || (sqlite3OsDeviceCharacteristics(pPager->fd) & + SQLITE_IOCAP_POWERSAFE_OVERWRITE)!=0 + ){ + /* Sector size doesn't matter for temporary files. Also, the file + ** may not have been opened yet, in which case the OsSectorSize() + ** call will segfault. */ + pPager->sectorSize = 512; + }else{ + pPager->sectorSize = sqlite3SectorSize(pPager->fd); + } +} + +/* +** Playback the journal and thus restore the database file to +** the state it was in before we started making changes. +** +** The journal file format is as follows: +** +** (1) 8 byte prefix. A copy of aJournalMagic[]. +** (2) 4 byte big-endian integer which is the number of valid page records +** in the journal. If this value is 0xffffffff, then compute the +** number of page records from the journal size. +** (3) 4 byte big-endian integer which is the initial value for the +** sanity checksum. +** (4) 4 byte integer which is the number of pages to truncate the +** database to during a rollback. +** (5) 4 byte big-endian integer which is the sector size. The header +** is this many bytes in size. +** (6) 4 byte big-endian integer which is the page size. +** (7) zero padding out to the next sector size. +** (8) Zero or more pages instances, each as follows: +** + 4 byte page number. +** + pPager->pageSize bytes of data. +** + 4 byte checksum +** +** When we speak of the journal header, we mean the first 7 items above. +** Each entry in the journal is an instance of the 8th item. +** +** Call the value from the second bullet "nRec". nRec is the number of +** valid page entries in the journal. In most cases, you can compute the +** value of nRec from the size of the journal file. But if a power +** failure occurred while the journal was being written, it could be the +** case that the size of the journal file had already been increased but +** the extra entries had not yet made it safely to disk. In such a case, +** the value of nRec computed from the file size would be too large. For +** that reason, we always use the nRec value in the header. +** +** If the nRec value is 0xffffffff it means that nRec should be computed +** from the file size. This value is used when the user selects the +** no-sync option for the journal. A power failure could lead to corruption +** in this case. But for things like temporary table (which will be +** deleted when the power is restored) we don't care. +** +** If the file opened as the journal file is not a well-formed +** journal file then all pages up to the first corrupted page are rolled +** back (or no pages if the journal header is corrupted). The journal file +** is then deleted and SQLITE_OK returned, just as if no corruption had +** been encountered. +** +** If an I/O or malloc() error occurs, the journal-file is not deleted +** and an error code is returned. +** +** The isHot parameter indicates that we are trying to rollback a journal +** that might be a hot journal. Or, it could be that the journal is +** preserved because of JOURNALMODE_PERSIST or JOURNALMODE_TRUNCATE. +** If the journal really is hot, reset the pager cache prior rolling +** back any content. If the journal is merely persistent, no reset is +** needed. +*/ +static int pager_playback(Pager *pPager, int isHot){ + sqlite3_vfs *pVfs = pPager->pVfs; + i64 szJ; /* Size of the journal file in bytes */ + u32 nRec; /* Number of Records in the journal */ + u32 u; /* Unsigned loop counter */ + Pgno mxPg = 0; /* Size of the original file in pages */ + int rc; /* Result code of a subroutine */ + int res = 1; /* Value returned by sqlite3OsAccess() */ + char *zSuper = 0; /* Name of super-journal file if any */ + int needPagerReset; /* True to reset page prior to first page rollback */ + int nPlayback = 0; /* Total number of pages restored from journal */ + u32 savedPageSize = pPager->pageSize; + + /* Figure out how many records are in the journal. Abort early if + ** the journal is empty. + */ + assert( isOpen(pPager->jfd) ); + rc = sqlite3OsFileSize(pPager->jfd, &szJ); + if( rc!=SQLITE_OK ){ + goto end_playback; + } + + /* Read the super-journal name from the journal, if it is present. + ** If a super-journal file name is specified, but the file is not + ** present on disk, then the journal is not hot and does not need to be + ** played back. + ** + ** TODO: Technically the following is an error because it assumes that + ** buffer Pager.pTmpSpace is (mxPathname+1) bytes or larger. i.e. that + ** (pPager->pageSize >= pPager->pVfs->mxPathname+1). Using os_unix.c, + ** mxPathname is 512, which is the same as the minimum allowable value + ** for pageSize. + */ + zSuper = pPager->pTmpSpace; + rc = readSuperJournal(pPager->jfd, zSuper, pPager->pVfs->mxPathname+1); + if( rc==SQLITE_OK && zSuper[0] ){ + rc = sqlite3OsAccess(pVfs, zSuper, SQLITE_ACCESS_EXISTS, &res); + } + zSuper = 0; + if( rc!=SQLITE_OK || !res ){ + goto end_playback; + } + pPager->journalOff = 0; + needPagerReset = isHot; + + /* This loop terminates either when a readJournalHdr() or + ** pager_playback_one_page() call returns SQLITE_DONE or an IO error + ** occurs. + */ + while( 1 ){ + /* Read the next journal header from the journal file. If there are + ** not enough bytes left in the journal file for a complete header, or + ** it is corrupted, then a process must have failed while writing it. + ** This indicates nothing more needs to be rolled back. + */ + rc = readJournalHdr(pPager, isHot, szJ, &nRec, &mxPg); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_DONE ){ + rc = SQLITE_OK; + } + goto end_playback; + } + + /* If nRec is 0xffffffff, then this journal was created by a process + ** working in no-sync mode. This means that the rest of the journal + ** file consists of pages, there are no more journal headers. Compute + ** the value of nRec based on this assumption. + */ + if( nRec==0xffffffff ){ + assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ); + nRec = (int)((szJ - JOURNAL_HDR_SZ(pPager))/JOURNAL_PG_SZ(pPager)); + } + + /* If nRec is 0 and this rollback is of a transaction created by this + ** process and if this is the final header in the journal, then it means + ** that this part of the journal was being filled but has not yet been + ** synced to disk. Compute the number of pages based on the remaining + ** size of the file. + ** + ** The third term of the test was added to fix ticket #2565. + ** When rolling back a hot journal, nRec==0 always means that the next + ** chunk of the journal contains zero pages to be rolled back. But + ** when doing a ROLLBACK and the nRec==0 chunk is the last chunk in + ** the journal, it means that the journal might contain additional + ** pages that need to be rolled back and that the number of pages + ** should be computed based on the journal file size. + */ + if( nRec==0 && !isHot && + pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ){ + nRec = (int)((szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager)); + } + + /* If this is the first header read from the journal, truncate the + ** database file back to its original size. + */ + if( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ){ + rc = pager_truncate(pPager, mxPg); + if( rc!=SQLITE_OK ){ + goto end_playback; + } + pPager->dbSize = mxPg; + if( pPager->mxPgnomxPgno = mxPg; + } + } + + /* Copy original pages out of the journal and back into the + ** database file and/or page cache. + */ + for(u=0; ujournalOff,0,1,0); + if( rc==SQLITE_OK ){ + nPlayback++; + }else{ + if( rc==SQLITE_DONE ){ + pPager->journalOff = szJ; + break; + }else if( rc==SQLITE_IOERR_SHORT_READ ){ + /* If the journal has been truncated, simply stop reading and + ** processing the journal. This might happen if the journal was + ** not completely written and synced prior to a crash. In that + ** case, the database should have never been written in the + ** first place so it is OK to simply abandon the rollback. */ + rc = SQLITE_OK; + goto end_playback; + }else{ + /* If we are unable to rollback, quit and return the error + ** code. This will cause the pager to enter the error state + ** so that no further harm will be done. Perhaps the next + ** process to come along will be able to rollback the database. + */ + goto end_playback; + } + } + } + } + /*NOTREACHED*/ + assert( 0 ); + +end_playback: + if( rc==SQLITE_OK ){ + rc = sqlite3PagerSetPagesize(pPager, &savedPageSize, -1); + } + /* Following a rollback, the database file should be back in its original + ** state prior to the start of the transaction, so invoke the + ** SQLITE_FCNTL_DB_UNCHANGED file-control method to disable the + ** assertion that the transaction counter was modified. + */ +#ifdef SQLITE_DEBUG + sqlite3OsFileControlHint(pPager->fd,SQLITE_FCNTL_DB_UNCHANGED,0); +#endif + + /* If this playback is happening automatically as a result of an IO or + ** malloc error that occurred after the change-counter was updated but + ** before the transaction was committed, then the change-counter + ** modification may just have been reverted. If this happens in exclusive + ** mode, then subsequent transactions performed by the connection will not + ** update the change-counter at all. This may lead to cache inconsistency + ** problems for other processes at some point in the future. So, just + ** in case this has happened, clear the changeCountDone flag now. + */ + pPager->changeCountDone = pPager->tempFile; + + if( rc==SQLITE_OK ){ + /* Leave 4 bytes of space before the super-journal filename in memory. + ** This is because it may end up being passed to sqlite3OsOpen(), in + ** which case it requires 4 0x00 bytes in memory immediately before + ** the filename. */ + zSuper = &pPager->pTmpSpace[4]; + rc = readSuperJournal(pPager->jfd, zSuper, pPager->pVfs->mxPathname+1); + testcase( rc!=SQLITE_OK ); + } + if( rc==SQLITE_OK + && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN) + ){ + rc = sqlite3PagerSync(pPager, 0); + } + if( rc==SQLITE_OK ){ + rc = pager_end_transaction(pPager, zSuper[0]!='\0', 0); + testcase( rc!=SQLITE_OK ); + } + if( rc==SQLITE_OK && zSuper[0] && res ){ + /* If there was a super-journal and this routine will return success, + ** see if it is possible to delete the super-journal. + */ + assert( zSuper==&pPager->pTmpSpace[4] ); + memset(pPager->pTmpSpace, 0, 4); + rc = pager_delsuper(pPager, zSuper); + testcase( rc!=SQLITE_OK ); + } + if( isHot && nPlayback ){ + sqlite3_log(SQLITE_NOTICE_RECOVER_ROLLBACK, "recovered %d pages from %s", + nPlayback, pPager->zJournal); + } + + /* The Pager.sectorSize variable may have been updated while rolling + ** back a journal created by a process with a different sector size + ** value. Reset it to the correct value for this process. + */ + setSectorSize(pPager); + return rc; +} + + +/* +** Read the content for page pPg out of the database file (or out of +** the WAL if that is where the most recent copy if found) into +** pPg->pData. A shared lock or greater must be held on the database +** file before this function is called. +** +** If page 1 is read, then the value of Pager.dbFileVers[] is set to +** the value read from the database file. +** +** If an IO error occurs, then the IO error is returned to the caller. +** Otherwise, SQLITE_OK is returned. +*/ +static int readDbPage(PgHdr *pPg){ + Pager *pPager = pPg->pPager; /* Pager object associated with page pPg */ + int rc = SQLITE_OK; /* Return code */ + +#ifndef SQLITE_OMIT_WAL + u32 iFrame = 0; /* Frame of WAL containing pgno */ + + assert( pPager->eState>=PAGER_READER && !MEMDB ); + assert( isOpen(pPager->fd) ); + + if( pagerUseWal(pPager) ){ + rc = sqlite3WalFindFrame(pPager->pWal, pPg->pgno, &iFrame); + if( rc ) return rc; + } + if( iFrame ){ + rc = sqlite3WalReadFrame(pPager->pWal, iFrame,pPager->pageSize,pPg->pData); + }else +#endif + { + i64 iOffset = (pPg->pgno-1)*(i64)pPager->pageSize; + rc = sqlite3OsRead(pPager->fd, pPg->pData, pPager->pageSize, iOffset); + if( rc==SQLITE_IOERR_SHORT_READ ){ + rc = SQLITE_OK; + } + } + + if( pPg->pgno==1 ){ + if( rc ){ + /* If the read is unsuccessful, set the dbFileVers[] to something + ** that will never be a valid file version. dbFileVers[] is a copy + ** of bytes 24..39 of the database. Bytes 28..31 should always be + ** zero or the size of the database in page. Bytes 32..35 and 35..39 + ** should be page numbers which are never 0xffffffff. So filling + ** pPager->dbFileVers[] with all 0xff bytes should suffice. + ** + ** For an encrypted database, the situation is more complex: bytes + ** 24..39 of the database are white noise. But the probability of + ** white noise equaling 16 bytes of 0xff is vanishingly small so + ** we should still be ok. + */ + memset(pPager->dbFileVers, 0xff, sizeof(pPager->dbFileVers)); + }else{ + u8 *dbFileVers = &((u8*)pPg->pData)[24]; + memcpy(&pPager->dbFileVers, dbFileVers, sizeof(pPager->dbFileVers)); + } + } + CODEC1(pPager, pPg->pData, pPg->pgno, 3, rc = SQLITE_NOMEM_BKPT); + + PAGER_INCR(sqlite3_pager_readdb_count); + PAGER_INCR(pPager->nRead); + IOTRACE(("PGIN %p %d\n", pPager, pPg->pgno)); + PAGERTRACE(("FETCH %d page %d hash(%08x)\n", + PAGERID(pPager), pPg->pgno, pager_pagehash(pPg))); + + return rc; +} + +/* +** Update the value of the change-counter at offsets 24 and 92 in +** the header and the sqlite version number at offset 96. +** +** This is an unconditional update. See also the pager_incr_changecounter() +** routine which only updates the change-counter if the update is actually +** needed, as determined by the pPager->changeCountDone state variable. +*/ +static void pager_write_changecounter(PgHdr *pPg){ + u32 change_counter; + if( NEVER(pPg==0) ) return; + + /* Increment the value just read and write it back to byte 24. */ + change_counter = sqlite3Get4byte((u8*)pPg->pPager->dbFileVers)+1; + put32bits(((char*)pPg->pData)+24, change_counter); + + /* Also store the SQLite version number in bytes 96..99 and in + ** bytes 92..95 store the change counter for which the version number + ** is valid. */ + put32bits(((char*)pPg->pData)+92, change_counter); + put32bits(((char*)pPg->pData)+96, SQLITE_VERSION_NUMBER); +} + +#ifndef SQLITE_OMIT_WAL +/* +** This function is invoked once for each page that has already been +** written into the log file when a WAL transaction is rolled back. +** Parameter iPg is the page number of said page. The pCtx argument +** is actually a pointer to the Pager structure. +** +** If page iPg is present in the cache, and has no outstanding references, +** it is discarded. Otherwise, if there are one or more outstanding +** references, the page content is reloaded from the database. If the +** attempt to reload content from the database is required and fails, +** return an SQLite error code. Otherwise, SQLITE_OK. +*/ +static int pagerUndoCallback(void *pCtx, Pgno iPg){ + int rc = SQLITE_OK; + Pager *pPager = (Pager *)pCtx; + PgHdr *pPg; + + assert( pagerUseWal(pPager) ); + pPg = sqlite3PagerLookup(pPager, iPg); + if( pPg ){ + if( sqlite3PcachePageRefcount(pPg)==1 ){ + sqlite3PcacheDrop(pPg); + }else{ + rc = readDbPage(pPg); + if( rc==SQLITE_OK ){ + pPager->xReiniter(pPg); + } + sqlite3PagerUnrefNotNull(pPg); + } + } + + /* Normally, if a transaction is rolled back, any backup processes are + ** updated as data is copied out of the rollback journal and into the + ** database. This is not generally possible with a WAL database, as + ** rollback involves simply truncating the log file. Therefore, if one + ** or more frames have already been written to the log (and therefore + ** also copied into the backup databases) as part of this transaction, + ** the backups must be restarted. + */ + sqlite3BackupRestart(pPager->pBackup); + + return rc; +} + +/* +** This function is called to rollback a transaction on a WAL database. +*/ +static int pagerRollbackWal(Pager *pPager){ + int rc; /* Return Code */ + PgHdr *pList; /* List of dirty pages to revert */ + + /* For all pages in the cache that are currently dirty or have already + ** been written (but not committed) to the log file, do one of the + ** following: + ** + ** + Discard the cached page (if refcount==0), or + ** + Reload page content from the database (if refcount>0). + */ + pPager->dbSize = pPager->dbOrigSize; + rc = sqlite3WalUndo(pPager->pWal, pagerUndoCallback, (void *)pPager); + pList = sqlite3PcacheDirtyList(pPager->pPCache); + while( pList && rc==SQLITE_OK ){ + PgHdr *pNext = pList->pDirty; + rc = pagerUndoCallback((void *)pPager, pList->pgno); + pList = pNext; + } + + return rc; +} + +/* +** This function is a wrapper around sqlite3WalFrames(). As well as logging +** the contents of the list of pages headed by pList (connected by pDirty), +** this function notifies any active backup processes that the pages have +** changed. +** +** The list of pages passed into this routine is always sorted by page number. +** Hence, if page 1 appears anywhere on the list, it will be the first page. +*/ +static int pagerWalFrames( + Pager *pPager, /* Pager object */ + PgHdr *pList, /* List of frames to log */ + Pgno nTruncate, /* Database size after this commit */ + int isCommit /* True if this is a commit */ +){ + int rc; /* Return code */ + int nList; /* Number of pages in pList */ + PgHdr *p; /* For looping over pages */ + + assert( pPager->pWal ); + assert( pList ); +#ifdef SQLITE_DEBUG + /* Verify that the page list is in accending order */ + for(p=pList; p && p->pDirty; p=p->pDirty){ + assert( p->pgno < p->pDirty->pgno ); + } +#endif + + assert( pList->pDirty==0 || isCommit ); + if( isCommit ){ + /* If a WAL transaction is being committed, there is no point in writing + ** any pages with page numbers greater than nTruncate into the WAL file. + ** They will never be read by any client. So remove them from the pDirty + ** list here. */ + PgHdr **ppNext = &pList; + nList = 0; + for(p=pList; (*ppNext = p)!=0; p=p->pDirty){ + if( p->pgno<=nTruncate ){ + ppNext = &p->pDirty; + nList++; + } + } + assert( pList ); + }else{ + nList = 1; + } + pPager->aStat[PAGER_STAT_WRITE] += nList; + + if( pList->pgno==1 ) pager_write_changecounter(pList); + rc = sqlite3WalFrames(pPager->pWal, + pPager->pageSize, pList, nTruncate, isCommit, pPager->walSyncFlags + ); + if( rc==SQLITE_OK && pPager->pBackup ){ + for(p=pList; p; p=p->pDirty){ + sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData); + } + } + +#ifdef SQLITE_CHECK_PAGES + pList = sqlite3PcacheDirtyList(pPager->pPCache); + for(p=pList; p; p=p->pDirty){ + pager_set_pagehash(p); + } +#endif + + return rc; +} + +/* +** Begin a read transaction on the WAL. +** +** This routine used to be called "pagerOpenSnapshot()" because it essentially +** makes a snapshot of the database at the current point in time and preserves +** that snapshot for use by the reader in spite of concurrently changes by +** other writers or checkpointers. +*/ +static int pagerBeginReadTransaction(Pager *pPager){ + int rc; /* Return code */ + int changed = 0; /* True if cache must be reset */ + + assert( pagerUseWal(pPager) ); + assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER ); + + /* sqlite3WalEndReadTransaction() was not called for the previous + ** transaction in locking_mode=EXCLUSIVE. So call it now. If we + ** are in locking_mode=NORMAL and EndRead() was previously called, + ** the duplicate call is harmless. + */ + sqlite3WalEndReadTransaction(pPager->pWal); + + rc = sqlite3WalBeginReadTransaction(pPager->pWal, &changed); + if( rc!=SQLITE_OK || changed ){ + pager_reset(pPager); + if( USEFETCH(pPager) ) sqlite3OsUnfetch(pPager->fd, 0, 0); + } + + return rc; +} +#endif + +/* +** This function is called as part of the transition from PAGER_OPEN +** to PAGER_READER state to determine the size of the database file +** in pages (assuming the page size currently stored in Pager.pageSize). +** +** If no error occurs, SQLITE_OK is returned and the size of the database +** in pages is stored in *pnPage. Otherwise, an error code (perhaps +** SQLITE_IOERR_FSTAT) is returned and *pnPage is left unmodified. +*/ +static int pagerPagecount(Pager *pPager, Pgno *pnPage){ + Pgno nPage; /* Value to return via *pnPage */ + + /* Query the WAL sub-system for the database size. The WalDbsize() + ** function returns zero if the WAL is not open (i.e. Pager.pWal==0), or + ** if the database size is not available. The database size is not + ** available from the WAL sub-system if the log file is empty or + ** contains no valid committed transactions. + */ + assert( pPager->eState==PAGER_OPEN ); + assert( pPager->eLock>=SHARED_LOCK ); + assert( isOpen(pPager->fd) ); + assert( pPager->tempFile==0 ); + nPage = sqlite3WalDbsize(pPager->pWal); + + /* If the number of pages in the database is not available from the + ** WAL sub-system, determine the page count based on the size of + ** the database file. If the size of the database file is not an + ** integer multiple of the page-size, round up the result. + */ + if( nPage==0 && ALWAYS(isOpen(pPager->fd)) ){ + i64 n = 0; /* Size of db file in bytes */ + int rc = sqlite3OsFileSize(pPager->fd, &n); + if( rc!=SQLITE_OK ){ + return rc; + } + nPage = (Pgno)((n+pPager->pageSize-1) / pPager->pageSize); + } + + /* If the current number of pages in the file is greater than the + ** configured maximum pager number, increase the allowed limit so + ** that the file can be read. + */ + if( nPage>pPager->mxPgno ){ + pPager->mxPgno = (Pgno)nPage; + } + + *pnPage = nPage; + return SQLITE_OK; +} + +#ifndef SQLITE_OMIT_WAL +/* +** Check if the *-wal file that corresponds to the database opened by pPager +** exists if the database is not empy, or verify that the *-wal file does +** not exist (by deleting it) if the database file is empty. +** +** If the database is not empty and the *-wal file exists, open the pager +** in WAL mode. If the database is empty or if no *-wal file exists and +** if no error occurs, make sure Pager.journalMode is not set to +** PAGER_JOURNALMODE_WAL. +** +** Return SQLITE_OK or an error code. +** +** The caller must hold a SHARED lock on the database file to call this +** function. Because an EXCLUSIVE lock on the db file is required to delete +** a WAL on a none-empty database, this ensures there is no race condition +** between the xAccess() below and an xDelete() being executed by some +** other connection. +*/ +static int pagerOpenWalIfPresent(Pager *pPager){ + int rc = SQLITE_OK; + assert( pPager->eState==PAGER_OPEN ); + assert( pPager->eLock>=SHARED_LOCK ); + + if( !pPager->tempFile ){ + int isWal; /* True if WAL file exists */ + rc = sqlite3OsAccess( + pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &isWal + ); + if( rc==SQLITE_OK ){ + if( isWal ){ + Pgno nPage; /* Size of the database file */ + + rc = pagerPagecount(pPager, &nPage); + if( rc ) return rc; + if( nPage==0 ){ + rc = sqlite3OsDelete(pPager->pVfs, pPager->zWal, 0); + }else{ + testcase( sqlite3PcachePagecount(pPager->pPCache)==0 ); + rc = sqlite3PagerOpenWal(pPager, 0); + } + }else if( pPager->journalMode==PAGER_JOURNALMODE_WAL ){ + pPager->journalMode = PAGER_JOURNALMODE_DELETE; + } + } + } + return rc; +} +#endif + +/* +** Playback savepoint pSavepoint. Or, if pSavepoint==NULL, then playback +** the entire super-journal file. The case pSavepoint==NULL occurs when +** a ROLLBACK TO command is invoked on a SAVEPOINT that is a transaction +** savepoint. +** +** When pSavepoint is not NULL (meaning a non-transaction savepoint is +** being rolled back), then the rollback consists of up to three stages, +** performed in the order specified: +** +** * Pages are played back from the main journal starting at byte +** offset PagerSavepoint.iOffset and continuing to +** PagerSavepoint.iHdrOffset, or to the end of the main journal +** file if PagerSavepoint.iHdrOffset is zero. +** +** * If PagerSavepoint.iHdrOffset is not zero, then pages are played +** back starting from the journal header immediately following +** PagerSavepoint.iHdrOffset to the end of the main journal file. +** +** * Pages are then played back from the sub-journal file, starting +** with the PagerSavepoint.iSubRec and continuing to the end of +** the journal file. +** +** Throughout the rollback process, each time a page is rolled back, the +** corresponding bit is set in a bitvec structure (variable pDone in the +** implementation below). This is used to ensure that a page is only +** rolled back the first time it is encountered in either journal. +** +** If pSavepoint is NULL, then pages are only played back from the main +** journal file. There is no need for a bitvec in this case. +** +** In either case, before playback commences the Pager.dbSize variable +** is reset to the value that it held at the start of the savepoint +** (or transaction). No page with a page-number greater than this value +** is played back. If one is encountered it is simply skipped. +*/ +static int pagerPlaybackSavepoint(Pager *pPager, PagerSavepoint *pSavepoint){ + i64 szJ; /* Effective size of the main journal */ + i64 iHdrOff; /* End of first segment of main-journal records */ + int rc = SQLITE_OK; /* Return code */ + Bitvec *pDone = 0; /* Bitvec to ensure pages played back only once */ + + assert( pPager->eState!=PAGER_ERROR ); + assert( pPager->eState>=PAGER_WRITER_LOCKED ); + + /* Allocate a bitvec to use to store the set of pages rolled back */ + if( pSavepoint ){ + pDone = sqlite3BitvecCreate(pSavepoint->nOrig); + if( !pDone ){ + return SQLITE_NOMEM_BKPT; + } + } + + /* Set the database size back to the value it was before the savepoint + ** being reverted was opened. + */ + pPager->dbSize = pSavepoint ? pSavepoint->nOrig : pPager->dbOrigSize; + pPager->changeCountDone = pPager->tempFile; + + if( !pSavepoint && pagerUseWal(pPager) ){ + return pagerRollbackWal(pPager); + } + + /* Use pPager->journalOff as the effective size of the main rollback + ** journal. The actual file might be larger than this in + ** PAGER_JOURNALMODE_TRUNCATE or PAGER_JOURNALMODE_PERSIST. But anything + ** past pPager->journalOff is off-limits to us. + */ + szJ = pPager->journalOff; + assert( pagerUseWal(pPager)==0 || szJ==0 ); + + /* Begin by rolling back records from the main journal starting at + ** PagerSavepoint.iOffset and continuing to the next journal header. + ** There might be records in the main journal that have a page number + ** greater than the current database size (pPager->dbSize) but those + ** will be skipped automatically. Pages are added to pDone as they + ** are played back. + */ + if( pSavepoint && !pagerUseWal(pPager) ){ + iHdrOff = pSavepoint->iHdrOffset ? pSavepoint->iHdrOffset : szJ; + pPager->journalOff = pSavepoint->iOffset; + while( rc==SQLITE_OK && pPager->journalOffjournalOff, pDone, 1, 1); + } + assert( rc!=SQLITE_DONE ); + }else{ + pPager->journalOff = 0; + } + + /* Continue rolling back records out of the main journal starting at + ** the first journal header seen and continuing until the effective end + ** of the main journal file. Continue to skip out-of-range pages and + ** continue adding pages rolled back to pDone. + */ + while( rc==SQLITE_OK && pPager->journalOffjournalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff" + ** test is related to ticket #2565. See the discussion in the + ** pager_playback() function for additional information. + */ + if( nJRec==0 + && pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff + ){ + nJRec = (u32)((szJ - pPager->journalOff)/JOURNAL_PG_SZ(pPager)); + } + for(ii=0; rc==SQLITE_OK && iijournalOffjournalOff, pDone, 1, 1); + } + assert( rc!=SQLITE_DONE ); + } + assert( rc!=SQLITE_OK || pPager->journalOff>=szJ ); + + /* Finally, rollback pages from the sub-journal. Page that were + ** previously rolled back out of the main journal (and are hence in pDone) + ** will be skipped. Out-of-range pages are also skipped. + */ + if( pSavepoint ){ + u32 ii; /* Loop counter */ + i64 offset = (i64)pSavepoint->iSubRec*(4+pPager->pageSize); + + if( pagerUseWal(pPager) ){ + rc = sqlite3WalSavepointUndo(pPager->pWal, pSavepoint->aWalData); + } + for(ii=pSavepoint->iSubRec; rc==SQLITE_OK && iinSubRec; ii++){ + assert( offset==(i64)ii*(4+pPager->pageSize) ); + rc = pager_playback_one_page(pPager, &offset, pDone, 0, 1); + } + assert( rc!=SQLITE_DONE ); + } + + sqlite3BitvecDestroy(pDone); + if( rc==SQLITE_OK ){ + pPager->journalOff = szJ; + } + + return rc; +} + +/* +** Change the maximum number of in-memory pages that are allowed +** before attempting to recycle clean and unused pages. +*/ +SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){ + sqlite3PcacheSetCachesize(pPager->pPCache, mxPage); +} + +/* +** Change the maximum number of in-memory pages that are allowed +** before attempting to spill pages to journal. +*/ +SQLITE_PRIVATE int sqlite3PagerSetSpillsize(Pager *pPager, int mxPage){ + return sqlite3PcacheSetSpillsize(pPager->pPCache, mxPage); +} + +/* +** Invoke SQLITE_FCNTL_MMAP_SIZE based on the current value of szMmap. +*/ +static void pagerFixMaplimit(Pager *pPager){ +#if SQLITE_MAX_MMAP_SIZE>0 + sqlite3_file *fd = pPager->fd; + if( isOpen(fd) && fd->pMethods->iVersion>=3 ){ + sqlite3_int64 sz; + sz = pPager->szMmap; + pPager->bUseFetch = (sz>0); + setGetterMethod(pPager); + sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_MMAP_SIZE, &sz); + } +#endif +} + +/* +** Change the maximum size of any memory mapping made of the database file. +*/ +SQLITE_PRIVATE void sqlite3PagerSetMmapLimit(Pager *pPager, sqlite3_int64 szMmap){ + pPager->szMmap = szMmap; + pagerFixMaplimit(pPager); +} + +/* +** Free as much memory as possible from the pager. +*/ +SQLITE_PRIVATE void sqlite3PagerShrink(Pager *pPager){ + sqlite3PcacheShrink(pPager->pPCache); +} + +/* +** Adjust settings of the pager to those specified in the pgFlags parameter. +** +** The "level" in pgFlags & PAGER_SYNCHRONOUS_MASK sets the robustness +** of the database to damage due to OS crashes or power failures by +** changing the number of syncs()s when writing the journals. +** There are four levels: +** +** OFF sqlite3OsSync() is never called. This is the default +** for temporary and transient files. +** +** NORMAL The journal is synced once before writes begin on the +** database. This is normally adequate protection, but +** it is theoretically possible, though very unlikely, +** that an inopertune power failure could leave the journal +** in a state which would cause damage to the database +** when it is rolled back. +** +** FULL The journal is synced twice before writes begin on the +** database (with some additional information - the nRec field +** of the journal header - being written in between the two +** syncs). If we assume that writing a +** single disk sector is atomic, then this mode provides +** assurance that the journal will not be corrupted to the +** point of causing damage to the database during rollback. +** +** EXTRA This is like FULL except that is also syncs the directory +** that contains the rollback journal after the rollback +** journal is unlinked. +** +** The above is for a rollback-journal mode. For WAL mode, OFF continues +** to mean that no syncs ever occur. NORMAL means that the WAL is synced +** prior to the start of checkpoint and that the database file is synced +** at the conclusion of the checkpoint if the entire content of the WAL +** was written back into the database. But no sync operations occur for +** an ordinary commit in NORMAL mode with WAL. FULL means that the WAL +** file is synced following each commit operation, in addition to the +** syncs associated with NORMAL. There is no difference between FULL +** and EXTRA for WAL mode. +** +** Do not confuse synchronous=FULL with SQLITE_SYNC_FULL. The +** SQLITE_SYNC_FULL macro means to use the MacOSX-style full-fsync +** using fcntl(F_FULLFSYNC). SQLITE_SYNC_NORMAL means to do an +** ordinary fsync() call. There is no difference between SQLITE_SYNC_FULL +** and SQLITE_SYNC_NORMAL on platforms other than MacOSX. But the +** synchronous=FULL versus synchronous=NORMAL setting determines when +** the xSync primitive is called and is relevant to all platforms. +** +** Numeric values associated with these states are OFF==1, NORMAL=2, +** and FULL=3. +*/ +SQLITE_PRIVATE void sqlite3PagerSetFlags( + Pager *pPager, /* The pager to set safety level for */ + unsigned pgFlags /* Various flags */ +){ + unsigned level = pgFlags & PAGER_SYNCHRONOUS_MASK; + if( pPager->tempFile ){ + pPager->noSync = 1; + pPager->fullSync = 0; + pPager->extraSync = 0; + }else{ + pPager->noSync = level==PAGER_SYNCHRONOUS_OFF ?1:0; + pPager->fullSync = level>=PAGER_SYNCHRONOUS_FULL ?1:0; + pPager->extraSync = level==PAGER_SYNCHRONOUS_EXTRA ?1:0; + } + if( pPager->noSync ){ + pPager->syncFlags = 0; + }else if( pgFlags & PAGER_FULLFSYNC ){ + pPager->syncFlags = SQLITE_SYNC_FULL; + }else{ + pPager->syncFlags = SQLITE_SYNC_NORMAL; + } + pPager->walSyncFlags = (pPager->syncFlags<<2); + if( pPager->fullSync ){ + pPager->walSyncFlags |= pPager->syncFlags; + } + if( (pgFlags & PAGER_CKPT_FULLFSYNC) && !pPager->noSync ){ + pPager->walSyncFlags |= (SQLITE_SYNC_FULL<<2); + } + if( pgFlags & PAGER_CACHESPILL ){ + pPager->doNotSpill &= ~SPILLFLAG_OFF; + }else{ + pPager->doNotSpill |= SPILLFLAG_OFF; + } +} + +/* +** The following global variable is incremented whenever the library +** attempts to open a temporary file. This information is used for +** testing and analysis only. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_opentemp_count = 0; +#endif + +/* +** Open a temporary file. +** +** Write the file descriptor into *pFile. Return SQLITE_OK on success +** or some other error code if we fail. The OS will automatically +** delete the temporary file when it is closed. +** +** The flags passed to the VFS layer xOpen() call are those specified +** by parameter vfsFlags ORed with the following: +** +** SQLITE_OPEN_READWRITE +** SQLITE_OPEN_CREATE +** SQLITE_OPEN_EXCLUSIVE +** SQLITE_OPEN_DELETEONCLOSE +*/ +static int pagerOpentemp( + Pager *pPager, /* The pager object */ + sqlite3_file *pFile, /* Write the file descriptor here */ + int vfsFlags /* Flags passed through to the VFS */ +){ + int rc; /* Return code */ + +#ifdef SQLITE_TEST + sqlite3_opentemp_count++; /* Used for testing and analysis only */ +#endif + + vfsFlags |= SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | + SQLITE_OPEN_EXCLUSIVE | SQLITE_OPEN_DELETEONCLOSE; + rc = sqlite3OsOpen(pPager->pVfs, 0, pFile, vfsFlags, 0); + assert( rc!=SQLITE_OK || isOpen(pFile) ); + return rc; +} + +/* +** Set the busy handler function. +** +** The pager invokes the busy-handler if sqlite3OsLock() returns +** SQLITE_BUSY when trying to upgrade from no-lock to a SHARED lock, +** or when trying to upgrade from a RESERVED lock to an EXCLUSIVE +** lock. It does *not* invoke the busy handler when upgrading from +** SHARED to RESERVED, or when upgrading from SHARED to EXCLUSIVE +** (which occurs during hot-journal rollback). Summary: +** +** Transition | Invokes xBusyHandler +** -------------------------------------------------------- +** NO_LOCK -> SHARED_LOCK | Yes +** SHARED_LOCK -> RESERVED_LOCK | No +** SHARED_LOCK -> EXCLUSIVE_LOCK | No +** RESERVED_LOCK -> EXCLUSIVE_LOCK | Yes +** +** If the busy-handler callback returns non-zero, the lock is +** retried. If it returns zero, then the SQLITE_BUSY error is +** returned to the caller of the pager API function. +*/ +SQLITE_PRIVATE void sqlite3PagerSetBusyHandler( + Pager *pPager, /* Pager object */ + int (*xBusyHandler)(void *), /* Pointer to busy-handler function */ + void *pBusyHandlerArg /* Argument to pass to xBusyHandler */ +){ + void **ap; + pPager->xBusyHandler = xBusyHandler; + pPager->pBusyHandlerArg = pBusyHandlerArg; + ap = (void **)&pPager->xBusyHandler; + assert( ((int(*)(void *))(ap[0]))==xBusyHandler ); + assert( ap[1]==pBusyHandlerArg ); + sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_BUSYHANDLER, (void *)ap); +} + +/* +** Change the page size used by the Pager object. The new page size +** is passed in *pPageSize. +** +** If the pager is in the error state when this function is called, it +** is a no-op. The value returned is the error state error code (i.e. +** one of SQLITE_IOERR, an SQLITE_IOERR_xxx sub-code or SQLITE_FULL). +** +** Otherwise, if all of the following are true: +** +** * the new page size (value of *pPageSize) is valid (a power +** of two between 512 and SQLITE_MAX_PAGE_SIZE, inclusive), and +** +** * there are no outstanding page references, and +** +** * the database is either not an in-memory database or it is +** an in-memory database that currently consists of zero pages. +** +** then the pager object page size is set to *pPageSize. +** +** If the page size is changed, then this function uses sqlite3PagerMalloc() +** to obtain a new Pager.pTmpSpace buffer. If this allocation attempt +** fails, SQLITE_NOMEM is returned and the page size remains unchanged. +** In all other cases, SQLITE_OK is returned. +** +** If the page size is not changed, either because one of the enumerated +** conditions above is not true, the pager was in error state when this +** function was called, or because the memory allocation attempt failed, +** then *pPageSize is set to the old, retained page size before returning. +*/ +SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager *pPager, u32 *pPageSize, int nReserve){ + int rc = SQLITE_OK; + + /* It is not possible to do a full assert_pager_state() here, as this + ** function may be called from within PagerOpen(), before the state + ** of the Pager object is internally consistent. + ** + ** At one point this function returned an error if the pager was in + ** PAGER_ERROR state. But since PAGER_ERROR state guarantees that + ** there is at least one outstanding page reference, this function + ** is a no-op for that case anyhow. + */ + + u32 pageSize = *pPageSize; + assert( pageSize==0 || (pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE) ); + if( (pPager->memDb==0 || pPager->dbSize==0) + && sqlite3PcacheRefCount(pPager->pPCache)==0 + && pageSize && pageSize!=(u32)pPager->pageSize + ){ + char *pNew = NULL; /* New temp space */ + i64 nByte = 0; + + if( pPager->eState>PAGER_OPEN && isOpen(pPager->fd) ){ + rc = sqlite3OsFileSize(pPager->fd, &nByte); + } + if( rc==SQLITE_OK ){ + /* 8 bytes of zeroed overrun space is sufficient so that the b-tree + * cell header parser will never run off the end of the allocation */ + pNew = (char *)sqlite3PageMalloc(pageSize+8); + if( !pNew ){ + rc = SQLITE_NOMEM_BKPT; + }else{ + memset(pNew+pageSize, 0, 8); + } + } + + if( rc==SQLITE_OK ){ + pager_reset(pPager); + rc = sqlite3PcacheSetPageSize(pPager->pPCache, pageSize); + } + if( rc==SQLITE_OK ){ + sqlite3PageFree(pPager->pTmpSpace); + pPager->pTmpSpace = pNew; + pPager->dbSize = (Pgno)((nByte+pageSize-1)/pageSize); + pPager->pageSize = pageSize; + pPager->lckPgno = (Pgno)(PENDING_BYTE/pageSize) + 1; + }else{ + sqlite3PageFree(pNew); + } + } + + *pPageSize = pPager->pageSize; + if( rc==SQLITE_OK ){ + if( nReserve<0 ) nReserve = pPager->nReserve; + assert( nReserve>=0 && nReserve<1000 ); + pPager->nReserve = (i16)nReserve; + pagerReportSize(pPager); + pagerFixMaplimit(pPager); + } + return rc; +} + +/* +** Return a pointer to the "temporary page" buffer held internally +** by the pager. This is a buffer that is big enough to hold the +** entire content of a database page. This buffer is used internally +** during rollback and will be overwritten whenever a rollback +** occurs. But other modules are free to use it too, as long as +** no rollbacks are happening. +*/ +SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager *pPager){ + return pPager->pTmpSpace; +} + +/* +** Attempt to set the maximum database page count if mxPage is positive. +** Make no changes if mxPage is zero or negative. And never reduce the +** maximum page count below the current size of the database. +** +** Regardless of mxPage, return the current maximum page count. +*/ +SQLITE_PRIVATE Pgno sqlite3PagerMaxPageCount(Pager *pPager, Pgno mxPage){ + if( mxPage>0 ){ + pPager->mxPgno = mxPage; + } + assert( pPager->eState!=PAGER_OPEN ); /* Called only by OP_MaxPgcnt */ + /* assert( pPager->mxPgno>=pPager->dbSize ); */ + /* OP_MaxPgcnt ensures that the parameter passed to this function is not + ** less than the total number of valid pages in the database. But this + ** may be less than Pager.dbSize, and so the assert() above is not valid */ + return pPager->mxPgno; +} + +/* +** The following set of routines are used to disable the simulated +** I/O error mechanism. These routines are used to avoid simulated +** errors in places where we do not care about errors. +** +** Unless -DSQLITE_TEST=1 is used, these routines are all no-ops +** and generate no code. +*/ +#ifdef SQLITE_TEST +SQLITE_API extern int sqlite3_io_error_pending; +SQLITE_API extern int sqlite3_io_error_hit; +static int saved_cnt; +void disable_simulated_io_errors(void){ + saved_cnt = sqlite3_io_error_pending; + sqlite3_io_error_pending = -1; +} +void enable_simulated_io_errors(void){ + sqlite3_io_error_pending = saved_cnt; +} +#else +# define disable_simulated_io_errors() +# define enable_simulated_io_errors() +#endif + +/* +** Read the first N bytes from the beginning of the file into memory +** that pDest points to. +** +** If the pager was opened on a transient file (zFilename==""), or +** opened on a file less than N bytes in size, the output buffer is +** zeroed and SQLITE_OK returned. The rationale for this is that this +** function is used to read database headers, and a new transient or +** zero sized database has a header than consists entirely of zeroes. +** +** If any IO error apart from SQLITE_IOERR_SHORT_READ is encountered, +** the error code is returned to the caller and the contents of the +** output buffer undefined. +*/ +SQLITE_PRIVATE int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){ + int rc = SQLITE_OK; + memset(pDest, 0, N); + assert( isOpen(pPager->fd) || pPager->tempFile ); + + /* This routine is only called by btree immediately after creating + ** the Pager object. There has not been an opportunity to transition + ** to WAL mode yet. + */ + assert( !pagerUseWal(pPager) ); + + if( isOpen(pPager->fd) ){ + IOTRACE(("DBHDR %p 0 %d\n", pPager, N)) + rc = sqlite3OsRead(pPager->fd, pDest, N, 0); + if( rc==SQLITE_IOERR_SHORT_READ ){ + rc = SQLITE_OK; + } + } + return rc; +} + +/* +** This function may only be called when a read-transaction is open on +** the pager. It returns the total number of pages in the database. +** +** However, if the file is between 1 and bytes in size, then +** this is considered a 1 page file. +*/ +SQLITE_PRIVATE void sqlite3PagerPagecount(Pager *pPager, int *pnPage){ + assert( pPager->eState>=PAGER_READER ); + assert( pPager->eState!=PAGER_WRITER_FINISHED ); + *pnPage = (int)pPager->dbSize; +} + + +/* +** Try to obtain a lock of type locktype on the database file. If +** a similar or greater lock is already held, this function is a no-op +** (returning SQLITE_OK immediately). +** +** Otherwise, attempt to obtain the lock using sqlite3OsLock(). Invoke +** the busy callback if the lock is currently not available. Repeat +** until the busy callback returns false or until the attempt to +** obtain the lock succeeds. +** +** Return SQLITE_OK on success and an error code if we cannot obtain +** the lock. If the lock is obtained successfully, set the Pager.state +** variable to locktype before returning. +*/ +static int pager_wait_on_lock(Pager *pPager, int locktype){ + int rc; /* Return code */ + + /* Check that this is either a no-op (because the requested lock is + ** already held), or one of the transitions that the busy-handler + ** may be invoked during, according to the comment above + ** sqlite3PagerSetBusyhandler(). + */ + assert( (pPager->eLock>=locktype) + || (pPager->eLock==NO_LOCK && locktype==SHARED_LOCK) + || (pPager->eLock==RESERVED_LOCK && locktype==EXCLUSIVE_LOCK) + ); + + do { + rc = pagerLockDb(pPager, locktype); + }while( rc==SQLITE_BUSY && pPager->xBusyHandler(pPager->pBusyHandlerArg) ); + return rc; +} + +/* +** Function assertTruncateConstraint(pPager) checks that one of the +** following is true for all dirty pages currently in the page-cache: +** +** a) The page number is less than or equal to the size of the +** current database image, in pages, OR +** +** b) if the page content were written at this time, it would not +** be necessary to write the current content out to the sub-journal. +** +** If the condition asserted by this function were not true, and the +** dirty page were to be discarded from the cache via the pagerStress() +** routine, pagerStress() would not write the current page content to +** the database file. If a savepoint transaction were rolled back after +** this happened, the correct behavior would be to restore the current +** content of the page. However, since this content is not present in either +** the database file or the portion of the rollback journal and +** sub-journal rolled back the content could not be restored and the +** database image would become corrupt. It is therefore fortunate that +** this circumstance cannot arise. +*/ +#if defined(SQLITE_DEBUG) +static void assertTruncateConstraintCb(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + assert( pPg->flags&PGHDR_DIRTY ); + if( pPg->pgno>pPager->dbSize ){ /* if (a) is false */ + Pgno pgno = pPg->pgno; + int i; + for(i=0; ipPager->nSavepoint; i++){ + PagerSavepoint *p = &pPager->aSavepoint[i]; + assert( p->nOrigpInSavepoint,pgno) ); + } + } +} +static void assertTruncateConstraint(Pager *pPager){ + sqlite3PcacheIterateDirty(pPager->pPCache, assertTruncateConstraintCb); +} +#else +# define assertTruncateConstraint(pPager) +#endif + +/* +** Truncate the in-memory database file image to nPage pages. This +** function does not actually modify the database file on disk. It +** just sets the internal state of the pager object so that the +** truncation will be done when the current transaction is committed. +** +** This function is only called right before committing a transaction. +** Once this function has been called, the transaction must either be +** rolled back or committed. It is not safe to call this function and +** then continue writing to the database. +*/ +SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){ + assert( pPager->dbSize>=nPage || CORRUPT_DB ); + assert( pPager->eState>=PAGER_WRITER_CACHEMOD ); + pPager->dbSize = nPage; + + /* At one point the code here called assertTruncateConstraint() to + ** ensure that all pages being truncated away by this operation are, + ** if one or more savepoints are open, present in the savepoint + ** journal so that they can be restored if the savepoint is rolled + ** back. This is no longer necessary as this function is now only + ** called right before committing a transaction. So although the + ** Pager object may still have open savepoints (Pager.nSavepoint!=0), + ** they cannot be rolled back. So the assertTruncateConstraint() call + ** is no longer correct. */ +} + + +/* +** This function is called before attempting a hot-journal rollback. It +** syncs the journal file to disk, then sets pPager->journalHdr to the +** size of the journal file so that the pager_playback() routine knows +** that the entire journal file has been synced. +** +** Syncing a hot-journal to disk before attempting to roll it back ensures +** that if a power-failure occurs during the rollback, the process that +** attempts rollback following system recovery sees the same journal +** content as this process. +** +** If everything goes as planned, SQLITE_OK is returned. Otherwise, +** an SQLite error code. +*/ +static int pagerSyncHotJournal(Pager *pPager){ + int rc = SQLITE_OK; + if( !pPager->noSync ){ + rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_NORMAL); + } + if( rc==SQLITE_OK ){ + rc = sqlite3OsFileSize(pPager->jfd, &pPager->journalHdr); + } + return rc; +} + +#if SQLITE_MAX_MMAP_SIZE>0 +/* +** Obtain a reference to a memory mapped page object for page number pgno. +** The new object will use the pointer pData, obtained from xFetch(). +** If successful, set *ppPage to point to the new page reference +** and return SQLITE_OK. Otherwise, return an SQLite error code and set +** *ppPage to zero. +** +** Page references obtained by calling this function should be released +** by calling pagerReleaseMapPage(). +*/ +static int pagerAcquireMapPage( + Pager *pPager, /* Pager object */ + Pgno pgno, /* Page number */ + void *pData, /* xFetch()'d data for this page */ + PgHdr **ppPage /* OUT: Acquired page object */ +){ + PgHdr *p; /* Memory mapped page to return */ + + if( pPager->pMmapFreelist ){ + *ppPage = p = pPager->pMmapFreelist; + pPager->pMmapFreelist = p->pDirty; + p->pDirty = 0; + assert( pPager->nExtra>=8 ); + memset(p->pExtra, 0, 8); + }else{ + *ppPage = p = (PgHdr *)sqlite3MallocZero(sizeof(PgHdr) + pPager->nExtra); + if( p==0 ){ + sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1) * pPager->pageSize, pData); + return SQLITE_NOMEM_BKPT; + } + p->pExtra = (void *)&p[1]; + p->flags = PGHDR_MMAP; + p->nRef = 1; + p->pPager = pPager; + } + + assert( p->pExtra==(void *)&p[1] ); + assert( p->pPage==0 ); + assert( p->flags==PGHDR_MMAP ); + assert( p->pPager==pPager ); + assert( p->nRef==1 ); + + p->pgno = pgno; + p->pData = pData; + pPager->nMmapOut++; + + return SQLITE_OK; +} +#endif + +/* +** Release a reference to page pPg. pPg must have been returned by an +** earlier call to pagerAcquireMapPage(). +*/ +static void pagerReleaseMapPage(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + pPager->nMmapOut--; + pPg->pDirty = pPager->pMmapFreelist; + pPager->pMmapFreelist = pPg; + + assert( pPager->fd->pMethods->iVersion>=3 ); + sqlite3OsUnfetch(pPager->fd, (i64)(pPg->pgno-1)*pPager->pageSize, pPg->pData); +} + +/* +** Free all PgHdr objects stored in the Pager.pMmapFreelist list. +*/ +static void pagerFreeMapHdrs(Pager *pPager){ + PgHdr *p; + PgHdr *pNext; + for(p=pPager->pMmapFreelist; p; p=pNext){ + pNext = p->pDirty; + sqlite3_free(p); + } +} + +/* Verify that the database file has not be deleted or renamed out from +** under the pager. Return SQLITE_OK if the database is still where it ought +** to be on disk. Return non-zero (SQLITE_READONLY_DBMOVED or some other error +** code from sqlite3OsAccess()) if the database has gone missing. +*/ +static int databaseIsUnmoved(Pager *pPager){ + int bHasMoved = 0; + int rc; + + if( pPager->tempFile ) return SQLITE_OK; + if( pPager->dbSize==0 ) return SQLITE_OK; + assert( pPager->zFilename && pPager->zFilename[0] ); + rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_HAS_MOVED, &bHasMoved); + if( rc==SQLITE_NOTFOUND ){ + /* If the HAS_MOVED file-control is unimplemented, assume that the file + ** has not been moved. That is the historical behavior of SQLite: prior to + ** version 3.8.3, it never checked */ + rc = SQLITE_OK; + }else if( rc==SQLITE_OK && bHasMoved ){ + rc = SQLITE_READONLY_DBMOVED; + } + return rc; +} + + +/* +** Shutdown the page cache. Free all memory and close all files. +** +** If a transaction was in progress when this routine is called, that +** transaction is rolled back. All outstanding pages are invalidated +** and their memory is freed. Any attempt to use a page associated +** with this page cache after this function returns will likely +** result in a coredump. +** +** This function always succeeds. If a transaction is active an attempt +** is made to roll it back. If an error occurs during the rollback +** a hot journal may be left in the filesystem but no error is returned +** to the caller. +*/ +SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager, sqlite3 *db){ + u8 *pTmp = (u8*)pPager->pTmpSpace; + assert( db || pagerUseWal(pPager)==0 ); + assert( assert_pager_state(pPager) ); + disable_simulated_io_errors(); + sqlite3BeginBenignMalloc(); + pagerFreeMapHdrs(pPager); + /* pPager->errCode = 0; */ + pPager->exclusiveMode = 0; +#ifndef SQLITE_OMIT_WAL + { + u8 *a = 0; + assert( db || pPager->pWal==0 ); + if( db && 0==(db->flags & SQLITE_NoCkptOnClose) + && SQLITE_OK==databaseIsUnmoved(pPager) + ){ + a = pTmp; + } + sqlite3WalClose(pPager->pWal, db, pPager->walSyncFlags, pPager->pageSize,a); + pPager->pWal = 0; + } +#endif + pager_reset(pPager); + if( MEMDB ){ + pager_unlock(pPager); + }else{ + /* If it is open, sync the journal file before calling UnlockAndRollback. + ** If this is not done, then an unsynced portion of the open journal + ** file may be played back into the database. If a power failure occurs + ** while this is happening, the database could become corrupt. + ** + ** If an error occurs while trying to sync the journal, shift the pager + ** into the ERROR state. This causes UnlockAndRollback to unlock the + ** database and close the journal file without attempting to roll it + ** back or finalize it. The next database user will have to do hot-journal + ** rollback before accessing the database file. + */ + if( isOpen(pPager->jfd) ){ + pager_error(pPager, pagerSyncHotJournal(pPager)); + } + pagerUnlockAndRollback(pPager); + } + sqlite3EndBenignMalloc(); + enable_simulated_io_errors(); + PAGERTRACE(("CLOSE %d\n", PAGERID(pPager))); + IOTRACE(("CLOSE %p\n", pPager)) + sqlite3OsClose(pPager->jfd); + sqlite3OsClose(pPager->fd); + sqlite3PageFree(pTmp); + sqlite3PcacheClose(pPager->pPCache); + +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC + if( pPager->xCodecFree ) pPager->xCodecFree(pPager->pCodec); +#endif +/* END SQLCIPHER */ + + assert( !pPager->aSavepoint && !pPager->pInJournal ); + assert( !isOpen(pPager->jfd) && !isOpen(pPager->sjfd) ); + + sqlite3_free(pPager); + return SQLITE_OK; +} + +#if !defined(NDEBUG) || defined(SQLITE_TEST) +/* +** Return the page number for page pPg. +*/ +SQLITE_PRIVATE Pgno sqlite3PagerPagenumber(DbPage *pPg){ + return pPg->pgno; +} +#endif + +/* +** Increment the reference count for page pPg. +*/ +SQLITE_PRIVATE void sqlite3PagerRef(DbPage *pPg){ + sqlite3PcacheRef(pPg); +} + +/* +** Sync the journal. In other words, make sure all the pages that have +** been written to the journal have actually reached the surface of the +** disk and can be restored in the event of a hot-journal rollback. +** +** If the Pager.noSync flag is set, then this function is a no-op. +** Otherwise, the actions required depend on the journal-mode and the +** device characteristics of the file-system, as follows: +** +** * If the journal file is an in-memory journal file, no action need +** be taken. +** +** * Otherwise, if the device does not support the SAFE_APPEND property, +** then the nRec field of the most recently written journal header +** is updated to contain the number of journal records that have +** been written following it. If the pager is operating in full-sync +** mode, then the journal file is synced before this field is updated. +** +** * If the device does not support the SEQUENTIAL property, then +** journal file is synced. +** +** Or, in pseudo-code: +** +** if( NOT ){ +** if( NOT SAFE_APPEND ){ +** if( ) xSync(); +** +** } +** if( NOT SEQUENTIAL ) xSync(); +** } +** +** If successful, this routine clears the PGHDR_NEED_SYNC flag of every +** page currently held in memory before returning SQLITE_OK. If an IO +** error is encountered, then the IO error code is returned to the caller. +*/ +static int syncJournal(Pager *pPager, int newHdr){ + int rc; /* Return code */ + + assert( pPager->eState==PAGER_WRITER_CACHEMOD + || pPager->eState==PAGER_WRITER_DBMOD + ); + assert( assert_pager_state(pPager) ); + assert( !pagerUseWal(pPager) ); + + rc = sqlite3PagerExclusiveLock(pPager); + if( rc!=SQLITE_OK ) return rc; + + if( !pPager->noSync ){ + assert( !pPager->tempFile ); + if( isOpen(pPager->jfd) && pPager->journalMode!=PAGER_JOURNALMODE_MEMORY ){ + const int iDc = sqlite3OsDeviceCharacteristics(pPager->fd); + assert( isOpen(pPager->jfd) ); + + if( 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){ + /* This block deals with an obscure problem. If the last connection + ** that wrote to this database was operating in persistent-journal + ** mode, then the journal file may at this point actually be larger + ** than Pager.journalOff bytes. If the next thing in the journal + ** file happens to be a journal-header (written as part of the + ** previous connection's transaction), and a crash or power-failure + ** occurs after nRec is updated but before this connection writes + ** anything else to the journal file (or commits/rolls back its + ** transaction), then SQLite may become confused when doing the + ** hot-journal rollback following recovery. It may roll back all + ** of this connections data, then proceed to rolling back the old, + ** out-of-date data that follows it. Database corruption. + ** + ** To work around this, if the journal file does appear to contain + ** a valid header following Pager.journalOff, then write a 0x00 + ** byte to the start of it to prevent it from being recognized. + ** + ** Variable iNextHdrOffset is set to the offset at which this + ** problematic header will occur, if it exists. aMagic is used + ** as a temporary buffer to inspect the first couple of bytes of + ** the potential journal header. + */ + i64 iNextHdrOffset; + u8 aMagic[8]; + u8 zHeader[sizeof(aJournalMagic)+4]; + + memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic)); + put32bits(&zHeader[sizeof(aJournalMagic)], pPager->nRec); + + iNextHdrOffset = journalHdrOffset(pPager); + rc = sqlite3OsRead(pPager->jfd, aMagic, 8, iNextHdrOffset); + if( rc==SQLITE_OK && 0==memcmp(aMagic, aJournalMagic, 8) ){ + static const u8 zerobyte = 0; + rc = sqlite3OsWrite(pPager->jfd, &zerobyte, 1, iNextHdrOffset); + } + if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){ + return rc; + } + + /* Write the nRec value into the journal file header. If in + ** full-synchronous mode, sync the journal first. This ensures that + ** all data has really hit the disk before nRec is updated to mark + ** it as a candidate for rollback. + ** + ** This is not required if the persistent media supports the + ** SAFE_APPEND property. Because in this case it is not possible + ** for garbage data to be appended to the file, the nRec field + ** is populated with 0xFFFFFFFF when the journal header is written + ** and never needs to be updated. + */ + if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){ + PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager))); + IOTRACE(("JSYNC %p\n", pPager)) + rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags); + if( rc!=SQLITE_OK ) return rc; + } + IOTRACE(("JHDR %p %lld\n", pPager, pPager->journalHdr)); + rc = sqlite3OsWrite( + pPager->jfd, zHeader, sizeof(zHeader), pPager->journalHdr + ); + if( rc!=SQLITE_OK ) return rc; + } + if( 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){ + PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager))); + IOTRACE(("JSYNC %p\n", pPager)) + rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags| + (pPager->syncFlags==SQLITE_SYNC_FULL?SQLITE_SYNC_DATAONLY:0) + ); + if( rc!=SQLITE_OK ) return rc; + } + + pPager->journalHdr = pPager->journalOff; + if( newHdr && 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){ + pPager->nRec = 0; + rc = writeJournalHdr(pPager); + if( rc!=SQLITE_OK ) return rc; + } + }else{ + pPager->journalHdr = pPager->journalOff; + } + } + + /* Unless the pager is in noSync mode, the journal file was just + ** successfully synced. Either way, clear the PGHDR_NEED_SYNC flag on + ** all pages. + */ + sqlite3PcacheClearSyncFlags(pPager->pPCache); + pPager->eState = PAGER_WRITER_DBMOD; + assert( assert_pager_state(pPager) ); + return SQLITE_OK; +} + +/* +** The argument is the first in a linked list of dirty pages connected +** by the PgHdr.pDirty pointer. This function writes each one of the +** in-memory pages in the list to the database file. The argument may +** be NULL, representing an empty list. In this case this function is +** a no-op. +** +** The pager must hold at least a RESERVED lock when this function +** is called. Before writing anything to the database file, this lock +** is upgraded to an EXCLUSIVE lock. If the lock cannot be obtained, +** SQLITE_BUSY is returned and no data is written to the database file. +** +** If the pager is a temp-file pager and the actual file-system file +** is not yet open, it is created and opened before any data is +** written out. +** +** Once the lock has been upgraded and, if necessary, the file opened, +** the pages are written out to the database file in list order. Writing +** a page is skipped if it meets either of the following criteria: +** +** * The page number is greater than Pager.dbSize, or +** * The PGHDR_DONT_WRITE flag is set on the page. +** +** If writing out a page causes the database file to grow, Pager.dbFileSize +** is updated accordingly. If page 1 is written out, then the value cached +** in Pager.dbFileVers[] is updated to match the new value stored in +** the database file. +** +** If everything is successful, SQLITE_OK is returned. If an IO error +** occurs, an IO error code is returned. Or, if the EXCLUSIVE lock cannot +** be obtained, SQLITE_BUSY is returned. +*/ +static int pager_write_pagelist(Pager *pPager, PgHdr *pList){ + int rc = SQLITE_OK; /* Return code */ + + /* This function is only called for rollback pagers in WRITER_DBMOD state. */ + assert( !pagerUseWal(pPager) ); + assert( pPager->tempFile || pPager->eState==PAGER_WRITER_DBMOD ); + assert( pPager->eLock==EXCLUSIVE_LOCK ); + assert( isOpen(pPager->fd) || pList->pDirty==0 ); + + /* If the file is a temp-file has not yet been opened, open it now. It + ** is not possible for rc to be other than SQLITE_OK if this branch + ** is taken, as pager_wait_on_lock() is a no-op for temp-files. + */ + if( !isOpen(pPager->fd) ){ + assert( pPager->tempFile && rc==SQLITE_OK ); + rc = pagerOpentemp(pPager, pPager->fd, pPager->vfsFlags); + } + + /* Before the first write, give the VFS a hint of what the final + ** file size will be. + */ + assert( rc!=SQLITE_OK || isOpen(pPager->fd) ); + if( rc==SQLITE_OK + && pPager->dbHintSizedbSize + && (pList->pDirty || pList->pgno>pPager->dbHintSize) + ){ + sqlite3_int64 szFile = pPager->pageSize * (sqlite3_int64)pPager->dbSize; + sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_SIZE_HINT, &szFile); + pPager->dbHintSize = pPager->dbSize; + } + + while( rc==SQLITE_OK && pList ){ + Pgno pgno = pList->pgno; + + /* If there are dirty pages in the page cache with page numbers greater + ** than Pager.dbSize, this means sqlite3PagerTruncateImage() was called to + ** make the file smaller (presumably by auto-vacuum code). Do not write + ** any such pages to the file. + ** + ** Also, do not write out any page that has the PGHDR_DONT_WRITE flag + ** set (set by sqlite3PagerDontWrite()). + */ + if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){ + i64 offset = (pgno-1)*(i64)pPager->pageSize; /* Offset to write */ + char *pData; /* Data to write */ + + assert( (pList->flags&PGHDR_NEED_SYNC)==0 ); + if( pList->pgno==1 ) pager_write_changecounter(pList); + + /* Encode the database */ + CODEC2(pPager, pList->pData, pgno, 6, return SQLITE_NOMEM_BKPT, pData); + + /* Write out the page data. */ + rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset); + + /* If page 1 was just written, update Pager.dbFileVers to match + ** the value now stored in the database file. If writing this + ** page caused the database file to grow, update dbFileSize. + */ + if( pgno==1 ){ + memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers)); + } + if( pgno>pPager->dbFileSize ){ + pPager->dbFileSize = pgno; + } + pPager->aStat[PAGER_STAT_WRITE]++; + + /* Update any backup objects copying the contents of this pager. */ + sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData); + + PAGERTRACE(("STORE %d page %d hash(%08x)\n", + PAGERID(pPager), pgno, pager_pagehash(pList))); + IOTRACE(("PGOUT %p %d\n", pPager, pgno)); + PAGER_INCR(sqlite3_pager_writedb_count); + }else{ + PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager), pgno)); + } + pager_set_pagehash(pList); + pList = pList->pDirty; + } + + return rc; +} + +/* +** Ensure that the sub-journal file is open. If it is already open, this +** function is a no-op. +** +** SQLITE_OK is returned if everything goes according to plan. An +** SQLITE_IOERR_XXX error code is returned if a call to sqlite3OsOpen() +** fails. +*/ +static int openSubJournal(Pager *pPager){ + int rc = SQLITE_OK; + if( !isOpen(pPager->sjfd) ){ + const int flags = SQLITE_OPEN_SUBJOURNAL | SQLITE_OPEN_READWRITE + | SQLITE_OPEN_CREATE | SQLITE_OPEN_EXCLUSIVE + | SQLITE_OPEN_DELETEONCLOSE; + int nStmtSpill = sqlite3Config.nStmtSpill; + if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY || pPager->subjInMemory ){ + nStmtSpill = -1; + } + rc = sqlite3JournalOpen(pPager->pVfs, 0, pPager->sjfd, flags, nStmtSpill); + } + return rc; +} + +/* +** Append a record of the current state of page pPg to the sub-journal. +** +** If successful, set the bit corresponding to pPg->pgno in the bitvecs +** for all open savepoints before returning. +** +** This function returns SQLITE_OK if everything is successful, an IO +** error code if the attempt to write to the sub-journal fails, or +** SQLITE_NOMEM if a malloc fails while setting a bit in a savepoint +** bitvec. +*/ +static int subjournalPage(PgHdr *pPg){ + int rc = SQLITE_OK; + Pager *pPager = pPg->pPager; + if( pPager->journalMode!=PAGER_JOURNALMODE_OFF ){ + + /* Open the sub-journal, if it has not already been opened */ + assert( pPager->useJournal ); + assert( isOpen(pPager->jfd) || pagerUseWal(pPager) ); + assert( isOpen(pPager->sjfd) || pPager->nSubRec==0 ); + assert( pagerUseWal(pPager) + || pageInJournal(pPager, pPg) + || pPg->pgno>pPager->dbOrigSize + ); + rc = openSubJournal(pPager); + + /* If the sub-journal was opened successfully (or was already open), + ** write the journal record into the file. */ + if( rc==SQLITE_OK ){ + void *pData = pPg->pData; + i64 offset = (i64)pPager->nSubRec*(4+pPager->pageSize); + char *pData2; + +/* BEGIN SQLCIPHER */ +#if SQLITE_HAS_CODEC + if( !pPager->subjInMemory ){ + CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM_BKPT, pData2); + }else +#endif +/* END SQLCIPHER */ + pData2 = pData; + PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno)); + rc = write32bits(pPager->sjfd, offset, pPg->pgno); + if( rc==SQLITE_OK ){ + rc = sqlite3OsWrite(pPager->sjfd, pData2, pPager->pageSize, offset+4); + } + } + } + if( rc==SQLITE_OK ){ + pPager->nSubRec++; + assert( pPager->nSavepoint>0 ); + rc = addToSavepointBitvecs(pPager, pPg->pgno); + } + return rc; +} +static int subjournalPageIfRequired(PgHdr *pPg){ + if( subjRequiresPage(pPg) ){ + return subjournalPage(pPg); + }else{ + return SQLITE_OK; + } +} + +/* +** This function is called by the pcache layer when it has reached some +** soft memory limit. The first argument is a pointer to a Pager object +** (cast as a void*). The pager is always 'purgeable' (not an in-memory +** database). The second argument is a reference to a page that is +** currently dirty but has no outstanding references. The page +** is always associated with the Pager object passed as the first +** argument. +** +** The job of this function is to make pPg clean by writing its contents +** out to the database file, if possible. This may involve syncing the +** journal file. +** +** If successful, sqlite3PcacheMakeClean() is called on the page and +** SQLITE_OK returned. If an IO error occurs while trying to make the +** page clean, the IO error code is returned. If the page cannot be +** made clean for some other reason, but no error occurs, then SQLITE_OK +** is returned by sqlite3PcacheMakeClean() is not called. +*/ +static int pagerStress(void *p, PgHdr *pPg){ + Pager *pPager = (Pager *)p; + int rc = SQLITE_OK; + + assert( pPg->pPager==pPager ); + assert( pPg->flags&PGHDR_DIRTY ); + + /* The doNotSpill NOSYNC bit is set during times when doing a sync of + ** journal (and adding a new header) is not allowed. This occurs + ** during calls to sqlite3PagerWrite() while trying to journal multiple + ** pages belonging to the same sector. + ** + ** The doNotSpill ROLLBACK and OFF bits inhibits all cache spilling + ** regardless of whether or not a sync is required. This is set during + ** a rollback or by user request, respectively. + ** + ** Spilling is also prohibited when in an error state since that could + ** lead to database corruption. In the current implementation it + ** is impossible for sqlite3PcacheFetch() to be called with createFlag==3 + ** while in the error state, hence it is impossible for this routine to + ** be called in the error state. Nevertheless, we include a NEVER() + ** test for the error state as a safeguard against future changes. + */ + if( NEVER(pPager->errCode) ) return SQLITE_OK; + testcase( pPager->doNotSpill & SPILLFLAG_ROLLBACK ); + testcase( pPager->doNotSpill & SPILLFLAG_OFF ); + testcase( pPager->doNotSpill & SPILLFLAG_NOSYNC ); + if( pPager->doNotSpill + && ((pPager->doNotSpill & (SPILLFLAG_ROLLBACK|SPILLFLAG_OFF))!=0 + || (pPg->flags & PGHDR_NEED_SYNC)!=0) + ){ + return SQLITE_OK; + } + + pPager->aStat[PAGER_STAT_SPILL]++; + pPg->pDirty = 0; + if( pagerUseWal(pPager) ){ + /* Write a single frame for this page to the log. */ + rc = subjournalPageIfRequired(pPg); + if( rc==SQLITE_OK ){ + rc = pagerWalFrames(pPager, pPg, 0, 0); + } + }else{ + +#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE + if( pPager->tempFile==0 ){ + rc = sqlite3JournalCreate(pPager->jfd); + if( rc!=SQLITE_OK ) return pager_error(pPager, rc); + } +#endif + + /* Sync the journal file if required. */ + if( pPg->flags&PGHDR_NEED_SYNC + || pPager->eState==PAGER_WRITER_CACHEMOD + ){ + rc = syncJournal(pPager, 1); + } + + /* Write the contents of the page out to the database file. */ + if( rc==SQLITE_OK ){ + assert( (pPg->flags&PGHDR_NEED_SYNC)==0 ); + rc = pager_write_pagelist(pPager, pPg); + } + } + + /* Mark the page as clean. */ + if( rc==SQLITE_OK ){ + PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager), pPg->pgno)); + sqlite3PcacheMakeClean(pPg); + } + + return pager_error(pPager, rc); +} + +/* +** Flush all unreferenced dirty pages to disk. +*/ +SQLITE_PRIVATE int sqlite3PagerFlush(Pager *pPager){ + int rc = pPager->errCode; + if( !MEMDB ){ + PgHdr *pList = sqlite3PcacheDirtyList(pPager->pPCache); + assert( assert_pager_state(pPager) ); + while( rc==SQLITE_OK && pList ){ + PgHdr *pNext = pList->pDirty; + if( pList->nRef==0 ){ + rc = pagerStress((void*)pPager, pList); + } + pList = pNext; + } + } + + return rc; +} + +/* +** Allocate and initialize a new Pager object and put a pointer to it +** in *ppPager. The pager should eventually be freed by passing it +** to sqlite3PagerClose(). +** +** The zFilename argument is the path to the database file to open. +** If zFilename is NULL then a randomly-named temporary file is created +** and used as the file to be cached. Temporary files are be deleted +** automatically when they are closed. If zFilename is ":memory:" then +** all information is held in cache. It is never written to disk. +** This can be used to implement an in-memory database. +** +** The nExtra parameter specifies the number of bytes of space allocated +** along with each page reference. This space is available to the user +** via the sqlite3PagerGetExtra() API. When a new page is allocated, the +** first 8 bytes of this space are zeroed but the remainder is uninitialized. +** (The extra space is used by btree as the MemPage object.) +** +** The flags argument is used to specify properties that affect the +** operation of the pager. It should be passed some bitwise combination +** of the PAGER_* flags. +** +** The vfsFlags parameter is a bitmask to pass to the flags parameter +** of the xOpen() method of the supplied VFS when opening files. +** +** If the pager object is allocated and the specified file opened +** successfully, SQLITE_OK is returned and *ppPager set to point to +** the new pager object. If an error occurs, *ppPager is set to NULL +** and error code returned. This function may return SQLITE_NOMEM +** (sqlite3Malloc() is used to allocate memory), SQLITE_CANTOPEN or +** various SQLITE_IO_XXX errors. +*/ +SQLITE_PRIVATE int sqlite3PagerOpen( + sqlite3_vfs *pVfs, /* The virtual file system to use */ + Pager **ppPager, /* OUT: Return the Pager structure here */ + const char *zFilename, /* Name of the database file to open */ + int nExtra, /* Extra bytes append to each in-memory page */ + int flags, /* flags controlling this file */ + int vfsFlags, /* flags passed through to sqlite3_vfs.xOpen() */ + void (*xReinit)(DbPage*) /* Function to reinitialize pages */ +){ + u8 *pPtr; + Pager *pPager = 0; /* Pager object to allocate and return */ + int rc = SQLITE_OK; /* Return code */ + int tempFile = 0; /* True for temp files (incl. in-memory files) */ + int memDb = 0; /* True if this is an in-memory file */ +#ifndef SQLITE_OMIT_DESERIALIZE + int memJM = 0; /* Memory journal mode */ +#else +# define memJM 0 +#endif + int readOnly = 0; /* True if this is a read-only file */ + int journalFileSize; /* Bytes to allocate for each journal fd */ + char *zPathname = 0; /* Full path to database file */ + int nPathname = 0; /* Number of bytes in zPathname */ + int useJournal = (flags & PAGER_OMIT_JOURNAL)==0; /* False to omit journal */ + int pcacheSize = sqlite3PcacheSize(); /* Bytes to allocate for PCache */ + u32 szPageDflt = SQLITE_DEFAULT_PAGE_SIZE; /* Default page size */ + const char *zUri = 0; /* URI args to copy */ + int nUriByte = 1; /* Number of bytes of URI args at *zUri */ + + /* Figure out how much space is required for each journal file-handle + ** (there are two of them, the main journal and the sub-journal). */ + journalFileSize = ROUND8(sqlite3JournalSize(pVfs)); + + /* Set the output variable to NULL in case an error occurs. */ + *ppPager = 0; + +#ifndef SQLITE_OMIT_MEMORYDB + if( flags & PAGER_MEMORY ){ + memDb = 1; + if( zFilename && zFilename[0] ){ + zPathname = sqlite3DbStrDup(0, zFilename); + if( zPathname==0 ) return SQLITE_NOMEM_BKPT; + nPathname = sqlite3Strlen30(zPathname); + zFilename = 0; + } + } +#endif + + /* Compute and store the full pathname in an allocated buffer pointed + ** to by zPathname, length nPathname. Or, if this is a temporary file, + ** leave both nPathname and zPathname set to 0. + */ + if( zFilename && zFilename[0] ){ + const char *z; + nPathname = pVfs->mxPathname+1; + zPathname = sqlite3DbMallocRaw(0, nPathname*2); + if( zPathname==0 ){ + return SQLITE_NOMEM_BKPT; + } + zPathname[0] = 0; /* Make sure initialized even if FullPathname() fails */ + rc = sqlite3OsFullPathname(pVfs, zFilename, nPathname, zPathname); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_OK_SYMLINK ){ + if( vfsFlags & SQLITE_OPEN_NOFOLLOW ){ + rc = SQLITE_CANTOPEN_SYMLINK; + }else{ + rc = SQLITE_OK; + } + } + } + nPathname = sqlite3Strlen30(zPathname); + z = zUri = &zFilename[sqlite3Strlen30(zFilename)+1]; + while( *z ){ + z += strlen(z)+1; + z += strlen(z)+1; + } + nUriByte = (int)(&z[1] - zUri); + assert( nUriByte>=1 ); + if( rc==SQLITE_OK && nPathname+8>pVfs->mxPathname ){ + /* This branch is taken when the journal path required by + ** the database being opened will be more than pVfs->mxPathname + ** bytes in length. This means the database cannot be opened, + ** as it will not be possible to open the journal file or even + ** check for a hot-journal before reading. + */ + rc = SQLITE_CANTOPEN_BKPT; + } + if( rc!=SQLITE_OK ){ + sqlite3DbFree(0, zPathname); + return rc; + } + } + + /* Allocate memory for the Pager structure, PCache object, the + ** three file descriptors, the database file name and the journal + ** file name. The layout in memory is as follows: + ** + ** Pager object (sizeof(Pager) bytes) + ** PCache object (sqlite3PcacheSize() bytes) + ** Database file handle (pVfs->szOsFile bytes) + ** Sub-journal file handle (journalFileSize bytes) + ** Main journal file handle (journalFileSize bytes) + ** Ptr back to the Pager (sizeof(Pager*) bytes) + ** \0\0\0\0 database prefix (4 bytes) + ** Database file name (nPathname+1 bytes) + ** URI query parameters (nUriByte bytes) + ** Journal filename (nPathname+8+1 bytes) + ** WAL filename (nPathname+4+1 bytes) + ** \0\0\0 terminator (3 bytes) + ** + ** Some 3rd-party software, over which we have no control, depends on + ** the specific order of the filenames and the \0 separators between them + ** so that it can (for example) find the database filename given the WAL + ** filename without using the sqlite3_filename_database() API. This is a + ** misuse of SQLite and a bug in the 3rd-party software, but the 3rd-party + ** software is in widespread use, so we try to avoid changing the filename + ** order and formatting if possible. In particular, the details of the + ** filename format expected by 3rd-party software should be as follows: + ** + ** - Main Database Path + ** - \0 + ** - Multiple URI components consisting of: + ** - Key + ** - \0 + ** - Value + ** - \0 + ** - \0 + ** - Journal Path + ** - \0 + ** - WAL Path (zWALName) + ** - \0 + ** + ** The sqlite3_create_filename() interface and the databaseFilename() utility + ** that is used by sqlite3_filename_database() and kin also depend on the + ** specific formatting and order of the various filenames, so if the format + ** changes here, be sure to change it there as well. + */ + pPtr = (u8 *)sqlite3MallocZero( + ROUND8(sizeof(*pPager)) + /* Pager structure */ + ROUND8(pcacheSize) + /* PCache object */ + ROUND8(pVfs->szOsFile) + /* The main db file */ + journalFileSize * 2 + /* The two journal files */ + sizeof(pPager) + /* Space to hold a pointer */ + 4 + /* Database prefix */ + nPathname + 1 + /* database filename */ + nUriByte + /* query parameters */ + nPathname + 8 + 1 + /* Journal filename */ +#ifndef SQLITE_OMIT_WAL + nPathname + 4 + 1 + /* WAL filename */ +#endif + 3 /* Terminator */ + ); + assert( EIGHT_BYTE_ALIGNMENT(SQLITE_INT_TO_PTR(journalFileSize)) ); + if( !pPtr ){ + sqlite3DbFree(0, zPathname); + return SQLITE_NOMEM_BKPT; + } + pPager = (Pager*)pPtr; pPtr += ROUND8(sizeof(*pPager)); + pPager->pPCache = (PCache*)pPtr; pPtr += ROUND8(pcacheSize); + pPager->fd = (sqlite3_file*)pPtr; pPtr += ROUND8(pVfs->szOsFile); + pPager->sjfd = (sqlite3_file*)pPtr; pPtr += journalFileSize; + pPager->jfd = (sqlite3_file*)pPtr; pPtr += journalFileSize; + assert( EIGHT_BYTE_ALIGNMENT(pPager->jfd) ); + memcpy(pPtr, &pPager, sizeof(pPager)); pPtr += sizeof(pPager); + + /* Fill in the Pager.zFilename and pPager.zQueryParam fields */ + pPtr += 4; /* Skip zero prefix */ + pPager->zFilename = (char*)pPtr; + if( nPathname>0 ){ + memcpy(pPtr, zPathname, nPathname); pPtr += nPathname + 1; + if( zUri ){ + memcpy(pPtr, zUri, nUriByte); pPtr += nUriByte; + }else{ + pPtr++; + } + } + + + /* Fill in Pager.zJournal */ + if( nPathname>0 ){ + pPager->zJournal = (char*)pPtr; + memcpy(pPtr, zPathname, nPathname); pPtr += nPathname; + memcpy(pPtr, "-journal",8); pPtr += 8 + 1; +#ifdef SQLITE_ENABLE_8_3_NAMES + sqlite3FileSuffix3(zFilename,pPager->zJournal); + pPtr = (u8*)(pPager->zJournal + sqlite3Strlen30(pPager->zJournal)+1); +#endif + }else{ + pPager->zJournal = 0; + } + +#ifndef SQLITE_OMIT_WAL + /* Fill in Pager.zWal */ + if( nPathname>0 ){ + pPager->zWal = (char*)pPtr; + memcpy(pPtr, zPathname, nPathname); pPtr += nPathname; + memcpy(pPtr, "-wal", 4); pPtr += 4 + 1; +#ifdef SQLITE_ENABLE_8_3_NAMES + sqlite3FileSuffix3(zFilename, pPager->zWal); + pPtr = (u8*)(pPager->zWal + sqlite3Strlen30(pPager->zWal)+1); +#endif + }else{ + pPager->zWal = 0; + } +#endif + (void)pPtr; /* Suppress warning about unused pPtr value */ + + if( nPathname ) sqlite3DbFree(0, zPathname); + pPager->pVfs = pVfs; + pPager->vfsFlags = vfsFlags; + + /* Open the pager file. + */ + if( zFilename && zFilename[0] ){ + int fout = 0; /* VFS flags returned by xOpen() */ + rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd, vfsFlags, &fout); + assert( !memDb ); +#ifndef SQLITE_OMIT_DESERIALIZE + pPager->memVfs = memJM = (fout&SQLITE_OPEN_MEMORY)!=0; +#endif + readOnly = (fout&SQLITE_OPEN_READONLY)!=0; + + /* If the file was successfully opened for read/write access, + ** choose a default page size in case we have to create the + ** database file. The default page size is the maximum of: + ** + ** + SQLITE_DEFAULT_PAGE_SIZE, + ** + The value returned by sqlite3OsSectorSize() + ** + The largest page size that can be written atomically. + */ + if( rc==SQLITE_OK ){ + int iDc = sqlite3OsDeviceCharacteristics(pPager->fd); + if( !readOnly ){ + setSectorSize(pPager); + assert(SQLITE_DEFAULT_PAGE_SIZE<=SQLITE_MAX_DEFAULT_PAGE_SIZE); + if( szPageDfltsectorSize ){ + if( pPager->sectorSize>SQLITE_MAX_DEFAULT_PAGE_SIZE ){ + szPageDflt = SQLITE_MAX_DEFAULT_PAGE_SIZE; + }else{ + szPageDflt = (u32)pPager->sectorSize; + } + } +#ifdef SQLITE_ENABLE_ATOMIC_WRITE + { + int ii; + assert(SQLITE_IOCAP_ATOMIC512==(512>>8)); + assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8)); + assert(SQLITE_MAX_DEFAULT_PAGE_SIZE<=65536); + for(ii=szPageDflt; ii<=SQLITE_MAX_DEFAULT_PAGE_SIZE; ii=ii*2){ + if( iDc&(SQLITE_IOCAP_ATOMIC|(ii>>8)) ){ + szPageDflt = ii; + } + } + } +#endif + } + pPager->noLock = sqlite3_uri_boolean(pPager->zFilename, "nolock", 0); + if( (iDc & SQLITE_IOCAP_IMMUTABLE)!=0 + || sqlite3_uri_boolean(pPager->zFilename, "immutable", 0) ){ + vfsFlags |= SQLITE_OPEN_READONLY; + goto act_like_temp_file; + } + } + }else{ + /* If a temporary file is requested, it is not opened immediately. + ** In this case we accept the default page size and delay actually + ** opening the file until the first call to OsWrite(). + ** + ** This branch is also run for an in-memory database. An in-memory + ** database is the same as a temp-file that is never written out to + ** disk and uses an in-memory rollback journal. + ** + ** This branch also runs for files marked as immutable. + */ +act_like_temp_file: + tempFile = 1; + pPager->eState = PAGER_READER; /* Pretend we already have a lock */ + pPager->eLock = EXCLUSIVE_LOCK; /* Pretend we are in EXCLUSIVE mode */ + pPager->noLock = 1; /* Do no locking */ + readOnly = (vfsFlags&SQLITE_OPEN_READONLY); + } + + /* The following call to PagerSetPagesize() serves to set the value of + ** Pager.pageSize and to allocate the Pager.pTmpSpace buffer. + */ + if( rc==SQLITE_OK ){ + assert( pPager->memDb==0 ); + rc = sqlite3PagerSetPagesize(pPager, &szPageDflt, -1); + testcase( rc!=SQLITE_OK ); + } + + /* Initialize the PCache object. */ + if( rc==SQLITE_OK ){ + nExtra = ROUND8(nExtra); + assert( nExtra>=8 && nExtra<1000 ); + rc = sqlite3PcacheOpen(szPageDflt, nExtra, !memDb, + !memDb?pagerStress:0, (void *)pPager, pPager->pPCache); + } + + /* If an error occurred above, free the Pager structure and close the file. + */ + if( rc!=SQLITE_OK ){ + sqlite3OsClose(pPager->fd); + sqlite3PageFree(pPager->pTmpSpace); + sqlite3_free(pPager); + return rc; + } + + PAGERTRACE(("OPEN %d %s\n", FILEHANDLEID(pPager->fd), pPager->zFilename)); + IOTRACE(("OPEN %p %s\n", pPager, pPager->zFilename)) + + pPager->useJournal = (u8)useJournal; + /* pPager->stmtOpen = 0; */ + /* pPager->stmtInUse = 0; */ + /* pPager->nRef = 0; */ + /* pPager->stmtSize = 0; */ + /* pPager->stmtJSize = 0; */ + /* pPager->nPage = 0; */ + pPager->mxPgno = SQLITE_MAX_PAGE_COUNT; + /* pPager->state = PAGER_UNLOCK; */ + /* pPager->errMask = 0; */ + pPager->tempFile = (u8)tempFile; + assert( tempFile==PAGER_LOCKINGMODE_NORMAL + || tempFile==PAGER_LOCKINGMODE_EXCLUSIVE ); + assert( PAGER_LOCKINGMODE_EXCLUSIVE==1 ); + pPager->exclusiveMode = (u8)tempFile; + pPager->changeCountDone = pPager->tempFile; + pPager->memDb = (u8)memDb; + pPager->readOnly = (u8)readOnly; + assert( useJournal || pPager->tempFile ); + sqlite3PagerSetFlags(pPager, (SQLITE_DEFAULT_SYNCHRONOUS+1)|PAGER_CACHESPILL); + /* pPager->pFirst = 0; */ + /* pPager->pFirstSynced = 0; */ + /* pPager->pLast = 0; */ + pPager->nExtra = (u16)nExtra; + pPager->journalSizeLimit = SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT; + assert( isOpen(pPager->fd) || tempFile ); + setSectorSize(pPager); + if( !useJournal ){ + pPager->journalMode = PAGER_JOURNALMODE_OFF; + }else if( memDb || memJM ){ + pPager->journalMode = PAGER_JOURNALMODE_MEMORY; + } + /* pPager->xBusyHandler = 0; */ + /* pPager->pBusyHandlerArg = 0; */ + pPager->xReiniter = xReinit; + setGetterMethod(pPager); + /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */ + /* pPager->szMmap = SQLITE_DEFAULT_MMAP_SIZE // will be set by btree.c */ + + *ppPager = pPager; + return SQLITE_OK; +} + +/* +** Return the sqlite3_file for the main database given the name +** of the corresonding WAL or Journal name as passed into +** xOpen. +*/ +SQLITE_API sqlite3_file *sqlite3_database_file_object(const char *zName){ + Pager *pPager; + while( zName[-1]!=0 || zName[-2]!=0 || zName[-3]!=0 || zName[-4]!=0 ){ + zName--; + } + pPager = *(Pager**)(zName - 4 - sizeof(Pager*)); + return pPager->fd; +} + + +/* +** This function is called after transitioning from PAGER_UNLOCK to +** PAGER_SHARED state. It tests if there is a hot journal present in +** the file-system for the given pager. A hot journal is one that +** needs to be played back. According to this function, a hot-journal +** file exists if the following criteria are met: +** +** * The journal file exists in the file system, and +** * No process holds a RESERVED or greater lock on the database file, and +** * The database file itself is greater than 0 bytes in size, and +** * The first byte of the journal file exists and is not 0x00. +** +** If the current size of the database file is 0 but a journal file +** exists, that is probably an old journal left over from a prior +** database with the same name. In this case the journal file is +** just deleted using OsDelete, *pExists is set to 0 and SQLITE_OK +** is returned. +** +** This routine does not check if there is a super-journal filename +** at the end of the file. If there is, and that super-journal file +** does not exist, then the journal file is not really hot. In this +** case this routine will return a false-positive. The pager_playback() +** routine will discover that the journal file is not really hot and +** will not roll it back. +** +** If a hot-journal file is found to exist, *pExists is set to 1 and +** SQLITE_OK returned. If no hot-journal file is present, *pExists is +** set to 0 and SQLITE_OK returned. If an IO error occurs while trying +** to determine whether or not a hot-journal file exists, the IO error +** code is returned and the value of *pExists is undefined. +*/ +static int hasHotJournal(Pager *pPager, int *pExists){ + sqlite3_vfs * const pVfs = pPager->pVfs; + int rc = SQLITE_OK; /* Return code */ + int exists = 1; /* True if a journal file is present */ + int jrnlOpen = !!isOpen(pPager->jfd); + + assert( pPager->useJournal ); + assert( isOpen(pPager->fd) ); + assert( pPager->eState==PAGER_OPEN ); + + assert( jrnlOpen==0 || ( sqlite3OsDeviceCharacteristics(pPager->jfd) & + SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN + )); + + *pExists = 0; + if( !jrnlOpen ){ + rc = sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &exists); + } + if( rc==SQLITE_OK && exists ){ + int locked = 0; /* True if some process holds a RESERVED lock */ + + /* Race condition here: Another process might have been holding the + ** the RESERVED lock and have a journal open at the sqlite3OsAccess() + ** call above, but then delete the journal and drop the lock before + ** we get to the following sqlite3OsCheckReservedLock() call. If that + ** is the case, this routine might think there is a hot journal when + ** in fact there is none. This results in a false-positive which will + ** be dealt with by the playback routine. Ticket #3883. + */ + rc = sqlite3OsCheckReservedLock(pPager->fd, &locked); + if( rc==SQLITE_OK && !locked ){ + Pgno nPage; /* Number of pages in database file */ + + assert( pPager->tempFile==0 ); + rc = pagerPagecount(pPager, &nPage); + if( rc==SQLITE_OK ){ + /* If the database is zero pages in size, that means that either (1) the + ** journal is a remnant from a prior database with the same name where + ** the database file but not the journal was deleted, or (2) the initial + ** transaction that populates a new database is being rolled back. + ** In either case, the journal file can be deleted. However, take care + ** not to delete the journal file if it is already open due to + ** journal_mode=PERSIST. + */ + if( nPage==0 && !jrnlOpen ){ + sqlite3BeginBenignMalloc(); + if( pagerLockDb(pPager, RESERVED_LOCK)==SQLITE_OK ){ + sqlite3OsDelete(pVfs, pPager->zJournal, 0); + if( !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK); + } + sqlite3EndBenignMalloc(); + }else{ + /* The journal file exists and no other connection has a reserved + ** or greater lock on the database file. Now check that there is + ** at least one non-zero bytes at the start of the journal file. + ** If there is, then we consider this journal to be hot. If not, + ** it can be ignored. + */ + if( !jrnlOpen ){ + int f = SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL; + rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &f); + } + if( rc==SQLITE_OK ){ + u8 first = 0; + rc = sqlite3OsRead(pPager->jfd, (void *)&first, 1, 0); + if( rc==SQLITE_IOERR_SHORT_READ ){ + rc = SQLITE_OK; + } + if( !jrnlOpen ){ + sqlite3OsClose(pPager->jfd); + } + *pExists = (first!=0); + }else if( rc==SQLITE_CANTOPEN ){ + /* If we cannot open the rollback journal file in order to see if + ** it has a zero header, that might be due to an I/O error, or + ** it might be due to the race condition described above and in + ** ticket #3883. Either way, assume that the journal is hot. + ** This might be a false positive. But if it is, then the + ** automatic journal playback and recovery mechanism will deal + ** with it under an EXCLUSIVE lock where we do not need to + ** worry so much with race conditions. + */ + *pExists = 1; + rc = SQLITE_OK; + } + } + } + } + } + + return rc; +} + +/* +** This function is called to obtain a shared lock on the database file. +** It is illegal to call sqlite3PagerGet() until after this function +** has been successfully called. If a shared-lock is already held when +** this function is called, it is a no-op. +** +** The following operations are also performed by this function. +** +** 1) If the pager is currently in PAGER_OPEN state (no lock held +** on the database file), then an attempt is made to obtain a +** SHARED lock on the database file. Immediately after obtaining +** the SHARED lock, the file-system is checked for a hot-journal, +** which is played back if present. Following any hot-journal +** rollback, the contents of the cache are validated by checking +** the 'change-counter' field of the database file header and +** discarded if they are found to be invalid. +** +** 2) If the pager is running in exclusive-mode, and there are currently +** no outstanding references to any pages, and is in the error state, +** then an attempt is made to clear the error state by discarding +** the contents of the page cache and rolling back any open journal +** file. +** +** If everything is successful, SQLITE_OK is returned. If an IO error +** occurs while locking the database, checking for a hot-journal file or +** rolling back a journal file, the IO error code is returned. +*/ +SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager){ + int rc = SQLITE_OK; /* Return code */ + + /* This routine is only called from b-tree and only when there are no + ** outstanding pages. This implies that the pager state should either + ** be OPEN or READER. READER is only possible if the pager is or was in + ** exclusive access mode. */ + assert( sqlite3PcacheRefCount(pPager->pPCache)==0 ); + assert( assert_pager_state(pPager) ); + assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER ); + assert( pPager->errCode==SQLITE_OK ); + + if( !pagerUseWal(pPager) && pPager->eState==PAGER_OPEN ){ + int bHotJournal = 1; /* True if there exists a hot journal-file */ + + assert( !MEMDB ); + assert( pPager->tempFile==0 || pPager->eLock==EXCLUSIVE_LOCK ); + + rc = pager_wait_on_lock(pPager, SHARED_LOCK); + if( rc!=SQLITE_OK ){ + assert( pPager->eLock==NO_LOCK || pPager->eLock==UNKNOWN_LOCK ); + goto failed; + } + + /* If a journal file exists, and there is no RESERVED lock on the + ** database file, then it either needs to be played back or deleted. + */ + if( pPager->eLock<=SHARED_LOCK ){ + rc = hasHotJournal(pPager, &bHotJournal); + } + if( rc!=SQLITE_OK ){ + goto failed; + } + if( bHotJournal ){ + if( pPager->readOnly ){ + rc = SQLITE_READONLY_ROLLBACK; + goto failed; + } + + /* Get an EXCLUSIVE lock on the database file. At this point it is + ** important that a RESERVED lock is not obtained on the way to the + ** EXCLUSIVE lock. If it were, another process might open the + ** database file, detect the RESERVED lock, and conclude that the + ** database is safe to read while this process is still rolling the + ** hot-journal back. + ** + ** Because the intermediate RESERVED lock is not requested, any + ** other process attempting to access the database file will get to + ** this point in the code and fail to obtain its own EXCLUSIVE lock + ** on the database file. + ** + ** Unless the pager is in locking_mode=exclusive mode, the lock is + ** downgraded to SHARED_LOCK before this function returns. + */ + rc = pagerLockDb(pPager, EXCLUSIVE_LOCK); + if( rc!=SQLITE_OK ){ + goto failed; + } + + /* If it is not already open and the file exists on disk, open the + ** journal for read/write access. Write access is required because + ** in exclusive-access mode the file descriptor will be kept open + ** and possibly used for a transaction later on. Also, write-access + ** is usually required to finalize the journal in journal_mode=persist + ** mode (and also for journal_mode=truncate on some systems). + ** + ** If the journal does not exist, it usually means that some + ** other connection managed to get in and roll it back before + ** this connection obtained the exclusive lock above. Or, it + ** may mean that the pager was in the error-state when this + ** function was called and the journal file does not exist. + */ + if( !isOpen(pPager->jfd) && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){ + sqlite3_vfs * const pVfs = pPager->pVfs; + int bExists; /* True if journal file exists */ + rc = sqlite3OsAccess( + pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &bExists); + if( rc==SQLITE_OK && bExists ){ + int fout = 0; + int f = SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_JOURNAL; + assert( !pPager->tempFile ); + rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout); + assert( rc!=SQLITE_OK || isOpen(pPager->jfd) ); + if( rc==SQLITE_OK && fout&SQLITE_OPEN_READONLY ){ + rc = SQLITE_CANTOPEN_BKPT; + sqlite3OsClose(pPager->jfd); + } + } + } + + /* Playback and delete the journal. Drop the database write + ** lock and reacquire the read lock. Purge the cache before + ** playing back the hot-journal so that we don't end up with + ** an inconsistent cache. Sync the hot journal before playing + ** it back since the process that crashed and left the hot journal + ** probably did not sync it and we are required to always sync + ** the journal before playing it back. + */ + if( isOpen(pPager->jfd) ){ + assert( rc==SQLITE_OK ); + rc = pagerSyncHotJournal(pPager); + if( rc==SQLITE_OK ){ + rc = pager_playback(pPager, !pPager->tempFile); + pPager->eState = PAGER_OPEN; + } + }else if( !pPager->exclusiveMode ){ + pagerUnlockDb(pPager, SHARED_LOCK); + } + + if( rc!=SQLITE_OK ){ + /* This branch is taken if an error occurs while trying to open + ** or roll back a hot-journal while holding an EXCLUSIVE lock. The + ** pager_unlock() routine will be called before returning to unlock + ** the file. If the unlock attempt fails, then Pager.eLock must be + ** set to UNKNOWN_LOCK (see the comment above the #define for + ** UNKNOWN_LOCK above for an explanation). + ** + ** In order to get pager_unlock() to do this, set Pager.eState to + ** PAGER_ERROR now. This is not actually counted as a transition + ** to ERROR state in the state diagram at the top of this file, + ** since we know that the same call to pager_unlock() will very + ** shortly transition the pager object to the OPEN state. Calling + ** assert_pager_state() would fail now, as it should not be possible + ** to be in ERROR state when there are zero outstanding page + ** references. + */ + pager_error(pPager, rc); + goto failed; + } + + assert( pPager->eState==PAGER_OPEN ); + assert( (pPager->eLock==SHARED_LOCK) + || (pPager->exclusiveMode && pPager->eLock>SHARED_LOCK) + ); + } + + if( !pPager->tempFile && pPager->hasHeldSharedLock ){ + /* The shared-lock has just been acquired then check to + ** see if the database has been modified. If the database has changed, + ** flush the cache. The hasHeldSharedLock flag prevents this from + ** occurring on the very first access to a file, in order to save a + ** single unnecessary sqlite3OsRead() call at the start-up. + ** + ** Database changes are detected by looking at 15 bytes beginning + ** at offset 24 into the file. The first 4 of these 16 bytes are + ** a 32-bit counter that is incremented with each change. The + ** other bytes change randomly with each file change when + ** a codec is in use. + ** + ** There is a vanishingly small chance that a change will not be + ** detected. The chance of an undetected change is so small that + ** it can be neglected. + */ + char dbFileVers[sizeof(pPager->dbFileVers)]; + + IOTRACE(("CKVERS %p %d\n", pPager, sizeof(dbFileVers))); + rc = sqlite3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24); + if( rc!=SQLITE_OK ){ + if( rc!=SQLITE_IOERR_SHORT_READ ){ + goto failed; + } + memset(dbFileVers, 0, sizeof(dbFileVers)); + } + + if( memcmp(pPager->dbFileVers, dbFileVers, sizeof(dbFileVers))!=0 ){ + pager_reset(pPager); + + /* Unmap the database file. It is possible that external processes + ** may have truncated the database file and then extended it back + ** to its original size while this process was not holding a lock. + ** In this case there may exist a Pager.pMap mapping that appears + ** to be the right size but is not actually valid. Avoid this + ** possibility by unmapping the db here. */ + if( USEFETCH(pPager) ){ + sqlite3OsUnfetch(pPager->fd, 0, 0); + } + } + } + + /* If there is a WAL file in the file-system, open this database in WAL + ** mode. Otherwise, the following function call is a no-op. + */ + rc = pagerOpenWalIfPresent(pPager); +#ifndef SQLITE_OMIT_WAL + assert( pPager->pWal==0 || rc==SQLITE_OK ); +#endif + } + + if( pagerUseWal(pPager) ){ + assert( rc==SQLITE_OK ); + rc = pagerBeginReadTransaction(pPager); + } + + if( pPager->tempFile==0 && pPager->eState==PAGER_OPEN && rc==SQLITE_OK ){ + rc = pagerPagecount(pPager, &pPager->dbSize); + } + + failed: + if( rc!=SQLITE_OK ){ + assert( !MEMDB ); + pager_unlock(pPager); + assert( pPager->eState==PAGER_OPEN ); + }else{ + pPager->eState = PAGER_READER; + pPager->hasHeldSharedLock = 1; + } + return rc; +} + +/* +** If the reference count has reached zero, rollback any active +** transaction and unlock the pager. +** +** Except, in locking_mode=EXCLUSIVE when there is nothing to in +** the rollback journal, the unlock is not performed and there is +** nothing to rollback, so this routine is a no-op. +*/ +static void pagerUnlockIfUnused(Pager *pPager){ + if( sqlite3PcacheRefCount(pPager->pPCache)==0 ){ + assert( pPager->nMmapOut==0 ); /* because page1 is never memory mapped */ + pagerUnlockAndRollback(pPager); + } +} + +/* +** The page getter methods each try to acquire a reference to a +** page with page number pgno. If the requested reference is +** successfully obtained, it is copied to *ppPage and SQLITE_OK returned. +** +** There are different implementations of the getter method depending +** on the current state of the pager. +** +** getPageNormal() -- The normal getter +** getPageError() -- Used if the pager is in an error state +** getPageMmap() -- Used if memory-mapped I/O is enabled +** +** If the requested page is already in the cache, it is returned. +** Otherwise, a new page object is allocated and populated with data +** read from the database file. In some cases, the pcache module may +** choose not to allocate a new page object and may reuse an existing +** object with no outstanding references. +** +** The extra data appended to a page is always initialized to zeros the +** first time a page is loaded into memory. If the page requested is +** already in the cache when this function is called, then the extra +** data is left as it was when the page object was last used. +** +** If the database image is smaller than the requested page or if +** the flags parameter contains the PAGER_GET_NOCONTENT bit and the +** requested page is not already stored in the cache, then no +** actual disk read occurs. In this case the memory image of the +** page is initialized to all zeros. +** +** If PAGER_GET_NOCONTENT is true, it means that we do not care about +** the contents of the page. This occurs in two scenarios: +** +** a) When reading a free-list leaf page from the database, and +** +** b) When a savepoint is being rolled back and we need to load +** a new page into the cache to be filled with the data read +** from the savepoint journal. +** +** If PAGER_GET_NOCONTENT is true, then the data returned is zeroed instead +** of being read from the database. Additionally, the bits corresponding +** to pgno in Pager.pInJournal (bitvec of pages already written to the +** journal file) and the PagerSavepoint.pInSavepoint bitvecs of any open +** savepoints are set. This means if the page is made writable at any +** point in the future, using a call to sqlite3PagerWrite(), its contents +** will not be journaled. This saves IO. +** +** The acquisition might fail for several reasons. In all cases, +** an appropriate error code is returned and *ppPage is set to NULL. +** +** See also sqlite3PagerLookup(). Both this routine and Lookup() attempt +** to find a page in the in-memory cache first. If the page is not already +** in memory, this routine goes to disk to read it in whereas Lookup() +** just returns 0. This routine acquires a read-lock the first time it +** has to go to disk, and could also playback an old journal if necessary. +** Since Lookup() never goes to disk, it never has to deal with locks +** or journal files. +*/ +static int getPageNormal( + Pager *pPager, /* The pager open on the database file */ + Pgno pgno, /* Page number to fetch */ + DbPage **ppPage, /* Write a pointer to the page here */ + int flags /* PAGER_GET_XXX flags */ +){ + int rc = SQLITE_OK; + PgHdr *pPg; + u8 noContent; /* True if PAGER_GET_NOCONTENT is set */ + sqlite3_pcache_page *pBase; + + assert( pPager->errCode==SQLITE_OK ); + assert( pPager->eState>=PAGER_READER ); + assert( assert_pager_state(pPager) ); + assert( pPager->hasHeldSharedLock==1 ); + + if( pgno==0 ) return SQLITE_CORRUPT_BKPT; + pBase = sqlite3PcacheFetch(pPager->pPCache, pgno, 3); + if( pBase==0 ){ + pPg = 0; + rc = sqlite3PcacheFetchStress(pPager->pPCache, pgno, &pBase); + if( rc!=SQLITE_OK ) goto pager_acquire_err; + if( pBase==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto pager_acquire_err; + } + } + pPg = *ppPage = sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pBase); + assert( pPg==(*ppPage) ); + assert( pPg->pgno==pgno ); + assert( pPg->pPager==pPager || pPg->pPager==0 ); + + noContent = (flags & PAGER_GET_NOCONTENT)!=0; + if( pPg->pPager && !noContent ){ + /* In this case the pcache already contains an initialized copy of + ** the page. Return without further ado. */ + assert( pgno!=PAGER_SJ_PGNO(pPager) ); + pPager->aStat[PAGER_STAT_HIT]++; + return SQLITE_OK; + + }else{ + /* The pager cache has created a new page. Its content needs to + ** be initialized. But first some error checks: + ** + ** (*) obsolete. Was: maximum page number is 2^31 + ** (2) Never try to fetch the locking page + */ + if( pgno==PAGER_SJ_PGNO(pPager) ){ + rc = SQLITE_CORRUPT_BKPT; + goto pager_acquire_err; + } + + pPg->pPager = pPager; + + assert( !isOpen(pPager->fd) || !MEMDB ); + if( !isOpen(pPager->fd) || pPager->dbSizepPager->mxPgno ){ + rc = SQLITE_FULL; + if( pgno<=pPager->dbSize ){ + sqlite3PcacheRelease(pPg); + pPg = 0; + } + goto pager_acquire_err; + } + if( noContent ){ + /* Failure to set the bits in the InJournal bit-vectors is benign. + ** It merely means that we might do some extra work to journal a + ** page that does not need to be journaled. Nevertheless, be sure + ** to test the case where a malloc error occurs while trying to set + ** a bit in a bit vector. + */ + sqlite3BeginBenignMalloc(); + if( pgno<=pPager->dbOrigSize ){ + TESTONLY( rc = ) sqlite3BitvecSet(pPager->pInJournal, pgno); + testcase( rc==SQLITE_NOMEM ); + } + TESTONLY( rc = ) addToSavepointBitvecs(pPager, pgno); + testcase( rc==SQLITE_NOMEM ); + sqlite3EndBenignMalloc(); + } + memset(pPg->pData, 0, pPager->pageSize); + IOTRACE(("ZERO %p %d\n", pPager, pgno)); + }else{ + assert( pPg->pPager==pPager ); + pPager->aStat[PAGER_STAT_MISS]++; + rc = readDbPage(pPg); + if( rc!=SQLITE_OK ){ + goto pager_acquire_err; + } + } + pager_set_pagehash(pPg); + } + return SQLITE_OK; + +pager_acquire_err: + assert( rc!=SQLITE_OK ); + if( pPg ){ + sqlite3PcacheDrop(pPg); + } + pagerUnlockIfUnused(pPager); + *ppPage = 0; + return rc; +} + +#if SQLITE_MAX_MMAP_SIZE>0 +/* The page getter for when memory-mapped I/O is enabled */ +static int getPageMMap( + Pager *pPager, /* The pager open on the database file */ + Pgno pgno, /* Page number to fetch */ + DbPage **ppPage, /* Write a pointer to the page here */ + int flags /* PAGER_GET_XXX flags */ +){ + int rc = SQLITE_OK; + PgHdr *pPg = 0; + u32 iFrame = 0; /* Frame to read from WAL file */ + + /* It is acceptable to use a read-only (mmap) page for any page except + ** page 1 if there is no write-transaction open or the ACQUIRE_READONLY + ** flag was specified by the caller. And so long as the db is not a + ** temporary or in-memory database. */ + const int bMmapOk = (pgno>1 + && (pPager->eState==PAGER_READER || (flags & PAGER_GET_READONLY)) + ); + + assert( USEFETCH(pPager) ); +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC + assert( pPager->xCodec==0 ); +#endif +/* END SQLCIPHER */ + + /* Optimization note: Adding the "pgno<=1" term before "pgno==0" here + ** allows the compiler optimizer to reuse the results of the "pgno>1" + ** test in the previous statement, and avoid testing pgno==0 in the + ** common case where pgno is large. */ + if( pgno<=1 && pgno==0 ){ + return SQLITE_CORRUPT_BKPT; + } + assert( pPager->eState>=PAGER_READER ); + assert( assert_pager_state(pPager) ); + assert( pPager->hasHeldSharedLock==1 ); + assert( pPager->errCode==SQLITE_OK ); + + if( bMmapOk && pagerUseWal(pPager) ){ + rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iFrame); + if( rc!=SQLITE_OK ){ + *ppPage = 0; + return rc; + } + } + if( bMmapOk && iFrame==0 ){ + void *pData = 0; + rc = sqlite3OsFetch(pPager->fd, + (i64)(pgno-1) * pPager->pageSize, pPager->pageSize, &pData + ); + if( rc==SQLITE_OK && pData ){ + if( pPager->eState>PAGER_READER || pPager->tempFile ){ + pPg = sqlite3PagerLookup(pPager, pgno); + } + if( pPg==0 ){ + rc = pagerAcquireMapPage(pPager, pgno, pData, &pPg); + }else{ + sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1)*pPager->pageSize, pData); + } + if( pPg ){ + assert( rc==SQLITE_OK ); + *ppPage = pPg; + return SQLITE_OK; + } + } + if( rc!=SQLITE_OK ){ + *ppPage = 0; + return rc; + } + } + return getPageNormal(pPager, pgno, ppPage, flags); +} +#endif /* SQLITE_MAX_MMAP_SIZE>0 */ + +/* The page getter method for when the pager is an error state */ +static int getPageError( + Pager *pPager, /* The pager open on the database file */ + Pgno pgno, /* Page number to fetch */ + DbPage **ppPage, /* Write a pointer to the page here */ + int flags /* PAGER_GET_XXX flags */ +){ + UNUSED_PARAMETER(pgno); + UNUSED_PARAMETER(flags); + assert( pPager->errCode!=SQLITE_OK ); + *ppPage = 0; + return pPager->errCode; +} + + +/* Dispatch all page fetch requests to the appropriate getter method. +*/ +SQLITE_PRIVATE int sqlite3PagerGet( + Pager *pPager, /* The pager open on the database file */ + Pgno pgno, /* Page number to fetch */ + DbPage **ppPage, /* Write a pointer to the page here */ + int flags /* PAGER_GET_XXX flags */ +){ + /* printf("PAGE %u\n", pgno); fflush(stdout); */ + return pPager->xGet(pPager, pgno, ppPage, flags); +} + +/* +** Acquire a page if it is already in the in-memory cache. Do +** not read the page from disk. Return a pointer to the page, +** or 0 if the page is not in cache. +** +** See also sqlite3PagerGet(). The difference between this routine +** and sqlite3PagerGet() is that _get() will go to the disk and read +** in the page if the page is not already in cache. This routine +** returns NULL if the page is not in cache or if a disk I/O error +** has ever happened. +*/ +SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){ + sqlite3_pcache_page *pPage; + assert( pPager!=0 ); + assert( pgno!=0 ); + assert( pPager->pPCache!=0 ); + pPage = sqlite3PcacheFetch(pPager->pPCache, pgno, 0); + assert( pPage==0 || pPager->hasHeldSharedLock ); + if( pPage==0 ) return 0; + return sqlite3PcacheFetchFinish(pPager->pPCache, pgno, pPage); +} + +/* +** Release a page reference. +** +** The sqlite3PagerUnref() and sqlite3PagerUnrefNotNull() may only be used +** if we know that the page being released is not the last reference to page1. +** The btree layer always holds page1 open until the end, so these first +** two routines can be used to release any page other than BtShared.pPage1. +** The assert() at tag-20230419-2 proves that this constraint is always +** honored. +** +** Use sqlite3PagerUnrefPageOne() to release page1. This latter routine +** checks the total number of outstanding pages and if the number of +** pages reaches zero it drops the database lock. +*/ +SQLITE_PRIVATE void sqlite3PagerUnrefNotNull(DbPage *pPg){ + TESTONLY( Pager *pPager = pPg->pPager; ) + assert( pPg!=0 ); + if( pPg->flags & PGHDR_MMAP ){ + assert( pPg->pgno!=1 ); /* Page1 is never memory mapped */ + pagerReleaseMapPage(pPg); + }else{ + sqlite3PcacheRelease(pPg); + } + /* Do not use this routine to release the last reference to page1 */ + assert( sqlite3PcacheRefCount(pPager->pPCache)>0 ); /* tag-20230419-2 */ +} +SQLITE_PRIVATE void sqlite3PagerUnref(DbPage *pPg){ + if( pPg ) sqlite3PagerUnrefNotNull(pPg); +} +SQLITE_PRIVATE void sqlite3PagerUnrefPageOne(DbPage *pPg){ + Pager *pPager; + assert( pPg!=0 ); + assert( pPg->pgno==1 ); + assert( (pPg->flags & PGHDR_MMAP)==0 ); /* Page1 is never memory mapped */ + pPager = pPg->pPager; + sqlite3PcacheRelease(pPg); + pagerUnlockIfUnused(pPager); +} + +/* +** This function is called at the start of every write transaction. +** There must already be a RESERVED or EXCLUSIVE lock on the database +** file when this routine is called. +** +** Open the journal file for pager pPager and write a journal header +** to the start of it. If there are active savepoints, open the sub-journal +** as well. This function is only used when the journal file is being +** opened to write a rollback log for a transaction. It is not used +** when opening a hot journal file to roll it back. +** +** If the journal file is already open (as it may be in exclusive mode), +** then this function just writes a journal header to the start of the +** already open file. +** +** Whether or not the journal file is opened by this function, the +** Pager.pInJournal bitvec structure is allocated. +** +** Return SQLITE_OK if everything is successful. Otherwise, return +** SQLITE_NOMEM if the attempt to allocate Pager.pInJournal fails, or +** an IO error code if opening or writing the journal file fails. +*/ +static int pager_open_journal(Pager *pPager){ + int rc = SQLITE_OK; /* Return code */ + sqlite3_vfs * const pVfs = pPager->pVfs; /* Local cache of vfs pointer */ + + assert( pPager->eState==PAGER_WRITER_LOCKED ); + assert( assert_pager_state(pPager) ); + assert( pPager->pInJournal==0 ); + + /* If already in the error state, this function is a no-op. But on + ** the other hand, this routine is never called if we are already in + ** an error state. */ + if( NEVER(pPager->errCode) ) return pPager->errCode; + + if( !pagerUseWal(pPager) && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){ + pPager->pInJournal = sqlite3BitvecCreate(pPager->dbSize); + if( pPager->pInJournal==0 ){ + return SQLITE_NOMEM_BKPT; + } + + /* Open the journal file if it is not already open. */ + if( !isOpen(pPager->jfd) ){ + if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ){ + sqlite3MemJournalOpen(pPager->jfd); + }else{ + int flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE; + int nSpill; + + if( pPager->tempFile ){ + flags |= (SQLITE_OPEN_DELETEONCLOSE|SQLITE_OPEN_TEMP_JOURNAL); + flags |= SQLITE_OPEN_EXCLUSIVE; + nSpill = sqlite3Config.nStmtSpill; + }else{ + flags |= SQLITE_OPEN_MAIN_JOURNAL; + nSpill = jrnlBufferSize(pPager); + } + + /* Verify that the database still has the same name as it did when + ** it was originally opened. */ + rc = databaseIsUnmoved(pPager); + if( rc==SQLITE_OK ){ + rc = sqlite3JournalOpen ( + pVfs, pPager->zJournal, pPager->jfd, flags, nSpill + ); + } + } + assert( rc!=SQLITE_OK || isOpen(pPager->jfd) ); + } + + + /* Write the first journal header to the journal file and open + ** the sub-journal if necessary. + */ + if( rc==SQLITE_OK ){ + /* TODO: Check if all of these are really required. */ + pPager->nRec = 0; + pPager->journalOff = 0; + pPager->setSuper = 0; + pPager->journalHdr = 0; + rc = writeJournalHdr(pPager); + } + } + + if( rc!=SQLITE_OK ){ + sqlite3BitvecDestroy(pPager->pInJournal); + pPager->pInJournal = 0; + pPager->journalOff = 0; + }else{ + assert( pPager->eState==PAGER_WRITER_LOCKED ); + pPager->eState = PAGER_WRITER_CACHEMOD; + } + + return rc; +} + +/* +** Begin a write-transaction on the specified pager object. If a +** write-transaction has already been opened, this function is a no-op. +** +** If the exFlag argument is false, then acquire at least a RESERVED +** lock on the database file. If exFlag is true, then acquire at least +** an EXCLUSIVE lock. If such a lock is already held, no locking +** functions need be called. +** +** If the subjInMemory argument is non-zero, then any sub-journal opened +** within this transaction will be opened as an in-memory file. This +** has no effect if the sub-journal is already opened (as it may be when +** running in exclusive mode) or if the transaction does not require a +** sub-journal. If the subjInMemory argument is zero, then any required +** sub-journal is implemented in-memory if pPager is an in-memory database, +** or using a temporary file otherwise. +*/ +SQLITE_PRIVATE int sqlite3PagerBegin(Pager *pPager, int exFlag, int subjInMemory){ + int rc = SQLITE_OK; + + if( pPager->errCode ) return pPager->errCode; + assert( pPager->eState>=PAGER_READER && pPager->eStatesubjInMemory = (u8)subjInMemory; + + if( pPager->eState==PAGER_READER ){ + assert( pPager->pInJournal==0 ); + + if( pagerUseWal(pPager) ){ + /* If the pager is configured to use locking_mode=exclusive, and an + ** exclusive lock on the database is not already held, obtain it now. + */ + if( pPager->exclusiveMode && sqlite3WalExclusiveMode(pPager->pWal, -1) ){ + rc = pagerLockDb(pPager, EXCLUSIVE_LOCK); + if( rc!=SQLITE_OK ){ + return rc; + } + (void)sqlite3WalExclusiveMode(pPager->pWal, 1); + } + + /* Grab the write lock on the log file. If successful, upgrade to + ** PAGER_RESERVED state. Otherwise, return an error code to the caller. + ** The busy-handler is not invoked if another connection already + ** holds the write-lock. If possible, the upper layer will call it. + */ + rc = sqlite3WalBeginWriteTransaction(pPager->pWal); + }else{ + /* Obtain a RESERVED lock on the database file. If the exFlag parameter + ** is true, then immediately upgrade this to an EXCLUSIVE lock. The + ** busy-handler callback can be used when upgrading to the EXCLUSIVE + ** lock, but not when obtaining the RESERVED lock. + */ + rc = pagerLockDb(pPager, RESERVED_LOCK); + if( rc==SQLITE_OK && exFlag ){ + rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK); + } + } + + if( rc==SQLITE_OK ){ + /* Change to WRITER_LOCKED state. + ** + ** WAL mode sets Pager.eState to PAGER_WRITER_LOCKED or CACHEMOD + ** when it has an open transaction, but never to DBMOD or FINISHED. + ** This is because in those states the code to roll back savepoint + ** transactions may copy data from the sub-journal into the database + ** file as well as into the page cache. Which would be incorrect in + ** WAL mode. + */ + pPager->eState = PAGER_WRITER_LOCKED; + pPager->dbHintSize = pPager->dbSize; + pPager->dbFileSize = pPager->dbSize; + pPager->dbOrigSize = pPager->dbSize; + pPager->journalOff = 0; + } + + assert( rc==SQLITE_OK || pPager->eState==PAGER_READER ); + assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED ); + assert( assert_pager_state(pPager) ); + } + + PAGERTRACE(("TRANSACTION %d\n", PAGERID(pPager))); + return rc; +} + +/* +** Write page pPg onto the end of the rollback journal. +*/ +static SQLITE_NOINLINE int pagerAddPageToRollbackJournal(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + int rc; + u32 cksum; + char *pData2; + i64 iOff = pPager->journalOff; + + /* We should never write to the journal file the page that + ** contains the database locks. The following assert verifies + ** that we do not. */ + assert( pPg->pgno!=PAGER_SJ_PGNO(pPager) ); + + assert( pPager->journalHdr<=pPager->journalOff ); + CODEC2(pPager, pPg->pData, pPg->pgno, 7, return SQLITE_NOMEM_BKPT, pData2); + cksum = pager_cksum(pPager, (u8*)pData2); + + /* Even if an IO or diskfull error occurs while journalling the + ** page in the block above, set the need-sync flag for the page. + ** Otherwise, when the transaction is rolled back, the logic in + ** playback_one_page() will think that the page needs to be restored + ** in the database file. And if an IO error occurs while doing so, + ** then corruption may follow. + */ + pPg->flags |= PGHDR_NEED_SYNC; + + rc = write32bits(pPager->jfd, iOff, pPg->pgno); + if( rc!=SQLITE_OK ) return rc; + rc = sqlite3OsWrite(pPager->jfd, pData2, pPager->pageSize, iOff+4); + if( rc!=SQLITE_OK ) return rc; + rc = write32bits(pPager->jfd, iOff+pPager->pageSize+4, cksum); + if( rc!=SQLITE_OK ) return rc; + + IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno, + pPager->journalOff, pPager->pageSize)); + PAGER_INCR(sqlite3_pager_writej_count); + PAGERTRACE(("JOURNAL %d page %d needSync=%d hash(%08x)\n", + PAGERID(pPager), pPg->pgno, + ((pPg->flags&PGHDR_NEED_SYNC)?1:0), pager_pagehash(pPg))); + + pPager->journalOff += 8 + pPager->pageSize; + pPager->nRec++; + assert( pPager->pInJournal!=0 ); + rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno); + testcase( rc==SQLITE_NOMEM ); + assert( rc==SQLITE_OK || rc==SQLITE_NOMEM ); + rc |= addToSavepointBitvecs(pPager, pPg->pgno); + assert( rc==SQLITE_OK || rc==SQLITE_NOMEM ); + return rc; +} + +/* +** Mark a single data page as writeable. The page is written into the +** main journal or sub-journal as required. If the page is written into +** one of the journals, the corresponding bit is set in the +** Pager.pInJournal bitvec and the PagerSavepoint.pInSavepoint bitvecs +** of any open savepoints as appropriate. +*/ +static int pager_write(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + int rc = SQLITE_OK; + + /* This routine is not called unless a write-transaction has already + ** been started. The journal file may or may not be open at this point. + ** It is never called in the ERROR state. + */ + assert( pPager->eState==PAGER_WRITER_LOCKED + || pPager->eState==PAGER_WRITER_CACHEMOD + || pPager->eState==PAGER_WRITER_DBMOD + ); + assert( assert_pager_state(pPager) ); + assert( pPager->errCode==0 ); + assert( pPager->readOnly==0 ); + CHECK_PAGE(pPg); + + /* The journal file needs to be opened. Higher level routines have already + ** obtained the necessary locks to begin the write-transaction, but the + ** rollback journal might not yet be open. Open it now if this is the case. + ** + ** This is done before calling sqlite3PcacheMakeDirty() on the page. + ** Otherwise, if it were done after calling sqlite3PcacheMakeDirty(), then + ** an error might occur and the pager would end up in WRITER_LOCKED state + ** with pages marked as dirty in the cache. + */ + if( pPager->eState==PAGER_WRITER_LOCKED ){ + rc = pager_open_journal(pPager); + if( rc!=SQLITE_OK ) return rc; + } + assert( pPager->eState>=PAGER_WRITER_CACHEMOD ); + assert( assert_pager_state(pPager) ); + + /* Mark the page that is about to be modified as dirty. */ + sqlite3PcacheMakeDirty(pPg); + + /* If a rollback journal is in use, them make sure the page that is about + ** to change is in the rollback journal, or if the page is a new page off + ** then end of the file, make sure it is marked as PGHDR_NEED_SYNC. + */ + assert( (pPager->pInJournal!=0) == isOpen(pPager->jfd) ); + if( pPager->pInJournal!=0 + && sqlite3BitvecTestNotNull(pPager->pInJournal, pPg->pgno)==0 + ){ + assert( pagerUseWal(pPager)==0 ); + if( pPg->pgno<=pPager->dbOrigSize ){ + rc = pagerAddPageToRollbackJournal(pPg); + if( rc!=SQLITE_OK ){ + return rc; + } + }else{ + if( pPager->eState!=PAGER_WRITER_DBMOD ){ + pPg->flags |= PGHDR_NEED_SYNC; + } + PAGERTRACE(("APPEND %d page %d needSync=%d\n", + PAGERID(pPager), pPg->pgno, + ((pPg->flags&PGHDR_NEED_SYNC)?1:0))); + } + } + + /* The PGHDR_DIRTY bit is set above when the page was added to the dirty-list + ** and before writing the page into the rollback journal. Wait until now, + ** after the page has been successfully journalled, before setting the + ** PGHDR_WRITEABLE bit that indicates that the page can be safely modified. + */ + pPg->flags |= PGHDR_WRITEABLE; + + /* If the statement journal is open and the page is not in it, + ** then write the page into the statement journal. + */ + if( pPager->nSavepoint>0 ){ + rc = subjournalPageIfRequired(pPg); + } + + /* Update the database size and return. */ + if( pPager->dbSizepgno ){ + pPager->dbSize = pPg->pgno; + } + return rc; +} + +/* +** This is a variant of sqlite3PagerWrite() that runs when the sector size +** is larger than the page size. SQLite makes the (reasonable) assumption that +** all bytes of a sector are written together by hardware. Hence, all bytes of +** a sector need to be journalled in case of a power loss in the middle of +** a write. +** +** Usually, the sector size is less than or equal to the page size, in which +** case pages can be individually written. This routine only runs in the +** exceptional case where the page size is smaller than the sector size. +*/ +static SQLITE_NOINLINE int pagerWriteLargeSector(PgHdr *pPg){ + int rc = SQLITE_OK; /* Return code */ + Pgno nPageCount; /* Total number of pages in database file */ + Pgno pg1; /* First page of the sector pPg is located on. */ + int nPage = 0; /* Number of pages starting at pg1 to journal */ + int ii; /* Loop counter */ + int needSync = 0; /* True if any page has PGHDR_NEED_SYNC */ + Pager *pPager = pPg->pPager; /* The pager that owns pPg */ + Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize); + + /* Set the doNotSpill NOSYNC bit to 1. This is because we cannot allow + ** a journal header to be written between the pages journaled by + ** this function. + */ + assert( !MEMDB ); + assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)==0 ); + pPager->doNotSpill |= SPILLFLAG_NOSYNC; + + /* This trick assumes that both the page-size and sector-size are + ** an integer power of 2. It sets variable pg1 to the identifier + ** of the first page of the sector pPg is located on. + */ + pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1; + + nPageCount = pPager->dbSize; + if( pPg->pgno>nPageCount ){ + nPage = (pPg->pgno - pg1)+1; + }else if( (pg1+nPagePerSector-1)>nPageCount ){ + nPage = nPageCount+1-pg1; + }else{ + nPage = nPagePerSector; + } + assert(nPage>0); + assert(pg1<=pPg->pgno); + assert((pg1+nPage)>pPg->pgno); + + for(ii=0; iipgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){ + if( pg!=PAGER_SJ_PGNO(pPager) ){ + rc = sqlite3PagerGet(pPager, pg, &pPage, 0); + if( rc==SQLITE_OK ){ + rc = pager_write(pPage); + if( pPage->flags&PGHDR_NEED_SYNC ){ + needSync = 1; + } + sqlite3PagerUnrefNotNull(pPage); + } + } + }else if( (pPage = sqlite3PagerLookup(pPager, pg))!=0 ){ + if( pPage->flags&PGHDR_NEED_SYNC ){ + needSync = 1; + } + sqlite3PagerUnrefNotNull(pPage); + } + } + + /* If the PGHDR_NEED_SYNC flag is set for any of the nPage pages + ** starting at pg1, then it needs to be set for all of them. Because + ** writing to any of these nPage pages may damage the others, the + ** journal file must contain sync()ed copies of all of them + ** before any of them can be written out to the database file. + */ + if( rc==SQLITE_OK && needSync ){ + assert( !MEMDB ); + for(ii=0; iiflags |= PGHDR_NEED_SYNC; + sqlite3PagerUnrefNotNull(pPage); + } + } + } + + assert( (pPager->doNotSpill & SPILLFLAG_NOSYNC)!=0 ); + pPager->doNotSpill &= ~SPILLFLAG_NOSYNC; + return rc; +} + +/* +** Mark a data page as writeable. This routine must be called before +** making changes to a page. The caller must check the return value +** of this function and be careful not to change any page data unless +** this routine returns SQLITE_OK. +** +** The difference between this function and pager_write() is that this +** function also deals with the special case where 2 or more pages +** fit on a single disk sector. In this case all co-resident pages +** must have been written to the journal file before returning. +** +** If an error occurs, SQLITE_NOMEM or an IO error code is returned +** as appropriate. Otherwise, SQLITE_OK. +*/ +SQLITE_PRIVATE int sqlite3PagerWrite(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + assert( (pPg->flags & PGHDR_MMAP)==0 ); + assert( pPager->eState>=PAGER_WRITER_LOCKED ); + assert( assert_pager_state(pPager) ); + if( (pPg->flags & PGHDR_WRITEABLE)!=0 && pPager->dbSize>=pPg->pgno ){ + if( pPager->nSavepoint ) return subjournalPageIfRequired(pPg); + return SQLITE_OK; + }else if( pPager->errCode ){ + return pPager->errCode; + }else if( pPager->sectorSize > (u32)pPager->pageSize ){ + assert( pPager->tempFile==0 ); + return pagerWriteLargeSector(pPg); + }else{ + return pager_write(pPg); + } +} + +/* +** Return TRUE if the page given in the argument was previously passed +** to sqlite3PagerWrite(). In other words, return TRUE if it is ok +** to change the content of the page. +*/ +#ifndef NDEBUG +SQLITE_PRIVATE int sqlite3PagerIswriteable(DbPage *pPg){ + return pPg->flags & PGHDR_WRITEABLE; +} +#endif + +/* +** A call to this routine tells the pager that it is not necessary to +** write the information on page pPg back to the disk, even though +** that page might be marked as dirty. This happens, for example, when +** the page has been added as a leaf of the freelist and so its +** content no longer matters. +** +** The overlying software layer calls this routine when all of the data +** on the given page is unused. The pager marks the page as clean so +** that it does not get written to disk. +** +** Tests show that this optimization can quadruple the speed of large +** DELETE operations. +** +** This optimization cannot be used with a temp-file, as the page may +** have been dirty at the start of the transaction. In that case, if +** memory pressure forces page pPg out of the cache, the data does need +** to be written out to disk so that it may be read back in if the +** current transaction is rolled back. +*/ +SQLITE_PRIVATE void sqlite3PagerDontWrite(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + if( !pPager->tempFile && (pPg->flags&PGHDR_DIRTY) && pPager->nSavepoint==0 ){ + PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager))); + IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno)) + pPg->flags |= PGHDR_DONT_WRITE; + pPg->flags &= ~PGHDR_WRITEABLE; + testcase( pPg->flags & PGHDR_NEED_SYNC ); + pager_set_pagehash(pPg); + } +} + +/* +** This routine is called to increment the value of the database file +** change-counter, stored as a 4-byte big-endian integer starting at +** byte offset 24 of the pager file. The secondary change counter at +** 92 is also updated, as is the SQLite version number at offset 96. +** +** But this only happens if the pPager->changeCountDone flag is false. +** To avoid excess churning of page 1, the update only happens once. +** See also the pager_write_changecounter() routine that does an +** unconditional update of the change counters. +** +** If the isDirectMode flag is zero, then this is done by calling +** sqlite3PagerWrite() on page 1, then modifying the contents of the +** page data. In this case the file will be updated when the current +** transaction is committed. +** +** The isDirectMode flag may only be non-zero if the library was compiled +** with the SQLITE_ENABLE_ATOMIC_WRITE macro defined. In this case, +** if isDirect is non-zero, then the database file is updated directly +** by writing an updated version of page 1 using a call to the +** sqlite3OsWrite() function. +*/ +static int pager_incr_changecounter(Pager *pPager, int isDirectMode){ + int rc = SQLITE_OK; + + assert( pPager->eState==PAGER_WRITER_CACHEMOD + || pPager->eState==PAGER_WRITER_DBMOD + ); + assert( assert_pager_state(pPager) ); + + /* Declare and initialize constant integer 'isDirect'. If the + ** atomic-write optimization is enabled in this build, then isDirect + ** is initialized to the value passed as the isDirectMode parameter + ** to this function. Otherwise, it is always set to zero. + ** + ** The idea is that if the atomic-write optimization is not + ** enabled at compile time, the compiler can omit the tests of + ** 'isDirect' below, as well as the block enclosed in the + ** "if( isDirect )" condition. + */ +#ifndef SQLITE_ENABLE_ATOMIC_WRITE +# define DIRECT_MODE 0 + assert( isDirectMode==0 ); + UNUSED_PARAMETER(isDirectMode); +#else +# define DIRECT_MODE isDirectMode +#endif + + if( !pPager->changeCountDone && pPager->dbSize>0 ){ + PgHdr *pPgHdr; /* Reference to page 1 */ + + assert( !pPager->tempFile && isOpen(pPager->fd) ); + + /* Open page 1 of the file for writing. */ + rc = sqlite3PagerGet(pPager, 1, &pPgHdr, 0); + assert( pPgHdr==0 || rc==SQLITE_OK ); + + /* If page one was fetched successfully, and this function is not + ** operating in direct-mode, make page 1 writable. When not in + ** direct mode, page 1 is always held in cache and hence the PagerGet() + ** above is always successful - hence the ALWAYS on rc==SQLITE_OK. + */ + if( !DIRECT_MODE && ALWAYS(rc==SQLITE_OK) ){ + rc = sqlite3PagerWrite(pPgHdr); + } + + if( rc==SQLITE_OK ){ + /* Actually do the update of the change counter */ + pager_write_changecounter(pPgHdr); + + /* If running in direct mode, write the contents of page 1 to the file. */ + if( DIRECT_MODE ){ + const void *zBuf; + assert( pPager->dbFileSize>0 ); + CODEC2(pPager, pPgHdr->pData, 1, 6, rc=SQLITE_NOMEM_BKPT, zBuf); + if( rc==SQLITE_OK ){ + rc = sqlite3OsWrite(pPager->fd, zBuf, pPager->pageSize, 0); + pPager->aStat[PAGER_STAT_WRITE]++; + } + if( rc==SQLITE_OK ){ + /* Update the pager's copy of the change-counter. Otherwise, the + ** next time a read transaction is opened the cache will be + ** flushed (as the change-counter values will not match). */ + const void *pCopy = (const void *)&((const char *)zBuf)[24]; + memcpy(&pPager->dbFileVers, pCopy, sizeof(pPager->dbFileVers)); + pPager->changeCountDone = 1; + } + }else{ + pPager->changeCountDone = 1; + } + } + + /* Release the page reference. */ + sqlite3PagerUnref(pPgHdr); + } + return rc; +} + +/* +** Sync the database file to disk. This is a no-op for in-memory databases +** or pages with the Pager.noSync flag set. +** +** If successful, or if called on a pager for which it is a no-op, this +** function returns SQLITE_OK. Otherwise, an IO error code is returned. +*/ +SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager, const char *zSuper){ + int rc = SQLITE_OK; + void *pArg = (void*)zSuper; + rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SYNC, pArg); + if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK; + if( rc==SQLITE_OK && !pPager->noSync ){ + assert( !MEMDB ); + rc = sqlite3OsSync(pPager->fd, pPager->syncFlags); + } + return rc; +} + +/* +** This function may only be called while a write-transaction is active in +** rollback. If the connection is in WAL mode, this call is a no-op. +** Otherwise, if the connection does not already have an EXCLUSIVE lock on +** the database file, an attempt is made to obtain one. +** +** If the EXCLUSIVE lock is already held or the attempt to obtain it is +** successful, or the connection is in WAL mode, SQLITE_OK is returned. +** Otherwise, either SQLITE_BUSY or an SQLITE_IOERR_XXX error code is +** returned. +*/ +SQLITE_PRIVATE int sqlite3PagerExclusiveLock(Pager *pPager){ + int rc = pPager->errCode; + assert( assert_pager_state(pPager) ); + if( rc==SQLITE_OK ){ + assert( pPager->eState==PAGER_WRITER_CACHEMOD + || pPager->eState==PAGER_WRITER_DBMOD + || pPager->eState==PAGER_WRITER_LOCKED + ); + assert( assert_pager_state(pPager) ); + if( 0==pagerUseWal(pPager) ){ + rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK); + } + } + return rc; +} + +/* +** Sync the database file for the pager pPager. zSuper points to the name +** of a super-journal file that should be written into the individual +** journal file. zSuper may be NULL, which is interpreted as no +** super-journal (a single database transaction). +** +** This routine ensures that: +** +** * The database file change-counter is updated, +** * the journal is synced (unless the atomic-write optimization is used), +** * all dirty pages are written to the database file, +** * the database file is truncated (if required), and +** * the database file synced. +** +** The only thing that remains to commit the transaction is to finalize +** (delete, truncate or zero the first part of) the journal file (or +** delete the super-journal file if specified). +** +** Note that if zSuper==NULL, this does not overwrite a previous value +** passed to an sqlite3PagerCommitPhaseOne() call. +** +** If the final parameter - noSync - is true, then the database file itself +** is not synced. The caller must call sqlite3PagerSync() directly to +** sync the database file before calling CommitPhaseTwo() to delete the +** journal file in this case. +*/ +SQLITE_PRIVATE int sqlite3PagerCommitPhaseOne( + Pager *pPager, /* Pager object */ + const char *zSuper, /* If not NULL, the super-journal name */ + int noSync /* True to omit the xSync on the db file */ +){ + int rc = SQLITE_OK; /* Return code */ + + assert( pPager->eState==PAGER_WRITER_LOCKED + || pPager->eState==PAGER_WRITER_CACHEMOD + || pPager->eState==PAGER_WRITER_DBMOD + || pPager->eState==PAGER_ERROR + ); + assert( assert_pager_state(pPager) ); + + /* If a prior error occurred, report that error again. */ + if( NEVER(pPager->errCode) ) return pPager->errCode; + + /* Provide the ability to easily simulate an I/O error during testing */ + if( sqlite3FaultSim(400) ) return SQLITE_IOERR; + + PAGERTRACE(("DATABASE SYNC: File=%s zSuper=%s nSize=%d\n", + pPager->zFilename, zSuper, pPager->dbSize)); + + /* If no database changes have been made, return early. */ + if( pPager->eStatetempFile ); + assert( isOpen(pPager->fd) || pPager->tempFile ); + if( 0==pagerFlushOnCommit(pPager, 1) ){ + /* If this is an in-memory db, or no pages have been written to, or this + ** function has already been called, it is mostly a no-op. However, any + ** backup in progress needs to be restarted. */ + sqlite3BackupRestart(pPager->pBackup); + }else{ + PgHdr *pList; + if( pagerUseWal(pPager) ){ + PgHdr *pPageOne = 0; + pList = sqlite3PcacheDirtyList(pPager->pPCache); + if( pList==0 ){ + /* Must have at least one page for the WAL commit flag. + ** Ticket [2d1a5c67dfc2363e44f29d9bbd57f] 2011-05-18 */ + rc = sqlite3PagerGet(pPager, 1, &pPageOne, 0); + pList = pPageOne; + pList->pDirty = 0; + } + assert( rc==SQLITE_OK ); + if( ALWAYS(pList) ){ + rc = pagerWalFrames(pPager, pList, pPager->dbSize, 1); + } + sqlite3PagerUnref(pPageOne); + if( rc==SQLITE_OK ){ + sqlite3PcacheCleanAll(pPager->pPCache); + } + }else{ + /* The bBatch boolean is true if the batch-atomic-write commit method + ** should be used. No rollback journal is created if batch-atomic-write + ** is enabled. + */ +#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE + sqlite3_file *fd = pPager->fd; + int bBatch = zSuper==0 /* An SQLITE_IOCAP_BATCH_ATOMIC commit */ + && (sqlite3OsDeviceCharacteristics(fd) & SQLITE_IOCAP_BATCH_ATOMIC) + && !pPager->noSync + && sqlite3JournalIsInMemory(pPager->jfd); +#else +# define bBatch 0 +#endif + +#ifdef SQLITE_ENABLE_ATOMIC_WRITE + /* The following block updates the change-counter. Exactly how it + ** does this depends on whether or not the atomic-update optimization + ** was enabled at compile time, and if this transaction meets the + ** runtime criteria to use the operation: + ** + ** * The file-system supports the atomic-write property for + ** blocks of size page-size, and + ** * This commit is not part of a multi-file transaction, and + ** * Exactly one page has been modified and store in the journal file. + ** + ** If the optimization was not enabled at compile time, then the + ** pager_incr_changecounter() function is called to update the change + ** counter in 'indirect-mode'. If the optimization is compiled in but + ** is not applicable to this transaction, call sqlite3JournalCreate() + ** to make sure the journal file has actually been created, then call + ** pager_incr_changecounter() to update the change-counter in indirect + ** mode. + ** + ** Otherwise, if the optimization is both enabled and applicable, + ** then call pager_incr_changecounter() to update the change-counter + ** in 'direct' mode. In this case the journal file will never be + ** created for this transaction. + */ + if( bBatch==0 ){ + PgHdr *pPg; + assert( isOpen(pPager->jfd) + || pPager->journalMode==PAGER_JOURNALMODE_OFF + || pPager->journalMode==PAGER_JOURNALMODE_WAL + ); + if( !zSuper && isOpen(pPager->jfd) + && pPager->journalOff==jrnlBufferSize(pPager) + && pPager->dbSize>=pPager->dbOrigSize + && (!(pPg = sqlite3PcacheDirtyList(pPager->pPCache)) || 0==pPg->pDirty) + ){ + /* Update the db file change counter via the direct-write method. The + ** following call will modify the in-memory representation of page 1 + ** to include the updated change counter and then write page 1 + ** directly to the database file. Because of the atomic-write + ** property of the host file-system, this is safe. + */ + rc = pager_incr_changecounter(pPager, 1); + }else{ + rc = sqlite3JournalCreate(pPager->jfd); + if( rc==SQLITE_OK ){ + rc = pager_incr_changecounter(pPager, 0); + } + } + } +#else /* SQLITE_ENABLE_ATOMIC_WRITE */ +#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE + if( zSuper ){ + rc = sqlite3JournalCreate(pPager->jfd); + if( rc!=SQLITE_OK ) goto commit_phase_one_exit; + assert( bBatch==0 ); + } +#endif + rc = pager_incr_changecounter(pPager, 0); +#endif /* !SQLITE_ENABLE_ATOMIC_WRITE */ + if( rc!=SQLITE_OK ) goto commit_phase_one_exit; + + /* Write the super-journal name into the journal file. If a + ** super-journal file name has already been written to the journal file, + ** or if zSuper is NULL (no super-journal), then this call is a no-op. + */ + rc = writeSuperJournal(pPager, zSuper); + if( rc!=SQLITE_OK ) goto commit_phase_one_exit; + + /* Sync the journal file and write all dirty pages to the database. + ** If the atomic-update optimization is being used, this sync will not + ** create the journal file or perform any real IO. + ** + ** Because the change-counter page was just modified, unless the + ** atomic-update optimization is used it is almost certain that the + ** journal requires a sync here. However, in locking_mode=exclusive + ** on a system under memory pressure it is just possible that this is + ** not the case. In this case it is likely enough that the redundant + ** xSync() call will be changed to a no-op by the OS anyhow. + */ + rc = syncJournal(pPager, 0); + if( rc!=SQLITE_OK ) goto commit_phase_one_exit; + + pList = sqlite3PcacheDirtyList(pPager->pPCache); +#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE + if( bBatch ){ + rc = sqlite3OsFileControl(fd, SQLITE_FCNTL_BEGIN_ATOMIC_WRITE, 0); + if( rc==SQLITE_OK ){ + rc = pager_write_pagelist(pPager, pList); + if( rc==SQLITE_OK ){ + rc = sqlite3OsFileControl(fd, SQLITE_FCNTL_COMMIT_ATOMIC_WRITE, 0); + } + if( rc!=SQLITE_OK ){ + sqlite3OsFileControlHint(fd, SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE, 0); + } + } + + if( (rc&0xFF)==SQLITE_IOERR && rc!=SQLITE_IOERR_NOMEM ){ + rc = sqlite3JournalCreate(pPager->jfd); + if( rc!=SQLITE_OK ){ + sqlite3OsClose(pPager->jfd); + goto commit_phase_one_exit; + } + bBatch = 0; + }else{ + sqlite3OsClose(pPager->jfd); + } + } +#endif /* SQLITE_ENABLE_BATCH_ATOMIC_WRITE */ + + if( bBatch==0 ){ + rc = pager_write_pagelist(pPager, pList); + } + if( rc!=SQLITE_OK ){ + assert( rc!=SQLITE_IOERR_BLOCKED ); + goto commit_phase_one_exit; + } + sqlite3PcacheCleanAll(pPager->pPCache); + + /* If the file on disk is smaller than the database image, use + ** pager_truncate to grow the file here. This can happen if the database + ** image was extended as part of the current transaction and then the + ** last page in the db image moved to the free-list. In this case the + ** last page is never written out to disk, leaving the database file + ** undersized. Fix this now if it is the case. */ + if( pPager->dbSize>pPager->dbFileSize ){ + Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_SJ_PGNO(pPager)); + assert( pPager->eState==PAGER_WRITER_DBMOD ); + rc = pager_truncate(pPager, nNew); + if( rc!=SQLITE_OK ) goto commit_phase_one_exit; + } + + /* Finally, sync the database file. */ + if( !noSync ){ + rc = sqlite3PagerSync(pPager, zSuper); + } + IOTRACE(("DBSYNC %p\n", pPager)) + } + } + +commit_phase_one_exit: + if( rc==SQLITE_OK && !pagerUseWal(pPager) ){ + pPager->eState = PAGER_WRITER_FINISHED; + } + return rc; +} + + +/* +** When this function is called, the database file has been completely +** updated to reflect the changes made by the current transaction and +** synced to disk. The journal file still exists in the file-system +** though, and if a failure occurs at this point it will eventually +** be used as a hot-journal and the current transaction rolled back. +** +** This function finalizes the journal file, either by deleting, +** truncating or partially zeroing it, so that it cannot be used +** for hot-journal rollback. Once this is done the transaction is +** irrevocably committed. +** +** If an error occurs, an IO error code is returned and the pager +** moves into the error state. Otherwise, SQLITE_OK is returned. +*/ +SQLITE_PRIVATE int sqlite3PagerCommitPhaseTwo(Pager *pPager){ + int rc = SQLITE_OK; /* Return code */ + + /* This routine should not be called if a prior error has occurred. + ** But if (due to a coding error elsewhere in the system) it does get + ** called, just return the same error code without doing anything. */ + if( NEVER(pPager->errCode) ) return pPager->errCode; + pPager->iDataVersion++; + + assert( pPager->eState==PAGER_WRITER_LOCKED + || pPager->eState==PAGER_WRITER_FINISHED + || (pagerUseWal(pPager) && pPager->eState==PAGER_WRITER_CACHEMOD) + ); + assert( assert_pager_state(pPager) ); + + /* An optimization. If the database was not actually modified during + ** this transaction, the pager is running in exclusive-mode and is + ** using persistent journals, then this function is a no-op. + ** + ** The start of the journal file currently contains a single journal + ** header with the nRec field set to 0. If such a journal is used as + ** a hot-journal during hot-journal rollback, 0 changes will be made + ** to the database file. So there is no need to zero the journal + ** header. Since the pager is in exclusive mode, there is no need + ** to drop any locks either. + */ + if( pPager->eState==PAGER_WRITER_LOCKED + && pPager->exclusiveMode + && pPager->journalMode==PAGER_JOURNALMODE_PERSIST + ){ + assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) || !pPager->journalOff ); + pPager->eState = PAGER_READER; + return SQLITE_OK; + } + + PAGERTRACE(("COMMIT %d\n", PAGERID(pPager))); + rc = pager_end_transaction(pPager, pPager->setSuper, 1); + return pager_error(pPager, rc); +} + +/* +** If a write transaction is open, then all changes made within the +** transaction are reverted and the current write-transaction is closed. +** The pager falls back to PAGER_READER state if successful, or PAGER_ERROR +** state if an error occurs. +** +** If the pager is already in PAGER_ERROR state when this function is called, +** it returns Pager.errCode immediately. No work is performed in this case. +** +** Otherwise, in rollback mode, this function performs two functions: +** +** 1) It rolls back the journal file, restoring all database file and +** in-memory cache pages to the state they were in when the transaction +** was opened, and +** +** 2) It finalizes the journal file, so that it is not used for hot +** rollback at any point in the future. +** +** Finalization of the journal file (task 2) is only performed if the +** rollback is successful. +** +** In WAL mode, all cache-entries containing data modified within the +** current transaction are either expelled from the cache or reverted to +** their pre-transaction state by re-reading data from the database or +** WAL files. The WAL transaction is then closed. +*/ +SQLITE_PRIVATE int sqlite3PagerRollback(Pager *pPager){ + int rc = SQLITE_OK; /* Return code */ + PAGERTRACE(("ROLLBACK %d\n", PAGERID(pPager))); + + /* PagerRollback() is a no-op if called in READER or OPEN state. If + ** the pager is already in the ERROR state, the rollback is not + ** attempted here. Instead, the error code is returned to the caller. + */ + assert( assert_pager_state(pPager) ); + if( pPager->eState==PAGER_ERROR ) return pPager->errCode; + if( pPager->eState<=PAGER_READER ) return SQLITE_OK; + + if( pagerUseWal(pPager) ){ + int rc2; + rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_ROLLBACK, -1); + rc2 = pager_end_transaction(pPager, pPager->setSuper, 0); + if( rc==SQLITE_OK ) rc = rc2; + }else if( !isOpen(pPager->jfd) || pPager->eState==PAGER_WRITER_LOCKED ){ + int eState = pPager->eState; + rc = pager_end_transaction(pPager, 0, 0); + if( !MEMDB && eState>PAGER_WRITER_LOCKED ){ + /* This can happen using journal_mode=off. Move the pager to the error + ** state to indicate that the contents of the cache may not be trusted. + ** Any active readers will get SQLITE_ABORT. + */ + pPager->errCode = SQLITE_ABORT; + pPager->eState = PAGER_ERROR; + setGetterMethod(pPager); + return rc; + } + }else{ + rc = pager_playback(pPager, 0); + } + + assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK ); + assert( rc==SQLITE_OK || rc==SQLITE_FULL || rc==SQLITE_CORRUPT + || rc==SQLITE_NOMEM || (rc&0xFF)==SQLITE_IOERR + || rc==SQLITE_CANTOPEN + ); + + /* If an error occurs during a ROLLBACK, we can no longer trust the pager + ** cache. So call pager_error() on the way out to make any error persistent. + */ + return pager_error(pPager, rc); +} + +/* +** Return TRUE if the database file is opened read-only. Return FALSE +** if the database is (in theory) writable. +*/ +SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager *pPager){ + return pPager->readOnly; +} + +#ifdef SQLITE_DEBUG +/* +** Return the sum of the reference counts for all pages held by pPager. +*/ +SQLITE_PRIVATE int sqlite3PagerRefcount(Pager *pPager){ + return sqlite3PcacheRefCount(pPager->pPCache); +} +#endif + +/* +** Return the approximate number of bytes of memory currently +** used by the pager and its associated cache. +*/ +SQLITE_PRIVATE int sqlite3PagerMemUsed(Pager *pPager){ + int perPageSize = pPager->pageSize + pPager->nExtra + + (int)(sizeof(PgHdr) + 5*sizeof(void*)); + return perPageSize*sqlite3PcachePagecount(pPager->pPCache) + + sqlite3MallocSize(pPager) + + pPager->pageSize; +} + +/* +** Return the number of references to the specified page. +*/ +SQLITE_PRIVATE int sqlite3PagerPageRefcount(DbPage *pPage){ + return sqlite3PcachePageRefcount(pPage); +} + +#ifdef SQLITE_TEST +/* +** This routine is used for testing and analysis only. +*/ +SQLITE_PRIVATE int *sqlite3PagerStats(Pager *pPager){ + static int a[11]; + a[0] = sqlite3PcacheRefCount(pPager->pPCache); + a[1] = sqlite3PcachePagecount(pPager->pPCache); + a[2] = sqlite3PcacheGetCachesize(pPager->pPCache); + a[3] = pPager->eState==PAGER_OPEN ? -1 : (int) pPager->dbSize; + a[4] = pPager->eState; + a[5] = pPager->errCode; + a[6] = pPager->aStat[PAGER_STAT_HIT]; + a[7] = pPager->aStat[PAGER_STAT_MISS]; + a[8] = 0; /* Used to be pPager->nOvfl */ + a[9] = pPager->nRead; + a[10] = pPager->aStat[PAGER_STAT_WRITE]; + return a; +} +#endif + +/* +** Parameter eStat must be one of SQLITE_DBSTATUS_CACHE_HIT, _MISS, _WRITE, +** or _WRITE+1. The SQLITE_DBSTATUS_CACHE_WRITE+1 case is a translation +** of SQLITE_DBSTATUS_CACHE_SPILL. The _SPILL case is not contiguous because +** it was added later. +** +** Before returning, *pnVal is incremented by the +** current cache hit or miss count, according to the value of eStat. If the +** reset parameter is non-zero, the cache hit or miss count is zeroed before +** returning. +*/ +SQLITE_PRIVATE void sqlite3PagerCacheStat(Pager *pPager, int eStat, int reset, int *pnVal){ + + assert( eStat==SQLITE_DBSTATUS_CACHE_HIT + || eStat==SQLITE_DBSTATUS_CACHE_MISS + || eStat==SQLITE_DBSTATUS_CACHE_WRITE + || eStat==SQLITE_DBSTATUS_CACHE_WRITE+1 + ); + + assert( SQLITE_DBSTATUS_CACHE_HIT+1==SQLITE_DBSTATUS_CACHE_MISS ); + assert( SQLITE_DBSTATUS_CACHE_HIT+2==SQLITE_DBSTATUS_CACHE_WRITE ); + assert( PAGER_STAT_HIT==0 && PAGER_STAT_MISS==1 + && PAGER_STAT_WRITE==2 && PAGER_STAT_SPILL==3 ); + + eStat -= SQLITE_DBSTATUS_CACHE_HIT; + *pnVal += pPager->aStat[eStat]; + if( reset ){ + pPager->aStat[eStat] = 0; + } +} + +/* +** Return true if this is an in-memory or temp-file backed pager. +*/ +SQLITE_PRIVATE int sqlite3PagerIsMemdb(Pager *pPager){ + return pPager->tempFile || pPager->memVfs; +} + +/* +** Check that there are at least nSavepoint savepoints open. If there are +** currently less than nSavepoints open, then open one or more savepoints +** to make up the difference. If the number of savepoints is already +** equal to nSavepoint, then this function is a no-op. +** +** If a memory allocation fails, SQLITE_NOMEM is returned. If an error +** occurs while opening the sub-journal file, then an IO error code is +** returned. Otherwise, SQLITE_OK. +*/ +static SQLITE_NOINLINE int pagerOpenSavepoint(Pager *pPager, int nSavepoint){ + int rc = SQLITE_OK; /* Return code */ + int nCurrent = pPager->nSavepoint; /* Current number of savepoints */ + int ii; /* Iterator variable */ + PagerSavepoint *aNew; /* New Pager.aSavepoint array */ + + assert( pPager->eState>=PAGER_WRITER_LOCKED ); + assert( assert_pager_state(pPager) ); + assert( nSavepoint>nCurrent && pPager->useJournal ); + + /* Grow the Pager.aSavepoint array using realloc(). Return SQLITE_NOMEM + ** if the allocation fails. Otherwise, zero the new portion in case a + ** malloc failure occurs while populating it in the for(...) loop below. + */ + aNew = (PagerSavepoint *)sqlite3Realloc( + pPager->aSavepoint, sizeof(PagerSavepoint)*nSavepoint + ); + if( !aNew ){ + return SQLITE_NOMEM_BKPT; + } + memset(&aNew[nCurrent], 0, (nSavepoint-nCurrent) * sizeof(PagerSavepoint)); + pPager->aSavepoint = aNew; + + /* Populate the PagerSavepoint structures just allocated. */ + for(ii=nCurrent; iidbSize; + if( isOpen(pPager->jfd) && pPager->journalOff>0 ){ + aNew[ii].iOffset = pPager->journalOff; + }else{ + aNew[ii].iOffset = JOURNAL_HDR_SZ(pPager); + } + aNew[ii].iSubRec = pPager->nSubRec; + aNew[ii].pInSavepoint = sqlite3BitvecCreate(pPager->dbSize); + aNew[ii].bTruncateOnRelease = 1; + if( !aNew[ii].pInSavepoint ){ + return SQLITE_NOMEM_BKPT; + } + if( pagerUseWal(pPager) ){ + sqlite3WalSavepoint(pPager->pWal, aNew[ii].aWalData); + } + pPager->nSavepoint = ii+1; + } + assert( pPager->nSavepoint==nSavepoint ); + assertTruncateConstraint(pPager); + return rc; +} +SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int nSavepoint){ + assert( pPager->eState>=PAGER_WRITER_LOCKED ); + assert( assert_pager_state(pPager) ); + + if( nSavepoint>pPager->nSavepoint && pPager->useJournal ){ + return pagerOpenSavepoint(pPager, nSavepoint); + }else{ + return SQLITE_OK; + } +} + + +/* +** This function is called to rollback or release (commit) a savepoint. +** The savepoint to release or rollback need not be the most recently +** created savepoint. +** +** Parameter op is always either SAVEPOINT_ROLLBACK or SAVEPOINT_RELEASE. +** If it is SAVEPOINT_RELEASE, then release and destroy the savepoint with +** index iSavepoint. If it is SAVEPOINT_ROLLBACK, then rollback all changes +** that have occurred since the specified savepoint was created. +** +** The savepoint to rollback or release is identified by parameter +** iSavepoint. A value of 0 means to operate on the outermost savepoint +** (the first created). A value of (Pager.nSavepoint-1) means operate +** on the most recently created savepoint. If iSavepoint is greater than +** (Pager.nSavepoint-1), then this function is a no-op. +** +** If a negative value is passed to this function, then the current +** transaction is rolled back. This is different to calling +** sqlite3PagerRollback() because this function does not terminate +** the transaction or unlock the database, it just restores the +** contents of the database to its original state. +** +** In any case, all savepoints with an index greater than iSavepoint +** are destroyed. If this is a release operation (op==SAVEPOINT_RELEASE), +** then savepoint iSavepoint is also destroyed. +** +** This function may return SQLITE_NOMEM if a memory allocation fails, +** or an IO error code if an IO error occurs while rolling back a +** savepoint. If no errors occur, SQLITE_OK is returned. +*/ +SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint){ + int rc = pPager->errCode; + +#ifdef SQLITE_ENABLE_ZIPVFS + if( op==SAVEPOINT_RELEASE ) rc = SQLITE_OK; +#endif + + assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK ); + assert( iSavepoint>=0 || op==SAVEPOINT_ROLLBACK ); + + if( rc==SQLITE_OK && iSavepointnSavepoint ){ + int ii; /* Iterator variable */ + int nNew; /* Number of remaining savepoints after this op. */ + + /* Figure out how many savepoints will still be active after this + ** operation. Store this value in nNew. Then free resources associated + ** with any savepoints that are destroyed by this operation. + */ + nNew = iSavepoint + (( op==SAVEPOINT_RELEASE ) ? 0 : 1); + for(ii=nNew; iinSavepoint; ii++){ + sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint); + } + pPager->nSavepoint = nNew; + + /* Truncate the sub-journal so that it only includes the parts + ** that are still in use. */ + if( op==SAVEPOINT_RELEASE ){ + PagerSavepoint *pRel = &pPager->aSavepoint[nNew]; + if( pRel->bTruncateOnRelease && isOpen(pPager->sjfd) ){ + /* Only truncate if it is an in-memory sub-journal. */ + if( sqlite3JournalIsInMemory(pPager->sjfd) ){ + i64 sz = (pPager->pageSize+4)*(i64)pRel->iSubRec; + rc = sqlite3OsTruncate(pPager->sjfd, sz); + assert( rc==SQLITE_OK ); + } + pPager->nSubRec = pRel->iSubRec; + } + } + /* Else this is a rollback operation, playback the specified savepoint. + ** If this is a temp-file, it is possible that the journal file has + ** not yet been opened. In this case there have been no changes to + ** the database file, so the playback operation can be skipped. + */ + else if( pagerUseWal(pPager) || isOpen(pPager->jfd) ){ + PagerSavepoint *pSavepoint = (nNew==0)?0:&pPager->aSavepoint[nNew-1]; + rc = pagerPlaybackSavepoint(pPager, pSavepoint); + assert(rc!=SQLITE_DONE); + } + +#ifdef SQLITE_ENABLE_ZIPVFS + /* If the cache has been modified but the savepoint cannot be rolled + ** back journal_mode=off, put the pager in the error state. This way, + ** if the VFS used by this pager includes ZipVFS, the entire transaction + ** can be rolled back at the ZipVFS level. */ + else if( + pPager->journalMode==PAGER_JOURNALMODE_OFF + && pPager->eState>=PAGER_WRITER_CACHEMOD + ){ + pPager->errCode = SQLITE_ABORT; + pPager->eState = PAGER_ERROR; + setGetterMethod(pPager); + } +#endif + } + + return rc; +} + +/* +** Return the full pathname of the database file. +** +** Except, if the pager is in-memory only, then return an empty string if +** nullIfMemDb is true. This routine is called with nullIfMemDb==1 when +** used to report the filename to the user, for compatibility with legacy +** behavior. But when the Btree needs to know the filename for matching to +** shared cache, it uses nullIfMemDb==0 so that in-memory databases can +** participate in shared-cache. +** +** The return value to this routine is always safe to use with +** sqlite3_uri_parameter() and sqlite3_filename_database() and friends. +*/ +SQLITE_PRIVATE const char *sqlite3PagerFilename(const Pager *pPager, int nullIfMemDb){ + static const char zFake[8] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + if( nullIfMemDb && (pPager->memDb || sqlite3IsMemdb(pPager->pVfs)) ){ + return &zFake[4]; + }else{ + return pPager->zFilename; + } +} + +/* +** Return the VFS structure for the pager. +*/ +SQLITE_PRIVATE sqlite3_vfs *sqlite3PagerVfs(Pager *pPager){ + return pPager->pVfs; +} + +/* +** Return the file handle for the database file associated +** with the pager. This might return NULL if the file has +** not yet been opened. +*/ +SQLITE_PRIVATE sqlite3_file *sqlite3PagerFile(Pager *pPager){ + return pPager->fd; +} + +/* +** Return the file handle for the journal file (if it exists). +** This will be either the rollback journal or the WAL file. +*/ +SQLITE_PRIVATE sqlite3_file *sqlite3PagerJrnlFile(Pager *pPager){ +#if SQLITE_OMIT_WAL + return pPager->jfd; +#else + return pPager->pWal ? sqlite3WalFile(pPager->pWal) : pPager->jfd; +#endif +} + +/* +** Return the full pathname of the journal file. +*/ +SQLITE_PRIVATE const char *sqlite3PagerJournalname(Pager *pPager){ + return pPager->zJournal; +} + +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC +/* +** Set or retrieve the codec for this pager +*/ +void sqlcipherPagerSetCodec( + Pager *pPager, + void *(*xCodec)(void*,void*,Pgno,int), + void (*xCodecSizeChng)(void*,int,int), + void (*xCodecFree)(void*), + void *pCodec +){ + if( pPager->xCodecFree ){ + pPager->xCodecFree(pPager->pCodec); + }else{ + pager_reset(pPager); + } + pPager->xCodec = pPager->memDb ? 0 : xCodec; + pPager->xCodecSizeChng = xCodecSizeChng; + pPager->xCodecFree = xCodecFree; + pPager->pCodec = pCodec; + setGetterMethod(pPager); + pagerReportSize(pPager); +} +void *sqlcipherPagerGetCodec(Pager *pPager){ + return pPager->pCodec; +} + +/* +** This function is called by the wal module when writing page content +** into the log file. +** +** This function returns a pointer to a buffer containing the encrypted +** page content. If a malloc fails, this function may return NULL. +*/ +void *sqlcipherPagerCodec(PgHdr *pPg){ + void *aData = 0; + CODEC2(pPg->pPager, pPg->pData, pPg->pgno, 6, return 0, aData); + return aData; +} +#endif /* SQLITE_HAS_CODEC */ +/* END SQLCIPHER */ + +#ifndef SQLITE_OMIT_AUTOVACUUM +/* +** Move the page pPg to location pgno in the file. +** +** There must be no references to the page previously located at +** pgno (which we call pPgOld) though that page is allowed to be +** in cache. If the page previously located at pgno is not already +** in the rollback journal, it is not put there by by this routine. +** +** References to the page pPg remain valid. Updating any +** meta-data associated with pPg (i.e. data stored in the nExtra bytes +** allocated along with the page) is the responsibility of the caller. +** +** A transaction must be active when this routine is called. It used to be +** required that a statement transaction was not active, but this restriction +** has been removed (CREATE INDEX needs to move a page when a statement +** transaction is active). +** +** If the fourth argument, isCommit, is non-zero, then this page is being +** moved as part of a database reorganization just before the transaction +** is being committed. In this case, it is guaranteed that the database page +** pPg refers to will not be written to again within this transaction. +** +** This function may return SQLITE_NOMEM or an IO error code if an error +** occurs. Otherwise, it returns SQLITE_OK. +*/ +SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){ + PgHdr *pPgOld; /* The page being overwritten. */ + Pgno needSyncPgno = 0; /* Old value of pPg->pgno, if sync is required */ + int rc; /* Return code */ + Pgno origPgno; /* The original page number */ + + assert( pPg->nRef>0 ); + assert( pPager->eState==PAGER_WRITER_CACHEMOD + || pPager->eState==PAGER_WRITER_DBMOD + ); + assert( assert_pager_state(pPager) ); + + /* In order to be able to rollback, an in-memory database must journal + ** the page we are moving from. + */ + assert( pPager->tempFile || !MEMDB ); + if( pPager->tempFile ){ + rc = sqlite3PagerWrite(pPg); + if( rc ) return rc; + } + + /* If the page being moved is dirty and has not been saved by the latest + ** savepoint, then save the current contents of the page into the + ** sub-journal now. This is required to handle the following scenario: + ** + ** BEGIN; + ** + ** SAVEPOINT one; + ** + ** ROLLBACK TO one; + ** + ** If page X were not written to the sub-journal here, it would not + ** be possible to restore its contents when the "ROLLBACK TO one" + ** statement were is processed. + ** + ** subjournalPage() may need to allocate space to store pPg->pgno into + ** one or more savepoint bitvecs. This is the reason this function + ** may return SQLITE_NOMEM. + */ + if( (pPg->flags & PGHDR_DIRTY)!=0 + && SQLITE_OK!=(rc = subjournalPageIfRequired(pPg)) + ){ + return rc; + } + + PAGERTRACE(("MOVE %d page %d (needSync=%d) moves to %d\n", + PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno)); + IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno)) + + /* If the journal needs to be sync()ed before page pPg->pgno can + ** be written to, store pPg->pgno in local variable needSyncPgno. + ** + ** If the isCommit flag is set, there is no need to remember that + ** the journal needs to be sync()ed before database page pPg->pgno + ** can be written to. The caller has already promised not to write to it. + */ + if( (pPg->flags&PGHDR_NEED_SYNC) && !isCommit ){ + needSyncPgno = pPg->pgno; + assert( pPager->journalMode==PAGER_JOURNALMODE_OFF || + pageInJournal(pPager, pPg) || pPg->pgno>pPager->dbOrigSize ); + assert( pPg->flags&PGHDR_DIRTY ); + } + + /* If the cache contains a page with page-number pgno, remove it + ** from its hash chain. Also, if the PGHDR_NEED_SYNC flag was set for + ** page pgno before the 'move' operation, it needs to be retained + ** for the page moved there. + */ + pPg->flags &= ~PGHDR_NEED_SYNC; + pPgOld = sqlite3PagerLookup(pPager, pgno); + assert( !pPgOld || pPgOld->nRef==1 || CORRUPT_DB ); + if( pPgOld ){ + if( NEVER(pPgOld->nRef>1) ){ + sqlite3PagerUnrefNotNull(pPgOld); + return SQLITE_CORRUPT_BKPT; + } + pPg->flags |= (pPgOld->flags&PGHDR_NEED_SYNC); + if( pPager->tempFile ){ + /* Do not discard pages from an in-memory database since we might + ** need to rollback later. Just move the page out of the way. */ + sqlite3PcacheMove(pPgOld, pPager->dbSize+1); + }else{ + sqlite3PcacheDrop(pPgOld); + } + } + + origPgno = pPg->pgno; + sqlite3PcacheMove(pPg, pgno); + sqlite3PcacheMakeDirty(pPg); + + /* For an in-memory database, make sure the original page continues + ** to exist, in case the transaction needs to roll back. Use pPgOld + ** as the original page since it has already been allocated. + */ + if( pPager->tempFile && pPgOld ){ + sqlite3PcacheMove(pPgOld, origPgno); + sqlite3PagerUnrefNotNull(pPgOld); + } + + if( needSyncPgno ){ + /* If needSyncPgno is non-zero, then the journal file needs to be + ** sync()ed before any data is written to database file page needSyncPgno. + ** Currently, no such page exists in the page-cache and the + ** "is journaled" bitvec flag has been set. This needs to be remedied by + ** loading the page into the pager-cache and setting the PGHDR_NEED_SYNC + ** flag. + ** + ** If the attempt to load the page into the page-cache fails, (due + ** to a malloc() or IO failure), clear the bit in the pInJournal[] + ** array. Otherwise, if the page is loaded and written again in + ** this transaction, it may be written to the database file before + ** it is synced into the journal file. This way, it may end up in + ** the journal file twice, but that is not a problem. + */ + PgHdr *pPgHdr; + rc = sqlite3PagerGet(pPager, needSyncPgno, &pPgHdr, 0); + if( rc!=SQLITE_OK ){ + if( needSyncPgno<=pPager->dbOrigSize ){ + assert( pPager->pTmpSpace!=0 ); + sqlite3BitvecClear(pPager->pInJournal, needSyncPgno, pPager->pTmpSpace); + } + return rc; + } + pPgHdr->flags |= PGHDR_NEED_SYNC; + sqlite3PcacheMakeDirty(pPgHdr); + sqlite3PagerUnrefNotNull(pPgHdr); + } + + return SQLITE_OK; +} +#endif + +/* +** The page handle passed as the first argument refers to a dirty page +** with a page number other than iNew. This function changes the page's +** page number to iNew and sets the value of the PgHdr.flags field to +** the value passed as the third parameter. +*/ +SQLITE_PRIVATE void sqlite3PagerRekey(DbPage *pPg, Pgno iNew, u16 flags){ + assert( pPg->pgno!=iNew ); + pPg->flags = flags; + sqlite3PcacheMove(pPg, iNew); +} + +/* +** Return a pointer to the data for the specified page. +*/ +SQLITE_PRIVATE void *sqlite3PagerGetData(DbPage *pPg){ + assert( pPg->nRef>0 || pPg->pPager->memDb ); + return pPg->pData; +} + +/* +** Return a pointer to the Pager.nExtra bytes of "extra" space +** allocated along with the specified page. +*/ +SQLITE_PRIVATE void *sqlite3PagerGetExtra(DbPage *pPg){ + return pPg->pExtra; +} + +/* +** Get/set the locking-mode for this pager. Parameter eMode must be one +** of PAGER_LOCKINGMODE_QUERY, PAGER_LOCKINGMODE_NORMAL or +** PAGER_LOCKINGMODE_EXCLUSIVE. If the parameter is not _QUERY, then +** the locking-mode is set to the value specified. +** +** The returned value is either PAGER_LOCKINGMODE_NORMAL or +** PAGER_LOCKINGMODE_EXCLUSIVE, indicating the current (possibly updated) +** locking-mode. +*/ +SQLITE_PRIVATE int sqlite3PagerLockingMode(Pager *pPager, int eMode){ + assert( eMode==PAGER_LOCKINGMODE_QUERY + || eMode==PAGER_LOCKINGMODE_NORMAL + || eMode==PAGER_LOCKINGMODE_EXCLUSIVE ); + assert( PAGER_LOCKINGMODE_QUERY<0 ); + assert( PAGER_LOCKINGMODE_NORMAL>=0 && PAGER_LOCKINGMODE_EXCLUSIVE>=0 ); + assert( pPager->exclusiveMode || 0==sqlite3WalHeapMemory(pPager->pWal) ); + if( eMode>=0 && !pPager->tempFile && !sqlite3WalHeapMemory(pPager->pWal) ){ + pPager->exclusiveMode = (u8)eMode; + } + return (int)pPager->exclusiveMode; +} + +/* +** Set the journal-mode for this pager. Parameter eMode must be one of: +** +** PAGER_JOURNALMODE_DELETE +** PAGER_JOURNALMODE_TRUNCATE +** PAGER_JOURNALMODE_PERSIST +** PAGER_JOURNALMODE_OFF +** PAGER_JOURNALMODE_MEMORY +** PAGER_JOURNALMODE_WAL +** +** The journalmode is set to the value specified if the change is allowed. +** The change may be disallowed for the following reasons: +** +** * An in-memory database can only have its journal_mode set to _OFF +** or _MEMORY. +** +** * Temporary databases cannot have _WAL journalmode. +** +** The returned indicate the current (possibly updated) journal-mode. +*/ +SQLITE_PRIVATE int sqlite3PagerSetJournalMode(Pager *pPager, int eMode){ + u8 eOld = pPager->journalMode; /* Prior journalmode */ + + /* The eMode parameter is always valid */ + assert( eMode==PAGER_JOURNALMODE_DELETE /* 0 */ + || eMode==PAGER_JOURNALMODE_PERSIST /* 1 */ + || eMode==PAGER_JOURNALMODE_OFF /* 2 */ + || eMode==PAGER_JOURNALMODE_TRUNCATE /* 3 */ + || eMode==PAGER_JOURNALMODE_MEMORY /* 4 */ + || eMode==PAGER_JOURNALMODE_WAL /* 5 */ ); + + /* This routine is only called from the OP_JournalMode opcode, and + ** the logic there will never allow a temporary file to be changed + ** to WAL mode. + */ + assert( pPager->tempFile==0 || eMode!=PAGER_JOURNALMODE_WAL ); + + /* Do allow the journalmode of an in-memory database to be set to + ** anything other than MEMORY or OFF + */ + if( MEMDB ){ + assert( eOld==PAGER_JOURNALMODE_MEMORY || eOld==PAGER_JOURNALMODE_OFF ); + if( eMode!=PAGER_JOURNALMODE_MEMORY && eMode!=PAGER_JOURNALMODE_OFF ){ + eMode = eOld; + } + } + + if( eMode!=eOld ){ + + /* Change the journal mode. */ + assert( pPager->eState!=PAGER_ERROR ); + pPager->journalMode = (u8)eMode; + + /* When transistioning from TRUNCATE or PERSIST to any other journal + ** mode except WAL, unless the pager is in locking_mode=exclusive mode, + ** delete the journal file. + */ + assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 ); + assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 ); + assert( (PAGER_JOURNALMODE_DELETE & 5)==0 ); + assert( (PAGER_JOURNALMODE_MEMORY & 5)==4 ); + assert( (PAGER_JOURNALMODE_OFF & 5)==0 ); + assert( (PAGER_JOURNALMODE_WAL & 5)==5 ); + + assert( isOpen(pPager->fd) || pPager->exclusiveMode ); + if( !pPager->exclusiveMode && (eOld & 5)==1 && (eMode & 1)==0 ){ + /* In this case we would like to delete the journal file. If it is + ** not possible, then that is not a problem. Deleting the journal file + ** here is an optimization only. + ** + ** Before deleting the journal file, obtain a RESERVED lock on the + ** database file. This ensures that the journal file is not deleted + ** while it is in use by some other client. + */ + sqlite3OsClose(pPager->jfd); + if( pPager->eLock>=RESERVED_LOCK ){ + sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0); + }else{ + int rc = SQLITE_OK; + int state = pPager->eState; + assert( state==PAGER_OPEN || state==PAGER_READER ); + if( state==PAGER_OPEN ){ + rc = sqlite3PagerSharedLock(pPager); + } + if( pPager->eState==PAGER_READER ){ + assert( rc==SQLITE_OK ); + rc = pagerLockDb(pPager, RESERVED_LOCK); + } + if( rc==SQLITE_OK ){ + sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0); + } + if( rc==SQLITE_OK && state==PAGER_READER ){ + pagerUnlockDb(pPager, SHARED_LOCK); + }else if( state==PAGER_OPEN ){ + pager_unlock(pPager); + } + assert( state==pPager->eState ); + } + }else if( eMode==PAGER_JOURNALMODE_OFF ){ + sqlite3OsClose(pPager->jfd); + } + } + + /* Return the new journal mode */ + return (int)pPager->journalMode; +} + +/* +** Return the current journal mode. +*/ +SQLITE_PRIVATE int sqlite3PagerGetJournalMode(Pager *pPager){ + return (int)pPager->journalMode; +} + +/* +** Return TRUE if the pager is in a state where it is OK to change the +** journalmode. Journalmode changes can only happen when the database +** is unmodified. +*/ +SQLITE_PRIVATE int sqlite3PagerOkToChangeJournalMode(Pager *pPager){ + assert( assert_pager_state(pPager) ); + if( pPager->eState>=PAGER_WRITER_CACHEMOD ) return 0; + if( NEVER(isOpen(pPager->jfd) && pPager->journalOff>0) ) return 0; + return 1; +} + +/* +** Get/set the size-limit used for persistent journal files. +** +** Setting the size limit to -1 means no limit is enforced. +** An attempt to set a limit smaller than -1 is a no-op. +*/ +SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *pPager, i64 iLimit){ + if( iLimit>=-1 ){ + pPager->journalSizeLimit = iLimit; + sqlite3WalLimit(pPager->pWal, iLimit); + } + return pPager->journalSizeLimit; +} + +/* +** Return a pointer to the pPager->pBackup variable. The backup module +** in backup.c maintains the content of this variable. This module +** uses it opaquely as an argument to sqlite3BackupRestart() and +** sqlite3BackupUpdate() only. +*/ +SQLITE_PRIVATE sqlite3_backup **sqlite3PagerBackupPtr(Pager *pPager){ + return &pPager->pBackup; +} + +#ifndef SQLITE_OMIT_VACUUM +/* +** Unless this is an in-memory or temporary database, clear the pager cache. +*/ +SQLITE_PRIVATE void sqlite3PagerClearCache(Pager *pPager){ + assert( MEMDB==0 || pPager->tempFile ); + if( pPager->tempFile==0 ) pager_reset(pPager); +} +#endif + + +#ifndef SQLITE_OMIT_WAL +/* +** This function is called when the user invokes "PRAGMA wal_checkpoint", +** "PRAGMA wal_blocking_checkpoint" or calls the sqlite3_wal_checkpoint() +** or wal_blocking_checkpoint() API functions. +** +** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART. +*/ +SQLITE_PRIVATE int sqlite3PagerCheckpoint( + Pager *pPager, /* Checkpoint on this pager */ + sqlite3 *db, /* Db handle used to check for interrupts */ + int eMode, /* Type of checkpoint */ + int *pnLog, /* OUT: Final number of frames in log */ + int *pnCkpt /* OUT: Final number of checkpointed frames */ +){ + int rc = SQLITE_OK; + if( pPager->pWal==0 && pPager->journalMode==PAGER_JOURNALMODE_WAL ){ + /* This only happens when a database file is zero bytes in size opened and + ** then "PRAGMA journal_mode=WAL" is run and then sqlite3_wal_checkpoint() + ** is invoked without any intervening transactions. We need to start + ** a transaction to initialize pWal. The PRAGMA table_list statement is + ** used for this since it starts transactions on every database file, + ** including all ATTACHed databases. This seems expensive for a single + ** sqlite3_wal_checkpoint() call, but it happens very rarely. + ** https://sqlite.org/forum/forumpost/fd0f19d229156939 + */ + sqlite3_exec(db, "PRAGMA table_list",0,0,0); + } + if( pPager->pWal ){ + rc = sqlite3WalCheckpoint(pPager->pWal, db, eMode, + (eMode==SQLITE_CHECKPOINT_PASSIVE ? 0 : pPager->xBusyHandler), + pPager->pBusyHandlerArg, + pPager->walSyncFlags, pPager->pageSize, (u8 *)pPager->pTmpSpace, + pnLog, pnCkpt + ); + } + return rc; +} + +SQLITE_PRIVATE int sqlite3PagerWalCallback(Pager *pPager){ + return sqlite3WalCallback(pPager->pWal); +} + +/* +** Return true if the underlying VFS for the given pager supports the +** primitives necessary for write-ahead logging. +*/ +SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager){ + const sqlite3_io_methods *pMethods = pPager->fd->pMethods; + if( pPager->noLock ) return 0; + return pPager->exclusiveMode || (pMethods->iVersion>=2 && pMethods->xShmMap); +} + +/* +** Attempt to take an exclusive lock on the database file. If a PENDING lock +** is obtained instead, immediately release it. +*/ +static int pagerExclusiveLock(Pager *pPager){ + int rc; /* Return code */ + u8 eOrigLock; /* Original lock */ + + assert( pPager->eLock>=SHARED_LOCK ); + eOrigLock = pPager->eLock; + rc = pagerLockDb(pPager, EXCLUSIVE_LOCK); + if( rc!=SQLITE_OK ){ + /* If the attempt to grab the exclusive lock failed, release the + ** pending lock that may have been obtained instead. */ + pagerUnlockDb(pPager, eOrigLock); + } + + return rc; +} + +/* +** Call sqlite3WalOpen() to open the WAL handle. If the pager is in +** exclusive-locking mode when this function is called, take an EXCLUSIVE +** lock on the database file and use heap-memory to store the wal-index +** in. Otherwise, use the normal shared-memory. +*/ +static int pagerOpenWal(Pager *pPager){ + int rc = SQLITE_OK; + + assert( pPager->pWal==0 && pPager->tempFile==0 ); + assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK ); + + /* If the pager is already in exclusive-mode, the WAL module will use + ** heap-memory for the wal-index instead of the VFS shared-memory + ** implementation. Take the exclusive lock now, before opening the WAL + ** file, to make sure this is safe. + */ + if( pPager->exclusiveMode ){ + rc = pagerExclusiveLock(pPager); + } + + /* Open the connection to the log file. If this operation fails, + ** (e.g. due to malloc() failure), return an error code. + */ + if( rc==SQLITE_OK ){ + rc = sqlite3WalOpen(pPager->pVfs, + pPager->fd, pPager->zWal, pPager->exclusiveMode, + pPager->journalSizeLimit, &pPager->pWal + ); + } + pagerFixMaplimit(pPager); + + return rc; +} + + +/* +** The caller must be holding a SHARED lock on the database file to call +** this function. +** +** If the pager passed as the first argument is open on a real database +** file (not a temp file or an in-memory database), and the WAL file +** is not already open, make an attempt to open it now. If successful, +** return SQLITE_OK. If an error occurs or the VFS used by the pager does +** not support the xShmXXX() methods, return an error code. *pbOpen is +** not modified in either case. +** +** If the pager is open on a temp-file (or in-memory database), or if +** the WAL file is already open, set *pbOpen to 1 and return SQLITE_OK +** without doing anything. +*/ +SQLITE_PRIVATE int sqlite3PagerOpenWal( + Pager *pPager, /* Pager object */ + int *pbOpen /* OUT: Set to true if call is a no-op */ +){ + int rc = SQLITE_OK; /* Return code */ + + assert( assert_pager_state(pPager) ); + assert( pPager->eState==PAGER_OPEN || pbOpen ); + assert( pPager->eState==PAGER_READER || !pbOpen ); + assert( pbOpen==0 || *pbOpen==0 ); + assert( pbOpen!=0 || (!pPager->tempFile && !pPager->pWal) ); + + if( !pPager->tempFile && !pPager->pWal ){ + if( !sqlite3PagerWalSupported(pPager) ) return SQLITE_CANTOPEN; + + /* Close any rollback journal previously open */ + sqlite3OsClose(pPager->jfd); + + rc = pagerOpenWal(pPager); + if( rc==SQLITE_OK ){ + pPager->journalMode = PAGER_JOURNALMODE_WAL; + pPager->eState = PAGER_OPEN; + } + }else{ + *pbOpen = 1; + } + + return rc; +} + +/* +** This function is called to close the connection to the log file prior +** to switching from WAL to rollback mode. +** +** Before closing the log file, this function attempts to take an +** EXCLUSIVE lock on the database file. If this cannot be obtained, an +** error (SQLITE_BUSY) is returned and the log connection is not closed. +** If successful, the EXCLUSIVE lock is not released before returning. +*/ +SQLITE_PRIVATE int sqlite3PagerCloseWal(Pager *pPager, sqlite3 *db){ + int rc = SQLITE_OK; + + assert( pPager->journalMode==PAGER_JOURNALMODE_WAL ); + + /* If the log file is not already open, but does exist in the file-system, + ** it may need to be checkpointed before the connection can switch to + ** rollback mode. Open it now so this can happen. + */ + if( !pPager->pWal ){ + int logexists = 0; + rc = pagerLockDb(pPager, SHARED_LOCK); + if( rc==SQLITE_OK ){ + rc = sqlite3OsAccess( + pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &logexists + ); + } + if( rc==SQLITE_OK && logexists ){ + rc = pagerOpenWal(pPager); + } + } + + /* Checkpoint and close the log. Because an EXCLUSIVE lock is held on + ** the database file, the log and log-summary files will be deleted. + */ + if( rc==SQLITE_OK && pPager->pWal ){ + rc = pagerExclusiveLock(pPager); + if( rc==SQLITE_OK ){ + rc = sqlite3WalClose(pPager->pWal, db, pPager->walSyncFlags, + pPager->pageSize, (u8*)pPager->pTmpSpace); + pPager->pWal = 0; + pagerFixMaplimit(pPager); + if( rc && !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK); + } + } + return rc; +} + +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT +/* +** If pager pPager is a wal-mode database not in exclusive locking mode, +** invoke the sqlite3WalWriteLock() function on the associated Wal object +** with the same db and bLock parameters as were passed to this function. +** Return an SQLite error code if an error occurs, or SQLITE_OK otherwise. +*/ +SQLITE_PRIVATE int sqlite3PagerWalWriteLock(Pager *pPager, int bLock){ + int rc = SQLITE_OK; + if( pagerUseWal(pPager) && pPager->exclusiveMode==0 ){ + rc = sqlite3WalWriteLock(pPager->pWal, bLock); + } + return rc; +} + +/* +** Set the database handle used by the wal layer to determine if +** blocking locks are required. +*/ +SQLITE_PRIVATE void sqlite3PagerWalDb(Pager *pPager, sqlite3 *db){ + if( pagerUseWal(pPager) ){ + sqlite3WalDb(pPager->pWal, db); + } +} +#endif + +#ifdef SQLITE_ENABLE_SNAPSHOT +/* +** If this is a WAL database, obtain a snapshot handle for the snapshot +** currently open. Otherwise, return an error. +*/ +SQLITE_PRIVATE int sqlite3PagerSnapshotGet(Pager *pPager, sqlite3_snapshot **ppSnapshot){ + int rc = SQLITE_ERROR; + if( pPager->pWal ){ + rc = sqlite3WalSnapshotGet(pPager->pWal, ppSnapshot); + } + return rc; +} + +/* +** If this is a WAL database, store a pointer to pSnapshot. Next time a +** read transaction is opened, attempt to read from the snapshot it +** identifies. If this is not a WAL database, return an error. +*/ +SQLITE_PRIVATE int sqlite3PagerSnapshotOpen( + Pager *pPager, + sqlite3_snapshot *pSnapshot +){ + int rc = SQLITE_OK; + if( pPager->pWal ){ + sqlite3WalSnapshotOpen(pPager->pWal, pSnapshot); + }else{ + rc = SQLITE_ERROR; + } + return rc; +} + +/* +** If this is a WAL database, call sqlite3WalSnapshotRecover(). If this +** is not a WAL database, return an error. +*/ +SQLITE_PRIVATE int sqlite3PagerSnapshotRecover(Pager *pPager){ + int rc; + if( pPager->pWal ){ + rc = sqlite3WalSnapshotRecover(pPager->pWal); + }else{ + rc = SQLITE_ERROR; + } + return rc; +} + +/* +** The caller currently has a read transaction open on the database. +** If this is not a WAL database, SQLITE_ERROR is returned. Otherwise, +** this function takes a SHARED lock on the CHECKPOINTER slot and then +** checks if the snapshot passed as the second argument is still +** available. If so, SQLITE_OK is returned. +** +** If the snapshot is not available, SQLITE_ERROR is returned. Or, if +** the CHECKPOINTER lock cannot be obtained, SQLITE_BUSY. If any error +** occurs (any value other than SQLITE_OK is returned), the CHECKPOINTER +** lock is released before returning. +*/ +SQLITE_PRIVATE int sqlite3PagerSnapshotCheck(Pager *pPager, sqlite3_snapshot *pSnapshot){ + int rc; + if( pPager->pWal ){ + rc = sqlite3WalSnapshotCheck(pPager->pWal, pSnapshot); + }else{ + rc = SQLITE_ERROR; + } + return rc; +} + +/* +** Release a lock obtained by an earlier successful call to +** sqlite3PagerSnapshotCheck(). +*/ +SQLITE_PRIVATE void sqlite3PagerSnapshotUnlock(Pager *pPager){ + assert( pPager->pWal ); + sqlite3WalSnapshotUnlock(pPager->pWal); +} + +#endif /* SQLITE_ENABLE_SNAPSHOT */ +#endif /* !SQLITE_OMIT_WAL */ + +#ifdef SQLITE_ENABLE_ZIPVFS +/* +** A read-lock must be held on the pager when this function is called. If +** the pager is in WAL mode and the WAL file currently contains one or more +** frames, return the size in bytes of the page images stored within the +** WAL frames. Otherwise, if this is not a WAL database or the WAL file +** is empty, return 0. +*/ +SQLITE_PRIVATE int sqlite3PagerWalFramesize(Pager *pPager){ + assert( pPager->eState>=PAGER_READER ); + return sqlite3WalFramesize(pPager->pWal); +} +#endif + +#endif /* SQLITE_OMIT_DISKIO */ + +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC + +SQLITE_API int sqlite3pager_is_sj_pgno(Pager *pPager, Pgno pgno) { + return (PAGER_SJ_PGNO(pPager) == pgno) ? 1 : 0; +} + +SQLITE_API void sqlite3pager_error(Pager *pPager, int error) { + pPager->errCode = error; + pPager->eState = PAGER_ERROR; + setGetterMethod(pPager); +} + +SQLITE_API void sqlite3pager_reset(Pager *pPager){ + pager_reset(pPager); +} + +#endif +/* END SQLCIPHER */ + + +/************** End of pager.c ***********************************************/ +/************** Begin file wal.c *********************************************/ +/* +** 2010 February 1 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains the implementation of a write-ahead log (WAL) used in +** "journal_mode=WAL" mode. +** +** WRITE-AHEAD LOG (WAL) FILE FORMAT +** +** A WAL file consists of a header followed by zero or more "frames". +** Each frame records the revised content of a single page from the +** database file. All changes to the database are recorded by writing +** frames into the WAL. Transactions commit when a frame is written that +** contains a commit marker. A single WAL can and usually does record +** multiple transactions. Periodically, the content of the WAL is +** transferred back into the database file in an operation called a +** "checkpoint". +** +** A single WAL file can be used multiple times. In other words, the +** WAL can fill up with frames and then be checkpointed and then new +** frames can overwrite the old ones. A WAL always grows from beginning +** toward the end. Checksums and counters attached to each frame are +** used to determine which frames within the WAL are valid and which +** are leftovers from prior checkpoints. +** +** The WAL header is 32 bytes in size and consists of the following eight +** big-endian 32-bit unsigned integer values: +** +** 0: Magic number. 0x377f0682 or 0x377f0683 +** 4: File format version. Currently 3007000 +** 8: Database page size. Example: 1024 +** 12: Checkpoint sequence number +** 16: Salt-1, random integer incremented with each checkpoint +** 20: Salt-2, a different random integer changing with each ckpt +** 24: Checksum-1 (first part of checksum for first 24 bytes of header). +** 28: Checksum-2 (second part of checksum for first 24 bytes of header). +** +** Immediately following the wal-header are zero or more frames. Each +** frame consists of a 24-byte frame-header followed by a bytes +** of page data. The frame-header is six big-endian 32-bit unsigned +** integer values, as follows: +** +** 0: Page number. +** 4: For commit records, the size of the database image in pages +** after the commit. For all other records, zero. +** 8: Salt-1 (copied from the header) +** 12: Salt-2 (copied from the header) +** 16: Checksum-1. +** 20: Checksum-2. +** +** A frame is considered valid if and only if the following conditions are +** true: +** +** (1) The salt-1 and salt-2 values in the frame-header match +** salt values in the wal-header +** +** (2) The checksum values in the final 8 bytes of the frame-header +** exactly match the checksum computed consecutively on the +** WAL header and the first 8 bytes and the content of all frames +** up to and including the current frame. +** +** The checksum is computed using 32-bit big-endian integers if the +** magic number in the first 4 bytes of the WAL is 0x377f0683 and it +** is computed using little-endian if the magic number is 0x377f0682. +** The checksum values are always stored in the frame header in a +** big-endian format regardless of which byte order is used to compute +** the checksum. The checksum is computed by interpreting the input as +** an even number of unsigned 32-bit integers: x[0] through x[N]. The +** algorithm used for the checksum is as follows: +** +** for i from 0 to n-1 step 2: +** s0 += x[i] + s1; +** s1 += x[i+1] + s0; +** endfor +** +** Note that s0 and s1 are both weighted checksums using fibonacci weights +** in reverse order (the largest fibonacci weight occurs on the first element +** of the sequence being summed.) The s1 value spans all 32-bit +** terms of the sequence whereas s0 omits the final term. +** +** On a checkpoint, the WAL is first VFS.xSync-ed, then valid content of the +** WAL is transferred into the database, then the database is VFS.xSync-ed. +** The VFS.xSync operations serve as write barriers - all writes launched +** before the xSync must complete before any write that launches after the +** xSync begins. +** +** After each checkpoint, the salt-1 value is incremented and the salt-2 +** value is randomized. This prevents old and new frames in the WAL from +** being considered valid at the same time and being checkpointing together +** following a crash. +** +** READER ALGORITHM +** +** To read a page from the database (call it page number P), a reader +** first checks the WAL to see if it contains page P. If so, then the +** last valid instance of page P that is a followed by a commit frame +** or is a commit frame itself becomes the value read. If the WAL +** contains no copies of page P that are valid and which are a commit +** frame or are followed by a commit frame, then page P is read from +** the database file. +** +** To start a read transaction, the reader records the index of the last +** valid frame in the WAL. The reader uses this recorded "mxFrame" value +** for all subsequent read operations. New transactions can be appended +** to the WAL, but as long as the reader uses its original mxFrame value +** and ignores the newly appended content, it will see a consistent snapshot +** of the database from a single point in time. This technique allows +** multiple concurrent readers to view different versions of the database +** content simultaneously. +** +** The reader algorithm in the previous paragraphs works correctly, but +** because frames for page P can appear anywhere within the WAL, the +** reader has to scan the entire WAL looking for page P frames. If the +** WAL is large (multiple megabytes is typical) that scan can be slow, +** and read performance suffers. To overcome this problem, a separate +** data structure called the wal-index is maintained to expedite the +** search for frames of a particular page. +** +** WAL-INDEX FORMAT +** +** Conceptually, the wal-index is shared memory, though VFS implementations +** might choose to implement the wal-index using a mmapped file. Because +** the wal-index is shared memory, SQLite does not support journal_mode=WAL +** on a network filesystem. All users of the database must be able to +** share memory. +** +** In the default unix and windows implementation, the wal-index is a mmapped +** file whose name is the database name with a "-shm" suffix added. For that +** reason, the wal-index is sometimes called the "shm" file. +** +** The wal-index is transient. After a crash, the wal-index can (and should +** be) reconstructed from the original WAL file. In fact, the VFS is required +** to either truncate or zero the header of the wal-index when the last +** connection to it closes. Because the wal-index is transient, it can +** use an architecture-specific format; it does not have to be cross-platform. +** Hence, unlike the database and WAL file formats which store all values +** as big endian, the wal-index can store multi-byte values in the native +** byte order of the host computer. +** +** The purpose of the wal-index is to answer this question quickly: Given +** a page number P and a maximum frame index M, return the index of the +** last frame in the wal before frame M for page P in the WAL, or return +** NULL if there are no frames for page P in the WAL prior to M. +** +** The wal-index consists of a header region, followed by an one or +** more index blocks. +** +** The wal-index header contains the total number of frames within the WAL +** in the mxFrame field. +** +** Each index block except for the first contains information on +** HASHTABLE_NPAGE frames. The first index block contains information on +** HASHTABLE_NPAGE_ONE frames. The values of HASHTABLE_NPAGE_ONE and +** HASHTABLE_NPAGE are selected so that together the wal-index header and +** first index block are the same size as all other index blocks in the +** wal-index. The values are: +** +** HASHTABLE_NPAGE 4096 +** HASHTABLE_NPAGE_ONE 4062 +** +** Each index block contains two sections, a page-mapping that contains the +** database page number associated with each wal frame, and a hash-table +** that allows readers to query an index block for a specific page number. +** The page-mapping is an array of HASHTABLE_NPAGE (or HASHTABLE_NPAGE_ONE +** for the first index block) 32-bit page numbers. The first entry in the +** first index-block contains the database page number corresponding to the +** first frame in the WAL file. The first entry in the second index block +** in the WAL file corresponds to the (HASHTABLE_NPAGE_ONE+1)th frame in +** the log, and so on. +** +** The last index block in a wal-index usually contains less than the full +** complement of HASHTABLE_NPAGE (or HASHTABLE_NPAGE_ONE) page-numbers, +** depending on the contents of the WAL file. This does not change the +** allocated size of the page-mapping array - the page-mapping array merely +** contains unused entries. +** +** Even without using the hash table, the last frame for page P +** can be found by scanning the page-mapping sections of each index block +** starting with the last index block and moving toward the first, and +** within each index block, starting at the end and moving toward the +** beginning. The first entry that equals P corresponds to the frame +** holding the content for that page. +** +** The hash table consists of HASHTABLE_NSLOT 16-bit unsigned integers. +** HASHTABLE_NSLOT = 2*HASHTABLE_NPAGE, and there is one entry in the +** hash table for each page number in the mapping section, so the hash +** table is never more than half full. The expected number of collisions +** prior to finding a match is 1. Each entry of the hash table is an +** 1-based index of an entry in the mapping section of the same +** index block. Let K be the 1-based index of the largest entry in +** the mapping section. (For index blocks other than the last, K will +** always be exactly HASHTABLE_NPAGE (4096) and for the last index block +** K will be (mxFrame%HASHTABLE_NPAGE).) Unused slots of the hash table +** contain a value of 0. +** +** To look for page P in the hash table, first compute a hash iKey on +** P as follows: +** +** iKey = (P * 383) % HASHTABLE_NSLOT +** +** Then start scanning entries of the hash table, starting with iKey +** (wrapping around to the beginning when the end of the hash table is +** reached) until an unused hash slot is found. Let the first unused slot +** be at index iUnused. (iUnused might be less than iKey if there was +** wrap-around.) Because the hash table is never more than half full, +** the search is guaranteed to eventually hit an unused entry. Let +** iMax be the value between iKey and iUnused, closest to iUnused, +** where aHash[iMax]==P. If there is no iMax entry (if there exists +** no hash slot such that aHash[i]==p) then page P is not in the +** current index block. Otherwise the iMax-th mapping entry of the +** current index block corresponds to the last entry that references +** page P. +** +** A hash search begins with the last index block and moves toward the +** first index block, looking for entries corresponding to page P. On +** average, only two or three slots in each index block need to be +** examined in order to either find the last entry for page P, or to +** establish that no such entry exists in the block. Each index block +** holds over 4000 entries. So two or three index blocks are sufficient +** to cover a typical 10 megabyte WAL file, assuming 1K pages. 8 or 10 +** comparisons (on average) suffice to either locate a frame in the +** WAL or to establish that the frame does not exist in the WAL. This +** is much faster than scanning the entire 10MB WAL. +** +** Note that entries are added in order of increasing K. Hence, one +** reader might be using some value K0 and a second reader that started +** at a later time (after additional transactions were added to the WAL +** and to the wal-index) might be using a different value K1, where K1>K0. +** Both readers can use the same hash table and mapping section to get +** the correct result. There may be entries in the hash table with +** K>K0 but to the first reader, those entries will appear to be unused +** slots in the hash table and so the first reader will get an answer as +** if no values greater than K0 had ever been inserted into the hash table +** in the first place - which is what reader one wants. Meanwhile, the +** second reader using K1 will see additional values that were inserted +** later, which is exactly what reader two wants. +** +** When a rollback occurs, the value of K is decreased. Hash table entries +** that correspond to frames greater than the new K value are removed +** from the hash table at this point. +*/ +#ifndef SQLITE_OMIT_WAL + +/* #include "wal.h" */ + +/* +** Trace output macros +*/ +#if defined(SQLITE_TEST) && defined(SQLITE_DEBUG) +SQLITE_PRIVATE int sqlite3WalTrace = 0; +# define WALTRACE(X) if(sqlite3WalTrace) sqlite3DebugPrintf X +#else +# define WALTRACE(X) +#endif + +/* +** The maximum (and only) versions of the wal and wal-index formats +** that may be interpreted by this version of SQLite. +** +** If a client begins recovering a WAL file and finds that (a) the checksum +** values in the wal-header are correct and (b) the version field is not +** WAL_MAX_VERSION, recovery fails and SQLite returns SQLITE_CANTOPEN. +** +** Similarly, if a client successfully reads a wal-index header (i.e. the +** checksum test is successful) and finds that the version field is not +** WALINDEX_MAX_VERSION, then no read-transaction is opened and SQLite +** returns SQLITE_CANTOPEN. +*/ +#define WAL_MAX_VERSION 3007000 +#define WALINDEX_MAX_VERSION 3007000 + +/* +** Index numbers for various locking bytes. WAL_NREADER is the number +** of available reader locks and should be at least 3. The default +** is SQLITE_SHM_NLOCK==8 and WAL_NREADER==5. +** +** Technically, the various VFSes are free to implement these locks however +** they see fit. However, compatibility is encouraged so that VFSes can +** interoperate. The standard implemention used on both unix and windows +** is for the index number to indicate a byte offset into the +** WalCkptInfo.aLock[] array in the wal-index header. In other words, all +** locks are on the shm file. The WALINDEX_LOCK_OFFSET constant (which +** should be 120) is the location in the shm file for the first locking +** byte. +*/ +#define WAL_WRITE_LOCK 0 +#define WAL_ALL_BUT_WRITE 1 +#define WAL_CKPT_LOCK 1 +#define WAL_RECOVER_LOCK 2 +#define WAL_READ_LOCK(I) (3+(I)) +#define WAL_NREADER (SQLITE_SHM_NLOCK-3) + + +/* Object declarations */ +typedef struct WalIndexHdr WalIndexHdr; +typedef struct WalIterator WalIterator; +typedef struct WalCkptInfo WalCkptInfo; + + +/* +** The following object holds a copy of the wal-index header content. +** +** The actual header in the wal-index consists of two copies of this +** object followed by one instance of the WalCkptInfo object. +** For all versions of SQLite through 3.10.0 and probably beyond, +** the locking bytes (WalCkptInfo.aLock) start at offset 120 and +** the total header size is 136 bytes. +** +** The szPage value can be any power of 2 between 512 and 32768, inclusive. +** Or it can be 1 to represent a 65536-byte page. The latter case was +** added in 3.7.1 when support for 64K pages was added. +*/ +struct WalIndexHdr { + u32 iVersion; /* Wal-index version */ + u32 unused; /* Unused (padding) field */ + u32 iChange; /* Counter incremented each transaction */ + u8 isInit; /* 1 when initialized */ + u8 bigEndCksum; /* True if checksums in WAL are big-endian */ + u16 szPage; /* Database page size in bytes. 1==64K */ + u32 mxFrame; /* Index of last valid frame in the WAL */ + u32 nPage; /* Size of database in pages */ + u32 aFrameCksum[2]; /* Checksum of last frame in log */ + u32 aSalt[2]; /* Two salt values copied from WAL header */ + u32 aCksum[2]; /* Checksum over all prior fields */ +}; + +/* +** A copy of the following object occurs in the wal-index immediately +** following the second copy of the WalIndexHdr. This object stores +** information used by checkpoint. +** +** nBackfill is the number of frames in the WAL that have been written +** back into the database. (We call the act of moving content from WAL to +** database "backfilling".) The nBackfill number is never greater than +** WalIndexHdr.mxFrame. nBackfill can only be increased by threads +** holding the WAL_CKPT_LOCK lock (which includes a recovery thread). +** However, a WAL_WRITE_LOCK thread can move the value of nBackfill from +** mxFrame back to zero when the WAL is reset. +** +** nBackfillAttempted is the largest value of nBackfill that a checkpoint +** has attempted to achieve. Normally nBackfill==nBackfillAtempted, however +** the nBackfillAttempted is set before any backfilling is done and the +** nBackfill is only set after all backfilling completes. So if a checkpoint +** crashes, nBackfillAttempted might be larger than nBackfill. The +** WalIndexHdr.mxFrame must never be less than nBackfillAttempted. +** +** The aLock[] field is a set of bytes used for locking. These bytes should +** never be read or written. +** +** There is one entry in aReadMark[] for each reader lock. If a reader +** holds read-lock K, then the value in aReadMark[K] is no greater than +** the mxFrame for that reader. The value READMARK_NOT_USED (0xffffffff) +** for any aReadMark[] means that entry is unused. aReadMark[0] is +** a special case; its value is never used and it exists as a place-holder +** to avoid having to offset aReadMark[] indexs by one. Readers holding +** WAL_READ_LOCK(0) always ignore the entire WAL and read all content +** directly from the database. +** +** The value of aReadMark[K] may only be changed by a thread that +** is holding an exclusive lock on WAL_READ_LOCK(K). Thus, the value of +** aReadMark[K] cannot changed while there is a reader is using that mark +** since the reader will be holding a shared lock on WAL_READ_LOCK(K). +** +** The checkpointer may only transfer frames from WAL to database where +** the frame numbers are less than or equal to every aReadMark[] that is +** in use (that is, every aReadMark[j] for which there is a corresponding +** WAL_READ_LOCK(j)). New readers (usually) pick the aReadMark[] with the +** largest value and will increase an unused aReadMark[] to mxFrame if there +** is not already an aReadMark[] equal to mxFrame. The exception to the +** previous sentence is when nBackfill equals mxFrame (meaning that everything +** in the WAL has been backfilled into the database) then new readers +** will choose aReadMark[0] which has value 0 and hence such reader will +** get all their all content directly from the database file and ignore +** the WAL. +** +** Writers normally append new frames to the end of the WAL. However, +** if nBackfill equals mxFrame (meaning that all WAL content has been +** written back into the database) and if no readers are using the WAL +** (in other words, if there are no WAL_READ_LOCK(i) where i>0) then +** the writer will first "reset" the WAL back to the beginning and start +** writing new content beginning at frame 1. +** +** We assume that 32-bit loads are atomic and so no locks are needed in +** order to read from any aReadMark[] entries. +*/ +struct WalCkptInfo { + u32 nBackfill; /* Number of WAL frames backfilled into DB */ + u32 aReadMark[WAL_NREADER]; /* Reader marks */ + u8 aLock[SQLITE_SHM_NLOCK]; /* Reserved space for locks */ + u32 nBackfillAttempted; /* WAL frames perhaps written, or maybe not */ + u32 notUsed0; /* Available for future enhancements */ +}; +#define READMARK_NOT_USED 0xffffffff + +/* +** This is a schematic view of the complete 136-byte header of the +** wal-index file (also known as the -shm file): +** +** +-----------------------------+ +** 0: | iVersion | \ +** +-----------------------------+ | +** 4: | (unused padding) | | +** +-----------------------------+ | +** 8: | iChange | | +** +-------+-------+-------------+ | +** 12: | bInit | bBig | szPage | | +** +-------+-------+-------------+ | +** 16: | mxFrame | | First copy of the +** +-----------------------------+ | WalIndexHdr object +** 20: | nPage | | +** +-----------------------------+ | +** 24: | aFrameCksum | | +** | | | +** +-----------------------------+ | +** 32: | aSalt | | +** | | | +** +-----------------------------+ | +** 40: | aCksum | | +** | | / +** +-----------------------------+ +** 48: | iVersion | \ +** +-----------------------------+ | +** 52: | (unused padding) | | +** +-----------------------------+ | +** 56: | iChange | | +** +-------+-------+-------------+ | +** 60: | bInit | bBig | szPage | | +** +-------+-------+-------------+ | Second copy of the +** 64: | mxFrame | | WalIndexHdr +** +-----------------------------+ | +** 68: | nPage | | +** +-----------------------------+ | +** 72: | aFrameCksum | | +** | | | +** +-----------------------------+ | +** 80: | aSalt | | +** | | | +** +-----------------------------+ | +** 88: | aCksum | | +** | | / +** +-----------------------------+ +** 96: | nBackfill | +** +-----------------------------+ +** 100: | 5 read marks | +** | | +** | | +** | | +** | | +** +-------+-------+------+------+ +** 120: | Write | Ckpt | Rcvr | Rd0 | \ +** +-------+-------+------+------+ ) 8 lock bytes +** | Read1 | Read2 | Rd3 | Rd4 | / +** +-------+-------+------+------+ +** 128: | nBackfillAttempted | +** +-----------------------------+ +** 132: | (unused padding) | +** +-----------------------------+ +*/ + +/* A block of WALINDEX_LOCK_RESERVED bytes beginning at +** WALINDEX_LOCK_OFFSET is reserved for locks. Since some systems +** only support mandatory file-locks, we do not read or write data +** from the region of the file on which locks are applied. +*/ +#define WALINDEX_LOCK_OFFSET (sizeof(WalIndexHdr)*2+offsetof(WalCkptInfo,aLock)) +#define WALINDEX_HDR_SIZE (sizeof(WalIndexHdr)*2+sizeof(WalCkptInfo)) + +/* Size of header before each frame in wal */ +#define WAL_FRAME_HDRSIZE 24 + +/* Size of write ahead log header, including checksum. */ +#define WAL_HDRSIZE 32 + +/* WAL magic value. Either this value, or the same value with the least +** significant bit also set (WAL_MAGIC | 0x00000001) is stored in 32-bit +** big-endian format in the first 4 bytes of a WAL file. +** +** If the LSB is set, then the checksums for each frame within the WAL +** file are calculated by treating all data as an array of 32-bit +** big-endian words. Otherwise, they are calculated by interpreting +** all data as 32-bit little-endian words. +*/ +#define WAL_MAGIC 0x377f0682 + +/* +** Return the offset of frame iFrame in the write-ahead log file, +** assuming a database page size of szPage bytes. The offset returned +** is to the start of the write-ahead log frame-header. +*/ +#define walFrameOffset(iFrame, szPage) ( \ + WAL_HDRSIZE + ((iFrame)-1)*(i64)((szPage)+WAL_FRAME_HDRSIZE) \ +) + +/* +** An open write-ahead log file is represented by an instance of the +** following object. +*/ +struct Wal { + sqlite3_vfs *pVfs; /* The VFS used to create pDbFd */ + sqlite3_file *pDbFd; /* File handle for the database file */ + sqlite3_file *pWalFd; /* File handle for WAL file */ + u32 iCallback; /* Value to pass to log callback (or 0) */ + i64 mxWalSize; /* Truncate WAL to this size upon reset */ + int nWiData; /* Size of array apWiData */ + int szFirstBlock; /* Size of first block written to WAL file */ + volatile u32 **apWiData; /* Pointer to wal-index content in memory */ + u32 szPage; /* Database page size */ + i16 readLock; /* Which read lock is being held. -1 for none */ + u8 syncFlags; /* Flags to use to sync header writes */ + u8 exclusiveMode; /* Non-zero if connection is in exclusive mode */ + u8 writeLock; /* True if in a write transaction */ + u8 ckptLock; /* True if holding a checkpoint lock */ + u8 readOnly; /* WAL_RDWR, WAL_RDONLY, or WAL_SHM_RDONLY */ + u8 truncateOnCommit; /* True to truncate WAL file on commit */ + u8 syncHeader; /* Fsync the WAL header if true */ + u8 padToSectorBoundary; /* Pad transactions out to the next sector */ + u8 bShmUnreliable; /* SHM content is read-only and unreliable */ + WalIndexHdr hdr; /* Wal-index header for current transaction */ + u32 minFrame; /* Ignore wal frames before this one */ + u32 iReCksum; /* On commit, recalculate checksums from here */ + const char *zWalName; /* Name of WAL file */ + u32 nCkpt; /* Checkpoint sequence counter in the wal-header */ +#ifdef SQLITE_DEBUG + u8 lockError; /* True if a locking error has occurred */ +#endif +#ifdef SQLITE_ENABLE_SNAPSHOT + WalIndexHdr *pSnapshot; /* Start transaction here if not NULL */ +#endif +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT + sqlite3 *db; +#endif +}; + +/* +** Candidate values for Wal.exclusiveMode. +*/ +#define WAL_NORMAL_MODE 0 +#define WAL_EXCLUSIVE_MODE 1 +#define WAL_HEAPMEMORY_MODE 2 + +/* +** Possible values for WAL.readOnly +*/ +#define WAL_RDWR 0 /* Normal read/write connection */ +#define WAL_RDONLY 1 /* The WAL file is readonly */ +#define WAL_SHM_RDONLY 2 /* The SHM file is readonly */ + +/* +** Each page of the wal-index mapping contains a hash-table made up of +** an array of HASHTABLE_NSLOT elements of the following type. +*/ +typedef u16 ht_slot; + +/* +** This structure is used to implement an iterator that loops through +** all frames in the WAL in database page order. Where two or more frames +** correspond to the same database page, the iterator visits only the +** frame most recently written to the WAL (in other words, the frame with +** the largest index). +** +** The internals of this structure are only accessed by: +** +** walIteratorInit() - Create a new iterator, +** walIteratorNext() - Step an iterator, +** walIteratorFree() - Free an iterator. +** +** This functionality is used by the checkpoint code (see walCheckpoint()). +*/ +struct WalIterator { + u32 iPrior; /* Last result returned from the iterator */ + int nSegment; /* Number of entries in aSegment[] */ + struct WalSegment { + int iNext; /* Next slot in aIndex[] not yet returned */ + ht_slot *aIndex; /* i0, i1, i2... such that aPgno[iN] ascend */ + u32 *aPgno; /* Array of page numbers. */ + int nEntry; /* Nr. of entries in aPgno[] and aIndex[] */ + int iZero; /* Frame number associated with aPgno[0] */ + } aSegment[1]; /* One for every 32KB page in the wal-index */ +}; + +/* +** Define the parameters of the hash tables in the wal-index file. There +** is a hash-table following every HASHTABLE_NPAGE page numbers in the +** wal-index. +** +** Changing any of these constants will alter the wal-index format and +** create incompatibilities. +*/ +#define HASHTABLE_NPAGE 4096 /* Must be power of 2 */ +#define HASHTABLE_HASH_1 383 /* Should be prime */ +#define HASHTABLE_NSLOT (HASHTABLE_NPAGE*2) /* Must be a power of 2 */ + +/* +** The block of page numbers associated with the first hash-table in a +** wal-index is smaller than usual. This is so that there is a complete +** hash-table on each aligned 32KB page of the wal-index. +*/ +#define HASHTABLE_NPAGE_ONE (HASHTABLE_NPAGE - (WALINDEX_HDR_SIZE/sizeof(u32))) + +/* The wal-index is divided into pages of WALINDEX_PGSZ bytes each. */ +#define WALINDEX_PGSZ ( \ + sizeof(ht_slot)*HASHTABLE_NSLOT + HASHTABLE_NPAGE*sizeof(u32) \ +) + +/* +** Obtain a pointer to the iPage'th page of the wal-index. The wal-index +** is broken into pages of WALINDEX_PGSZ bytes. Wal-index pages are +** numbered from zero. +** +** If the wal-index is currently smaller the iPage pages then the size +** of the wal-index might be increased, but only if it is safe to do +** so. It is safe to enlarge the wal-index if pWal->writeLock is true +** or pWal->exclusiveMode==WAL_HEAPMEMORY_MODE. +** +** Three possible result scenarios: +** +** (1) rc==SQLITE_OK and *ppPage==Requested-Wal-Index-Page +** (2) rc>=SQLITE_ERROR and *ppPage==NULL +** (3) rc==SQLITE_OK and *ppPage==NULL // only if iPage==0 +** +** Scenario (3) can only occur when pWal->writeLock is false and iPage==0 +*/ +static SQLITE_NOINLINE int walIndexPageRealloc( + Wal *pWal, /* The WAL context */ + int iPage, /* The page we seek */ + volatile u32 **ppPage /* Write the page pointer here */ +){ + int rc = SQLITE_OK; + + /* Enlarge the pWal->apWiData[] array if required */ + if( pWal->nWiData<=iPage ){ + sqlite3_int64 nByte = sizeof(u32*)*(iPage+1); + volatile u32 **apNew; + apNew = (volatile u32 **)sqlite3Realloc((void *)pWal->apWiData, nByte); + if( !apNew ){ + *ppPage = 0; + return SQLITE_NOMEM_BKPT; + } + memset((void*)&apNew[pWal->nWiData], 0, + sizeof(u32*)*(iPage+1-pWal->nWiData)); + pWal->apWiData = apNew; + pWal->nWiData = iPage+1; + } + + /* Request a pointer to the required page from the VFS */ + assert( pWal->apWiData[iPage]==0 ); + if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE ){ + pWal->apWiData[iPage] = (u32 volatile *)sqlite3MallocZero(WALINDEX_PGSZ); + if( !pWal->apWiData[iPage] ) rc = SQLITE_NOMEM_BKPT; + }else{ + rc = sqlite3OsShmMap(pWal->pDbFd, iPage, WALINDEX_PGSZ, + pWal->writeLock, (void volatile **)&pWal->apWiData[iPage] + ); + assert( pWal->apWiData[iPage]!=0 + || rc!=SQLITE_OK + || (pWal->writeLock==0 && iPage==0) ); + testcase( pWal->apWiData[iPage]==0 && rc==SQLITE_OK ); + if( rc==SQLITE_OK ){ + if( iPage>0 && sqlite3FaultSim(600) ) rc = SQLITE_NOMEM; + }else if( (rc&0xff)==SQLITE_READONLY ){ + pWal->readOnly |= WAL_SHM_RDONLY; + if( rc==SQLITE_READONLY ){ + rc = SQLITE_OK; + } + } + } + + *ppPage = pWal->apWiData[iPage]; + assert( iPage==0 || *ppPage || rc!=SQLITE_OK ); + return rc; +} +static int walIndexPage( + Wal *pWal, /* The WAL context */ + int iPage, /* The page we seek */ + volatile u32 **ppPage /* Write the page pointer here */ +){ + if( pWal->nWiData<=iPage || (*ppPage = pWal->apWiData[iPage])==0 ){ + return walIndexPageRealloc(pWal, iPage, ppPage); + } + return SQLITE_OK; +} + +/* +** Return a pointer to the WalCkptInfo structure in the wal-index. +*/ +static volatile WalCkptInfo *walCkptInfo(Wal *pWal){ + assert( pWal->nWiData>0 && pWal->apWiData[0] ); + return (volatile WalCkptInfo*)&(pWal->apWiData[0][sizeof(WalIndexHdr)/2]); +} + +/* +** Return a pointer to the WalIndexHdr structure in the wal-index. +*/ +static volatile WalIndexHdr *walIndexHdr(Wal *pWal){ + assert( pWal->nWiData>0 && pWal->apWiData[0] ); + return (volatile WalIndexHdr*)pWal->apWiData[0]; +} + +/* +** The argument to this macro must be of type u32. On a little-endian +** architecture, it returns the u32 value that results from interpreting +** the 4 bytes as a big-endian value. On a big-endian architecture, it +** returns the value that would be produced by interpreting the 4 bytes +** of the input value as a little-endian integer. +*/ +#define BYTESWAP32(x) ( \ + (((x)&0x000000FF)<<24) + (((x)&0x0000FF00)<<8) \ + + (((x)&0x00FF0000)>>8) + (((x)&0xFF000000)>>24) \ +) + +/* +** Generate or extend an 8 byte checksum based on the data in +** array aByte[] and the initial values of aIn[0] and aIn[1] (or +** initial values of 0 and 0 if aIn==NULL). +** +** The checksum is written back into aOut[] before returning. +** +** nByte must be a positive multiple of 8. +*/ +static void walChecksumBytes( + int nativeCksum, /* True for native byte-order, false for non-native */ + u8 *a, /* Content to be checksummed */ + int nByte, /* Bytes of content in a[]. Must be a multiple of 8. */ + const u32 *aIn, /* Initial checksum value input */ + u32 *aOut /* OUT: Final checksum value output */ +){ + u32 s1, s2; + u32 *aData = (u32 *)a; + u32 *aEnd = (u32 *)&a[nByte]; + + if( aIn ){ + s1 = aIn[0]; + s2 = aIn[1]; + }else{ + s1 = s2 = 0; + } + + assert( nByte>=8 ); + assert( (nByte&0x00000007)==0 ); + assert( nByte<=65536 ); + assert( nByte%4==0 ); + + if( !nativeCksum ){ + do { + s1 += BYTESWAP32(aData[0]) + s2; + s2 += BYTESWAP32(aData[1]) + s1; + aData += 2; + }while( aDataexclusiveMode!=WAL_HEAPMEMORY_MODE ){ + sqlite3OsShmBarrier(pWal->pDbFd); + } +} + +/* +** Add the SQLITE_NO_TSAN as part of the return-type of a function +** definition as a hint that the function contains constructs that +** might give false-positive TSAN warnings. +** +** See tag-20200519-1. +*/ +#if defined(__clang__) && !defined(SQLITE_NO_TSAN) +# define SQLITE_NO_TSAN __attribute__((no_sanitize_thread)) +#else +# define SQLITE_NO_TSAN +#endif + +/* +** Write the header information in pWal->hdr into the wal-index. +** +** The checksum on pWal->hdr is updated before it is written. +*/ +static SQLITE_NO_TSAN void walIndexWriteHdr(Wal *pWal){ + volatile WalIndexHdr *aHdr = walIndexHdr(pWal); + const int nCksum = offsetof(WalIndexHdr, aCksum); + + assert( pWal->writeLock ); + pWal->hdr.isInit = 1; + pWal->hdr.iVersion = WALINDEX_MAX_VERSION; + walChecksumBytes(1, (u8*)&pWal->hdr, nCksum, 0, pWal->hdr.aCksum); + /* Possible TSAN false-positive. See tag-20200519-1 */ + memcpy((void*)&aHdr[1], (const void*)&pWal->hdr, sizeof(WalIndexHdr)); + walShmBarrier(pWal); + memcpy((void*)&aHdr[0], (const void*)&pWal->hdr, sizeof(WalIndexHdr)); +} + +/* +** This function encodes a single frame header and writes it to a buffer +** supplied by the caller. A frame-header is made up of a series of +** 4-byte big-endian integers, as follows: +** +** 0: Page number. +** 4: For commit records, the size of the database image in pages +** after the commit. For all other records, zero. +** 8: Salt-1 (copied from the wal-header) +** 12: Salt-2 (copied from the wal-header) +** 16: Checksum-1. +** 20: Checksum-2. +*/ +static void walEncodeFrame( + Wal *pWal, /* The write-ahead log */ + u32 iPage, /* Database page number for frame */ + u32 nTruncate, /* New db size (or 0 for non-commit frames) */ + u8 *aData, /* Pointer to page data */ + u8 *aFrame /* OUT: Write encoded frame here */ +){ + int nativeCksum; /* True for native byte-order checksums */ + u32 *aCksum = pWal->hdr.aFrameCksum; + assert( WAL_FRAME_HDRSIZE==24 ); + sqlite3Put4byte(&aFrame[0], iPage); + sqlite3Put4byte(&aFrame[4], nTruncate); + if( pWal->iReCksum==0 ){ + memcpy(&aFrame[8], pWal->hdr.aSalt, 8); + + nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN); + walChecksumBytes(nativeCksum, aFrame, 8, aCksum, aCksum); + walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum); + + sqlite3Put4byte(&aFrame[16], aCksum[0]); + sqlite3Put4byte(&aFrame[20], aCksum[1]); + }else{ + memset(&aFrame[8], 0, 16); + } +} + +/* +** Check to see if the frame with header in aFrame[] and content +** in aData[] is valid. If it is a valid frame, fill *piPage and +** *pnTruncate and return true. Return if the frame is not valid. +*/ +static int walDecodeFrame( + Wal *pWal, /* The write-ahead log */ + u32 *piPage, /* OUT: Database page number for frame */ + u32 *pnTruncate, /* OUT: New db size (or 0 if not commit) */ + u8 *aData, /* Pointer to page data (for checksum) */ + u8 *aFrame /* Frame data */ +){ + int nativeCksum; /* True for native byte-order checksums */ + u32 *aCksum = pWal->hdr.aFrameCksum; + u32 pgno; /* Page number of the frame */ + assert( WAL_FRAME_HDRSIZE==24 ); + + /* A frame is only valid if the salt values in the frame-header + ** match the salt values in the wal-header. + */ + if( memcmp(&pWal->hdr.aSalt, &aFrame[8], 8)!=0 ){ + return 0; + } + + /* A frame is only valid if the page number is creater than zero. + */ + pgno = sqlite3Get4byte(&aFrame[0]); + if( pgno==0 ){ + return 0; + } + + /* A frame is only valid if a checksum of the WAL header, + ** all prior frams, the first 16 bytes of this frame-header, + ** and the frame-data matches the checksum in the last 8 + ** bytes of this frame-header. + */ + nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN); + walChecksumBytes(nativeCksum, aFrame, 8, aCksum, aCksum); + walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum); + if( aCksum[0]!=sqlite3Get4byte(&aFrame[16]) + || aCksum[1]!=sqlite3Get4byte(&aFrame[20]) + ){ + /* Checksum failed. */ + return 0; + } + + /* If we reach this point, the frame is valid. Return the page number + ** and the new database size. + */ + *piPage = pgno; + *pnTruncate = sqlite3Get4byte(&aFrame[4]); + return 1; +} + + +#if defined(SQLITE_TEST) && defined(SQLITE_DEBUG) +/* +** Names of locks. This routine is used to provide debugging output and is not +** a part of an ordinary build. +*/ +static const char *walLockName(int lockIdx){ + if( lockIdx==WAL_WRITE_LOCK ){ + return "WRITE-LOCK"; + }else if( lockIdx==WAL_CKPT_LOCK ){ + return "CKPT-LOCK"; + }else if( lockIdx==WAL_RECOVER_LOCK ){ + return "RECOVER-LOCK"; + }else{ + static char zName[15]; + sqlite3_snprintf(sizeof(zName), zName, "READ-LOCK[%d]", + lockIdx-WAL_READ_LOCK(0)); + return zName; + } +} +#endif /*defined(SQLITE_TEST) || defined(SQLITE_DEBUG) */ + + +/* +** Set or release locks on the WAL. Locks are either shared or exclusive. +** A lock cannot be moved directly between shared and exclusive - it must go +** through the unlocked state first. +** +** In locking_mode=EXCLUSIVE, all of these routines become no-ops. +*/ +static int walLockShared(Wal *pWal, int lockIdx){ + int rc; + if( pWal->exclusiveMode ) return SQLITE_OK; + rc = sqlite3OsShmLock(pWal->pDbFd, lockIdx, 1, + SQLITE_SHM_LOCK | SQLITE_SHM_SHARED); + WALTRACE(("WAL%p: acquire SHARED-%s %s\n", pWal, + walLockName(lockIdx), rc ? "failed" : "ok")); + VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && (rc&0xFF)!=SQLITE_BUSY); ) + return rc; +} +static void walUnlockShared(Wal *pWal, int lockIdx){ + if( pWal->exclusiveMode ) return; + (void)sqlite3OsShmLock(pWal->pDbFd, lockIdx, 1, + SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED); + WALTRACE(("WAL%p: release SHARED-%s\n", pWal, walLockName(lockIdx))); +} +static int walLockExclusive(Wal *pWal, int lockIdx, int n){ + int rc; + if( pWal->exclusiveMode ) return SQLITE_OK; + rc = sqlite3OsShmLock(pWal->pDbFd, lockIdx, n, + SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE); + WALTRACE(("WAL%p: acquire EXCLUSIVE-%s cnt=%d %s\n", pWal, + walLockName(lockIdx), n, rc ? "failed" : "ok")); + VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && (rc&0xFF)!=SQLITE_BUSY); ) + return rc; +} +static void walUnlockExclusive(Wal *pWal, int lockIdx, int n){ + if( pWal->exclusiveMode ) return; + (void)sqlite3OsShmLock(pWal->pDbFd, lockIdx, n, + SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE); + WALTRACE(("WAL%p: release EXCLUSIVE-%s cnt=%d\n", pWal, + walLockName(lockIdx), n)); +} + +/* +** Compute a hash on a page number. The resulting hash value must land +** between 0 and (HASHTABLE_NSLOT-1). The walHashNext() function advances +** the hash to the next value in the event of a collision. +*/ +static int walHash(u32 iPage){ + assert( iPage>0 ); + assert( (HASHTABLE_NSLOT & (HASHTABLE_NSLOT-1))==0 ); + return (iPage*HASHTABLE_HASH_1) & (HASHTABLE_NSLOT-1); +} +static int walNextHash(int iPriorHash){ + return (iPriorHash+1)&(HASHTABLE_NSLOT-1); +} + +/* +** An instance of the WalHashLoc object is used to describe the location +** of a page hash table in the wal-index. This becomes the return value +** from walHashGet(). +*/ +typedef struct WalHashLoc WalHashLoc; +struct WalHashLoc { + volatile ht_slot *aHash; /* Start of the wal-index hash table */ + volatile u32 *aPgno; /* aPgno[1] is the page of first frame indexed */ + u32 iZero; /* One less than the frame number of first indexed*/ +}; + +/* +** Return pointers to the hash table and page number array stored on +** page iHash of the wal-index. The wal-index is broken into 32KB pages +** numbered starting from 0. +** +** Set output variable pLoc->aHash to point to the start of the hash table +** in the wal-index file. Set pLoc->iZero to one less than the frame +** number of the first frame indexed by this hash table. If a +** slot in the hash table is set to N, it refers to frame number +** (pLoc->iZero+N) in the log. +** +** Finally, set pLoc->aPgno so that pLoc->aPgno[0] is the page number of the +** first frame indexed by the hash table, frame (pLoc->iZero). +*/ +static int walHashGet( + Wal *pWal, /* WAL handle */ + int iHash, /* Find the iHash'th table */ + WalHashLoc *pLoc /* OUT: Hash table location */ +){ + int rc; /* Return code */ + + rc = walIndexPage(pWal, iHash, &pLoc->aPgno); + assert( rc==SQLITE_OK || iHash>0 ); + + if( pLoc->aPgno ){ + pLoc->aHash = (volatile ht_slot *)&pLoc->aPgno[HASHTABLE_NPAGE]; + if( iHash==0 ){ + pLoc->aPgno = &pLoc->aPgno[WALINDEX_HDR_SIZE/sizeof(u32)]; + pLoc->iZero = 0; + }else{ + pLoc->iZero = HASHTABLE_NPAGE_ONE + (iHash-1)*HASHTABLE_NPAGE; + } + }else if( NEVER(rc==SQLITE_OK) ){ + rc = SQLITE_ERROR; + } + return rc; +} + +/* +** Return the number of the wal-index page that contains the hash-table +** and page-number array that contain entries corresponding to WAL frame +** iFrame. The wal-index is broken up into 32KB pages. Wal-index pages +** are numbered starting from 0. +*/ +static int walFramePage(u32 iFrame){ + int iHash = (iFrame+HASHTABLE_NPAGE-HASHTABLE_NPAGE_ONE-1) / HASHTABLE_NPAGE; + assert( (iHash==0 || iFrame>HASHTABLE_NPAGE_ONE) + && (iHash>=1 || iFrame<=HASHTABLE_NPAGE_ONE) + && (iHash<=1 || iFrame>(HASHTABLE_NPAGE_ONE+HASHTABLE_NPAGE)) + && (iHash>=2 || iFrame<=HASHTABLE_NPAGE_ONE+HASHTABLE_NPAGE) + && (iHash<=2 || iFrame>(HASHTABLE_NPAGE_ONE+2*HASHTABLE_NPAGE)) + ); + assert( iHash>=0 ); + return iHash; +} + +/* +** Return the page number associated with frame iFrame in this WAL. +*/ +static u32 walFramePgno(Wal *pWal, u32 iFrame){ + int iHash = walFramePage(iFrame); + if( iHash==0 ){ + return pWal->apWiData[0][WALINDEX_HDR_SIZE/sizeof(u32) + iFrame - 1]; + } + return pWal->apWiData[iHash][(iFrame-1-HASHTABLE_NPAGE_ONE)%HASHTABLE_NPAGE]; +} + +/* +** Remove entries from the hash table that point to WAL slots greater +** than pWal->hdr.mxFrame. +** +** This function is called whenever pWal->hdr.mxFrame is decreased due +** to a rollback or savepoint. +** +** At most only the hash table containing pWal->hdr.mxFrame needs to be +** updated. Any later hash tables will be automatically cleared when +** pWal->hdr.mxFrame advances to the point where those hash tables are +** actually needed. +*/ +static void walCleanupHash(Wal *pWal){ + WalHashLoc sLoc; /* Hash table location */ + int iLimit = 0; /* Zero values greater than this */ + int nByte; /* Number of bytes to zero in aPgno[] */ + int i; /* Used to iterate through aHash[] */ + + assert( pWal->writeLock ); + testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE-1 ); + testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE ); + testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE+1 ); + + if( pWal->hdr.mxFrame==0 ) return; + + /* Obtain pointers to the hash-table and page-number array containing + ** the entry that corresponds to frame pWal->hdr.mxFrame. It is guaranteed + ** that the page said hash-table and array reside on is already mapped.(1) + */ + assert( pWal->nWiData>walFramePage(pWal->hdr.mxFrame) ); + assert( pWal->apWiData[walFramePage(pWal->hdr.mxFrame)] ); + i = walHashGet(pWal, walFramePage(pWal->hdr.mxFrame), &sLoc); + if( NEVER(i) ) return; /* Defense-in-depth, in case (1) above is wrong */ + + /* Zero all hash-table entries that correspond to frame numbers greater + ** than pWal->hdr.mxFrame. + */ + iLimit = pWal->hdr.mxFrame - sLoc.iZero; + assert( iLimit>0 ); + for(i=0; iiLimit ){ + sLoc.aHash[i] = 0; + } + } + + /* Zero the entries in the aPgno array that correspond to frames with + ** frame numbers greater than pWal->hdr.mxFrame. + */ + nByte = (int)((char *)sLoc.aHash - (char *)&sLoc.aPgno[iLimit]); + assert( nByte>=0 ); + memset((void *)&sLoc.aPgno[iLimit], 0, nByte); + +#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT + /* Verify that the every entry in the mapping region is still reachable + ** via the hash table even after the cleanup. + */ + if( iLimit ){ + int j; /* Loop counter */ + int iKey; /* Hash key */ + for(j=0; j=0 ); + memset((void*)sLoc.aPgno, 0, nByte); + } + + /* If the entry in aPgno[] is already set, then the previous writer + ** must have exited unexpectedly in the middle of a transaction (after + ** writing one or more dirty pages to the WAL to free up memory). + ** Remove the remnants of that writers uncommitted transaction from + ** the hash-table before writing any new entries. + */ + if( sLoc.aPgno[idx-1] ){ + walCleanupHash(pWal); + assert( !sLoc.aPgno[idx-1] ); + } + + /* Write the aPgno[] array entry and the hash-table slot. */ + nCollide = idx; + for(iKey=walHash(iPage); sLoc.aHash[iKey]; iKey=walNextHash(iKey)){ + if( (nCollide--)==0 ) return SQLITE_CORRUPT_BKPT; + } + sLoc.aPgno[idx-1] = iPage; + AtomicStore(&sLoc.aHash[iKey], (ht_slot)idx); + +#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT + /* Verify that the number of entries in the hash table exactly equals + ** the number of entries in the mapping region. + */ + { + int i; /* Loop counter */ + int nEntry = 0; /* Number of entries in the hash table */ + for(i=0; ickptLock==1 || pWal->ckptLock==0 ); + assert( WAL_ALL_BUT_WRITE==WAL_WRITE_LOCK+1 ); + assert( WAL_CKPT_LOCK==WAL_ALL_BUT_WRITE ); + assert( pWal->writeLock ); + iLock = WAL_ALL_BUT_WRITE + pWal->ckptLock; + rc = walLockExclusive(pWal, iLock, WAL_READ_LOCK(0)-iLock); + if( rc ){ + return rc; + } + + WALTRACE(("WAL%p: recovery begin...\n", pWal)); + + memset(&pWal->hdr, 0, sizeof(WalIndexHdr)); + + rc = sqlite3OsFileSize(pWal->pWalFd, &nSize); + if( rc!=SQLITE_OK ){ + goto recovery_error; + } + + if( nSize>WAL_HDRSIZE ){ + u8 aBuf[WAL_HDRSIZE]; /* Buffer to load WAL header into */ + u32 *aPrivate = 0; /* Heap copy of *-shm hash being populated */ + u8 *aFrame = 0; /* Malloc'd buffer to load entire frame */ + int szFrame; /* Number of bytes in buffer aFrame[] */ + u8 *aData; /* Pointer to data part of aFrame buffer */ + int szPage; /* Page size according to the log */ + u32 magic; /* Magic value read from WAL header */ + u32 version; /* Magic value read from WAL header */ + int isValid; /* True if this frame is valid */ + u32 iPg; /* Current 32KB wal-index page */ + u32 iLastFrame; /* Last frame in wal, based on nSize alone */ + + /* Read in the WAL header. */ + rc = sqlite3OsRead(pWal->pWalFd, aBuf, WAL_HDRSIZE, 0); + if( rc!=SQLITE_OK ){ + goto recovery_error; + } + + /* If the database page size is not a power of two, or is greater than + ** SQLITE_MAX_PAGE_SIZE, conclude that the WAL file contains no valid + ** data. Similarly, if the 'magic' value is invalid, ignore the whole + ** WAL file. + */ + magic = sqlite3Get4byte(&aBuf[0]); + szPage = sqlite3Get4byte(&aBuf[8]); + if( (magic&0xFFFFFFFE)!=WAL_MAGIC + || szPage&(szPage-1) + || szPage>SQLITE_MAX_PAGE_SIZE + || szPage<512 + ){ + goto finished; + } + pWal->hdr.bigEndCksum = (u8)(magic&0x00000001); + pWal->szPage = szPage; + pWal->nCkpt = sqlite3Get4byte(&aBuf[12]); + memcpy(&pWal->hdr.aSalt, &aBuf[16], 8); + + /* Verify that the WAL header checksum is correct */ + walChecksumBytes(pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN, + aBuf, WAL_HDRSIZE-2*4, 0, pWal->hdr.aFrameCksum + ); + if( pWal->hdr.aFrameCksum[0]!=sqlite3Get4byte(&aBuf[24]) + || pWal->hdr.aFrameCksum[1]!=sqlite3Get4byte(&aBuf[28]) + ){ + goto finished; + } + + /* Verify that the version number on the WAL format is one that + ** are able to understand */ + version = sqlite3Get4byte(&aBuf[4]); + if( version!=WAL_MAX_VERSION ){ + rc = SQLITE_CANTOPEN_BKPT; + goto finished; + } + + /* Malloc a buffer to read frames into. */ + szFrame = szPage + WAL_FRAME_HDRSIZE; + aFrame = (u8 *)sqlite3_malloc64(szFrame + WALINDEX_PGSZ); + if( !aFrame ){ + rc = SQLITE_NOMEM_BKPT; + goto recovery_error; + } + aData = &aFrame[WAL_FRAME_HDRSIZE]; + aPrivate = (u32*)&aData[szPage]; + + /* Read all frames from the log file. */ + iLastFrame = (nSize - WAL_HDRSIZE) / szFrame; + for(iPg=0; iPg<=(u32)walFramePage(iLastFrame); iPg++){ + u32 *aShare; + u32 iFrame; /* Index of last frame read */ + u32 iLast = MIN(iLastFrame, HASHTABLE_NPAGE_ONE+iPg*HASHTABLE_NPAGE); + u32 iFirst = 1 + (iPg==0?0:HASHTABLE_NPAGE_ONE+(iPg-1)*HASHTABLE_NPAGE); + u32 nHdr, nHdr32; + rc = walIndexPage(pWal, iPg, (volatile u32**)&aShare); + assert( aShare!=0 || rc!=SQLITE_OK ); + if( aShare==0 ) break; + pWal->apWiData[iPg] = aPrivate; + + for(iFrame=iFirst; iFrame<=iLast; iFrame++){ + i64 iOffset = walFrameOffset(iFrame, szPage); + u32 pgno; /* Database page number for frame */ + u32 nTruncate; /* dbsize field from frame header */ + + /* Read and decode the next log frame. */ + rc = sqlite3OsRead(pWal->pWalFd, aFrame, szFrame, iOffset); + if( rc!=SQLITE_OK ) break; + isValid = walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame); + if( !isValid ) break; + rc = walIndexAppend(pWal, iFrame, pgno); + if( NEVER(rc!=SQLITE_OK) ) break; + + /* If nTruncate is non-zero, this is a commit record. */ + if( nTruncate ){ + pWal->hdr.mxFrame = iFrame; + pWal->hdr.nPage = nTruncate; + pWal->hdr.szPage = (u16)((szPage&0xff00) | (szPage>>16)); + testcase( szPage<=32768 ); + testcase( szPage>=65536 ); + aFrameCksum[0] = pWal->hdr.aFrameCksum[0]; + aFrameCksum[1] = pWal->hdr.aFrameCksum[1]; + } + } + pWal->apWiData[iPg] = aShare; + nHdr = (iPg==0 ? WALINDEX_HDR_SIZE : 0); + nHdr32 = nHdr / sizeof(u32); +#ifndef SQLITE_SAFER_WALINDEX_RECOVERY + /* Memcpy() should work fine here, on all reasonable implementations. + ** Technically, memcpy() might change the destination to some + ** intermediate value before setting to the final value, and that might + ** cause a concurrent reader to malfunction. Memcpy() is allowed to + ** do that, according to the spec, but no memcpy() implementation that + ** we know of actually does that, which is why we say that memcpy() + ** is safe for this. Memcpy() is certainly a lot faster. + */ + memcpy(&aShare[nHdr32], &aPrivate[nHdr32], WALINDEX_PGSZ-nHdr); +#else + /* In the event that some platform is found for which memcpy() + ** changes the destination to some intermediate value before + ** setting the final value, this alternative copy routine is + ** provided. + */ + { + int i; + for(i=nHdr32; ihdr.aFrameCksum[0] = aFrameCksum[0]; + pWal->hdr.aFrameCksum[1] = aFrameCksum[1]; + walIndexWriteHdr(pWal); + + /* Reset the checkpoint-header. This is safe because this thread is + ** currently holding locks that exclude all other writers and + ** checkpointers. Then set the values of read-mark slots 1 through N. + */ + pInfo = walCkptInfo(pWal); + pInfo->nBackfill = 0; + pInfo->nBackfillAttempted = pWal->hdr.mxFrame; + pInfo->aReadMark[0] = 0; + for(i=1; ihdr.mxFrame ){ + pInfo->aReadMark[i] = pWal->hdr.mxFrame; + }else{ + pInfo->aReadMark[i] = READMARK_NOT_USED; + } + walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1); + }else if( rc!=SQLITE_BUSY ){ + goto recovery_error; + } + } + + /* If more than one frame was recovered from the log file, report an + ** event via sqlite3_log(). This is to help with identifying performance + ** problems caused by applications routinely shutting down without + ** checkpointing the log file. + */ + if( pWal->hdr.nPage ){ + sqlite3_log(SQLITE_NOTICE_RECOVER_WAL, + "recovered %d frames from WAL file %s", + pWal->hdr.mxFrame, pWal->zWalName + ); + } + } + +recovery_error: + WALTRACE(("WAL%p: recovery %s\n", pWal, rc ? "failed" : "ok")); + walUnlockExclusive(pWal, iLock, WAL_READ_LOCK(0)-iLock); + return rc; +} + +/* +** Close an open wal-index. +*/ +static void walIndexClose(Wal *pWal, int isDelete){ + if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE || pWal->bShmUnreliable ){ + int i; + for(i=0; inWiData; i++){ + sqlite3_free((void *)pWal->apWiData[i]); + pWal->apWiData[i] = 0; + } + } + if( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE ){ + sqlite3OsShmUnmap(pWal->pDbFd, isDelete); + } +} + +/* +** Open a connection to the WAL file zWalName. The database file must +** already be opened on connection pDbFd. The buffer that zWalName points +** to must remain valid for the lifetime of the returned Wal* handle. +** +** A SHARED lock should be held on the database file when this function +** is called. The purpose of this SHARED lock is to prevent any other +** client from unlinking the WAL or wal-index file. If another process +** were to do this just after this client opened one of these files, the +** system would be badly broken. +** +** If the log file is successfully opened, SQLITE_OK is returned and +** *ppWal is set to point to a new WAL handle. If an error occurs, +** an SQLite error code is returned and *ppWal is left unmodified. +*/ +SQLITE_PRIVATE int sqlite3WalOpen( + sqlite3_vfs *pVfs, /* vfs module to open wal and wal-index */ + sqlite3_file *pDbFd, /* The open database file */ + const char *zWalName, /* Name of the WAL file */ + int bNoShm, /* True to run in heap-memory mode */ + i64 mxWalSize, /* Truncate WAL to this size on reset */ + Wal **ppWal /* OUT: Allocated Wal handle */ +){ + int rc; /* Return Code */ + Wal *pRet; /* Object to allocate and return */ + int flags; /* Flags passed to OsOpen() */ + + assert( zWalName && zWalName[0] ); + assert( pDbFd ); + + /* Verify the values of various constants. Any changes to the values + ** of these constants would result in an incompatible on-disk format + ** for the -shm file. Any change that causes one of these asserts to + ** fail is a backward compatibility problem, even if the change otherwise + ** works. + ** + ** This table also serves as a helpful cross-reference when trying to + ** interpret hex dumps of the -shm file. + */ + assert( 48 == sizeof(WalIndexHdr) ); + assert( 40 == sizeof(WalCkptInfo) ); + assert( 120 == WALINDEX_LOCK_OFFSET ); + assert( 136 == WALINDEX_HDR_SIZE ); + assert( 4096 == HASHTABLE_NPAGE ); + assert( 4062 == HASHTABLE_NPAGE_ONE ); + assert( 8192 == HASHTABLE_NSLOT ); + assert( 383 == HASHTABLE_HASH_1 ); + assert( 32768 == WALINDEX_PGSZ ); + assert( 8 == SQLITE_SHM_NLOCK ); + assert( 5 == WAL_NREADER ); + assert( 24 == WAL_FRAME_HDRSIZE ); + assert( 32 == WAL_HDRSIZE ); + assert( 120 == WALINDEX_LOCK_OFFSET + WAL_WRITE_LOCK ); + assert( 121 == WALINDEX_LOCK_OFFSET + WAL_CKPT_LOCK ); + assert( 122 == WALINDEX_LOCK_OFFSET + WAL_RECOVER_LOCK ); + assert( 123 == WALINDEX_LOCK_OFFSET + WAL_READ_LOCK(0) ); + assert( 124 == WALINDEX_LOCK_OFFSET + WAL_READ_LOCK(1) ); + assert( 125 == WALINDEX_LOCK_OFFSET + WAL_READ_LOCK(2) ); + assert( 126 == WALINDEX_LOCK_OFFSET + WAL_READ_LOCK(3) ); + assert( 127 == WALINDEX_LOCK_OFFSET + WAL_READ_LOCK(4) ); + + /* In the amalgamation, the os_unix.c and os_win.c source files come before + ** this source file. Verify that the #defines of the locking byte offsets + ** in os_unix.c and os_win.c agree with the WALINDEX_LOCK_OFFSET value. + ** For that matter, if the lock offset ever changes from its initial design + ** value of 120, we need to know that so there is an assert() to check it. + */ +#ifdef WIN_SHM_BASE + assert( WIN_SHM_BASE==WALINDEX_LOCK_OFFSET ); +#endif +#ifdef UNIX_SHM_BASE + assert( UNIX_SHM_BASE==WALINDEX_LOCK_OFFSET ); +#endif + + + /* Allocate an instance of struct Wal to return. */ + *ppWal = 0; + pRet = (Wal*)sqlite3MallocZero(sizeof(Wal) + pVfs->szOsFile); + if( !pRet ){ + return SQLITE_NOMEM_BKPT; + } + + pRet->pVfs = pVfs; + pRet->pWalFd = (sqlite3_file *)&pRet[1]; + pRet->pDbFd = pDbFd; + pRet->readLock = -1; + pRet->mxWalSize = mxWalSize; + pRet->zWalName = zWalName; + pRet->syncHeader = 1; + pRet->padToSectorBoundary = 1; + pRet->exclusiveMode = (bNoShm ? WAL_HEAPMEMORY_MODE: WAL_NORMAL_MODE); + + /* Open file handle on the write-ahead log file. */ + flags = (SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_WAL); + rc = sqlite3OsOpen(pVfs, zWalName, pRet->pWalFd, flags, &flags); + if( rc==SQLITE_OK && flags&SQLITE_OPEN_READONLY ){ + pRet->readOnly = WAL_RDONLY; + } + + if( rc!=SQLITE_OK ){ + walIndexClose(pRet, 0); + sqlite3OsClose(pRet->pWalFd); + sqlite3_free(pRet); + }else{ + int iDC = sqlite3OsDeviceCharacteristics(pDbFd); + if( iDC & SQLITE_IOCAP_SEQUENTIAL ){ pRet->syncHeader = 0; } + if( iDC & SQLITE_IOCAP_POWERSAFE_OVERWRITE ){ + pRet->padToSectorBoundary = 0; + } + *ppWal = pRet; + WALTRACE(("WAL%d: opened\n", pRet)); + } + return rc; +} + +/* +** Change the size to which the WAL file is trucated on each reset. +*/ +SQLITE_PRIVATE void sqlite3WalLimit(Wal *pWal, i64 iLimit){ + if( pWal ) pWal->mxWalSize = iLimit; +} + +/* +** Find the smallest page number out of all pages held in the WAL that +** has not been returned by any prior invocation of this method on the +** same WalIterator object. Write into *piFrame the frame index where +** that page was last written into the WAL. Write into *piPage the page +** number. +** +** Return 0 on success. If there are no pages in the WAL with a page +** number larger than *piPage, then return 1. +*/ +static int walIteratorNext( + WalIterator *p, /* Iterator */ + u32 *piPage, /* OUT: The page number of the next page */ + u32 *piFrame /* OUT: Wal frame index of next page */ +){ + u32 iMin; /* Result pgno must be greater than iMin */ + u32 iRet = 0xFFFFFFFF; /* 0xffffffff is never a valid page number */ + int i; /* For looping through segments */ + + iMin = p->iPrior; + assert( iMin<0xffffffff ); + for(i=p->nSegment-1; i>=0; i--){ + struct WalSegment *pSegment = &p->aSegment[i]; + while( pSegment->iNextnEntry ){ + u32 iPg = pSegment->aPgno[pSegment->aIndex[pSegment->iNext]]; + if( iPg>iMin ){ + if( iPgiZero + pSegment->aIndex[pSegment->iNext]; + } + break; + } + pSegment->iNext++; + } + } + + *piPage = p->iPrior = iRet; + return (iRet==0xFFFFFFFF); +} + +/* +** This function merges two sorted lists into a single sorted list. +** +** aLeft[] and aRight[] are arrays of indices. The sort key is +** aContent[aLeft[]] and aContent[aRight[]]. Upon entry, the following +** is guaranteed for all J0 && nRight>0 ); + while( iRight=nRight || aContent[aLeft[iLeft]]=nLeft || aContent[aLeft[iLeft]]>dbpage ); + assert( iRight>=nRight || aContent[aRight[iRight]]>dbpage ); + } + + *paRight = aLeft; + *pnRight = iOut; + memcpy(aLeft, aTmp, sizeof(aTmp[0])*iOut); +} + +/* +** Sort the elements in list aList using aContent[] as the sort key. +** Remove elements with duplicate keys, preferring to keep the +** larger aList[] values. +** +** The aList[] entries are indices into aContent[]. The values in +** aList[] are to be sorted so that for all J0 ); + assert( HASHTABLE_NPAGE==(1<<(ArraySize(aSub)-1)) ); + + for(iList=0; iListaList && p->nList<=(1<aList==&aList[iList&~((2<aList, p->nList, &aMerge, &nMerge, aBuffer); + } + aSub[iSub].aList = aMerge; + aSub[iSub].nList = nMerge; + } + + for(iSub++; iSubnList<=(1<aList==&aList[nList&~((2<aList, p->nList, &aMerge, &nMerge, aBuffer); + } + } + assert( aMerge==aList ); + *pnList = nMerge; + +#ifdef SQLITE_DEBUG + { + int i; + for(i=1; i<*pnList; i++){ + assert( aContent[aList[i]] > aContent[aList[i-1]] ); + } + } +#endif +} + +/* +** Free an iterator allocated by walIteratorInit(). +*/ +static void walIteratorFree(WalIterator *p){ + sqlite3_free(p); +} + +/* +** Construct a WalInterator object that can be used to loop over all +** pages in the WAL following frame nBackfill in ascending order. Frames +** nBackfill or earlier may be included - excluding them is an optimization +** only. The caller must hold the checkpoint lock. +** +** On success, make *pp point to the newly allocated WalInterator object +** return SQLITE_OK. Otherwise, return an error code. If this routine +** returns an error, the value of *pp is undefined. +** +** The calling routine should invoke walIteratorFree() to destroy the +** WalIterator object when it has finished with it. +*/ +static int walIteratorInit(Wal *pWal, u32 nBackfill, WalIterator **pp){ + WalIterator *p; /* Return value */ + int nSegment; /* Number of segments to merge */ + u32 iLast; /* Last frame in log */ + sqlite3_int64 nByte; /* Number of bytes to allocate */ + int i; /* Iterator variable */ + ht_slot *aTmp; /* Temp space used by merge-sort */ + int rc = SQLITE_OK; /* Return Code */ + + /* This routine only runs while holding the checkpoint lock. And + ** it only runs if there is actually content in the log (mxFrame>0). + */ + assert( pWal->ckptLock && pWal->hdr.mxFrame>0 ); + iLast = pWal->hdr.mxFrame; + + /* Allocate space for the WalIterator object. */ + nSegment = walFramePage(iLast) + 1; + nByte = sizeof(WalIterator) + + (nSegment-1)*sizeof(struct WalSegment) + + iLast*sizeof(ht_slot); + p = (WalIterator *)sqlite3_malloc64(nByte); + if( !p ){ + return SQLITE_NOMEM_BKPT; + } + memset(p, 0, nByte); + p->nSegment = nSegment; + + /* Allocate temporary space used by the merge-sort routine. This block + ** of memory will be freed before this function returns. + */ + aTmp = (ht_slot *)sqlite3_malloc64( + sizeof(ht_slot) * (iLast>HASHTABLE_NPAGE?HASHTABLE_NPAGE:iLast) + ); + if( !aTmp ){ + rc = SQLITE_NOMEM_BKPT; + } + + for(i=walFramePage(nBackfill+1); rc==SQLITE_OK && iaSegment[p->nSegment])[sLoc.iZero]; + sLoc.iZero++; + + for(j=0; jaSegment[i].iZero = sLoc.iZero; + p->aSegment[i].nEntry = nEntry; + p->aSegment[i].aIndex = aIndex; + p->aSegment[i].aPgno = (u32 *)sLoc.aPgno; + } + } + sqlite3_free(aTmp); + + if( rc!=SQLITE_OK ){ + walIteratorFree(p); + p = 0; + } + *pp = p; + return rc; +} + +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT +/* +** Attempt to enable blocking locks. Blocking locks are enabled only if (a) +** they are supported by the VFS, and (b) the database handle is configured +** with a busy-timeout. Return 1 if blocking locks are successfully enabled, +** or 0 otherwise. +*/ +static int walEnableBlocking(Wal *pWal){ + int res = 0; + if( pWal->db ){ + int tmout = pWal->db->busyTimeout; + if( tmout ){ + int rc; + rc = sqlite3OsFileControl( + pWal->pDbFd, SQLITE_FCNTL_LOCK_TIMEOUT, (void*)&tmout + ); + res = (rc==SQLITE_OK); + } + } + return res; +} + +/* +** Disable blocking locks. +*/ +static void walDisableBlocking(Wal *pWal){ + int tmout = 0; + sqlite3OsFileControl(pWal->pDbFd, SQLITE_FCNTL_LOCK_TIMEOUT, (void*)&tmout); +} + +/* +** If parameter bLock is true, attempt to enable blocking locks, take +** the WRITER lock, and then disable blocking locks. If blocking locks +** cannot be enabled, no attempt to obtain the WRITER lock is made. Return +** an SQLite error code if an error occurs, or SQLITE_OK otherwise. It is not +** an error if blocking locks can not be enabled. +** +** If the bLock parameter is false and the WRITER lock is held, release it. +*/ +SQLITE_PRIVATE int sqlite3WalWriteLock(Wal *pWal, int bLock){ + int rc = SQLITE_OK; + assert( pWal->readLock<0 || bLock==0 ); + if( bLock ){ + assert( pWal->db ); + if( walEnableBlocking(pWal) ){ + rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1); + if( rc==SQLITE_OK ){ + pWal->writeLock = 1; + } + walDisableBlocking(pWal); + } + }else if( pWal->writeLock ){ + walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1); + pWal->writeLock = 0; + } + return rc; +} + +/* +** Set the database handle used to determine if blocking locks are required. +*/ +SQLITE_PRIVATE void sqlite3WalDb(Wal *pWal, sqlite3 *db){ + pWal->db = db; +} + +/* +** Take an exclusive WRITE lock. Blocking if so configured. +*/ +static int walLockWriter(Wal *pWal){ + int rc; + walEnableBlocking(pWal); + rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1); + walDisableBlocking(pWal); + return rc; +} +#else +# define walEnableBlocking(x) 0 +# define walDisableBlocking(x) +# define walLockWriter(pWal) walLockExclusive((pWal), WAL_WRITE_LOCK, 1) +# define sqlite3WalDb(pWal, db) +#endif /* ifdef SQLITE_ENABLE_SETLK_TIMEOUT */ + + +/* +** Attempt to obtain the exclusive WAL lock defined by parameters lockIdx and +** n. If the attempt fails and parameter xBusy is not NULL, then it is a +** busy-handler function. Invoke it and retry the lock until either the +** lock is successfully obtained or the busy-handler returns 0. +*/ +static int walBusyLock( + Wal *pWal, /* WAL connection */ + int (*xBusy)(void*), /* Function to call when busy */ + void *pBusyArg, /* Context argument for xBusyHandler */ + int lockIdx, /* Offset of first byte to lock */ + int n /* Number of bytes to lock */ +){ + int rc; + do { + rc = walLockExclusive(pWal, lockIdx, n); + }while( xBusy && rc==SQLITE_BUSY && xBusy(pBusyArg) ); +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT + if( rc==SQLITE_BUSY_TIMEOUT ){ + walDisableBlocking(pWal); + rc = SQLITE_BUSY; + } +#endif + return rc; +} + +/* +** The cache of the wal-index header must be valid to call this function. +** Return the page-size in bytes used by the database. +*/ +static int walPagesize(Wal *pWal){ + return (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16); +} + +/* +** The following is guaranteed when this function is called: +** +** a) the WRITER lock is held, +** b) the entire log file has been checkpointed, and +** c) any existing readers are reading exclusively from the database +** file - there are no readers that may attempt to read a frame from +** the log file. +** +** This function updates the shared-memory structures so that the next +** client to write to the database (which may be this one) does so by +** writing frames into the start of the log file. +** +** The value of parameter salt1 is used as the aSalt[1] value in the +** new wal-index header. It should be passed a pseudo-random value (i.e. +** one obtained from sqlite3_randomness()). +*/ +static void walRestartHdr(Wal *pWal, u32 salt1){ + volatile WalCkptInfo *pInfo = walCkptInfo(pWal); + int i; /* Loop counter */ + u32 *aSalt = pWal->hdr.aSalt; /* Big-endian salt values */ + pWal->nCkpt++; + pWal->hdr.mxFrame = 0; + sqlite3Put4byte((u8*)&aSalt[0], 1 + sqlite3Get4byte((u8*)&aSalt[0])); + memcpy(&pWal->hdr.aSalt[1], &salt1, 4); + walIndexWriteHdr(pWal); + AtomicStore(&pInfo->nBackfill, 0); + pInfo->nBackfillAttempted = 0; + pInfo->aReadMark[1] = 0; + for(i=2; iaReadMark[i] = READMARK_NOT_USED; + assert( pInfo->aReadMark[0]==0 ); +} + +/* +** Copy as much content as we can from the WAL back into the database file +** in response to an sqlite3_wal_checkpoint() request or the equivalent. +** +** The amount of information copies from WAL to database might be limited +** by active readers. This routine will never overwrite a database page +** that a concurrent reader might be using. +** +** All I/O barrier operations (a.k.a fsyncs) occur in this routine when +** SQLite is in WAL-mode in synchronous=NORMAL. That means that if +** checkpoints are always run by a background thread or background +** process, foreground threads will never block on a lengthy fsync call. +** +** Fsync is called on the WAL before writing content out of the WAL and +** into the database. This ensures that if the new content is persistent +** in the WAL and can be recovered following a power-loss or hard reset. +** +** Fsync is also called on the database file if (and only if) the entire +** WAL content is copied into the database file. This second fsync makes +** it safe to delete the WAL since the new content will persist in the +** database file. +** +** This routine uses and updates the nBackfill field of the wal-index header. +** This is the only routine that will increase the value of nBackfill. +** (A WAL reset or recovery will revert nBackfill to zero, but not increase +** its value.) +** +** The caller must be holding sufficient locks to ensure that no other +** checkpoint is running (in any other thread or process) at the same +** time. +*/ +static int walCheckpoint( + Wal *pWal, /* Wal connection */ + sqlite3 *db, /* Check for interrupts on this handle */ + int eMode, /* One of PASSIVE, FULL or RESTART */ + int (*xBusy)(void*), /* Function to call when busy */ + void *pBusyArg, /* Context argument for xBusyHandler */ + int sync_flags, /* Flags for OsSync() (or 0) */ + u8 *zBuf /* Temporary buffer to use */ +){ + int rc = SQLITE_OK; /* Return code */ + int szPage; /* Database page-size */ + WalIterator *pIter = 0; /* Wal iterator context */ + u32 iDbpage = 0; /* Next database page to write */ + u32 iFrame = 0; /* Wal frame containing data for iDbpage */ + u32 mxSafeFrame; /* Max frame that can be backfilled */ + u32 mxPage; /* Max database page to write */ + int i; /* Loop counter */ + volatile WalCkptInfo *pInfo; /* The checkpoint status information */ + + szPage = walPagesize(pWal); + testcase( szPage<=32768 ); + testcase( szPage>=65536 ); + pInfo = walCkptInfo(pWal); + if( pInfo->nBackfillhdr.mxFrame ){ + + /* EVIDENCE-OF: R-62920-47450 The busy-handler callback is never invoked + ** in the SQLITE_CHECKPOINT_PASSIVE mode. */ + assert( eMode!=SQLITE_CHECKPOINT_PASSIVE || xBusy==0 ); + + /* Compute in mxSafeFrame the index of the last frame of the WAL that is + ** safe to write into the database. Frames beyond mxSafeFrame might + ** overwrite database pages that are in use by active readers and thus + ** cannot be backfilled from the WAL. + */ + mxSafeFrame = pWal->hdr.mxFrame; + mxPage = pWal->hdr.nPage; + for(i=1; iaReadMark+i); + if( mxSafeFrame>y ){ + assert( y<=pWal->hdr.mxFrame ); + rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(i), 1); + if( rc==SQLITE_OK ){ + u32 iMark = (i==1 ? mxSafeFrame : READMARK_NOT_USED); + AtomicStore(pInfo->aReadMark+i, iMark); + walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1); + }else if( rc==SQLITE_BUSY ){ + mxSafeFrame = y; + xBusy = 0; + }else{ + goto walcheckpoint_out; + } + } + } + + /* Allocate the iterator */ + if( pInfo->nBackfillnBackfill, &pIter); + assert( rc==SQLITE_OK || pIter==0 ); + } + + if( pIter + && (rc = walBusyLock(pWal,xBusy,pBusyArg,WAL_READ_LOCK(0),1))==SQLITE_OK + ){ + u32 nBackfill = pInfo->nBackfill; + + pInfo->nBackfillAttempted = mxSafeFrame; + + /* Sync the WAL to disk */ + rc = sqlite3OsSync(pWal->pWalFd, CKPT_SYNC_FLAGS(sync_flags)); + + /* If the database may grow as a result of this checkpoint, hint + ** about the eventual size of the db file to the VFS layer. + */ + if( rc==SQLITE_OK ){ + i64 nReq = ((i64)mxPage * szPage); + i64 nSize; /* Current size of database file */ + sqlite3OsFileControl(pWal->pDbFd, SQLITE_FCNTL_CKPT_START, 0); + rc = sqlite3OsFileSize(pWal->pDbFd, &nSize); + if( rc==SQLITE_OK && nSizehdr.mxFrame*szPage)pDbFd, SQLITE_FCNTL_SIZE_HINT,&nReq); + } + } + + } + + /* Iterate through the contents of the WAL, copying data to the db file */ + while( rc==SQLITE_OK && 0==walIteratorNext(pIter, &iDbpage, &iFrame) ){ + i64 iOffset; + assert( walFramePgno(pWal, iFrame)==iDbpage ); + if( AtomicLoad(&db->u1.isInterrupted) ){ + rc = db->mallocFailed ? SQLITE_NOMEM_BKPT : SQLITE_INTERRUPT; + break; + } + if( iFrame<=nBackfill || iFrame>mxSafeFrame || iDbpage>mxPage ){ + continue; + } + iOffset = walFrameOffset(iFrame, szPage) + WAL_FRAME_HDRSIZE; + /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL file */ + rc = sqlite3OsRead(pWal->pWalFd, zBuf, szPage, iOffset); + if( rc!=SQLITE_OK ) break; + iOffset = (iDbpage-1)*(i64)szPage; + testcase( IS_BIG_INT(iOffset) ); + rc = sqlite3OsWrite(pWal->pDbFd, zBuf, szPage, iOffset); + if( rc!=SQLITE_OK ) break; + } + sqlite3OsFileControl(pWal->pDbFd, SQLITE_FCNTL_CKPT_DONE, 0); + + /* If work was actually accomplished... */ + if( rc==SQLITE_OK ){ + if( mxSafeFrame==walIndexHdr(pWal)->mxFrame ){ + i64 szDb = pWal->hdr.nPage*(i64)szPage; + testcase( IS_BIG_INT(szDb) ); + rc = sqlite3OsTruncate(pWal->pDbFd, szDb); + if( rc==SQLITE_OK ){ + rc = sqlite3OsSync(pWal->pDbFd, CKPT_SYNC_FLAGS(sync_flags)); + } + } + if( rc==SQLITE_OK ){ + AtomicStore(&pInfo->nBackfill, mxSafeFrame); + } + } + + /* Release the reader lock held while backfilling */ + walUnlockExclusive(pWal, WAL_READ_LOCK(0), 1); + } + + if( rc==SQLITE_BUSY ){ + /* Reset the return code so as not to report a checkpoint failure + ** just because there are active readers. */ + rc = SQLITE_OK; + } + } + + /* If this is an SQLITE_CHECKPOINT_RESTART or TRUNCATE operation, and the + ** entire wal file has been copied into the database file, then block + ** until all readers have finished using the wal file. This ensures that + ** the next process to write to the database restarts the wal file. + */ + if( rc==SQLITE_OK && eMode!=SQLITE_CHECKPOINT_PASSIVE ){ + assert( pWal->writeLock ); + if( pInfo->nBackfillhdr.mxFrame ){ + rc = SQLITE_BUSY; + }else if( eMode>=SQLITE_CHECKPOINT_RESTART ){ + u32 salt1; + sqlite3_randomness(4, &salt1); + assert( pInfo->nBackfill==pWal->hdr.mxFrame ); + rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(1), WAL_NREADER-1); + if( rc==SQLITE_OK ){ + if( eMode==SQLITE_CHECKPOINT_TRUNCATE ){ + /* IMPLEMENTATION-OF: R-44699-57140 This mode works the same way as + ** SQLITE_CHECKPOINT_RESTART with the addition that it also + ** truncates the log file to zero bytes just prior to a + ** successful return. + ** + ** In theory, it might be safe to do this without updating the + ** wal-index header in shared memory, as all subsequent reader or + ** writer clients should see that the entire log file has been + ** checkpointed and behave accordingly. This seems unsafe though, + ** as it would leave the system in a state where the contents of + ** the wal-index header do not match the contents of the + ** file-system. To avoid this, update the wal-index header to + ** indicate that the log file contains zero valid frames. */ + walRestartHdr(pWal, salt1); + rc = sqlite3OsTruncate(pWal->pWalFd, 0); + } + walUnlockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1); + } + } + } + + walcheckpoint_out: + walIteratorFree(pIter); + return rc; +} + +/* +** If the WAL file is currently larger than nMax bytes in size, truncate +** it to exactly nMax bytes. If an error occurs while doing so, ignore it. +*/ +static void walLimitSize(Wal *pWal, i64 nMax){ + i64 sz; + int rx; + sqlite3BeginBenignMalloc(); + rx = sqlite3OsFileSize(pWal->pWalFd, &sz); + if( rx==SQLITE_OK && (sz > nMax ) ){ + rx = sqlite3OsTruncate(pWal->pWalFd, nMax); + } + sqlite3EndBenignMalloc(); + if( rx ){ + sqlite3_log(rx, "cannot limit WAL size: %s", pWal->zWalName); + } +} + +/* +** Close a connection to a log file. +*/ +SQLITE_PRIVATE int sqlite3WalClose( + Wal *pWal, /* Wal to close */ + sqlite3 *db, /* For interrupt flag */ + int sync_flags, /* Flags to pass to OsSync() (or 0) */ + int nBuf, + u8 *zBuf /* Buffer of at least nBuf bytes */ +){ + int rc = SQLITE_OK; + if( pWal ){ + int isDelete = 0; /* True to unlink wal and wal-index files */ + + /* If an EXCLUSIVE lock can be obtained on the database file (using the + ** ordinary, rollback-mode locking methods, this guarantees that the + ** connection associated with this log file is the only connection to + ** the database. In this case checkpoint the database and unlink both + ** the wal and wal-index files. + ** + ** The EXCLUSIVE lock is not released before returning. + */ + if( zBuf!=0 + && SQLITE_OK==(rc = sqlite3OsLock(pWal->pDbFd, SQLITE_LOCK_EXCLUSIVE)) + ){ + if( pWal->exclusiveMode==WAL_NORMAL_MODE ){ + pWal->exclusiveMode = WAL_EXCLUSIVE_MODE; + } + rc = sqlite3WalCheckpoint(pWal, db, + SQLITE_CHECKPOINT_PASSIVE, 0, 0, sync_flags, nBuf, zBuf, 0, 0 + ); + if( rc==SQLITE_OK ){ + int bPersist = -1; + sqlite3OsFileControlHint( + pWal->pDbFd, SQLITE_FCNTL_PERSIST_WAL, &bPersist + ); + if( bPersist!=1 ){ + /* Try to delete the WAL file if the checkpoint completed and + ** fsyned (rc==SQLITE_OK) and if we are not in persistent-wal + ** mode (!bPersist) */ + isDelete = 1; + }else if( pWal->mxWalSize>=0 ){ + /* Try to truncate the WAL file to zero bytes if the checkpoint + ** completed and fsynced (rc==SQLITE_OK) and we are in persistent + ** WAL mode (bPersist) and if the PRAGMA journal_size_limit is a + ** non-negative value (pWal->mxWalSize>=0). Note that we truncate + ** to zero bytes as truncating to the journal_size_limit might + ** leave a corrupt WAL file on disk. */ + walLimitSize(pWal, 0); + } + } + } + + walIndexClose(pWal, isDelete); + sqlite3OsClose(pWal->pWalFd); + if( isDelete ){ + sqlite3BeginBenignMalloc(); + sqlite3OsDelete(pWal->pVfs, pWal->zWalName, 0); + sqlite3EndBenignMalloc(); + } + WALTRACE(("WAL%p: closed\n", pWal)); + sqlite3_free((void *)pWal->apWiData); + sqlite3_free(pWal); + } + return rc; +} + +/* +** Try to read the wal-index header. Return 0 on success and 1 if +** there is a problem. +** +** The wal-index is in shared memory. Another thread or process might +** be writing the header at the same time this procedure is trying to +** read it, which might result in inconsistency. A dirty read is detected +** by verifying that both copies of the header are the same and also by +** a checksum on the header. +** +** If and only if the read is consistent and the header is different from +** pWal->hdr, then pWal->hdr is updated to the content of the new header +** and *pChanged is set to 1. +** +** If the checksum cannot be verified return non-zero. If the header +** is read successfully and the checksum verified, return zero. +*/ +static SQLITE_NO_TSAN int walIndexTryHdr(Wal *pWal, int *pChanged){ + u32 aCksum[2]; /* Checksum on the header content */ + WalIndexHdr h1, h2; /* Two copies of the header content */ + WalIndexHdr volatile *aHdr; /* Header in shared memory */ + + /* The first page of the wal-index must be mapped at this point. */ + assert( pWal->nWiData>0 && pWal->apWiData[0] ); + + /* Read the header. This might happen concurrently with a write to the + ** same area of shared memory on a different CPU in a SMP, + ** meaning it is possible that an inconsistent snapshot is read + ** from the file. If this happens, return non-zero. + ** + ** tag-20200519-1: + ** There are two copies of the header at the beginning of the wal-index. + ** When reading, read [0] first then [1]. Writes are in the reverse order. + ** Memory barriers are used to prevent the compiler or the hardware from + ** reordering the reads and writes. TSAN and similar tools can sometimes + ** give false-positive warnings about these accesses because the tools do not + ** account for the double-read and the memory barrier. The use of mutexes + ** here would be problematic as the memory being accessed is potentially + ** shared among multiple processes and not all mutex implementions work + ** reliably in that environment. + */ + aHdr = walIndexHdr(pWal); + memcpy(&h1, (void *)&aHdr[0], sizeof(h1)); /* Possible TSAN false-positive */ + walShmBarrier(pWal); + memcpy(&h2, (void *)&aHdr[1], sizeof(h2)); + + if( memcmp(&h1, &h2, sizeof(h1))!=0 ){ + return 1; /* Dirty read */ + } + if( h1.isInit==0 ){ + return 1; /* Malformed header - probably all zeros */ + } + walChecksumBytes(1, (u8*)&h1, sizeof(h1)-sizeof(h1.aCksum), 0, aCksum); + if( aCksum[0]!=h1.aCksum[0] || aCksum[1]!=h1.aCksum[1] ){ + return 1; /* Checksum does not match */ + } + + if( memcmp(&pWal->hdr, &h1, sizeof(WalIndexHdr)) ){ + *pChanged = 1; + memcpy(&pWal->hdr, &h1, sizeof(WalIndexHdr)); + pWal->szPage = (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16); + testcase( pWal->szPage<=32768 ); + testcase( pWal->szPage>=65536 ); + } + + /* The header was successfully read. Return zero. */ + return 0; +} + +/* +** This is the value that walTryBeginRead returns when it needs to +** be retried. +*/ +#define WAL_RETRY (-1) + +/* +** Read the wal-index header from the wal-index and into pWal->hdr. +** If the wal-header appears to be corrupt, try to reconstruct the +** wal-index from the WAL before returning. +** +** Set *pChanged to 1 if the wal-index header value in pWal->hdr is +** changed by this operation. If pWal->hdr is unchanged, set *pChanged +** to 0. +** +** If the wal-index header is successfully read, return SQLITE_OK. +** Otherwise an SQLite error code. +*/ +static int walIndexReadHdr(Wal *pWal, int *pChanged){ + int rc; /* Return code */ + int badHdr; /* True if a header read failed */ + volatile u32 *page0; /* Chunk of wal-index containing header */ + + /* Ensure that page 0 of the wal-index (the page that contains the + ** wal-index header) is mapped. Return early if an error occurs here. + */ + assert( pChanged ); + rc = walIndexPage(pWal, 0, &page0); + if( rc!=SQLITE_OK ){ + assert( rc!=SQLITE_READONLY ); /* READONLY changed to OK in walIndexPage */ + if( rc==SQLITE_READONLY_CANTINIT ){ + /* The SQLITE_READONLY_CANTINIT return means that the shared-memory + ** was openable but is not writable, and this thread is unable to + ** confirm that another write-capable connection has the shared-memory + ** open, and hence the content of the shared-memory is unreliable, + ** since the shared-memory might be inconsistent with the WAL file + ** and there is no writer on hand to fix it. */ + assert( page0==0 ); + assert( pWal->writeLock==0 ); + assert( pWal->readOnly & WAL_SHM_RDONLY ); + pWal->bShmUnreliable = 1; + pWal->exclusiveMode = WAL_HEAPMEMORY_MODE; + *pChanged = 1; + }else{ + return rc; /* Any other non-OK return is just an error */ + } + }else{ + /* page0 can be NULL if the SHM is zero bytes in size and pWal->writeLock + ** is zero, which prevents the SHM from growing */ + testcase( page0!=0 ); + } + assert( page0!=0 || pWal->writeLock==0 ); + + /* If the first page of the wal-index has been mapped, try to read the + ** wal-index header immediately, without holding any lock. This usually + ** works, but may fail if the wal-index header is corrupt or currently + ** being modified by another thread or process. + */ + badHdr = (page0 ? walIndexTryHdr(pWal, pChanged) : 1); + + /* If the first attempt failed, it might have been due to a race + ** with a writer. So get a WRITE lock and try again. + */ + if( badHdr ){ + if( pWal->bShmUnreliable==0 && (pWal->readOnly & WAL_SHM_RDONLY) ){ + if( SQLITE_OK==(rc = walLockShared(pWal, WAL_WRITE_LOCK)) ){ + walUnlockShared(pWal, WAL_WRITE_LOCK); + rc = SQLITE_READONLY_RECOVERY; + } + }else{ + int bWriteLock = pWal->writeLock; + if( bWriteLock || SQLITE_OK==(rc = walLockWriter(pWal)) ){ + pWal->writeLock = 1; + if( SQLITE_OK==(rc = walIndexPage(pWal, 0, &page0)) ){ + badHdr = walIndexTryHdr(pWal, pChanged); + if( badHdr ){ + /* If the wal-index header is still malformed even while holding + ** a WRITE lock, it can only mean that the header is corrupted and + ** needs to be reconstructed. So run recovery to do exactly that. + */ + rc = walIndexRecover(pWal); + *pChanged = 1; + } + } + if( bWriteLock==0 ){ + pWal->writeLock = 0; + walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1); + } + } + } + } + + /* If the header is read successfully, check the version number to make + ** sure the wal-index was not constructed with some future format that + ** this version of SQLite cannot understand. + */ + if( badHdr==0 && pWal->hdr.iVersion!=WALINDEX_MAX_VERSION ){ + rc = SQLITE_CANTOPEN_BKPT; + } + if( pWal->bShmUnreliable ){ + if( rc!=SQLITE_OK ){ + walIndexClose(pWal, 0); + pWal->bShmUnreliable = 0; + assert( pWal->nWiData>0 && pWal->apWiData[0]==0 ); + /* walIndexRecover() might have returned SHORT_READ if a concurrent + ** writer truncated the WAL out from under it. If that happens, it + ** indicates that a writer has fixed the SHM file for us, so retry */ + if( rc==SQLITE_IOERR_SHORT_READ ) rc = WAL_RETRY; + } + pWal->exclusiveMode = WAL_NORMAL_MODE; + } + + return rc; +} + +/* +** Open a transaction in a connection where the shared-memory is read-only +** and where we cannot verify that there is a separate write-capable connection +** on hand to keep the shared-memory up-to-date with the WAL file. +** +** This can happen, for example, when the shared-memory is implemented by +** memory-mapping a *-shm file, where a prior writer has shut down and +** left the *-shm file on disk, and now the present connection is trying +** to use that database but lacks write permission on the *-shm file. +** Other scenarios are also possible, depending on the VFS implementation. +** +** Precondition: +** +** The *-wal file has been read and an appropriate wal-index has been +** constructed in pWal->apWiData[] using heap memory instead of shared +** memory. +** +** If this function returns SQLITE_OK, then the read transaction has +** been successfully opened. In this case output variable (*pChanged) +** is set to true before returning if the caller should discard the +** contents of the page cache before proceeding. Or, if it returns +** WAL_RETRY, then the heap memory wal-index has been discarded and +** the caller should retry opening the read transaction from the +** beginning (including attempting to map the *-shm file). +** +** If an error occurs, an SQLite error code is returned. +*/ +static int walBeginShmUnreliable(Wal *pWal, int *pChanged){ + i64 szWal; /* Size of wal file on disk in bytes */ + i64 iOffset; /* Current offset when reading wal file */ + u8 aBuf[WAL_HDRSIZE]; /* Buffer to load WAL header into */ + u8 *aFrame = 0; /* Malloc'd buffer to load entire frame */ + int szFrame; /* Number of bytes in buffer aFrame[] */ + u8 *aData; /* Pointer to data part of aFrame buffer */ + volatile void *pDummy; /* Dummy argument for xShmMap */ + int rc; /* Return code */ + u32 aSaveCksum[2]; /* Saved copy of pWal->hdr.aFrameCksum */ + + assert( pWal->bShmUnreliable ); + assert( pWal->readOnly & WAL_SHM_RDONLY ); + assert( pWal->nWiData>0 && pWal->apWiData[0] ); + + /* Take WAL_READ_LOCK(0). This has the effect of preventing any + ** writers from running a checkpoint, but does not stop them + ** from running recovery. */ + rc = walLockShared(pWal, WAL_READ_LOCK(0)); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_BUSY ) rc = WAL_RETRY; + goto begin_unreliable_shm_out; + } + pWal->readLock = 0; + + /* Check to see if a separate writer has attached to the shared-memory area, + ** thus making the shared-memory "reliable" again. Do this by invoking + ** the xShmMap() routine of the VFS and looking to see if the return + ** is SQLITE_READONLY instead of SQLITE_READONLY_CANTINIT. + ** + ** If the shared-memory is now "reliable" return WAL_RETRY, which will + ** cause the heap-memory WAL-index to be discarded and the actual + ** shared memory to be used in its place. + ** + ** This step is important because, even though this connection is holding + ** the WAL_READ_LOCK(0) which prevents a checkpoint, a writer might + ** have already checkpointed the WAL file and, while the current + ** is active, wrap the WAL and start overwriting frames that this + ** process wants to use. + ** + ** Once sqlite3OsShmMap() has been called for an sqlite3_file and has + ** returned any SQLITE_READONLY value, it must return only SQLITE_READONLY + ** or SQLITE_READONLY_CANTINIT or some error for all subsequent invocations, + ** even if some external agent does a "chmod" to make the shared-memory + ** writable by us, until sqlite3OsShmUnmap() has been called. + ** This is a requirement on the VFS implementation. + */ + rc = sqlite3OsShmMap(pWal->pDbFd, 0, WALINDEX_PGSZ, 0, &pDummy); + assert( rc!=SQLITE_OK ); /* SQLITE_OK not possible for read-only connection */ + if( rc!=SQLITE_READONLY_CANTINIT ){ + rc = (rc==SQLITE_READONLY ? WAL_RETRY : rc); + goto begin_unreliable_shm_out; + } + + /* We reach this point only if the real shared-memory is still unreliable. + ** Assume the in-memory WAL-index substitute is correct and load it + ** into pWal->hdr. + */ + memcpy(&pWal->hdr, (void*)walIndexHdr(pWal), sizeof(WalIndexHdr)); + + /* Make sure some writer hasn't come in and changed the WAL file out + ** from under us, then disconnected, while we were not looking. + */ + rc = sqlite3OsFileSize(pWal->pWalFd, &szWal); + if( rc!=SQLITE_OK ){ + goto begin_unreliable_shm_out; + } + if( szWalhdr.mxFrame==0 ? SQLITE_OK : WAL_RETRY); + goto begin_unreliable_shm_out; + } + + /* Check the salt keys at the start of the wal file still match. */ + rc = sqlite3OsRead(pWal->pWalFd, aBuf, WAL_HDRSIZE, 0); + if( rc!=SQLITE_OK ){ + goto begin_unreliable_shm_out; + } + if( memcmp(&pWal->hdr.aSalt, &aBuf[16], 8) ){ + /* Some writer has wrapped the WAL file while we were not looking. + ** Return WAL_RETRY which will cause the in-memory WAL-index to be + ** rebuilt. */ + rc = WAL_RETRY; + goto begin_unreliable_shm_out; + } + + /* Allocate a buffer to read frames into */ + assert( (pWal->szPage & (pWal->szPage-1))==0 ); + assert( pWal->szPage>=512 && pWal->szPage<=65536 ); + szFrame = pWal->szPage + WAL_FRAME_HDRSIZE; + aFrame = (u8 *)sqlite3_malloc64(szFrame); + if( aFrame==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto begin_unreliable_shm_out; + } + aData = &aFrame[WAL_FRAME_HDRSIZE]; + + /* Check to see if a complete transaction has been appended to the + ** wal file since the heap-memory wal-index was created. If so, the + ** heap-memory wal-index is discarded and WAL_RETRY returned to + ** the caller. */ + aSaveCksum[0] = pWal->hdr.aFrameCksum[0]; + aSaveCksum[1] = pWal->hdr.aFrameCksum[1]; + for(iOffset=walFrameOffset(pWal->hdr.mxFrame+1, pWal->szPage); + iOffset+szFrame<=szWal; + iOffset+=szFrame + ){ + u32 pgno; /* Database page number for frame */ + u32 nTruncate; /* dbsize field from frame header */ + + /* Read and decode the next log frame. */ + rc = sqlite3OsRead(pWal->pWalFd, aFrame, szFrame, iOffset); + if( rc!=SQLITE_OK ) break; + if( !walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame) ) break; + + /* If nTruncate is non-zero, then a complete transaction has been + ** appended to this wal file. Set rc to WAL_RETRY and break out of + ** the loop. */ + if( nTruncate ){ + rc = WAL_RETRY; + break; + } + } + pWal->hdr.aFrameCksum[0] = aSaveCksum[0]; + pWal->hdr.aFrameCksum[1] = aSaveCksum[1]; + + begin_unreliable_shm_out: + sqlite3_free(aFrame); + if( rc!=SQLITE_OK ){ + int i; + for(i=0; inWiData; i++){ + sqlite3_free((void*)pWal->apWiData[i]); + pWal->apWiData[i] = 0; + } + pWal->bShmUnreliable = 0; + sqlite3WalEndReadTransaction(pWal); + *pChanged = 1; + } + return rc; +} + +/* +** Attempt to start a read transaction. This might fail due to a race or +** other transient condition. When that happens, it returns WAL_RETRY to +** indicate to the caller that it is safe to retry immediately. +** +** On success return SQLITE_OK. On a permanent failure (such an +** I/O error or an SQLITE_BUSY because another process is running +** recovery) return a positive error code. +** +** The useWal parameter is true to force the use of the WAL and disable +** the case where the WAL is bypassed because it has been completely +** checkpointed. If useWal==0 then this routine calls walIndexReadHdr() +** to make a copy of the wal-index header into pWal->hdr. If the +** wal-index header has changed, *pChanged is set to 1 (as an indication +** to the caller that the local page cache is obsolete and needs to be +** flushed.) When useWal==1, the wal-index header is assumed to already +** be loaded and the pChanged parameter is unused. +** +** The caller must set the cnt parameter to the number of prior calls to +** this routine during the current read attempt that returned WAL_RETRY. +** This routine will start taking more aggressive measures to clear the +** race conditions after multiple WAL_RETRY returns, and after an excessive +** number of errors will ultimately return SQLITE_PROTOCOL. The +** SQLITE_PROTOCOL return indicates that some other process has gone rogue +** and is not honoring the locking protocol. There is a vanishingly small +** chance that SQLITE_PROTOCOL could be returned because of a run of really +** bad luck when there is lots of contention for the wal-index, but that +** possibility is so small that it can be safely neglected, we believe. +** +** On success, this routine obtains a read lock on +** WAL_READ_LOCK(pWal->readLock). The pWal->readLock integer is +** in the range 0 <= pWal->readLock < WAL_NREADER. If pWal->readLock==(-1) +** that means the Wal does not hold any read lock. The reader must not +** access any database page that is modified by a WAL frame up to and +** including frame number aReadMark[pWal->readLock]. The reader will +** use WAL frames up to and including pWal->hdr.mxFrame if pWal->readLock>0 +** Or if pWal->readLock==0, then the reader will ignore the WAL +** completely and get all content directly from the database file. +** If the useWal parameter is 1 then the WAL will never be ignored and +** this routine will always set pWal->readLock>0 on success. +** When the read transaction is completed, the caller must release the +** lock on WAL_READ_LOCK(pWal->readLock) and set pWal->readLock to -1. +** +** This routine uses the nBackfill and aReadMark[] fields of the header +** to select a particular WAL_READ_LOCK() that strives to let the +** checkpoint process do as much work as possible. This routine might +** update values of the aReadMark[] array in the header, but if it does +** so it takes care to hold an exclusive lock on the corresponding +** WAL_READ_LOCK() while changing values. +*/ +static int walTryBeginRead(Wal *pWal, int *pChanged, int useWal, int cnt){ + volatile WalCkptInfo *pInfo; /* Checkpoint information in wal-index */ + u32 mxReadMark; /* Largest aReadMark[] value */ + int mxI; /* Index of largest aReadMark[] value */ + int i; /* Loop counter */ + int rc = SQLITE_OK; /* Return code */ + u32 mxFrame; /* Wal frame to lock to */ + + assert( pWal->readLock<0 ); /* Not currently locked */ + + /* useWal may only be set for read/write connections */ + assert( (pWal->readOnly & WAL_SHM_RDONLY)==0 || useWal==0 ); + + /* Take steps to avoid spinning forever if there is a protocol error. + ** + ** Circumstances that cause a RETRY should only last for the briefest + ** instances of time. No I/O or other system calls are done while the + ** locks are held, so the locks should not be held for very long. But + ** if we are unlucky, another process that is holding a lock might get + ** paged out or take a page-fault that is time-consuming to resolve, + ** during the few nanoseconds that it is holding the lock. In that case, + ** it might take longer than normal for the lock to free. + ** + ** After 5 RETRYs, we begin calling sqlite3OsSleep(). The first few + ** calls to sqlite3OsSleep() have a delay of 1 microsecond. Really this + ** is more of a scheduler yield than an actual delay. But on the 10th + ** an subsequent retries, the delays start becoming longer and longer, + ** so that on the 100th (and last) RETRY we delay for 323 milliseconds. + ** The total delay time before giving up is less than 10 seconds. + */ + if( cnt>5 ){ + int nDelay = 1; /* Pause time in microseconds */ + if( cnt>100 ){ + VVA_ONLY( pWal->lockError = 1; ) + return SQLITE_PROTOCOL; + } + if( cnt>=10 ) nDelay = (cnt-9)*(cnt-9)*39; + sqlite3OsSleep(pWal->pVfs, nDelay); + } + + if( !useWal ){ + assert( rc==SQLITE_OK ); + if( pWal->bShmUnreliable==0 ){ + rc = walIndexReadHdr(pWal, pChanged); + } + if( rc==SQLITE_BUSY ){ + /* If there is not a recovery running in another thread or process + ** then convert BUSY errors to WAL_RETRY. If recovery is known to + ** be running, convert BUSY to BUSY_RECOVERY. There is a race here + ** which might cause WAL_RETRY to be returned even if BUSY_RECOVERY + ** would be technically correct. But the race is benign since with + ** WAL_RETRY this routine will be called again and will probably be + ** right on the second iteration. + */ + if( pWal->apWiData[0]==0 ){ + /* This branch is taken when the xShmMap() method returns SQLITE_BUSY. + ** We assume this is a transient condition, so return WAL_RETRY. The + ** xShmMap() implementation used by the default unix and win32 VFS + ** modules may return SQLITE_BUSY due to a race condition in the + ** code that determines whether or not the shared-memory region + ** must be zeroed before the requested page is returned. + */ + rc = WAL_RETRY; + }else if( SQLITE_OK==(rc = walLockShared(pWal, WAL_RECOVER_LOCK)) ){ + walUnlockShared(pWal, WAL_RECOVER_LOCK); + rc = WAL_RETRY; + }else if( rc==SQLITE_BUSY ){ + rc = SQLITE_BUSY_RECOVERY; + } + } + if( rc!=SQLITE_OK ){ + return rc; + } + else if( pWal->bShmUnreliable ){ + return walBeginShmUnreliable(pWal, pChanged); + } + } + + assert( pWal->nWiData>0 ); + assert( pWal->apWiData[0]!=0 ); + pInfo = walCkptInfo(pWal); + if( !useWal && AtomicLoad(&pInfo->nBackfill)==pWal->hdr.mxFrame +#ifdef SQLITE_ENABLE_SNAPSHOT + && (pWal->pSnapshot==0 || pWal->hdr.mxFrame==0) +#endif + ){ + /* The WAL has been completely backfilled (or it is empty). + ** and can be safely ignored. + */ + rc = walLockShared(pWal, WAL_READ_LOCK(0)); + walShmBarrier(pWal); + if( rc==SQLITE_OK ){ + if( memcmp((void *)walIndexHdr(pWal), &pWal->hdr, sizeof(WalIndexHdr)) ){ + /* It is not safe to allow the reader to continue here if frames + ** may have been appended to the log before READ_LOCK(0) was obtained. + ** When holding READ_LOCK(0), the reader ignores the entire log file, + ** which implies that the database file contains a trustworthy + ** snapshot. Since holding READ_LOCK(0) prevents a checkpoint from + ** happening, this is usually correct. + ** + ** However, if frames have been appended to the log (or if the log + ** is wrapped and written for that matter) before the READ_LOCK(0) + ** is obtained, that is not necessarily true. A checkpointer may + ** have started to backfill the appended frames but crashed before + ** it finished. Leaving a corrupt image in the database file. + */ + walUnlockShared(pWal, WAL_READ_LOCK(0)); + return WAL_RETRY; + } + pWal->readLock = 0; + return SQLITE_OK; + }else if( rc!=SQLITE_BUSY ){ + return rc; + } + } + + /* If we get this far, it means that the reader will want to use + ** the WAL to get at content from recent commits. The job now is + ** to select one of the aReadMark[] entries that is closest to + ** but not exceeding pWal->hdr.mxFrame and lock that entry. + */ + mxReadMark = 0; + mxI = 0; + mxFrame = pWal->hdr.mxFrame; +#ifdef SQLITE_ENABLE_SNAPSHOT + if( pWal->pSnapshot && pWal->pSnapshot->mxFramepSnapshot->mxFrame; + } +#endif + for(i=1; iaReadMark+i); + if( mxReadMark<=thisMark && thisMark<=mxFrame ){ + assert( thisMark!=READMARK_NOT_USED ); + mxReadMark = thisMark; + mxI = i; + } + } + if( (pWal->readOnly & WAL_SHM_RDONLY)==0 + && (mxReadMarkaReadMark+i,mxFrame); + mxReadMark = mxFrame; + mxI = i; + walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1); + break; + }else if( rc!=SQLITE_BUSY ){ + return rc; + } + } + } + if( mxI==0 ){ + assert( rc==SQLITE_BUSY || (pWal->readOnly & WAL_SHM_RDONLY)!=0 ); + return rc==SQLITE_BUSY ? WAL_RETRY : SQLITE_READONLY_CANTINIT; + } + + rc = walLockShared(pWal, WAL_READ_LOCK(mxI)); + if( rc ){ + return rc==SQLITE_BUSY ? WAL_RETRY : rc; + } + /* Now that the read-lock has been obtained, check that neither the + ** value in the aReadMark[] array or the contents of the wal-index + ** header have changed. + ** + ** It is necessary to check that the wal-index header did not change + ** between the time it was read and when the shared-lock was obtained + ** on WAL_READ_LOCK(mxI) was obtained to account for the possibility + ** that the log file may have been wrapped by a writer, or that frames + ** that occur later in the log than pWal->hdr.mxFrame may have been + ** copied into the database by a checkpointer. If either of these things + ** happened, then reading the database with the current value of + ** pWal->hdr.mxFrame risks reading a corrupted snapshot. So, retry + ** instead. + ** + ** Before checking that the live wal-index header has not changed + ** since it was read, set Wal.minFrame to the first frame in the wal + ** file that has not yet been checkpointed. This client will not need + ** to read any frames earlier than minFrame from the wal file - they + ** can be safely read directly from the database file. + ** + ** Because a ShmBarrier() call is made between taking the copy of + ** nBackfill and checking that the wal-header in shared-memory still + ** matches the one cached in pWal->hdr, it is guaranteed that the + ** checkpointer that set nBackfill was not working with a wal-index + ** header newer than that cached in pWal->hdr. If it were, that could + ** cause a problem. The checkpointer could omit to checkpoint + ** a version of page X that lies before pWal->minFrame (call that version + ** A) on the basis that there is a newer version (version B) of the same + ** page later in the wal file. But if version B happens to like past + ** frame pWal->hdr.mxFrame - then the client would incorrectly assume + ** that it can read version A from the database file. However, since + ** we can guarantee that the checkpointer that set nBackfill could not + ** see any pages past pWal->hdr.mxFrame, this problem does not come up. + */ + pWal->minFrame = AtomicLoad(&pInfo->nBackfill)+1; + walShmBarrier(pWal); + if( AtomicLoad(pInfo->aReadMark+mxI)!=mxReadMark + || memcmp((void *)walIndexHdr(pWal), &pWal->hdr, sizeof(WalIndexHdr)) + ){ + walUnlockShared(pWal, WAL_READ_LOCK(mxI)); + return WAL_RETRY; + }else{ + assert( mxReadMark<=pWal->hdr.mxFrame ); + pWal->readLock = (i16)mxI; + } + return rc; +} + +#ifdef SQLITE_ENABLE_SNAPSHOT +/* +** Attempt to reduce the value of the WalCkptInfo.nBackfillAttempted +** variable so that older snapshots can be accessed. To do this, loop +** through all wal frames from nBackfillAttempted to (nBackfill+1), +** comparing their content to the corresponding page with the database +** file, if any. Set nBackfillAttempted to the frame number of the +** first frame for which the wal file content matches the db file. +** +** This is only really safe if the file-system is such that any page +** writes made by earlier checkpointers were atomic operations, which +** is not always true. It is also possible that nBackfillAttempted +** may be left set to a value larger than expected, if a wal frame +** contains content that duplicate of an earlier version of the same +** page. +** +** SQLITE_OK is returned if successful, or an SQLite error code if an +** error occurs. It is not an error if nBackfillAttempted cannot be +** decreased at all. +*/ +SQLITE_PRIVATE int sqlite3WalSnapshotRecover(Wal *pWal){ + int rc; + + assert( pWal->readLock>=0 ); + rc = walLockExclusive(pWal, WAL_CKPT_LOCK, 1); + if( rc==SQLITE_OK ){ + volatile WalCkptInfo *pInfo = walCkptInfo(pWal); + int szPage = (int)pWal->szPage; + i64 szDb; /* Size of db file in bytes */ + + rc = sqlite3OsFileSize(pWal->pDbFd, &szDb); + if( rc==SQLITE_OK ){ + void *pBuf1 = sqlite3_malloc(szPage); + void *pBuf2 = sqlite3_malloc(szPage); + if( pBuf1==0 || pBuf2==0 ){ + rc = SQLITE_NOMEM; + }else{ + u32 i = pInfo->nBackfillAttempted; + for(i=pInfo->nBackfillAttempted; i>AtomicLoad(&pInfo->nBackfill); i--){ + WalHashLoc sLoc; /* Hash table location */ + u32 pgno; /* Page number in db file */ + i64 iDbOff; /* Offset of db file entry */ + i64 iWalOff; /* Offset of wal file entry */ + + rc = walHashGet(pWal, walFramePage(i), &sLoc); + if( rc!=SQLITE_OK ) break; + assert( i - sLoc.iZero - 1 >=0 ); + pgno = sLoc.aPgno[i-sLoc.iZero-1]; + iDbOff = (i64)(pgno-1) * szPage; + + if( iDbOff+szPage<=szDb ){ + iWalOff = walFrameOffset(i, szPage) + WAL_FRAME_HDRSIZE; + rc = sqlite3OsRead(pWal->pWalFd, pBuf1, szPage, iWalOff); + + if( rc==SQLITE_OK ){ + rc = sqlite3OsRead(pWal->pDbFd, pBuf2, szPage, iDbOff); + } + + if( rc!=SQLITE_OK || 0==memcmp(pBuf1, pBuf2, szPage) ){ + break; + } + } + + pInfo->nBackfillAttempted = i-1; + } + } + + sqlite3_free(pBuf1); + sqlite3_free(pBuf2); + } + walUnlockExclusive(pWal, WAL_CKPT_LOCK, 1); + } + + return rc; +} +#endif /* SQLITE_ENABLE_SNAPSHOT */ + +/* +** Begin a read transaction on the database. +** +** This routine used to be called sqlite3OpenSnapshot() and with good reason: +** it takes a snapshot of the state of the WAL and wal-index for the current +** instant in time. The current thread will continue to use this snapshot. +** Other threads might append new content to the WAL and wal-index but +** that extra content is ignored by the current thread. +** +** If the database contents have changes since the previous read +** transaction, then *pChanged is set to 1 before returning. The +** Pager layer will use this to know that its cache is stale and +** needs to be flushed. +*/ +SQLITE_PRIVATE int sqlite3WalBeginReadTransaction(Wal *pWal, int *pChanged){ + int rc; /* Return code */ + int cnt = 0; /* Number of TryBeginRead attempts */ +#ifdef SQLITE_ENABLE_SNAPSHOT + int bChanged = 0; + WalIndexHdr *pSnapshot = pWal->pSnapshot; +#endif + + assert( pWal->ckptLock==0 ); + +#ifdef SQLITE_ENABLE_SNAPSHOT + if( pSnapshot ){ + if( memcmp(pSnapshot, &pWal->hdr, sizeof(WalIndexHdr))!=0 ){ + bChanged = 1; + } + + /* It is possible that there is a checkpointer thread running + ** concurrent with this code. If this is the case, it may be that the + ** checkpointer has already determined that it will checkpoint + ** snapshot X, where X is later in the wal file than pSnapshot, but + ** has not yet set the pInfo->nBackfillAttempted variable to indicate + ** its intent. To avoid the race condition this leads to, ensure that + ** there is no checkpointer process by taking a shared CKPT lock + ** before checking pInfo->nBackfillAttempted. */ + (void)walEnableBlocking(pWal); + rc = walLockShared(pWal, WAL_CKPT_LOCK); + walDisableBlocking(pWal); + + if( rc!=SQLITE_OK ){ + return rc; + } + pWal->ckptLock = 1; + } +#endif + + do{ + rc = walTryBeginRead(pWal, pChanged, 0, ++cnt); + }while( rc==WAL_RETRY ); + testcase( (rc&0xff)==SQLITE_BUSY ); + testcase( (rc&0xff)==SQLITE_IOERR ); + testcase( rc==SQLITE_PROTOCOL ); + testcase( rc==SQLITE_OK ); + +#ifdef SQLITE_ENABLE_SNAPSHOT + if( rc==SQLITE_OK ){ + if( pSnapshot && memcmp(pSnapshot, &pWal->hdr, sizeof(WalIndexHdr))!=0 ){ + /* At this point the client has a lock on an aReadMark[] slot holding + ** a value equal to or smaller than pSnapshot->mxFrame, but pWal->hdr + ** is populated with the wal-index header corresponding to the head + ** of the wal file. Verify that pSnapshot is still valid before + ** continuing. Reasons why pSnapshot might no longer be valid: + ** + ** (1) The WAL file has been reset since the snapshot was taken. + ** In this case, the salt will have changed. + ** + ** (2) A checkpoint as been attempted that wrote frames past + ** pSnapshot->mxFrame into the database file. Note that the + ** checkpoint need not have completed for this to cause problems. + */ + volatile WalCkptInfo *pInfo = walCkptInfo(pWal); + + assert( pWal->readLock>0 || pWal->hdr.mxFrame==0 ); + assert( pInfo->aReadMark[pWal->readLock]<=pSnapshot->mxFrame ); + + /* Check that the wal file has not been wrapped. Assuming that it has + ** not, also check that no checkpointer has attempted to checkpoint any + ** frames beyond pSnapshot->mxFrame. If either of these conditions are + ** true, return SQLITE_ERROR_SNAPSHOT. Otherwise, overwrite pWal->hdr + ** with *pSnapshot and set *pChanged as appropriate for opening the + ** snapshot. */ + if( !memcmp(pSnapshot->aSalt, pWal->hdr.aSalt, sizeof(pWal->hdr.aSalt)) + && pSnapshot->mxFrame>=pInfo->nBackfillAttempted + ){ + assert( pWal->readLock>0 ); + memcpy(&pWal->hdr, pSnapshot, sizeof(WalIndexHdr)); + *pChanged = bChanged; + }else{ + rc = SQLITE_ERROR_SNAPSHOT; + } + + /* A client using a non-current snapshot may not ignore any frames + ** from the start of the wal file. This is because, for a system + ** where (minFrame < iSnapshot < maxFrame), a checkpointer may + ** have omitted to checkpoint a frame earlier than minFrame in + ** the file because there exists a frame after iSnapshot that + ** is the same database page. */ + pWal->minFrame = 1; + + if( rc!=SQLITE_OK ){ + sqlite3WalEndReadTransaction(pWal); + } + } + } + + /* Release the shared CKPT lock obtained above. */ + if( pWal->ckptLock ){ + assert( pSnapshot ); + walUnlockShared(pWal, WAL_CKPT_LOCK); + pWal->ckptLock = 0; + } +#endif + return rc; +} + +/* +** Finish with a read transaction. All this does is release the +** read-lock. +*/ +SQLITE_PRIVATE void sqlite3WalEndReadTransaction(Wal *pWal){ + sqlite3WalEndWriteTransaction(pWal); + if( pWal->readLock>=0 ){ + walUnlockShared(pWal, WAL_READ_LOCK(pWal->readLock)); + pWal->readLock = -1; + } +} + +/* +** Search the wal file for page pgno. If found, set *piRead to the frame that +** contains the page. Otherwise, if pgno is not in the wal file, set *piRead +** to zero. +** +** Return SQLITE_OK if successful, or an error code if an error occurs. If an +** error does occur, the final value of *piRead is undefined. +*/ +SQLITE_PRIVATE int sqlite3WalFindFrame( + Wal *pWal, /* WAL handle */ + Pgno pgno, /* Database page number to read data for */ + u32 *piRead /* OUT: Frame number (or zero) */ +){ + u32 iRead = 0; /* If !=0, WAL frame to return data from */ + u32 iLast = pWal->hdr.mxFrame; /* Last page in WAL for this reader */ + int iHash; /* Used to loop through N hash tables */ + int iMinHash; + + /* This routine is only be called from within a read transaction. */ + assert( pWal->readLock>=0 || pWal->lockError ); + + /* If the "last page" field of the wal-index header snapshot is 0, then + ** no data will be read from the wal under any circumstances. Return early + ** in this case as an optimization. Likewise, if pWal->readLock==0, + ** then the WAL is ignored by the reader so return early, as if the + ** WAL were empty. + */ + if( iLast==0 || (pWal->readLock==0 && pWal->bShmUnreliable==0) ){ + *piRead = 0; + return SQLITE_OK; + } + + /* Search the hash table or tables for an entry matching page number + ** pgno. Each iteration of the following for() loop searches one + ** hash table (each hash table indexes up to HASHTABLE_NPAGE frames). + ** + ** This code might run concurrently to the code in walIndexAppend() + ** that adds entries to the wal-index (and possibly to this hash + ** table). This means the value just read from the hash + ** slot (aHash[iKey]) may have been added before or after the + ** current read transaction was opened. Values added after the + ** read transaction was opened may have been written incorrectly - + ** i.e. these slots may contain garbage data. However, we assume + ** that any slots written before the current read transaction was + ** opened remain unmodified. + ** + ** For the reasons above, the if(...) condition featured in the inner + ** loop of the following block is more stringent that would be required + ** if we had exclusive access to the hash-table: + ** + ** (aPgno[iFrame]==pgno): + ** This condition filters out normal hash-table collisions. + ** + ** (iFrame<=iLast): + ** This condition filters out entries that were added to the hash + ** table after the current read-transaction had started. + */ + iMinHash = walFramePage(pWal->minFrame); + for(iHash=walFramePage(iLast); iHash>=iMinHash; iHash--){ + WalHashLoc sLoc; /* Hash table location */ + int iKey; /* Hash slot index */ + int nCollide; /* Number of hash collisions remaining */ + int rc; /* Error code */ + u32 iH; + + rc = walHashGet(pWal, iHash, &sLoc); + if( rc!=SQLITE_OK ){ + return rc; + } + nCollide = HASHTABLE_NSLOT; + iKey = walHash(pgno); + while( (iH = AtomicLoad(&sLoc.aHash[iKey]))!=0 ){ + u32 iFrame = iH + sLoc.iZero; + if( iFrame<=iLast && iFrame>=pWal->minFrame && sLoc.aPgno[iH-1]==pgno ){ + assert( iFrame>iRead || CORRUPT_DB ); + iRead = iFrame; + } + if( (nCollide--)==0 ){ + return SQLITE_CORRUPT_BKPT; + } + iKey = walNextHash(iKey); + } + if( iRead ) break; + } + +#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT + /* If expensive assert() statements are available, do a linear search + ** of the wal-index file content. Make sure the results agree with the + ** result obtained using the hash indexes above. */ + { + u32 iRead2 = 0; + u32 iTest; + assert( pWal->bShmUnreliable || pWal->minFrame>0 ); + for(iTest=iLast; iTest>=pWal->minFrame && iTest>0; iTest--){ + if( walFramePgno(pWal, iTest)==pgno ){ + iRead2 = iTest; + break; + } + } + assert( iRead==iRead2 ); + } +#endif + + *piRead = iRead; + return SQLITE_OK; +} + +/* +** Read the contents of frame iRead from the wal file into buffer pOut +** (which is nOut bytes in size). Return SQLITE_OK if successful, or an +** error code otherwise. +*/ +SQLITE_PRIVATE int sqlite3WalReadFrame( + Wal *pWal, /* WAL handle */ + u32 iRead, /* Frame to read */ + int nOut, /* Size of buffer pOut in bytes */ + u8 *pOut /* Buffer to write page data to */ +){ + int sz; + i64 iOffset; + sz = pWal->hdr.szPage; + sz = (sz&0xfe00) + ((sz&0x0001)<<16); + testcase( sz<=32768 ); + testcase( sz>=65536 ); + iOffset = walFrameOffset(iRead, sz) + WAL_FRAME_HDRSIZE; + /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL */ + return sqlite3OsRead(pWal->pWalFd, pOut, (nOut>sz ? sz : nOut), iOffset); +} + +/* +** Return the size of the database in pages (or zero, if unknown). +*/ +SQLITE_PRIVATE Pgno sqlite3WalDbsize(Wal *pWal){ + if( pWal && ALWAYS(pWal->readLock>=0) ){ + return pWal->hdr.nPage; + } + return 0; +} + + +/* +** This function starts a write transaction on the WAL. +** +** A read transaction must have already been started by a prior call +** to sqlite3WalBeginReadTransaction(). +** +** If another thread or process has written into the database since +** the read transaction was started, then it is not possible for this +** thread to write as doing so would cause a fork. So this routine +** returns SQLITE_BUSY in that case and no write transaction is started. +** +** There can only be a single writer active at a time. +*/ +SQLITE_PRIVATE int sqlite3WalBeginWriteTransaction(Wal *pWal){ + int rc; + +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT + /* If the write-lock is already held, then it was obtained before the + ** read-transaction was even opened, making this call a no-op. + ** Return early. */ + if( pWal->writeLock ){ + assert( !memcmp(&pWal->hdr,(void *)walIndexHdr(pWal),sizeof(WalIndexHdr)) ); + return SQLITE_OK; + } +#endif + + /* Cannot start a write transaction without first holding a read + ** transaction. */ + assert( pWal->readLock>=0 ); + assert( pWal->writeLock==0 && pWal->iReCksum==0 ); + + if( pWal->readOnly ){ + return SQLITE_READONLY; + } + + /* Only one writer allowed at a time. Get the write lock. Return + ** SQLITE_BUSY if unable. + */ + rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1); + if( rc ){ + return rc; + } + pWal->writeLock = 1; + + /* If another connection has written to the database file since the + ** time the read transaction on this connection was started, then + ** the write is disallowed. + */ + if( memcmp(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr))!=0 ){ + walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1); + pWal->writeLock = 0; + rc = SQLITE_BUSY_SNAPSHOT; + } + + return rc; +} + +/* +** End a write transaction. The commit has already been done. This +** routine merely releases the lock. +*/ +SQLITE_PRIVATE int sqlite3WalEndWriteTransaction(Wal *pWal){ + if( pWal->writeLock ){ + walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1); + pWal->writeLock = 0; + pWal->iReCksum = 0; + pWal->truncateOnCommit = 0; + } + return SQLITE_OK; +} + +/* +** If any data has been written (but not committed) to the log file, this +** function moves the write-pointer back to the start of the transaction. +** +** Additionally, the callback function is invoked for each frame written +** to the WAL since the start of the transaction. If the callback returns +** other than SQLITE_OK, it is not invoked again and the error code is +** returned to the caller. +** +** Otherwise, if the callback function does not return an error, this +** function returns SQLITE_OK. +*/ +SQLITE_PRIVATE int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx){ + int rc = SQLITE_OK; + if( ALWAYS(pWal->writeLock) ){ + Pgno iMax = pWal->hdr.mxFrame; + Pgno iFrame; + + /* Restore the clients cache of the wal-index header to the state it + ** was in before the client began writing to the database. + */ + memcpy(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr)); + + for(iFrame=pWal->hdr.mxFrame+1; + ALWAYS(rc==SQLITE_OK) && iFrame<=iMax; + iFrame++ + ){ + /* This call cannot fail. Unless the page for which the page number + ** is passed as the second argument is (a) in the cache and + ** (b) has an outstanding reference, then xUndo is either a no-op + ** (if (a) is false) or simply expels the page from the cache (if (b) + ** is false). + ** + ** If the upper layer is doing a rollback, it is guaranteed that there + ** are no outstanding references to any page other than page 1. And + ** page 1 is never written to the log until the transaction is + ** committed. As a result, the call to xUndo may not fail. + */ + assert( walFramePgno(pWal, iFrame)!=1 ); + rc = xUndo(pUndoCtx, walFramePgno(pWal, iFrame)); + } + if( iMax!=pWal->hdr.mxFrame ) walCleanupHash(pWal); + } + return rc; +} + +/* +** Argument aWalData must point to an array of WAL_SAVEPOINT_NDATA u32 +** values. This function populates the array with values required to +** "rollback" the write position of the WAL handle back to the current +** point in the event of a savepoint rollback (via WalSavepointUndo()). +*/ +SQLITE_PRIVATE void sqlite3WalSavepoint(Wal *pWal, u32 *aWalData){ + assert( pWal->writeLock ); + aWalData[0] = pWal->hdr.mxFrame; + aWalData[1] = pWal->hdr.aFrameCksum[0]; + aWalData[2] = pWal->hdr.aFrameCksum[1]; + aWalData[3] = pWal->nCkpt; +} + +/* +** Move the write position of the WAL back to the point identified by +** the values in the aWalData[] array. aWalData must point to an array +** of WAL_SAVEPOINT_NDATA u32 values that has been previously populated +** by a call to WalSavepoint(). +*/ +SQLITE_PRIVATE int sqlite3WalSavepointUndo(Wal *pWal, u32 *aWalData){ + int rc = SQLITE_OK; + + assert( pWal->writeLock ); + assert( aWalData[3]!=pWal->nCkpt || aWalData[0]<=pWal->hdr.mxFrame ); + + if( aWalData[3]!=pWal->nCkpt ){ + /* This savepoint was opened immediately after the write-transaction + ** was started. Right after that, the writer decided to wrap around + ** to the start of the log. Update the savepoint values to match. + */ + aWalData[0] = 0; + aWalData[3] = pWal->nCkpt; + } + + if( aWalData[0]hdr.mxFrame ){ + pWal->hdr.mxFrame = aWalData[0]; + pWal->hdr.aFrameCksum[0] = aWalData[1]; + pWal->hdr.aFrameCksum[1] = aWalData[2]; + walCleanupHash(pWal); + } + + return rc; +} + +/* +** This function is called just before writing a set of frames to the log +** file (see sqlite3WalFrames()). It checks to see if, instead of appending +** to the current log file, it is possible to overwrite the start of the +** existing log file with the new frames (i.e. "reset" the log). If so, +** it sets pWal->hdr.mxFrame to 0. Otherwise, pWal->hdr.mxFrame is left +** unchanged. +** +** SQLITE_OK is returned if no error is encountered (regardless of whether +** or not pWal->hdr.mxFrame is modified). An SQLite error code is returned +** if an error occurs. +*/ +static int walRestartLog(Wal *pWal){ + int rc = SQLITE_OK; + int cnt; + + if( pWal->readLock==0 ){ + volatile WalCkptInfo *pInfo = walCkptInfo(pWal); + assert( pInfo->nBackfill==pWal->hdr.mxFrame ); + if( pInfo->nBackfill>0 ){ + u32 salt1; + sqlite3_randomness(4, &salt1); + rc = walLockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1); + if( rc==SQLITE_OK ){ + /* If all readers are using WAL_READ_LOCK(0) (in other words if no + ** readers are currently using the WAL), then the transactions + ** frames will overwrite the start of the existing log. Update the + ** wal-index header to reflect this. + ** + ** In theory it would be Ok to update the cache of the header only + ** at this point. But updating the actual wal-index header is also + ** safe and means there is no special case for sqlite3WalUndo() + ** to handle if this transaction is rolled back. */ + walRestartHdr(pWal, salt1); + walUnlockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1); + }else if( rc!=SQLITE_BUSY ){ + return rc; + } + } + walUnlockShared(pWal, WAL_READ_LOCK(0)); + pWal->readLock = -1; + cnt = 0; + do{ + int notUsed; + rc = walTryBeginRead(pWal, ¬Used, 1, ++cnt); + }while( rc==WAL_RETRY ); + assert( (rc&0xff)!=SQLITE_BUSY ); /* BUSY not possible when useWal==1 */ + testcase( (rc&0xff)==SQLITE_IOERR ); + testcase( rc==SQLITE_PROTOCOL ); + testcase( rc==SQLITE_OK ); + } + return rc; +} + +/* +** Information about the current state of the WAL file and where +** the next fsync should occur - passed from sqlite3WalFrames() into +** walWriteToLog(). +*/ +typedef struct WalWriter { + Wal *pWal; /* The complete WAL information */ + sqlite3_file *pFd; /* The WAL file to which we write */ + sqlite3_int64 iSyncPoint; /* Fsync at this offset */ + int syncFlags; /* Flags for the fsync */ + int szPage; /* Size of one page */ +} WalWriter; + +/* +** Write iAmt bytes of content into the WAL file beginning at iOffset. +** Do a sync when crossing the p->iSyncPoint boundary. +** +** In other words, if iSyncPoint is in between iOffset and iOffset+iAmt, +** first write the part before iSyncPoint, then sync, then write the +** rest. +*/ +static int walWriteToLog( + WalWriter *p, /* WAL to write to */ + void *pContent, /* Content to be written */ + int iAmt, /* Number of bytes to write */ + sqlite3_int64 iOffset /* Start writing at this offset */ +){ + int rc; + if( iOffsetiSyncPoint && iOffset+iAmt>=p->iSyncPoint ){ + int iFirstAmt = (int)(p->iSyncPoint - iOffset); + rc = sqlite3OsWrite(p->pFd, pContent, iFirstAmt, iOffset); + if( rc ) return rc; + iOffset += iFirstAmt; + iAmt -= iFirstAmt; + pContent = (void*)(iFirstAmt + (char*)pContent); + assert( WAL_SYNC_FLAGS(p->syncFlags)!=0 ); + rc = sqlite3OsSync(p->pFd, WAL_SYNC_FLAGS(p->syncFlags)); + if( iAmt==0 || rc ) return rc; + } + rc = sqlite3OsWrite(p->pFd, pContent, iAmt, iOffset); + return rc; +} + +/* +** Write out a single frame of the WAL +*/ +static int walWriteOneFrame( + WalWriter *p, /* Where to write the frame */ + PgHdr *pPage, /* The page of the frame to be written */ + int nTruncate, /* The commit flag. Usually 0. >0 for commit */ + sqlite3_int64 iOffset /* Byte offset at which to write */ +){ + int rc; /* Result code from subfunctions */ + void *pData; /* Data actually written */ + u8 aFrame[WAL_FRAME_HDRSIZE]; /* Buffer to assemble frame-header in */ +#if defined(SQLITE_HAS_CODEC) + if( (pData = sqlcipherPagerCodec(pPage))==0 ) return SQLITE_NOMEM_BKPT; +#else + pData = pPage->pData; +#endif + walEncodeFrame(p->pWal, pPage->pgno, nTruncate, pData, aFrame); + rc = walWriteToLog(p, aFrame, sizeof(aFrame), iOffset); + if( rc ) return rc; + /* Write the page data */ + rc = walWriteToLog(p, pData, p->szPage, iOffset+sizeof(aFrame)); + return rc; +} + +/* +** This function is called as part of committing a transaction within which +** one or more frames have been overwritten. It updates the checksums for +** all frames written to the wal file by the current transaction starting +** with the earliest to have been overwritten. +** +** SQLITE_OK is returned if successful, or an SQLite error code otherwise. +*/ +static int walRewriteChecksums(Wal *pWal, u32 iLast){ + const int szPage = pWal->szPage;/* Database page size */ + int rc = SQLITE_OK; /* Return code */ + u8 *aBuf; /* Buffer to load data from wal file into */ + u8 aFrame[WAL_FRAME_HDRSIZE]; /* Buffer to assemble frame-headers in */ + u32 iRead; /* Next frame to read from wal file */ + i64 iCksumOff; + + aBuf = sqlite3_malloc(szPage + WAL_FRAME_HDRSIZE); + if( aBuf==0 ) return SQLITE_NOMEM_BKPT; + + /* Find the checksum values to use as input for the recalculating the + ** first checksum. If the first frame is frame 1 (implying that the current + ** transaction restarted the wal file), these values must be read from the + ** wal-file header. Otherwise, read them from the frame header of the + ** previous frame. */ + assert( pWal->iReCksum>0 ); + if( pWal->iReCksum==1 ){ + iCksumOff = 24; + }else{ + iCksumOff = walFrameOffset(pWal->iReCksum-1, szPage) + 16; + } + rc = sqlite3OsRead(pWal->pWalFd, aBuf, sizeof(u32)*2, iCksumOff); + pWal->hdr.aFrameCksum[0] = sqlite3Get4byte(aBuf); + pWal->hdr.aFrameCksum[1] = sqlite3Get4byte(&aBuf[sizeof(u32)]); + + iRead = pWal->iReCksum; + pWal->iReCksum = 0; + for(; rc==SQLITE_OK && iRead<=iLast; iRead++){ + i64 iOff = walFrameOffset(iRead, szPage); + rc = sqlite3OsRead(pWal->pWalFd, aBuf, szPage+WAL_FRAME_HDRSIZE, iOff); + if( rc==SQLITE_OK ){ + u32 iPgno, nDbSize; + iPgno = sqlite3Get4byte(aBuf); + nDbSize = sqlite3Get4byte(&aBuf[4]); + + walEncodeFrame(pWal, iPgno, nDbSize, &aBuf[WAL_FRAME_HDRSIZE], aFrame); + rc = sqlite3OsWrite(pWal->pWalFd, aFrame, sizeof(aFrame), iOff); + } + } + + sqlite3_free(aBuf); + return rc; +} + +/* +** Write a set of frames to the log. The caller must hold the write-lock +** on the log file (obtained using sqlite3WalBeginWriteTransaction()). +*/ +SQLITE_PRIVATE int sqlite3WalFrames( + Wal *pWal, /* Wal handle to write to */ + int szPage, /* Database page-size in bytes */ + PgHdr *pList, /* List of dirty pages to write */ + Pgno nTruncate, /* Database size after this commit */ + int isCommit, /* True if this is a commit */ + int sync_flags /* Flags to pass to OsSync() (or 0) */ +){ + int rc; /* Used to catch return codes */ + u32 iFrame; /* Next frame address */ + PgHdr *p; /* Iterator to run through pList with. */ + PgHdr *pLast = 0; /* Last frame in list */ + int nExtra = 0; /* Number of extra copies of last page */ + int szFrame; /* The size of a single frame */ + i64 iOffset; /* Next byte to write in WAL file */ + WalWriter w; /* The writer */ + u32 iFirst = 0; /* First frame that may be overwritten */ + WalIndexHdr *pLive; /* Pointer to shared header */ + + assert( pList ); + assert( pWal->writeLock ); + + /* If this frame set completes a transaction, then nTruncate>0. If + ** nTruncate==0 then this frame set does not complete the transaction. */ + assert( (isCommit!=0)==(nTruncate!=0) ); + +#if defined(SQLITE_TEST) && defined(SQLITE_DEBUG) + { int cnt; for(cnt=0, p=pList; p; p=p->pDirty, cnt++){} + WALTRACE(("WAL%p: frame write begin. %d frames. mxFrame=%d. %s\n", + pWal, cnt, pWal->hdr.mxFrame, isCommit ? "Commit" : "Spill")); + } +#endif + + pLive = (WalIndexHdr*)walIndexHdr(pWal); + if( memcmp(&pWal->hdr, (void *)pLive, sizeof(WalIndexHdr))!=0 ){ + iFirst = pLive->mxFrame+1; + } + + /* See if it is possible to write these frames into the start of the + ** log file, instead of appending to it at pWal->hdr.mxFrame. + */ + if( SQLITE_OK!=(rc = walRestartLog(pWal)) ){ + return rc; + } + + /* If this is the first frame written into the log, write the WAL + ** header to the start of the WAL file. See comments at the top of + ** this source file for a description of the WAL header format. + */ + iFrame = pWal->hdr.mxFrame; + if( iFrame==0 ){ + u8 aWalHdr[WAL_HDRSIZE]; /* Buffer to assemble wal-header in */ + u32 aCksum[2]; /* Checksum for wal-header */ + + sqlite3Put4byte(&aWalHdr[0], (WAL_MAGIC | SQLITE_BIGENDIAN)); + sqlite3Put4byte(&aWalHdr[4], WAL_MAX_VERSION); + sqlite3Put4byte(&aWalHdr[8], szPage); + sqlite3Put4byte(&aWalHdr[12], pWal->nCkpt); + if( pWal->nCkpt==0 ) sqlite3_randomness(8, pWal->hdr.aSalt); + memcpy(&aWalHdr[16], pWal->hdr.aSalt, 8); + walChecksumBytes(1, aWalHdr, WAL_HDRSIZE-2*4, 0, aCksum); + sqlite3Put4byte(&aWalHdr[24], aCksum[0]); + sqlite3Put4byte(&aWalHdr[28], aCksum[1]); + + pWal->szPage = szPage; + pWal->hdr.bigEndCksum = SQLITE_BIGENDIAN; + pWal->hdr.aFrameCksum[0] = aCksum[0]; + pWal->hdr.aFrameCksum[1] = aCksum[1]; + pWal->truncateOnCommit = 1; + + rc = sqlite3OsWrite(pWal->pWalFd, aWalHdr, sizeof(aWalHdr), 0); + WALTRACE(("WAL%p: wal-header write %s\n", pWal, rc ? "failed" : "ok")); + if( rc!=SQLITE_OK ){ + return rc; + } + + /* Sync the header (unless SQLITE_IOCAP_SEQUENTIAL is true or unless + ** all syncing is turned off by PRAGMA synchronous=OFF). Otherwise + ** an out-of-order write following a WAL restart could result in + ** database corruption. See the ticket: + ** + ** https://sqlite.org/src/info/ff5be73dee + */ + if( pWal->syncHeader ){ + rc = sqlite3OsSync(pWal->pWalFd, CKPT_SYNC_FLAGS(sync_flags)); + if( rc ) return rc; + } + } + if( (int)pWal->szPage!=szPage ){ + return SQLITE_CORRUPT_BKPT; /* TH3 test case: cov1/corrupt155.test */ + } + + /* Setup information needed to write frames into the WAL */ + w.pWal = pWal; + w.pFd = pWal->pWalFd; + w.iSyncPoint = 0; + w.syncFlags = sync_flags; + w.szPage = szPage; + iOffset = walFrameOffset(iFrame+1, szPage); + szFrame = szPage + WAL_FRAME_HDRSIZE; + + /* Write all frames into the log file exactly once */ + for(p=pList; p; p=p->pDirty){ + int nDbSize; /* 0 normally. Positive == commit flag */ + + /* Check if this page has already been written into the wal file by + ** the current transaction. If so, overwrite the existing frame and + ** set Wal.writeLock to WAL_WRITELOCK_RECKSUM - indicating that + ** checksums must be recomputed when the transaction is committed. */ + if( iFirst && (p->pDirty || isCommit==0) ){ + u32 iWrite = 0; + VVA_ONLY(rc =) sqlite3WalFindFrame(pWal, p->pgno, &iWrite); + assert( rc==SQLITE_OK || iWrite==0 ); + if( iWrite>=iFirst ){ + i64 iOff = walFrameOffset(iWrite, szPage) + WAL_FRAME_HDRSIZE; + void *pData; + if( pWal->iReCksum==0 || iWriteiReCksum ){ + pWal->iReCksum = iWrite; + } +#if defined(SQLITE_HAS_CODEC) + if( (pData = sqlcipherPagerCodec(p))==0 ) return SQLITE_NOMEM; +#else + pData = p->pData; +#endif + rc = sqlite3OsWrite(pWal->pWalFd, pData, szPage, iOff); + if( rc ) return rc; + p->flags &= ~PGHDR_WAL_APPEND; + continue; + } + } + + iFrame++; + assert( iOffset==walFrameOffset(iFrame, szPage) ); + nDbSize = (isCommit && p->pDirty==0) ? nTruncate : 0; + rc = walWriteOneFrame(&w, p, nDbSize, iOffset); + if( rc ) return rc; + pLast = p; + iOffset += szFrame; + p->flags |= PGHDR_WAL_APPEND; + } + + /* Recalculate checksums within the wal file if required. */ + if( isCommit && pWal->iReCksum ){ + rc = walRewriteChecksums(pWal, iFrame); + if( rc ) return rc; + } + + /* If this is the end of a transaction, then we might need to pad + ** the transaction and/or sync the WAL file. + ** + ** Padding and syncing only occur if this set of frames complete a + ** transaction and if PRAGMA synchronous=FULL. If synchronous==NORMAL + ** or synchronous==OFF, then no padding or syncing are needed. + ** + ** If SQLITE_IOCAP_POWERSAFE_OVERWRITE is defined, then padding is not + ** needed and only the sync is done. If padding is needed, then the + ** final frame is repeated (with its commit mark) until the next sector + ** boundary is crossed. Only the part of the WAL prior to the last + ** sector boundary is synced; the part of the last frame that extends + ** past the sector boundary is written after the sync. + */ + if( isCommit && WAL_SYNC_FLAGS(sync_flags)!=0 ){ + int bSync = 1; + if( pWal->padToSectorBoundary ){ + int sectorSize = sqlite3SectorSize(pWal->pWalFd); + w.iSyncPoint = ((iOffset+sectorSize-1)/sectorSize)*sectorSize; + bSync = (w.iSyncPoint==iOffset); + testcase( bSync ); + while( iOffsettruncateOnCommit && pWal->mxWalSize>=0 ){ + i64 sz = pWal->mxWalSize; + if( walFrameOffset(iFrame+nExtra+1, szPage)>pWal->mxWalSize ){ + sz = walFrameOffset(iFrame+nExtra+1, szPage); + } + walLimitSize(pWal, sz); + pWal->truncateOnCommit = 0; + } + + /* Append data to the wal-index. It is not necessary to lock the + ** wal-index to do this as the SQLITE_SHM_WRITE lock held on the wal-index + ** guarantees that there are no other writers, and no data that may + ** be in use by existing readers is being overwritten. + */ + iFrame = pWal->hdr.mxFrame; + for(p=pList; p && rc==SQLITE_OK; p=p->pDirty){ + if( (p->flags & PGHDR_WAL_APPEND)==0 ) continue; + iFrame++; + rc = walIndexAppend(pWal, iFrame, p->pgno); + } + assert( pLast!=0 || nExtra==0 ); + while( rc==SQLITE_OK && nExtra>0 ){ + iFrame++; + nExtra--; + rc = walIndexAppend(pWal, iFrame, pLast->pgno); + } + + if( rc==SQLITE_OK ){ + /* Update the private copy of the header. */ + pWal->hdr.szPage = (u16)((szPage&0xff00) | (szPage>>16)); + testcase( szPage<=32768 ); + testcase( szPage>=65536 ); + pWal->hdr.mxFrame = iFrame; + if( isCommit ){ + pWal->hdr.iChange++; + pWal->hdr.nPage = nTruncate; + } + /* If this is a commit, update the wal-index header too. */ + if( isCommit ){ + walIndexWriteHdr(pWal); + pWal->iCallback = iFrame; + } + } + + WALTRACE(("WAL%p: frame write %s\n", pWal, rc ? "failed" : "ok")); + return rc; +} + +/* +** This routine is called to implement sqlite3_wal_checkpoint() and +** related interfaces. +** +** Obtain a CHECKPOINT lock and then backfill as much information as +** we can from WAL into the database. +** +** If parameter xBusy is not NULL, it is a pointer to a busy-handler +** callback. In this case this function runs a blocking checkpoint. +*/ +SQLITE_PRIVATE int sqlite3WalCheckpoint( + Wal *pWal, /* Wal connection */ + sqlite3 *db, /* Check this handle's interrupt flag */ + int eMode, /* PASSIVE, FULL, RESTART, or TRUNCATE */ + int (*xBusy)(void*), /* Function to call when busy */ + void *pBusyArg, /* Context argument for xBusyHandler */ + int sync_flags, /* Flags to sync db file with (or 0) */ + int nBuf, /* Size of temporary buffer */ + u8 *zBuf, /* Temporary buffer to use */ + int *pnLog, /* OUT: Number of frames in WAL */ + int *pnCkpt /* OUT: Number of backfilled frames in WAL */ +){ + int rc; /* Return code */ + int isChanged = 0; /* True if a new wal-index header is loaded */ + int eMode2 = eMode; /* Mode to pass to walCheckpoint() */ + int (*xBusy2)(void*) = xBusy; /* Busy handler for eMode2 */ + + assert( pWal->ckptLock==0 ); + assert( pWal->writeLock==0 ); + + /* EVIDENCE-OF: R-62920-47450 The busy-handler callback is never invoked + ** in the SQLITE_CHECKPOINT_PASSIVE mode. */ + assert( eMode!=SQLITE_CHECKPOINT_PASSIVE || xBusy==0 ); + + if( pWal->readOnly ) return SQLITE_READONLY; + WALTRACE(("WAL%p: checkpoint begins\n", pWal)); + + /* Enable blocking locks, if possible. If blocking locks are successfully + ** enabled, set xBusy2=0 so that the busy-handler is never invoked. */ + sqlite3WalDb(pWal, db); + (void)walEnableBlocking(pWal); + + /* IMPLEMENTATION-OF: R-62028-47212 All calls obtain an exclusive + ** "checkpoint" lock on the database file. + ** EVIDENCE-OF: R-10421-19736 If any other process is running a + ** checkpoint operation at the same time, the lock cannot be obtained and + ** SQLITE_BUSY is returned. + ** EVIDENCE-OF: R-53820-33897 Even if there is a busy-handler configured, + ** it will not be invoked in this case. + */ + rc = walLockExclusive(pWal, WAL_CKPT_LOCK, 1); + testcase( rc==SQLITE_BUSY ); + testcase( rc!=SQLITE_OK && xBusy2!=0 ); + if( rc==SQLITE_OK ){ + pWal->ckptLock = 1; + + /* IMPLEMENTATION-OF: R-59782-36818 The SQLITE_CHECKPOINT_FULL, RESTART and + ** TRUNCATE modes also obtain the exclusive "writer" lock on the database + ** file. + ** + ** EVIDENCE-OF: R-60642-04082 If the writer lock cannot be obtained + ** immediately, and a busy-handler is configured, it is invoked and the + ** writer lock retried until either the busy-handler returns 0 or the + ** lock is successfully obtained. + */ + if( eMode!=SQLITE_CHECKPOINT_PASSIVE ){ + rc = walBusyLock(pWal, xBusy2, pBusyArg, WAL_WRITE_LOCK, 1); + if( rc==SQLITE_OK ){ + pWal->writeLock = 1; + }else if( rc==SQLITE_BUSY ){ + eMode2 = SQLITE_CHECKPOINT_PASSIVE; + xBusy2 = 0; + rc = SQLITE_OK; + } + } + } + + + /* Read the wal-index header. */ + if( rc==SQLITE_OK ){ + walDisableBlocking(pWal); + rc = walIndexReadHdr(pWal, &isChanged); + (void)walEnableBlocking(pWal); + if( isChanged && pWal->pDbFd->pMethods->iVersion>=3 ){ + sqlite3OsUnfetch(pWal->pDbFd, 0, 0); + } + } + + /* Copy data from the log to the database file. */ + if( rc==SQLITE_OK ){ + + if( pWal->hdr.mxFrame && walPagesize(pWal)!=nBuf ){ + rc = SQLITE_CORRUPT_BKPT; + }else{ + rc = walCheckpoint(pWal, db, eMode2, xBusy2, pBusyArg, sync_flags, zBuf); + } + + /* If no error occurred, set the output variables. */ + if( rc==SQLITE_OK || rc==SQLITE_BUSY ){ + if( pnLog ) *pnLog = (int)pWal->hdr.mxFrame; + if( pnCkpt ) *pnCkpt = (int)(walCkptInfo(pWal)->nBackfill); + } + } + + if( isChanged ){ + /* If a new wal-index header was loaded before the checkpoint was + ** performed, then the pager-cache associated with pWal is now + ** out of date. So zero the cached wal-index header to ensure that + ** next time the pager opens a snapshot on this database it knows that + ** the cache needs to be reset. + */ + memset(&pWal->hdr, 0, sizeof(WalIndexHdr)); + } + + walDisableBlocking(pWal); + sqlite3WalDb(pWal, 0); + + /* Release the locks. */ + sqlite3WalEndWriteTransaction(pWal); + if( pWal->ckptLock ){ + walUnlockExclusive(pWal, WAL_CKPT_LOCK, 1); + pWal->ckptLock = 0; + } + WALTRACE(("WAL%p: checkpoint %s\n", pWal, rc ? "failed" : "ok")); +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT + if( rc==SQLITE_BUSY_TIMEOUT ) rc = SQLITE_BUSY; +#endif + return (rc==SQLITE_OK && eMode!=eMode2 ? SQLITE_BUSY : rc); +} + +/* Return the value to pass to a sqlite3_wal_hook callback, the +** number of frames in the WAL at the point of the last commit since +** sqlite3WalCallback() was called. If no commits have occurred since +** the last call, then return 0. +*/ +SQLITE_PRIVATE int sqlite3WalCallback(Wal *pWal){ + u32 ret = 0; + if( pWal ){ + ret = pWal->iCallback; + pWal->iCallback = 0; + } + return (int)ret; +} + +/* +** This function is called to change the WAL subsystem into or out +** of locking_mode=EXCLUSIVE. +** +** If op is zero, then attempt to change from locking_mode=EXCLUSIVE +** into locking_mode=NORMAL. This means that we must acquire a lock +** on the pWal->readLock byte. If the WAL is already in locking_mode=NORMAL +** or if the acquisition of the lock fails, then return 0. If the +** transition out of exclusive-mode is successful, return 1. This +** operation must occur while the pager is still holding the exclusive +** lock on the main database file. +** +** If op is one, then change from locking_mode=NORMAL into +** locking_mode=EXCLUSIVE. This means that the pWal->readLock must +** be released. Return 1 if the transition is made and 0 if the +** WAL is already in exclusive-locking mode - meaning that this +** routine is a no-op. The pager must already hold the exclusive lock +** on the main database file before invoking this operation. +** +** If op is negative, then do a dry-run of the op==1 case but do +** not actually change anything. The pager uses this to see if it +** should acquire the database exclusive lock prior to invoking +** the op==1 case. +*/ +SQLITE_PRIVATE int sqlite3WalExclusiveMode(Wal *pWal, int op){ + int rc; + assert( pWal->writeLock==0 ); + assert( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE || op==-1 ); + + /* pWal->readLock is usually set, but might be -1 if there was a + ** prior error while attempting to acquire are read-lock. This cannot + ** happen if the connection is actually in exclusive mode (as no xShmLock + ** locks are taken in this case). Nor should the pager attempt to + ** upgrade to exclusive-mode following such an error. + */ + assert( pWal->readLock>=0 || pWal->lockError ); + assert( pWal->readLock>=0 || (op<=0 && pWal->exclusiveMode==0) ); + + if( op==0 ){ + if( pWal->exclusiveMode!=WAL_NORMAL_MODE ){ + pWal->exclusiveMode = WAL_NORMAL_MODE; + if( walLockShared(pWal, WAL_READ_LOCK(pWal->readLock))!=SQLITE_OK ){ + pWal->exclusiveMode = WAL_EXCLUSIVE_MODE; + } + rc = pWal->exclusiveMode==WAL_NORMAL_MODE; + }else{ + /* Already in locking_mode=NORMAL */ + rc = 0; + } + }else if( op>0 ){ + assert( pWal->exclusiveMode==WAL_NORMAL_MODE ); + assert( pWal->readLock>=0 ); + walUnlockShared(pWal, WAL_READ_LOCK(pWal->readLock)); + pWal->exclusiveMode = WAL_EXCLUSIVE_MODE; + rc = 1; + }else{ + rc = pWal->exclusiveMode==WAL_NORMAL_MODE; + } + return rc; +} + +/* +** Return true if the argument is non-NULL and the WAL module is using +** heap-memory for the wal-index. Otherwise, if the argument is NULL or the +** WAL module is using shared-memory, return false. +*/ +SQLITE_PRIVATE int sqlite3WalHeapMemory(Wal *pWal){ + return (pWal && pWal->exclusiveMode==WAL_HEAPMEMORY_MODE ); +} + +#ifdef SQLITE_ENABLE_SNAPSHOT +/* Create a snapshot object. The content of a snapshot is opaque to +** every other subsystem, so the WAL module can put whatever it needs +** in the object. +*/ +SQLITE_PRIVATE int sqlite3WalSnapshotGet(Wal *pWal, sqlite3_snapshot **ppSnapshot){ + int rc = SQLITE_OK; + WalIndexHdr *pRet; + static const u32 aZero[4] = { 0, 0, 0, 0 }; + + assert( pWal->readLock>=0 && pWal->writeLock==0 ); + + if( memcmp(&pWal->hdr.aFrameCksum[0],aZero,16)==0 ){ + *ppSnapshot = 0; + return SQLITE_ERROR; + } + pRet = (WalIndexHdr*)sqlite3_malloc(sizeof(WalIndexHdr)); + if( pRet==0 ){ + rc = SQLITE_NOMEM_BKPT; + }else{ + memcpy(pRet, &pWal->hdr, sizeof(WalIndexHdr)); + *ppSnapshot = (sqlite3_snapshot*)pRet; + } + + return rc; +} + +/* Try to open on pSnapshot when the next read-transaction starts +*/ +SQLITE_PRIVATE void sqlite3WalSnapshotOpen( + Wal *pWal, + sqlite3_snapshot *pSnapshot +){ + pWal->pSnapshot = (WalIndexHdr*)pSnapshot; +} + +/* +** Return a +ve value if snapshot p1 is newer than p2. A -ve value if +** p1 is older than p2 and zero if p1 and p2 are the same snapshot. +*/ +SQLITE_API int sqlite3_snapshot_cmp(sqlite3_snapshot *p1, sqlite3_snapshot *p2){ + WalIndexHdr *pHdr1 = (WalIndexHdr*)p1; + WalIndexHdr *pHdr2 = (WalIndexHdr*)p2; + + /* aSalt[0] is a copy of the value stored in the wal file header. It + ** is incremented each time the wal file is restarted. */ + if( pHdr1->aSalt[0]aSalt[0] ) return -1; + if( pHdr1->aSalt[0]>pHdr2->aSalt[0] ) return +1; + if( pHdr1->mxFramemxFrame ) return -1; + if( pHdr1->mxFrame>pHdr2->mxFrame ) return +1; + return 0; +} + +/* +** The caller currently has a read transaction open on the database. +** This function takes a SHARED lock on the CHECKPOINTER slot and then +** checks if the snapshot passed as the second argument is still +** available. If so, SQLITE_OK is returned. +** +** If the snapshot is not available, SQLITE_ERROR is returned. Or, if +** the CHECKPOINTER lock cannot be obtained, SQLITE_BUSY. If any error +** occurs (any value other than SQLITE_OK is returned), the CHECKPOINTER +** lock is released before returning. +*/ +SQLITE_PRIVATE int sqlite3WalSnapshotCheck(Wal *pWal, sqlite3_snapshot *pSnapshot){ + int rc; + rc = walLockShared(pWal, WAL_CKPT_LOCK); + if( rc==SQLITE_OK ){ + WalIndexHdr *pNew = (WalIndexHdr*)pSnapshot; + if( memcmp(pNew->aSalt, pWal->hdr.aSalt, sizeof(pWal->hdr.aSalt)) + || pNew->mxFramenBackfillAttempted + ){ + rc = SQLITE_ERROR_SNAPSHOT; + walUnlockShared(pWal, WAL_CKPT_LOCK); + } + } + return rc; +} + +/* +** Release a lock obtained by an earlier successful call to +** sqlite3WalSnapshotCheck(). +*/ +SQLITE_PRIVATE void sqlite3WalSnapshotUnlock(Wal *pWal){ + assert( pWal ); + walUnlockShared(pWal, WAL_CKPT_LOCK); +} + + +#endif /* SQLITE_ENABLE_SNAPSHOT */ + +#ifdef SQLITE_ENABLE_ZIPVFS +/* +** If the argument is not NULL, it points to a Wal object that holds a +** read-lock. This function returns the database page-size if it is known, +** or zero if it is not (or if pWal is NULL). +*/ +SQLITE_PRIVATE int sqlite3WalFramesize(Wal *pWal){ + assert( pWal==0 || pWal->readLock>=0 ); + return (pWal ? pWal->szPage : 0); +} +#endif + +/* Return the sqlite3_file object for the WAL file +*/ +SQLITE_PRIVATE sqlite3_file *sqlite3WalFile(Wal *pWal){ + return pWal->pWalFd; +} + +#endif /* #ifndef SQLITE_OMIT_WAL */ + +/************** End of wal.c *************************************************/ +/************** Begin file btmutex.c *****************************************/ +/* +** 2007 August 27 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains code used to implement mutexes on Btree objects. +** This code really belongs in btree.c. But btree.c is getting too +** big and we want to break it down some. This packaged seemed like +** a good breakout. +*/ +/************** Include btreeInt.h in the middle of btmutex.c ****************/ +/************** Begin file btreeInt.h ****************************************/ +/* +** 2004 April 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file implements an external (disk-based) database using BTrees. +** For a detailed discussion of BTrees, refer to +** +** Donald E. Knuth, THE ART OF COMPUTER PROGRAMMING, Volume 3: +** "Sorting And Searching", pages 473-480. Addison-Wesley +** Publishing Company, Reading, Massachusetts. +** +** The basic idea is that each page of the file contains N database +** entries and N+1 pointers to subpages. +** +** ---------------------------------------------------------------- +** | Ptr(0) | Key(0) | Ptr(1) | Key(1) | ... | Key(N-1) | Ptr(N) | +** ---------------------------------------------------------------- +** +** All of the keys on the page that Ptr(0) points to have values less +** than Key(0). All of the keys on page Ptr(1) and its subpages have +** values greater than Key(0) and less than Key(1). All of the keys +** on Ptr(N) and its subpages have values greater than Key(N-1). And +** so forth. +** +** Finding a particular key requires reading O(log(M)) pages from the +** disk where M is the number of entries in the tree. +** +** In this implementation, a single file can hold one or more separate +** BTrees. Each BTree is identified by the index of its root page. The +** key and data for any entry are combined to form the "payload". A +** fixed amount of payload can be carried directly on the database +** page. If the payload is larger than the preset amount then surplus +** bytes are stored on overflow pages. The payload for an entry +** and the preceding pointer are combined to form a "Cell". Each +** page has a small header which contains the Ptr(N) pointer and other +** information such as the size of key and data. +** +** FORMAT DETAILS +** +** The file is divided into pages. The first page is called page 1, +** the second is page 2, and so forth. A page number of zero indicates +** "no such page". The page size can be any power of 2 between 512 and 65536. +** Each page can be either a btree page, a freelist page, an overflow +** page, or a pointer-map page. +** +** The first page is always a btree page. The first 100 bytes of the first +** page contain a special header (the "file header") that describes the file. +** The format of the file header is as follows: +** +** OFFSET SIZE DESCRIPTION +** 0 16 Header string: "SQLite format 3\000" +** 16 2 Page size in bytes. (1 means 65536) +** 18 1 File format write version +** 19 1 File format read version +** 20 1 Bytes of unused space at the end of each page +** 21 1 Max embedded payload fraction (must be 64) +** 22 1 Min embedded payload fraction (must be 32) +** 23 1 Min leaf payload fraction (must be 32) +** 24 4 File change counter +** 28 4 Reserved for future use +** 32 4 First freelist page +** 36 4 Number of freelist pages in the file +** 40 60 15 4-byte meta values passed to higher layers +** +** 40 4 Schema cookie +** 44 4 File format of schema layer +** 48 4 Size of page cache +** 52 4 Largest root-page (auto/incr_vacuum) +** 56 4 1=UTF-8 2=UTF16le 3=UTF16be +** 60 4 User version +** 64 4 Incremental vacuum mode +** 68 4 Application-ID +** 72 20 unused +** 92 4 The version-valid-for number +** 96 4 SQLITE_VERSION_NUMBER +** +** All of the integer values are big-endian (most significant byte first). +** +** The file change counter is incremented when the database is changed +** This counter allows other processes to know when the file has changed +** and thus when they need to flush their cache. +** +** The max embedded payload fraction is the amount of the total usable +** space in a page that can be consumed by a single cell for standard +** B-tree (non-LEAFDATA) tables. A value of 255 means 100%. The default +** is to limit the maximum cell size so that at least 4 cells will fit +** on one page. Thus the default max embedded payload fraction is 64. +** +** If the payload for a cell is larger than the max payload, then extra +** payload is spilled to overflow pages. Once an overflow page is allocated, +** as many bytes as possible are moved into the overflow pages without letting +** the cell size drop below the min embedded payload fraction. +** +** The min leaf payload fraction is like the min embedded payload fraction +** except that it applies to leaf nodes in a LEAFDATA tree. The maximum +** payload fraction for a LEAFDATA tree is always 100% (or 255) and it +** not specified in the header. +** +** Each btree pages is divided into three sections: The header, the +** cell pointer array, and the cell content area. Page 1 also has a 100-byte +** file header that occurs before the page header. +** +** |----------------| +** | file header | 100 bytes. Page 1 only. +** |----------------| +** | page header | 8 bytes for leaves. 12 bytes for interior nodes +** |----------------| +** | cell pointer | | 2 bytes per cell. Sorted order. +** | array | | Grows downward +** | | v +** |----------------| +** | unallocated | +** | space | +** |----------------| ^ Grows upwards +** | cell content | | Arbitrary order interspersed with freeblocks. +** | area | | and free space fragments. +** |----------------| +** +** The page headers looks like this: +** +** OFFSET SIZE DESCRIPTION +** 0 1 Flags. 1: intkey, 2: zerodata, 4: leafdata, 8: leaf +** 1 2 byte offset to the first freeblock +** 3 2 number of cells on this page +** 5 2 first byte of the cell content area +** 7 1 number of fragmented free bytes +** 8 4 Right child (the Ptr(N) value). Omitted on leaves. +** +** The flags define the format of this btree page. The leaf flag means that +** this page has no children. The zerodata flag means that this page carries +** only keys and no data. The intkey flag means that the key is an integer +** which is stored in the key size entry of the cell header rather than in +** the payload area. +** +** The cell pointer array begins on the first byte after the page header. +** The cell pointer array contains zero or more 2-byte numbers which are +** offsets from the beginning of the page to the cell content in the cell +** content area. The cell pointers occur in sorted order. The system strives +** to keep free space after the last cell pointer so that new cells can +** be easily added without having to defragment the page. +** +** Cell content is stored at the very end of the page and grows toward the +** beginning of the page. +** +** Unused space within the cell content area is collected into a linked list of +** freeblocks. Each freeblock is at least 4 bytes in size. The byte offset +** to the first freeblock is given in the header. Freeblocks occur in +** increasing order. Because a freeblock must be at least 4 bytes in size, +** any group of 3 or fewer unused bytes in the cell content area cannot +** exist on the freeblock chain. A group of 3 or fewer free bytes is called +** a fragment. The total number of bytes in all fragments is recorded. +** in the page header at offset 7. +** +** SIZE DESCRIPTION +** 2 Byte offset of the next freeblock +** 2 Bytes in this freeblock +** +** Cells are of variable length. Cells are stored in the cell content area at +** the end of the page. Pointers to the cells are in the cell pointer array +** that immediately follows the page header. Cells is not necessarily +** contiguous or in order, but cell pointers are contiguous and in order. +** +** Cell content makes use of variable length integers. A variable +** length integer is 1 to 9 bytes where the lower 7 bits of each +** byte are used. The integer consists of all bytes that have bit 8 set and +** the first byte with bit 8 clear. The most significant byte of the integer +** appears first. A variable-length integer may not be more than 9 bytes long. +** As a special case, all 8 bits of the 9th byte are used as data. This +** allows a 64-bit integer to be encoded in 9 bytes. +** +** 0x00 becomes 0x00000000 +** 0x7f becomes 0x0000007f +** 0x81 0x00 becomes 0x00000080 +** 0x82 0x00 becomes 0x00000100 +** 0x80 0x7f becomes 0x0000007f +** 0x8a 0x91 0xd1 0xac 0x78 becomes 0x12345678 +** 0x81 0x81 0x81 0x81 0x01 becomes 0x10204081 +** +** Variable length integers are used for rowids and to hold the number of +** bytes of key and data in a btree cell. +** +** The content of a cell looks like this: +** +** SIZE DESCRIPTION +** 4 Page number of the left child. Omitted if leaf flag is set. +** var Number of bytes of data. Omitted if the zerodata flag is set. +** var Number of bytes of key. Or the key itself if intkey flag is set. +** * Payload +** 4 First page of the overflow chain. Omitted if no overflow +** +** Overflow pages form a linked list. Each page except the last is completely +** filled with data (pagesize - 4 bytes). The last page can have as little +** as 1 byte of data. +** +** SIZE DESCRIPTION +** 4 Page number of next overflow page +** * Data +** +** Freelist pages come in two subtypes: trunk pages and leaf pages. The +** file header points to the first in a linked list of trunk page. Each trunk +** page points to multiple leaf pages. The content of a leaf page is +** unspecified. A trunk page looks like this: +** +** SIZE DESCRIPTION +** 4 Page number of next trunk page +** 4 Number of leaf pointers on this page +** * zero or more pages numbers of leaves +*/ +/* #include "sqliteInt.h" */ + + +/* The following value is the maximum cell size assuming a maximum page +** size give above. +*/ +#define MX_CELL_SIZE(pBt) ((int)(pBt->pageSize-8)) + +/* The maximum number of cells on a single page of the database. This +** assumes a minimum cell size of 6 bytes (4 bytes for the cell itself +** plus 2 bytes for the index to the cell in the page header). Such +** small cells will be rare, but they are possible. +*/ +#define MX_CELL(pBt) ((pBt->pageSize-8)/6) + +/* Forward declarations */ +typedef struct MemPage MemPage; +typedef struct BtLock BtLock; +typedef struct CellInfo CellInfo; + +/* +** This is a magic string that appears at the beginning of every +** SQLite database in order to identify the file as a real database. +** +** You can change this value at compile-time by specifying a +** -DSQLITE_FILE_HEADER="..." on the compiler command-line. The +** header must be exactly 16 bytes including the zero-terminator so +** the string itself should be 15 characters long. If you change +** the header, then your custom library will not be able to read +** databases generated by the standard tools and the standard tools +** will not be able to read databases created by your custom library. +*/ +#ifndef SQLITE_FILE_HEADER /* 123456789 123456 */ +# define SQLITE_FILE_HEADER "SQLite format 3" +#endif + +/* +** Page type flags. An ORed combination of these flags appear as the +** first byte of on-disk image of every BTree page. +*/ +#define PTF_INTKEY 0x01 +#define PTF_ZERODATA 0x02 +#define PTF_LEAFDATA 0x04 +#define PTF_LEAF 0x08 + +/* +** An instance of this object stores information about each a single database +** page that has been loaded into memory. The information in this object +** is derived from the raw on-disk page content. +** +** As each database page is loaded into memory, the pager allocats an +** instance of this object and zeros the first 8 bytes. (This is the +** "extra" information associated with each page of the pager.) +** +** Access to all fields of this structure is controlled by the mutex +** stored in MemPage.pBt->mutex. +*/ +struct MemPage { + u8 isInit; /* True if previously initialized. MUST BE FIRST! */ + u8 intKey; /* True if table b-trees. False for index b-trees */ + u8 intKeyLeaf; /* True if the leaf of an intKey table */ + Pgno pgno; /* Page number for this page */ + /* Only the first 8 bytes (above) are zeroed by pager.c when a new page + ** is allocated. All fields that follow must be initialized before use */ + u8 leaf; /* True if a leaf page */ + u8 hdrOffset; /* 100 for page 1. 0 otherwise */ + u8 childPtrSize; /* 0 if leaf==1. 4 if leaf==0 */ + u8 max1bytePayload; /* min(maxLocal,127) */ + u8 nOverflow; /* Number of overflow cell bodies in aCell[] */ + u16 maxLocal; /* Copy of BtShared.maxLocal or BtShared.maxLeaf */ + u16 minLocal; /* Copy of BtShared.minLocal or BtShared.minLeaf */ + u16 cellOffset; /* Index in aData of first cell pointer */ + int nFree; /* Number of free bytes on the page. -1 for unknown */ + u16 nCell; /* Number of cells on this page, local and ovfl */ + u16 maskPage; /* Mask for page offset */ + u16 aiOvfl[4]; /* Insert the i-th overflow cell before the aiOvfl-th + ** non-overflow cell */ + u8 *apOvfl[4]; /* Pointers to the body of overflow cells */ + BtShared *pBt; /* Pointer to BtShared that this page is part of */ + u8 *aData; /* Pointer to disk image of the page data */ + u8 *aDataEnd; /* One byte past the end of the entire page - not just + ** the usable space, the entire page. Used to prevent + ** corruption-induced buffer overflow. */ + u8 *aCellIdx; /* The cell index area */ + u8 *aDataOfst; /* Same as aData for leaves. aData+4 for interior */ + DbPage *pDbPage; /* Pager page handle */ + u16 (*xCellSize)(MemPage*,u8*); /* cellSizePtr method */ + void (*xParseCell)(MemPage*,u8*,CellInfo*); /* btreeParseCell method */ +}; + +/* +** A linked list of the following structures is stored at BtShared.pLock. +** Locks are added (or upgraded from READ_LOCK to WRITE_LOCK) when a cursor +** is opened on the table with root page BtShared.iTable. Locks are removed +** from this list when a transaction is committed or rolled back, or when +** a btree handle is closed. +*/ +struct BtLock { + Btree *pBtree; /* Btree handle holding this lock */ + Pgno iTable; /* Root page of table */ + u8 eLock; /* READ_LOCK or WRITE_LOCK */ + BtLock *pNext; /* Next in BtShared.pLock list */ +}; + +/* Candidate values for BtLock.eLock */ +#define READ_LOCK 1 +#define WRITE_LOCK 2 + +/* A Btree handle +** +** A database connection contains a pointer to an instance of +** this object for every database file that it has open. This structure +** is opaque to the database connection. The database connection cannot +** see the internals of this structure and only deals with pointers to +** this structure. +** +** For some database files, the same underlying database cache might be +** shared between multiple connections. In that case, each connection +** has it own instance of this object. But each instance of this object +** points to the same BtShared object. The database cache and the +** schema associated with the database file are all contained within +** the BtShared object. +** +** All fields in this structure are accessed under sqlite3.mutex. +** The pBt pointer itself may not be changed while there exists cursors +** in the referenced BtShared that point back to this Btree since those +** cursors have to go through this Btree to find their BtShared and +** they often do so without holding sqlite3.mutex. +*/ +struct Btree { + sqlite3 *db; /* The database connection holding this btree */ + BtShared *pBt; /* Sharable content of this btree */ + u8 inTrans; /* TRANS_NONE, TRANS_READ or TRANS_WRITE */ + u8 sharable; /* True if we can share pBt with another db */ + u8 locked; /* True if db currently has pBt locked */ + u8 hasIncrblobCur; /* True if there are one or more Incrblob cursors */ + int wantToLock; /* Number of nested calls to sqlite3BtreeEnter() */ + int nBackup; /* Number of backup operations reading this btree */ + u32 iBDataVersion; /* Combines with pBt->pPager->iDataVersion */ + Btree *pNext; /* List of other sharable Btrees from the same db */ + Btree *pPrev; /* Back pointer of the same list */ +#ifdef SQLITE_DEBUG + u64 nSeek; /* Calls to sqlite3BtreeMovetoUnpacked() */ +#endif +#ifndef SQLITE_OMIT_SHARED_CACHE + BtLock lock; /* Object used to lock page 1 */ +#endif +}; + +/* +** Btree.inTrans may take one of the following values. +** +** If the shared-data extension is enabled, there may be multiple users +** of the Btree structure. At most one of these may open a write transaction, +** but any number may have active read transactions. +** +** These values must match SQLITE_TXN_NONE, SQLITE_TXN_READ, and +** SQLITE_TXN_WRITE +*/ +#define TRANS_NONE 0 +#define TRANS_READ 1 +#define TRANS_WRITE 2 + +#if TRANS_NONE!=SQLITE_TXN_NONE +# error wrong numeric code for no-transaction +#endif +#if TRANS_READ!=SQLITE_TXN_READ +# error wrong numeric code for read-transaction +#endif +#if TRANS_WRITE!=SQLITE_TXN_WRITE +# error wrong numeric code for write-transaction +#endif + + +/* +** An instance of this object represents a single database file. +** +** A single database file can be in use at the same time by two +** or more database connections. When two or more connections are +** sharing the same database file, each connection has it own +** private Btree object for the file and each of those Btrees points +** to this one BtShared object. BtShared.nRef is the number of +** connections currently sharing this database file. +** +** Fields in this structure are accessed under the BtShared.mutex +** mutex, except for nRef and pNext which are accessed under the +** global SQLITE_MUTEX_STATIC_MAIN mutex. The pPager field +** may not be modified once it is initially set as long as nRef>0. +** The pSchema field may be set once under BtShared.mutex and +** thereafter is unchanged as long as nRef>0. +** +** isPending: +** +** If a BtShared client fails to obtain a write-lock on a database +** table (because there exists one or more read-locks on the table), +** the shared-cache enters 'pending-lock' state and isPending is +** set to true. +** +** The shared-cache leaves the 'pending lock' state when either of +** the following occur: +** +** 1) The current writer (BtShared.pWriter) concludes its transaction, OR +** 2) The number of locks held by other connections drops to zero. +** +** while in the 'pending-lock' state, no connection may start a new +** transaction. +** +** This feature is included to help prevent writer-starvation. +*/ +struct BtShared { + Pager *pPager; /* The page cache */ + sqlite3 *db; /* Database connection currently using this Btree */ + BtCursor *pCursor; /* A list of all open cursors */ + MemPage *pPage1; /* First page of the database */ + u8 openFlags; /* Flags to sqlite3BtreeOpen() */ +#ifndef SQLITE_OMIT_AUTOVACUUM + u8 autoVacuum; /* True if auto-vacuum is enabled */ + u8 incrVacuum; /* True if incr-vacuum is enabled */ + u8 bDoTruncate; /* True to truncate db on commit */ +#endif + u8 inTransaction; /* Transaction state */ + u8 max1bytePayload; /* Maximum first byte of cell for a 1-byte payload */ + u8 nReserveWanted; /* Desired number of extra bytes per page */ + u16 btsFlags; /* Boolean parameters. See BTS_* macros below */ + u16 maxLocal; /* Maximum local payload in non-LEAFDATA tables */ + u16 minLocal; /* Minimum local payload in non-LEAFDATA tables */ + u16 maxLeaf; /* Maximum local payload in a LEAFDATA table */ + u16 minLeaf; /* Minimum local payload in a LEAFDATA table */ + u32 pageSize; /* Total number of bytes on a page */ + u32 usableSize; /* Number of usable bytes on each page */ + int nTransaction; /* Number of open transactions (read + write) */ + u32 nPage; /* Number of pages in the database */ + void *pSchema; /* Pointer to space allocated by sqlite3BtreeSchema() */ + void (*xFreeSchema)(void*); /* Destructor for BtShared.pSchema */ + sqlite3_mutex *mutex; /* Non-recursive mutex required to access this object */ + Bitvec *pHasContent; /* Set of pages moved to free-list this transaction */ +#ifndef SQLITE_OMIT_SHARED_CACHE + int nRef; /* Number of references to this structure */ + BtShared *pNext; /* Next on a list of sharable BtShared structs */ + BtLock *pLock; /* List of locks held on this shared-btree struct */ + Btree *pWriter; /* Btree with currently open write transaction */ +#endif + u8 *pTmpSpace; /* Temp space sufficient to hold a single cell */ + int nPreformatSize; /* Size of last cell written by TransferRow() */ +}; + +/* +** Allowed values for BtShared.btsFlags +*/ +#define BTS_READ_ONLY 0x0001 /* Underlying file is readonly */ +#define BTS_PAGESIZE_FIXED 0x0002 /* Page size can no longer be changed */ +#define BTS_SECURE_DELETE 0x0004 /* PRAGMA secure_delete is enabled */ +#define BTS_OVERWRITE 0x0008 /* Overwrite deleted content with zeros */ +#define BTS_FAST_SECURE 0x000c /* Combination of the previous two */ +#define BTS_INITIALLY_EMPTY 0x0010 /* Database was empty at trans start */ +#define BTS_NO_WAL 0x0020 /* Do not open write-ahead-log files */ +#define BTS_EXCLUSIVE 0x0040 /* pWriter has an exclusive lock */ +#define BTS_PENDING 0x0080 /* Waiting for read-locks to clear */ + +/* +** An instance of the following structure is used to hold information +** about a cell. The parseCellPtr() function fills in this structure +** based on information extract from the raw disk page. +*/ +struct CellInfo { + i64 nKey; /* The key for INTKEY tables, or nPayload otherwise */ + u8 *pPayload; /* Pointer to the start of payload */ + u32 nPayload; /* Bytes of payload */ + u16 nLocal; /* Amount of payload held locally, not on overflow */ + u16 nSize; /* Size of the cell content on the main b-tree page */ +}; + +/* +** Maximum depth of an SQLite B-Tree structure. Any B-Tree deeper than +** this will be declared corrupt. This value is calculated based on a +** maximum database size of 2^31 pages a minimum fanout of 2 for a +** root-node and 3 for all other internal nodes. +** +** If a tree that appears to be taller than this is encountered, it is +** assumed that the database is corrupt. +*/ +#define BTCURSOR_MAX_DEPTH 20 + +/* +** A cursor is a pointer to a particular entry within a particular +** b-tree within a database file. +** +** The entry is identified by its MemPage and the index in +** MemPage.aCell[] of the entry. +** +** A single database file can be shared by two more database connections, +** but cursors cannot be shared. Each cursor is associated with a +** particular database connection identified BtCursor.pBtree.db. +** +** Fields in this structure are accessed under the BtShared.mutex +** found at self->pBt->mutex. +** +** skipNext meaning: +** The meaning of skipNext depends on the value of eState: +** +** eState Meaning of skipNext +** VALID skipNext is meaningless and is ignored +** INVALID skipNext is meaningless and is ignored +** SKIPNEXT sqlite3BtreeNext() is a no-op if skipNext>0 and +** sqlite3BtreePrevious() is no-op if skipNext<0. +** REQUIRESEEK restoreCursorPosition() restores the cursor to +** eState=SKIPNEXT if skipNext!=0 +** FAULT skipNext holds the cursor fault error code. +*/ +struct BtCursor { + u8 eState; /* One of the CURSOR_XXX constants (see below) */ + u8 curFlags; /* zero or more BTCF_* flags defined below */ + u8 curPagerFlags; /* Flags to send to sqlite3PagerGet() */ + u8 hints; /* As configured by CursorSetHints() */ + int skipNext; /* Prev() is noop if negative. Next() is noop if positive. + ** Error code if eState==CURSOR_FAULT */ + Btree *pBtree; /* The Btree to which this cursor belongs */ + Pgno *aOverflow; /* Cache of overflow page locations */ + void *pKey; /* Saved key that was cursor last known position */ + /* All fields above are zeroed when the cursor is allocated. See + ** sqlite3BtreeCursorZero(). Fields that follow must be manually + ** initialized. */ +#define BTCURSOR_FIRST_UNINIT pBt /* Name of first uninitialized field */ + BtShared *pBt; /* The BtShared this cursor points to */ + BtCursor *pNext; /* Forms a linked list of all cursors */ + CellInfo info; /* A parse of the cell we are pointing at */ + i64 nKey; /* Size of pKey, or last integer key */ + Pgno pgnoRoot; /* The root page of this tree */ + i8 iPage; /* Index of current page in apPage */ + u8 curIntKey; /* Value of apPage[0]->intKey */ + u16 ix; /* Current index for apPage[iPage] */ + u16 aiIdx[BTCURSOR_MAX_DEPTH-1]; /* Current index in apPage[i] */ + struct KeyInfo *pKeyInfo; /* Arg passed to comparison function */ + MemPage *pPage; /* Current page */ + MemPage *apPage[BTCURSOR_MAX_DEPTH-1]; /* Stack of parents of current page */ +}; + +/* +** Legal values for BtCursor.curFlags +*/ +#define BTCF_WriteFlag 0x01 /* True if a write cursor */ +#define BTCF_ValidNKey 0x02 /* True if info.nKey is valid */ +#define BTCF_ValidOvfl 0x04 /* True if aOverflow is valid */ +#define BTCF_AtLast 0x08 /* Cursor is pointing to the last entry */ +#define BTCF_Incrblob 0x10 /* True if an incremental I/O handle */ +#define BTCF_Multiple 0x20 /* Maybe another cursor on the same btree */ +#define BTCF_Pinned 0x40 /* Cursor is busy and cannot be moved */ + +/* +** Potential values for BtCursor.eState. +** +** CURSOR_INVALID: +** Cursor does not point to a valid entry. This can happen (for example) +** because the table is empty or because BtreeCursorFirst() has not been +** called. +** +** CURSOR_VALID: +** Cursor points to a valid entry. getPayload() etc. may be called. +** +** CURSOR_SKIPNEXT: +** Cursor is valid except that the Cursor.skipNext field is non-zero +** indicating that the next sqlite3BtreeNext() or sqlite3BtreePrevious() +** operation should be a no-op. +** +** CURSOR_REQUIRESEEK: +** The table that this cursor was opened on still exists, but has been +** modified since the cursor was last used. The cursor position is saved +** in variables BtCursor.pKey and BtCursor.nKey. When a cursor is in +** this state, restoreCursorPosition() can be called to attempt to +** seek the cursor to the saved position. +** +** CURSOR_FAULT: +** An unrecoverable error (an I/O error or a malloc failure) has occurred +** on a different connection that shares the BtShared cache with this +** cursor. The error has left the cache in an inconsistent state. +** Do nothing else with this cursor. Any attempt to use the cursor +** should return the error code stored in BtCursor.skipNext +*/ +#define CURSOR_VALID 0 +#define CURSOR_INVALID 1 +#define CURSOR_SKIPNEXT 2 +#define CURSOR_REQUIRESEEK 3 +#define CURSOR_FAULT 4 + +/* +** The database page the PENDING_BYTE occupies. This page is never used. +*/ +#define PENDING_BYTE_PAGE(pBt) ((Pgno)((PENDING_BYTE/((pBt)->pageSize))+1)) + +/* +** These macros define the location of the pointer-map entry for a +** database page. The first argument to each is the number of usable +** bytes on each page of the database (often 1024). The second is the +** page number to look up in the pointer map. +** +** PTRMAP_PAGENO returns the database page number of the pointer-map +** page that stores the required pointer. PTRMAP_PTROFFSET returns +** the offset of the requested map entry. +** +** If the pgno argument passed to PTRMAP_PAGENO is a pointer-map page, +** then pgno is returned. So (pgno==PTRMAP_PAGENO(pgsz, pgno)) can be +** used to test if pgno is a pointer-map page. PTRMAP_ISPAGE implements +** this test. +*/ +#define PTRMAP_PAGENO(pBt, pgno) ptrmapPageno(pBt, pgno) +#define PTRMAP_PTROFFSET(pgptrmap, pgno) (5*(pgno-pgptrmap-1)) +#define PTRMAP_ISPAGE(pBt, pgno) (PTRMAP_PAGENO((pBt),(pgno))==(pgno)) + +/* +** The pointer map is a lookup table that identifies the parent page for +** each child page in the database file. The parent page is the page that +** contains a pointer to the child. Every page in the database contains +** 0 or 1 parent pages. (In this context 'database page' refers +** to any page that is not part of the pointer map itself.) Each pointer map +** entry consists of a single byte 'type' and a 4 byte parent page number. +** The PTRMAP_XXX identifiers below are the valid types. +** +** The purpose of the pointer map is to facility moving pages from one +** position in the file to another as part of autovacuum. When a page +** is moved, the pointer in its parent must be updated to point to the +** new location. The pointer map is used to locate the parent page quickly. +** +** PTRMAP_ROOTPAGE: The database page is a root-page. The page-number is not +** used in this case. +** +** PTRMAP_FREEPAGE: The database page is an unused (free) page. The page-number +** is not used in this case. +** +** PTRMAP_OVERFLOW1: The database page is the first page in a list of +** overflow pages. The page number identifies the page that +** contains the cell with a pointer to this overflow page. +** +** PTRMAP_OVERFLOW2: The database page is the second or later page in a list of +** overflow pages. The page-number identifies the previous +** page in the overflow page list. +** +** PTRMAP_BTREE: The database page is a non-root btree page. The page number +** identifies the parent page in the btree. +*/ +#define PTRMAP_ROOTPAGE 1 +#define PTRMAP_FREEPAGE 2 +#define PTRMAP_OVERFLOW1 3 +#define PTRMAP_OVERFLOW2 4 +#define PTRMAP_BTREE 5 + +/* A bunch of assert() statements to check the transaction state variables +** of handle p (type Btree*) are internally consistent. +*/ +#define btreeIntegrity(p) \ + assert( p->pBt->inTransaction!=TRANS_NONE || p->pBt->nTransaction==0 ); \ + assert( p->pBt->inTransaction>=p->inTrans ); + + +/* +** The ISAUTOVACUUM macro is used within balance_nonroot() to determine +** if the database supports auto-vacuum or not. Because it is used +** within an expression that is an argument to another macro +** (sqliteMallocRaw), it is not possible to use conditional compilation. +** So, this macro is defined instead. +*/ +#ifndef SQLITE_OMIT_AUTOVACUUM +#define ISAUTOVACUUM(pBt) (pBt->autoVacuum) +#else +#define ISAUTOVACUUM(pBt) 0 +#endif + + +/* +** This structure is passed around through all the PRAGMA integrity_check +** checking routines in order to keep track of some global state information. +** +** The aRef[] array is allocated so that there is 1 bit for each page in +** the database. As the integrity-check proceeds, for each page used in +** the database the corresponding bit is set. This allows integrity-check to +** detect pages that are used twice and orphaned pages (both of which +** indicate corruption). +*/ +typedef struct IntegrityCk IntegrityCk; +struct IntegrityCk { + BtShared *pBt; /* The tree being checked out */ + Pager *pPager; /* The associated pager. Also accessible by pBt->pPager */ + u8 *aPgRef; /* 1 bit per page in the db (see above) */ + Pgno nPage; /* Number of pages in the database */ + int mxErr; /* Stop accumulating errors when this reaches zero */ + int nErr; /* Number of messages written to zErrMsg so far */ + int rc; /* SQLITE_OK, SQLITE_NOMEM, or SQLITE_INTERRUPT */ + u32 nStep; /* Number of steps into the integrity_check process */ + const char *zPfx; /* Error message prefix */ + Pgno v0; /* Value for first %u substitution in zPfx (root page) */ + Pgno v1; /* Value for second %u substitution in zPfx (current pg) */ + int v2; /* Value for third %d substitution in zPfx */ + StrAccum errMsg; /* Accumulate the error message text here */ + u32 *heap; /* Min-heap used for analyzing cell coverage */ + sqlite3 *db; /* Database connection running the check */ +}; + +/* +** Routines to read or write a two- and four-byte big-endian integer values. +*/ +#define get2byte(x) ((x)[0]<<8 | (x)[1]) +#define put2byte(p,v) ((p)[0] = (u8)((v)>>8), (p)[1] = (u8)(v)) +#define get4byte sqlite3Get4byte +#define put4byte sqlite3Put4byte + +/* +** get2byteAligned(), unlike get2byte(), requires that its argument point to a +** two-byte aligned address. get2bytea() is only used for accessing the +** cell addresses in a btree header. +*/ +#if SQLITE_BYTEORDER==4321 +# define get2byteAligned(x) (*(u16*)(x)) +#elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4008000 +# define get2byteAligned(x) __builtin_bswap16(*(u16*)(x)) +#elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300 +# define get2byteAligned(x) _byteswap_ushort(*(u16*)(x)) +#else +# define get2byteAligned(x) ((x)[0]<<8 | (x)[1]) +#endif + +/************** End of btreeInt.h ********************************************/ +/************** Continuing where we left off in btmutex.c ********************/ +#ifndef SQLITE_OMIT_SHARED_CACHE +#if SQLITE_THREADSAFE + +/* +** Obtain the BtShared mutex associated with B-Tree handle p. Also, +** set BtShared.db to the database handle associated with p and the +** p->locked boolean to true. +*/ +static void lockBtreeMutex(Btree *p){ + assert( p->locked==0 ); + assert( sqlite3_mutex_notheld(p->pBt->mutex) ); + assert( sqlite3_mutex_held(p->db->mutex) ); + + sqlite3_mutex_enter(p->pBt->mutex); + p->pBt->db = p->db; + p->locked = 1; +} + +/* +** Release the BtShared mutex associated with B-Tree handle p and +** clear the p->locked boolean. +*/ +static void SQLITE_NOINLINE unlockBtreeMutex(Btree *p){ + BtShared *pBt = p->pBt; + assert( p->locked==1 ); + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( sqlite3_mutex_held(p->db->mutex) ); + assert( p->db==pBt->db ); + + sqlite3_mutex_leave(pBt->mutex); + p->locked = 0; +} + +/* Forward reference */ +static void SQLITE_NOINLINE btreeLockCarefully(Btree *p); + +/* +** Enter a mutex on the given BTree object. +** +** If the object is not sharable, then no mutex is ever required +** and this routine is a no-op. The underlying mutex is non-recursive. +** But we keep a reference count in Btree.wantToLock so the behavior +** of this interface is recursive. +** +** To avoid deadlocks, multiple Btrees are locked in the same order +** by all database connections. The p->pNext is a list of other +** Btrees belonging to the same database connection as the p Btree +** which need to be locked after p. If we cannot get a lock on +** p, then first unlock all of the others on p->pNext, then wait +** for the lock to become available on p, then relock all of the +** subsequent Btrees that desire a lock. +*/ +SQLITE_PRIVATE void sqlite3BtreeEnter(Btree *p){ + /* Some basic sanity checking on the Btree. The list of Btrees + ** connected by pNext and pPrev should be in sorted order by + ** Btree.pBt value. All elements of the list should belong to + ** the same connection. Only shared Btrees are on the list. */ + assert( p->pNext==0 || p->pNext->pBt>p->pBt ); + assert( p->pPrev==0 || p->pPrev->pBtpBt ); + assert( p->pNext==0 || p->pNext->db==p->db ); + assert( p->pPrev==0 || p->pPrev->db==p->db ); + assert( p->sharable || (p->pNext==0 && p->pPrev==0) ); + + /* Check for locking consistency */ + assert( !p->locked || p->wantToLock>0 ); + assert( p->sharable || p->wantToLock==0 ); + + /* We should already hold a lock on the database connection */ + assert( sqlite3_mutex_held(p->db->mutex) ); + + /* Unless the database is sharable and unlocked, then BtShared.db + ** should already be set correctly. */ + assert( (p->locked==0 && p->sharable) || p->pBt->db==p->db ); + + if( !p->sharable ) return; + p->wantToLock++; + if( p->locked ) return; + btreeLockCarefully(p); +} + +/* This is a helper function for sqlite3BtreeLock(). By moving +** complex, but seldom used logic, out of sqlite3BtreeLock() and +** into this routine, we avoid unnecessary stack pointer changes +** and thus help the sqlite3BtreeLock() routine to run much faster +** in the common case. +*/ +static void SQLITE_NOINLINE btreeLockCarefully(Btree *p){ + Btree *pLater; + + /* In most cases, we should be able to acquire the lock we + ** want without having to go through the ascending lock + ** procedure that follows. Just be sure not to block. + */ + if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){ + p->pBt->db = p->db; + p->locked = 1; + return; + } + + /* To avoid deadlock, first release all locks with a larger + ** BtShared address. Then acquire our lock. Then reacquire + ** the other BtShared locks that we used to hold in ascending + ** order. + */ + for(pLater=p->pNext; pLater; pLater=pLater->pNext){ + assert( pLater->sharable ); + assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt ); + assert( !pLater->locked || pLater->wantToLock>0 ); + if( pLater->locked ){ + unlockBtreeMutex(pLater); + } + } + lockBtreeMutex(p); + for(pLater=p->pNext; pLater; pLater=pLater->pNext){ + if( pLater->wantToLock ){ + lockBtreeMutex(pLater); + } + } +} + + +/* +** Exit the recursive mutex on a Btree. +*/ +SQLITE_PRIVATE void sqlite3BtreeLeave(Btree *p){ + assert( sqlite3_mutex_held(p->db->mutex) ); + if( p->sharable ){ + assert( p->wantToLock>0 ); + p->wantToLock--; + if( p->wantToLock==0 ){ + unlockBtreeMutex(p); + } + } +} + +#ifndef NDEBUG +/* +** Return true if the BtShared mutex is held on the btree, or if the +** B-Tree is not marked as sharable. +** +** This routine is used only from within assert() statements. +*/ +SQLITE_PRIVATE int sqlite3BtreeHoldsMutex(Btree *p){ + assert( p->sharable==0 || p->locked==0 || p->wantToLock>0 ); + assert( p->sharable==0 || p->locked==0 || p->db==p->pBt->db ); + assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->pBt->mutex) ); + assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->db->mutex) ); + + return (p->sharable==0 || p->locked); +} +#endif + + +/* +** Enter the mutex on every Btree associated with a database +** connection. This is needed (for example) prior to parsing +** a statement since we will be comparing table and column names +** against all schemas and we do not want those schemas being +** reset out from under us. +** +** There is a corresponding leave-all procedures. +** +** Enter the mutexes in accending order by BtShared pointer address +** to avoid the possibility of deadlock when two threads with +** two or more btrees in common both try to lock all their btrees +** at the same instant. +*/ +static void SQLITE_NOINLINE btreeEnterAll(sqlite3 *db){ + int i; + int skipOk = 1; + Btree *p; + assert( sqlite3_mutex_held(db->mutex) ); + for(i=0; inDb; i++){ + p = db->aDb[i].pBt; + if( p && p->sharable ){ + sqlite3BtreeEnter(p); + skipOk = 0; + } + } + db->noSharedCache = skipOk; +} +SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3 *db){ + if( db->noSharedCache==0 ) btreeEnterAll(db); +} +static void SQLITE_NOINLINE btreeLeaveAll(sqlite3 *db){ + int i; + Btree *p; + assert( sqlite3_mutex_held(db->mutex) ); + for(i=0; inDb; i++){ + p = db->aDb[i].pBt; + if( p ) sqlite3BtreeLeave(p); + } +} +SQLITE_PRIVATE void sqlite3BtreeLeaveAll(sqlite3 *db){ + if( db->noSharedCache==0 ) btreeLeaveAll(db); +} + +#ifndef NDEBUG +/* +** Return true if the current thread holds the database connection +** mutex and all required BtShared mutexes. +** +** This routine is used inside assert() statements only. +*/ +SQLITE_PRIVATE int sqlite3BtreeHoldsAllMutexes(sqlite3 *db){ + int i; + if( !sqlite3_mutex_held(db->mutex) ){ + return 0; + } + for(i=0; inDb; i++){ + Btree *p; + p = db->aDb[i].pBt; + if( p && p->sharable && + (p->wantToLock==0 || !sqlite3_mutex_held(p->pBt->mutex)) ){ + return 0; + } + } + return 1; +} +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* +** Return true if the correct mutexes are held for accessing the +** db->aDb[iDb].pSchema structure. The mutexes required for schema +** access are: +** +** (1) The mutex on db +** (2) if iDb!=1, then the mutex on db->aDb[iDb].pBt. +** +** If pSchema is not NULL, then iDb is computed from pSchema and +** db using sqlite3SchemaToIndex(). +*/ +SQLITE_PRIVATE int sqlite3SchemaMutexHeld(sqlite3 *db, int iDb, Schema *pSchema){ + Btree *p; + assert( db!=0 ); + if( db->pVfs==0 && db->nDb==0 ) return 1; + if( pSchema ) iDb = sqlite3SchemaToIndex(db, pSchema); + assert( iDb>=0 && iDbnDb ); + if( !sqlite3_mutex_held(db->mutex) ) return 0; + if( iDb==1 ) return 1; + p = db->aDb[iDb].pBt; + assert( p!=0 ); + return p->sharable==0 || p->locked==1; +} +#endif /* NDEBUG */ + +#else /* SQLITE_THREADSAFE>0 above. SQLITE_THREADSAFE==0 below */ +/* +** The following are special cases for mutex enter routines for use +** in single threaded applications that use shared cache. Except for +** these two routines, all mutex operations are no-ops in that case and +** are null #defines in btree.h. +** +** If shared cache is disabled, then all btree mutex routines, including +** the ones below, are no-ops and are null #defines in btree.h. +*/ + +SQLITE_PRIVATE void sqlite3BtreeEnter(Btree *p){ + p->pBt->db = p->db; +} +SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3 *db){ + int i; + for(i=0; inDb; i++){ + Btree *p = db->aDb[i].pBt; + if( p ){ + p->pBt->db = p->db; + } + } +} +#endif /* if SQLITE_THREADSAFE */ + +#ifndef SQLITE_OMIT_INCRBLOB +/* +** Enter a mutex on a Btree given a cursor owned by that Btree. +** +** These entry points are used by incremental I/O only. Enter() is required +** any time OMIT_SHARED_CACHE is not defined, regardless of whether or not +** the build is threadsafe. Leave() is only required by threadsafe builds. +*/ +SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor *pCur){ + sqlite3BtreeEnter(pCur->pBtree); +} +# if SQLITE_THREADSAFE +SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor *pCur){ + sqlite3BtreeLeave(pCur->pBtree); +} +# endif +#endif /* ifndef SQLITE_OMIT_INCRBLOB */ + +#endif /* ifndef SQLITE_OMIT_SHARED_CACHE */ + +/************** End of btmutex.c *********************************************/ +/************** Begin file btree.c *******************************************/ +/* +** 2004 April 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file implements an external (disk-based) database using BTrees. +** See the header comment on "btreeInt.h" for additional information. +** Including a description of file format and an overview of operation. +*/ +/* #include "btreeInt.h" */ + +/* +** The header string that appears at the beginning of every +** SQLite database. +*/ +static const char zMagicHeader[] = SQLITE_FILE_HEADER; + +/* +** Set this global variable to 1 to enable tracing using the TRACE +** macro. +*/ +#if 0 +int sqlite3BtreeTrace=1; /* True to enable tracing */ +# define TRACE(X) if(sqlite3BtreeTrace){printf X;fflush(stdout);} +#else +# define TRACE(X) +#endif + +/* +** Extract a 2-byte big-endian integer from an array of unsigned bytes. +** But if the value is zero, make it 65536. +** +** This routine is used to extract the "offset to cell content area" value +** from the header of a btree page. If the page size is 65536 and the page +** is empty, the offset should be 65536, but the 2-byte value stores zero. +** This routine makes the necessary adjustment to 65536. +*/ +#define get2byteNotZero(X) (((((int)get2byte(X))-1)&0xffff)+1) + +/* +** Values passed as the 5th argument to allocateBtreePage() +*/ +#define BTALLOC_ANY 0 /* Allocate any page */ +#define BTALLOC_EXACT 1 /* Allocate exact page if possible */ +#define BTALLOC_LE 2 /* Allocate any page <= the parameter */ + +/* +** Macro IfNotOmitAV(x) returns (x) if SQLITE_OMIT_AUTOVACUUM is not +** defined, or 0 if it is. For example: +** +** bIncrVacuum = IfNotOmitAV(pBtShared->incrVacuum); +*/ +#ifndef SQLITE_OMIT_AUTOVACUUM +#define IfNotOmitAV(expr) (expr) +#else +#define IfNotOmitAV(expr) 0 +#endif + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** A list of BtShared objects that are eligible for participation +** in shared cache. This variable has file scope during normal builds, +** but the test harness needs to access it so we make it global for +** test builds. +** +** Access to this variable is protected by SQLITE_MUTEX_STATIC_MAIN. +*/ +#ifdef SQLITE_TEST +SQLITE_PRIVATE BtShared *SQLITE_WSD sqlite3SharedCacheList = 0; +#else +static BtShared *SQLITE_WSD sqlite3SharedCacheList = 0; +#endif +#endif /* SQLITE_OMIT_SHARED_CACHE */ + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** Enable or disable the shared pager and schema features. +** +** This routine has no effect on existing database connections. +** The shared cache setting effects only future calls to +** sqlite3_open(), sqlite3_open16(), or sqlite3_open_v2(). +*/ +SQLITE_API int sqlite3_enable_shared_cache(int enable){ + sqlite3GlobalConfig.sharedCacheEnabled = enable; + return SQLITE_OK; +} +#endif + + + +#ifdef SQLITE_OMIT_SHARED_CACHE + /* + ** The functions querySharedCacheTableLock(), setSharedCacheTableLock(), + ** and clearAllSharedCacheTableLocks() + ** manipulate entries in the BtShared.pLock linked list used to store + ** shared-cache table level locks. If the library is compiled with the + ** shared-cache feature disabled, then there is only ever one user + ** of each BtShared structure and so this locking is not necessary. + ** So define the lock related functions as no-ops. + */ + #define querySharedCacheTableLock(a,b,c) SQLITE_OK + #define setSharedCacheTableLock(a,b,c) SQLITE_OK + #define clearAllSharedCacheTableLocks(a) + #define downgradeAllSharedCacheTableLocks(a) + #define hasSharedCacheTableLock(a,b,c,d) 1 + #define hasReadConflicts(a, b) 0 +#endif + +#ifdef SQLITE_DEBUG +/* +** Return and reset the seek counter for a Btree object. +*/ +SQLITE_PRIVATE sqlite3_uint64 sqlite3BtreeSeekCount(Btree *pBt){ + u64 n = pBt->nSeek; + pBt->nSeek = 0; + return n; +} +#endif + +/* +** Implementation of the SQLITE_CORRUPT_PAGE() macro. Takes a single +** (MemPage*) as an argument. The (MemPage*) must not be NULL. +** +** If SQLITE_DEBUG is not defined, then this macro is equivalent to +** SQLITE_CORRUPT_BKPT. Or, if SQLITE_DEBUG is set, then the log message +** normally produced as a side-effect of SQLITE_CORRUPT_BKPT is augmented +** with the page number and filename associated with the (MemPage*). +*/ +#ifdef SQLITE_DEBUG +int corruptPageError(int lineno, MemPage *p){ + char *zMsg; + sqlite3BeginBenignMalloc(); + zMsg = sqlite3_mprintf("database corruption page %u of %s", + p->pgno, sqlite3PagerFilename(p->pBt->pPager, 0) + ); + sqlite3EndBenignMalloc(); + if( zMsg ){ + sqlite3ReportError(SQLITE_CORRUPT, lineno, zMsg); + } + sqlite3_free(zMsg); + return SQLITE_CORRUPT_BKPT; +} +# define SQLITE_CORRUPT_PAGE(pMemPage) corruptPageError(__LINE__, pMemPage) +#else +# define SQLITE_CORRUPT_PAGE(pMemPage) SQLITE_CORRUPT_PGNO(pMemPage->pgno) +#endif + +#ifndef SQLITE_OMIT_SHARED_CACHE + +#ifdef SQLITE_DEBUG +/* +**** This function is only used as part of an assert() statement. *** +** +** Check to see if pBtree holds the required locks to read or write to the +** table with root page iRoot. Return 1 if it does and 0 if not. +** +** For example, when writing to a table with root-page iRoot via +** Btree connection pBtree: +** +** assert( hasSharedCacheTableLock(pBtree, iRoot, 0, WRITE_LOCK) ); +** +** When writing to an index that resides in a sharable database, the +** caller should have first obtained a lock specifying the root page of +** the corresponding table. This makes things a bit more complicated, +** as this module treats each table as a separate structure. To determine +** the table corresponding to the index being written, this +** function has to search through the database schema. +** +** Instead of a lock on the table/index rooted at page iRoot, the caller may +** hold a write-lock on the schema table (root page 1). This is also +** acceptable. +*/ +static int hasSharedCacheTableLock( + Btree *pBtree, /* Handle that must hold lock */ + Pgno iRoot, /* Root page of b-tree */ + int isIndex, /* True if iRoot is the root of an index b-tree */ + int eLockType /* Required lock type (READ_LOCK or WRITE_LOCK) */ +){ + Schema *pSchema = (Schema *)pBtree->pBt->pSchema; + Pgno iTab = 0; + BtLock *pLock; + + /* If this database is not shareable, or if the client is reading + ** and has the read-uncommitted flag set, then no lock is required. + ** Return true immediately. + */ + if( (pBtree->sharable==0) + || (eLockType==READ_LOCK && (pBtree->db->flags & SQLITE_ReadUncommit)) + ){ + return 1; + } + + /* If the client is reading or writing an index and the schema is + ** not loaded, then it is too difficult to actually check to see if + ** the correct locks are held. So do not bother - just return true. + ** This case does not come up very often anyhow. + */ + if( isIndex && (!pSchema || (pSchema->schemaFlags&DB_SchemaLoaded)==0) ){ + return 1; + } + + /* Figure out the root-page that the lock should be held on. For table + ** b-trees, this is just the root page of the b-tree being read or + ** written. For index b-trees, it is the root page of the associated + ** table. */ + if( isIndex ){ + HashElem *p; + int bSeen = 0; + for(p=sqliteHashFirst(&pSchema->idxHash); p; p=sqliteHashNext(p)){ + Index *pIdx = (Index *)sqliteHashData(p); + if( pIdx->tnum==iRoot ){ + if( bSeen ){ + /* Two or more indexes share the same root page. There must + ** be imposter tables. So just return true. The assert is not + ** useful in that case. */ + return 1; + } + iTab = pIdx->pTable->tnum; + bSeen = 1; + } + } + }else{ + iTab = iRoot; + } + + /* Search for the required lock. Either a write-lock on root-page iTab, a + ** write-lock on the schema table, or (if the client is reading) a + ** read-lock on iTab will suffice. Return 1 if any of these are found. */ + for(pLock=pBtree->pBt->pLock; pLock; pLock=pLock->pNext){ + if( pLock->pBtree==pBtree + && (pLock->iTable==iTab || (pLock->eLock==WRITE_LOCK && pLock->iTable==1)) + && pLock->eLock>=eLockType + ){ + return 1; + } + } + + /* Failed to find the required lock. */ + return 0; +} +#endif /* SQLITE_DEBUG */ + +#ifdef SQLITE_DEBUG +/* +**** This function may be used as part of assert() statements only. **** +** +** Return true if it would be illegal for pBtree to write into the +** table or index rooted at iRoot because other shared connections are +** simultaneously reading that same table or index. +** +** It is illegal for pBtree to write if some other Btree object that +** shares the same BtShared object is currently reading or writing +** the iRoot table. Except, if the other Btree object has the +** read-uncommitted flag set, then it is OK for the other object to +** have a read cursor. +** +** For example, before writing to any part of the table or index +** rooted at page iRoot, one should call: +** +** assert( !hasReadConflicts(pBtree, iRoot) ); +*/ +static int hasReadConflicts(Btree *pBtree, Pgno iRoot){ + BtCursor *p; + for(p=pBtree->pBt->pCursor; p; p=p->pNext){ + if( p->pgnoRoot==iRoot + && p->pBtree!=pBtree + && 0==(p->pBtree->db->flags & SQLITE_ReadUncommit) + ){ + return 1; + } + } + return 0; +} +#endif /* #ifdef SQLITE_DEBUG */ + +/* +** Query to see if Btree handle p may obtain a lock of type eLock +** (READ_LOCK or WRITE_LOCK) on the table with root-page iTab. Return +** SQLITE_OK if the lock may be obtained (by calling +** setSharedCacheTableLock()), or SQLITE_LOCKED if not. +*/ +static int querySharedCacheTableLock(Btree *p, Pgno iTab, u8 eLock){ + BtShared *pBt = p->pBt; + BtLock *pIter; + + assert( sqlite3BtreeHoldsMutex(p) ); + assert( eLock==READ_LOCK || eLock==WRITE_LOCK ); + assert( p->db!=0 ); + assert( !(p->db->flags&SQLITE_ReadUncommit)||eLock==WRITE_LOCK||iTab==1 ); + + /* If requesting a write-lock, then the Btree must have an open write + ** transaction on this file. And, obviously, for this to be so there + ** must be an open write transaction on the file itself. + */ + assert( eLock==READ_LOCK || (p==pBt->pWriter && p->inTrans==TRANS_WRITE) ); + assert( eLock==READ_LOCK || pBt->inTransaction==TRANS_WRITE ); + + /* This routine is a no-op if the shared-cache is not enabled */ + if( !p->sharable ){ + return SQLITE_OK; + } + + /* If some other connection is holding an exclusive lock, the + ** requested lock may not be obtained. + */ + if( pBt->pWriter!=p && (pBt->btsFlags & BTS_EXCLUSIVE)!=0 ){ + sqlite3ConnectionBlocked(p->db, pBt->pWriter->db); + return SQLITE_LOCKED_SHAREDCACHE; + } + + for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){ + /* The condition (pIter->eLock!=eLock) in the following if(...) + ** statement is a simplification of: + ** + ** (eLock==WRITE_LOCK || pIter->eLock==WRITE_LOCK) + ** + ** since we know that if eLock==WRITE_LOCK, then no other connection + ** may hold a WRITE_LOCK on any table in this file (since there can + ** only be a single writer). + */ + assert( pIter->eLock==READ_LOCK || pIter->eLock==WRITE_LOCK ); + assert( eLock==READ_LOCK || pIter->pBtree==p || pIter->eLock==READ_LOCK); + if( pIter->pBtree!=p && pIter->iTable==iTab && pIter->eLock!=eLock ){ + sqlite3ConnectionBlocked(p->db, pIter->pBtree->db); + if( eLock==WRITE_LOCK ){ + assert( p==pBt->pWriter ); + pBt->btsFlags |= BTS_PENDING; + } + return SQLITE_LOCKED_SHAREDCACHE; + } + } + return SQLITE_OK; +} +#endif /* !SQLITE_OMIT_SHARED_CACHE */ + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** Add a lock on the table with root-page iTable to the shared-btree used +** by Btree handle p. Parameter eLock must be either READ_LOCK or +** WRITE_LOCK. +** +** This function assumes the following: +** +** (a) The specified Btree object p is connected to a sharable +** database (one with the BtShared.sharable flag set), and +** +** (b) No other Btree objects hold a lock that conflicts +** with the requested lock (i.e. querySharedCacheTableLock() has +** already been called and returned SQLITE_OK). +** +** SQLITE_OK is returned if the lock is added successfully. SQLITE_NOMEM +** is returned if a malloc attempt fails. +*/ +static int setSharedCacheTableLock(Btree *p, Pgno iTable, u8 eLock){ + BtShared *pBt = p->pBt; + BtLock *pLock = 0; + BtLock *pIter; + + assert( sqlite3BtreeHoldsMutex(p) ); + assert( eLock==READ_LOCK || eLock==WRITE_LOCK ); + assert( p->db!=0 ); + + /* A connection with the read-uncommitted flag set will never try to + ** obtain a read-lock using this function. The only read-lock obtained + ** by a connection in read-uncommitted mode is on the sqlite_schema + ** table, and that lock is obtained in BtreeBeginTrans(). */ + assert( 0==(p->db->flags&SQLITE_ReadUncommit) || eLock==WRITE_LOCK ); + + /* This function should only be called on a sharable b-tree after it + ** has been determined that no other b-tree holds a conflicting lock. */ + assert( p->sharable ); + assert( SQLITE_OK==querySharedCacheTableLock(p, iTable, eLock) ); + + /* First search the list for an existing lock on this table. */ + for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){ + if( pIter->iTable==iTable && pIter->pBtree==p ){ + pLock = pIter; + break; + } + } + + /* If the above search did not find a BtLock struct associating Btree p + ** with table iTable, allocate one and link it into the list. + */ + if( !pLock ){ + pLock = (BtLock *)sqlite3MallocZero(sizeof(BtLock)); + if( !pLock ){ + return SQLITE_NOMEM_BKPT; + } + pLock->iTable = iTable; + pLock->pBtree = p; + pLock->pNext = pBt->pLock; + pBt->pLock = pLock; + } + + /* Set the BtLock.eLock variable to the maximum of the current lock + ** and the requested lock. This means if a write-lock was already held + ** and a read-lock requested, we don't incorrectly downgrade the lock. + */ + assert( WRITE_LOCK>READ_LOCK ); + if( eLock>pLock->eLock ){ + pLock->eLock = eLock; + } + + return SQLITE_OK; +} +#endif /* !SQLITE_OMIT_SHARED_CACHE */ + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** Release all the table locks (locks obtained via calls to +** the setSharedCacheTableLock() procedure) held by Btree object p. +** +** This function assumes that Btree p has an open read or write +** transaction. If it does not, then the BTS_PENDING flag +** may be incorrectly cleared. +*/ +static void clearAllSharedCacheTableLocks(Btree *p){ + BtShared *pBt = p->pBt; + BtLock **ppIter = &pBt->pLock; + + assert( sqlite3BtreeHoldsMutex(p) ); + assert( p->sharable || 0==*ppIter ); + assert( p->inTrans>0 ); + + while( *ppIter ){ + BtLock *pLock = *ppIter; + assert( (pBt->btsFlags & BTS_EXCLUSIVE)==0 || pBt->pWriter==pLock->pBtree ); + assert( pLock->pBtree->inTrans>=pLock->eLock ); + if( pLock->pBtree==p ){ + *ppIter = pLock->pNext; + assert( pLock->iTable!=1 || pLock==&p->lock ); + if( pLock->iTable!=1 ){ + sqlite3_free(pLock); + } + }else{ + ppIter = &pLock->pNext; + } + } + + assert( (pBt->btsFlags & BTS_PENDING)==0 || pBt->pWriter ); + if( pBt->pWriter==p ){ + pBt->pWriter = 0; + pBt->btsFlags &= ~(BTS_EXCLUSIVE|BTS_PENDING); + }else if( pBt->nTransaction==2 ){ + /* This function is called when Btree p is concluding its + ** transaction. If there currently exists a writer, and p is not + ** that writer, then the number of locks held by connections other + ** than the writer must be about to drop to zero. In this case + ** set the BTS_PENDING flag to 0. + ** + ** If there is not currently a writer, then BTS_PENDING must + ** be zero already. So this next line is harmless in that case. + */ + pBt->btsFlags &= ~BTS_PENDING; + } +} + +/* +** This function changes all write-locks held by Btree p into read-locks. +*/ +static void downgradeAllSharedCacheTableLocks(Btree *p){ + BtShared *pBt = p->pBt; + if( pBt->pWriter==p ){ + BtLock *pLock; + pBt->pWriter = 0; + pBt->btsFlags &= ~(BTS_EXCLUSIVE|BTS_PENDING); + for(pLock=pBt->pLock; pLock; pLock=pLock->pNext){ + assert( pLock->eLock==READ_LOCK || pLock->pBtree==p ); + pLock->eLock = READ_LOCK; + } + } +} + +#endif /* SQLITE_OMIT_SHARED_CACHE */ + +static void releasePage(MemPage *pPage); /* Forward reference */ +static void releasePageOne(MemPage *pPage); /* Forward reference */ +static void releasePageNotNull(MemPage *pPage); /* Forward reference */ + +/* +***** This routine is used inside of assert() only **** +** +** Verify that the cursor holds the mutex on its BtShared +*/ +#ifdef SQLITE_DEBUG +static int cursorHoldsMutex(BtCursor *p){ + return sqlite3_mutex_held(p->pBt->mutex); +} + +/* Verify that the cursor and the BtShared agree about what is the current +** database connetion. This is important in shared-cache mode. If the database +** connection pointers get out-of-sync, it is possible for routines like +** btreeInitPage() to reference an stale connection pointer that references a +** a connection that has already closed. This routine is used inside assert() +** statements only and for the purpose of double-checking that the btree code +** does keep the database connection pointers up-to-date. +*/ +static int cursorOwnsBtShared(BtCursor *p){ + assert( cursorHoldsMutex(p) ); + return (p->pBtree->db==p->pBt->db); +} +#endif + +/* +** Invalidate the overflow cache of the cursor passed as the first argument. +** on the shared btree structure pBt. +*/ +#define invalidateOverflowCache(pCur) (pCur->curFlags &= ~BTCF_ValidOvfl) + +/* +** Invalidate the overflow page-list cache for all cursors opened +** on the shared btree structure pBt. +*/ +static void invalidateAllOverflowCache(BtShared *pBt){ + BtCursor *p; + assert( sqlite3_mutex_held(pBt->mutex) ); + for(p=pBt->pCursor; p; p=p->pNext){ + invalidateOverflowCache(p); + } +} + +#ifndef SQLITE_OMIT_INCRBLOB +/* +** This function is called before modifying the contents of a table +** to invalidate any incrblob cursors that are open on the +** row or one of the rows being modified. +** +** If argument isClearTable is true, then the entire contents of the +** table is about to be deleted. In this case invalidate all incrblob +** cursors open on any row within the table with root-page pgnoRoot. +** +** Otherwise, if argument isClearTable is false, then the row with +** rowid iRow is being replaced or deleted. In this case invalidate +** only those incrblob cursors open on that specific row. +*/ +static void invalidateIncrblobCursors( + Btree *pBtree, /* The database file to check */ + Pgno pgnoRoot, /* The table that might be changing */ + i64 iRow, /* The rowid that might be changing */ + int isClearTable /* True if all rows are being deleted */ +){ + BtCursor *p; + assert( pBtree->hasIncrblobCur ); + assert( sqlite3BtreeHoldsMutex(pBtree) ); + pBtree->hasIncrblobCur = 0; + for(p=pBtree->pBt->pCursor; p; p=p->pNext){ + if( (p->curFlags & BTCF_Incrblob)!=0 ){ + pBtree->hasIncrblobCur = 1; + if( p->pgnoRoot==pgnoRoot && (isClearTable || p->info.nKey==iRow) ){ + p->eState = CURSOR_INVALID; + } + } + } +} + +#else + /* Stub function when INCRBLOB is omitted */ + #define invalidateIncrblobCursors(w,x,y,z) +#endif /* SQLITE_OMIT_INCRBLOB */ + +/* +** Set bit pgno of the BtShared.pHasContent bitvec. This is called +** when a page that previously contained data becomes a free-list leaf +** page. +** +** The BtShared.pHasContent bitvec exists to work around an obscure +** bug caused by the interaction of two useful IO optimizations surrounding +** free-list leaf pages: +** +** 1) When all data is deleted from a page and the page becomes +** a free-list leaf page, the page is not written to the database +** (as free-list leaf pages contain no meaningful data). Sometimes +** such a page is not even journalled (as it will not be modified, +** why bother journalling it?). +** +** 2) When a free-list leaf page is reused, its content is not read +** from the database or written to the journal file (why should it +** be, if it is not at all meaningful?). +** +** By themselves, these optimizations work fine and provide a handy +** performance boost to bulk delete or insert operations. However, if +** a page is moved to the free-list and then reused within the same +** transaction, a problem comes up. If the page is not journalled when +** it is moved to the free-list and it is also not journalled when it +** is extracted from the free-list and reused, then the original data +** may be lost. In the event of a rollback, it may not be possible +** to restore the database to its original configuration. +** +** The solution is the BtShared.pHasContent bitvec. Whenever a page is +** moved to become a free-list leaf page, the corresponding bit is +** set in the bitvec. Whenever a leaf page is extracted from the free-list, +** optimization 2 above is omitted if the corresponding bit is already +** set in BtShared.pHasContent. The contents of the bitvec are cleared +** at the end of every transaction. +*/ +static int btreeSetHasContent(BtShared *pBt, Pgno pgno){ + int rc = SQLITE_OK; + if( !pBt->pHasContent ){ + assert( pgno<=pBt->nPage ); + pBt->pHasContent = sqlite3BitvecCreate(pBt->nPage); + if( !pBt->pHasContent ){ + rc = SQLITE_NOMEM_BKPT; + } + } + if( rc==SQLITE_OK && pgno<=sqlite3BitvecSize(pBt->pHasContent) ){ + rc = sqlite3BitvecSet(pBt->pHasContent, pgno); + } + return rc; +} + +/* +** Query the BtShared.pHasContent vector. +** +** This function is called when a free-list leaf page is removed from the +** free-list for reuse. It returns false if it is safe to retrieve the +** page from the pager layer with the 'no-content' flag set. True otherwise. +*/ +static int btreeGetHasContent(BtShared *pBt, Pgno pgno){ + Bitvec *p = pBt->pHasContent; + return p && (pgno>sqlite3BitvecSize(p) || sqlite3BitvecTestNotNull(p, pgno)); +} + +/* +** Clear (destroy) the BtShared.pHasContent bitvec. This should be +** invoked at the conclusion of each write-transaction. +*/ +static void btreeClearHasContent(BtShared *pBt){ + sqlite3BitvecDestroy(pBt->pHasContent); + pBt->pHasContent = 0; +} + +/* +** Release all of the apPage[] pages for a cursor. +*/ +static void btreeReleaseAllCursorPages(BtCursor *pCur){ + int i; + if( pCur->iPage>=0 ){ + for(i=0; iiPage; i++){ + releasePageNotNull(pCur->apPage[i]); + } + releasePageNotNull(pCur->pPage); + pCur->iPage = -1; + } +} + +/* +** The cursor passed as the only argument must point to a valid entry +** when this function is called (i.e. have eState==CURSOR_VALID). This +** function saves the current cursor key in variables pCur->nKey and +** pCur->pKey. SQLITE_OK is returned if successful or an SQLite error +** code otherwise. +** +** If the cursor is open on an intkey table, then the integer key +** (the rowid) is stored in pCur->nKey and pCur->pKey is left set to +** NULL. If the cursor is open on a non-intkey table, then pCur->pKey is +** set to point to a malloced buffer pCur->nKey bytes in size containing +** the key. +*/ +static int saveCursorKey(BtCursor *pCur){ + int rc = SQLITE_OK; + assert( CURSOR_VALID==pCur->eState ); + assert( 0==pCur->pKey ); + assert( cursorHoldsMutex(pCur) ); + + if( pCur->curIntKey ){ + /* Only the rowid is required for a table btree */ + pCur->nKey = sqlite3BtreeIntegerKey(pCur); + }else{ + /* For an index btree, save the complete key content. It is possible + ** that the current key is corrupt. In that case, it is possible that + ** the sqlite3VdbeRecordUnpack() function may overread the buffer by + ** up to the size of 1 varint plus 1 8-byte value when the cursor + ** position is restored. Hence the 17 bytes of padding allocated + ** below. */ + void *pKey; + pCur->nKey = sqlite3BtreePayloadSize(pCur); + pKey = sqlite3Malloc( pCur->nKey + 9 + 8 ); + if( pKey ){ + rc = sqlite3BtreePayload(pCur, 0, (int)pCur->nKey, pKey); + if( rc==SQLITE_OK ){ + memset(((u8*)pKey)+pCur->nKey, 0, 9+8); + pCur->pKey = pKey; + }else{ + sqlite3_free(pKey); + } + }else{ + rc = SQLITE_NOMEM_BKPT; + } + } + assert( !pCur->curIntKey || !pCur->pKey ); + return rc; +} + +/* +** Save the current cursor position in the variables BtCursor.nKey +** and BtCursor.pKey. The cursor's state is set to CURSOR_REQUIRESEEK. +** +** The caller must ensure that the cursor is valid (has eState==CURSOR_VALID) +** prior to calling this routine. +*/ +static int saveCursorPosition(BtCursor *pCur){ + int rc; + + assert( CURSOR_VALID==pCur->eState || CURSOR_SKIPNEXT==pCur->eState ); + assert( 0==pCur->pKey ); + assert( cursorHoldsMutex(pCur) ); + + if( pCur->curFlags & BTCF_Pinned ){ + return SQLITE_CONSTRAINT_PINNED; + } + if( pCur->eState==CURSOR_SKIPNEXT ){ + pCur->eState = CURSOR_VALID; + }else{ + pCur->skipNext = 0; + } + + rc = saveCursorKey(pCur); + if( rc==SQLITE_OK ){ + btreeReleaseAllCursorPages(pCur); + pCur->eState = CURSOR_REQUIRESEEK; + } + + pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl|BTCF_AtLast); + return rc; +} + +/* Forward reference */ +static int SQLITE_NOINLINE saveCursorsOnList(BtCursor*,Pgno,BtCursor*); + +/* +** Save the positions of all cursors (except pExcept) that are open on +** the table with root-page iRoot. "Saving the cursor position" means that +** the location in the btree is remembered in such a way that it can be +** moved back to the same spot after the btree has been modified. This +** routine is called just before cursor pExcept is used to modify the +** table, for example in BtreeDelete() or BtreeInsert(). +** +** If there are two or more cursors on the same btree, then all such +** cursors should have their BTCF_Multiple flag set. The btreeCursor() +** routine enforces that rule. This routine only needs to be called in +** the uncommon case when pExpect has the BTCF_Multiple flag set. +** +** If pExpect!=NULL and if no other cursors are found on the same root-page, +** then the BTCF_Multiple flag on pExpect is cleared, to avoid another +** pointless call to this routine. +** +** Implementation note: This routine merely checks to see if any cursors +** need to be saved. It calls out to saveCursorsOnList() in the (unusual) +** event that cursors are in need to being saved. +*/ +static int saveAllCursors(BtShared *pBt, Pgno iRoot, BtCursor *pExcept){ + BtCursor *p; + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( pExcept==0 || pExcept->pBt==pBt ); + for(p=pBt->pCursor; p; p=p->pNext){ + if( p!=pExcept && (0==iRoot || p->pgnoRoot==iRoot) ) break; + } + if( p ) return saveCursorsOnList(p, iRoot, pExcept); + if( pExcept ) pExcept->curFlags &= ~BTCF_Multiple; + return SQLITE_OK; +} + +/* This helper routine to saveAllCursors does the actual work of saving +** the cursors if and when a cursor is found that actually requires saving. +** The common case is that no cursors need to be saved, so this routine is +** broken out from its caller to avoid unnecessary stack pointer movement. +*/ +static int SQLITE_NOINLINE saveCursorsOnList( + BtCursor *p, /* The first cursor that needs saving */ + Pgno iRoot, /* Only save cursor with this iRoot. Save all if zero */ + BtCursor *pExcept /* Do not save this cursor */ +){ + do{ + if( p!=pExcept && (0==iRoot || p->pgnoRoot==iRoot) ){ + if( p->eState==CURSOR_VALID || p->eState==CURSOR_SKIPNEXT ){ + int rc = saveCursorPosition(p); + if( SQLITE_OK!=rc ){ + return rc; + } + }else{ + testcase( p->iPage>=0 ); + btreeReleaseAllCursorPages(p); + } + } + p = p->pNext; + }while( p ); + return SQLITE_OK; +} + +/* +** Clear the current cursor position. +*/ +SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *pCur){ + assert( cursorHoldsMutex(pCur) ); + sqlite3_free(pCur->pKey); + pCur->pKey = 0; + pCur->eState = CURSOR_INVALID; +} + +/* +** In this version of BtreeMoveto, pKey is a packed index record +** such as is generated by the OP_MakeRecord opcode. Unpack the +** record and then call sqlite3BtreeIndexMoveto() to do the work. +*/ +static int btreeMoveto( + BtCursor *pCur, /* Cursor open on the btree to be searched */ + const void *pKey, /* Packed key if the btree is an index */ + i64 nKey, /* Integer key for tables. Size of pKey for indices */ + int bias, /* Bias search to the high end */ + int *pRes /* Write search results here */ +){ + int rc; /* Status code */ + UnpackedRecord *pIdxKey; /* Unpacked index key */ + + if( pKey ){ + KeyInfo *pKeyInfo = pCur->pKeyInfo; + assert( nKey==(i64)(int)nKey ); + pIdxKey = sqlite3VdbeAllocUnpackedRecord(pKeyInfo); + if( pIdxKey==0 ) return SQLITE_NOMEM_BKPT; + sqlite3VdbeRecordUnpack(pKeyInfo, (int)nKey, pKey, pIdxKey); + if( pIdxKey->nField==0 || pIdxKey->nField>pKeyInfo->nAllField ){ + rc = SQLITE_CORRUPT_BKPT; + }else{ + rc = sqlite3BtreeIndexMoveto(pCur, pIdxKey, pRes); + } + sqlite3DbFree(pCur->pKeyInfo->db, pIdxKey); + }else{ + pIdxKey = 0; + rc = sqlite3BtreeTableMoveto(pCur, nKey, bias, pRes); + } + return rc; +} + +/* +** Restore the cursor to the position it was in (or as close to as possible) +** when saveCursorPosition() was called. Note that this call deletes the +** saved position info stored by saveCursorPosition(), so there can be +** at most one effective restoreCursorPosition() call after each +** saveCursorPosition(). +*/ +static int btreeRestoreCursorPosition(BtCursor *pCur){ + int rc; + int skipNext = 0; + assert( cursorOwnsBtShared(pCur) ); + assert( pCur->eState>=CURSOR_REQUIRESEEK ); + if( pCur->eState==CURSOR_FAULT ){ + return pCur->skipNext; + } + pCur->eState = CURSOR_INVALID; + if( sqlite3FaultSim(410) ){ + rc = SQLITE_IOERR; + }else{ + rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &skipNext); + } + if( rc==SQLITE_OK ){ + sqlite3_free(pCur->pKey); + pCur->pKey = 0; + assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID ); + if( skipNext ) pCur->skipNext = skipNext; + if( pCur->skipNext && pCur->eState==CURSOR_VALID ){ + pCur->eState = CURSOR_SKIPNEXT; + } + } + return rc; +} + +#define restoreCursorPosition(p) \ + (p->eState>=CURSOR_REQUIRESEEK ? \ + btreeRestoreCursorPosition(p) : \ + SQLITE_OK) + +/* +** Determine whether or not a cursor has moved from the position where +** it was last placed, or has been invalidated for any other reason. +** Cursors can move when the row they are pointing at is deleted out +** from under them, for example. Cursor might also move if a btree +** is rebalanced. +** +** Calling this routine with a NULL cursor pointer returns false. +** +** Use the separate sqlite3BtreeCursorRestore() routine to restore a cursor +** back to where it ought to be if this routine returns true. +*/ +SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor *pCur){ + assert( EIGHT_BYTE_ALIGNMENT(pCur) + || pCur==sqlite3BtreeFakeValidCursor() ); + assert( offsetof(BtCursor, eState)==0 ); + assert( sizeof(pCur->eState)==1 ); + return CURSOR_VALID != *(u8*)pCur; +} + +/* +** Return a pointer to a fake BtCursor object that will always answer +** false to the sqlite3BtreeCursorHasMoved() routine above. The fake +** cursor returned must not be used with any other Btree interface. +*/ +SQLITE_PRIVATE BtCursor *sqlite3BtreeFakeValidCursor(void){ + static u8 fakeCursor = CURSOR_VALID; + assert( offsetof(BtCursor, eState)==0 ); + return (BtCursor*)&fakeCursor; +} + +/* +** This routine restores a cursor back to its original position after it +** has been moved by some outside activity (such as a btree rebalance or +** a row having been deleted out from under the cursor). +** +** On success, the *pDifferentRow parameter is false if the cursor is left +** pointing at exactly the same row. *pDifferntRow is the row the cursor +** was pointing to has been deleted, forcing the cursor to point to some +** nearby row. +** +** This routine should only be called for a cursor that just returned +** TRUE from sqlite3BtreeCursorHasMoved(). +*/ +SQLITE_PRIVATE int sqlite3BtreeCursorRestore(BtCursor *pCur, int *pDifferentRow){ + int rc; + + assert( pCur!=0 ); + assert( pCur->eState!=CURSOR_VALID ); + rc = restoreCursorPosition(pCur); + if( rc ){ + *pDifferentRow = 1; + return rc; + } + if( pCur->eState!=CURSOR_VALID ){ + *pDifferentRow = 1; + }else{ + *pDifferentRow = 0; + } + return SQLITE_OK; +} + +#ifdef SQLITE_ENABLE_CURSOR_HINTS +/* +** Provide hints to the cursor. The particular hint given (and the type +** and number of the varargs parameters) is determined by the eHintType +** parameter. See the definitions of the BTREE_HINT_* macros for details. +*/ +SQLITE_PRIVATE void sqlite3BtreeCursorHint(BtCursor *pCur, int eHintType, ...){ + /* Used only by system that substitute their own storage engine */ +#ifdef SQLITE_DEBUG + if( ALWAYS(eHintType==BTREE_HINT_RANGE) ){ + va_list ap; + Expr *pExpr; + Walker w; + memset(&w, 0, sizeof(w)); + w.xExprCallback = sqlite3CursorRangeHintExprCheck; + va_start(ap, eHintType); + pExpr = va_arg(ap, Expr*); + w.u.aMem = va_arg(ap, Mem*); + va_end(ap); + assert( pExpr!=0 ); + assert( w.u.aMem!=0 ); + sqlite3WalkExpr(&w, pExpr); + } +#endif /* SQLITE_DEBUG */ +} +#endif /* SQLITE_ENABLE_CURSOR_HINTS */ + + +/* +** Provide flag hints to the cursor. +*/ +SQLITE_PRIVATE void sqlite3BtreeCursorHintFlags(BtCursor *pCur, unsigned x){ + assert( x==BTREE_SEEK_EQ || x==BTREE_BULKLOAD || x==0 ); + pCur->hints = x; +} + + +#ifndef SQLITE_OMIT_AUTOVACUUM +/* +** Given a page number of a regular database page, return the page +** number for the pointer-map page that contains the entry for the +** input page number. +** +** Return 0 (not a valid page) for pgno==1 since there is +** no pointer map associated with page 1. The integrity_check logic +** requires that ptrmapPageno(*,1)!=1. +*/ +static Pgno ptrmapPageno(BtShared *pBt, Pgno pgno){ + int nPagesPerMapPage; + Pgno iPtrMap, ret; + assert( sqlite3_mutex_held(pBt->mutex) ); + if( pgno<2 ) return 0; + nPagesPerMapPage = (pBt->usableSize/5)+1; + iPtrMap = (pgno-2)/nPagesPerMapPage; + ret = (iPtrMap*nPagesPerMapPage) + 2; + if( ret==PENDING_BYTE_PAGE(pBt) ){ + ret++; + } + return ret; +} + +/* +** Write an entry into the pointer map. +** +** This routine updates the pointer map entry for page number 'key' +** so that it maps to type 'eType' and parent page number 'pgno'. +** +** If *pRC is initially non-zero (non-SQLITE_OK) then this routine is +** a no-op. If an error occurs, the appropriate error code is written +** into *pRC. +*/ +static void ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent, int *pRC){ + DbPage *pDbPage; /* The pointer map page */ + u8 *pPtrmap; /* The pointer map data */ + Pgno iPtrmap; /* The pointer map page number */ + int offset; /* Offset in pointer map page */ + int rc; /* Return code from subfunctions */ + + if( *pRC ) return; + + assert( sqlite3_mutex_held(pBt->mutex) ); + /* The super-journal page number must never be used as a pointer map page */ + assert( 0==PTRMAP_ISPAGE(pBt, PENDING_BYTE_PAGE(pBt)) ); + + assert( pBt->autoVacuum ); + if( key==0 ){ + *pRC = SQLITE_CORRUPT_BKPT; + return; + } + iPtrmap = PTRMAP_PAGENO(pBt, key); + rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage, 0); + if( rc!=SQLITE_OK ){ + *pRC = rc; + return; + } + if( ((char*)sqlite3PagerGetExtra(pDbPage))[0]!=0 ){ + /* The first byte of the extra data is the MemPage.isInit byte. + ** If that byte is set, it means this page is also being used + ** as a btree page. */ + *pRC = SQLITE_CORRUPT_BKPT; + goto ptrmap_exit; + } + offset = PTRMAP_PTROFFSET(iPtrmap, key); + if( offset<0 ){ + *pRC = SQLITE_CORRUPT_BKPT; + goto ptrmap_exit; + } + assert( offset <= (int)pBt->usableSize-5 ); + pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage); + + if( eType!=pPtrmap[offset] || get4byte(&pPtrmap[offset+1])!=parent ){ + TRACE(("PTRMAP_UPDATE: %u->(%u,%u)\n", key, eType, parent)); + *pRC= rc = sqlite3PagerWrite(pDbPage); + if( rc==SQLITE_OK ){ + pPtrmap[offset] = eType; + put4byte(&pPtrmap[offset+1], parent); + } + } + +ptrmap_exit: + sqlite3PagerUnref(pDbPage); +} + +/* +** Read an entry from the pointer map. +** +** This routine retrieves the pointer map entry for page 'key', writing +** the type and parent page number to *pEType and *pPgno respectively. +** An error code is returned if something goes wrong, otherwise SQLITE_OK. +*/ +static int ptrmapGet(BtShared *pBt, Pgno key, u8 *pEType, Pgno *pPgno){ + DbPage *pDbPage; /* The pointer map page */ + int iPtrmap; /* Pointer map page index */ + u8 *pPtrmap; /* Pointer map page data */ + int offset; /* Offset of entry in pointer map */ + int rc; + + assert( sqlite3_mutex_held(pBt->mutex) ); + + iPtrmap = PTRMAP_PAGENO(pBt, key); + rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage, 0); + if( rc!=0 ){ + return rc; + } + pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage); + + offset = PTRMAP_PTROFFSET(iPtrmap, key); + if( offset<0 ){ + sqlite3PagerUnref(pDbPage); + return SQLITE_CORRUPT_BKPT; + } + assert( offset <= (int)pBt->usableSize-5 ); + assert( pEType!=0 ); + *pEType = pPtrmap[offset]; + if( pPgno ) *pPgno = get4byte(&pPtrmap[offset+1]); + + sqlite3PagerUnref(pDbPage); + if( *pEType<1 || *pEType>5 ) return SQLITE_CORRUPT_PGNO(iPtrmap); + return SQLITE_OK; +} + +#else /* if defined SQLITE_OMIT_AUTOVACUUM */ + #define ptrmapPut(w,x,y,z,rc) + #define ptrmapGet(w,x,y,z) SQLITE_OK + #define ptrmapPutOvflPtr(x, y, z, rc) +#endif + +/* +** Given a btree page and a cell index (0 means the first cell on +** the page, 1 means the second cell, and so forth) return a pointer +** to the cell content. +** +** findCellPastPtr() does the same except it skips past the initial +** 4-byte child pointer found on interior pages, if there is one. +** +** This routine works only for pages that do not contain overflow cells. +*/ +#define findCell(P,I) \ + ((P)->aData + ((P)->maskPage & get2byteAligned(&(P)->aCellIdx[2*(I)]))) +#define findCellPastPtr(P,I) \ + ((P)->aDataOfst + ((P)->maskPage & get2byteAligned(&(P)->aCellIdx[2*(I)]))) + + +/* +** This is common tail processing for btreeParseCellPtr() and +** btreeParseCellPtrIndex() for the case when the cell does not fit entirely +** on a single B-tree page. Make necessary adjustments to the CellInfo +** structure. +*/ +static SQLITE_NOINLINE void btreeParseCellAdjustSizeForOverflow( + MemPage *pPage, /* Page containing the cell */ + u8 *pCell, /* Pointer to the cell text. */ + CellInfo *pInfo /* Fill in this structure */ +){ + /* If the payload will not fit completely on the local page, we have + ** to decide how much to store locally and how much to spill onto + ** overflow pages. The strategy is to minimize the amount of unused + ** space on overflow pages while keeping the amount of local storage + ** in between minLocal and maxLocal. + ** + ** Warning: changing the way overflow payload is distributed in any + ** way will result in an incompatible file format. + */ + int minLocal; /* Minimum amount of payload held locally */ + int maxLocal; /* Maximum amount of payload held locally */ + int surplus; /* Overflow payload available for local storage */ + + minLocal = pPage->minLocal; + maxLocal = pPage->maxLocal; + surplus = minLocal + (pInfo->nPayload - minLocal)%(pPage->pBt->usableSize-4); + testcase( surplus==maxLocal ); + testcase( surplus==maxLocal+1 ); + if( surplus <= maxLocal ){ + pInfo->nLocal = (u16)surplus; + }else{ + pInfo->nLocal = (u16)minLocal; + } + pInfo->nSize = (u16)(&pInfo->pPayload[pInfo->nLocal] - pCell) + 4; +} + +/* +** Given a record with nPayload bytes of payload stored within btree +** page pPage, return the number of bytes of payload stored locally. +*/ +static int btreePayloadToLocal(MemPage *pPage, i64 nPayload){ + int maxLocal; /* Maximum amount of payload held locally */ + maxLocal = pPage->maxLocal; + if( nPayload<=maxLocal ){ + return nPayload; + }else{ + int minLocal; /* Minimum amount of payload held locally */ + int surplus; /* Overflow payload available for local storage */ + minLocal = pPage->minLocal; + surplus = minLocal + (nPayload - minLocal)%(pPage->pBt->usableSize-4); + return ( surplus <= maxLocal ) ? surplus : minLocal; + } +} + +/* +** The following routines are implementations of the MemPage.xParseCell() +** method. +** +** Parse a cell content block and fill in the CellInfo structure. +** +** btreeParseCellPtr() => table btree leaf nodes +** btreeParseCellNoPayload() => table btree internal nodes +** btreeParseCellPtrIndex() => index btree nodes +** +** There is also a wrapper function btreeParseCell() that works for +** all MemPage types and that references the cell by index rather than +** by pointer. +*/ +static void btreeParseCellPtrNoPayload( + MemPage *pPage, /* Page containing the cell */ + u8 *pCell, /* Pointer to the cell text. */ + CellInfo *pInfo /* Fill in this structure */ +){ + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( pPage->leaf==0 ); + assert( pPage->childPtrSize==4 ); +#ifndef SQLITE_DEBUG + UNUSED_PARAMETER(pPage); +#endif + pInfo->nSize = 4 + getVarint(&pCell[4], (u64*)&pInfo->nKey); + pInfo->nPayload = 0; + pInfo->nLocal = 0; + pInfo->pPayload = 0; + return; +} +static void btreeParseCellPtr( + MemPage *pPage, /* Page containing the cell */ + u8 *pCell, /* Pointer to the cell text. */ + CellInfo *pInfo /* Fill in this structure */ +){ + u8 *pIter; /* For scanning through pCell */ + u32 nPayload; /* Number of bytes of cell payload */ + u64 iKey; /* Extracted Key value */ + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( pPage->leaf==0 || pPage->leaf==1 ); + assert( pPage->intKeyLeaf ); + assert( pPage->childPtrSize==0 ); + pIter = pCell; + + /* The next block of code is equivalent to: + ** + ** pIter += getVarint32(pIter, nPayload); + ** + ** The code is inlined to avoid a function call. + */ + nPayload = *pIter; + if( nPayload>=0x80 ){ + u8 *pEnd = &pIter[8]; + nPayload &= 0x7f; + do{ + nPayload = (nPayload<<7) | (*++pIter & 0x7f); + }while( (*pIter)>=0x80 && pIternKey); + ** + ** The code is inlined and the loop is unrolled for performance. + ** This routine is a high-runner. + */ + iKey = *pIter; + if( iKey>=0x80 ){ + u8 x; + iKey = (iKey<<7) ^ (x = *++pIter); + if( x>=0x80 ){ + iKey = (iKey<<7) ^ (x = *++pIter); + if( x>=0x80 ){ + iKey = (iKey<<7) ^ 0x10204000 ^ (x = *++pIter); + if( x>=0x80 ){ + iKey = (iKey<<7) ^ 0x4000 ^ (x = *++pIter); + if( x>=0x80 ){ + iKey = (iKey<<7) ^ 0x4000 ^ (x = *++pIter); + if( x>=0x80 ){ + iKey = (iKey<<7) ^ 0x4000 ^ (x = *++pIter); + if( x>=0x80 ){ + iKey = (iKey<<7) ^ 0x4000 ^ (x = *++pIter); + if( x>=0x80 ){ + iKey = (iKey<<8) ^ 0x8000 ^ (*++pIter); + } + } + } + } + } + }else{ + iKey ^= 0x204000; + } + }else{ + iKey ^= 0x4000; + } + } + pIter++; + + pInfo->nKey = *(i64*)&iKey; + pInfo->nPayload = nPayload; + pInfo->pPayload = pIter; + testcase( nPayload==pPage->maxLocal ); + testcase( nPayload==(u32)pPage->maxLocal+1 ); + if( nPayload<=pPage->maxLocal ){ + /* This is the (easy) common case where the entire payload fits + ** on the local page. No overflow is required. + */ + pInfo->nSize = nPayload + (u16)(pIter - pCell); + if( pInfo->nSize<4 ) pInfo->nSize = 4; + pInfo->nLocal = (u16)nPayload; + }else{ + btreeParseCellAdjustSizeForOverflow(pPage, pCell, pInfo); + } +} +static void btreeParseCellPtrIndex( + MemPage *pPage, /* Page containing the cell */ + u8 *pCell, /* Pointer to the cell text. */ + CellInfo *pInfo /* Fill in this structure */ +){ + u8 *pIter; /* For scanning through pCell */ + u32 nPayload; /* Number of bytes of cell payload */ + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( pPage->leaf==0 || pPage->leaf==1 ); + assert( pPage->intKeyLeaf==0 ); + pIter = pCell + pPage->childPtrSize; + nPayload = *pIter; + if( nPayload>=0x80 ){ + u8 *pEnd = &pIter[8]; + nPayload &= 0x7f; + do{ + nPayload = (nPayload<<7) | (*++pIter & 0x7f); + }while( *(pIter)>=0x80 && pIternKey = nPayload; + pInfo->nPayload = nPayload; + pInfo->pPayload = pIter; + testcase( nPayload==pPage->maxLocal ); + testcase( nPayload==(u32)pPage->maxLocal+1 ); + if( nPayload<=pPage->maxLocal ){ + /* This is the (easy) common case where the entire payload fits + ** on the local page. No overflow is required. + */ + pInfo->nSize = nPayload + (u16)(pIter - pCell); + if( pInfo->nSize<4 ) pInfo->nSize = 4; + pInfo->nLocal = (u16)nPayload; + }else{ + btreeParseCellAdjustSizeForOverflow(pPage, pCell, pInfo); + } +} +static void btreeParseCell( + MemPage *pPage, /* Page containing the cell */ + int iCell, /* The cell index. First cell is 0 */ + CellInfo *pInfo /* Fill in this structure */ +){ + pPage->xParseCell(pPage, findCell(pPage, iCell), pInfo); +} + +/* +** The following routines are implementations of the MemPage.xCellSize +** method. +** +** Compute the total number of bytes that a Cell needs in the cell +** data area of the btree-page. The return number includes the cell +** data header and the local payload, but not any overflow page or +** the space used by the cell pointer. +** +** cellSizePtrNoPayload() => table internal nodes +** cellSizePtrTableLeaf() => table leaf nodes +** cellSizePtr() => index internal nodes +** cellSizeIdxLeaf() => index leaf nodes +*/ +static u16 cellSizePtr(MemPage *pPage, u8 *pCell){ + u8 *pIter = pCell + 4; /* For looping over bytes of pCell */ + u8 *pEnd; /* End mark for a varint */ + u32 nSize; /* Size value to return */ + +#ifdef SQLITE_DEBUG + /* The value returned by this function should always be the same as + ** the (CellInfo.nSize) value found by doing a full parse of the + ** cell. If SQLITE_DEBUG is defined, an assert() at the bottom of + ** this function verifies that this invariant is not violated. */ + CellInfo debuginfo; + pPage->xParseCell(pPage, pCell, &debuginfo); +#endif + + assert( pPage->childPtrSize==4 ); + nSize = *pIter; + if( nSize>=0x80 ){ + pEnd = &pIter[8]; + nSize &= 0x7f; + do{ + nSize = (nSize<<7) | (*++pIter & 0x7f); + }while( *(pIter)>=0x80 && pItermaxLocal ); + testcase( nSize==(u32)pPage->maxLocal+1 ); + if( nSize<=pPage->maxLocal ){ + nSize += (u32)(pIter - pCell); + assert( nSize>4 ); + }else{ + int minLocal = pPage->minLocal; + nSize = minLocal + (nSize - minLocal) % (pPage->pBt->usableSize - 4); + testcase( nSize==pPage->maxLocal ); + testcase( nSize==(u32)pPage->maxLocal+1 ); + if( nSize>pPage->maxLocal ){ + nSize = minLocal; + } + nSize += 4 + (u16)(pIter - pCell); + } + assert( nSize==debuginfo.nSize || CORRUPT_DB ); + return (u16)nSize; +} +static u16 cellSizePtrIdxLeaf(MemPage *pPage, u8 *pCell){ + u8 *pIter = pCell; /* For looping over bytes of pCell */ + u8 *pEnd; /* End mark for a varint */ + u32 nSize; /* Size value to return */ + +#ifdef SQLITE_DEBUG + /* The value returned by this function should always be the same as + ** the (CellInfo.nSize) value found by doing a full parse of the + ** cell. If SQLITE_DEBUG is defined, an assert() at the bottom of + ** this function verifies that this invariant is not violated. */ + CellInfo debuginfo; + pPage->xParseCell(pPage, pCell, &debuginfo); +#endif + + assert( pPage->childPtrSize==0 ); + nSize = *pIter; + if( nSize>=0x80 ){ + pEnd = &pIter[8]; + nSize &= 0x7f; + do{ + nSize = (nSize<<7) | (*++pIter & 0x7f); + }while( *(pIter)>=0x80 && pItermaxLocal ); + testcase( nSize==(u32)pPage->maxLocal+1 ); + if( nSize<=pPage->maxLocal ){ + nSize += (u32)(pIter - pCell); + if( nSize<4 ) nSize = 4; + }else{ + int minLocal = pPage->minLocal; + nSize = minLocal + (nSize - minLocal) % (pPage->pBt->usableSize - 4); + testcase( nSize==pPage->maxLocal ); + testcase( nSize==(u32)pPage->maxLocal+1 ); + if( nSize>pPage->maxLocal ){ + nSize = minLocal; + } + nSize += 4 + (u16)(pIter - pCell); + } + assert( nSize==debuginfo.nSize || CORRUPT_DB ); + return (u16)nSize; +} +static u16 cellSizePtrNoPayload(MemPage *pPage, u8 *pCell){ + u8 *pIter = pCell + 4; /* For looping over bytes of pCell */ + u8 *pEnd; /* End mark for a varint */ + +#ifdef SQLITE_DEBUG + /* The value returned by this function should always be the same as + ** the (CellInfo.nSize) value found by doing a full parse of the + ** cell. If SQLITE_DEBUG is defined, an assert() at the bottom of + ** this function verifies that this invariant is not violated. */ + CellInfo debuginfo; + pPage->xParseCell(pPage, pCell, &debuginfo); +#else + UNUSED_PARAMETER(pPage); +#endif + + assert( pPage->childPtrSize==4 ); + pEnd = pIter + 9; + while( (*pIter++)&0x80 && pIterxParseCell(pPage, pCell, &debuginfo); +#endif + + nSize = *pIter; + if( nSize>=0x80 ){ + pEnd = &pIter[8]; + nSize &= 0x7f; + do{ + nSize = (nSize<<7) | (*++pIter & 0x7f); + }while( *(pIter)>=0x80 && pItermaxLocal ); + testcase( nSize==(u32)pPage->maxLocal+1 ); + if( nSize<=pPage->maxLocal ){ + nSize += (u32)(pIter - pCell); + if( nSize<4 ) nSize = 4; + }else{ + int minLocal = pPage->minLocal; + nSize = minLocal + (nSize - minLocal) % (pPage->pBt->usableSize - 4); + testcase( nSize==pPage->maxLocal ); + testcase( nSize==(u32)pPage->maxLocal+1 ); + if( nSize>pPage->maxLocal ){ + nSize = minLocal; + } + nSize += 4 + (u16)(pIter - pCell); + } + assert( nSize==debuginfo.nSize || CORRUPT_DB ); + return (u16)nSize; +} + + +#ifdef SQLITE_DEBUG +/* This variation on cellSizePtr() is used inside of assert() statements +** only. */ +static u16 cellSize(MemPage *pPage, int iCell){ + return pPage->xCellSize(pPage, findCell(pPage, iCell)); +} +#endif + +#ifndef SQLITE_OMIT_AUTOVACUUM +/* +** The cell pCell is currently part of page pSrc but will ultimately be part +** of pPage. (pSrc and pPage are often the same.) If pCell contains a +** pointer to an overflow page, insert an entry into the pointer-map for +** the overflow page that will be valid after pCell has been moved to pPage. +*/ +static void ptrmapPutOvflPtr(MemPage *pPage, MemPage *pSrc, u8 *pCell,int *pRC){ + CellInfo info; + if( *pRC ) return; + assert( pCell!=0 ); + pPage->xParseCell(pPage, pCell, &info); + if( info.nLocalaDataEnd, pCell, pCell+info.nLocal) ){ + testcase( pSrc!=pPage ); + *pRC = SQLITE_CORRUPT_BKPT; + return; + } + ovfl = get4byte(&pCell[info.nSize-4]); + ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, pRC); + } +} +#endif + + +/* +** Defragment the page given. This routine reorganizes cells within the +** page so that there are no free-blocks on the free-block list. +** +** Parameter nMaxFrag is the maximum amount of fragmented space that may be +** present in the page after this routine returns. +** +** EVIDENCE-OF: R-44582-60138 SQLite may from time to time reorganize a +** b-tree page so that there are no freeblocks or fragment bytes, all +** unused bytes are contained in the unallocated space region, and all +** cells are packed tightly at the end of the page. +*/ +static int defragmentPage(MemPage *pPage, int nMaxFrag){ + int i; /* Loop counter */ + int pc; /* Address of the i-th cell */ + int hdr; /* Offset to the page header */ + int size; /* Size of a cell */ + int usableSize; /* Number of usable bytes on a page */ + int cellOffset; /* Offset to the cell pointer array */ + int cbrk; /* Offset to the cell content area */ + int nCell; /* Number of cells on the page */ + unsigned char *data; /* The page data */ + unsigned char *temp; /* Temp area for cell content */ + unsigned char *src; /* Source of content */ + int iCellFirst; /* First allowable cell index */ + int iCellLast; /* Last possible cell index */ + int iCellStart; /* First cell offset in input */ + + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + assert( pPage->pBt!=0 ); + assert( pPage->pBt->usableSize <= SQLITE_MAX_PAGE_SIZE ); + assert( pPage->nOverflow==0 ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + data = pPage->aData; + hdr = pPage->hdrOffset; + cellOffset = pPage->cellOffset; + nCell = pPage->nCell; + assert( nCell==get2byte(&data[hdr+3]) || CORRUPT_DB ); + iCellFirst = cellOffset + 2*nCell; + usableSize = pPage->pBt->usableSize; + + /* This block handles pages with two or fewer free blocks and nMaxFrag + ** or fewer fragmented bytes. In this case it is faster to move the + ** two (or one) blocks of cells using memmove() and add the required + ** offsets to each pointer in the cell-pointer array than it is to + ** reconstruct the entire page. */ + if( (int)data[hdr+7]<=nMaxFrag ){ + int iFree = get2byte(&data[hdr+1]); + if( iFree>usableSize-4 ) return SQLITE_CORRUPT_PAGE(pPage); + if( iFree ){ + int iFree2 = get2byte(&data[iFree]); + if( iFree2>usableSize-4 ) return SQLITE_CORRUPT_PAGE(pPage); + if( 0==iFree2 || (data[iFree2]==0 && data[iFree2+1]==0) ){ + u8 *pEnd = &data[cellOffset + nCell*2]; + u8 *pAddr; + int sz2 = 0; + int sz = get2byte(&data[iFree+2]); + int top = get2byte(&data[hdr+5]); + if( top>=iFree ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + if( iFree2 ){ + if( iFree+sz>iFree2 ) return SQLITE_CORRUPT_PAGE(pPage); + sz2 = get2byte(&data[iFree2+2]); + if( iFree2+sz2 > usableSize ) return SQLITE_CORRUPT_PAGE(pPage); + memmove(&data[iFree+sz+sz2], &data[iFree+sz], iFree2-(iFree+sz)); + sz += sz2; + }else if( iFree+sz>usableSize ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + + cbrk = top+sz; + assert( cbrk+(iFree-top) <= usableSize ); + memmove(&data[cbrk], &data[top], iFree-top); + for(pAddr=&data[cellOffset]; pAddr0 ){ + temp = sqlite3PagerTempSpace(pPage->pBt->pPager); + memcpy(&temp[iCellStart], &data[iCellStart], usableSize - iCellStart); + src = temp; + for(i=0; iiCellLast ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + assert( pc>=0 && pc<=iCellLast ); + size = pPage->xCellSize(pPage, &src[pc]); + cbrk -= size; + if( cbrkusableSize ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + assert( cbrk+size<=usableSize && cbrk>=iCellStart ); + testcase( cbrk+size==usableSize ); + testcase( pc+size==usableSize ); + put2byte(pAddr, cbrk); + memcpy(&data[cbrk], &src[pc], size); + } + } + data[hdr+7] = 0; + +defragment_out: + assert( pPage->nFree>=0 ); + if( data[hdr+7]+cbrk-iCellFirst!=pPage->nFree ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + assert( cbrk>=iCellFirst ); + put2byte(&data[hdr+5], cbrk); + data[hdr+1] = 0; + data[hdr+2] = 0; + memset(&data[iCellFirst], 0, cbrk-iCellFirst); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + return SQLITE_OK; +} + +/* +** Search the free-list on page pPg for space to store a cell nByte bytes in +** size. If one can be found, return a pointer to the space and remove it +** from the free-list. +** +** If no suitable space can be found on the free-list, return NULL. +** +** This function may detect corruption within pPg. If corruption is +** detected then *pRc is set to SQLITE_CORRUPT and NULL is returned. +** +** Slots on the free list that are between 1 and 3 bytes larger than nByte +** will be ignored if adding the extra space to the fragmentation count +** causes the fragmentation count to exceed 60. +*/ +static u8 *pageFindSlot(MemPage *pPg, int nByte, int *pRc){ + const int hdr = pPg->hdrOffset; /* Offset to page header */ + u8 * const aData = pPg->aData; /* Page data */ + int iAddr = hdr + 1; /* Address of ptr to pc */ + u8 *pTmp = &aData[iAddr]; /* Temporary ptr into aData[] */ + int pc = get2byte(pTmp); /* Address of a free slot */ + int x; /* Excess size of the slot */ + int maxPC = pPg->pBt->usableSize - nByte; /* Max address for a usable slot */ + int size; /* Size of the free slot */ + + assert( pc>0 ); + while( pc<=maxPC ){ + /* EVIDENCE-OF: R-22710-53328 The third and fourth bytes of each + ** freeblock form a big-endian integer which is the size of the freeblock + ** in bytes, including the 4-byte header. */ + pTmp = &aData[pc+2]; + size = get2byte(pTmp); + if( (x = size - nByte)>=0 ){ + testcase( x==4 ); + testcase( x==3 ); + if( x<4 ){ + /* EVIDENCE-OF: R-11498-58022 In a well-formed b-tree page, the total + ** number of bytes in fragments may not exceed 60. */ + if( aData[hdr+7]>57 ) return 0; + + /* Remove the slot from the free-list. Update the number of + ** fragmented bytes within the page. */ + memcpy(&aData[iAddr], &aData[pc], 2); + aData[hdr+7] += (u8)x; + return &aData[pc]; + }else if( x+pc > maxPC ){ + /* This slot extends off the end of the usable part of the page */ + *pRc = SQLITE_CORRUPT_PAGE(pPg); + return 0; + }else{ + /* The slot remains on the free-list. Reduce its size to account + ** for the portion used by the new allocation. */ + put2byte(&aData[pc+2], x); + } + return &aData[pc + x]; + } + iAddr = pc; + pTmp = &aData[pc]; + pc = get2byte(pTmp); + if( pc<=iAddr ){ + if( pc ){ + /* The next slot in the chain comes before the current slot */ + *pRc = SQLITE_CORRUPT_PAGE(pPg); + } + return 0; + } + } + if( pc>maxPC+nByte-4 ){ + /* The free slot chain extends off the end of the page */ + *pRc = SQLITE_CORRUPT_PAGE(pPg); + } + return 0; +} + +/* +** Allocate nByte bytes of space from within the B-Tree page passed +** as the first argument. Write into *pIdx the index into pPage->aData[] +** of the first byte of allocated space. Return either SQLITE_OK or +** an error code (usually SQLITE_CORRUPT). +** +** The caller guarantees that there is sufficient space to make the +** allocation. This routine might need to defragment in order to bring +** all the space together, however. This routine will avoid using +** the first two bytes past the cell pointer area since presumably this +** allocation is being made in order to insert a new cell, so we will +** also end up needing a new cell pointer. +*/ +static SQLITE_INLINE int allocateSpace(MemPage *pPage, int nByte, int *pIdx){ + const int hdr = pPage->hdrOffset; /* Local cache of pPage->hdrOffset */ + u8 * const data = pPage->aData; /* Local cache of pPage->aData */ + int top; /* First byte of cell content area */ + int rc = SQLITE_OK; /* Integer return code */ + u8 *pTmp; /* Temp ptr into data[] */ + int gap; /* First byte of gap between cell pointers and cell content */ + + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + assert( pPage->pBt ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( nByte>=0 ); /* Minimum cell size is 4 */ + assert( pPage->nFree>=nByte ); + assert( pPage->nOverflow==0 ); + assert( nByte < (int)(pPage->pBt->usableSize-8) ); + + assert( pPage->cellOffset == hdr + 12 - 4*pPage->leaf ); + gap = pPage->cellOffset + 2*pPage->nCell; + assert( gap<=65536 ); + /* EVIDENCE-OF: R-29356-02391 If the database uses a 65536-byte page size + ** and the reserved space is zero (the usual value for reserved space) + ** then the cell content offset of an empty page wants to be 65536. + ** However, that integer is too large to be stored in a 2-byte unsigned + ** integer, so a value of 0 is used in its place. */ + pTmp = &data[hdr+5]; + top = get2byte(pTmp); + if( gap>top ){ + if( top==0 && pPage->pBt->usableSize==65536 ){ + top = 65536; + }else{ + return SQLITE_CORRUPT_PAGE(pPage); + } + }else if( top>(int)pPage->pBt->usableSize ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + + /* If there is enough space between gap and top for one more cell pointer, + ** and if the freelist is not empty, then search the + ** freelist looking for a slot big enough to satisfy the request. + */ + testcase( gap+2==top ); + testcase( gap+1==top ); + testcase( gap==top ); + if( (data[hdr+2] || data[hdr+1]) && gap+2<=top ){ + u8 *pSpace = pageFindSlot(pPage, nByte, &rc); + if( pSpace ){ + int g2; + assert( pSpace+nByte<=data+pPage->pBt->usableSize ); + *pIdx = g2 = (int)(pSpace-data); + if( g2<=gap ){ + return SQLITE_CORRUPT_PAGE(pPage); + }else{ + return SQLITE_OK; + } + }else if( rc ){ + return rc; + } + } + + /* The request could not be fulfilled using a freelist slot. Check + ** to see if defragmentation is necessary. + */ + testcase( gap+2+nByte==top ); + if( gap+2+nByte>top ){ + assert( pPage->nCell>0 || CORRUPT_DB ); + assert( pPage->nFree>=0 ); + rc = defragmentPage(pPage, MIN(4, pPage->nFree - (2+nByte))); + if( rc ) return rc; + top = get2byteNotZero(&data[hdr+5]); + assert( gap+2+nByte<=top ); + } + + + /* Allocate memory from the gap in between the cell pointer array + ** and the cell content area. The btreeComputeFreeSpace() call has already + ** validated the freelist. Given that the freelist is valid, there + ** is no way that the allocation can extend off the end of the page. + ** The assert() below verifies the previous sentence. + */ + top -= nByte; + put2byte(&data[hdr+5], top); + assert( top+nByte <= (int)pPage->pBt->usableSize ); + *pIdx = top; + return SQLITE_OK; +} + +/* +** Return a section of the pPage->aData to the freelist. +** The first byte of the new free block is pPage->aData[iStart] +** and the size of the block is iSize bytes. +** +** Adjacent freeblocks are coalesced. +** +** Even though the freeblock list was checked by btreeComputeFreeSpace(), +** that routine will not detect overlap between cells or freeblocks. Nor +** does it detect cells or freeblocks that encrouch into the reserved bytes +** at the end of the page. So do additional corruption checks inside this +** routine and return SQLITE_CORRUPT if any problems are found. +*/ +static int freeSpace(MemPage *pPage, u16 iStart, u16 iSize){ + u16 iPtr; /* Address of ptr to next freeblock */ + u16 iFreeBlk; /* Address of the next freeblock */ + u8 hdr; /* Page header size. 0 or 100 */ + u8 nFrag = 0; /* Reduction in fragmentation */ + u16 iOrigSize = iSize; /* Original value of iSize */ + u16 x; /* Offset to cell content area */ + u32 iEnd = iStart + iSize; /* First byte past the iStart buffer */ + unsigned char *data = pPage->aData; /* Page content */ + u8 *pTmp; /* Temporary ptr into data[] */ + + assert( pPage->pBt!=0 ); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + assert( CORRUPT_DB || iStart>=pPage->hdrOffset+6+pPage->childPtrSize ); + assert( CORRUPT_DB || iEnd <= pPage->pBt->usableSize ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( iSize>=4 ); /* Minimum cell size is 4 */ + assert( CORRUPT_DB || iStart<=pPage->pBt->usableSize-4 ); + + /* The list of freeblocks must be in ascending order. Find the + ** spot on the list where iStart should be inserted. + */ + hdr = pPage->hdrOffset; + iPtr = hdr + 1; + if( data[iPtr+1]==0 && data[iPtr]==0 ){ + iFreeBlk = 0; /* Shortcut for the case when the freelist is empty */ + }else{ + while( (iFreeBlk = get2byte(&data[iPtr]))pPage->pBt->usableSize-4 ){ /* TH3: corrupt081.100 */ + return SQLITE_CORRUPT_PAGE(pPage); + } + assert( iFreeBlk>iPtr || iFreeBlk==0 || CORRUPT_DB ); + + /* At this point: + ** iFreeBlk: First freeblock after iStart, or zero if none + ** iPtr: The address of a pointer to iFreeBlk + ** + ** Check to see if iFreeBlk should be coalesced onto the end of iStart. + */ + if( iFreeBlk && iEnd+3>=iFreeBlk ){ + nFrag = iFreeBlk - iEnd; + if( iEnd>iFreeBlk ) return SQLITE_CORRUPT_PAGE(pPage); + iEnd = iFreeBlk + get2byte(&data[iFreeBlk+2]); + if( iEnd > pPage->pBt->usableSize ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + iSize = iEnd - iStart; + iFreeBlk = get2byte(&data[iFreeBlk]); + } + + /* If iPtr is another freeblock (that is, if iPtr is not the freelist + ** pointer in the page header) then check to see if iStart should be + ** coalesced onto the end of iPtr. + */ + if( iPtr>hdr+1 ){ + int iPtrEnd = iPtr + get2byte(&data[iPtr+2]); + if( iPtrEnd+3>=iStart ){ + if( iPtrEnd>iStart ) return SQLITE_CORRUPT_PAGE(pPage); + nFrag += iStart - iPtrEnd; + iSize = iEnd - iPtr; + iStart = iPtr; + } + } + if( nFrag>data[hdr+7] ) return SQLITE_CORRUPT_PAGE(pPage); + data[hdr+7] -= nFrag; + } + pTmp = &data[hdr+5]; + x = get2byte(pTmp); + if( pPage->pBt->btsFlags & BTS_FAST_SECURE ){ + /* Overwrite deleted information with zeros when the secure_delete + ** option is enabled */ + memset(&data[iStart], 0, iSize); + } + if( iStart<=x ){ + /* The new freeblock is at the beginning of the cell content area, + ** so just extend the cell content area rather than create another + ** freelist entry */ + if( iStartnFree += iOrigSize; + return SQLITE_OK; +} + +/* +** Decode the flags byte (the first byte of the header) for a page +** and initialize fields of the MemPage structure accordingly. +** +** Only the following combinations are supported. Anything different +** indicates a corrupt database files: +** +** PTF_ZERODATA (0x02, 2) +** PTF_LEAFDATA | PTF_INTKEY (0x05, 5) +** PTF_ZERODATA | PTF_LEAF (0x0a, 10) +** PTF_LEAFDATA | PTF_INTKEY | PTF_LEAF (0x0d, 13) +*/ +static int decodeFlags(MemPage *pPage, int flagByte){ + BtShared *pBt; /* A copy of pPage->pBt */ + + assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + pBt = pPage->pBt; + pPage->max1bytePayload = pBt->max1bytePayload; + if( flagByte>=(PTF_ZERODATA | PTF_LEAF) ){ + pPage->childPtrSize = 0; + pPage->leaf = 1; + if( flagByte==(PTF_LEAFDATA | PTF_INTKEY | PTF_LEAF) ){ + pPage->intKeyLeaf = 1; + pPage->xCellSize = cellSizePtrTableLeaf; + pPage->xParseCell = btreeParseCellPtr; + pPage->intKey = 1; + pPage->maxLocal = pBt->maxLeaf; + pPage->minLocal = pBt->minLeaf; + }else if( flagByte==(PTF_ZERODATA | PTF_LEAF) ){ + pPage->intKey = 0; + pPage->intKeyLeaf = 0; + pPage->xCellSize = cellSizePtrIdxLeaf; + pPage->xParseCell = btreeParseCellPtrIndex; + pPage->maxLocal = pBt->maxLocal; + pPage->minLocal = pBt->minLocal; + }else{ + pPage->intKey = 0; + pPage->intKeyLeaf = 0; + pPage->xCellSize = cellSizePtrIdxLeaf; + pPage->xParseCell = btreeParseCellPtrIndex; + return SQLITE_CORRUPT_PAGE(pPage); + } + }else{ + pPage->childPtrSize = 4; + pPage->leaf = 0; + if( flagByte==(PTF_ZERODATA) ){ + pPage->intKey = 0; + pPage->intKeyLeaf = 0; + pPage->xCellSize = cellSizePtr; + pPage->xParseCell = btreeParseCellPtrIndex; + pPage->maxLocal = pBt->maxLocal; + pPage->minLocal = pBt->minLocal; + }else if( flagByte==(PTF_LEAFDATA | PTF_INTKEY) ){ + pPage->intKeyLeaf = 0; + pPage->xCellSize = cellSizePtrNoPayload; + pPage->xParseCell = btreeParseCellPtrNoPayload; + pPage->intKey = 1; + pPage->maxLocal = pBt->maxLeaf; + pPage->minLocal = pBt->minLeaf; + }else{ + pPage->intKey = 0; + pPage->intKeyLeaf = 0; + pPage->xCellSize = cellSizePtr; + pPage->xParseCell = btreeParseCellPtrIndex; + return SQLITE_CORRUPT_PAGE(pPage); + } + } + return SQLITE_OK; +} + +/* +** Compute the amount of freespace on the page. In other words, fill +** in the pPage->nFree field. +*/ +static int btreeComputeFreeSpace(MemPage *pPage){ + int pc; /* Address of a freeblock within pPage->aData[] */ + u8 hdr; /* Offset to beginning of page header */ + u8 *data; /* Equal to pPage->aData */ + int usableSize; /* Amount of usable space on each page */ + int nFree; /* Number of unused bytes on the page */ + int top; /* First byte of the cell content area */ + int iCellFirst; /* First allowable cell or freeblock offset */ + int iCellLast; /* Last possible cell or freeblock offset */ + + assert( pPage->pBt!=0 ); + assert( pPage->pBt->db!=0 ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) ); + assert( pPage == sqlite3PagerGetExtra(pPage->pDbPage) ); + assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) ); + assert( pPage->isInit==1 ); + assert( pPage->nFree<0 ); + + usableSize = pPage->pBt->usableSize; + hdr = pPage->hdrOffset; + data = pPage->aData; + /* EVIDENCE-OF: R-58015-48175 The two-byte integer at offset 5 designates + ** the start of the cell content area. A zero value for this integer is + ** interpreted as 65536. */ + top = get2byteNotZero(&data[hdr+5]); + iCellFirst = hdr + 8 + pPage->childPtrSize + 2*pPage->nCell; + iCellLast = usableSize - 4; + + /* Compute the total free space on the page + ** EVIDENCE-OF: R-23588-34450 The two-byte integer at offset 1 gives the + ** start of the first freeblock on the page, or is zero if there are no + ** freeblocks. */ + pc = get2byte(&data[hdr+1]); + nFree = data[hdr+7] + top; /* Init nFree to non-freeblock free space */ + if( pc>0 ){ + u32 next, size; + if( pciCellLast ){ + /* Freeblock off the end of the page */ + return SQLITE_CORRUPT_PAGE(pPage); + } + next = get2byte(&data[pc]); + size = get2byte(&data[pc+2]); + nFree = nFree + size; + if( next<=pc+size+3 ) break; + pc = next; + } + if( next>0 ){ + /* Freeblock not in ascending order */ + return SQLITE_CORRUPT_PAGE(pPage); + } + if( pc+size>(unsigned int)usableSize ){ + /* Last freeblock extends past page end */ + return SQLITE_CORRUPT_PAGE(pPage); + } + } + + /* At this point, nFree contains the sum of the offset to the start + ** of the cell-content area plus the number of free bytes within + ** the cell-content area. If this is greater than the usable-size + ** of the page, then the page must be corrupted. This check also + ** serves to verify that the offset to the start of the cell-content + ** area, according to the page header, lies within the page. + */ + if( nFree>usableSize || nFreenFree = (u16)(nFree - iCellFirst); + return SQLITE_OK; +} + +/* +** Do additional sanity check after btreeInitPage() if +** PRAGMA cell_size_check=ON +*/ +static SQLITE_NOINLINE int btreeCellSizeCheck(MemPage *pPage){ + int iCellFirst; /* First allowable cell or freeblock offset */ + int iCellLast; /* Last possible cell or freeblock offset */ + int i; /* Index into the cell pointer array */ + int sz; /* Size of a cell */ + int pc; /* Address of a freeblock within pPage->aData[] */ + u8 *data; /* Equal to pPage->aData */ + int usableSize; /* Maximum usable space on the page */ + int cellOffset; /* Start of cell content area */ + + iCellFirst = pPage->cellOffset + 2*pPage->nCell; + usableSize = pPage->pBt->usableSize; + iCellLast = usableSize - 4; + data = pPage->aData; + cellOffset = pPage->cellOffset; + if( !pPage->leaf ) iCellLast--; + for(i=0; inCell; i++){ + pc = get2byteAligned(&data[cellOffset+i*2]); + testcase( pc==iCellFirst ); + testcase( pc==iCellLast ); + if( pciCellLast ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + sz = pPage->xCellSize(pPage, &data[pc]); + testcase( pc+sz==usableSize ); + if( pc+sz>usableSize ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + } + return SQLITE_OK; +} + +/* +** Initialize the auxiliary information for a disk block. +** +** Return SQLITE_OK on success. If we see that the page does +** not contain a well-formed database page, then return +** SQLITE_CORRUPT. Note that a return of SQLITE_OK does not +** guarantee that the page is well-formed. It only shows that +** we failed to detect any corruption. +*/ +static int btreeInitPage(MemPage *pPage){ + u8 *data; /* Equal to pPage->aData */ + BtShared *pBt; /* The main btree structure */ + + assert( pPage->pBt!=0 ); + assert( pPage->pBt->db!=0 ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) ); + assert( pPage == sqlite3PagerGetExtra(pPage->pDbPage) ); + assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) ); + assert( pPage->isInit==0 ); + + pBt = pPage->pBt; + data = pPage->aData + pPage->hdrOffset; + /* EVIDENCE-OF: R-28594-02890 The one-byte flag at offset 0 indicating + ** the b-tree page type. */ + if( decodeFlags(pPage, data[0]) ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + assert( pBt->pageSize>=512 && pBt->pageSize<=65536 ); + pPage->maskPage = (u16)(pBt->pageSize - 1); + pPage->nOverflow = 0; + pPage->cellOffset = pPage->hdrOffset + 8 + pPage->childPtrSize; + pPage->aCellIdx = data + pPage->childPtrSize + 8; + pPage->aDataEnd = pPage->aData + pBt->pageSize; + pPage->aDataOfst = pPage->aData + pPage->childPtrSize; + /* EVIDENCE-OF: R-37002-32774 The two-byte integer at offset 3 gives the + ** number of cells on the page. */ + pPage->nCell = get2byte(&data[3]); + if( pPage->nCell>MX_CELL(pBt) ){ + /* To many cells for a single page. The page must be corrupt */ + return SQLITE_CORRUPT_PAGE(pPage); + } + testcase( pPage->nCell==MX_CELL(pBt) ); + /* EVIDENCE-OF: R-24089-57979 If a page contains no cells (which is only + ** possible for a root page of a table that contains no rows) then the + ** offset to the cell content area will equal the page size minus the + ** bytes of reserved space. */ + assert( pPage->nCell>0 + || get2byteNotZero(&data[5])==(int)pBt->usableSize + || CORRUPT_DB ); + pPage->nFree = -1; /* Indicate that this value is yet uncomputed */ + pPage->isInit = 1; + if( pBt->db->flags & SQLITE_CellSizeCk ){ + return btreeCellSizeCheck(pPage); + } + return SQLITE_OK; +} + +/* +** Set up a raw page so that it looks like a database page holding +** no entries. +*/ +static void zeroPage(MemPage *pPage, int flags){ + unsigned char *data = pPage->aData; + BtShared *pBt = pPage->pBt; + u8 hdr = pPage->hdrOffset; + u16 first; + + assert( sqlite3PagerPagenumber(pPage->pDbPage)==pPage->pgno || CORRUPT_DB ); + assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage ); + assert( sqlite3PagerGetData(pPage->pDbPage) == data ); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + assert( sqlite3_mutex_held(pBt->mutex) ); + if( pBt->btsFlags & BTS_FAST_SECURE ){ + memset(&data[hdr], 0, pBt->usableSize - hdr); + } + data[hdr] = (char)flags; + first = hdr + ((flags&PTF_LEAF)==0 ? 12 : 8); + memset(&data[hdr+1], 0, 4); + data[hdr+7] = 0; + put2byte(&data[hdr+5], pBt->usableSize); + pPage->nFree = (u16)(pBt->usableSize - first); + decodeFlags(pPage, flags); + pPage->cellOffset = first; + pPage->aDataEnd = &data[pBt->pageSize]; + pPage->aCellIdx = &data[first]; + pPage->aDataOfst = &data[pPage->childPtrSize]; + pPage->nOverflow = 0; + assert( pBt->pageSize>=512 && pBt->pageSize<=65536 ); + pPage->maskPage = (u16)(pBt->pageSize - 1); + pPage->nCell = 0; + pPage->isInit = 1; +} + + +/* +** Convert a DbPage obtained from the pager into a MemPage used by +** the btree layer. +*/ +static MemPage *btreePageFromDbPage(DbPage *pDbPage, Pgno pgno, BtShared *pBt){ + MemPage *pPage = (MemPage*)sqlite3PagerGetExtra(pDbPage); + if( pgno!=pPage->pgno ){ + pPage->aData = sqlite3PagerGetData(pDbPage); + pPage->pDbPage = pDbPage; + pPage->pBt = pBt; + pPage->pgno = pgno; + pPage->hdrOffset = pgno==1 ? 100 : 0; + } + assert( pPage->aData==sqlite3PagerGetData(pDbPage) ); + return pPage; +} + +/* +** Get a page from the pager. Initialize the MemPage.pBt and +** MemPage.aData elements if needed. See also: btreeGetUnusedPage(). +** +** If the PAGER_GET_NOCONTENT flag is set, it means that we do not care +** about the content of the page at this time. So do not go to the disk +** to fetch the content. Just fill in the content with zeros for now. +** If in the future we call sqlite3PagerWrite() on this page, that +** means we have started to be concerned about content and the disk +** read should occur at that point. +*/ +static int btreeGetPage( + BtShared *pBt, /* The btree */ + Pgno pgno, /* Number of the page to fetch */ + MemPage **ppPage, /* Return the page in this parameter */ + int flags /* PAGER_GET_NOCONTENT or PAGER_GET_READONLY */ +){ + int rc; + DbPage *pDbPage; + + assert( flags==0 || flags==PAGER_GET_NOCONTENT || flags==PAGER_GET_READONLY ); + assert( sqlite3_mutex_held(pBt->mutex) ); + rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, flags); + if( rc ) return rc; + *ppPage = btreePageFromDbPage(pDbPage, pgno, pBt); + return SQLITE_OK; +} + +/* +** Retrieve a page from the pager cache. If the requested page is not +** already in the pager cache return NULL. Initialize the MemPage.pBt and +** MemPage.aData elements if needed. +*/ +static MemPage *btreePageLookup(BtShared *pBt, Pgno pgno){ + DbPage *pDbPage; + assert( sqlite3_mutex_held(pBt->mutex) ); + pDbPage = sqlite3PagerLookup(pBt->pPager, pgno); + if( pDbPage ){ + return btreePageFromDbPage(pDbPage, pgno, pBt); + } + return 0; +} + +/* +** Return the size of the database file in pages. If there is any kind of +** error, return ((unsigned int)-1). +*/ +static Pgno btreePagecount(BtShared *pBt){ + return pBt->nPage; +} +SQLITE_PRIVATE Pgno sqlite3BtreeLastPage(Btree *p){ + assert( sqlite3BtreeHoldsMutex(p) ); + return btreePagecount(p->pBt); +} + +/* +** Get a page from the pager and initialize it. +** +** If pCur!=0 then the page is being fetched as part of a moveToChild() +** call. Do additional sanity checking on the page in this case. +** And if the fetch fails, this routine must decrement pCur->iPage. +** +** The page is fetched as read-write unless pCur is not NULL and is +** a read-only cursor. +** +** If an error occurs, then *ppPage is undefined. It +** may remain unchanged, or it may be set to an invalid value. +*/ +static int getAndInitPage( + BtShared *pBt, /* The database file */ + Pgno pgno, /* Number of the page to get */ + MemPage **ppPage, /* Write the page pointer here */ + BtCursor *pCur, /* Cursor to receive the page, or NULL */ + int bReadOnly /* True for a read-only page */ +){ + int rc; + DbPage *pDbPage; + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( pCur==0 || ppPage==&pCur->pPage ); + assert( pCur==0 || bReadOnly==pCur->curPagerFlags ); + assert( pCur==0 || pCur->iPage>0 ); + + if( pgno>btreePagecount(pBt) ){ + rc = SQLITE_CORRUPT_BKPT; + goto getAndInitPage_error1; + } + rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, bReadOnly); + if( rc ){ + goto getAndInitPage_error1; + } + *ppPage = (MemPage*)sqlite3PagerGetExtra(pDbPage); + if( (*ppPage)->isInit==0 ){ + btreePageFromDbPage(pDbPage, pgno, pBt); + rc = btreeInitPage(*ppPage); + if( rc!=SQLITE_OK ){ + goto getAndInitPage_error2; + } + } + assert( (*ppPage)->pgno==pgno || CORRUPT_DB ); + assert( (*ppPage)->aData==sqlite3PagerGetData(pDbPage) ); + + /* If obtaining a child page for a cursor, we must verify that the page is + ** compatible with the root page. */ + if( pCur && ((*ppPage)->nCell<1 || (*ppPage)->intKey!=pCur->curIntKey) ){ + rc = SQLITE_CORRUPT_PGNO(pgno); + goto getAndInitPage_error2; + } + return SQLITE_OK; + +getAndInitPage_error2: + releasePage(*ppPage); +getAndInitPage_error1: + if( pCur ){ + pCur->iPage--; + pCur->pPage = pCur->apPage[pCur->iPage]; + } + testcase( pgno==0 ); + assert( pgno!=0 || rc!=SQLITE_OK ); + return rc; +} + +/* +** Release a MemPage. This should be called once for each prior +** call to btreeGetPage. +** +** Page1 is a special case and must be released using releasePageOne(). +*/ +static void releasePageNotNull(MemPage *pPage){ + assert( pPage->aData ); + assert( pPage->pBt ); + assert( pPage->pDbPage!=0 ); + assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage ); + assert( sqlite3PagerGetData(pPage->pDbPage)==pPage->aData ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + sqlite3PagerUnrefNotNull(pPage->pDbPage); +} +static void releasePage(MemPage *pPage){ + if( pPage ) releasePageNotNull(pPage); +} +static void releasePageOne(MemPage *pPage){ + assert( pPage!=0 ); + assert( pPage->aData ); + assert( pPage->pBt ); + assert( pPage->pDbPage!=0 ); + assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage ); + assert( sqlite3PagerGetData(pPage->pDbPage)==pPage->aData ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + sqlite3PagerUnrefPageOne(pPage->pDbPage); +} + +/* +** Get an unused page. +** +** This works just like btreeGetPage() with the addition: +** +** * If the page is already in use for some other purpose, immediately +** release it and return an SQLITE_CURRUPT error. +** * Make sure the isInit flag is clear +*/ +static int btreeGetUnusedPage( + BtShared *pBt, /* The btree */ + Pgno pgno, /* Number of the page to fetch */ + MemPage **ppPage, /* Return the page in this parameter */ + int flags /* PAGER_GET_NOCONTENT or PAGER_GET_READONLY */ +){ + int rc = btreeGetPage(pBt, pgno, ppPage, flags); + if( rc==SQLITE_OK ){ + if( sqlite3PagerPageRefcount((*ppPage)->pDbPage)>1 ){ + releasePage(*ppPage); + *ppPage = 0; + return SQLITE_CORRUPT_BKPT; + } + (*ppPage)->isInit = 0; + }else{ + *ppPage = 0; + } + return rc; +} + + +/* +** During a rollback, when the pager reloads information into the cache +** so that the cache is restored to its original state at the start of +** the transaction, for each page restored this routine is called. +** +** This routine needs to reset the extra data section at the end of the +** page to agree with the restored data. +*/ +static void pageReinit(DbPage *pData){ + MemPage *pPage; + pPage = (MemPage *)sqlite3PagerGetExtra(pData); + assert( sqlite3PagerPageRefcount(pData)>0 ); + if( pPage->isInit ){ + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + pPage->isInit = 0; + if( sqlite3PagerPageRefcount(pData)>1 ){ + /* pPage might not be a btree page; it might be an overflow page + ** or ptrmap page or a free page. In those cases, the following + ** call to btreeInitPage() will likely return SQLITE_CORRUPT. + ** But no harm is done by this. And it is very important that + ** btreeInitPage() be called on every btree page so we make + ** the call for every page that comes in for re-initing. */ + btreeInitPage(pPage); + } + } +} + +/* +** Invoke the busy handler for a btree. +*/ +static int btreeInvokeBusyHandler(void *pArg){ + BtShared *pBt = (BtShared*)pArg; + assert( pBt->db ); + assert( sqlite3_mutex_held(pBt->db->mutex) ); + return sqlite3InvokeBusyHandler(&pBt->db->busyHandler); +} + +/* +** Open a database file. +** +** zFilename is the name of the database file. If zFilename is NULL +** then an ephemeral database is created. The ephemeral database might +** be exclusively in memory, or it might use a disk-based memory cache. +** Either way, the ephemeral database will be automatically deleted +** when sqlite3BtreeClose() is called. +** +** If zFilename is ":memory:" then an in-memory database is created +** that is automatically destroyed when it is closed. +** +** The "flags" parameter is a bitmask that might contain bits like +** BTREE_OMIT_JOURNAL and/or BTREE_MEMORY. +** +** If the database is already opened in the same database connection +** and we are in shared cache mode, then the open will fail with an +** SQLITE_CONSTRAINT error. We cannot allow two or more BtShared +** objects in the same database connection since doing so will lead +** to problems with locking. +*/ +SQLITE_PRIVATE int sqlite3BtreeOpen( + sqlite3_vfs *pVfs, /* VFS to use for this b-tree */ + const char *zFilename, /* Name of the file containing the BTree database */ + sqlite3 *db, /* Associated database handle */ + Btree **ppBtree, /* Pointer to new Btree object written here */ + int flags, /* Options */ + int vfsFlags /* Flags passed through to sqlite3_vfs.xOpen() */ +){ + BtShared *pBt = 0; /* Shared part of btree structure */ + Btree *p; /* Handle to return */ + sqlite3_mutex *mutexOpen = 0; /* Prevents a race condition. Ticket #3537 */ + int rc = SQLITE_OK; /* Result code from this function */ + u8 nReserve; /* Byte of unused space on each page */ + unsigned char zDbHeader[100]; /* Database header content */ + + /* True if opening an ephemeral, temporary database */ + const int isTempDb = zFilename==0 || zFilename[0]==0; + + /* Set the variable isMemdb to true for an in-memory database, or + ** false for a file-based database. + */ +#ifdef SQLITE_OMIT_MEMORYDB + const int isMemdb = 0; +#else + const int isMemdb = (zFilename && strcmp(zFilename, ":memory:")==0) + || (isTempDb && sqlite3TempInMemory(db)) + || (vfsFlags & SQLITE_OPEN_MEMORY)!=0; +#endif + + assert( db!=0 ); + assert( pVfs!=0 ); + assert( sqlite3_mutex_held(db->mutex) ); + assert( (flags&0xff)==flags ); /* flags fit in 8 bits */ + + /* Only a BTREE_SINGLE database can be BTREE_UNORDERED */ + assert( (flags & BTREE_UNORDERED)==0 || (flags & BTREE_SINGLE)!=0 ); + + /* A BTREE_SINGLE database is always a temporary and/or ephemeral */ + assert( (flags & BTREE_SINGLE)==0 || isTempDb ); + + if( isMemdb ){ + flags |= BTREE_MEMORY; + } + if( (vfsFlags & SQLITE_OPEN_MAIN_DB)!=0 && (isMemdb || isTempDb) ){ + vfsFlags = (vfsFlags & ~SQLITE_OPEN_MAIN_DB) | SQLITE_OPEN_TEMP_DB; + } + p = sqlite3MallocZero(sizeof(Btree)); + if( !p ){ + return SQLITE_NOMEM_BKPT; + } + p->inTrans = TRANS_NONE; + p->db = db; +#ifndef SQLITE_OMIT_SHARED_CACHE + p->lock.pBtree = p; + p->lock.iTable = 1; +#endif + +#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO) + /* + ** If this Btree is a candidate for shared cache, try to find an + ** existing BtShared object that we can share with + */ + if( isTempDb==0 && (isMemdb==0 || (vfsFlags&SQLITE_OPEN_URI)!=0) ){ + if( vfsFlags & SQLITE_OPEN_SHAREDCACHE ){ + int nFilename = sqlite3Strlen30(zFilename)+1; + int nFullPathname = pVfs->mxPathname+1; + char *zFullPathname = sqlite3Malloc(MAX(nFullPathname,nFilename)); + MUTEX_LOGIC( sqlite3_mutex *mutexShared; ) + + p->sharable = 1; + if( !zFullPathname ){ + sqlite3_free(p); + return SQLITE_NOMEM_BKPT; + } + if( isMemdb ){ + memcpy(zFullPathname, zFilename, nFilename); + }else{ + rc = sqlite3OsFullPathname(pVfs, zFilename, + nFullPathname, zFullPathname); + if( rc ){ + if( rc==SQLITE_OK_SYMLINK ){ + rc = SQLITE_OK; + }else{ + sqlite3_free(zFullPathname); + sqlite3_free(p); + return rc; + } + } + } +#if SQLITE_THREADSAFE + mutexOpen = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_OPEN); + sqlite3_mutex_enter(mutexOpen); + mutexShared = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); + sqlite3_mutex_enter(mutexShared); +#endif + for(pBt=GLOBAL(BtShared*,sqlite3SharedCacheList); pBt; pBt=pBt->pNext){ + assert( pBt->nRef>0 ); + if( 0==strcmp(zFullPathname, sqlite3PagerFilename(pBt->pPager, 0)) + && sqlite3PagerVfs(pBt->pPager)==pVfs ){ + int iDb; + for(iDb=db->nDb-1; iDb>=0; iDb--){ + Btree *pExisting = db->aDb[iDb].pBt; + if( pExisting && pExisting->pBt==pBt ){ + sqlite3_mutex_leave(mutexShared); + sqlite3_mutex_leave(mutexOpen); + sqlite3_free(zFullPathname); + sqlite3_free(p); + return SQLITE_CONSTRAINT; + } + } + p->pBt = pBt; + pBt->nRef++; + break; + } + } + sqlite3_mutex_leave(mutexShared); + sqlite3_free(zFullPathname); + } +#ifdef SQLITE_DEBUG + else{ + /* In debug mode, we mark all persistent databases as sharable + ** even when they are not. This exercises the locking code and + ** gives more opportunity for asserts(sqlite3_mutex_held()) + ** statements to find locking problems. + */ + p->sharable = 1; + } +#endif + } +#endif + if( pBt==0 ){ + /* + ** The following asserts make sure that structures used by the btree are + ** the right size. This is to guard against size changes that result + ** when compiling on a different architecture. + */ + assert( sizeof(i64)==8 ); + assert( sizeof(u64)==8 ); + assert( sizeof(u32)==4 ); + assert( sizeof(u16)==2 ); + assert( sizeof(Pgno)==4 ); + + pBt = sqlite3MallocZero( sizeof(*pBt) ); + if( pBt==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto btree_open_out; + } + rc = sqlite3PagerOpen(pVfs, &pBt->pPager, zFilename, + sizeof(MemPage), flags, vfsFlags, pageReinit); + if( rc==SQLITE_OK ){ + sqlite3PagerSetMmapLimit(pBt->pPager, db->szMmap); + rc = sqlite3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader); + } + if( rc!=SQLITE_OK ){ + goto btree_open_out; + } + pBt->openFlags = (u8)flags; + pBt->db = db; + sqlite3PagerSetBusyHandler(pBt->pPager, btreeInvokeBusyHandler, pBt); + p->pBt = pBt; + + pBt->pCursor = 0; + pBt->pPage1 = 0; + if( sqlite3PagerIsreadonly(pBt->pPager) ) pBt->btsFlags |= BTS_READ_ONLY; +#if defined(SQLITE_SECURE_DELETE) + pBt->btsFlags |= BTS_SECURE_DELETE; +#elif defined(SQLITE_FAST_SECURE_DELETE) + pBt->btsFlags |= BTS_OVERWRITE; +#endif + /* EVIDENCE-OF: R-51873-39618 The page size for a database file is + ** determined by the 2-byte integer located at an offset of 16 bytes from + ** the beginning of the database file. */ + pBt->pageSize = (zDbHeader[16]<<8) | (zDbHeader[17]<<16); + if( pBt->pageSize<512 || pBt->pageSize>SQLITE_MAX_PAGE_SIZE + || ((pBt->pageSize-1)&pBt->pageSize)!=0 ){ + pBt->pageSize = 0; +#ifndef SQLITE_OMIT_AUTOVACUUM + /* If the magic name ":memory:" will create an in-memory database, then + ** leave the autoVacuum mode at 0 (do not auto-vacuum), even if + ** SQLITE_DEFAULT_AUTOVACUUM is true. On the other hand, if + ** SQLITE_OMIT_MEMORYDB has been defined, then ":memory:" is just a + ** regular file-name. In this case the auto-vacuum applies as per normal. + */ + if( zFilename && !isMemdb ){ + pBt->autoVacuum = (SQLITE_DEFAULT_AUTOVACUUM ? 1 : 0); + pBt->incrVacuum = (SQLITE_DEFAULT_AUTOVACUUM==2 ? 1 : 0); + } +#endif + nReserve = 0; + }else{ + /* EVIDENCE-OF: R-37497-42412 The size of the reserved region is + ** determined by the one-byte unsigned integer found at an offset of 20 + ** into the database file header. */ + nReserve = zDbHeader[20]; + pBt->btsFlags |= BTS_PAGESIZE_FIXED; +#ifndef SQLITE_OMIT_AUTOVACUUM + pBt->autoVacuum = (get4byte(&zDbHeader[36 + 4*4])?1:0); + pBt->incrVacuum = (get4byte(&zDbHeader[36 + 7*4])?1:0); +#endif + } + rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve); + if( rc ) goto btree_open_out; + pBt->usableSize = pBt->pageSize - nReserve; + assert( (pBt->pageSize & 7)==0 ); /* 8-byte alignment of pageSize */ + +#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO) + /* Add the new BtShared object to the linked list sharable BtShareds. + */ + pBt->nRef = 1; + if( p->sharable ){ + MUTEX_LOGIC( sqlite3_mutex *mutexShared; ) + MUTEX_LOGIC( mutexShared = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);) + if( SQLITE_THREADSAFE && sqlite3GlobalConfig.bCoreMutex ){ + pBt->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_FAST); + if( pBt->mutex==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto btree_open_out; + } + } + sqlite3_mutex_enter(mutexShared); + pBt->pNext = GLOBAL(BtShared*,sqlite3SharedCacheList); + GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt; + sqlite3_mutex_leave(mutexShared); + } +#endif + } + +#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO) + /* If the new Btree uses a sharable pBtShared, then link the new + ** Btree into the list of all sharable Btrees for the same connection. + ** The list is kept in ascending order by pBt address. + */ + if( p->sharable ){ + int i; + Btree *pSib; + for(i=0; inDb; i++){ + if( (pSib = db->aDb[i].pBt)!=0 && pSib->sharable ){ + while( pSib->pPrev ){ pSib = pSib->pPrev; } + if( (uptr)p->pBt<(uptr)pSib->pBt ){ + p->pNext = pSib; + p->pPrev = 0; + pSib->pPrev = p; + }else{ + while( pSib->pNext && (uptr)pSib->pNext->pBt<(uptr)p->pBt ){ + pSib = pSib->pNext; + } + p->pNext = pSib->pNext; + p->pPrev = pSib; + if( p->pNext ){ + p->pNext->pPrev = p; + } + pSib->pNext = p; + } + break; + } + } + } +#endif + *ppBtree = p; + +btree_open_out: + if( rc!=SQLITE_OK ){ + if( pBt && pBt->pPager ){ + sqlite3PagerClose(pBt->pPager, 0); + } + sqlite3_free(pBt); + sqlite3_free(p); + *ppBtree = 0; + }else{ + sqlite3_file *pFile; + + /* If the B-Tree was successfully opened, set the pager-cache size to the + ** default value. Except, when opening on an existing shared pager-cache, + ** do not change the pager-cache size. + */ + if( sqlite3BtreeSchema(p, 0, 0)==0 ){ + sqlite3BtreeSetCacheSize(p, SQLITE_DEFAULT_CACHE_SIZE); + } + + pFile = sqlite3PagerFile(pBt->pPager); + if( pFile->pMethods ){ + sqlite3OsFileControlHint(pFile, SQLITE_FCNTL_PDB, (void*)&pBt->db); + } + } + if( mutexOpen ){ + assert( sqlite3_mutex_held(mutexOpen) ); + sqlite3_mutex_leave(mutexOpen); + } + assert( rc!=SQLITE_OK || sqlite3BtreeConnectionCount(*ppBtree)>0 ); + return rc; +} + +/* +** Decrement the BtShared.nRef counter. When it reaches zero, +** remove the BtShared structure from the sharing list. Return +** true if the BtShared.nRef counter reaches zero and return +** false if it is still positive. +*/ +static int removeFromSharingList(BtShared *pBt){ +#ifndef SQLITE_OMIT_SHARED_CACHE + MUTEX_LOGIC( sqlite3_mutex *pMainMtx; ) + BtShared *pList; + int removed = 0; + + assert( sqlite3_mutex_notheld(pBt->mutex) ); + MUTEX_LOGIC( pMainMtx = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); ) + sqlite3_mutex_enter(pMainMtx); + pBt->nRef--; + if( pBt->nRef<=0 ){ + if( GLOBAL(BtShared*,sqlite3SharedCacheList)==pBt ){ + GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt->pNext; + }else{ + pList = GLOBAL(BtShared*,sqlite3SharedCacheList); + while( ALWAYS(pList) && pList->pNext!=pBt ){ + pList=pList->pNext; + } + if( ALWAYS(pList) ){ + pList->pNext = pBt->pNext; + } + } + if( SQLITE_THREADSAFE ){ + sqlite3_mutex_free(pBt->mutex); + } + removed = 1; + } + sqlite3_mutex_leave(pMainMtx); + return removed; +#else + return 1; +#endif +} + +/* +** Make sure pBt->pTmpSpace points to an allocation of +** MX_CELL_SIZE(pBt) bytes with a 4-byte prefix for a left-child +** pointer. +*/ +static SQLITE_NOINLINE int allocateTempSpace(BtShared *pBt){ + assert( pBt!=0 ); + assert( pBt->pTmpSpace==0 ); + /* This routine is called only by btreeCursor() when allocating the + ** first write cursor for the BtShared object */ + assert( pBt->pCursor!=0 && (pBt->pCursor->curFlags & BTCF_WriteFlag)!=0 ); + pBt->pTmpSpace = sqlite3PageMalloc( pBt->pageSize ); + if( pBt->pTmpSpace==0 ){ + BtCursor *pCur = pBt->pCursor; + pBt->pCursor = pCur->pNext; /* Unlink the cursor */ + memset(pCur, 0, sizeof(*pCur)); + return SQLITE_NOMEM_BKPT; + } + + /* One of the uses of pBt->pTmpSpace is to format cells before + ** inserting them into a leaf page (function fillInCell()). If + ** a cell is less than 4 bytes in size, it is rounded up to 4 bytes + ** by the various routines that manipulate binary cells. Which + ** can mean that fillInCell() only initializes the first 2 or 3 + ** bytes of pTmpSpace, but that the first 4 bytes are copied from + ** it into a database page. This is not actually a problem, but it + ** does cause a valgrind error when the 1 or 2 bytes of unitialized + ** data is passed to system call write(). So to avoid this error, + ** zero the first 4 bytes of temp space here. + ** + ** Also: Provide four bytes of initialized space before the + ** beginning of pTmpSpace as an area available to prepend the + ** left-child pointer to the beginning of a cell. + */ + memset(pBt->pTmpSpace, 0, 8); + pBt->pTmpSpace += 4; + return SQLITE_OK; +} + +/* +** Free the pBt->pTmpSpace allocation +*/ +static void freeTempSpace(BtShared *pBt){ + if( pBt->pTmpSpace ){ + pBt->pTmpSpace -= 4; + sqlite3PageFree(pBt->pTmpSpace); + pBt->pTmpSpace = 0; + } +} + +/* +** Close an open database and invalidate all cursors. +*/ +SQLITE_PRIVATE int sqlite3BtreeClose(Btree *p){ + BtShared *pBt = p->pBt; + + /* Close all cursors opened via this handle. */ + assert( sqlite3_mutex_held(p->db->mutex) ); + sqlite3BtreeEnter(p); + + /* Verify that no other cursors have this Btree open */ +#ifdef SQLITE_DEBUG + { + BtCursor *pCur = pBt->pCursor; + while( pCur ){ + BtCursor *pTmp = pCur; + pCur = pCur->pNext; + assert( pTmp->pBtree!=p ); + + } + } +#endif + + /* Rollback any active transaction and free the handle structure. + ** The call to sqlite3BtreeRollback() drops any table-locks held by + ** this handle. + */ + sqlite3BtreeRollback(p, SQLITE_OK, 0); + sqlite3BtreeLeave(p); + + /* If there are still other outstanding references to the shared-btree + ** structure, return now. The remainder of this procedure cleans + ** up the shared-btree. + */ + assert( p->wantToLock==0 && p->locked==0 ); + if( !p->sharable || removeFromSharingList(pBt) ){ + /* The pBt is no longer on the sharing list, so we can access + ** it without having to hold the mutex. + ** + ** Clean out and delete the BtShared object. + */ + assert( !pBt->pCursor ); + sqlite3PagerClose(pBt->pPager, p->db); + if( pBt->xFreeSchema && pBt->pSchema ){ + pBt->xFreeSchema(pBt->pSchema); + } + sqlite3DbFree(0, pBt->pSchema); + freeTempSpace(pBt); + sqlite3_free(pBt); + } + +#ifndef SQLITE_OMIT_SHARED_CACHE + assert( p->wantToLock==0 ); + assert( p->locked==0 ); + if( p->pPrev ) p->pPrev->pNext = p->pNext; + if( p->pNext ) p->pNext->pPrev = p->pPrev; +#endif + + sqlite3_free(p); + return SQLITE_OK; +} + +/* +** Change the "soft" limit on the number of pages in the cache. +** Unused and unmodified pages will be recycled when the number of +** pages in the cache exceeds this soft limit. But the size of the +** cache is allowed to grow larger than this limit if it contains +** dirty pages or pages still in active use. +*/ +SQLITE_PRIVATE int sqlite3BtreeSetCacheSize(Btree *p, int mxPage){ + BtShared *pBt = p->pBt; + assert( sqlite3_mutex_held(p->db->mutex) ); + sqlite3BtreeEnter(p); + sqlite3PagerSetCachesize(pBt->pPager, mxPage); + sqlite3BtreeLeave(p); + return SQLITE_OK; +} + +/* +** Change the "spill" limit on the number of pages in the cache. +** If the number of pages exceeds this limit during a write transaction, +** the pager might attempt to "spill" pages to the journal early in +** order to free up memory. +** +** The value returned is the current spill size. If zero is passed +** as an argument, no changes are made to the spill size setting, so +** using mxPage of 0 is a way to query the current spill size. +*/ +SQLITE_PRIVATE int sqlite3BtreeSetSpillSize(Btree *p, int mxPage){ + BtShared *pBt = p->pBt; + int res; + assert( sqlite3_mutex_held(p->db->mutex) ); + sqlite3BtreeEnter(p); + res = sqlite3PagerSetSpillsize(pBt->pPager, mxPage); + sqlite3BtreeLeave(p); + return res; +} + +#if SQLITE_MAX_MMAP_SIZE>0 +/* +** Change the limit on the amount of the database file that may be +** memory mapped. +*/ +SQLITE_PRIVATE int sqlite3BtreeSetMmapLimit(Btree *p, sqlite3_int64 szMmap){ + BtShared *pBt = p->pBt; + assert( sqlite3_mutex_held(p->db->mutex) ); + sqlite3BtreeEnter(p); + sqlite3PagerSetMmapLimit(pBt->pPager, szMmap); + sqlite3BtreeLeave(p); + return SQLITE_OK; +} +#endif /* SQLITE_MAX_MMAP_SIZE>0 */ + +/* +** Change the way data is synced to disk in order to increase or decrease +** how well the database resists damage due to OS crashes and power +** failures. Level 1 is the same as asynchronous (no syncs() occur and +** there is a high probability of damage) Level 2 is the default. There +** is a very low but non-zero probability of damage. Level 3 reduces the +** probability of damage to near zero but with a write performance reduction. +*/ +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +SQLITE_PRIVATE int sqlite3BtreeSetPagerFlags( + Btree *p, /* The btree to set the safety level on */ + unsigned pgFlags /* Various PAGER_* flags */ +){ + BtShared *pBt = p->pBt; + assert( sqlite3_mutex_held(p->db->mutex) ); + sqlite3BtreeEnter(p); + sqlite3PagerSetFlags(pBt->pPager, pgFlags); + sqlite3BtreeLeave(p); + return SQLITE_OK; +} +#endif + +/* +** Change the default pages size and the number of reserved bytes per page. +** Or, if the page size has already been fixed, return SQLITE_READONLY +** without changing anything. +** +** The page size must be a power of 2 between 512 and 65536. If the page +** size supplied does not meet this constraint then the page size is not +** changed. +** +** Page sizes are constrained to be a power of two so that the region +** of the database file used for locking (beginning at PENDING_BYTE, +** the first byte past the 1GB boundary, 0x40000000) needs to occur +** at the beginning of a page. +** +** If parameter nReserve is less than zero, then the number of reserved +** bytes per page is left unchanged. +** +** If the iFix!=0 then the BTS_PAGESIZE_FIXED flag is set so that the page size +** and autovacuum mode can no longer be changed. +*/ +SQLITE_PRIVATE int sqlite3BtreeSetPageSize(Btree *p, int pageSize, int nReserve, int iFix){ + int rc = SQLITE_OK; + int x; + BtShared *pBt = p->pBt; + assert( nReserve>=0 && nReserve<=255 ); + sqlite3BtreeEnter(p); + pBt->nReserveWanted = nReserve; + x = pBt->pageSize - pBt->usableSize; + if( nReservebtsFlags & BTS_PAGESIZE_FIXED ){ + sqlite3BtreeLeave(p); + return SQLITE_READONLY; + } + assert( nReserve>=0 && nReserve<=255 ); + if( pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE && + ((pageSize-1)&pageSize)==0 ){ + assert( (pageSize & 7)==0 ); + assert( !pBt->pCursor ); + if( nReserve>32 && pageSize==512 ) pageSize = 1024; + pBt->pageSize = (u32)pageSize; + freeTempSpace(pBt); + } + rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve); + pBt->usableSize = pBt->pageSize - (u16)nReserve; + if( iFix ) pBt->btsFlags |= BTS_PAGESIZE_FIXED; + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Return the currently defined page size +*/ +SQLITE_PRIVATE int sqlite3BtreeGetPageSize(Btree *p){ + return p->pBt->pageSize; +} + +/* +** This function is similar to sqlite3BtreeGetReserve(), except that it +** may only be called if it is guaranteed that the b-tree mutex is already +** held. +** +** This is useful in one special case in the backup API code where it is +** known that the shared b-tree mutex is held, but the mutex on the +** database handle that owns *p is not. In this case if sqlite3BtreeEnter() +** were to be called, it might collide with some other operation on the +** database handle that owns *p, causing undefined behavior. +*/ +SQLITE_PRIVATE int sqlite3BtreeGetReserveNoMutex(Btree *p){ + int n; + assert( sqlite3_mutex_held(p->pBt->mutex) ); + n = p->pBt->pageSize - p->pBt->usableSize; + return n; +} + +/* +** Return the number of bytes of space at the end of every page that +** are intentually left unused. This is the "reserved" space that is +** sometimes used by extensions. +** +** The value returned is the larger of the current reserve size and +** the latest reserve size requested by SQLITE_FILECTRL_RESERVE_BYTES. +** The amount of reserve can only grow - never shrink. +*/ +SQLITE_PRIVATE int sqlite3BtreeGetRequestedReserve(Btree *p){ + int n1, n2; + sqlite3BtreeEnter(p); + n1 = (int)p->pBt->nReserveWanted; + n2 = sqlite3BtreeGetReserveNoMutex(p); + sqlite3BtreeLeave(p); + return n1>n2 ? n1 : n2; +} + + +/* +** Set the maximum page count for a database if mxPage is positive. +** No changes are made if mxPage is 0 or negative. +** Regardless of the value of mxPage, return the maximum page count. +*/ +SQLITE_PRIVATE Pgno sqlite3BtreeMaxPageCount(Btree *p, Pgno mxPage){ + Pgno n; + sqlite3BtreeEnter(p); + n = sqlite3PagerMaxPageCount(p->pBt->pPager, mxPage); + sqlite3BtreeLeave(p); + return n; +} + +/* +** Change the values for the BTS_SECURE_DELETE and BTS_OVERWRITE flags: +** +** newFlag==0 Both BTS_SECURE_DELETE and BTS_OVERWRITE are cleared +** newFlag==1 BTS_SECURE_DELETE set and BTS_OVERWRITE is cleared +** newFlag==2 BTS_SECURE_DELETE cleared and BTS_OVERWRITE is set +** newFlag==(-1) No changes +** +** This routine acts as a query if newFlag is less than zero +** +** With BTS_OVERWRITE set, deleted content is overwritten by zeros, but +** freelist leaf pages are not written back to the database. Thus in-page +** deleted content is cleared, but freelist deleted content is not. +** +** With BTS_SECURE_DELETE, operation is like BTS_OVERWRITE with the addition +** that freelist leaf pages are written back into the database, increasing +** the amount of disk I/O. +*/ +SQLITE_PRIVATE int sqlite3BtreeSecureDelete(Btree *p, int newFlag){ + int b; + if( p==0 ) return 0; + sqlite3BtreeEnter(p); + assert( BTS_OVERWRITE==BTS_SECURE_DELETE*2 ); + assert( BTS_FAST_SECURE==(BTS_OVERWRITE|BTS_SECURE_DELETE) ); + if( newFlag>=0 ){ + p->pBt->btsFlags &= ~BTS_FAST_SECURE; + p->pBt->btsFlags |= BTS_SECURE_DELETE*newFlag; + } + b = (p->pBt->btsFlags & BTS_FAST_SECURE)/BTS_SECURE_DELETE; + sqlite3BtreeLeave(p); + return b; +} + +/* +** Change the 'auto-vacuum' property of the database. If the 'autoVacuum' +** parameter is non-zero, then auto-vacuum mode is enabled. If zero, it +** is disabled. The default value for the auto-vacuum property is +** determined by the SQLITE_DEFAULT_AUTOVACUUM macro. +*/ +SQLITE_PRIVATE int sqlite3BtreeSetAutoVacuum(Btree *p, int autoVacuum){ +#ifdef SQLITE_OMIT_AUTOVACUUM + return SQLITE_READONLY; +#else + BtShared *pBt = p->pBt; + int rc = SQLITE_OK; + u8 av = (u8)autoVacuum; + + sqlite3BtreeEnter(p); + if( (pBt->btsFlags & BTS_PAGESIZE_FIXED)!=0 && (av ?1:0)!=pBt->autoVacuum ){ + rc = SQLITE_READONLY; + }else{ + pBt->autoVacuum = av ?1:0; + pBt->incrVacuum = av==2 ?1:0; + } + sqlite3BtreeLeave(p); + return rc; +#endif +} + +/* +** Return the value of the 'auto-vacuum' property. If auto-vacuum is +** enabled 1 is returned. Otherwise 0. +*/ +SQLITE_PRIVATE int sqlite3BtreeGetAutoVacuum(Btree *p){ +#ifdef SQLITE_OMIT_AUTOVACUUM + return BTREE_AUTOVACUUM_NONE; +#else + int rc; + sqlite3BtreeEnter(p); + rc = ( + (!p->pBt->autoVacuum)?BTREE_AUTOVACUUM_NONE: + (!p->pBt->incrVacuum)?BTREE_AUTOVACUUM_FULL: + BTREE_AUTOVACUUM_INCR + ); + sqlite3BtreeLeave(p); + return rc; +#endif +} + +/* +** If the user has not set the safety-level for this database connection +** using "PRAGMA synchronous", and if the safety-level is not already +** set to the value passed to this function as the second parameter, +** set it so. +*/ +#if SQLITE_DEFAULT_SYNCHRONOUS!=SQLITE_DEFAULT_WAL_SYNCHRONOUS \ + && !defined(SQLITE_OMIT_WAL) +static void setDefaultSyncFlag(BtShared *pBt, u8 safety_level){ + sqlite3 *db; + Db *pDb; + if( (db=pBt->db)!=0 && (pDb=db->aDb)!=0 ){ + while( pDb->pBt==0 || pDb->pBt->pBt!=pBt ){ pDb++; } + if( pDb->bSyncSet==0 + && pDb->safety_level!=safety_level + && pDb!=&db->aDb[1] + ){ + pDb->safety_level = safety_level; + sqlite3PagerSetFlags(pBt->pPager, + pDb->safety_level | (db->flags & PAGER_FLAGS_MASK)); + } + } +} +#else +# define setDefaultSyncFlag(pBt,safety_level) +#endif + +/* Forward declaration */ +static int newDatabase(BtShared*); + + +/* +** Get a reference to pPage1 of the database file. This will +** also acquire a readlock on that file. +** +** SQLITE_OK is returned on success. If the file is not a +** well-formed database file, then SQLITE_CORRUPT is returned. +** SQLITE_BUSY is returned if the database is locked. SQLITE_NOMEM +** is returned if we run out of memory. +*/ +static int lockBtree(BtShared *pBt){ + int rc; /* Result code from subfunctions */ + MemPage *pPage1; /* Page 1 of the database file */ + u32 nPage; /* Number of pages in the database */ + u32 nPageFile = 0; /* Number of pages in the database file */ + + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( pBt->pPage1==0 ); + rc = sqlite3PagerSharedLock(pBt->pPager); + if( rc!=SQLITE_OK ) return rc; + rc = btreeGetPage(pBt, 1, &pPage1, 0); + if( rc!=SQLITE_OK ) return rc; + + /* Do some checking to help insure the file we opened really is + ** a valid database file. + */ + nPage = get4byte(28+(u8*)pPage1->aData); + sqlite3PagerPagecount(pBt->pPager, (int*)&nPageFile); + if( nPage==0 || memcmp(24+(u8*)pPage1->aData, 92+(u8*)pPage1->aData,4)!=0 ){ + nPage = nPageFile; + } + if( (pBt->db->flags & SQLITE_ResetDatabase)!=0 ){ + nPage = 0; + } + if( nPage>0 ){ + u32 pageSize; + u32 usableSize; + u8 *page1 = pPage1->aData; + rc = SQLITE_NOTADB; + /* EVIDENCE-OF: R-43737-39999 Every valid SQLite database file begins + ** with the following 16 bytes (in hex): 53 51 4c 69 74 65 20 66 6f 72 6d + ** 61 74 20 33 00. */ + if( memcmp(page1, zMagicHeader, 16)!=0 ){ + goto page1_init_failed; + } + +#ifdef SQLITE_OMIT_WAL + if( page1[18]>1 ){ + pBt->btsFlags |= BTS_READ_ONLY; + } + if( page1[19]>1 ){ + goto page1_init_failed; + } +#else + if( page1[18]>2 ){ + pBt->btsFlags |= BTS_READ_ONLY; + } + if( page1[19]>2 ){ + goto page1_init_failed; + } + + /* If the read version is set to 2, this database should be accessed + ** in WAL mode. If the log is not already open, open it now. Then + ** return SQLITE_OK and return without populating BtShared.pPage1. + ** The caller detects this and calls this function again. This is + ** required as the version of page 1 currently in the page1 buffer + ** may not be the latest version - there may be a newer one in the log + ** file. + */ + if( page1[19]==2 && (pBt->btsFlags & BTS_NO_WAL)==0 ){ + int isOpen = 0; + rc = sqlite3PagerOpenWal(pBt->pPager, &isOpen); + if( rc!=SQLITE_OK ){ + goto page1_init_failed; + }else{ + setDefaultSyncFlag(pBt, SQLITE_DEFAULT_WAL_SYNCHRONOUS+1); + if( isOpen==0 ){ + releasePageOne(pPage1); + return SQLITE_OK; + } + } + rc = SQLITE_NOTADB; + }else{ + setDefaultSyncFlag(pBt, SQLITE_DEFAULT_SYNCHRONOUS+1); + } +#endif + + /* EVIDENCE-OF: R-15465-20813 The maximum and minimum embedded payload + ** fractions and the leaf payload fraction values must be 64, 32, and 32. + ** + ** The original design allowed these amounts to vary, but as of + ** version 3.6.0, we require them to be fixed. + */ + if( memcmp(&page1[21], "\100\040\040",3)!=0 ){ + goto page1_init_failed; + } + /* EVIDENCE-OF: R-51873-39618 The page size for a database file is + ** determined by the 2-byte integer located at an offset of 16 bytes from + ** the beginning of the database file. */ + pageSize = (page1[16]<<8) | (page1[17]<<16); + /* EVIDENCE-OF: R-25008-21688 The size of a page is a power of two + ** between 512 and 65536 inclusive. */ + if( ((pageSize-1)&pageSize)!=0 + || pageSize>SQLITE_MAX_PAGE_SIZE + || pageSize<=256 + ){ + goto page1_init_failed; + } + pBt->btsFlags |= BTS_PAGESIZE_FIXED; + assert( (pageSize & 7)==0 ); + /* EVIDENCE-OF: R-59310-51205 The "reserved space" size in the 1-byte + ** integer at offset 20 is the number of bytes of space at the end of + ** each page to reserve for extensions. + ** + ** EVIDENCE-OF: R-37497-42412 The size of the reserved region is + ** determined by the one-byte unsigned integer found at an offset of 20 + ** into the database file header. */ + usableSize = pageSize - page1[20]; + if( (u32)pageSize!=pBt->pageSize ){ + /* After reading the first page of the database assuming a page size + ** of BtShared.pageSize, we have discovered that the page-size is + ** actually pageSize. Unlock the database, leave pBt->pPage1 at + ** zero and return SQLITE_OK. The caller will call this function + ** again with the correct page-size. + */ + releasePageOne(pPage1); + pBt->usableSize = usableSize; + pBt->pageSize = pageSize; + freeTempSpace(pBt); + rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, + pageSize-usableSize); + return rc; + } + if( nPage>nPageFile ){ + if( sqlite3WritableSchema(pBt->db)==0 ){ + rc = SQLITE_CORRUPT_BKPT; + goto page1_init_failed; + }else{ + nPage = nPageFile; + } + } + /* EVIDENCE-OF: R-28312-64704 However, the usable size is not allowed to + ** be less than 480. In other words, if the page size is 512, then the + ** reserved space size cannot exceed 32. */ + if( usableSize<480 ){ + goto page1_init_failed; + } + pBt->pageSize = pageSize; + pBt->usableSize = usableSize; +#ifndef SQLITE_OMIT_AUTOVACUUM + pBt->autoVacuum = (get4byte(&page1[36 + 4*4])?1:0); + pBt->incrVacuum = (get4byte(&page1[36 + 7*4])?1:0); +#endif + } + + /* maxLocal is the maximum amount of payload to store locally for + ** a cell. Make sure it is small enough so that at least minFanout + ** cells can will fit on one page. We assume a 10-byte page header. + ** Besides the payload, the cell must store: + ** 2-byte pointer to the cell + ** 4-byte child pointer + ** 9-byte nKey value + ** 4-byte nData value + ** 4-byte overflow page pointer + ** So a cell consists of a 2-byte pointer, a header which is as much as + ** 17 bytes long, 0 to N bytes of payload, and an optional 4 byte overflow + ** page pointer. + */ + pBt->maxLocal = (u16)((pBt->usableSize-12)*64/255 - 23); + pBt->minLocal = (u16)((pBt->usableSize-12)*32/255 - 23); + pBt->maxLeaf = (u16)(pBt->usableSize - 35); + pBt->minLeaf = (u16)((pBt->usableSize-12)*32/255 - 23); + if( pBt->maxLocal>127 ){ + pBt->max1bytePayload = 127; + }else{ + pBt->max1bytePayload = (u8)pBt->maxLocal; + } + assert( pBt->maxLeaf + 23 <= MX_CELL_SIZE(pBt) ); + pBt->pPage1 = pPage1; + pBt->nPage = nPage; + return SQLITE_OK; + +page1_init_failed: + releasePageOne(pPage1); + pBt->pPage1 = 0; + return rc; +} + +#ifndef NDEBUG +/* +** Return the number of cursors open on pBt. This is for use +** in assert() expressions, so it is only compiled if NDEBUG is not +** defined. +** +** Only write cursors are counted if wrOnly is true. If wrOnly is +** false then all cursors are counted. +** +** For the purposes of this routine, a cursor is any cursor that +** is capable of reading or writing to the database. Cursors that +** have been tripped into the CURSOR_FAULT state are not counted. +*/ +static int countValidCursors(BtShared *pBt, int wrOnly){ + BtCursor *pCur; + int r = 0; + for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){ + if( (wrOnly==0 || (pCur->curFlags & BTCF_WriteFlag)!=0) + && pCur->eState!=CURSOR_FAULT ) r++; + } + return r; +} +#endif + +/* +** If there are no outstanding cursors and we are not in the middle +** of a transaction but there is a read lock on the database, then +** this routine unrefs the first page of the database file which +** has the effect of releasing the read lock. +** +** If there is a transaction in progress, this routine is a no-op. +*/ +static void unlockBtreeIfUnused(BtShared *pBt){ + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( countValidCursors(pBt,0)==0 || pBt->inTransaction>TRANS_NONE ); + if( pBt->inTransaction==TRANS_NONE && pBt->pPage1!=0 ){ + MemPage *pPage1 = pBt->pPage1; + assert( pPage1->aData ); + assert( sqlite3PagerRefcount(pBt->pPager)==1 ); + pBt->pPage1 = 0; + releasePageOne(pPage1); + } +} + +/* +** If pBt points to an empty file then convert that empty file +** into a new empty database by initializing the first page of +** the database. +*/ +static int newDatabase(BtShared *pBt){ + MemPage *pP1; + unsigned char *data; + int rc; + + assert( sqlite3_mutex_held(pBt->mutex) ); + if( pBt->nPage>0 ){ + return SQLITE_OK; + } + pP1 = pBt->pPage1; + assert( pP1!=0 ); + data = pP1->aData; + rc = sqlite3PagerWrite(pP1->pDbPage); + if( rc ) return rc; + memcpy(data, zMagicHeader, sizeof(zMagicHeader)); + assert( sizeof(zMagicHeader)==16 ); + data[16] = (u8)((pBt->pageSize>>8)&0xff); + data[17] = (u8)((pBt->pageSize>>16)&0xff); + data[18] = 1; + data[19] = 1; + assert( pBt->usableSize<=pBt->pageSize && pBt->usableSize+255>=pBt->pageSize); + data[20] = (u8)(pBt->pageSize - pBt->usableSize); + data[21] = 64; + data[22] = 32; + data[23] = 32; + memset(&data[24], 0, 100-24); + zeroPage(pP1, PTF_INTKEY|PTF_LEAF|PTF_LEAFDATA ); + pBt->btsFlags |= BTS_PAGESIZE_FIXED; +#ifndef SQLITE_OMIT_AUTOVACUUM + assert( pBt->autoVacuum==1 || pBt->autoVacuum==0 ); + assert( pBt->incrVacuum==1 || pBt->incrVacuum==0 ); + put4byte(&data[36 + 4*4], pBt->autoVacuum); + put4byte(&data[36 + 7*4], pBt->incrVacuum); +#endif + pBt->nPage = 1; + data[31] = 1; + return SQLITE_OK; +} + +/* +** Initialize the first page of the database file (creating a database +** consisting of a single page and no schema objects). Return SQLITE_OK +** if successful, or an SQLite error code otherwise. +*/ +SQLITE_PRIVATE int sqlite3BtreeNewDb(Btree *p){ + int rc; + sqlite3BtreeEnter(p); + p->pBt->nPage = 0; + rc = newDatabase(p->pBt); + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Attempt to start a new transaction. A write-transaction +** is started if the second argument is nonzero, otherwise a read- +** transaction. If the second argument is 2 or more and exclusive +** transaction is started, meaning that no other process is allowed +** to access the database. A preexisting transaction may not be +** upgraded to exclusive by calling this routine a second time - the +** exclusivity flag only works for a new transaction. +** +** A write-transaction must be started before attempting any +** changes to the database. None of the following routines +** will work unless a transaction is started first: +** +** sqlite3BtreeCreateTable() +** sqlite3BtreeCreateIndex() +** sqlite3BtreeClearTable() +** sqlite3BtreeDropTable() +** sqlite3BtreeInsert() +** sqlite3BtreeDelete() +** sqlite3BtreeUpdateMeta() +** +** If an initial attempt to acquire the lock fails because of lock contention +** and the database was previously unlocked, then invoke the busy handler +** if there is one. But if there was previously a read-lock, do not +** invoke the busy handler - just return SQLITE_BUSY. SQLITE_BUSY is +** returned when there is already a read-lock in order to avoid a deadlock. +** +** Suppose there are two processes A and B. A has a read lock and B has +** a reserved lock. B tries to promote to exclusive but is blocked because +** of A's read lock. A tries to promote to reserved but is blocked by B. +** One or the other of the two processes must give way or there can be +** no progress. By returning SQLITE_BUSY and not invoking the busy callback +** when A already has a read lock, we encourage A to give up and let B +** proceed. +*/ +SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree *p, int wrflag, int *pSchemaVersion){ + BtShared *pBt = p->pBt; + Pager *pPager = pBt->pPager; + int rc = SQLITE_OK; + + sqlite3BtreeEnter(p); + btreeIntegrity(p); + + /* If the btree is already in a write-transaction, or it + ** is already in a read-transaction and a read-transaction + ** is requested, this is a no-op. + */ + if( p->inTrans==TRANS_WRITE || (p->inTrans==TRANS_READ && !wrflag) ){ + goto trans_begun; + } + assert( pBt->inTransaction==TRANS_WRITE || IfNotOmitAV(pBt->bDoTruncate)==0 ); + + if( (p->db->flags & SQLITE_ResetDatabase) + && sqlite3PagerIsreadonly(pPager)==0 + ){ + pBt->btsFlags &= ~BTS_READ_ONLY; + } + + /* Write transactions are not possible on a read-only database */ + if( (pBt->btsFlags & BTS_READ_ONLY)!=0 && wrflag ){ + rc = SQLITE_READONLY; + goto trans_begun; + } + +#ifndef SQLITE_OMIT_SHARED_CACHE + { + sqlite3 *pBlock = 0; + /* If another database handle has already opened a write transaction + ** on this shared-btree structure and a second write transaction is + ** requested, return SQLITE_LOCKED. + */ + if( (wrflag && pBt->inTransaction==TRANS_WRITE) + || (pBt->btsFlags & BTS_PENDING)!=0 + ){ + pBlock = pBt->pWriter->db; + }else if( wrflag>1 ){ + BtLock *pIter; + for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){ + if( pIter->pBtree!=p ){ + pBlock = pIter->pBtree->db; + break; + } + } + } + if( pBlock ){ + sqlite3ConnectionBlocked(p->db, pBlock); + rc = SQLITE_LOCKED_SHAREDCACHE; + goto trans_begun; + } + } +#endif + + /* Any read-only or read-write transaction implies a read-lock on + ** page 1. So if some other shared-cache client already has a write-lock + ** on page 1, the transaction cannot be opened. */ + rc = querySharedCacheTableLock(p, SCHEMA_ROOT, READ_LOCK); + if( SQLITE_OK!=rc ) goto trans_begun; + + pBt->btsFlags &= ~BTS_INITIALLY_EMPTY; + if( pBt->nPage==0 ) pBt->btsFlags |= BTS_INITIALLY_EMPTY; + do { + sqlite3PagerWalDb(pPager, p->db); + +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT + /* If transitioning from no transaction directly to a write transaction, + ** block for the WRITER lock first if possible. */ + if( pBt->pPage1==0 && wrflag ){ + assert( pBt->inTransaction==TRANS_NONE ); + rc = sqlite3PagerWalWriteLock(pPager, 1); + if( rc!=SQLITE_BUSY && rc!=SQLITE_OK ) break; + } +#endif + + /* Call lockBtree() until either pBt->pPage1 is populated or + ** lockBtree() returns something other than SQLITE_OK. lockBtree() + ** may return SQLITE_OK but leave pBt->pPage1 set to 0 if after + ** reading page 1 it discovers that the page-size of the database + ** file is not pBt->pageSize. In this case lockBtree() will update + ** pBt->pageSize to the page-size of the file on disk. + */ + while( pBt->pPage1==0 && SQLITE_OK==(rc = lockBtree(pBt)) ); + + if( rc==SQLITE_OK && wrflag ){ + if( (pBt->btsFlags & BTS_READ_ONLY)!=0 ){ + rc = SQLITE_READONLY; + }else{ + rc = sqlite3PagerBegin(pPager, wrflag>1, sqlite3TempInMemory(p->db)); + if( rc==SQLITE_OK ){ + rc = newDatabase(pBt); + }else if( rc==SQLITE_BUSY_SNAPSHOT && pBt->inTransaction==TRANS_NONE ){ + /* if there was no transaction opened when this function was + ** called and SQLITE_BUSY_SNAPSHOT is returned, change the error + ** code to SQLITE_BUSY. */ + rc = SQLITE_BUSY; + } + } + } + + if( rc!=SQLITE_OK ){ + (void)sqlite3PagerWalWriteLock(pPager, 0); + unlockBtreeIfUnused(pBt); + } + }while( (rc&0xFF)==SQLITE_BUSY && pBt->inTransaction==TRANS_NONE && + btreeInvokeBusyHandler(pBt) ); + sqlite3PagerWalDb(pPager, 0); +#ifdef SQLITE_ENABLE_SETLK_TIMEOUT + if( rc==SQLITE_BUSY_TIMEOUT ) rc = SQLITE_BUSY; +#endif + + if( rc==SQLITE_OK ){ + if( p->inTrans==TRANS_NONE ){ + pBt->nTransaction++; +#ifndef SQLITE_OMIT_SHARED_CACHE + if( p->sharable ){ + assert( p->lock.pBtree==p && p->lock.iTable==1 ); + p->lock.eLock = READ_LOCK; + p->lock.pNext = pBt->pLock; + pBt->pLock = &p->lock; + } +#endif + } + p->inTrans = (wrflag?TRANS_WRITE:TRANS_READ); + if( p->inTrans>pBt->inTransaction ){ + pBt->inTransaction = p->inTrans; + } + if( wrflag ){ + MemPage *pPage1 = pBt->pPage1; +#ifndef SQLITE_OMIT_SHARED_CACHE + assert( !pBt->pWriter ); + pBt->pWriter = p; + pBt->btsFlags &= ~BTS_EXCLUSIVE; + if( wrflag>1 ) pBt->btsFlags |= BTS_EXCLUSIVE; +#endif + + /* If the db-size header field is incorrect (as it may be if an old + ** client has been writing the database file), update it now. Doing + ** this sooner rather than later means the database size can safely + ** re-read the database size from page 1 if a savepoint or transaction + ** rollback occurs within the transaction. + */ + if( pBt->nPage!=get4byte(&pPage1->aData[28]) ){ + rc = sqlite3PagerWrite(pPage1->pDbPage); + if( rc==SQLITE_OK ){ + put4byte(&pPage1->aData[28], pBt->nPage); + } + } + } + } + +trans_begun: + if( rc==SQLITE_OK ){ + if( pSchemaVersion ){ + *pSchemaVersion = get4byte(&pBt->pPage1->aData[40]); + } + if( wrflag ){ + /* This call makes sure that the pager has the correct number of + ** open savepoints. If the second parameter is greater than 0 and + ** the sub-journal is not already open, then it will be opened here. + */ + rc = sqlite3PagerOpenSavepoint(pPager, p->db->nSavepoint); + } + } + + btreeIntegrity(p); + sqlite3BtreeLeave(p); + return rc; +} + +#ifndef SQLITE_OMIT_AUTOVACUUM + +/* +** Set the pointer-map entries for all children of page pPage. Also, if +** pPage contains cells that point to overflow pages, set the pointer +** map entries for the overflow pages as well. +*/ +static int setChildPtrmaps(MemPage *pPage){ + int i; /* Counter variable */ + int nCell; /* Number of cells in page pPage */ + int rc; /* Return code */ + BtShared *pBt = pPage->pBt; + Pgno pgno = pPage->pgno; + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + rc = pPage->isInit ? SQLITE_OK : btreeInitPage(pPage); + if( rc!=SQLITE_OK ) return rc; + nCell = pPage->nCell; + + for(i=0; ileaf ){ + Pgno childPgno = get4byte(pCell); + ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc); + } + } + + if( !pPage->leaf ){ + Pgno childPgno = get4byte(&pPage->aData[pPage->hdrOffset+8]); + ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc); + } + + return rc; +} + +/* +** Somewhere on pPage is a pointer to page iFrom. Modify this pointer so +** that it points to iTo. Parameter eType describes the type of pointer to +** be modified, as follows: +** +** PTRMAP_BTREE: pPage is a btree-page. The pointer points at a child +** page of pPage. +** +** PTRMAP_OVERFLOW1: pPage is a btree-page. The pointer points at an overflow +** page pointed to by one of the cells on pPage. +** +** PTRMAP_OVERFLOW2: pPage is an overflow-page. The pointer points at the next +** overflow page in the list. +*/ +static int modifyPagePointer(MemPage *pPage, Pgno iFrom, Pgno iTo, u8 eType){ + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + if( eType==PTRMAP_OVERFLOW2 ){ + /* The pointer is always the first 4 bytes of the page in this case. */ + if( get4byte(pPage->aData)!=iFrom ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + put4byte(pPage->aData, iTo); + }else{ + int i; + int nCell; + int rc; + + rc = pPage->isInit ? SQLITE_OK : btreeInitPage(pPage); + if( rc ) return rc; + nCell = pPage->nCell; + + for(i=0; ixParseCell(pPage, pCell, &info); + if( info.nLocal pPage->aData+pPage->pBt->usableSize ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + if( iFrom==get4byte(pCell+info.nSize-4) ){ + put4byte(pCell+info.nSize-4, iTo); + break; + } + } + }else{ + if( pCell+4 > pPage->aData+pPage->pBt->usableSize ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + if( get4byte(pCell)==iFrom ){ + put4byte(pCell, iTo); + break; + } + } + } + + if( i==nCell ){ + if( eType!=PTRMAP_BTREE || + get4byte(&pPage->aData[pPage->hdrOffset+8])!=iFrom ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + put4byte(&pPage->aData[pPage->hdrOffset+8], iTo); + } + } + return SQLITE_OK; +} + + +/* +** Move the open database page pDbPage to location iFreePage in the +** database. The pDbPage reference remains valid. +** +** The isCommit flag indicates that there is no need to remember that +** the journal needs to be sync()ed before database page pDbPage->pgno +** can be written to. The caller has already promised not to write to that +** page. +*/ +static int relocatePage( + BtShared *pBt, /* Btree */ + MemPage *pDbPage, /* Open page to move */ + u8 eType, /* Pointer map 'type' entry for pDbPage */ + Pgno iPtrPage, /* Pointer map 'page-no' entry for pDbPage */ + Pgno iFreePage, /* The location to move pDbPage to */ + int isCommit /* isCommit flag passed to sqlite3PagerMovepage */ +){ + MemPage *pPtrPage; /* The page that contains a pointer to pDbPage */ + Pgno iDbPage = pDbPage->pgno; + Pager *pPager = pBt->pPager; + int rc; + + assert( eType==PTRMAP_OVERFLOW2 || eType==PTRMAP_OVERFLOW1 || + eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE ); + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( pDbPage->pBt==pBt ); + if( iDbPage<3 ) return SQLITE_CORRUPT_BKPT; + + /* Move page iDbPage from its current location to page number iFreePage */ + TRACE(("AUTOVACUUM: Moving %u to free page %u (ptr page %u type %u)\n", + iDbPage, iFreePage, iPtrPage, eType)); + rc = sqlite3PagerMovepage(pPager, pDbPage->pDbPage, iFreePage, isCommit); + if( rc!=SQLITE_OK ){ + return rc; + } + pDbPage->pgno = iFreePage; + + /* If pDbPage was a btree-page, then it may have child pages and/or cells + ** that point to overflow pages. The pointer map entries for all these + ** pages need to be changed. + ** + ** If pDbPage is an overflow page, then the first 4 bytes may store a + ** pointer to a subsequent overflow page. If this is the case, then + ** the pointer map needs to be updated for the subsequent overflow page. + */ + if( eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE ){ + rc = setChildPtrmaps(pDbPage); + if( rc!=SQLITE_OK ){ + return rc; + } + }else{ + Pgno nextOvfl = get4byte(pDbPage->aData); + if( nextOvfl!=0 ){ + ptrmapPut(pBt, nextOvfl, PTRMAP_OVERFLOW2, iFreePage, &rc); + if( rc!=SQLITE_OK ){ + return rc; + } + } + } + + /* Fix the database pointer on page iPtrPage that pointed at iDbPage so + ** that it points at iFreePage. Also fix the pointer map entry for + ** iPtrPage. + */ + if( eType!=PTRMAP_ROOTPAGE ){ + rc = btreeGetPage(pBt, iPtrPage, &pPtrPage, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = sqlite3PagerWrite(pPtrPage->pDbPage); + if( rc!=SQLITE_OK ){ + releasePage(pPtrPage); + return rc; + } + rc = modifyPagePointer(pPtrPage, iDbPage, iFreePage, eType); + releasePage(pPtrPage); + if( rc==SQLITE_OK ){ + ptrmapPut(pBt, iFreePage, eType, iPtrPage, &rc); + } + } + return rc; +} + +/* Forward declaration required by incrVacuumStep(). */ +static int allocateBtreePage(BtShared *, MemPage **, Pgno *, Pgno, u8); + +/* +** Perform a single step of an incremental-vacuum. If successful, return +** SQLITE_OK. If there is no work to do (and therefore no point in +** calling this function again), return SQLITE_DONE. Or, if an error +** occurs, return some other error code. +** +** More specifically, this function attempts to re-organize the database so +** that the last page of the file currently in use is no longer in use. +** +** Parameter nFin is the number of pages that this database would contain +** were this function called until it returns SQLITE_DONE. +** +** If the bCommit parameter is non-zero, this function assumes that the +** caller will keep calling incrVacuumStep() until it returns SQLITE_DONE +** or an error. bCommit is passed true for an auto-vacuum-on-commit +** operation, or false for an incremental vacuum. +*/ +static int incrVacuumStep(BtShared *pBt, Pgno nFin, Pgno iLastPg, int bCommit){ + Pgno nFreeList; /* Number of pages still on the free-list */ + int rc; + + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( iLastPg>nFin ); + + if( !PTRMAP_ISPAGE(pBt, iLastPg) && iLastPg!=PENDING_BYTE_PAGE(pBt) ){ + u8 eType; + Pgno iPtrPage; + + nFreeList = get4byte(&pBt->pPage1->aData[36]); + if( nFreeList==0 ){ + return SQLITE_DONE; + } + + rc = ptrmapGet(pBt, iLastPg, &eType, &iPtrPage); + if( rc!=SQLITE_OK ){ + return rc; + } + if( eType==PTRMAP_ROOTPAGE ){ + return SQLITE_CORRUPT_BKPT; + } + + if( eType==PTRMAP_FREEPAGE ){ + if( bCommit==0 ){ + /* Remove the page from the files free-list. This is not required + ** if bCommit is non-zero. In that case, the free-list will be + ** truncated to zero after this function returns, so it doesn't + ** matter if it still contains some garbage entries. + */ + Pgno iFreePg; + MemPage *pFreePg; + rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, iLastPg, BTALLOC_EXACT); + if( rc!=SQLITE_OK ){ + return rc; + } + assert( iFreePg==iLastPg ); + releasePage(pFreePg); + } + } else { + Pgno iFreePg; /* Index of free page to move pLastPg to */ + MemPage *pLastPg; + u8 eMode = BTALLOC_ANY; /* Mode parameter for allocateBtreePage() */ + Pgno iNear = 0; /* nearby parameter for allocateBtreePage() */ + + rc = btreeGetPage(pBt, iLastPg, &pLastPg, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + + /* If bCommit is zero, this loop runs exactly once and page pLastPg + ** is swapped with the first free page pulled off the free list. + ** + ** On the other hand, if bCommit is greater than zero, then keep + ** looping until a free-page located within the first nFin pages + ** of the file is found. + */ + if( bCommit==0 ){ + eMode = BTALLOC_LE; + iNear = nFin; + } + do { + MemPage *pFreePg; + Pgno dbSize = btreePagecount(pBt); + rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, iNear, eMode); + if( rc!=SQLITE_OK ){ + releasePage(pLastPg); + return rc; + } + releasePage(pFreePg); + if( iFreePg>dbSize ){ + releasePage(pLastPg); + return SQLITE_CORRUPT_BKPT; + } + }while( bCommit && iFreePg>nFin ); + assert( iFreePgbDoTruncate = 1; + pBt->nPage = iLastPg; + } + return SQLITE_OK; +} + +/* +** The database opened by the first argument is an auto-vacuum database +** nOrig pages in size containing nFree free pages. Return the expected +** size of the database in pages following an auto-vacuum operation. +*/ +static Pgno finalDbSize(BtShared *pBt, Pgno nOrig, Pgno nFree){ + int nEntry; /* Number of entries on one ptrmap page */ + Pgno nPtrmap; /* Number of PtrMap pages to be freed */ + Pgno nFin; /* Return value */ + + nEntry = pBt->usableSize/5; + nPtrmap = (nFree-nOrig+PTRMAP_PAGENO(pBt, nOrig)+nEntry)/nEntry; + nFin = nOrig - nFree - nPtrmap; + if( nOrig>PENDING_BYTE_PAGE(pBt) && nFinpBt; + + sqlite3BtreeEnter(p); + assert( pBt->inTransaction==TRANS_WRITE && p->inTrans==TRANS_WRITE ); + if( !pBt->autoVacuum ){ + rc = SQLITE_DONE; + }else{ + Pgno nOrig = btreePagecount(pBt); + Pgno nFree = get4byte(&pBt->pPage1->aData[36]); + Pgno nFin = finalDbSize(pBt, nOrig, nFree); + + if( nOrig=nOrig ){ + rc = SQLITE_CORRUPT_BKPT; + }else if( nFree>0 ){ + rc = saveAllCursors(pBt, 0, 0); + if( rc==SQLITE_OK ){ + invalidateAllOverflowCache(pBt); + rc = incrVacuumStep(pBt, nFin, nOrig, 0); + } + if( rc==SQLITE_OK ){ + rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); + put4byte(&pBt->pPage1->aData[28], pBt->nPage); + } + }else{ + rc = SQLITE_DONE; + } + } + sqlite3BtreeLeave(p); + return rc; +} + +/* +** This routine is called prior to sqlite3PagerCommit when a transaction +** is committed for an auto-vacuum database. +*/ +static int autoVacuumCommit(Btree *p){ + int rc = SQLITE_OK; + Pager *pPager; + BtShared *pBt; + sqlite3 *db; + VVA_ONLY( int nRef ); + + assert( p!=0 ); + pBt = p->pBt; + pPager = pBt->pPager; + VVA_ONLY( nRef = sqlite3PagerRefcount(pPager); ) + + assert( sqlite3_mutex_held(pBt->mutex) ); + invalidateAllOverflowCache(pBt); + assert(pBt->autoVacuum); + if( !pBt->incrVacuum ){ + Pgno nFin; /* Number of pages in database after autovacuuming */ + Pgno nFree; /* Number of pages on the freelist initially */ + Pgno nVac; /* Number of pages to vacuum */ + Pgno iFree; /* The next page to be freed */ + Pgno nOrig; /* Database size before freeing */ + + nOrig = btreePagecount(pBt); + if( PTRMAP_ISPAGE(pBt, nOrig) || nOrig==PENDING_BYTE_PAGE(pBt) ){ + /* It is not possible to create a database for which the final page + ** is either a pointer-map page or the pending-byte page. If one + ** is encountered, this indicates corruption. + */ + return SQLITE_CORRUPT_BKPT; + } + + nFree = get4byte(&pBt->pPage1->aData[36]); + db = p->db; + if( db->xAutovacPages ){ + int iDb; + for(iDb=0; ALWAYS(iDbnDb); iDb++){ + if( db->aDb[iDb].pBt==p ) break; + } + nVac = db->xAutovacPages( + db->pAutovacPagesArg, + db->aDb[iDb].zDbSName, + nOrig, + nFree, + pBt->pageSize + ); + if( nVac>nFree ){ + nVac = nFree; + } + if( nVac==0 ){ + return SQLITE_OK; + } + }else{ + nVac = nFree; + } + nFin = finalDbSize(pBt, nOrig, nVac); + if( nFin>nOrig ) return SQLITE_CORRUPT_BKPT; + if( nFinnFin && rc==SQLITE_OK; iFree--){ + rc = incrVacuumStep(pBt, nFin, iFree, nVac==nFree); + } + if( (rc==SQLITE_DONE || rc==SQLITE_OK) && nFree>0 ){ + rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); + if( nVac==nFree ){ + put4byte(&pBt->pPage1->aData[32], 0); + put4byte(&pBt->pPage1->aData[36], 0); + } + put4byte(&pBt->pPage1->aData[28], nFin); + pBt->bDoTruncate = 1; + pBt->nPage = nFin; + } + if( rc!=SQLITE_OK ){ + sqlite3PagerRollback(pPager); + } + } + + assert( nRef>=sqlite3PagerRefcount(pPager) ); + return rc; +} + +#else /* ifndef SQLITE_OMIT_AUTOVACUUM */ +# define setChildPtrmaps(x) SQLITE_OK +#endif + +/* +** This routine does the first phase of a two-phase commit. This routine +** causes a rollback journal to be created (if it does not already exist) +** and populated with enough information so that if a power loss occurs +** the database can be restored to its original state by playing back +** the journal. Then the contents of the journal are flushed out to +** the disk. After the journal is safely on oxide, the changes to the +** database are written into the database file and flushed to oxide. +** At the end of this call, the rollback journal still exists on the +** disk and we are still holding all locks, so the transaction has not +** committed. See sqlite3BtreeCommitPhaseTwo() for the second phase of the +** commit process. +** +** This call is a no-op if no write-transaction is currently active on pBt. +** +** Otherwise, sync the database file for the btree pBt. zSuperJrnl points to +** the name of a super-journal file that should be written into the +** individual journal file, or is NULL, indicating no super-journal file +** (single database transaction). +** +** When this is called, the super-journal should already have been +** created, populated with this journal pointer and synced to disk. +** +** Once this is routine has returned, the only thing required to commit +** the write-transaction for this database file is to delete the journal. +*/ +SQLITE_PRIVATE int sqlite3BtreeCommitPhaseOne(Btree *p, const char *zSuperJrnl){ + int rc = SQLITE_OK; + if( p->inTrans==TRANS_WRITE ){ + BtShared *pBt = p->pBt; + sqlite3BtreeEnter(p); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + rc = autoVacuumCommit(p); + if( rc!=SQLITE_OK ){ + sqlite3BtreeLeave(p); + return rc; + } + } + if( pBt->bDoTruncate ){ + sqlite3PagerTruncateImage(pBt->pPager, pBt->nPage); + } +#endif + rc = sqlite3PagerCommitPhaseOne(pBt->pPager, zSuperJrnl, 0); + sqlite3BtreeLeave(p); + } + return rc; +} + +/* +** This function is called from both BtreeCommitPhaseTwo() and BtreeRollback() +** at the conclusion of a transaction. +*/ +static void btreeEndTransaction(Btree *p){ + BtShared *pBt = p->pBt; + sqlite3 *db = p->db; + assert( sqlite3BtreeHoldsMutex(p) ); + +#ifndef SQLITE_OMIT_AUTOVACUUM + pBt->bDoTruncate = 0; +#endif + if( p->inTrans>TRANS_NONE && db->nVdbeRead>1 ){ + /* If there are other active statements that belong to this database + ** handle, downgrade to a read-only transaction. The other statements + ** may still be reading from the database. */ + downgradeAllSharedCacheTableLocks(p); + p->inTrans = TRANS_READ; + }else{ + /* If the handle had any kind of transaction open, decrement the + ** transaction count of the shared btree. If the transaction count + ** reaches 0, set the shared state to TRANS_NONE. The unlockBtreeIfUnused() + ** call below will unlock the pager. */ + if( p->inTrans!=TRANS_NONE ){ + clearAllSharedCacheTableLocks(p); + pBt->nTransaction--; + if( 0==pBt->nTransaction ){ + pBt->inTransaction = TRANS_NONE; + } + } + + /* Set the current transaction state to TRANS_NONE and unlock the + ** pager if this call closed the only read or write transaction. */ + p->inTrans = TRANS_NONE; + unlockBtreeIfUnused(pBt); + } + + btreeIntegrity(p); +} + +/* +** Commit the transaction currently in progress. +** +** This routine implements the second phase of a 2-phase commit. The +** sqlite3BtreeCommitPhaseOne() routine does the first phase and should +** be invoked prior to calling this routine. The sqlite3BtreeCommitPhaseOne() +** routine did all the work of writing information out to disk and flushing the +** contents so that they are written onto the disk platter. All this +** routine has to do is delete or truncate or zero the header in the +** the rollback journal (which causes the transaction to commit) and +** drop locks. +** +** Normally, if an error occurs while the pager layer is attempting to +** finalize the underlying journal file, this function returns an error and +** the upper layer will attempt a rollback. However, if the second argument +** is non-zero then this b-tree transaction is part of a multi-file +** transaction. In this case, the transaction has already been committed +** (by deleting a super-journal file) and the caller will ignore this +** functions return code. So, even if an error occurs in the pager layer, +** reset the b-tree objects internal state to indicate that the write +** transaction has been closed. This is quite safe, as the pager will have +** transitioned to the error state. +** +** This will release the write lock on the database file. If there +** are no active cursors, it also releases the read lock. +*/ +SQLITE_PRIVATE int sqlite3BtreeCommitPhaseTwo(Btree *p, int bCleanup){ + + if( p->inTrans==TRANS_NONE ) return SQLITE_OK; + sqlite3BtreeEnter(p); + btreeIntegrity(p); + + /* If the handle has a write-transaction open, commit the shared-btrees + ** transaction and set the shared state to TRANS_READ. + */ + if( p->inTrans==TRANS_WRITE ){ + int rc; + BtShared *pBt = p->pBt; + assert( pBt->inTransaction==TRANS_WRITE ); + assert( pBt->nTransaction>0 ); + rc = sqlite3PagerCommitPhaseTwo(pBt->pPager); + if( rc!=SQLITE_OK && bCleanup==0 ){ + sqlite3BtreeLeave(p); + return rc; + } + p->iBDataVersion--; /* Compensate for pPager->iDataVersion++; */ + pBt->inTransaction = TRANS_READ; + btreeClearHasContent(pBt); + } + + btreeEndTransaction(p); + sqlite3BtreeLeave(p); + return SQLITE_OK; +} + +/* +** Do both phases of a commit. +*/ +SQLITE_PRIVATE int sqlite3BtreeCommit(Btree *p){ + int rc; + sqlite3BtreeEnter(p); + rc = sqlite3BtreeCommitPhaseOne(p, 0); + if( rc==SQLITE_OK ){ + rc = sqlite3BtreeCommitPhaseTwo(p, 0); + } + sqlite3BtreeLeave(p); + return rc; +} + +/* +** This routine sets the state to CURSOR_FAULT and the error +** code to errCode for every cursor on any BtShared that pBtree +** references. Or if the writeOnly flag is set to 1, then only +** trip write cursors and leave read cursors unchanged. +** +** Every cursor is a candidate to be tripped, including cursors +** that belong to other database connections that happen to be +** sharing the cache with pBtree. +** +** This routine gets called when a rollback occurs. If the writeOnly +** flag is true, then only write-cursors need be tripped - read-only +** cursors save their current positions so that they may continue +** following the rollback. Or, if writeOnly is false, all cursors are +** tripped. In general, writeOnly is false if the transaction being +** rolled back modified the database schema. In this case b-tree root +** pages may be moved or deleted from the database altogether, making +** it unsafe for read cursors to continue. +** +** If the writeOnly flag is true and an error is encountered while +** saving the current position of a read-only cursor, all cursors, +** including all read-cursors are tripped. +** +** SQLITE_OK is returned if successful, or if an error occurs while +** saving a cursor position, an SQLite error code. +*/ +SQLITE_PRIVATE int sqlite3BtreeTripAllCursors(Btree *pBtree, int errCode, int writeOnly){ + BtCursor *p; + int rc = SQLITE_OK; + + assert( (writeOnly==0 || writeOnly==1) && BTCF_WriteFlag==1 ); + if( pBtree ){ + sqlite3BtreeEnter(pBtree); + for(p=pBtree->pBt->pCursor; p; p=p->pNext){ + if( writeOnly && (p->curFlags & BTCF_WriteFlag)==0 ){ + if( p->eState==CURSOR_VALID || p->eState==CURSOR_SKIPNEXT ){ + rc = saveCursorPosition(p); + if( rc!=SQLITE_OK ){ + (void)sqlite3BtreeTripAllCursors(pBtree, rc, 0); + break; + } + } + }else{ + sqlite3BtreeClearCursor(p); + p->eState = CURSOR_FAULT; + p->skipNext = errCode; + } + btreeReleaseAllCursorPages(p); + } + sqlite3BtreeLeave(pBtree); + } + return rc; +} + +/* +** Set the pBt->nPage field correctly, according to the current +** state of the database. Assume pBt->pPage1 is valid. +*/ +static void btreeSetNPage(BtShared *pBt, MemPage *pPage1){ + int nPage = get4byte(&pPage1->aData[28]); + testcase( nPage==0 ); + if( nPage==0 ) sqlite3PagerPagecount(pBt->pPager, &nPage); + testcase( pBt->nPage!=(u32)nPage ); + pBt->nPage = nPage; +} + +/* +** Rollback the transaction in progress. +** +** If tripCode is not SQLITE_OK then cursors will be invalidated (tripped). +** Only write cursors are tripped if writeOnly is true but all cursors are +** tripped if writeOnly is false. Any attempt to use +** a tripped cursor will result in an error. +** +** This will release the write lock on the database file. If there +** are no active cursors, it also releases the read lock. +*/ +SQLITE_PRIVATE int sqlite3BtreeRollback(Btree *p, int tripCode, int writeOnly){ + int rc; + BtShared *pBt = p->pBt; + MemPage *pPage1; + + assert( writeOnly==1 || writeOnly==0 ); + assert( tripCode==SQLITE_ABORT_ROLLBACK || tripCode==SQLITE_OK ); + sqlite3BtreeEnter(p); + if( tripCode==SQLITE_OK ){ + rc = tripCode = saveAllCursors(pBt, 0, 0); + if( rc ) writeOnly = 0; + }else{ + rc = SQLITE_OK; + } + if( tripCode ){ + int rc2 = sqlite3BtreeTripAllCursors(p, tripCode, writeOnly); + assert( rc==SQLITE_OK || (writeOnly==0 && rc2==SQLITE_OK) ); + if( rc2!=SQLITE_OK ) rc = rc2; + } + btreeIntegrity(p); + + if( p->inTrans==TRANS_WRITE ){ + int rc2; + + assert( TRANS_WRITE==pBt->inTransaction ); + rc2 = sqlite3PagerRollback(pBt->pPager); + if( rc2!=SQLITE_OK ){ + rc = rc2; + } + + /* The rollback may have destroyed the pPage1->aData value. So + ** call btreeGetPage() on page 1 again to make + ** sure pPage1->aData is set correctly. */ + if( btreeGetPage(pBt, 1, &pPage1, 0)==SQLITE_OK ){ + btreeSetNPage(pBt, pPage1); + releasePageOne(pPage1); + } + assert( countValidCursors(pBt, 1)==0 ); + pBt->inTransaction = TRANS_READ; + btreeClearHasContent(pBt); + } + + btreeEndTransaction(p); + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Start a statement subtransaction. The subtransaction can be rolled +** back independently of the main transaction. You must start a transaction +** before starting a subtransaction. The subtransaction is ended automatically +** if the main transaction commits or rolls back. +** +** Statement subtransactions are used around individual SQL statements +** that are contained within a BEGIN...COMMIT block. If a constraint +** error occurs within the statement, the effect of that one statement +** can be rolled back without having to rollback the entire transaction. +** +** A statement sub-transaction is implemented as an anonymous savepoint. The +** value passed as the second parameter is the total number of savepoints, +** including the new anonymous savepoint, open on the B-Tree. i.e. if there +** are no active savepoints and no other statement-transactions open, +** iStatement is 1. This anonymous savepoint can be released or rolled back +** using the sqlite3BtreeSavepoint() function. +*/ +SQLITE_PRIVATE int sqlite3BtreeBeginStmt(Btree *p, int iStatement){ + int rc; + BtShared *pBt = p->pBt; + sqlite3BtreeEnter(p); + assert( p->inTrans==TRANS_WRITE ); + assert( (pBt->btsFlags & BTS_READ_ONLY)==0 ); + assert( iStatement>0 ); + assert( iStatement>p->db->nSavepoint ); + assert( pBt->inTransaction==TRANS_WRITE ); + /* At the pager level, a statement transaction is a savepoint with + ** an index greater than all savepoints created explicitly using + ** SQL statements. It is illegal to open, release or rollback any + ** such savepoints while the statement transaction savepoint is active. + */ + rc = sqlite3PagerOpenSavepoint(pBt->pPager, iStatement); + sqlite3BtreeLeave(p); + return rc; +} + +/* +** The second argument to this function, op, is always SAVEPOINT_ROLLBACK +** or SAVEPOINT_RELEASE. This function either releases or rolls back the +** savepoint identified by parameter iSavepoint, depending on the value +** of op. +** +** Normally, iSavepoint is greater than or equal to zero. However, if op is +** SAVEPOINT_ROLLBACK, then iSavepoint may also be -1. In this case the +** contents of the entire transaction are rolled back. This is different +** from a normal transaction rollback, as no locks are released and the +** transaction remains open. +*/ +SQLITE_PRIVATE int sqlite3BtreeSavepoint(Btree *p, int op, int iSavepoint){ + int rc = SQLITE_OK; + if( p && p->inTrans==TRANS_WRITE ){ + BtShared *pBt = p->pBt; + assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK ); + assert( iSavepoint>=0 || (iSavepoint==-1 && op==SAVEPOINT_ROLLBACK) ); + sqlite3BtreeEnter(p); + if( op==SAVEPOINT_ROLLBACK ){ + rc = saveAllCursors(pBt, 0, 0); + } + if( rc==SQLITE_OK ){ + rc = sqlite3PagerSavepoint(pBt->pPager, op, iSavepoint); + } + if( rc==SQLITE_OK ){ + if( iSavepoint<0 && (pBt->btsFlags & BTS_INITIALLY_EMPTY)!=0 ){ + pBt->nPage = 0; + } + rc = newDatabase(pBt); + btreeSetNPage(pBt, pBt->pPage1); + + /* pBt->nPage might be zero if the database was corrupt when + ** the transaction was started. Otherwise, it must be at least 1. */ + assert( CORRUPT_DB || pBt->nPage>0 ); + } + sqlite3BtreeLeave(p); + } + return rc; +} + +/* +** Create a new cursor for the BTree whose root is on the page +** iTable. If a read-only cursor is requested, it is assumed that +** the caller already has at least a read-only transaction open +** on the database already. If a write-cursor is requested, then +** the caller is assumed to have an open write transaction. +** +** If the BTREE_WRCSR bit of wrFlag is clear, then the cursor can only +** be used for reading. If the BTREE_WRCSR bit is set, then the cursor +** can be used for reading or for writing if other conditions for writing +** are also met. These are the conditions that must be met in order +** for writing to be allowed: +** +** 1: The cursor must have been opened with wrFlag containing BTREE_WRCSR +** +** 2: Other database connections that share the same pager cache +** but which are not in the READ_UNCOMMITTED state may not have +** cursors open with wrFlag==0 on the same table. Otherwise +** the changes made by this write cursor would be visible to +** the read cursors in the other database connection. +** +** 3: The database must be writable (not on read-only media) +** +** 4: There must be an active transaction. +** +** The BTREE_FORDELETE bit of wrFlag may optionally be set if BTREE_WRCSR +** is set. If FORDELETE is set, that is a hint to the implementation that +** this cursor will only be used to seek to and delete entries of an index +** as part of a larger DELETE statement. The FORDELETE hint is not used by +** this implementation. But in a hypothetical alternative storage engine +** in which index entries are automatically deleted when corresponding table +** rows are deleted, the FORDELETE flag is a hint that all SEEK and DELETE +** operations on this cursor can be no-ops and all READ operations can +** return a null row (2-bytes: 0x01 0x00). +** +** No checking is done to make sure that page iTable really is the +** root page of a b-tree. If it is not, then the cursor acquired +** will not work correctly. +** +** It is assumed that the sqlite3BtreeCursorZero() has been called +** on pCur to initialize the memory space prior to invoking this routine. +*/ +static int btreeCursor( + Btree *p, /* The btree */ + Pgno iTable, /* Root page of table to open */ + int wrFlag, /* 1 to write. 0 read-only */ + struct KeyInfo *pKeyInfo, /* First arg to comparison function */ + BtCursor *pCur /* Space for new cursor */ +){ + BtShared *pBt = p->pBt; /* Shared b-tree handle */ + BtCursor *pX; /* Looping over other all cursors */ + + assert( sqlite3BtreeHoldsMutex(p) ); + assert( wrFlag==0 + || wrFlag==BTREE_WRCSR + || wrFlag==(BTREE_WRCSR|BTREE_FORDELETE) + ); + + /* The following assert statements verify that if this is a sharable + ** b-tree database, the connection is holding the required table locks, + ** and that no other connection has any open cursor that conflicts with + ** this lock. The iTable<1 term disables the check for corrupt schemas. */ + assert( hasSharedCacheTableLock(p, iTable, pKeyInfo!=0, (wrFlag?2:1)) + || iTable<1 ); + assert( wrFlag==0 || !hasReadConflicts(p, iTable) ); + + /* Assert that the caller has opened the required transaction. */ + assert( p->inTrans>TRANS_NONE ); + assert( wrFlag==0 || p->inTrans==TRANS_WRITE ); + assert( pBt->pPage1 && pBt->pPage1->aData ); + assert( wrFlag==0 || (pBt->btsFlags & BTS_READ_ONLY)==0 ); + + if( iTable<=1 ){ + if( iTable<1 ){ + return SQLITE_CORRUPT_BKPT; + }else if( btreePagecount(pBt)==0 ){ + assert( wrFlag==0 ); + iTable = 0; + } + } + + /* Now that no other errors can occur, finish filling in the BtCursor + ** variables and link the cursor into the BtShared list. */ + pCur->pgnoRoot = iTable; + pCur->iPage = -1; + pCur->pKeyInfo = pKeyInfo; + pCur->pBtree = p; + pCur->pBt = pBt; + pCur->curFlags = 0; + /* If there are two or more cursors on the same btree, then all such + ** cursors *must* have the BTCF_Multiple flag set. */ + for(pX=pBt->pCursor; pX; pX=pX->pNext){ + if( pX->pgnoRoot==iTable ){ + pX->curFlags |= BTCF_Multiple; + pCur->curFlags = BTCF_Multiple; + } + } + pCur->eState = CURSOR_INVALID; + pCur->pNext = pBt->pCursor; + pBt->pCursor = pCur; + if( wrFlag ){ + pCur->curFlags |= BTCF_WriteFlag; + pCur->curPagerFlags = 0; + if( pBt->pTmpSpace==0 ) return allocateTempSpace(pBt); + }else{ + pCur->curPagerFlags = PAGER_GET_READONLY; + } + return SQLITE_OK; +} +static int btreeCursorWithLock( + Btree *p, /* The btree */ + Pgno iTable, /* Root page of table to open */ + int wrFlag, /* 1 to write. 0 read-only */ + struct KeyInfo *pKeyInfo, /* First arg to comparison function */ + BtCursor *pCur /* Space for new cursor */ +){ + int rc; + sqlite3BtreeEnter(p); + rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur); + sqlite3BtreeLeave(p); + return rc; +} +SQLITE_PRIVATE int sqlite3BtreeCursor( + Btree *p, /* The btree */ + Pgno iTable, /* Root page of table to open */ + int wrFlag, /* 1 to write. 0 read-only */ + struct KeyInfo *pKeyInfo, /* First arg to xCompare() */ + BtCursor *pCur /* Write new cursor here */ +){ + if( p->sharable ){ + return btreeCursorWithLock(p, iTable, wrFlag, pKeyInfo, pCur); + }else{ + return btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur); + } +} + +/* +** Return the size of a BtCursor object in bytes. +** +** This interfaces is needed so that users of cursors can preallocate +** sufficient storage to hold a cursor. The BtCursor object is opaque +** to users so they cannot do the sizeof() themselves - they must call +** this routine. +*/ +SQLITE_PRIVATE int sqlite3BtreeCursorSize(void){ + return ROUND8(sizeof(BtCursor)); +} + +/* +** Initialize memory that will be converted into a BtCursor object. +** +** The simple approach here would be to memset() the entire object +** to zero. But it turns out that the apPage[] and aiIdx[] arrays +** do not need to be zeroed and they are large, so we can save a lot +** of run-time by skipping the initialization of those elements. +*/ +SQLITE_PRIVATE void sqlite3BtreeCursorZero(BtCursor *p){ + memset(p, 0, offsetof(BtCursor, BTCURSOR_FIRST_UNINIT)); +} + +/* +** Close a cursor. The read lock on the database file is released +** when the last cursor is closed. +*/ +SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){ + Btree *pBtree = pCur->pBtree; + if( pBtree ){ + BtShared *pBt = pCur->pBt; + sqlite3BtreeEnter(pBtree); + assert( pBt->pCursor!=0 ); + if( pBt->pCursor==pCur ){ + pBt->pCursor = pCur->pNext; + }else{ + BtCursor *pPrev = pBt->pCursor; + do{ + if( pPrev->pNext==pCur ){ + pPrev->pNext = pCur->pNext; + break; + } + pPrev = pPrev->pNext; + }while( ALWAYS(pPrev) ); + } + btreeReleaseAllCursorPages(pCur); + unlockBtreeIfUnused(pBt); + sqlite3_free(pCur->aOverflow); + sqlite3_free(pCur->pKey); + if( (pBt->openFlags & BTREE_SINGLE) && pBt->pCursor==0 ){ + /* Since the BtShared is not sharable, there is no need to + ** worry about the missing sqlite3BtreeLeave() call here. */ + assert( pBtree->sharable==0 ); + sqlite3BtreeClose(pBtree); + }else{ + sqlite3BtreeLeave(pBtree); + } + pCur->pBtree = 0; + } + return SQLITE_OK; +} + +/* +** Make sure the BtCursor* given in the argument has a valid +** BtCursor.info structure. If it is not already valid, call +** btreeParseCell() to fill it in. +** +** BtCursor.info is a cache of the information in the current cell. +** Using this cache reduces the number of calls to btreeParseCell(). +*/ +#ifndef NDEBUG + static int cellInfoEqual(CellInfo *a, CellInfo *b){ + if( a->nKey!=b->nKey ) return 0; + if( a->pPayload!=b->pPayload ) return 0; + if( a->nPayload!=b->nPayload ) return 0; + if( a->nLocal!=b->nLocal ) return 0; + if( a->nSize!=b->nSize ) return 0; + return 1; + } + static void assertCellInfo(BtCursor *pCur){ + CellInfo info; + memset(&info, 0, sizeof(info)); + btreeParseCell(pCur->pPage, pCur->ix, &info); + assert( CORRUPT_DB || cellInfoEqual(&info, &pCur->info) ); + } +#else + #define assertCellInfo(x) +#endif +static SQLITE_NOINLINE void getCellInfo(BtCursor *pCur){ + if( pCur->info.nSize==0 ){ + pCur->curFlags |= BTCF_ValidNKey; + btreeParseCell(pCur->pPage,pCur->ix,&pCur->info); + }else{ + assertCellInfo(pCur); + } +} + +#ifndef NDEBUG /* The next routine used only within assert() statements */ +/* +** Return true if the given BtCursor is valid. A valid cursor is one +** that is currently pointing to a row in a (non-empty) table. +** This is a verification routine is used only within assert() statements. +*/ +SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor *pCur){ + return pCur && pCur->eState==CURSOR_VALID; +} +#endif /* NDEBUG */ +SQLITE_PRIVATE int sqlite3BtreeCursorIsValidNN(BtCursor *pCur){ + assert( pCur!=0 ); + return pCur->eState==CURSOR_VALID; +} + +/* +** Return the value of the integer key or "rowid" for a table btree. +** This routine is only valid for a cursor that is pointing into a +** ordinary table btree. If the cursor points to an index btree or +** is invalid, the result of this routine is undefined. +*/ +SQLITE_PRIVATE i64 sqlite3BtreeIntegerKey(BtCursor *pCur){ + assert( cursorHoldsMutex(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->curIntKey ); + getCellInfo(pCur); + return pCur->info.nKey; +} + +/* +** Pin or unpin a cursor. +*/ +SQLITE_PRIVATE void sqlite3BtreeCursorPin(BtCursor *pCur){ + assert( (pCur->curFlags & BTCF_Pinned)==0 ); + pCur->curFlags |= BTCF_Pinned; +} +SQLITE_PRIVATE void sqlite3BtreeCursorUnpin(BtCursor *pCur){ + assert( (pCur->curFlags & BTCF_Pinned)!=0 ); + pCur->curFlags &= ~BTCF_Pinned; +} + +#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC +/* +** Return the offset into the database file for the start of the +** payload to which the cursor is pointing. +*/ +SQLITE_PRIVATE i64 sqlite3BtreeOffset(BtCursor *pCur){ + assert( cursorHoldsMutex(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + getCellInfo(pCur); + return (i64)pCur->pBt->pageSize*((i64)pCur->pPage->pgno - 1) + + (i64)(pCur->info.pPayload - pCur->pPage->aData); +} +#endif /* SQLITE_ENABLE_OFFSET_SQL_FUNC */ + +/* +** Return the number of bytes of payload for the entry that pCur is +** currently pointing to. For table btrees, this will be the amount +** of data. For index btrees, this will be the size of the key. +** +** The caller must guarantee that the cursor is pointing to a non-NULL +** valid entry. In other words, the calling procedure must guarantee +** that the cursor has Cursor.eState==CURSOR_VALID. +*/ +SQLITE_PRIVATE u32 sqlite3BtreePayloadSize(BtCursor *pCur){ + assert( cursorHoldsMutex(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + getCellInfo(pCur); + return pCur->info.nPayload; +} + +/* +** Return an upper bound on the size of any record for the table +** that the cursor is pointing into. +** +** This is an optimization. Everything will still work if this +** routine always returns 2147483647 (which is the largest record +** that SQLite can handle) or more. But returning a smaller value might +** prevent large memory allocations when trying to interpret a +** corrupt datrabase. +** +** The current implementation merely returns the size of the underlying +** database file. +*/ +SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeMaxRecordSize(BtCursor *pCur){ + assert( cursorHoldsMutex(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + return pCur->pBt->pageSize * (sqlite3_int64)pCur->pBt->nPage; +} + +/* +** Given the page number of an overflow page in the database (parameter +** ovfl), this function finds the page number of the next page in the +** linked list of overflow pages. If possible, it uses the auto-vacuum +** pointer-map data instead of reading the content of page ovfl to do so. +** +** If an error occurs an SQLite error code is returned. Otherwise: +** +** The page number of the next overflow page in the linked list is +** written to *pPgnoNext. If page ovfl is the last page in its linked +** list, *pPgnoNext is set to zero. +** +** If ppPage is not NULL, and a reference to the MemPage object corresponding +** to page number pOvfl was obtained, then *ppPage is set to point to that +** reference. It is the responsibility of the caller to call releasePage() +** on *ppPage to free the reference. In no reference was obtained (because +** the pointer-map was used to obtain the value for *pPgnoNext), then +** *ppPage is set to zero. +*/ +static int getOverflowPage( + BtShared *pBt, /* The database file */ + Pgno ovfl, /* Current overflow page number */ + MemPage **ppPage, /* OUT: MemPage handle (may be NULL) */ + Pgno *pPgnoNext /* OUT: Next overflow page number */ +){ + Pgno next = 0; + MemPage *pPage = 0; + int rc = SQLITE_OK; + + assert( sqlite3_mutex_held(pBt->mutex) ); + assert(pPgnoNext); + +#ifndef SQLITE_OMIT_AUTOVACUUM + /* Try to find the next page in the overflow list using the + ** autovacuum pointer-map pages. Guess that the next page in + ** the overflow list is page number (ovfl+1). If that guess turns + ** out to be wrong, fall back to loading the data of page + ** number ovfl to determine the next page number. + */ + if( pBt->autoVacuum ){ + Pgno pgno; + Pgno iGuess = ovfl+1; + u8 eType; + + while( PTRMAP_ISPAGE(pBt, iGuess) || iGuess==PENDING_BYTE_PAGE(pBt) ){ + iGuess++; + } + + if( iGuess<=btreePagecount(pBt) ){ + rc = ptrmapGet(pBt, iGuess, &eType, &pgno); + if( rc==SQLITE_OK && eType==PTRMAP_OVERFLOW2 && pgno==ovfl ){ + next = iGuess; + rc = SQLITE_DONE; + } + } + } +#endif + + assert( next==0 || rc==SQLITE_DONE ); + if( rc==SQLITE_OK ){ + rc = btreeGetPage(pBt, ovfl, &pPage, (ppPage==0) ? PAGER_GET_READONLY : 0); + assert( rc==SQLITE_OK || pPage==0 ); + if( rc==SQLITE_OK ){ + next = get4byte(pPage->aData); + } + } + + *pPgnoNext = next; + if( ppPage ){ + *ppPage = pPage; + }else{ + releasePage(pPage); + } + return (rc==SQLITE_DONE ? SQLITE_OK : rc); +} + +/* +** Copy data from a buffer to a page, or from a page to a buffer. +** +** pPayload is a pointer to data stored on database page pDbPage. +** If argument eOp is false, then nByte bytes of data are copied +** from pPayload to the buffer pointed at by pBuf. If eOp is true, +** then sqlite3PagerWrite() is called on pDbPage and nByte bytes +** of data are copied from the buffer pBuf to pPayload. +** +** SQLITE_OK is returned on success, otherwise an error code. +*/ +static int copyPayload( + void *pPayload, /* Pointer to page data */ + void *pBuf, /* Pointer to buffer */ + int nByte, /* Number of bytes to copy */ + int eOp, /* 0 -> copy from page, 1 -> copy to page */ + DbPage *pDbPage /* Page containing pPayload */ +){ + if( eOp ){ + /* Copy data from buffer to page (a write operation) */ + int rc = sqlite3PagerWrite(pDbPage); + if( rc!=SQLITE_OK ){ + return rc; + } + memcpy(pPayload, pBuf, nByte); + }else{ + /* Copy data from page to buffer (a read operation) */ + memcpy(pBuf, pPayload, nByte); + } + return SQLITE_OK; +} + +/* +** This function is used to read or overwrite payload information +** for the entry that the pCur cursor is pointing to. The eOp +** argument is interpreted as follows: +** +** 0: The operation is a read. Populate the overflow cache. +** 1: The operation is a write. Populate the overflow cache. +** +** A total of "amt" bytes are read or written beginning at "offset". +** Data is read to or from the buffer pBuf. +** +** The content being read or written might appear on the main page +** or be scattered out on multiple overflow pages. +** +** If the current cursor entry uses one or more overflow pages +** this function may allocate space for and lazily populate +** the overflow page-list cache array (BtCursor.aOverflow). +** Subsequent calls use this cache to make seeking to the supplied offset +** more efficient. +** +** Once an overflow page-list cache has been allocated, it must be +** invalidated if some other cursor writes to the same table, or if +** the cursor is moved to a different row. Additionally, in auto-vacuum +** mode, the following events may invalidate an overflow page-list cache. +** +** * An incremental vacuum, +** * A commit in auto_vacuum="full" mode, +** * Creating a table (may require moving an overflow page). +*/ +static int accessPayload( + BtCursor *pCur, /* Cursor pointing to entry to read from */ + u32 offset, /* Begin reading this far into payload */ + u32 amt, /* Read this many bytes */ + unsigned char *pBuf, /* Write the bytes into this buffer */ + int eOp /* zero to read. non-zero to write. */ +){ + unsigned char *aPayload; + int rc = SQLITE_OK; + int iIdx = 0; + MemPage *pPage = pCur->pPage; /* Btree page of current entry */ + BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */ +#ifdef SQLITE_DIRECT_OVERFLOW_READ + unsigned char * const pBufStart = pBuf; /* Start of original out buffer */ +#endif + + assert( pPage ); + assert( eOp==0 || eOp==1 ); + assert( pCur->eState==CURSOR_VALID ); + if( pCur->ix>=pPage->nCell ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + assert( cursorHoldsMutex(pCur) ); + + getCellInfo(pCur); + aPayload = pCur->info.pPayload; + assert( offset+amt <= pCur->info.nPayload ); + + assert( aPayload > pPage->aData ); + if( (uptr)(aPayload - pPage->aData) > (pBt->usableSize - pCur->info.nLocal) ){ + /* Trying to read or write past the end of the data is an error. The + ** conditional above is really: + ** &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize] + ** but is recast into its current form to avoid integer overflow problems + */ + return SQLITE_CORRUPT_PAGE(pPage); + } + + /* Check if data must be read/written to/from the btree page itself. */ + if( offsetinfo.nLocal ){ + int a = amt; + if( a+offset>pCur->info.nLocal ){ + a = pCur->info.nLocal - offset; + } + rc = copyPayload(&aPayload[offset], pBuf, a, eOp, pPage->pDbPage); + offset = 0; + pBuf += a; + amt -= a; + }else{ + offset -= pCur->info.nLocal; + } + + + if( rc==SQLITE_OK && amt>0 ){ + const u32 ovflSize = pBt->usableSize - 4; /* Bytes content per ovfl page */ + Pgno nextPage; + + nextPage = get4byte(&aPayload[pCur->info.nLocal]); + + /* If the BtCursor.aOverflow[] has not been allocated, allocate it now. + ** + ** The aOverflow[] array is sized at one entry for each overflow page + ** in the overflow chain. The page number of the first overflow page is + ** stored in aOverflow[0], etc. A value of 0 in the aOverflow[] array + ** means "not yet known" (the cache is lazily populated). + */ + if( (pCur->curFlags & BTCF_ValidOvfl)==0 ){ + int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize; + if( pCur->aOverflow==0 + || nOvfl*(int)sizeof(Pgno) > sqlite3MallocSize(pCur->aOverflow) + ){ + Pgno *aNew = (Pgno*)sqlite3Realloc( + pCur->aOverflow, nOvfl*2*sizeof(Pgno) + ); + if( aNew==0 ){ + return SQLITE_NOMEM_BKPT; + }else{ + pCur->aOverflow = aNew; + } + } + memset(pCur->aOverflow, 0, nOvfl*sizeof(Pgno)); + pCur->curFlags |= BTCF_ValidOvfl; + }else{ + /* If the overflow page-list cache has been allocated and the + ** entry for the first required overflow page is valid, skip + ** directly to it. + */ + if( pCur->aOverflow[offset/ovflSize] ){ + iIdx = (offset/ovflSize); + nextPage = pCur->aOverflow[iIdx]; + offset = (offset%ovflSize); + } + } + + assert( rc==SQLITE_OK && amt>0 ); + while( nextPage ){ + /* If required, populate the overflow page-list cache. */ + if( nextPage > pBt->nPage ) return SQLITE_CORRUPT_BKPT; + assert( pCur->aOverflow[iIdx]==0 + || pCur->aOverflow[iIdx]==nextPage + || CORRUPT_DB ); + pCur->aOverflow[iIdx] = nextPage; + + if( offset>=ovflSize ){ + /* The only reason to read this page is to obtain the page + ** number for the next page in the overflow chain. The page + ** data is not required. So first try to lookup the overflow + ** page-list cache, if any, then fall back to the getOverflowPage() + ** function. + */ + assert( pCur->curFlags & BTCF_ValidOvfl ); + assert( pCur->pBtree->db==pBt->db ); + if( pCur->aOverflow[iIdx+1] ){ + nextPage = pCur->aOverflow[iIdx+1]; + }else{ + rc = getOverflowPage(pBt, nextPage, 0, &nextPage); + } + offset -= ovflSize; + }else{ + /* Need to read this page properly. It contains some of the + ** range of data that is being read (eOp==0) or written (eOp!=0). + */ + int a = amt; + if( a + offset > ovflSize ){ + a = ovflSize - offset; + } + +#ifdef SQLITE_DIRECT_OVERFLOW_READ + /* If all the following are true: + ** + ** 1) this is a read operation, and + ** 2) data is required from the start of this overflow page, and + ** 3) there are no dirty pages in the page-cache + ** 4) the database is file-backed, and + ** 5) the page is not in the WAL file + ** 6) at least 4 bytes have already been read into the output buffer + ** + ** then data can be read directly from the database file into the + ** output buffer, bypassing the page-cache altogether. This speeds + ** up loading large records that span many overflow pages. + */ + if( eOp==0 /* (1) */ + && offset==0 /* (2) */ + && sqlite3PagerDirectReadOk(pBt->pPager, nextPage) /* (3,4,5) */ + && &pBuf[-4]>=pBufStart /* (6) */ + ){ + sqlite3_file *fd = sqlite3PagerFile(pBt->pPager); + u8 aSave[4]; + u8 *aWrite = &pBuf[-4]; + assert( aWrite>=pBufStart ); /* due to (6) */ + memcpy(aSave, aWrite, 4); + rc = sqlite3OsRead(fd, aWrite, a+4, (i64)pBt->pageSize*(nextPage-1)); + if( rc && nextPage>pBt->nPage ) rc = SQLITE_CORRUPT_BKPT; + nextPage = get4byte(aWrite); + memcpy(aWrite, aSave, 4); + }else +#endif + + { + DbPage *pDbPage; + rc = sqlite3PagerGet(pBt->pPager, nextPage, &pDbPage, + (eOp==0 ? PAGER_GET_READONLY : 0) + ); + if( rc==SQLITE_OK ){ + aPayload = sqlite3PagerGetData(pDbPage); + nextPage = get4byte(aPayload); + rc = copyPayload(&aPayload[offset+4], pBuf, a, eOp, pDbPage); + sqlite3PagerUnref(pDbPage); + offset = 0; + } + } + amt -= a; + if( amt==0 ) return rc; + pBuf += a; + } + if( rc ) break; + iIdx++; + } + } + + if( rc==SQLITE_OK && amt>0 ){ + /* Overflow chain ends prematurely */ + return SQLITE_CORRUPT_PAGE(pPage); + } + return rc; +} + +/* +** Read part of the payload for the row at which that cursor pCur is currently +** pointing. "amt" bytes will be transferred into pBuf[]. The transfer +** begins at "offset". +** +** pCur can be pointing to either a table or an index b-tree. +** If pointing to a table btree, then the content section is read. If +** pCur is pointing to an index b-tree then the key section is read. +** +** For sqlite3BtreePayload(), the caller must ensure that pCur is pointing +** to a valid row in the table. For sqlite3BtreePayloadChecked(), the +** cursor might be invalid or might need to be restored before being read. +** +** Return SQLITE_OK on success or an error code if anything goes +** wrong. An error is returned if "offset+amt" is larger than +** the available payload. +*/ +SQLITE_PRIVATE int sqlite3BtreePayload(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){ + assert( cursorHoldsMutex(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->iPage>=0 && pCur->pPage ); + return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0); +} + +/* +** This variant of sqlite3BtreePayload() works even if the cursor has not +** in the CURSOR_VALID state. It is only used by the sqlite3_blob_read() +** interface. +*/ +#ifndef SQLITE_OMIT_INCRBLOB +static SQLITE_NOINLINE int accessPayloadChecked( + BtCursor *pCur, + u32 offset, + u32 amt, + void *pBuf +){ + int rc; + if ( pCur->eState==CURSOR_INVALID ){ + return SQLITE_ABORT; + } + assert( cursorOwnsBtShared(pCur) ); + rc = btreeRestoreCursorPosition(pCur); + return rc ? rc : accessPayload(pCur, offset, amt, pBuf, 0); +} +SQLITE_PRIVATE int sqlite3BtreePayloadChecked(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){ + if( pCur->eState==CURSOR_VALID ){ + assert( cursorOwnsBtShared(pCur) ); + return accessPayload(pCur, offset, amt, pBuf, 0); + }else{ + return accessPayloadChecked(pCur, offset, amt, pBuf); + } +} +#endif /* SQLITE_OMIT_INCRBLOB */ + +/* +** Return a pointer to payload information from the entry that the +** pCur cursor is pointing to. The pointer is to the beginning of +** the key if index btrees (pPage->intKey==0) and is the data for +** table btrees (pPage->intKey==1). The number of bytes of available +** key/data is written into *pAmt. If *pAmt==0, then the value +** returned will not be a valid pointer. +** +** This routine is an optimization. It is common for the entire key +** and data to fit on the local page and for there to be no overflow +** pages. When that is so, this routine can be used to access the +** key and data without making a copy. If the key and/or data spills +** onto overflow pages, then accessPayload() must be used to reassemble +** the key/data and copy it into a preallocated buffer. +** +** The pointer returned by this routine looks directly into the cached +** page of the database. The data might change or move the next time +** any btree routine is called. +*/ +static const void *fetchPayload( + BtCursor *pCur, /* Cursor pointing to entry to read from */ + u32 *pAmt /* Write the number of available bytes here */ +){ + int amt; + assert( pCur!=0 && pCur->iPage>=0 && pCur->pPage); + assert( pCur->eState==CURSOR_VALID ); + assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); + assert( cursorOwnsBtShared(pCur) ); + assert( pCur->ixpPage->nCell || CORRUPT_DB ); + assert( pCur->info.nSize>0 ); + assert( pCur->info.pPayload>pCur->pPage->aData || CORRUPT_DB ); + assert( pCur->info.pPayloadpPage->aDataEnd ||CORRUPT_DB); + amt = pCur->info.nLocal; + if( amt>(int)(pCur->pPage->aDataEnd - pCur->info.pPayload) ){ + /* There is too little space on the page for the expected amount + ** of local content. Database must be corrupt. */ + assert( CORRUPT_DB ); + amt = MAX(0, (int)(pCur->pPage->aDataEnd - pCur->info.pPayload)); + } + *pAmt = (u32)amt; + return (void*)pCur->info.pPayload; +} + + +/* +** For the entry that cursor pCur is point to, return as +** many bytes of the key or data as are available on the local +** b-tree page. Write the number of available bytes into *pAmt. +** +** The pointer returned is ephemeral. The key/data may move +** or be destroyed on the next call to any Btree routine, +** including calls from other threads against the same cache. +** Hence, a mutex on the BtShared should be held prior to calling +** this routine. +** +** These routines is used to get quick access to key and data +** in the common case where no overflow pages are used. +*/ +SQLITE_PRIVATE const void *sqlite3BtreePayloadFetch(BtCursor *pCur, u32 *pAmt){ + return fetchPayload(pCur, pAmt); +} + + +/* +** Move the cursor down to a new child page. The newPgno argument is the +** page number of the child page to move to. +** +** This function returns SQLITE_CORRUPT if the page-header flags field of +** the new child page does not match the flags field of the parent (i.e. +** if an intkey page appears to be the parent of a non-intkey page, or +** vice-versa). +*/ +static int moveToChild(BtCursor *pCur, u32 newPgno){ + assert( cursorOwnsBtShared(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->iPageiPage>=0 ); + if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){ + return SQLITE_CORRUPT_BKPT; + } + pCur->info.nSize = 0; + pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl); + pCur->aiIdx[pCur->iPage] = pCur->ix; + pCur->apPage[pCur->iPage] = pCur->pPage; + pCur->ix = 0; + pCur->iPage++; + return getAndInitPage(pCur->pBt, newPgno, &pCur->pPage, pCur, + pCur->curPagerFlags); +} + +#ifdef SQLITE_DEBUG +/* +** Page pParent is an internal (non-leaf) tree page. This function +** asserts that page number iChild is the left-child if the iIdx'th +** cell in page pParent. Or, if iIdx is equal to the total number of +** cells in pParent, that page number iChild is the right-child of +** the page. +*/ +static void assertParentIndex(MemPage *pParent, int iIdx, Pgno iChild){ + if( CORRUPT_DB ) return; /* The conditions tested below might not be true + ** in a corrupt database */ + assert( iIdx<=pParent->nCell ); + if( iIdx==pParent->nCell ){ + assert( get4byte(&pParent->aData[pParent->hdrOffset+8])==iChild ); + }else{ + assert( get4byte(findCell(pParent, iIdx))==iChild ); + } +} +#else +# define assertParentIndex(x,y,z) +#endif + +/* +** Move the cursor up to the parent page. +** +** pCur->idx is set to the cell index that contains the pointer +** to the page we are coming from. If we are coming from the +** right-most child page then pCur->idx is set to one more than +** the largest cell index. +*/ +static void moveToParent(BtCursor *pCur){ + MemPage *pLeaf; + assert( cursorOwnsBtShared(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->iPage>0 ); + assert( pCur->pPage ); + assertParentIndex( + pCur->apPage[pCur->iPage-1], + pCur->aiIdx[pCur->iPage-1], + pCur->pPage->pgno + ); + testcase( pCur->aiIdx[pCur->iPage-1] > pCur->apPage[pCur->iPage-1]->nCell ); + pCur->info.nSize = 0; + pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl); + pCur->ix = pCur->aiIdx[pCur->iPage-1]; + pLeaf = pCur->pPage; + pCur->pPage = pCur->apPage[--pCur->iPage]; + releasePageNotNull(pLeaf); +} + +/* +** Move the cursor to point to the root page of its b-tree structure. +** +** If the table has a virtual root page, then the cursor is moved to point +** to the virtual root page instead of the actual root page. A table has a +** virtual root page when the actual root page contains no cells and a +** single child page. This can only happen with the table rooted at page 1. +** +** If the b-tree structure is empty, the cursor state is set to +** CURSOR_INVALID and this routine returns SQLITE_EMPTY. Otherwise, +** the cursor is set to point to the first cell located on the root +** (or virtual root) page and the cursor state is set to CURSOR_VALID. +** +** If this function returns successfully, it may be assumed that the +** page-header flags indicate that the [virtual] root-page is the expected +** kind of b-tree page (i.e. if when opening the cursor the caller did not +** specify a KeyInfo structure the flags byte is set to 0x05 or 0x0D, +** indicating a table b-tree, or if the caller did specify a KeyInfo +** structure the flags byte is set to 0x02 or 0x0A, indicating an index +** b-tree). +*/ +static int moveToRoot(BtCursor *pCur){ + MemPage *pRoot; + int rc = SQLITE_OK; + + assert( cursorOwnsBtShared(pCur) ); + assert( CURSOR_INVALID < CURSOR_REQUIRESEEK ); + assert( CURSOR_VALID < CURSOR_REQUIRESEEK ); + assert( CURSOR_FAULT > CURSOR_REQUIRESEEK ); + assert( pCur->eState < CURSOR_REQUIRESEEK || pCur->iPage<0 ); + assert( pCur->pgnoRoot>0 || pCur->iPage<0 ); + + if( pCur->iPage>=0 ){ + if( pCur->iPage ){ + releasePageNotNull(pCur->pPage); + while( --pCur->iPage ){ + releasePageNotNull(pCur->apPage[pCur->iPage]); + } + pRoot = pCur->pPage = pCur->apPage[0]; + goto skip_init; + } + }else if( pCur->pgnoRoot==0 ){ + pCur->eState = CURSOR_INVALID; + return SQLITE_EMPTY; + }else{ + assert( pCur->iPage==(-1) ); + if( pCur->eState>=CURSOR_REQUIRESEEK ){ + if( pCur->eState==CURSOR_FAULT ){ + assert( pCur->skipNext!=SQLITE_OK ); + return pCur->skipNext; + } + sqlite3BtreeClearCursor(pCur); + } + rc = getAndInitPage(pCur->pBt, pCur->pgnoRoot, &pCur->pPage, + 0, pCur->curPagerFlags); + if( rc!=SQLITE_OK ){ + pCur->eState = CURSOR_INVALID; + return rc; + } + pCur->iPage = 0; + pCur->curIntKey = pCur->pPage->intKey; + } + pRoot = pCur->pPage; + assert( pRoot->pgno==pCur->pgnoRoot || CORRUPT_DB ); + + /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor + ** expected to open it on an index b-tree. Otherwise, if pKeyInfo is + ** NULL, the caller expects a table b-tree. If this is not the case, + ** return an SQLITE_CORRUPT error. + ** + ** Earlier versions of SQLite assumed that this test could not fail + ** if the root page was already loaded when this function was called (i.e. + ** if pCur->iPage>=0). But this is not so if the database is corrupted + ** in such a way that page pRoot is linked into a second b-tree table + ** (or the freelist). */ + assert( pRoot->intKey==1 || pRoot->intKey==0 ); + if( pRoot->isInit==0 || (pCur->pKeyInfo==0)!=pRoot->intKey ){ + return SQLITE_CORRUPT_PAGE(pCur->pPage); + } + +skip_init: + pCur->ix = 0; + pCur->info.nSize = 0; + pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidNKey|BTCF_ValidOvfl); + + if( pRoot->nCell>0 ){ + pCur->eState = CURSOR_VALID; + }else if( !pRoot->leaf ){ + Pgno subpage; + if( pRoot->pgno!=1 ) return SQLITE_CORRUPT_BKPT; + subpage = get4byte(&pRoot->aData[pRoot->hdrOffset+8]); + pCur->eState = CURSOR_VALID; + rc = moveToChild(pCur, subpage); + }else{ + pCur->eState = CURSOR_INVALID; + rc = SQLITE_EMPTY; + } + return rc; +} + +/* +** Move the cursor down to the left-most leaf entry beneath the +** entry to which it is currently pointing. +** +** The left-most leaf is the one with the smallest key - the first +** in ascending order. +*/ +static int moveToLeftmost(BtCursor *pCur){ + Pgno pgno; + int rc = SQLITE_OK; + MemPage *pPage; + + assert( cursorOwnsBtShared(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + while( rc==SQLITE_OK && !(pPage = pCur->pPage)->leaf ){ + assert( pCur->ixnCell ); + pgno = get4byte(findCell(pPage, pCur->ix)); + rc = moveToChild(pCur, pgno); + } + return rc; +} + +/* +** Move the cursor down to the right-most leaf entry beneath the +** page to which it is currently pointing. Notice the difference +** between moveToLeftmost() and moveToRightmost(). moveToLeftmost() +** finds the left-most entry beneath the *entry* whereas moveToRightmost() +** finds the right-most entry beneath the *page*. +** +** The right-most entry is the one with the largest key - the last +** key in ascending order. +*/ +static int moveToRightmost(BtCursor *pCur){ + Pgno pgno; + int rc = SQLITE_OK; + MemPage *pPage = 0; + + assert( cursorOwnsBtShared(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + while( !(pPage = pCur->pPage)->leaf ){ + pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]); + pCur->ix = pPage->nCell; + rc = moveToChild(pCur, pgno); + if( rc ) return rc; + } + pCur->ix = pPage->nCell-1; + assert( pCur->info.nSize==0 ); + assert( (pCur->curFlags & BTCF_ValidNKey)==0 ); + return SQLITE_OK; +} + +/* Move the cursor to the first entry in the table. Return SQLITE_OK +** on success. Set *pRes to 0 if the cursor actually points to something +** or set *pRes to 1 if the table is empty. +*/ +SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){ + int rc; + + assert( cursorOwnsBtShared(pCur) ); + assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); + rc = moveToRoot(pCur); + if( rc==SQLITE_OK ){ + assert( pCur->pPage->nCell>0 ); + *pRes = 0; + rc = moveToLeftmost(pCur); + }else if( rc==SQLITE_EMPTY ){ + assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 ); + *pRes = 1; + rc = SQLITE_OK; + } + return rc; +} + +/* Move the cursor to the last entry in the table. Return SQLITE_OK +** on success. Set *pRes to 0 if the cursor actually points to something +** or set *pRes to 1 if the table is empty. +*/ +static SQLITE_NOINLINE int btreeLast(BtCursor *pCur, int *pRes){ + int rc = moveToRoot(pCur); + if( rc==SQLITE_OK ){ + assert( pCur->eState==CURSOR_VALID ); + *pRes = 0; + rc = moveToRightmost(pCur); + if( rc==SQLITE_OK ){ + pCur->curFlags |= BTCF_AtLast; + }else{ + pCur->curFlags &= ~BTCF_AtLast; + } + }else if( rc==SQLITE_EMPTY ){ + assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 ); + *pRes = 1; + rc = SQLITE_OK; + } + return rc; +} +SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){ + assert( cursorOwnsBtShared(pCur) ); + assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); + + /* If the cursor already points to the last entry, this is a no-op. */ + if( CURSOR_VALID==pCur->eState && (pCur->curFlags & BTCF_AtLast)!=0 ){ +#ifdef SQLITE_DEBUG + /* This block serves to assert() that the cursor really does point + ** to the last entry in the b-tree. */ + int ii; + for(ii=0; iiiPage; ii++){ + assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell ); + } + assert( pCur->ix==pCur->pPage->nCell-1 || CORRUPT_DB ); + testcase( pCur->ix!=pCur->pPage->nCell-1 ); + /* ^-- dbsqlfuzz b92b72e4de80b5140c30ab71372ca719b8feb618 */ + assert( pCur->pPage->leaf ); +#endif + *pRes = 0; + return SQLITE_OK; + } + return btreeLast(pCur, pRes); +} + +/* Move the cursor so that it points to an entry in a table (a.k.a INTKEY) +** table near the key intKey. Return a success code. +** +** If an exact match is not found, then the cursor is always +** left pointing at a leaf page which would hold the entry if it +** were present. The cursor might point to an entry that comes +** before or after the key. +** +** An integer is written into *pRes which is the result of +** comparing the key with the entry to which the cursor is +** pointing. The meaning of the integer written into +** *pRes is as follows: +** +** *pRes<0 The cursor is left pointing at an entry that +** is smaller than intKey or if the table is empty +** and the cursor is therefore left point to nothing. +** +** *pRes==0 The cursor is left pointing at an entry that +** exactly matches intKey. +** +** *pRes>0 The cursor is left pointing at an entry that +** is larger than intKey. +*/ +SQLITE_PRIVATE int sqlite3BtreeTableMoveto( + BtCursor *pCur, /* The cursor to be moved */ + i64 intKey, /* The table key */ + int biasRight, /* If true, bias the search to the high end */ + int *pRes /* Write search results here */ +){ + int rc; + + assert( cursorOwnsBtShared(pCur) ); + assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); + assert( pRes ); + assert( pCur->pKeyInfo==0 ); + assert( pCur->eState!=CURSOR_VALID || pCur->curIntKey!=0 ); + + /* If the cursor is already positioned at the point we are trying + ** to move to, then just return without doing any work */ + if( pCur->eState==CURSOR_VALID && (pCur->curFlags & BTCF_ValidNKey)!=0 ){ + if( pCur->info.nKey==intKey ){ + *pRes = 0; + return SQLITE_OK; + } + if( pCur->info.nKeycurFlags & BTCF_AtLast)!=0 ){ + *pRes = -1; + return SQLITE_OK; + } + /* If the requested key is one more than the previous key, then + ** try to get there using sqlite3BtreeNext() rather than a full + ** binary search. This is an optimization only. The correct answer + ** is still obtained without this case, only a little more slowely */ + if( pCur->info.nKey+1==intKey ){ + *pRes = 0; + rc = sqlite3BtreeNext(pCur, 0); + if( rc==SQLITE_OK ){ + getCellInfo(pCur); + if( pCur->info.nKey==intKey ){ + return SQLITE_OK; + } + }else if( rc!=SQLITE_DONE ){ + return rc; + } + } + } + } + +#ifdef SQLITE_DEBUG + pCur->pBtree->nSeek++; /* Performance measurement during testing */ +#endif + + rc = moveToRoot(pCur); + if( rc ){ + if( rc==SQLITE_EMPTY ){ + assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 ); + *pRes = -1; + return SQLITE_OK; + } + return rc; + } + assert( pCur->pPage ); + assert( pCur->pPage->isInit ); + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->pPage->nCell > 0 ); + assert( pCur->iPage==0 || pCur->apPage[0]->intKey==pCur->curIntKey ); + assert( pCur->curIntKey ); + + for(;;){ + int lwr, upr, idx, c; + Pgno chldPg; + MemPage *pPage = pCur->pPage; + u8 *pCell; /* Pointer to current cell in pPage */ + + /* pPage->nCell must be greater than zero. If this is the root-page + ** the cursor would have been INVALID above and this for(;;) loop + ** not run. If this is not the root-page, then the moveToChild() routine + ** would have already detected db corruption. Similarly, pPage must + ** be the right kind (index or table) of b-tree page. Otherwise + ** a moveToChild() or moveToRoot() call would have detected corruption. */ + assert( pPage->nCell>0 ); + assert( pPage->intKey ); + lwr = 0; + upr = pPage->nCell-1; + assert( biasRight==0 || biasRight==1 ); + idx = upr>>(1-biasRight); /* idx = biasRight ? upr : (lwr+upr)/2; */ + for(;;){ + i64 nCellKey; + pCell = findCellPastPtr(pPage, idx); + if( pPage->intKeyLeaf ){ + while( 0x80 <= *(pCell++) ){ + if( pCell>=pPage->aDataEnd ){ + return SQLITE_CORRUPT_PAGE(pPage); + } + } + } + getVarint(pCell, (u64*)&nCellKey); + if( nCellKeyupr ){ c = -1; break; } + }else if( nCellKey>intKey ){ + upr = idx-1; + if( lwr>upr ){ c = +1; break; } + }else{ + assert( nCellKey==intKey ); + pCur->ix = (u16)idx; + if( !pPage->leaf ){ + lwr = idx; + goto moveto_table_next_layer; + }else{ + pCur->curFlags |= BTCF_ValidNKey; + pCur->info.nKey = nCellKey; + pCur->info.nSize = 0; + *pRes = 0; + return SQLITE_OK; + } + } + assert( lwr+upr>=0 ); + idx = (lwr+upr)>>1; /* idx = (lwr+upr)/2; */ + } + assert( lwr==upr+1 || !pPage->leaf ); + assert( pPage->isInit ); + if( pPage->leaf ){ + assert( pCur->ixpPage->nCell ); + pCur->ix = (u16)idx; + *pRes = c; + rc = SQLITE_OK; + goto moveto_table_finish; + } +moveto_table_next_layer: + if( lwr>=pPage->nCell ){ + chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]); + }else{ + chldPg = get4byte(findCell(pPage, lwr)); + } + pCur->ix = (u16)lwr; + rc = moveToChild(pCur, chldPg); + if( rc ) break; + } +moveto_table_finish: + pCur->info.nSize = 0; + assert( (pCur->curFlags & BTCF_ValidOvfl)==0 ); + return rc; +} + +/* +** Compare the "idx"-th cell on the page the cursor pCur is currently +** pointing to to pIdxKey using xRecordCompare. Return negative or +** zero if the cell is less than or equal pIdxKey. Return positive +** if unknown. +** +** Return value negative: Cell at pCur[idx] less than pIdxKey +** +** Return value is zero: Cell at pCur[idx] equals pIdxKey +** +** Return value positive: Nothing is known about the relationship +** of the cell at pCur[idx] and pIdxKey. +** +** This routine is part of an optimization. It is always safe to return +** a positive value as that will cause the optimization to be skipped. +*/ +static int indexCellCompare( + BtCursor *pCur, + int idx, + UnpackedRecord *pIdxKey, + RecordCompare xRecordCompare +){ + MemPage *pPage = pCur->pPage; + int c; + int nCell; /* Size of the pCell cell in bytes */ + u8 *pCell = findCellPastPtr(pPage, idx); + + nCell = pCell[0]; + if( nCell<=pPage->max1bytePayload ){ + /* This branch runs if the record-size field of the cell is a + ** single byte varint and the record fits entirely on the main + ** b-tree page. */ + testcase( pCell+nCell+1==pPage->aDataEnd ); + c = xRecordCompare(nCell, (void*)&pCell[1], pIdxKey); + }else if( !(pCell[1] & 0x80) + && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal + ){ + /* The record-size field is a 2 byte varint and the record + ** fits entirely on the main b-tree page. */ + testcase( pCell+nCell+2==pPage->aDataEnd ); + c = xRecordCompare(nCell, (void*)&pCell[2], pIdxKey); + }else{ + /* If the record extends into overflow pages, do not attempt + ** the optimization. */ + c = 99; + } + return c; +} + +/* +** Return true (non-zero) if pCur is current pointing to the last +** page of a table. +*/ +static int cursorOnLastPage(BtCursor *pCur){ + int i; + assert( pCur->eState==CURSOR_VALID ); + for(i=0; iiPage; i++){ + MemPage *pPage = pCur->apPage[i]; + if( pCur->aiIdx[i]nCell ) return 0; + } + return 1; +} + +/* Move the cursor so that it points to an entry in an index table +** near the key pIdxKey. Return a success code. +** +** If an exact match is not found, then the cursor is always +** left pointing at a leaf page which would hold the entry if it +** were present. The cursor might point to an entry that comes +** before or after the key. +** +** An integer is written into *pRes which is the result of +** comparing the key with the entry to which the cursor is +** pointing. The meaning of the integer written into +** *pRes is as follows: +** +** *pRes<0 The cursor is left pointing at an entry that +** is smaller than pIdxKey or if the table is empty +** and the cursor is therefore left point to nothing. +** +** *pRes==0 The cursor is left pointing at an entry that +** exactly matches pIdxKey. +** +** *pRes>0 The cursor is left pointing at an entry that +** is larger than pIdxKey. +** +** The pIdxKey->eqSeen field is set to 1 if there +** exists an entry in the table that exactly matches pIdxKey. +*/ +SQLITE_PRIVATE int sqlite3BtreeIndexMoveto( + BtCursor *pCur, /* The cursor to be moved */ + UnpackedRecord *pIdxKey, /* Unpacked index key */ + int *pRes /* Write search results here */ +){ + int rc; + RecordCompare xRecordCompare; + + assert( cursorOwnsBtShared(pCur) ); + assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); + assert( pRes ); + assert( pCur->pKeyInfo!=0 ); + +#ifdef SQLITE_DEBUG + pCur->pBtree->nSeek++; /* Performance measurement during testing */ +#endif + + xRecordCompare = sqlite3VdbeFindCompare(pIdxKey); + pIdxKey->errCode = 0; + assert( pIdxKey->default_rc==1 + || pIdxKey->default_rc==0 + || pIdxKey->default_rc==-1 + ); + + + /* Check to see if we can skip a lot of work. Two cases: + ** + ** (1) If the cursor is already pointing to the very last cell + ** in the table and the pIdxKey search key is greater than or + ** equal to that last cell, then no movement is required. + ** + ** (2) If the cursor is on the last page of the table and the first + ** cell on that last page is less than or equal to the pIdxKey + ** search key, then we can start the search on the current page + ** without needing to go back to root. + */ + if( pCur->eState==CURSOR_VALID + && pCur->pPage->leaf + && cursorOnLastPage(pCur) + ){ + int c; + if( pCur->ix==pCur->pPage->nCell-1 + && (c = indexCellCompare(pCur, pCur->ix, pIdxKey, xRecordCompare))<=0 + && pIdxKey->errCode==SQLITE_OK + ){ + *pRes = c; + return SQLITE_OK; /* Cursor already pointing at the correct spot */ + } + if( pCur->iPage>0 + && indexCellCompare(pCur, 0, pIdxKey, xRecordCompare)<=0 + && pIdxKey->errCode==SQLITE_OK + ){ + pCur->curFlags &= ~BTCF_ValidOvfl; + if( !pCur->pPage->isInit ){ + return SQLITE_CORRUPT_BKPT; + } + goto bypass_moveto_root; /* Start search on the current page */ + } + pIdxKey->errCode = SQLITE_OK; + } + + rc = moveToRoot(pCur); + if( rc ){ + if( rc==SQLITE_EMPTY ){ + assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 ); + *pRes = -1; + return SQLITE_OK; + } + return rc; + } + +bypass_moveto_root: + assert( pCur->pPage ); + assert( pCur->pPage->isInit ); + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->pPage->nCell > 0 ); + assert( pCur->curIntKey==0 ); + assert( pIdxKey!=0 ); + for(;;){ + int lwr, upr, idx, c; + Pgno chldPg; + MemPage *pPage = pCur->pPage; + u8 *pCell; /* Pointer to current cell in pPage */ + + /* pPage->nCell must be greater than zero. If this is the root-page + ** the cursor would have been INVALID above and this for(;;) loop + ** not run. If this is not the root-page, then the moveToChild() routine + ** would have already detected db corruption. Similarly, pPage must + ** be the right kind (index or table) of b-tree page. Otherwise + ** a moveToChild() or moveToRoot() call would have detected corruption. */ + assert( pPage->nCell>0 ); + assert( pPage->intKey==0 ); + lwr = 0; + upr = pPage->nCell-1; + idx = upr>>1; /* idx = (lwr+upr)/2; */ + for(;;){ + int nCell; /* Size of the pCell cell in bytes */ + pCell = findCellPastPtr(pPage, idx); + + /* The maximum supported page-size is 65536 bytes. This means that + ** the maximum number of record bytes stored on an index B-Tree + ** page is less than 16384 bytes and may be stored as a 2-byte + ** varint. This information is used to attempt to avoid parsing + ** the entire cell by checking for the cases where the record is + ** stored entirely within the b-tree page by inspecting the first + ** 2 bytes of the cell. + */ + nCell = pCell[0]; + if( nCell<=pPage->max1bytePayload ){ + /* This branch runs if the record-size field of the cell is a + ** single byte varint and the record fits entirely on the main + ** b-tree page. */ + testcase( pCell+nCell+1==pPage->aDataEnd ); + c = xRecordCompare(nCell, (void*)&pCell[1], pIdxKey); + }else if( !(pCell[1] & 0x80) + && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal + ){ + /* The record-size field is a 2 byte varint and the record + ** fits entirely on the main b-tree page. */ + testcase( pCell+nCell+2==pPage->aDataEnd ); + c = xRecordCompare(nCell, (void*)&pCell[2], pIdxKey); + }else{ + /* The record flows over onto one or more overflow pages. In + ** this case the whole cell needs to be parsed, a buffer allocated + ** and accessPayload() used to retrieve the record into the + ** buffer before VdbeRecordCompare() can be called. + ** + ** If the record is corrupt, the xRecordCompare routine may read + ** up to two varints past the end of the buffer. An extra 18 + ** bytes of padding is allocated at the end of the buffer in + ** case this happens. */ + void *pCellKey; + u8 * const pCellBody = pCell - pPage->childPtrSize; + const int nOverrun = 18; /* Size of the overrun padding */ + pPage->xParseCell(pPage, pCellBody, &pCur->info); + nCell = (int)pCur->info.nKey; + testcase( nCell<0 ); /* True if key size is 2^32 or more */ + testcase( nCell==0 ); /* Invalid key size: 0x80 0x80 0x00 */ + testcase( nCell==1 ); /* Invalid key size: 0x80 0x80 0x01 */ + testcase( nCell==2 ); /* Minimum legal index key size */ + if( nCell<2 || nCell/pCur->pBt->usableSize>pCur->pBt->nPage ){ + rc = SQLITE_CORRUPT_PAGE(pPage); + goto moveto_index_finish; + } + pCellKey = sqlite3Malloc( nCell+nOverrun ); + if( pCellKey==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto moveto_index_finish; + } + pCur->ix = (u16)idx; + rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0); + memset(((u8*)pCellKey)+nCell,0,nOverrun); /* Fix uninit warnings */ + pCur->curFlags &= ~BTCF_ValidOvfl; + if( rc ){ + sqlite3_free(pCellKey); + goto moveto_index_finish; + } + c = sqlite3VdbeRecordCompare(nCell, pCellKey, pIdxKey); + sqlite3_free(pCellKey); + } + assert( + (pIdxKey->errCode!=SQLITE_CORRUPT || c==0) + && (pIdxKey->errCode!=SQLITE_NOMEM || pCur->pBtree->db->mallocFailed) + ); + if( c<0 ){ + lwr = idx+1; + }else if( c>0 ){ + upr = idx-1; + }else{ + assert( c==0 ); + *pRes = 0; + rc = SQLITE_OK; + pCur->ix = (u16)idx; + if( pIdxKey->errCode ) rc = SQLITE_CORRUPT_BKPT; + goto moveto_index_finish; + } + if( lwr>upr ) break; + assert( lwr+upr>=0 ); + idx = (lwr+upr)>>1; /* idx = (lwr+upr)/2 */ + } + assert( lwr==upr+1 || (pPage->intKey && !pPage->leaf) ); + assert( pPage->isInit ); + if( pPage->leaf ){ + assert( pCur->ixpPage->nCell || CORRUPT_DB ); + pCur->ix = (u16)idx; + *pRes = c; + rc = SQLITE_OK; + goto moveto_index_finish; + } + if( lwr>=pPage->nCell ){ + chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]); + }else{ + chldPg = get4byte(findCell(pPage, lwr)); + } + pCur->ix = (u16)lwr; + rc = moveToChild(pCur, chldPg); + if( rc ) break; + } +moveto_index_finish: + pCur->info.nSize = 0; + assert( (pCur->curFlags & BTCF_ValidOvfl)==0 ); + return rc; +} + + +/* +** Return TRUE if the cursor is not pointing at an entry of the table. +** +** TRUE will be returned after a call to sqlite3BtreeNext() moves +** past the last entry in the table or sqlite3BtreePrev() moves past +** the first entry. TRUE is also returned if the table is empty. +*/ +SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor *pCur){ + /* TODO: What if the cursor is in CURSOR_REQUIRESEEK but all table entries + ** have been deleted? This API will need to change to return an error code + ** as well as the boolean result value. + */ + return (CURSOR_VALID!=pCur->eState); +} + +/* +** Return an estimate for the number of rows in the table that pCur is +** pointing to. Return a negative number if no estimate is currently +** available. +*/ +SQLITE_PRIVATE i64 sqlite3BtreeRowCountEst(BtCursor *pCur){ + i64 n; + u8 i; + + assert( cursorOwnsBtShared(pCur) ); + assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); + + /* Currently this interface is only called by the OP_IfSmaller + ** opcode, and it that case the cursor will always be valid and + ** will always point to a leaf node. */ + if( NEVER(pCur->eState!=CURSOR_VALID) ) return -1; + if( NEVER(pCur->pPage->leaf==0) ) return -1; + + n = pCur->pPage->nCell; + for(i=0; iiPage; i++){ + n *= pCur->apPage[i]->nCell; + } + return n; +} + +/* +** Advance the cursor to the next entry in the database. +** Return value: +** +** SQLITE_OK success +** SQLITE_DONE cursor is already pointing at the last element +** otherwise some kind of error occurred +** +** The main entry point is sqlite3BtreeNext(). That routine is optimized +** for the common case of merely incrementing the cell counter BtCursor.aiIdx +** to the next cell on the current page. The (slower) btreeNext() helper +** routine is called when it is necessary to move to a different page or +** to restore the cursor. +** +** If bit 0x01 of the F argument in sqlite3BtreeNext(C,F) is 1, then the +** cursor corresponds to an SQL index and this routine could have been +** skipped if the SQL index had been a unique index. The F argument +** is a hint to the implement. SQLite btree implementation does not use +** this hint, but COMDB2 does. +*/ +static SQLITE_NOINLINE int btreeNext(BtCursor *pCur){ + int rc; + int idx; + MemPage *pPage; + + assert( cursorOwnsBtShared(pCur) ); + if( pCur->eState!=CURSOR_VALID ){ + assert( (pCur->curFlags & BTCF_ValidOvfl)==0 ); + rc = restoreCursorPosition(pCur); + if( rc!=SQLITE_OK ){ + return rc; + } + if( CURSOR_INVALID==pCur->eState ){ + return SQLITE_DONE; + } + if( pCur->eState==CURSOR_SKIPNEXT ){ + pCur->eState = CURSOR_VALID; + if( pCur->skipNext>0 ) return SQLITE_OK; + } + } + + pPage = pCur->pPage; + idx = ++pCur->ix; + if( sqlite3FaultSim(412) ) pPage->isInit = 0; + if( !pPage->isInit ){ + return SQLITE_CORRUPT_BKPT; + } + + if( idx>=pPage->nCell ){ + if( !pPage->leaf ){ + rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8])); + if( rc ) return rc; + return moveToLeftmost(pCur); + } + do{ + if( pCur->iPage==0 ){ + pCur->eState = CURSOR_INVALID; + return SQLITE_DONE; + } + moveToParent(pCur); + pPage = pCur->pPage; + }while( pCur->ix>=pPage->nCell ); + if( pPage->intKey ){ + return sqlite3BtreeNext(pCur, 0); + }else{ + return SQLITE_OK; + } + } + if( pPage->leaf ){ + return SQLITE_OK; + }else{ + return moveToLeftmost(pCur); + } +} +SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int flags){ + MemPage *pPage; + UNUSED_PARAMETER( flags ); /* Used in COMDB2 but not native SQLite */ + assert( cursorOwnsBtShared(pCur) ); + assert( flags==0 || flags==1 ); + pCur->info.nSize = 0; + pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl); + if( pCur->eState!=CURSOR_VALID ) return btreeNext(pCur); + pPage = pCur->pPage; + if( (++pCur->ix)>=pPage->nCell ){ + pCur->ix--; + return btreeNext(pCur); + } + if( pPage->leaf ){ + return SQLITE_OK; + }else{ + return moveToLeftmost(pCur); + } +} + +/* +** Step the cursor to the back to the previous entry in the database. +** Return values: +** +** SQLITE_OK success +** SQLITE_DONE the cursor is already on the first element of the table +** otherwise some kind of error occurred +** +** The main entry point is sqlite3BtreePrevious(). That routine is optimized +** for the common case of merely decrementing the cell counter BtCursor.aiIdx +** to the previous cell on the current page. The (slower) btreePrevious() +** helper routine is called when it is necessary to move to a different page +** or to restore the cursor. +** +** If bit 0x01 of the F argument to sqlite3BtreePrevious(C,F) is 1, then +** the cursor corresponds to an SQL index and this routine could have been +** skipped if the SQL index had been a unique index. The F argument is a +** hint to the implement. The native SQLite btree implementation does not +** use this hint, but COMDB2 does. +*/ +static SQLITE_NOINLINE int btreePrevious(BtCursor *pCur){ + int rc; + MemPage *pPage; + + assert( cursorOwnsBtShared(pCur) ); + assert( (pCur->curFlags & (BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey))==0 ); + assert( pCur->info.nSize==0 ); + if( pCur->eState!=CURSOR_VALID ){ + rc = restoreCursorPosition(pCur); + if( rc!=SQLITE_OK ){ + return rc; + } + if( CURSOR_INVALID==pCur->eState ){ + return SQLITE_DONE; + } + if( CURSOR_SKIPNEXT==pCur->eState ){ + pCur->eState = CURSOR_VALID; + if( pCur->skipNext<0 ) return SQLITE_OK; + } + } + + pPage = pCur->pPage; + assert( pPage->isInit ); + if( !pPage->leaf ){ + int idx = pCur->ix; + rc = moveToChild(pCur, get4byte(findCell(pPage, idx))); + if( rc ) return rc; + rc = moveToRightmost(pCur); + }else{ + while( pCur->ix==0 ){ + if( pCur->iPage==0 ){ + pCur->eState = CURSOR_INVALID; + return SQLITE_DONE; + } + moveToParent(pCur); + } + assert( pCur->info.nSize==0 ); + assert( (pCur->curFlags & (BTCF_ValidOvfl))==0 ); + + pCur->ix--; + pPage = pCur->pPage; + if( pPage->intKey && !pPage->leaf ){ + rc = sqlite3BtreePrevious(pCur, 0); + }else{ + rc = SQLITE_OK; + } + } + return rc; +} +SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int flags){ + assert( cursorOwnsBtShared(pCur) ); + assert( flags==0 || flags==1 ); + UNUSED_PARAMETER( flags ); /* Used in COMDB2 but not native SQLite */ + pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey); + pCur->info.nSize = 0; + if( pCur->eState!=CURSOR_VALID + || pCur->ix==0 + || pCur->pPage->leaf==0 + ){ + return btreePrevious(pCur); + } + pCur->ix--; + return SQLITE_OK; +} + +/* +** Allocate a new page from the database file. +** +** The new page is marked as dirty. (In other words, sqlite3PagerWrite() +** has already been called on the new page.) The new page has also +** been referenced and the calling routine is responsible for calling +** sqlite3PagerUnref() on the new page when it is done. +** +** SQLITE_OK is returned on success. Any other return value indicates +** an error. *ppPage is set to NULL in the event of an error. +** +** If the "nearby" parameter is not 0, then an effort is made to +** locate a page close to the page number "nearby". This can be used in an +** attempt to keep related pages close to each other in the database file, +** which in turn can make database access faster. +** +** If the eMode parameter is BTALLOC_EXACT and the nearby page exists +** anywhere on the free-list, then it is guaranteed to be returned. If +** eMode is BTALLOC_LT then the page returned will be less than or equal +** to nearby if any such page exists. If eMode is BTALLOC_ANY then there +** are no restrictions on which page is returned. +*/ +static int allocateBtreePage( + BtShared *pBt, /* The btree */ + MemPage **ppPage, /* Store pointer to the allocated page here */ + Pgno *pPgno, /* Store the page number here */ + Pgno nearby, /* Search for a page near this one */ + u8 eMode /* BTALLOC_EXACT, BTALLOC_LT, or BTALLOC_ANY */ +){ + MemPage *pPage1; + int rc; + u32 n; /* Number of pages on the freelist */ + u32 k; /* Number of leaves on the trunk of the freelist */ + MemPage *pTrunk = 0; + MemPage *pPrevTrunk = 0; + Pgno mxPage; /* Total size of the database file */ + + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( eMode==BTALLOC_ANY || (nearby>0 && IfNotOmitAV(pBt->autoVacuum)) ); + pPage1 = pBt->pPage1; + mxPage = btreePagecount(pBt); + /* EVIDENCE-OF: R-21003-45125 The 4-byte big-endian integer at offset 36 + ** stores the total number of pages on the freelist. */ + n = get4byte(&pPage1->aData[36]); + testcase( n==mxPage-1 ); + if( n>=mxPage ){ + return SQLITE_CORRUPT_BKPT; + } + if( n>0 ){ + /* There are pages on the freelist. Reuse one of those pages. */ + Pgno iTrunk; + u8 searchList = 0; /* If the free-list must be searched for 'nearby' */ + u32 nSearch = 0; /* Count of the number of search attempts */ + + /* If eMode==BTALLOC_EXACT and a query of the pointer-map + ** shows that the page 'nearby' is somewhere on the free-list, then + ** the entire-list will be searched for that page. + */ +#ifndef SQLITE_OMIT_AUTOVACUUM + if( eMode==BTALLOC_EXACT ){ + if( nearby<=mxPage ){ + u8 eType; + assert( nearby>0 ); + assert( pBt->autoVacuum ); + rc = ptrmapGet(pBt, nearby, &eType, 0); + if( rc ) return rc; + if( eType==PTRMAP_FREEPAGE ){ + searchList = 1; + } + } + }else if( eMode==BTALLOC_LE ){ + searchList = 1; + } +#endif + + /* Decrement the free-list count by 1. Set iTrunk to the index of the + ** first free-list trunk page. iPrevTrunk is initially 1. + */ + rc = sqlite3PagerWrite(pPage1->pDbPage); + if( rc ) return rc; + put4byte(&pPage1->aData[36], n-1); + + /* The code within this loop is run only once if the 'searchList' variable + ** is not true. Otherwise, it runs once for each trunk-page on the + ** free-list until the page 'nearby' is located (eMode==BTALLOC_EXACT) + ** or until a page less than 'nearby' is located (eMode==BTALLOC_LT) + */ + do { + pPrevTrunk = pTrunk; + if( pPrevTrunk ){ + /* EVIDENCE-OF: R-01506-11053 The first integer on a freelist trunk page + ** is the page number of the next freelist trunk page in the list or + ** zero if this is the last freelist trunk page. */ + iTrunk = get4byte(&pPrevTrunk->aData[0]); + }else{ + /* EVIDENCE-OF: R-59841-13798 The 4-byte big-endian integer at offset 32 + ** stores the page number of the first page of the freelist, or zero if + ** the freelist is empty. */ + iTrunk = get4byte(&pPage1->aData[32]); + } + testcase( iTrunk==mxPage ); + if( iTrunk>mxPage || nSearch++ > n ){ + rc = SQLITE_CORRUPT_PGNO(pPrevTrunk ? pPrevTrunk->pgno : 1); + }else{ + rc = btreeGetUnusedPage(pBt, iTrunk, &pTrunk, 0); + } + if( rc ){ + pTrunk = 0; + goto end_allocate_page; + } + assert( pTrunk!=0 ); + assert( pTrunk->aData!=0 ); + /* EVIDENCE-OF: R-13523-04394 The second integer on a freelist trunk page + ** is the number of leaf page pointers to follow. */ + k = get4byte(&pTrunk->aData[4]); + if( k==0 && !searchList ){ + /* The trunk has no leaves and the list is not being searched. + ** So extract the trunk page itself and use it as the newly + ** allocated page */ + assert( pPrevTrunk==0 ); + rc = sqlite3PagerWrite(pTrunk->pDbPage); + if( rc ){ + goto end_allocate_page; + } + *pPgno = iTrunk; + memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4); + *ppPage = pTrunk; + pTrunk = 0; + TRACE(("ALLOCATE: %u trunk - %u free pages left\n", *pPgno, n-1)); + }else if( k>(u32)(pBt->usableSize/4 - 2) ){ + /* Value of k is out of range. Database corruption */ + rc = SQLITE_CORRUPT_PGNO(iTrunk); + goto end_allocate_page; +#ifndef SQLITE_OMIT_AUTOVACUUM + }else if( searchList + && (nearby==iTrunk || (iTrunkpDbPage); + if( rc ){ + goto end_allocate_page; + } + if( k==0 ){ + if( !pPrevTrunk ){ + memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4); + }else{ + rc = sqlite3PagerWrite(pPrevTrunk->pDbPage); + if( rc!=SQLITE_OK ){ + goto end_allocate_page; + } + memcpy(&pPrevTrunk->aData[0], &pTrunk->aData[0], 4); + } + }else{ + /* The trunk page is required by the caller but it contains + ** pointers to free-list leaves. The first leaf becomes a trunk + ** page in this case. + */ + MemPage *pNewTrunk; + Pgno iNewTrunk = get4byte(&pTrunk->aData[8]); + if( iNewTrunk>mxPage ){ + rc = SQLITE_CORRUPT_PGNO(iTrunk); + goto end_allocate_page; + } + testcase( iNewTrunk==mxPage ); + rc = btreeGetUnusedPage(pBt, iNewTrunk, &pNewTrunk, 0); + if( rc!=SQLITE_OK ){ + goto end_allocate_page; + } + rc = sqlite3PagerWrite(pNewTrunk->pDbPage); + if( rc!=SQLITE_OK ){ + releasePage(pNewTrunk); + goto end_allocate_page; + } + memcpy(&pNewTrunk->aData[0], &pTrunk->aData[0], 4); + put4byte(&pNewTrunk->aData[4], k-1); + memcpy(&pNewTrunk->aData[8], &pTrunk->aData[12], (k-1)*4); + releasePage(pNewTrunk); + if( !pPrevTrunk ){ + assert( sqlite3PagerIswriteable(pPage1->pDbPage) ); + put4byte(&pPage1->aData[32], iNewTrunk); + }else{ + rc = sqlite3PagerWrite(pPrevTrunk->pDbPage); + if( rc ){ + goto end_allocate_page; + } + put4byte(&pPrevTrunk->aData[0], iNewTrunk); + } + } + pTrunk = 0; + TRACE(("ALLOCATE: %u trunk - %u free pages left\n", *pPgno, n-1)); +#endif + }else if( k>0 ){ + /* Extract a leaf from the trunk */ + u32 closest; + Pgno iPage; + unsigned char *aData = pTrunk->aData; + if( nearby>0 ){ + u32 i; + closest = 0; + if( eMode==BTALLOC_LE ){ + for(i=0; imxPage || iPage<2 ){ + rc = SQLITE_CORRUPT_PGNO(iTrunk); + goto end_allocate_page; + } + testcase( iPage==mxPage ); + if( !searchList + || (iPage==nearby || (iPagepgno, n-1)); + rc = sqlite3PagerWrite(pTrunk->pDbPage); + if( rc ) goto end_allocate_page; + if( closestpDbPage); + if( rc!=SQLITE_OK ){ + releasePage(*ppPage); + *ppPage = 0; + } + } + searchList = 0; + } + } + releasePage(pPrevTrunk); + pPrevTrunk = 0; + }while( searchList ); + }else{ + /* There are no pages on the freelist, so append a new page to the + ** database image. + ** + ** Normally, new pages allocated by this block can be requested from the + ** pager layer with the 'no-content' flag set. This prevents the pager + ** from trying to read the pages content from disk. However, if the + ** current transaction has already run one or more incremental-vacuum + ** steps, then the page we are about to allocate may contain content + ** that is required in the event of a rollback. In this case, do + ** not set the no-content flag. This causes the pager to load and journal + ** the current page content before overwriting it. + ** + ** Note that the pager will not actually attempt to load or journal + ** content for any page that really does lie past the end of the database + ** file on disk. So the effects of disabling the no-content optimization + ** here are confined to those pages that lie between the end of the + ** database image and the end of the database file. + */ + int bNoContent = (0==IfNotOmitAV(pBt->bDoTruncate))? PAGER_GET_NOCONTENT:0; + + rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); + if( rc ) return rc; + pBt->nPage++; + if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ) pBt->nPage++; + +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum && PTRMAP_ISPAGE(pBt, pBt->nPage) ){ + /* If *pPgno refers to a pointer-map page, allocate two new pages + ** at the end of the file instead of one. The first allocated page + ** becomes a new pointer-map page, the second is used by the caller. + */ + MemPage *pPg = 0; + TRACE(("ALLOCATE: %u from end of file (pointer-map page)\n", pBt->nPage)); + assert( pBt->nPage!=PENDING_BYTE_PAGE(pBt) ); + rc = btreeGetUnusedPage(pBt, pBt->nPage, &pPg, bNoContent); + if( rc==SQLITE_OK ){ + rc = sqlite3PagerWrite(pPg->pDbPage); + releasePage(pPg); + } + if( rc ) return rc; + pBt->nPage++; + if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ){ pBt->nPage++; } + } +#endif + put4byte(28 + (u8*)pBt->pPage1->aData, pBt->nPage); + *pPgno = pBt->nPage; + + assert( *pPgno!=PENDING_BYTE_PAGE(pBt) ); + rc = btreeGetUnusedPage(pBt, *pPgno, ppPage, bNoContent); + if( rc ) return rc; + rc = sqlite3PagerWrite((*ppPage)->pDbPage); + if( rc!=SQLITE_OK ){ + releasePage(*ppPage); + *ppPage = 0; + } + TRACE(("ALLOCATE: %u from end of file\n", *pPgno)); + } + + assert( CORRUPT_DB || *pPgno!=PENDING_BYTE_PAGE(pBt) ); + +end_allocate_page: + releasePage(pTrunk); + releasePage(pPrevTrunk); + assert( rc!=SQLITE_OK || sqlite3PagerPageRefcount((*ppPage)->pDbPage)<=1 ); + assert( rc!=SQLITE_OK || (*ppPage)->isInit==0 ); + return rc; +} + +/* +** This function is used to add page iPage to the database file free-list. +** It is assumed that the page is not already a part of the free-list. +** +** The value passed as the second argument to this function is optional. +** If the caller happens to have a pointer to the MemPage object +** corresponding to page iPage handy, it may pass it as the second value. +** Otherwise, it may pass NULL. +** +** If a pointer to a MemPage object is passed as the second argument, +** its reference count is not altered by this function. +*/ +static int freePage2(BtShared *pBt, MemPage *pMemPage, Pgno iPage){ + MemPage *pTrunk = 0; /* Free-list trunk page */ + Pgno iTrunk = 0; /* Page number of free-list trunk page */ + MemPage *pPage1 = pBt->pPage1; /* Local reference to page 1 */ + MemPage *pPage; /* Page being freed. May be NULL. */ + int rc; /* Return Code */ + u32 nFree; /* Initial number of pages on free-list */ + + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( CORRUPT_DB || iPage>1 ); + assert( !pMemPage || pMemPage->pgno==iPage ); + + if( iPage<2 || iPage>pBt->nPage ){ + return SQLITE_CORRUPT_BKPT; + } + if( pMemPage ){ + pPage = pMemPage; + sqlite3PagerRef(pPage->pDbPage); + }else{ + pPage = btreePageLookup(pBt, iPage); + } + + /* Increment the free page count on pPage1 */ + rc = sqlite3PagerWrite(pPage1->pDbPage); + if( rc ) goto freepage_out; + nFree = get4byte(&pPage1->aData[36]); + put4byte(&pPage1->aData[36], nFree+1); + + if( pBt->btsFlags & BTS_SECURE_DELETE ){ + /* If the secure_delete option is enabled, then + ** always fully overwrite deleted information with zeros. + */ + if( (!pPage && ((rc = btreeGetPage(pBt, iPage, &pPage, 0))!=0) ) + || ((rc = sqlite3PagerWrite(pPage->pDbPage))!=0) + ){ + goto freepage_out; + } + memset(pPage->aData, 0, pPage->pBt->pageSize); + } + + /* If the database supports auto-vacuum, write an entry in the pointer-map + ** to indicate that the page is free. + */ + if( ISAUTOVACUUM(pBt) ){ + ptrmapPut(pBt, iPage, PTRMAP_FREEPAGE, 0, &rc); + if( rc ) goto freepage_out; + } + + /* Now manipulate the actual database free-list structure. There are two + ** possibilities. If the free-list is currently empty, or if the first + ** trunk page in the free-list is full, then this page will become a + ** new free-list trunk page. Otherwise, it will become a leaf of the + ** first trunk page in the current free-list. This block tests if it + ** is possible to add the page as a new free-list leaf. + */ + if( nFree!=0 ){ + u32 nLeaf; /* Initial number of leaf cells on trunk page */ + + iTrunk = get4byte(&pPage1->aData[32]); + if( iTrunk>btreePagecount(pBt) ){ + rc = SQLITE_CORRUPT_BKPT; + goto freepage_out; + } + rc = btreeGetPage(pBt, iTrunk, &pTrunk, 0); + if( rc!=SQLITE_OK ){ + goto freepage_out; + } + + nLeaf = get4byte(&pTrunk->aData[4]); + assert( pBt->usableSize>32 ); + if( nLeaf > (u32)pBt->usableSize/4 - 2 ){ + rc = SQLITE_CORRUPT_BKPT; + goto freepage_out; + } + if( nLeaf < (u32)pBt->usableSize/4 - 8 ){ + /* In this case there is room on the trunk page to insert the page + ** being freed as a new leaf. + ** + ** Note that the trunk page is not really full until it contains + ** usableSize/4 - 2 entries, not usableSize/4 - 8 entries as we have + ** coded. But due to a coding error in versions of SQLite prior to + ** 3.6.0, databases with freelist trunk pages holding more than + ** usableSize/4 - 8 entries will be reported as corrupt. In order + ** to maintain backwards compatibility with older versions of SQLite, + ** we will continue to restrict the number of entries to usableSize/4 - 8 + ** for now. At some point in the future (once everyone has upgraded + ** to 3.6.0 or later) we should consider fixing the conditional above + ** to read "usableSize/4-2" instead of "usableSize/4-8". + ** + ** EVIDENCE-OF: R-19920-11576 However, newer versions of SQLite still + ** avoid using the last six entries in the freelist trunk page array in + ** order that database files created by newer versions of SQLite can be + ** read by older versions of SQLite. + */ + rc = sqlite3PagerWrite(pTrunk->pDbPage); + if( rc==SQLITE_OK ){ + put4byte(&pTrunk->aData[4], nLeaf+1); + put4byte(&pTrunk->aData[8+nLeaf*4], iPage); + if( pPage && (pBt->btsFlags & BTS_SECURE_DELETE)==0 ){ + sqlite3PagerDontWrite(pPage->pDbPage); + } + rc = btreeSetHasContent(pBt, iPage); + } + TRACE(("FREE-PAGE: %u leaf on trunk page %u\n",pPage->pgno,pTrunk->pgno)); + goto freepage_out; + } + } + + /* If control flows to this point, then it was not possible to add the + ** the page being freed as a leaf page of the first trunk in the free-list. + ** Possibly because the free-list is empty, or possibly because the + ** first trunk in the free-list is full. Either way, the page being freed + ** will become the new first trunk page in the free-list. + */ + if( pPage==0 && SQLITE_OK!=(rc = btreeGetPage(pBt, iPage, &pPage, 0)) ){ + goto freepage_out; + } + rc = sqlite3PagerWrite(pPage->pDbPage); + if( rc!=SQLITE_OK ){ + goto freepage_out; + } + put4byte(pPage->aData, iTrunk); + put4byte(&pPage->aData[4], 0); + put4byte(&pPage1->aData[32], iPage); + TRACE(("FREE-PAGE: %u new trunk page replacing %u\n", pPage->pgno, iTrunk)); + +freepage_out: + if( pPage ){ + pPage->isInit = 0; + } + releasePage(pPage); + releasePage(pTrunk); + return rc; +} +static void freePage(MemPage *pPage, int *pRC){ + if( (*pRC)==SQLITE_OK ){ + *pRC = freePage2(pPage->pBt, pPage, pPage->pgno); + } +} + +/* +** Free the overflow pages associated with the given Cell. +*/ +static SQLITE_NOINLINE int clearCellOverflow( + MemPage *pPage, /* The page that contains the Cell */ + unsigned char *pCell, /* First byte of the Cell */ + CellInfo *pInfo /* Size information about the cell */ +){ + BtShared *pBt; + Pgno ovflPgno; + int rc; + int nOvfl; + u32 ovflPageSize; + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( pInfo->nLocal!=pInfo->nPayload ); + testcase( pCell + pInfo->nSize == pPage->aDataEnd ); + testcase( pCell + (pInfo->nSize-1) == pPage->aDataEnd ); + if( pCell + pInfo->nSize > pPage->aDataEnd ){ + /* Cell extends past end of page */ + return SQLITE_CORRUPT_PAGE(pPage); + } + ovflPgno = get4byte(pCell + pInfo->nSize - 4); + pBt = pPage->pBt; + assert( pBt->usableSize > 4 ); + ovflPageSize = pBt->usableSize - 4; + nOvfl = (pInfo->nPayload - pInfo->nLocal + ovflPageSize - 1)/ovflPageSize; + assert( nOvfl>0 || + (CORRUPT_DB && (pInfo->nPayload + ovflPageSize)btreePagecount(pBt) ){ + /* 0 is not a legal page number and page 1 cannot be an + ** overflow page. Therefore if ovflPgno<2 or past the end of the + ** file the database must be corrupt. */ + return SQLITE_CORRUPT_BKPT; + } + if( nOvfl ){ + rc = getOverflowPage(pBt, ovflPgno, &pOvfl, &iNext); + if( rc ) return rc; + } + + if( ( pOvfl || ((pOvfl = btreePageLookup(pBt, ovflPgno))!=0) ) + && sqlite3PagerPageRefcount(pOvfl->pDbPage)!=1 + ){ + /* There is no reason any cursor should have an outstanding reference + ** to an overflow page belonging to a cell that is being deleted/updated. + ** So if there exists more than one reference to this page, then it + ** must not really be an overflow page and the database must be corrupt. + ** It is helpful to detect this before calling freePage2(), as + ** freePage2() may zero the page contents if secure-delete mode is + ** enabled. If this 'overflow' page happens to be a page that the + ** caller is iterating through or using in some other way, this + ** can be problematic. + */ + rc = SQLITE_CORRUPT_BKPT; + }else{ + rc = freePage2(pBt, pOvfl, ovflPgno); + } + + if( pOvfl ){ + sqlite3PagerUnref(pOvfl->pDbPage); + } + if( rc ) return rc; + ovflPgno = iNext; + } + return SQLITE_OK; +} + +/* Call xParseCell to compute the size of a cell. If the cell contains +** overflow, then invoke cellClearOverflow to clear out that overflow. +** STore the result code (SQLITE_OK or some error code) in rc. +** +** Implemented as macro to force inlining for performance. +*/ +#define BTREE_CLEAR_CELL(rc, pPage, pCell, sInfo) \ + pPage->xParseCell(pPage, pCell, &sInfo); \ + if( sInfo.nLocal!=sInfo.nPayload ){ \ + rc = clearCellOverflow(pPage, pCell, &sInfo); \ + }else{ \ + rc = SQLITE_OK; \ + } + + +/* +** Create the byte sequence used to represent a cell on page pPage +** and write that byte sequence into pCell[]. Overflow pages are +** allocated and filled in as necessary. The calling procedure +** is responsible for making sure sufficient space has been allocated +** for pCell[]. +** +** Note that pCell does not necessary need to point to the pPage->aData +** area. pCell might point to some temporary storage. The cell will +** be constructed in this temporary area then copied into pPage->aData +** later. +*/ +static int fillInCell( + MemPage *pPage, /* The page that contains the cell */ + unsigned char *pCell, /* Complete text of the cell */ + const BtreePayload *pX, /* Payload with which to construct the cell */ + int *pnSize /* Write cell size here */ +){ + int nPayload; + const u8 *pSrc; + int nSrc, n, rc, mn; + int spaceLeft; + MemPage *pToRelease; + unsigned char *pPrior; + unsigned char *pPayload; + BtShared *pBt; + Pgno pgnoOvfl; + int nHeader; + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + + /* pPage is not necessarily writeable since pCell might be auxiliary + ** buffer space that is separate from the pPage buffer area */ + assert( pCellaData || pCell>=&pPage->aData[pPage->pBt->pageSize] + || sqlite3PagerIswriteable(pPage->pDbPage) ); + + /* Fill in the header. */ + nHeader = pPage->childPtrSize; + if( pPage->intKey ){ + nPayload = pX->nData + pX->nZero; + pSrc = pX->pData; + nSrc = pX->nData; + assert( pPage->intKeyLeaf ); /* fillInCell() only called for leaves */ + nHeader += putVarint32(&pCell[nHeader], nPayload); + nHeader += putVarint(&pCell[nHeader], *(u64*)&pX->nKey); + }else{ + assert( pX->nKey<=0x7fffffff && pX->pKey!=0 ); + nSrc = nPayload = (int)pX->nKey; + pSrc = pX->pKey; + nHeader += putVarint32(&pCell[nHeader], nPayload); + } + + /* Fill in the payload */ + pPayload = &pCell[nHeader]; + if( nPayload<=pPage->maxLocal ){ + /* This is the common case where everything fits on the btree page + ** and no overflow pages are required. */ + n = nHeader + nPayload; + testcase( n==3 ); + testcase( n==4 ); + if( n<4 ) n = 4; + *pnSize = n; + assert( nSrc<=nPayload ); + testcase( nSrcminLocal; + n = mn + (nPayload - mn) % (pPage->pBt->usableSize - 4); + testcase( n==pPage->maxLocal ); + testcase( n==pPage->maxLocal+1 ); + if( n > pPage->maxLocal ) n = mn; + spaceLeft = n; + *pnSize = n + nHeader + 4; + pPrior = &pCell[nHeader+n]; + pToRelease = 0; + pgnoOvfl = 0; + pBt = pPage->pBt; + + /* At this point variables should be set as follows: + ** + ** nPayload Total payload size in bytes + ** pPayload Begin writing payload here + ** spaceLeft Space available at pPayload. If nPayload>spaceLeft, + ** that means content must spill into overflow pages. + ** *pnSize Size of the local cell (not counting overflow pages) + ** pPrior Where to write the pgno of the first overflow page + ** + ** Use a call to btreeParseCellPtr() to verify that the values above + ** were computed correctly. + */ +#ifdef SQLITE_DEBUG + { + CellInfo info; + pPage->xParseCell(pPage, pCell, &info); + assert( nHeader==(int)(info.pPayload - pCell) ); + assert( info.nKey==pX->nKey ); + assert( *pnSize == info.nSize ); + assert( spaceLeft == info.nLocal ); + } +#endif + + /* Write the payload into the local Cell and any extra into overflow pages */ + while( 1 ){ + n = nPayload; + if( n>spaceLeft ) n = spaceLeft; + + /* If pToRelease is not zero than pPayload points into the data area + ** of pToRelease. Make sure pToRelease is still writeable. */ + assert( pToRelease==0 || sqlite3PagerIswriteable(pToRelease->pDbPage) ); + + /* If pPayload is part of the data area of pPage, then make sure pPage + ** is still writeable */ + assert( pPayloadaData || pPayload>=&pPage->aData[pBt->pageSize] + || sqlite3PagerIswriteable(pPage->pDbPage) ); + + if( nSrc>=n ){ + memcpy(pPayload, pSrc, n); + }else if( nSrc>0 ){ + n = nSrc; + memcpy(pPayload, pSrc, n); + }else{ + memset(pPayload, 0, n); + } + nPayload -= n; + if( nPayload<=0 ) break; + pPayload += n; + pSrc += n; + nSrc -= n; + spaceLeft -= n; + if( spaceLeft==0 ){ + MemPage *pOvfl = 0; +#ifndef SQLITE_OMIT_AUTOVACUUM + Pgno pgnoPtrmap = pgnoOvfl; /* Overflow page pointer-map entry page */ + if( pBt->autoVacuum ){ + do{ + pgnoOvfl++; + } while( + PTRMAP_ISPAGE(pBt, pgnoOvfl) || pgnoOvfl==PENDING_BYTE_PAGE(pBt) + ); + } +#endif + rc = allocateBtreePage(pBt, &pOvfl, &pgnoOvfl, pgnoOvfl, 0); +#ifndef SQLITE_OMIT_AUTOVACUUM + /* If the database supports auto-vacuum, and the second or subsequent + ** overflow page is being allocated, add an entry to the pointer-map + ** for that page now. + ** + ** If this is the first overflow page, then write a partial entry + ** to the pointer-map. If we write nothing to this pointer-map slot, + ** then the optimistic overflow chain processing in clearCell() + ** may misinterpret the uninitialized values and delete the + ** wrong pages from the database. + */ + if( pBt->autoVacuum && rc==SQLITE_OK ){ + u8 eType = (pgnoPtrmap?PTRMAP_OVERFLOW2:PTRMAP_OVERFLOW1); + ptrmapPut(pBt, pgnoOvfl, eType, pgnoPtrmap, &rc); + if( rc ){ + releasePage(pOvfl); + } + } +#endif + if( rc ){ + releasePage(pToRelease); + return rc; + } + + /* If pToRelease is not zero than pPrior points into the data area + ** of pToRelease. Make sure pToRelease is still writeable. */ + assert( pToRelease==0 || sqlite3PagerIswriteable(pToRelease->pDbPage) ); + + /* If pPrior is part of the data area of pPage, then make sure pPage + ** is still writeable */ + assert( pPrioraData || pPrior>=&pPage->aData[pBt->pageSize] + || sqlite3PagerIswriteable(pPage->pDbPage) ); + + put4byte(pPrior, pgnoOvfl); + releasePage(pToRelease); + pToRelease = pOvfl; + pPrior = pOvfl->aData; + put4byte(pPrior, 0); + pPayload = &pOvfl->aData[4]; + spaceLeft = pBt->usableSize - 4; + } + } + releasePage(pToRelease); + return SQLITE_OK; +} + +/* +** Remove the i-th cell from pPage. This routine effects pPage only. +** The cell content is not freed or deallocated. It is assumed that +** the cell content has been copied someplace else. This routine just +** removes the reference to the cell from pPage. +** +** "sz" must be the number of bytes in the cell. +*/ +static void dropCell(MemPage *pPage, int idx, int sz, int *pRC){ + u32 pc; /* Offset to cell content of cell being deleted */ + u8 *data; /* pPage->aData */ + u8 *ptr; /* Used to move bytes around within data[] */ + int rc; /* The return code */ + int hdr; /* Beginning of the header. 0 most pages. 100 page 1 */ + + if( *pRC ) return; + assert( idx>=0 ); + assert( idxnCell ); + assert( CORRUPT_DB || sz==cellSize(pPage, idx) ); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( pPage->nFree>=0 ); + data = pPage->aData; + ptr = &pPage->aCellIdx[2*idx]; + assert( pPage->pBt->usableSize > (u32)(ptr-data) ); + pc = get2byte(ptr); + hdr = pPage->hdrOffset; + testcase( pc==(u32)get2byte(&data[hdr+5]) ); + testcase( pc+sz==pPage->pBt->usableSize ); + if( pc+sz > pPage->pBt->usableSize ){ + *pRC = SQLITE_CORRUPT_BKPT; + return; + } + rc = freeSpace(pPage, pc, sz); + if( rc ){ + *pRC = rc; + return; + } + pPage->nCell--; + if( pPage->nCell==0 ){ + memset(&data[hdr+1], 0, 4); + data[hdr+7] = 0; + put2byte(&data[hdr+5], pPage->pBt->usableSize); + pPage->nFree = pPage->pBt->usableSize - pPage->hdrOffset + - pPage->childPtrSize - 8; + }else{ + memmove(ptr, ptr+2, 2*(pPage->nCell - idx)); + put2byte(&data[hdr+3], pPage->nCell); + pPage->nFree += 2; + } +} + +/* +** Insert a new cell on pPage at cell index "i". pCell points to the +** content of the cell. +** +** If the cell content will fit on the page, then put it there. If it +** will not fit, then make a copy of the cell content into pTemp if +** pTemp is not null. Regardless of pTemp, allocate a new entry +** in pPage->apOvfl[] and make it point to the cell content (either +** in pTemp or the original pCell) and also record its index. +** Allocating a new entry in pPage->aCell[] implies that +** pPage->nOverflow is incremented. +** +** The insertCellFast() routine below works exactly the same as +** insertCell() except that it lacks the pTemp and iChild parameters +** which are assumed zero. Other than that, the two routines are the +** same. +** +** Fixes or enhancements to this routine should be reflected in +** insertCellFast()! +*/ +static int insertCell( + MemPage *pPage, /* Page into which we are copying */ + int i, /* New cell becomes the i-th cell of the page */ + u8 *pCell, /* Content of the new cell */ + int sz, /* Bytes of content in pCell */ + u8 *pTemp, /* Temp storage space for pCell, if needed */ + Pgno iChild /* If non-zero, replace first 4 bytes with this value */ +){ + int idx = 0; /* Where to write new cell content in data[] */ + int j; /* Loop counter */ + u8 *data; /* The content of the whole page */ + u8 *pIns; /* The point in pPage->aCellIdx[] where no cell inserted */ + + assert( i>=0 && i<=pPage->nCell+pPage->nOverflow ); + assert( MX_CELL(pPage->pBt)<=10921 ); + assert( pPage->nCell<=MX_CELL(pPage->pBt) || CORRUPT_DB ); + assert( pPage->nOverflow<=ArraySize(pPage->apOvfl) ); + assert( ArraySize(pPage->apOvfl)==ArraySize(pPage->aiOvfl) ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( sz==pPage->xCellSize(pPage, pCell) || CORRUPT_DB ); + assert( pPage->nFree>=0 ); + assert( iChild>0 ); + if( pPage->nOverflow || sz+2>pPage->nFree ){ + if( pTemp ){ + memcpy(pTemp, pCell, sz); + pCell = pTemp; + } + put4byte(pCell, iChild); + j = pPage->nOverflow++; + /* Comparison against ArraySize-1 since we hold back one extra slot + ** as a contingency. In other words, never need more than 3 overflow + ** slots but 4 are allocated, just to be safe. */ + assert( j < ArraySize(pPage->apOvfl)-1 ); + pPage->apOvfl[j] = pCell; + pPage->aiOvfl[j] = (u16)i; + + /* When multiple overflows occur, they are always sequential and in + ** sorted order. This invariants arise because multiple overflows can + ** only occur when inserting divider cells into the parent page during + ** balancing, and the dividers are adjacent and sorted. + */ + assert( j==0 || pPage->aiOvfl[j-1]<(u16)i ); /* Overflows in sorted order */ + assert( j==0 || i==pPage->aiOvfl[j-1]+1 ); /* Overflows are sequential */ + }else{ + int rc = sqlite3PagerWrite(pPage->pDbPage); + if( NEVER(rc!=SQLITE_OK) ){ + return rc; + } + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + data = pPage->aData; + assert( &data[pPage->cellOffset]==pPage->aCellIdx ); + rc = allocateSpace(pPage, sz, &idx); + if( rc ){ return rc; } + /* The allocateSpace() routine guarantees the following properties + ** if it returns successfully */ + assert( idx >= 0 ); + assert( idx >= pPage->cellOffset+2*pPage->nCell+2 || CORRUPT_DB ); + assert( idx+sz <= (int)pPage->pBt->usableSize ); + pPage->nFree -= (u16)(2 + sz); + /* In a corrupt database where an entry in the cell index section of + ** a btree page has a value of 3 or less, the pCell value might point + ** as many as 4 bytes in front of the start of the aData buffer for + ** the source page. Make sure this does not cause problems by not + ** reading the first 4 bytes */ + memcpy(&data[idx+4], pCell+4, sz-4); + put4byte(&data[idx], iChild); + pIns = pPage->aCellIdx + i*2; + memmove(pIns+2, pIns, 2*(pPage->nCell - i)); + put2byte(pIns, idx); + pPage->nCell++; + /* increment the cell count */ + if( (++data[pPage->hdrOffset+4])==0 ) data[pPage->hdrOffset+3]++; + assert( get2byte(&data[pPage->hdrOffset+3])==pPage->nCell || CORRUPT_DB ); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pPage->pBt->autoVacuum ){ + int rc2 = SQLITE_OK; + /* The cell may contain a pointer to an overflow page. If so, write + ** the entry for the overflow page into the pointer map. + */ + ptrmapPutOvflPtr(pPage, pPage, pCell, &rc2); + if( rc2 ) return rc2; + } +#endif + } + return SQLITE_OK; +} + +/* +** This variant of insertCell() assumes that the pTemp and iChild +** parameters are both zero. Use this variant in sqlite3BtreeInsert() +** for performance improvement, and also so that this variant is only +** called from that one place, and is thus inlined, and thus runs must +** faster. +** +** Fixes or enhancements to this routine should be reflected into +** the insertCell() routine. +*/ +static int insertCellFast( + MemPage *pPage, /* Page into which we are copying */ + int i, /* New cell becomes the i-th cell of the page */ + u8 *pCell, /* Content of the new cell */ + int sz /* Bytes of content in pCell */ +){ + int idx = 0; /* Where to write new cell content in data[] */ + int j; /* Loop counter */ + u8 *data; /* The content of the whole page */ + u8 *pIns; /* The point in pPage->aCellIdx[] where no cell inserted */ + + assert( i>=0 && i<=pPage->nCell+pPage->nOverflow ); + assert( MX_CELL(pPage->pBt)<=10921 ); + assert( pPage->nCell<=MX_CELL(pPage->pBt) || CORRUPT_DB ); + assert( pPage->nOverflow<=ArraySize(pPage->apOvfl) ); + assert( ArraySize(pPage->apOvfl)==ArraySize(pPage->aiOvfl) ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( sz==pPage->xCellSize(pPage, pCell) || CORRUPT_DB ); + assert( pPage->nFree>=0 ); + assert( pPage->nOverflow==0 ); + if( sz+2>pPage->nFree ){ + j = pPage->nOverflow++; + /* Comparison against ArraySize-1 since we hold back one extra slot + ** as a contingency. In other words, never need more than 3 overflow + ** slots but 4 are allocated, just to be safe. */ + assert( j < ArraySize(pPage->apOvfl)-1 ); + pPage->apOvfl[j] = pCell; + pPage->aiOvfl[j] = (u16)i; + + /* When multiple overflows occur, they are always sequential and in + ** sorted order. This invariants arise because multiple overflows can + ** only occur when inserting divider cells into the parent page during + ** balancing, and the dividers are adjacent and sorted. + */ + assert( j==0 || pPage->aiOvfl[j-1]<(u16)i ); /* Overflows in sorted order */ + assert( j==0 || i==pPage->aiOvfl[j-1]+1 ); /* Overflows are sequential */ + }else{ + int rc = sqlite3PagerWrite(pPage->pDbPage); + if( rc!=SQLITE_OK ){ + return rc; + } + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + data = pPage->aData; + assert( &data[pPage->cellOffset]==pPage->aCellIdx ); + rc = allocateSpace(pPage, sz, &idx); + if( rc ){ return rc; } + /* The allocateSpace() routine guarantees the following properties + ** if it returns successfully */ + assert( idx >= 0 ); + assert( idx >= pPage->cellOffset+2*pPage->nCell+2 || CORRUPT_DB ); + assert( idx+sz <= (int)pPage->pBt->usableSize ); + pPage->nFree -= (u16)(2 + sz); + memcpy(&data[idx], pCell, sz); + pIns = pPage->aCellIdx + i*2; + memmove(pIns+2, pIns, 2*(pPage->nCell - i)); + put2byte(pIns, idx); + pPage->nCell++; + /* increment the cell count */ + if( (++data[pPage->hdrOffset+4])==0 ) data[pPage->hdrOffset+3]++; + assert( get2byte(&data[pPage->hdrOffset+3])==pPage->nCell || CORRUPT_DB ); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pPage->pBt->autoVacuum ){ + int rc2 = SQLITE_OK; + /* The cell may contain a pointer to an overflow page. If so, write + ** the entry for the overflow page into the pointer map. + */ + ptrmapPutOvflPtr(pPage, pPage, pCell, &rc2); + if( rc2 ) return rc2; + } +#endif + } + return SQLITE_OK; +} + +/* +** The following parameters determine how many adjacent pages get involved +** in a balancing operation. NN is the number of neighbors on either side +** of the page that participate in the balancing operation. NB is the +** total number of pages that participate, including the target page and +** NN neighbors on either side. +** +** The minimum value of NN is 1 (of course). Increasing NN above 1 +** (to 2 or 3) gives a modest improvement in SELECT and DELETE performance +** in exchange for a larger degradation in INSERT and UPDATE performance. +** The value of NN appears to give the best results overall. +** +** (Later:) The description above makes it seem as if these values are +** tunable - as if you could change them and recompile and it would all work. +** But that is unlikely. NB has been 3 since the inception of SQLite and +** we have never tested any other value. +*/ +#define NN 1 /* Number of neighbors on either side of pPage */ +#define NB 3 /* (NN*2+1): Total pages involved in the balance */ + +/* +** A CellArray object contains a cache of pointers and sizes for a +** consecutive sequence of cells that might be held on multiple pages. +** +** The cells in this array are the divider cell or cells from the pParent +** page plus up to three child pages. There are a total of nCell cells. +** +** pRef is a pointer to one of the pages that contributes cells. This is +** used to access information such as MemPage.intKey and MemPage.pBt->pageSize +** which should be common to all pages that contribute cells to this array. +** +** apCell[] and szCell[] hold, respectively, pointers to the start of each +** cell and the size of each cell. Some of the apCell[] pointers might refer +** to overflow cells. In other words, some apCel[] pointers might not point +** to content area of the pages. +** +** A szCell[] of zero means the size of that cell has not yet been computed. +** +** The cells come from as many as four different pages: +** +** ----------- +** | Parent | +** ----------- +** / | \ +** / | \ +** --------- --------- --------- +** |Child-1| |Child-2| |Child-3| +** --------- --------- --------- +** +** The order of cells is in the array is for an index btree is: +** +** 1. All cells from Child-1 in order +** 2. The first divider cell from Parent +** 3. All cells from Child-2 in order +** 4. The second divider cell from Parent +** 5. All cells from Child-3 in order +** +** For a table-btree (with rowids) the items 2 and 4 are empty because +** content exists only in leaves and there are no divider cells. +** +** For an index btree, the apEnd[] array holds pointer to the end of page +** for Child-1, the Parent, Child-2, the Parent (again), and Child-3, +** respectively. The ixNx[] array holds the number of cells contained in +** each of these 5 stages, and all stages to the left. Hence: +** +** ixNx[0] = Number of cells in Child-1. +** ixNx[1] = Number of cells in Child-1 plus 1 for first divider. +** ixNx[2] = Number of cells in Child-1 and Child-2 + 1 for 1st divider. +** ixNx[3] = Number of cells in Child-1 and Child-2 + both divider cells +** ixNx[4] = Total number of cells. +** +** For a table-btree, the concept is similar, except only apEnd[0]..apEnd[2] +** are used and they point to the leaf pages only, and the ixNx value are: +** +** ixNx[0] = Number of cells in Child-1. +** ixNx[1] = Number of cells in Child-1 and Child-2. +** ixNx[2] = Total number of cells. +** +** Sometimes when deleting, a child page can have zero cells. In those +** cases, ixNx[] entries with higher indexes, and the corresponding apEnd[] +** entries, shift down. The end result is that each ixNx[] entry should +** be larger than the previous +*/ +typedef struct CellArray CellArray; +struct CellArray { + int nCell; /* Number of cells in apCell[] */ + MemPage *pRef; /* Reference page */ + u8 **apCell; /* All cells begin balanced */ + u16 *szCell; /* Local size of all cells in apCell[] */ + u8 *apEnd[NB*2]; /* MemPage.aDataEnd values */ + int ixNx[NB*2]; /* Index of at which we move to the next apEnd[] */ +}; + +/* +** Make sure the cell sizes at idx, idx+1, ..., idx+N-1 have been +** computed. +*/ +static void populateCellCache(CellArray *p, int idx, int N){ + MemPage *pRef = p->pRef; + u16 *szCell = p->szCell; + assert( idx>=0 && idx+N<=p->nCell ); + while( N>0 ){ + assert( p->apCell[idx]!=0 ); + if( szCell[idx]==0 ){ + szCell[idx] = pRef->xCellSize(pRef, p->apCell[idx]); + }else{ + assert( CORRUPT_DB || + szCell[idx]==pRef->xCellSize(pRef, p->apCell[idx]) ); + } + idx++; + N--; + } +} + +/* +** Return the size of the Nth element of the cell array +*/ +static SQLITE_NOINLINE u16 computeCellSize(CellArray *p, int N){ + assert( N>=0 && NnCell ); + assert( p->szCell[N]==0 ); + p->szCell[N] = p->pRef->xCellSize(p->pRef, p->apCell[N]); + return p->szCell[N]; +} +static u16 cachedCellSize(CellArray *p, int N){ + assert( N>=0 && NnCell ); + if( p->szCell[N] ) return p->szCell[N]; + return computeCellSize(p, N); +} + +/* +** Array apCell[] contains pointers to nCell b-tree page cells. The +** szCell[] array contains the size in bytes of each cell. This function +** replaces the current contents of page pPg with the contents of the cell +** array. +** +** Some of the cells in apCell[] may currently be stored in pPg. This +** function works around problems caused by this by making a copy of any +** such cells before overwriting the page data. +** +** The MemPage.nFree field is invalidated by this function. It is the +** responsibility of the caller to set it correctly. +*/ +static int rebuildPage( + CellArray *pCArray, /* Content to be added to page pPg */ + int iFirst, /* First cell in pCArray to use */ + int nCell, /* Final number of cells on page */ + MemPage *pPg /* The page to be reconstructed */ +){ + const int hdr = pPg->hdrOffset; /* Offset of header on pPg */ + u8 * const aData = pPg->aData; /* Pointer to data for pPg */ + const int usableSize = pPg->pBt->usableSize; + u8 * const pEnd = &aData[usableSize]; + int i = iFirst; /* Which cell to copy from pCArray*/ + u32 j; /* Start of cell content area */ + int iEnd = i+nCell; /* Loop terminator */ + u8 *pCellptr = pPg->aCellIdx; + u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager); + u8 *pData; + int k; /* Current slot in pCArray->apEnd[] */ + u8 *pSrcEnd; /* Current pCArray->apEnd[k] value */ + + assert( i(u32)usableSize) ){ j = 0; } + memcpy(&pTmp[j], &aData[j], usableSize - j); + + for(k=0; pCArray->ixNx[k]<=i && ALWAYS(kapEnd[k]; + + pData = pEnd; + while( 1/*exit by break*/ ){ + u8 *pCell = pCArray->apCell[i]; + u16 sz = pCArray->szCell[i]; + assert( sz>0 ); + if( SQLITE_WITHIN(pCell,aData+j,pEnd) ){ + if( ((uptr)(pCell+sz))>(uptr)pEnd ) return SQLITE_CORRUPT_BKPT; + pCell = &pTmp[pCell - aData]; + }else if( (uptr)(pCell+sz)>(uptr)pSrcEnd + && (uptr)(pCell)<(uptr)pSrcEnd + ){ + return SQLITE_CORRUPT_BKPT; + } + + pData -= sz; + put2byte(pCellptr, (pData - aData)); + pCellptr += 2; + if( pData < pCellptr ) return SQLITE_CORRUPT_BKPT; + memmove(pData, pCell, sz); + assert( sz==pPg->xCellSize(pPg, pCell) || CORRUPT_DB ); + i++; + if( i>=iEnd ) break; + if( pCArray->ixNx[k]<=i ){ + k++; + pSrcEnd = pCArray->apEnd[k]; + } + } + + /* The pPg->nFree field is now set incorrectly. The caller will fix it. */ + pPg->nCell = nCell; + pPg->nOverflow = 0; + + put2byte(&aData[hdr+1], 0); + put2byte(&aData[hdr+3], pPg->nCell); + put2byte(&aData[hdr+5], pData - aData); + aData[hdr+7] = 0x00; + return SQLITE_OK; +} + +/* +** The pCArray objects contains pointers to b-tree cells and the cell sizes. +** This function attempts to add the cells stored in the array to page pPg. +** If it cannot (because the page needs to be defragmented before the cells +** will fit), non-zero is returned. Otherwise, if the cells are added +** successfully, zero is returned. +** +** Argument pCellptr points to the first entry in the cell-pointer array +** (part of page pPg) to populate. After cell apCell[0] is written to the +** page body, a 16-bit offset is written to pCellptr. And so on, for each +** cell in the array. It is the responsibility of the caller to ensure +** that it is safe to overwrite this part of the cell-pointer array. +** +** When this function is called, *ppData points to the start of the +** content area on page pPg. If the size of the content area is extended, +** *ppData is updated to point to the new start of the content area +** before returning. +** +** Finally, argument pBegin points to the byte immediately following the +** end of the space required by this page for the cell-pointer area (for +** all cells - not just those inserted by the current call). If the content +** area must be extended to before this point in order to accomodate all +** cells in apCell[], then the cells do not fit and non-zero is returned. +*/ +static int pageInsertArray( + MemPage *pPg, /* Page to add cells to */ + u8 *pBegin, /* End of cell-pointer array */ + u8 **ppData, /* IN/OUT: Page content-area pointer */ + u8 *pCellptr, /* Pointer to cell-pointer area */ + int iFirst, /* Index of first cell to add */ + int nCell, /* Number of cells to add to pPg */ + CellArray *pCArray /* Array of cells */ +){ + int i = iFirst; /* Loop counter - cell index to insert */ + u8 *aData = pPg->aData; /* Complete page */ + u8 *pData = *ppData; /* Content area. A subset of aData[] */ + int iEnd = iFirst + nCell; /* End of loop. One past last cell to ins */ + int k; /* Current slot in pCArray->apEnd[] */ + u8 *pEnd; /* Maximum extent of cell data */ + assert( CORRUPT_DB || pPg->hdrOffset==0 ); /* Never called on page 1 */ + if( iEnd<=iFirst ) return 0; + for(k=0; pCArray->ixNx[k]<=i && ALWAYS(kapEnd[k]; + while( 1 /*Exit by break*/ ){ + int sz, rc; + u8 *pSlot; + assert( pCArray->szCell[i]!=0 ); + sz = pCArray->szCell[i]; + if( (aData[1]==0 && aData[2]==0) || (pSlot = pageFindSlot(pPg,sz,&rc))==0 ){ + if( (pData - pBegin)apCell[i] will never overlap on a well-formed + ** database. But they might for a corrupt database. Hence use memmove() + ** since memcpy() sends SIGABORT with overlapping buffers on OpenBSD */ + assert( (pSlot+sz)<=pCArray->apCell[i] + || pSlot>=(pCArray->apCell[i]+sz) + || CORRUPT_DB ); + if( (uptr)(pCArray->apCell[i]+sz)>(uptr)pEnd + && (uptr)(pCArray->apCell[i])<(uptr)pEnd + ){ + assert( CORRUPT_DB ); + (void)SQLITE_CORRUPT_BKPT; + return 1; + } + memmove(pSlot, pCArray->apCell[i], sz); + put2byte(pCellptr, (pSlot - aData)); + pCellptr += 2; + i++; + if( i>=iEnd ) break; + if( pCArray->ixNx[k]<=i ){ + k++; + pEnd = pCArray->apEnd[k]; + } + } + *ppData = pData; + return 0; +} + +/* +** The pCArray object contains pointers to b-tree cells and their sizes. +** +** This function adds the space associated with each cell in the array +** that is currently stored within the body of pPg to the pPg free-list. +** The cell-pointers and other fields of the page are not updated. +** +** This function returns the total number of cells added to the free-list. +*/ +static int pageFreeArray( + MemPage *pPg, /* Page to edit */ + int iFirst, /* First cell to delete */ + int nCell, /* Cells to delete */ + CellArray *pCArray /* Array of cells */ +){ + u8 * const aData = pPg->aData; + u8 * const pEnd = &aData[pPg->pBt->usableSize]; + u8 * const pStart = &aData[pPg->hdrOffset + 8 + pPg->childPtrSize]; + int nRet = 0; + int i, j; + int iEnd = iFirst + nCell; + int nFree = 0; + int aOfst[10]; + int aAfter[10]; + + for(i=iFirst; iapCell[i]; + if( SQLITE_WITHIN(pCell, pStart, pEnd) ){ + int sz; + int iAfter; + int iOfst; + /* No need to use cachedCellSize() here. The sizes of all cells that + ** are to be freed have already been computing while deciding which + ** cells need freeing */ + sz = pCArray->szCell[i]; assert( sz>0 ); + iOfst = (u16)(pCell - aData); + iAfter = iOfst+sz; + for(j=0; j=nFree ){ + if( nFree>=(int)(sizeof(aOfst)/sizeof(aOfst[0])) ){ + for(j=0; jpEnd ) return 0; + nFree++; + } + nRet++; + } + } + for(j=0; jnCell cells starting with +** pCArray->apCell[iOld]. After balancing, this page should hold nNew cells +** starting at apCell[iNew]. +** +** This routine makes the necessary adjustments to pPg so that it contains +** the correct cells after being balanced. +** +** The pPg->nFree field is invalid when this function returns. It is the +** responsibility of the caller to set it correctly. +*/ +static int editPage( + MemPage *pPg, /* Edit this page */ + int iOld, /* Index of first cell currently on page */ + int iNew, /* Index of new first cell on page */ + int nNew, /* Final number of cells on page */ + CellArray *pCArray /* Array of cells and sizes */ +){ + u8 * const aData = pPg->aData; + const int hdr = pPg->hdrOffset; + u8 *pBegin = &pPg->aCellIdx[nNew * 2]; + int nCell = pPg->nCell; /* Cells stored on pPg */ + u8 *pData; + u8 *pCellptr; + int i; + int iOldEnd = iOld + pPg->nCell + pPg->nOverflow; + int iNewEnd = iNew + nNew; + +#ifdef SQLITE_DEBUG + u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager); + memcpy(pTmp, aData, pPg->pBt->usableSize); +#endif + + /* Remove cells from the start and end of the page */ + assert( nCell>=0 ); + if( iOldnCell) ) return SQLITE_CORRUPT_BKPT; + memmove(pPg->aCellIdx, &pPg->aCellIdx[nShift*2], nCell*2); + nCell -= nShift; + } + if( iNewEnd < iOldEnd ){ + int nTail = pageFreeArray(pPg, iNewEnd, iOldEnd - iNewEnd, pCArray); + assert( nCell>=nTail ); + nCell -= nTail; + } + + pData = &aData[get2byte(&aData[hdr+5])]; + if( pDatapPg->aDataEnd) ) goto editpage_fail; + + /* Add cells to the start of the page */ + if( iNew=0 ); + pCellptr = pPg->aCellIdx; + memmove(&pCellptr[nAdd*2], pCellptr, nCell*2); + if( pageInsertArray( + pPg, pBegin, &pData, pCellptr, + iNew, nAdd, pCArray + ) ) goto editpage_fail; + nCell += nAdd; + } + + /* Add any overflow cells */ + for(i=0; inOverflow; i++){ + int iCell = (iOld + pPg->aiOvfl[i]) - iNew; + if( iCell>=0 && iCellaCellIdx[iCell * 2]; + if( nCell>iCell ){ + memmove(&pCellptr[2], pCellptr, (nCell - iCell) * 2); + } + nCell++; + cachedCellSize(pCArray, iCell+iNew); + if( pageInsertArray( + pPg, pBegin, &pData, pCellptr, + iCell+iNew, 1, pCArray + ) ) goto editpage_fail; + } + } + + /* Append cells to the end of the page */ + assert( nCell>=0 ); + pCellptr = &pPg->aCellIdx[nCell*2]; + if( pageInsertArray( + pPg, pBegin, &pData, pCellptr, + iNew+nCell, nNew-nCell, pCArray + ) ) goto editpage_fail; + + pPg->nCell = nNew; + pPg->nOverflow = 0; + + put2byte(&aData[hdr+3], pPg->nCell); + put2byte(&aData[hdr+5], pData - aData); + +#ifdef SQLITE_DEBUG + for(i=0; iapCell[i+iNew]; + int iOff = get2byteAligned(&pPg->aCellIdx[i*2]); + if( SQLITE_WITHIN(pCell, aData, &aData[pPg->pBt->usableSize]) ){ + pCell = &pTmp[pCell - aData]; + } + assert( 0==memcmp(pCell, &aData[iOff], + pCArray->pRef->xCellSize(pCArray->pRef, pCArray->apCell[i+iNew])) ); + } +#endif + + return SQLITE_OK; + editpage_fail: + /* Unable to edit this page. Rebuild it from scratch instead. */ + populateCellCache(pCArray, iNew, nNew); + return rebuildPage(pCArray, iNew, nNew, pPg); +} + + +#ifndef SQLITE_OMIT_QUICKBALANCE +/* +** This version of balance() handles the common special case where +** a new entry is being inserted on the extreme right-end of the +** tree, in other words, when the new entry will become the largest +** entry in the tree. +** +** Instead of trying to balance the 3 right-most leaf pages, just add +** a new page to the right-hand side and put the one new entry in +** that page. This leaves the right side of the tree somewhat +** unbalanced. But odds are that we will be inserting new entries +** at the end soon afterwards so the nearly empty page will quickly +** fill up. On average. +** +** pPage is the leaf page which is the right-most page in the tree. +** pParent is its parent. pPage must have a single overflow entry +** which is also the right-most entry on the page. +** +** The pSpace buffer is used to store a temporary copy of the divider +** cell that will be inserted into pParent. Such a cell consists of a 4 +** byte page number followed by a variable length integer. In other +** words, at most 13 bytes. Hence the pSpace buffer must be at +** least 13 bytes in size. +*/ +static int balance_quick(MemPage *pParent, MemPage *pPage, u8 *pSpace){ + BtShared *const pBt = pPage->pBt; /* B-Tree Database */ + MemPage *pNew; /* Newly allocated page */ + int rc; /* Return Code */ + Pgno pgnoNew; /* Page number of pNew */ + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( sqlite3PagerIswriteable(pParent->pDbPage) ); + assert( pPage->nOverflow==1 ); + + if( pPage->nCell==0 ) return SQLITE_CORRUPT_BKPT; /* dbfuzz001.test */ + assert( pPage->nFree>=0 ); + assert( pParent->nFree>=0 ); + + /* Allocate a new page. This page will become the right-sibling of + ** pPage. Make the parent page writable, so that the new divider cell + ** may be inserted. If both these operations are successful, proceed. + */ + rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0); + + if( rc==SQLITE_OK ){ + + u8 *pOut = &pSpace[4]; + u8 *pCell = pPage->apOvfl[0]; + u16 szCell = pPage->xCellSize(pPage, pCell); + u8 *pStop; + CellArray b; + + assert( sqlite3PagerIswriteable(pNew->pDbPage) ); + assert( CORRUPT_DB || pPage->aData[0]==(PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF) ); + zeroPage(pNew, PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF); + b.nCell = 1; + b.pRef = pPage; + b.apCell = &pCell; + b.szCell = &szCell; + b.apEnd[0] = pPage->aDataEnd; + b.ixNx[0] = 2; + rc = rebuildPage(&b, 0, 1, pNew); + if( NEVER(rc) ){ + releasePage(pNew); + return rc; + } + pNew->nFree = pBt->usableSize - pNew->cellOffset - 2 - szCell; + + /* If this is an auto-vacuum database, update the pointer map + ** with entries for the new page, and any pointer from the + ** cell on the page to an overflow page. If either of these + ** operations fails, the return code is set, but the contents + ** of the parent page are still manipulated by thh code below. + ** That is Ok, at this point the parent page is guaranteed to + ** be marked as dirty. Returning an error code will cause a + ** rollback, undoing any changes made to the parent page. + */ + if( ISAUTOVACUUM(pBt) ){ + ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno, &rc); + if( szCell>pNew->minLocal ){ + ptrmapPutOvflPtr(pNew, pNew, pCell, &rc); + } + } + + /* Create a divider cell to insert into pParent. The divider cell + ** consists of a 4-byte page number (the page number of pPage) and + ** a variable length key value (which must be the same value as the + ** largest key on pPage). + ** + ** To find the largest key value on pPage, first find the right-most + ** cell on pPage. The first two fields of this cell are the + ** record-length (a variable length integer at most 32-bits in size) + ** and the key value (a variable length integer, may have any value). + ** The first of the while(...) loops below skips over the record-length + ** field. The second while(...) loop copies the key value from the + ** cell on pPage into the pSpace buffer. + */ + pCell = findCell(pPage, pPage->nCell-1); + pStop = &pCell[9]; + while( (*(pCell++)&0x80) && pCellnCell, pSpace, (int)(pOut-pSpace), + 0, pPage->pgno); + } + + /* Set the right-child pointer of pParent to point to the new page. */ + put4byte(&pParent->aData[pParent->hdrOffset+8], pgnoNew); + + /* Release the reference to the new page. */ + releasePage(pNew); + } + + return rc; +} +#endif /* SQLITE_OMIT_QUICKBALANCE */ + +#if 0 +/* +** This function does not contribute anything to the operation of SQLite. +** it is sometimes activated temporarily while debugging code responsible +** for setting pointer-map entries. +*/ +static int ptrmapCheckPages(MemPage **apPage, int nPage){ + int i, j; + for(i=0; ipBt; + assert( pPage->isInit ); + + for(j=0; jnCell; j++){ + CellInfo info; + u8 *z; + + z = findCell(pPage, j); + pPage->xParseCell(pPage, z, &info); + if( info.nLocalpgno && e==PTRMAP_OVERFLOW1 ); + } + if( !pPage->leaf ){ + Pgno child = get4byte(z); + ptrmapGet(pBt, child, &e, &n); + assert( n==pPage->pgno && e==PTRMAP_BTREE ); + } + } + if( !pPage->leaf ){ + Pgno child = get4byte(&pPage->aData[pPage->hdrOffset+8]); + ptrmapGet(pBt, child, &e, &n); + assert( n==pPage->pgno && e==PTRMAP_BTREE ); + } + } + return 1; +} +#endif + +/* +** This function is used to copy the contents of the b-tree node stored +** on page pFrom to page pTo. If page pFrom was not a leaf page, then +** the pointer-map entries for each child page are updated so that the +** parent page stored in the pointer map is page pTo. If pFrom contained +** any cells with overflow page pointers, then the corresponding pointer +** map entries are also updated so that the parent page is page pTo. +** +** If pFrom is currently carrying any overflow cells (entries in the +** MemPage.apOvfl[] array), they are not copied to pTo. +** +** Before returning, page pTo is reinitialized using btreeInitPage(). +** +** The performance of this function is not critical. It is only used by +** the balance_shallower() and balance_deeper() procedures, neither of +** which are called often under normal circumstances. +*/ +static void copyNodeContent(MemPage *pFrom, MemPage *pTo, int *pRC){ + if( (*pRC)==SQLITE_OK ){ + BtShared * const pBt = pFrom->pBt; + u8 * const aFrom = pFrom->aData; + u8 * const aTo = pTo->aData; + int const iFromHdr = pFrom->hdrOffset; + int const iToHdr = ((pTo->pgno==1) ? 100 : 0); + int rc; + int iData; + + + assert( pFrom->isInit ); + assert( pFrom->nFree>=iToHdr ); + assert( get2byte(&aFrom[iFromHdr+5]) <= (int)pBt->usableSize ); + + /* Copy the b-tree node content from page pFrom to page pTo. */ + iData = get2byte(&aFrom[iFromHdr+5]); + memcpy(&aTo[iData], &aFrom[iData], pBt->usableSize-iData); + memcpy(&aTo[iToHdr], &aFrom[iFromHdr], pFrom->cellOffset + 2*pFrom->nCell); + + /* Reinitialize page pTo so that the contents of the MemPage structure + ** match the new data. The initialization of pTo can actually fail under + ** fairly obscure circumstances, even though it is a copy of initialized + ** page pFrom. + */ + pTo->isInit = 0; + rc = btreeInitPage(pTo); + if( rc==SQLITE_OK ) rc = btreeComputeFreeSpace(pTo); + if( rc!=SQLITE_OK ){ + *pRC = rc; + return; + } + + /* If this is an auto-vacuum database, update the pointer-map entries + ** for any b-tree or overflow pages that pTo now contains the pointers to. + */ + if( ISAUTOVACUUM(pBt) ){ + *pRC = setChildPtrmaps(pTo); + } + } +} + +/* +** This routine redistributes cells on the iParentIdx'th child of pParent +** (hereafter "the page") and up to 2 siblings so that all pages have about the +** same amount of free space. Usually a single sibling on either side of the +** page are used in the balancing, though both siblings might come from one +** side if the page is the first or last child of its parent. If the page +** has fewer than 2 siblings (something which can only happen if the page +** is a root page or a child of a root page) then all available siblings +** participate in the balancing. +** +** The number of siblings of the page might be increased or decreased by +** one or two in an effort to keep pages nearly full but not over full. +** +** Note that when this routine is called, some of the cells on the page +** might not actually be stored in MemPage.aData[]. This can happen +** if the page is overfull. This routine ensures that all cells allocated +** to the page and its siblings fit into MemPage.aData[] before returning. +** +** In the course of balancing the page and its siblings, cells may be +** inserted into or removed from the parent page (pParent). Doing so +** may cause the parent page to become overfull or underfull. If this +** happens, it is the responsibility of the caller to invoke the correct +** balancing routine to fix this problem (see the balance() routine). +** +** If this routine fails for any reason, it might leave the database +** in a corrupted state. So if this routine fails, the database should +** be rolled back. +** +** The third argument to this function, aOvflSpace, is a pointer to a +** buffer big enough to hold one page. If while inserting cells into the parent +** page (pParent) the parent page becomes overfull, this buffer is +** used to store the parent's overflow cells. Because this function inserts +** a maximum of four divider cells into the parent page, and the maximum +** size of a cell stored within an internal node is always less than 1/4 +** of the page-size, the aOvflSpace[] buffer is guaranteed to be large +** enough for all overflow cells. +** +** If aOvflSpace is set to a null pointer, this function returns +** SQLITE_NOMEM. +*/ +static int balance_nonroot( + MemPage *pParent, /* Parent page of siblings being balanced */ + int iParentIdx, /* Index of "the page" in pParent */ + u8 *aOvflSpace, /* page-size bytes of space for parent ovfl */ + int isRoot, /* True if pParent is a root-page */ + int bBulk /* True if this call is part of a bulk load */ +){ + BtShared *pBt; /* The whole database */ + int nMaxCells = 0; /* Allocated size of apCell, szCell, aFrom. */ + int nNew = 0; /* Number of pages in apNew[] */ + int nOld; /* Number of pages in apOld[] */ + int i, j, k; /* Loop counters */ + int nxDiv; /* Next divider slot in pParent->aCell[] */ + int rc = SQLITE_OK; /* The return code */ + u16 leafCorrection; /* 4 if pPage is a leaf. 0 if not */ + int leafData; /* True if pPage is a leaf of a LEAFDATA tree */ + int usableSpace; /* Bytes in pPage beyond the header */ + int pageFlags; /* Value of pPage->aData[0] */ + int iSpace1 = 0; /* First unused byte of aSpace1[] */ + int iOvflSpace = 0; /* First unused byte of aOvflSpace[] */ + int szScratch; /* Size of scratch memory requested */ + MemPage *apOld[NB]; /* pPage and up to two siblings */ + MemPage *apNew[NB+2]; /* pPage and up to NB siblings after balancing */ + u8 *pRight; /* Location in parent of right-sibling pointer */ + u8 *apDiv[NB-1]; /* Divider cells in pParent */ + int cntNew[NB+2]; /* Index in b.paCell[] of cell after i-th page */ + int cntOld[NB+2]; /* Old index in b.apCell[] */ + int szNew[NB+2]; /* Combined size of cells placed on i-th page */ + u8 *aSpace1; /* Space for copies of dividers cells */ + Pgno pgno; /* Temp var to store a page number in */ + u8 abDone[NB+2]; /* True after i'th new page is populated */ + Pgno aPgno[NB+2]; /* Page numbers of new pages before shuffling */ + CellArray b; /* Parsed information on cells being balanced */ + + memset(abDone, 0, sizeof(abDone)); + memset(&b, 0, sizeof(b)); + pBt = pParent->pBt; + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( sqlite3PagerIswriteable(pParent->pDbPage) ); + + /* At this point pParent may have at most one overflow cell. And if + ** this overflow cell is present, it must be the cell with + ** index iParentIdx. This scenario comes about when this function + ** is called (indirectly) from sqlite3BtreeDelete(). + */ + assert( pParent->nOverflow==0 || pParent->nOverflow==1 ); + assert( pParent->nOverflow==0 || pParent->aiOvfl[0]==iParentIdx ); + + if( !aOvflSpace ){ + return SQLITE_NOMEM_BKPT; + } + assert( pParent->nFree>=0 ); + + /* Find the sibling pages to balance. Also locate the cells in pParent + ** that divide the siblings. An attempt is made to find NN siblings on + ** either side of pPage. More siblings are taken from one side, however, + ** if there are fewer than NN siblings on the other side. If pParent + ** has NB or fewer children then all children of pParent are taken. + ** + ** This loop also drops the divider cells from the parent page. This + ** way, the remainder of the function does not have to deal with any + ** overflow cells in the parent page, since if any existed they will + ** have already been removed. + */ + i = pParent->nOverflow + pParent->nCell; + if( i<2 ){ + nxDiv = 0; + }else{ + assert( bBulk==0 || bBulk==1 ); + if( iParentIdx==0 ){ + nxDiv = 0; + }else if( iParentIdx==i ){ + nxDiv = i-2+bBulk; + }else{ + nxDiv = iParentIdx-1; + } + i = 2-bBulk; + } + nOld = i+1; + if( (i+nxDiv-pParent->nOverflow)==pParent->nCell ){ + pRight = &pParent->aData[pParent->hdrOffset+8]; + }else{ + pRight = findCell(pParent, i+nxDiv-pParent->nOverflow); + } + pgno = get4byte(pRight); + while( 1 ){ + if( rc==SQLITE_OK ){ + rc = getAndInitPage(pBt, pgno, &apOld[i], 0, 0); + } + if( rc ){ + memset(apOld, 0, (i+1)*sizeof(MemPage*)); + goto balance_cleanup; + } + if( apOld[i]->nFree<0 ){ + rc = btreeComputeFreeSpace(apOld[i]); + if( rc ){ + memset(apOld, 0, (i)*sizeof(MemPage*)); + goto balance_cleanup; + } + } + nMaxCells += apOld[i]->nCell + ArraySize(pParent->apOvfl); + if( (i--)==0 ) break; + + if( pParent->nOverflow && i+nxDiv==pParent->aiOvfl[0] ){ + apDiv[i] = pParent->apOvfl[0]; + pgno = get4byte(apDiv[i]); + szNew[i] = pParent->xCellSize(pParent, apDiv[i]); + pParent->nOverflow = 0; + }else{ + apDiv[i] = findCell(pParent, i+nxDiv-pParent->nOverflow); + pgno = get4byte(apDiv[i]); + szNew[i] = pParent->xCellSize(pParent, apDiv[i]); + + /* Drop the cell from the parent page. apDiv[i] still points to + ** the cell within the parent, even though it has been dropped. + ** This is safe because dropping a cell only overwrites the first + ** four bytes of it, and this function does not need the first + ** four bytes of the divider cell. So the pointer is safe to use + ** later on. + ** + ** But not if we are in secure-delete mode. In secure-delete mode, + ** the dropCell() routine will overwrite the entire cell with zeroes. + ** In this case, temporarily copy the cell into the aOvflSpace[] + ** buffer. It will be copied out again as soon as the aSpace[] buffer + ** is allocated. */ + if( pBt->btsFlags & BTS_FAST_SECURE ){ + int iOff; + + /* If the following if() condition is not true, the db is corrupted. + ** The call to dropCell() below will detect this. */ + iOff = SQLITE_PTR_TO_INT(apDiv[i]) - SQLITE_PTR_TO_INT(pParent->aData); + if( (iOff+szNew[i])<=(int)pBt->usableSize ){ + memcpy(&aOvflSpace[iOff], apDiv[i], szNew[i]); + apDiv[i] = &aOvflSpace[apDiv[i]-pParent->aData]; + } + } + dropCell(pParent, i+nxDiv-pParent->nOverflow, szNew[i], &rc); + } + } + + /* Make nMaxCells a multiple of 4 in order to preserve 8-byte + ** alignment */ + nMaxCells = (nMaxCells + 3)&~3; + + /* + ** Allocate space for memory structures + */ + szScratch = + nMaxCells*sizeof(u8*) /* b.apCell */ + + nMaxCells*sizeof(u16) /* b.szCell */ + + pBt->pageSize; /* aSpace1 */ + + assert( szScratch<=7*(int)pBt->pageSize ); + b.apCell = sqlite3StackAllocRaw(0, szScratch ); + if( b.apCell==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto balance_cleanup; + } + b.szCell = (u16*)&b.apCell[nMaxCells]; + aSpace1 = (u8*)&b.szCell[nMaxCells]; + assert( EIGHT_BYTE_ALIGNMENT(aSpace1) ); + + /* + ** Load pointers to all cells on sibling pages and the divider cells + ** into the local b.apCell[] array. Make copies of the divider cells + ** into space obtained from aSpace1[]. The divider cells have already + ** been removed from pParent. + ** + ** If the siblings are on leaf pages, then the child pointers of the + ** divider cells are stripped from the cells before they are copied + ** into aSpace1[]. In this way, all cells in b.apCell[] are without + ** child pointers. If siblings are not leaves, then all cell in + ** b.apCell[] include child pointers. Either way, all cells in b.apCell[] + ** are alike. + ** + ** leafCorrection: 4 if pPage is a leaf. 0 if pPage is not a leaf. + ** leafData: 1 if pPage holds key+data and pParent holds only keys. + */ + b.pRef = apOld[0]; + leafCorrection = b.pRef->leaf*4; + leafData = b.pRef->intKeyLeaf; + for(i=0; inCell; + u8 *aData = pOld->aData; + u16 maskPage = pOld->maskPage; + u8 *piCell = aData + pOld->cellOffset; + u8 *piEnd; + VVA_ONLY( int nCellAtStart = b.nCell; ) + + /* Verify that all sibling pages are of the same "type" (table-leaf, + ** table-interior, index-leaf, or index-interior). + */ + if( pOld->aData[0]!=apOld[0]->aData[0] ){ + rc = SQLITE_CORRUPT_BKPT; + goto balance_cleanup; + } + + /* Load b.apCell[] with pointers to all cells in pOld. If pOld + ** contains overflow cells, include them in the b.apCell[] array + ** in the correct spot. + ** + ** Note that when there are multiple overflow cells, it is always the + ** case that they are sequential and adjacent. This invariant arises + ** because multiple overflows can only occurs when inserting divider + ** cells into a parent on a prior balance, and divider cells are always + ** adjacent and are inserted in order. There is an assert() tagged + ** with "NOTE 1" in the overflow cell insertion loop to prove this + ** invariant. + ** + ** This must be done in advance. Once the balance starts, the cell + ** offset section of the btree page will be overwritten and we will no + ** long be able to find the cells if a pointer to each cell is not saved + ** first. + */ + memset(&b.szCell[b.nCell], 0, sizeof(b.szCell[0])*(limit+pOld->nOverflow)); + if( pOld->nOverflow>0 ){ + if( NEVER(limitaiOvfl[0]) ){ + rc = SQLITE_CORRUPT_BKPT; + goto balance_cleanup; + } + limit = pOld->aiOvfl[0]; + for(j=0; jnOverflow; k++){ + assert( k==0 || pOld->aiOvfl[k-1]+1==pOld->aiOvfl[k] );/* NOTE 1 */ + b.apCell[b.nCell] = pOld->apOvfl[k]; + b.nCell++; + } + } + piEnd = aData + pOld->cellOffset + 2*pOld->nCell; + while( piCellnCell+pOld->nOverflow) ); + + cntOld[i] = b.nCell; + if( imaxLocal+23 ); + assert( iSpace1 <= (int)pBt->pageSize ); + memcpy(pTemp, apDiv[i], sz); + b.apCell[b.nCell] = pTemp+leafCorrection; + assert( leafCorrection==0 || leafCorrection==4 ); + b.szCell[b.nCell] = b.szCell[b.nCell] - leafCorrection; + if( !pOld->leaf ){ + assert( leafCorrection==0 ); + assert( pOld->hdrOffset==0 || CORRUPT_DB ); + /* The right pointer of the child page pOld becomes the left + ** pointer of the divider cell */ + memcpy(b.apCell[b.nCell], &pOld->aData[8], 4); + }else{ + assert( leafCorrection==4 ); + while( b.szCell[b.nCell]<4 ){ + /* Do not allow any cells smaller than 4 bytes. If a smaller cell + ** does exist, pad it with 0x00 bytes. */ + assert( b.szCell[b.nCell]==3 || CORRUPT_DB ); + assert( b.apCell[b.nCell]==&aSpace1[iSpace1-3] || CORRUPT_DB ); + aSpace1[iSpace1++] = 0x00; + b.szCell[b.nCell]++; + } + } + b.nCell++; + } + } + + /* + ** Figure out the number of pages needed to hold all b.nCell cells. + ** Store this number in "k". Also compute szNew[] which is the total + ** size of all cells on the i-th page and cntNew[] which is the index + ** in b.apCell[] of the cell that divides page i from page i+1. + ** cntNew[k] should equal b.nCell. + ** + ** Values computed by this block: + ** + ** k: The total number of sibling pages + ** szNew[i]: Spaced used on the i-th sibling page. + ** cntNew[i]: Index in b.apCell[] and b.szCell[] for the first cell to + ** the right of the i-th sibling page. + ** usableSpace: Number of bytes of space available on each sibling. + ** + */ + usableSpace = pBt->usableSize - 12 + leafCorrection; + for(i=k=0; iaDataEnd; + b.ixNx[k] = cntOld[i]; + if( k && b.ixNx[k]==b.ixNx[k-1] ){ + k--; /* Omit b.ixNx[] entry for child pages with no cells */ + } + if( !leafData ){ + k++; + b.apEnd[k] = pParent->aDataEnd; + b.ixNx[k] = cntOld[i]+1; + } + assert( p->nFree>=0 ); + szNew[i] = usableSpace - p->nFree; + for(j=0; jnOverflow; j++){ + szNew[i] += 2 + p->xCellSize(p, p->apOvfl[j]); + } + cntNew[i] = cntOld[i]; + } + k = nOld; + for(i=0; iusableSpace ){ + if( i+1>=k ){ + k = i+2; + if( k>NB+2 ){ rc = SQLITE_CORRUPT_BKPT; goto balance_cleanup; } + szNew[k-1] = 0; + cntNew[k-1] = b.nCell; + } + sz = 2 + cachedCellSize(&b, cntNew[i]-1); + szNew[i] -= sz; + if( !leafData ){ + if( cntNew[i]usableSpace ) break; + szNew[i] += sz; + cntNew[i]++; + if( !leafData ){ + if( cntNew[i]=b.nCell ){ + k = i+1; + }else if( cntNew[i] <= (i>0 ? cntNew[i-1] : 0) ){ + rc = SQLITE_CORRUPT_BKPT; + goto balance_cleanup; + } + } + + /* + ** The packing computed by the previous block is biased toward the siblings + ** on the left side (siblings with smaller keys). The left siblings are + ** always nearly full, while the right-most sibling might be nearly empty. + ** The next block of code attempts to adjust the packing of siblings to + ** get a better balance. + ** + ** This adjustment is more than an optimization. The packing above might + ** be so out of balance as to be illegal. For example, the right-most + ** sibling might be completely empty. This adjustment is not optional. + */ + for(i=k-1; i>0; i--){ + int szRight = szNew[i]; /* Size of sibling on the right */ + int szLeft = szNew[i-1]; /* Size of sibling on the left */ + int r; /* Index of right-most cell in left sibling */ + int d; /* Index of first cell to the left of right sibling */ + + r = cntNew[i-1] - 1; + d = r + 1 - leafData; + (void)cachedCellSize(&b, d); + do{ + int szR, szD; + assert( d szLeft-(szR+(i==k-1?0:2)))){ + break; + } + szRight += szD + 2; + szLeft -= szR + 2; + cntNew[i-1] = r; + r--; + d--; + }while( r>=0 ); + szNew[i] = szRight; + szNew[i-1] = szLeft; + if( cntNew[i-1] <= (i>1 ? cntNew[i-2] : 0) ){ + rc = SQLITE_CORRUPT_BKPT; + goto balance_cleanup; + } + } + + /* Sanity check: For a non-corrupt database file one of the follwing + ** must be true: + ** (1) We found one or more cells (cntNew[0])>0), or + ** (2) pPage is a virtual root page. A virtual root page is when + ** the real root page is page 1 and we are the only child of + ** that page. + */ + assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) || CORRUPT_DB); + TRACE(("BALANCE: old: %u(nc=%u) %u(nc=%u) %u(nc=%u)\n", + apOld[0]->pgno, apOld[0]->nCell, + nOld>=2 ? apOld[1]->pgno : 0, nOld>=2 ? apOld[1]->nCell : 0, + nOld>=3 ? apOld[2]->pgno : 0, nOld>=3 ? apOld[2]->nCell : 0 + )); + + /* + ** Allocate k new pages. Reuse old pages where possible. + */ + pageFlags = apOld[0]->aData[0]; + for(i=0; ipDbPage); + nNew++; + if( sqlite3PagerPageRefcount(pNew->pDbPage)!=1+(i==(iParentIdx-nxDiv)) + && rc==SQLITE_OK + ){ + rc = SQLITE_CORRUPT_BKPT; + } + if( rc ) goto balance_cleanup; + }else{ + assert( i>0 ); + rc = allocateBtreePage(pBt, &pNew, &pgno, (bBulk ? 1 : pgno), 0); + if( rc ) goto balance_cleanup; + zeroPage(pNew, pageFlags); + apNew[i] = pNew; + nNew++; + cntOld[i] = b.nCell; + + /* Set the pointer-map entry for the new sibling page. */ + if( ISAUTOVACUUM(pBt) ){ + ptrmapPut(pBt, pNew->pgno, PTRMAP_BTREE, pParent->pgno, &rc); + if( rc!=SQLITE_OK ){ + goto balance_cleanup; + } + } + } + } + + /* + ** Reassign page numbers so that the new pages are in ascending order. + ** This helps to keep entries in the disk file in order so that a scan + ** of the table is closer to a linear scan through the file. That in turn + ** helps the operating system to deliver pages from the disk more rapidly. + ** + ** An O(N*N) sort algorithm is used, but since N is never more than NB+2 + ** (5), that is not a performance concern. + ** + ** When NB==3, this one optimization makes the database about 25% faster + ** for large insertions and deletions. + */ + for(i=0; ipgno; + assert( apNew[i]->pDbPage->flags & PGHDR_WRITEABLE ); + assert( apNew[i]->pDbPage->flags & PGHDR_DIRTY ); + } + for(i=0; ipgno < apNew[iB]->pgno ) iB = j; + } + + /* If apNew[i] has a page number that is bigger than any of the + ** subsequence apNew[i] entries, then swap apNew[i] with the subsequent + ** entry that has the smallest page number (which we know to be + ** entry apNew[iB]). + */ + if( iB!=i ){ + Pgno pgnoA = apNew[i]->pgno; + Pgno pgnoB = apNew[iB]->pgno; + Pgno pgnoTemp = (PENDING_BYTE/pBt->pageSize)+1; + u16 fgA = apNew[i]->pDbPage->flags; + u16 fgB = apNew[iB]->pDbPage->flags; + sqlite3PagerRekey(apNew[i]->pDbPage, pgnoTemp, fgB); + sqlite3PagerRekey(apNew[iB]->pDbPage, pgnoA, fgA); + sqlite3PagerRekey(apNew[i]->pDbPage, pgnoB, fgB); + apNew[i]->pgno = pgnoB; + apNew[iB]->pgno = pgnoA; + } + } + + TRACE(("BALANCE: new: %u(%u nc=%u) %u(%u nc=%u) %u(%u nc=%u) " + "%u(%u nc=%u) %u(%u nc=%u)\n", + apNew[0]->pgno, szNew[0], cntNew[0], + nNew>=2 ? apNew[1]->pgno : 0, nNew>=2 ? szNew[1] : 0, + nNew>=2 ? cntNew[1] - cntNew[0] - !leafData : 0, + nNew>=3 ? apNew[2]->pgno : 0, nNew>=3 ? szNew[2] : 0, + nNew>=3 ? cntNew[2] - cntNew[1] - !leafData : 0, + nNew>=4 ? apNew[3]->pgno : 0, nNew>=4 ? szNew[3] : 0, + nNew>=4 ? cntNew[3] - cntNew[2] - !leafData : 0, + nNew>=5 ? apNew[4]->pgno : 0, nNew>=5 ? szNew[4] : 0, + nNew>=5 ? cntNew[4] - cntNew[3] - !leafData : 0 + )); + + assert( sqlite3PagerIswriteable(pParent->pDbPage) ); + assert( nNew>=1 && nNew<=ArraySize(apNew) ); + assert( apNew[nNew-1]!=0 ); + put4byte(pRight, apNew[nNew-1]->pgno); + + /* If the sibling pages are not leaves, ensure that the right-child pointer + ** of the right-most new sibling page is set to the value that was + ** originally in the same field of the right-most old sibling page. */ + if( (pageFlags & PTF_LEAF)==0 && nOld!=nNew ){ + MemPage *pOld = (nNew>nOld ? apNew : apOld)[nOld-1]; + memcpy(&apNew[nNew-1]->aData[8], &pOld->aData[8], 4); + } + + /* Make any required updates to pointer map entries associated with + ** cells stored on sibling pages following the balance operation. Pointer + ** map entries associated with divider cells are set by the insertCell() + ** routine. The associated pointer map entries are: + ** + ** a) if the cell contains a reference to an overflow chain, the + ** entry associated with the first page in the overflow chain, and + ** + ** b) if the sibling pages are not leaves, the child page associated + ** with the cell. + ** + ** If the sibling pages are not leaves, then the pointer map entry + ** associated with the right-child of each sibling may also need to be + ** updated. This happens below, after the sibling pages have been + ** populated, not here. + */ + if( ISAUTOVACUUM(pBt) ){ + MemPage *pOld; + MemPage *pNew = pOld = apNew[0]; + int cntOldNext = pNew->nCell + pNew->nOverflow; + int iNew = 0; + int iOld = 0; + + for(i=0; i=0 && iOldnCell + pOld->nOverflow + !leafData; + } + if( i==cntNew[iNew] ){ + pNew = apNew[++iNew]; + if( !leafData ) continue; + } + + /* Cell pCell is destined for new sibling page pNew. Originally, it + ** was either part of sibling page iOld (possibly an overflow cell), + ** or else the divider cell to the left of sibling page iOld. So, + ** if sibling page iOld had the same page number as pNew, and if + ** pCell really was a part of sibling page iOld (not a divider or + ** overflow cell), we can skip updating the pointer map entries. */ + if( iOld>=nNew + || pNew->pgno!=aPgno[iOld] + || !SQLITE_WITHIN(pCell,pOld->aData,pOld->aDataEnd) + ){ + if( !leafCorrection ){ + ptrmapPut(pBt, get4byte(pCell), PTRMAP_BTREE, pNew->pgno, &rc); + } + if( cachedCellSize(&b,i)>pNew->minLocal ){ + ptrmapPutOvflPtr(pNew, pOld, pCell, &rc); + } + if( rc ) goto balance_cleanup; + } + } + } + + /* Insert new divider cells into pParent. */ + for(i=0; ileaf ){ + memcpy(&pNew->aData[8], pCell, 4); + }else if( leafData ){ + /* If the tree is a leaf-data tree, and the siblings are leaves, + ** then there is no divider cell in b.apCell[]. Instead, the divider + ** cell consists of the integer key for the right-most cell of + ** the sibling-page assembled above only. + */ + CellInfo info; + j--; + pNew->xParseCell(pNew, b.apCell[j], &info); + pCell = pTemp; + sz = 4 + putVarint(&pCell[4], info.nKey); + pTemp = 0; + }else{ + pCell -= 4; + /* Obscure case for non-leaf-data trees: If the cell at pCell was + ** previously stored on a leaf node, and its reported size was 4 + ** bytes, then it may actually be smaller than this + ** (see btreeParseCellPtr(), 4 bytes is the minimum size of + ** any cell). But it is important to pass the correct size to + ** insertCell(), so reparse the cell now. + ** + ** This can only happen for b-trees used to evaluate "IN (SELECT ...)" + ** and WITHOUT ROWID tables with exactly one column which is the + ** primary key. + */ + if( b.szCell[j]==4 ){ + assert(leafCorrection==4); + sz = pParent->xCellSize(pParent, pCell); + } + } + iOvflSpace += sz; + assert( sz<=pBt->maxLocal+23 ); + assert( iOvflSpace <= (int)pBt->pageSize ); + for(k=0; b.ixNx[k]<=j && ALWAYS(kpgno); + if( rc!=SQLITE_OK ) goto balance_cleanup; + assert( sqlite3PagerIswriteable(pParent->pDbPage) ); + } + + /* Now update the actual sibling pages. The order in which they are updated + ** is important, as this code needs to avoid disrupting any page from which + ** cells may still to be read. In practice, this means: + ** + ** (1) If cells are moving left (from apNew[iPg] to apNew[iPg-1]) + ** then it is not safe to update page apNew[iPg] until after + ** the left-hand sibling apNew[iPg-1] has been updated. + ** + ** (2) If cells are moving right (from apNew[iPg] to apNew[iPg+1]) + ** then it is not safe to update page apNew[iPg] until after + ** the right-hand sibling apNew[iPg+1] has been updated. + ** + ** If neither of the above apply, the page is safe to update. + ** + ** The iPg value in the following loop starts at nNew-1 goes down + ** to 0, then back up to nNew-1 again, thus making two passes over + ** the pages. On the initial downward pass, only condition (1) above + ** needs to be tested because (2) will always be true from the previous + ** step. On the upward pass, both conditions are always true, so the + ** upwards pass simply processes pages that were missed on the downward + ** pass. + */ + for(i=1-nNew; i=0 && iPg=0 /* On the upwards pass, or... */ + || cntOld[iPg-1]>=cntNew[iPg-1] /* Condition (1) is true */ + ){ + int iNew; + int iOld; + int nNewCell; + + /* Verify condition (1): If cells are moving left, update iPg + ** only after iPg-1 has already been updated. */ + assert( iPg==0 || cntOld[iPg-1]>=cntNew[iPg-1] || abDone[iPg-1] ); + + /* Verify condition (2): If cells are moving right, update iPg + ** only after iPg+1 has already been updated. */ + assert( cntNew[iPg]>=cntOld[iPg] || abDone[iPg+1] ); + + if( iPg==0 ){ + iNew = iOld = 0; + nNewCell = cntNew[0]; + }else{ + iOld = iPgnFree = usableSpace-szNew[iPg]; + assert( apNew[iPg]->nOverflow==0 ); + assert( apNew[iPg]->nCell==nNewCell ); + } + } + + /* All pages have been processed exactly once */ + assert( memcmp(abDone, "\01\01\01\01\01", nNew)==0 ); + + assert( nOld>0 ); + assert( nNew>0 ); + + if( isRoot && pParent->nCell==0 && pParent->hdrOffset<=apNew[0]->nFree ){ + /* The root page of the b-tree now contains no cells. The only sibling + ** page is the right-child of the parent. Copy the contents of the + ** child page into the parent, decreasing the overall height of the + ** b-tree structure by one. This is described as the "balance-shallower" + ** sub-algorithm in some documentation. + ** + ** If this is an auto-vacuum database, the call to copyNodeContent() + ** sets all pointer-map entries corresponding to database image pages + ** for which the pointer is stored within the content being copied. + ** + ** It is critical that the child page be defragmented before being + ** copied into the parent, because if the parent is page 1 then it will + ** by smaller than the child due to the database header, and so all the + ** free space needs to be up front. + */ + assert( nNew==1 || CORRUPT_DB ); + rc = defragmentPage(apNew[0], -1); + testcase( rc!=SQLITE_OK ); + assert( apNew[0]->nFree == + (get2byteNotZero(&apNew[0]->aData[5]) - apNew[0]->cellOffset + - apNew[0]->nCell*2) + || rc!=SQLITE_OK + ); + copyNodeContent(apNew[0], pParent, &rc); + freePage(apNew[0], &rc); + }else if( ISAUTOVACUUM(pBt) && !leafCorrection ){ + /* Fix the pointer map entries associated with the right-child of each + ** sibling page. All other pointer map entries have already been taken + ** care of. */ + for(i=0; iaData[8]); + ptrmapPut(pBt, key, PTRMAP_BTREE, apNew[i]->pgno, &rc); + } + } + + assert( pParent->isInit ); + TRACE(("BALANCE: finished: old=%u new=%u cells=%u\n", + nOld, nNew, b.nCell)); + + /* Free any old pages that were not reused as new pages. + */ + for(i=nNew; iisInit ){ + /* The ptrmapCheckPages() contains assert() statements that verify that + ** all pointer map pages are set correctly. This is helpful while + ** debugging. This is usually disabled because a corrupt database may + ** cause an assert() statement to fail. */ + ptrmapCheckPages(apNew, nNew); + ptrmapCheckPages(&pParent, 1); + } +#endif + + /* + ** Cleanup before returning. + */ +balance_cleanup: + sqlite3StackFree(0, b.apCell); + for(i=0; ipBt; /* The BTree */ + + assert( pRoot->nOverflow>0 ); + assert( sqlite3_mutex_held(pBt->mutex) ); + + /* Make pRoot, the root page of the b-tree, writable. Allocate a new + ** page that will become the new right-child of pPage. Copy the contents + ** of the node stored on pRoot into the new child page. + */ + rc = sqlite3PagerWrite(pRoot->pDbPage); + if( rc==SQLITE_OK ){ + rc = allocateBtreePage(pBt,&pChild,&pgnoChild,pRoot->pgno,0); + copyNodeContent(pRoot, pChild, &rc); + if( ISAUTOVACUUM(pBt) ){ + ptrmapPut(pBt, pgnoChild, PTRMAP_BTREE, pRoot->pgno, &rc); + } + } + if( rc ){ + *ppChild = 0; + releasePage(pChild); + return rc; + } + assert( sqlite3PagerIswriteable(pChild->pDbPage) ); + assert( sqlite3PagerIswriteable(pRoot->pDbPage) ); + assert( pChild->nCell==pRoot->nCell || CORRUPT_DB ); + + TRACE(("BALANCE: copy root %u into %u\n", pRoot->pgno, pChild->pgno)); + + /* Copy the overflow cells from pRoot to pChild */ + memcpy(pChild->aiOvfl, pRoot->aiOvfl, + pRoot->nOverflow*sizeof(pRoot->aiOvfl[0])); + memcpy(pChild->apOvfl, pRoot->apOvfl, + pRoot->nOverflow*sizeof(pRoot->apOvfl[0])); + pChild->nOverflow = pRoot->nOverflow; + + /* Zero the contents of pRoot. Then install pChild as the right-child. */ + zeroPage(pRoot, pChild->aData[0] & ~PTF_LEAF); + put4byte(&pRoot->aData[pRoot->hdrOffset+8], pgnoChild); + + *ppChild = pChild; + return SQLITE_OK; +} + +/* +** Return SQLITE_CORRUPT if any cursor other than pCur is currently valid +** on the same B-tree as pCur. +** +** This can occur if a database is corrupt with two or more SQL tables +** pointing to the same b-tree. If an insert occurs on one SQL table +** and causes a BEFORE TRIGGER to do a secondary insert on the other SQL +** table linked to the same b-tree. If the secondary insert causes a +** rebalance, that can change content out from under the cursor on the +** first SQL table, violating invariants on the first insert. +*/ +static int anotherValidCursor(BtCursor *pCur){ + BtCursor *pOther; + for(pOther=pCur->pBt->pCursor; pOther; pOther=pOther->pNext){ + if( pOther!=pCur + && pOther->eState==CURSOR_VALID + && pOther->pPage==pCur->pPage + ){ + return SQLITE_CORRUPT_BKPT; + } + } + return SQLITE_OK; +} + +/* +** The page that pCur currently points to has just been modified in +** some way. This function figures out if this modification means the +** tree needs to be balanced, and if so calls the appropriate balancing +** routine. Balancing routines are: +** +** balance_quick() +** balance_deeper() +** balance_nonroot() +*/ +static int balance(BtCursor *pCur){ + int rc = SQLITE_OK; + u8 aBalanceQuickSpace[13]; + u8 *pFree = 0; + + VVA_ONLY( int balance_quick_called = 0 ); + VVA_ONLY( int balance_deeper_called = 0 ); + + do { + int iPage; + MemPage *pPage = pCur->pPage; + + if( NEVER(pPage->nFree<0) && btreeComputeFreeSpace(pPage) ) break; + if( pPage->nOverflow==0 && pPage->nFree*3<=(int)pCur->pBt->usableSize*2 ){ + /* No rebalance required as long as: + ** (1) There are no overflow cells + ** (2) The amount of free space on the page is less than 2/3rds of + ** the total usable space on the page. */ + break; + }else if( (iPage = pCur->iPage)==0 ){ + if( pPage->nOverflow && (rc = anotherValidCursor(pCur))==SQLITE_OK ){ + /* The root page of the b-tree is overfull. In this case call the + ** balance_deeper() function to create a new child for the root-page + ** and copy the current contents of the root-page to it. The + ** next iteration of the do-loop will balance the child page. + */ + assert( balance_deeper_called==0 ); + VVA_ONLY( balance_deeper_called++ ); + rc = balance_deeper(pPage, &pCur->apPage[1]); + if( rc==SQLITE_OK ){ + pCur->iPage = 1; + pCur->ix = 0; + pCur->aiIdx[0] = 0; + pCur->apPage[0] = pPage; + pCur->pPage = pCur->apPage[1]; + assert( pCur->pPage->nOverflow ); + } + }else{ + break; + } + }else if( sqlite3PagerPageRefcount(pPage->pDbPage)>1 ){ + /* The page being written is not a root page, and there is currently + ** more than one reference to it. This only happens if the page is one + ** of its own ancestor pages. Corruption. */ + rc = SQLITE_CORRUPT_BKPT; + }else{ + MemPage * const pParent = pCur->apPage[iPage-1]; + int const iIdx = pCur->aiIdx[iPage-1]; + + rc = sqlite3PagerWrite(pParent->pDbPage); + if( rc==SQLITE_OK && pParent->nFree<0 ){ + rc = btreeComputeFreeSpace(pParent); + } + if( rc==SQLITE_OK ){ +#ifndef SQLITE_OMIT_QUICKBALANCE + if( pPage->intKeyLeaf + && pPage->nOverflow==1 + && pPage->aiOvfl[0]==pPage->nCell + && pParent->pgno!=1 + && pParent->nCell==iIdx + ){ + /* Call balance_quick() to create a new sibling of pPage on which + ** to store the overflow cell. balance_quick() inserts a new cell + ** into pParent, which may cause pParent overflow. If this + ** happens, the next iteration of the do-loop will balance pParent + ** use either balance_nonroot() or balance_deeper(). Until this + ** happens, the overflow cell is stored in the aBalanceQuickSpace[] + ** buffer. + ** + ** The purpose of the following assert() is to check that only a + ** single call to balance_quick() is made for each call to this + ** function. If this were not verified, a subtle bug involving reuse + ** of the aBalanceQuickSpace[] might sneak in. + */ + assert( balance_quick_called==0 ); + VVA_ONLY( balance_quick_called++ ); + rc = balance_quick(pParent, pPage, aBalanceQuickSpace); + }else +#endif + { + /* In this case, call balance_nonroot() to redistribute cells + ** between pPage and up to 2 of its sibling pages. This involves + ** modifying the contents of pParent, which may cause pParent to + ** become overfull or underfull. The next iteration of the do-loop + ** will balance the parent page to correct this. + ** + ** If the parent page becomes overfull, the overflow cell or cells + ** are stored in the pSpace buffer allocated immediately below. + ** A subsequent iteration of the do-loop will deal with this by + ** calling balance_nonroot() (balance_deeper() may be called first, + ** but it doesn't deal with overflow cells - just moves them to a + ** different page). Once this subsequent call to balance_nonroot() + ** has completed, it is safe to release the pSpace buffer used by + ** the previous call, as the overflow cell data will have been + ** copied either into the body of a database page or into the new + ** pSpace buffer passed to the latter call to balance_nonroot(). + */ + u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize); + rc = balance_nonroot(pParent, iIdx, pSpace, iPage==1, + pCur->hints&BTREE_BULKLOAD); + if( pFree ){ + /* If pFree is not NULL, it points to the pSpace buffer used + ** by a previous call to balance_nonroot(). Its contents are + ** now stored either on real database pages or within the + ** new pSpace buffer, so it may be safely freed here. */ + sqlite3PageFree(pFree); + } + + /* The pSpace buffer will be freed after the next call to + ** balance_nonroot(), or just before this function returns, whichever + ** comes first. */ + pFree = pSpace; + } + } + + pPage->nOverflow = 0; + + /* The next iteration of the do-loop balances the parent page. */ + releasePage(pPage); + pCur->iPage--; + assert( pCur->iPage>=0 ); + pCur->pPage = pCur->apPage[pCur->iPage]; + } + }while( rc==SQLITE_OK ); + + if( pFree ){ + sqlite3PageFree(pFree); + } + return rc; +} + +/* Overwrite content from pX into pDest. Only do the write if the +** content is different from what is already there. +*/ +static int btreeOverwriteContent( + MemPage *pPage, /* MemPage on which writing will occur */ + u8 *pDest, /* Pointer to the place to start writing */ + const BtreePayload *pX, /* Source of data to write */ + int iOffset, /* Offset of first byte to write */ + int iAmt /* Number of bytes to be written */ +){ + int nData = pX->nData - iOffset; + if( nData<=0 ){ + /* Overwritting with zeros */ + int i; + for(i=0; ipDbPage); + if( rc ) return rc; + memset(pDest + i, 0, iAmt - i); + } + }else{ + if( nDatapData) + iOffset, iAmt)!=0 ){ + int rc = sqlite3PagerWrite(pPage->pDbPage); + if( rc ) return rc; + /* In a corrupt database, it is possible for the source and destination + ** buffers to overlap. This is harmless since the database is already + ** corrupt but it does cause valgrind and ASAN warnings. So use + ** memmove(). */ + memmove(pDest, ((u8*)pX->pData) + iOffset, iAmt); + } + } + return SQLITE_OK; +} + +/* +** Overwrite the cell that cursor pCur is pointing to with fresh content +** contained in pX. In this variant, pCur is pointing to an overflow +** cell. +*/ +static SQLITE_NOINLINE int btreeOverwriteOverflowCell( + BtCursor *pCur, /* Cursor pointing to cell to ovewrite */ + const BtreePayload *pX /* Content to write into the cell */ +){ + int iOffset; /* Next byte of pX->pData to write */ + int nTotal = pX->nData + pX->nZero; /* Total bytes of to write */ + int rc; /* Return code */ + MemPage *pPage = pCur->pPage; /* Page being written */ + BtShared *pBt; /* Btree */ + Pgno ovflPgno; /* Next overflow page to write */ + u32 ovflPageSize; /* Size to write on overflow page */ + + assert( pCur->info.nLocalinfo.pPayload, pX, + 0, pCur->info.nLocal); + if( rc ) return rc; + + /* Now overwrite the overflow pages */ + iOffset = pCur->info.nLocal; + assert( nTotal>=0 ); + assert( iOffset>=0 ); + ovflPgno = get4byte(pCur->info.pPayload + iOffset); + pBt = pPage->pBt; + ovflPageSize = pBt->usableSize - 4; + do{ + rc = btreeGetPage(pBt, ovflPgno, &pPage, 0); + if( rc ) return rc; + if( sqlite3PagerPageRefcount(pPage->pDbPage)!=1 || pPage->isInit ){ + rc = SQLITE_CORRUPT_BKPT; + }else{ + if( iOffset+ovflPageSize<(u32)nTotal ){ + ovflPgno = get4byte(pPage->aData); + }else{ + ovflPageSize = nTotal - iOffset; + } + rc = btreeOverwriteContent(pPage, pPage->aData+4, pX, + iOffset, ovflPageSize); + } + sqlite3PagerUnref(pPage->pDbPage); + if( rc ) return rc; + iOffset += ovflPageSize; + }while( iOffsetnData + pX->nZero; /* Total bytes of to write */ + MemPage *pPage = pCur->pPage; /* Page being written */ + + if( pCur->info.pPayload + pCur->info.nLocal > pPage->aDataEnd + || pCur->info.pPayload < pPage->aData + pPage->cellOffset + ){ + return SQLITE_CORRUPT_BKPT; + } + if( pCur->info.nLocal==nTotal ){ + /* The entire cell is local */ + return btreeOverwriteContent(pPage, pCur->info.pPayload, pX, + 0, pCur->info.nLocal); + }else{ + /* The cell contains overflow content */ + return btreeOverwriteOverflowCell(pCur, pX); + } +} + + +/* +** Insert a new record into the BTree. The content of the new record +** is described by the pX object. The pCur cursor is used only to +** define what table the record should be inserted into, and is left +** pointing at a random location. +** +** For a table btree (used for rowid tables), only the pX.nKey value of +** the key is used. The pX.pKey value must be NULL. The pX.nKey is the +** rowid or INTEGER PRIMARY KEY of the row. The pX.nData,pData,nZero fields +** hold the content of the row. +** +** For an index btree (used for indexes and WITHOUT ROWID tables), the +** key is an arbitrary byte sequence stored in pX.pKey,nKey. The +** pX.pData,nData,nZero fields must be zero. +** +** If the seekResult parameter is non-zero, then a successful call to +** sqlite3BtreeIndexMoveto() to seek cursor pCur to (pKey,nKey) has already +** been performed. In other words, if seekResult!=0 then the cursor +** is currently pointing to a cell that will be adjacent to the cell +** to be inserted. If seekResult<0 then pCur points to a cell that is +** smaller then (pKey,nKey). If seekResult>0 then pCur points to a cell +** that is larger than (pKey,nKey). +** +** If seekResult==0, that means pCur is pointing at some unknown location. +** In that case, this routine must seek the cursor to the correct insertion +** point for (pKey,nKey) before doing the insertion. For index btrees, +** if pX->nMem is non-zero, then pX->aMem contains pointers to the unpacked +** key values and pX->aMem can be used instead of pX->pKey to avoid having +** to decode the key. +*/ +SQLITE_PRIVATE int sqlite3BtreeInsert( + BtCursor *pCur, /* Insert data into the table of this cursor */ + const BtreePayload *pX, /* Content of the row to be inserted */ + int flags, /* True if this is likely an append */ + int seekResult /* Result of prior IndexMoveto() call */ +){ + int rc; + int loc = seekResult; /* -1: before desired location +1: after */ + int szNew = 0; + int idx; + MemPage *pPage; + Btree *p = pCur->pBtree; + unsigned char *oldCell; + unsigned char *newCell = 0; + + assert( (flags & (BTREE_SAVEPOSITION|BTREE_APPEND|BTREE_PREFORMAT))==flags ); + assert( (flags & BTREE_PREFORMAT)==0 || seekResult || pCur->pKeyInfo==0 ); + + /* Save the positions of any other cursors open on this table. + ** + ** In some cases, the call to btreeMoveto() below is a no-op. For + ** example, when inserting data into a table with auto-generated integer + ** keys, the VDBE layer invokes sqlite3BtreeLast() to figure out the + ** integer key to use. It then calls this function to actually insert the + ** data into the intkey B-Tree. In this case btreeMoveto() recognizes + ** that the cursor is already where it needs to be and returns without + ** doing any work. To avoid thwarting these optimizations, it is important + ** not to clear the cursor here. + */ + if( pCur->curFlags & BTCF_Multiple ){ + rc = saveAllCursors(p->pBt, pCur->pgnoRoot, pCur); + if( rc ) return rc; + if( loc && pCur->iPage<0 ){ + /* This can only happen if the schema is corrupt such that there is more + ** than one table or index with the same root page as used by the cursor. + ** Which can only happen if the SQLITE_NoSchemaError flag was set when + ** the schema was loaded. This cannot be asserted though, as a user might + ** set the flag, load the schema, and then unset the flag. */ + return SQLITE_CORRUPT_BKPT; + } + } + + /* Ensure that the cursor is not in the CURSOR_FAULT state and that it + ** points to a valid cell. + */ + if( pCur->eState>=CURSOR_REQUIRESEEK ){ + testcase( pCur->eState==CURSOR_REQUIRESEEK ); + testcase( pCur->eState==CURSOR_FAULT ); + rc = moveToRoot(pCur); + if( rc && rc!=SQLITE_EMPTY ) return rc; + } + + assert( cursorOwnsBtShared(pCur) ); + assert( (pCur->curFlags & BTCF_WriteFlag)!=0 + && p->pBt->inTransaction==TRANS_WRITE + && (p->pBt->btsFlags & BTS_READ_ONLY)==0 ); + assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) ); + + /* Assert that the caller has been consistent. If this cursor was opened + ** expecting an index b-tree, then the caller should be inserting blob + ** keys with no associated data. If the cursor was opened expecting an + ** intkey table, the caller should be inserting integer keys with a + ** blob of associated data. */ + assert( (flags & BTREE_PREFORMAT) || (pX->pKey==0)==(pCur->pKeyInfo==0) ); + + if( pCur->pKeyInfo==0 ){ + assert( pX->pKey==0 ); + /* If this is an insert into a table b-tree, invalidate any incrblob + ** cursors open on the row being replaced */ + if( p->hasIncrblobCur ){ + invalidateIncrblobCursors(p, pCur->pgnoRoot, pX->nKey, 0); + } + + /* If BTREE_SAVEPOSITION is set, the cursor must already be pointing + ** to a row with the same key as the new entry being inserted. + */ +#ifdef SQLITE_DEBUG + if( flags & BTREE_SAVEPOSITION ){ + assert( pCur->curFlags & BTCF_ValidNKey ); + assert( pX->nKey==pCur->info.nKey ); + assert( loc==0 ); + } +#endif + + /* On the other hand, BTREE_SAVEPOSITION==0 does not imply + ** that the cursor is not pointing to a row to be overwritten. + ** So do a complete check. + */ + if( (pCur->curFlags&BTCF_ValidNKey)!=0 && pX->nKey==pCur->info.nKey ){ + /* The cursor is pointing to the entry that is to be + ** overwritten */ + assert( pX->nData>=0 && pX->nZero>=0 ); + if( pCur->info.nSize!=0 + && pCur->info.nPayload==(u32)pX->nData+pX->nZero + ){ + /* New entry is the same size as the old. Do an overwrite */ + return btreeOverwriteCell(pCur, pX); + } + assert( loc==0 ); + }else if( loc==0 ){ + /* The cursor is *not* pointing to the cell to be overwritten, nor + ** to an adjacent cell. Move the cursor so that it is pointing either + ** to the cell to be overwritten or an adjacent cell. + */ + rc = sqlite3BtreeTableMoveto(pCur, pX->nKey, + (flags & BTREE_APPEND)!=0, &loc); + if( rc ) return rc; + } + }else{ + /* This is an index or a WITHOUT ROWID table */ + + /* If BTREE_SAVEPOSITION is set, the cursor must already be pointing + ** to a row with the same key as the new entry being inserted. + */ + assert( (flags & BTREE_SAVEPOSITION)==0 || loc==0 ); + + /* If the cursor is not already pointing either to the cell to be + ** overwritten, or if a new cell is being inserted, if the cursor is + ** not pointing to an immediately adjacent cell, then move the cursor + ** so that it does. + */ + if( loc==0 && (flags & BTREE_SAVEPOSITION)==0 ){ + if( pX->nMem ){ + UnpackedRecord r; + r.pKeyInfo = pCur->pKeyInfo; + r.aMem = pX->aMem; + r.nField = pX->nMem; + r.default_rc = 0; + r.eqSeen = 0; + rc = sqlite3BtreeIndexMoveto(pCur, &r, &loc); + }else{ + rc = btreeMoveto(pCur, pX->pKey, pX->nKey, + (flags & BTREE_APPEND)!=0, &loc); + } + if( rc ) return rc; + } + + /* If the cursor is currently pointing to an entry to be overwritten + ** and the new content is the same as as the old, then use the + ** overwrite optimization. + */ + if( loc==0 ){ + getCellInfo(pCur); + if( pCur->info.nKey==pX->nKey ){ + BtreePayload x2; + x2.pData = pX->pKey; + x2.nData = pX->nKey; + x2.nZero = 0; + return btreeOverwriteCell(pCur, &x2); + } + } + } + assert( pCur->eState==CURSOR_VALID + || (pCur->eState==CURSOR_INVALID && loc) || CORRUPT_DB ); + + pPage = pCur->pPage; + assert( pPage->intKey || pX->nKey>=0 || (flags & BTREE_PREFORMAT) ); + assert( pPage->leaf || !pPage->intKey ); + if( pPage->nFree<0 ){ + if( NEVER(pCur->eState>CURSOR_INVALID) ){ + /* ^^^^^--- due to the moveToRoot() call above */ + rc = SQLITE_CORRUPT_BKPT; + }else{ + rc = btreeComputeFreeSpace(pPage); + } + if( rc ) return rc; + } + + TRACE(("INSERT: table=%u nkey=%lld ndata=%u page=%u %s\n", + pCur->pgnoRoot, pX->nKey, pX->nData, pPage->pgno, + loc==0 ? "overwrite" : "new entry")); + assert( pPage->isInit || CORRUPT_DB ); + newCell = p->pBt->pTmpSpace; + assert( newCell!=0 ); + assert( BTREE_PREFORMAT==OPFLAG_PREFORMAT ); + if( flags & BTREE_PREFORMAT ){ + rc = SQLITE_OK; + szNew = p->pBt->nPreformatSize; + if( szNew<4 ) szNew = 4; + if( ISAUTOVACUUM(p->pBt) && szNew>pPage->maxLocal ){ + CellInfo info; + pPage->xParseCell(pPage, newCell, &info); + if( info.nPayload!=info.nLocal ){ + Pgno ovfl = get4byte(&newCell[szNew-4]); + ptrmapPut(p->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, &rc); + if( NEVER(rc) ) goto end_insert; + } + } + }else{ + rc = fillInCell(pPage, newCell, pX, &szNew); + if( rc ) goto end_insert; + } + assert( szNew==pPage->xCellSize(pPage, newCell) ); + assert( szNew <= MX_CELL_SIZE(p->pBt) ); + idx = pCur->ix; + pCur->info.nSize = 0; + if( loc==0 ){ + CellInfo info; + assert( idx>=0 ); + if( idx>=pPage->nCell ){ + return SQLITE_CORRUPT_BKPT; + } + rc = sqlite3PagerWrite(pPage->pDbPage); + if( rc ){ + goto end_insert; + } + oldCell = findCell(pPage, idx); + if( !pPage->leaf ){ + memcpy(newCell, oldCell, 4); + } + BTREE_CLEAR_CELL(rc, pPage, oldCell, info); + testcase( pCur->curFlags & BTCF_ValidOvfl ); + invalidateOverflowCache(pCur); + if( info.nSize==szNew && info.nLocal==info.nPayload + && (!ISAUTOVACUUM(p->pBt) || szNewminLocal) + ){ + /* Overwrite the old cell with the new if they are the same size. + ** We could also try to do this if the old cell is smaller, then add + ** the leftover space to the free list. But experiments show that + ** doing that is no faster then skipping this optimization and just + ** calling dropCell() and insertCell(). + ** + ** This optimization cannot be used on an autovacuum database if the + ** new entry uses overflow pages, as the insertCell() call below is + ** necessary to add the PTRMAP_OVERFLOW1 pointer-map entry. */ + assert( rc==SQLITE_OK ); /* clearCell never fails when nLocal==nPayload */ + if( oldCell < pPage->aData+pPage->hdrOffset+10 ){ + return SQLITE_CORRUPT_BKPT; + } + if( oldCell+szNew > pPage->aDataEnd ){ + return SQLITE_CORRUPT_BKPT; + } + memcpy(oldCell, newCell, szNew); + return SQLITE_OK; + } + dropCell(pPage, idx, info.nSize, &rc); + if( rc ) goto end_insert; + }else if( loc<0 && pPage->nCell>0 ){ + assert( pPage->leaf ); + idx = ++pCur->ix; + pCur->curFlags &= ~BTCF_ValidNKey; + }else{ + assert( pPage->leaf ); + } + rc = insertCellFast(pPage, idx, newCell, szNew); + assert( pPage->nOverflow==0 || rc==SQLITE_OK ); + assert( rc!=SQLITE_OK || pPage->nCell>0 || pPage->nOverflow>0 ); + + /* If no error has occurred and pPage has an overflow cell, call balance() + ** to redistribute the cells within the tree. Since balance() may move + ** the cursor, zero the BtCursor.info.nSize and BTCF_ValidNKey + ** variables. + ** + ** Previous versions of SQLite called moveToRoot() to move the cursor + ** back to the root page as balance() used to invalidate the contents + ** of BtCursor.apPage[] and BtCursor.aiIdx[]. Instead of doing that, + ** set the cursor state to "invalid". This makes common insert operations + ** slightly faster. + ** + ** There is a subtle but important optimization here too. When inserting + ** multiple records into an intkey b-tree using a single cursor (as can + ** happen while processing an "INSERT INTO ... SELECT" statement), it + ** is advantageous to leave the cursor pointing to the last entry in + ** the b-tree if possible. If the cursor is left pointing to the last + ** entry in the table, and the next row inserted has an integer key + ** larger than the largest existing key, it is possible to insert the + ** row without seeking the cursor. This can be a big performance boost. + */ + if( pPage->nOverflow ){ + assert( rc==SQLITE_OK ); + pCur->curFlags &= ~(BTCF_ValidNKey); + rc = balance(pCur); + + /* Must make sure nOverflow is reset to zero even if the balance() + ** fails. Internal data structure corruption will result otherwise. + ** Also, set the cursor state to invalid. This stops saveCursorPosition() + ** from trying to save the current position of the cursor. */ + pCur->pPage->nOverflow = 0; + pCur->eState = CURSOR_INVALID; + if( (flags & BTREE_SAVEPOSITION) && rc==SQLITE_OK ){ + btreeReleaseAllCursorPages(pCur); + if( pCur->pKeyInfo ){ + assert( pCur->pKey==0 ); + pCur->pKey = sqlite3Malloc( pX->nKey ); + if( pCur->pKey==0 ){ + rc = SQLITE_NOMEM; + }else{ + memcpy(pCur->pKey, pX->pKey, pX->nKey); + } + } + pCur->eState = CURSOR_REQUIRESEEK; + pCur->nKey = pX->nKey; + } + } + assert( pCur->iPage<0 || pCur->pPage->nOverflow==0 ); + +end_insert: + return rc; +} + +/* +** This function is used as part of copying the current row from cursor +** pSrc into cursor pDest. If the cursors are open on intkey tables, then +** parameter iKey is used as the rowid value when the record is copied +** into pDest. Otherwise, the record is copied verbatim. +** +** This function does not actually write the new value to cursor pDest. +** Instead, it creates and populates any required overflow pages and +** writes the data for the new cell into the BtShared.pTmpSpace buffer +** for the destination database. The size of the cell, in bytes, is left +** in BtShared.nPreformatSize. The caller completes the insertion by +** calling sqlite3BtreeInsert() with the BTREE_PREFORMAT flag specified. +** +** SQLITE_OK is returned if successful, or an SQLite error code otherwise. +*/ +SQLITE_PRIVATE int sqlite3BtreeTransferRow(BtCursor *pDest, BtCursor *pSrc, i64 iKey){ + BtShared *pBt = pDest->pBt; + u8 *aOut = pBt->pTmpSpace; /* Pointer to next output buffer */ + const u8 *aIn; /* Pointer to next input buffer */ + u32 nIn; /* Size of input buffer aIn[] */ + u32 nRem; /* Bytes of data still to copy */ + + getCellInfo(pSrc); + if( pSrc->info.nPayload<0x80 ){ + *(aOut++) = pSrc->info.nPayload; + }else{ + aOut += sqlite3PutVarint(aOut, pSrc->info.nPayload); + } + if( pDest->pKeyInfo==0 ) aOut += putVarint(aOut, iKey); + nIn = pSrc->info.nLocal; + aIn = pSrc->info.pPayload; + if( aIn+nIn>pSrc->pPage->aDataEnd ){ + return SQLITE_CORRUPT_BKPT; + } + nRem = pSrc->info.nPayload; + if( nIn==nRem && nInpPage->maxLocal ){ + memcpy(aOut, aIn, nIn); + pBt->nPreformatSize = nIn + (aOut - pBt->pTmpSpace); + return SQLITE_OK; + }else{ + int rc = SQLITE_OK; + Pager *pSrcPager = pSrc->pBt->pPager; + u8 *pPgnoOut = 0; + Pgno ovflIn = 0; + DbPage *pPageIn = 0; + MemPage *pPageOut = 0; + u32 nOut; /* Size of output buffer aOut[] */ + + nOut = btreePayloadToLocal(pDest->pPage, pSrc->info.nPayload); + pBt->nPreformatSize = nOut + (aOut - pBt->pTmpSpace); + if( nOutinfo.nPayload ){ + pPgnoOut = &aOut[nOut]; + pBt->nPreformatSize += 4; + } + + if( nRem>nIn ){ + if( aIn+nIn+4>pSrc->pPage->aDataEnd ){ + return SQLITE_CORRUPT_BKPT; + } + ovflIn = get4byte(&pSrc->info.pPayload[nIn]); + } + + do { + nRem -= nOut; + do{ + assert( nOut>0 ); + if( nIn>0 ){ + int nCopy = MIN(nOut, nIn); + memcpy(aOut, aIn, nCopy); + nOut -= nCopy; + nIn -= nCopy; + aOut += nCopy; + aIn += nCopy; + } + if( nOut>0 ){ + sqlite3PagerUnref(pPageIn); + pPageIn = 0; + rc = sqlite3PagerGet(pSrcPager, ovflIn, &pPageIn, PAGER_GET_READONLY); + if( rc==SQLITE_OK ){ + aIn = (const u8*)sqlite3PagerGetData(pPageIn); + ovflIn = get4byte(aIn); + aIn += 4; + nIn = pSrc->pBt->usableSize - 4; + } + } + }while( rc==SQLITE_OK && nOut>0 ); + + if( rc==SQLITE_OK && nRem>0 && ALWAYS(pPgnoOut) ){ + Pgno pgnoNew; + MemPage *pNew = 0; + rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0); + put4byte(pPgnoOut, pgnoNew); + if( ISAUTOVACUUM(pBt) && pPageOut ){ + ptrmapPut(pBt, pgnoNew, PTRMAP_OVERFLOW2, pPageOut->pgno, &rc); + } + releasePage(pPageOut); + pPageOut = pNew; + if( pPageOut ){ + pPgnoOut = pPageOut->aData; + put4byte(pPgnoOut, 0); + aOut = &pPgnoOut[4]; + nOut = MIN(pBt->usableSize - 4, nRem); + } + } + }while( nRem>0 && rc==SQLITE_OK ); + + releasePage(pPageOut); + sqlite3PagerUnref(pPageIn); + return rc; + } +} + +/* +** Delete the entry that the cursor is pointing to. +** +** If the BTREE_SAVEPOSITION bit of the flags parameter is zero, then +** the cursor is left pointing at an arbitrary location after the delete. +** But if that bit is set, then the cursor is left in a state such that +** the next call to BtreeNext() or BtreePrev() moves it to the same row +** as it would have been on if the call to BtreeDelete() had been omitted. +** +** The BTREE_AUXDELETE bit of flags indicates that is one of several deletes +** associated with a single table entry and its indexes. Only one of those +** deletes is considered the "primary" delete. The primary delete occurs +** on a cursor that is not a BTREE_FORDELETE cursor. All but one delete +** operation on non-FORDELETE cursors is tagged with the AUXDELETE flag. +** The BTREE_AUXDELETE bit is a hint that is not used by this implementation, +** but which might be used by alternative storage engines. +*/ +SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){ + Btree *p = pCur->pBtree; + BtShared *pBt = p->pBt; + int rc; /* Return code */ + MemPage *pPage; /* Page to delete cell from */ + unsigned char *pCell; /* Pointer to cell to delete */ + int iCellIdx; /* Index of cell to delete */ + int iCellDepth; /* Depth of node containing pCell */ + CellInfo info; /* Size of the cell being deleted */ + u8 bPreserve; /* Keep cursor valid. 2 for CURSOR_SKIPNEXT */ + + assert( cursorOwnsBtShared(pCur) ); + assert( pBt->inTransaction==TRANS_WRITE ); + assert( (pBt->btsFlags & BTS_READ_ONLY)==0 ); + assert( pCur->curFlags & BTCF_WriteFlag ); + assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) ); + assert( !hasReadConflicts(p, pCur->pgnoRoot) ); + assert( (flags & ~(BTREE_SAVEPOSITION | BTREE_AUXDELETE))==0 ); + if( pCur->eState!=CURSOR_VALID ){ + if( pCur->eState>=CURSOR_REQUIRESEEK ){ + rc = btreeRestoreCursorPosition(pCur); + assert( rc!=SQLITE_OK || CORRUPT_DB || pCur->eState==CURSOR_VALID ); + if( rc || pCur->eState!=CURSOR_VALID ) return rc; + }else{ + return SQLITE_CORRUPT_BKPT; + } + } + assert( pCur->eState==CURSOR_VALID ); + + iCellDepth = pCur->iPage; + iCellIdx = pCur->ix; + pPage = pCur->pPage; + if( pPage->nCell<=iCellIdx ){ + return SQLITE_CORRUPT_BKPT; + } + pCell = findCell(pPage, iCellIdx); + if( pPage->nFree<0 && btreeComputeFreeSpace(pPage) ){ + return SQLITE_CORRUPT_BKPT; + } + if( pCell<&pPage->aCellIdx[pPage->nCell] ){ + return SQLITE_CORRUPT_BKPT; + } + + /* If the BTREE_SAVEPOSITION bit is on, then the cursor position must + ** be preserved following this delete operation. If the current delete + ** will cause a b-tree rebalance, then this is done by saving the cursor + ** key and leaving the cursor in CURSOR_REQUIRESEEK state before + ** returning. + ** + ** If the current delete will not cause a rebalance, then the cursor + ** will be left in CURSOR_SKIPNEXT state pointing to the entry immediately + ** before or after the deleted entry. + ** + ** The bPreserve value records which path is required: + ** + ** bPreserve==0 Not necessary to save the cursor position + ** bPreserve==1 Use CURSOR_REQUIRESEEK to save the cursor position + ** bPreserve==2 Cursor won't move. Set CURSOR_SKIPNEXT. + */ + bPreserve = (flags & BTREE_SAVEPOSITION)!=0; + if( bPreserve ){ + if( !pPage->leaf + || (pPage->nFree+pPage->xCellSize(pPage,pCell)+2) > + (int)(pBt->usableSize*2/3) + || pPage->nCell==1 /* See dbfuzz001.test for a test case */ + ){ + /* A b-tree rebalance will be required after deleting this entry. + ** Save the cursor key. */ + rc = saveCursorKey(pCur); + if( rc ) return rc; + }else{ + bPreserve = 2; + } + } + + /* If the page containing the entry to delete is not a leaf page, move + ** the cursor to the largest entry in the tree that is smaller than + ** the entry being deleted. This cell will replace the cell being deleted + ** from the internal node. The 'previous' entry is used for this instead + ** of the 'next' entry, as the previous entry is always a part of the + ** sub-tree headed by the child page of the cell being deleted. This makes + ** balancing the tree following the delete operation easier. */ + if( !pPage->leaf ){ + rc = sqlite3BtreePrevious(pCur, 0); + assert( rc!=SQLITE_DONE ); + if( rc ) return rc; + } + + /* Save the positions of any other cursors open on this table before + ** making any modifications. */ + if( pCur->curFlags & BTCF_Multiple ){ + rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur); + if( rc ) return rc; + } + + /* If this is a delete operation to remove a row from a table b-tree, + ** invalidate any incrblob cursors open on the row being deleted. */ + if( pCur->pKeyInfo==0 && p->hasIncrblobCur ){ + invalidateIncrblobCursors(p, pCur->pgnoRoot, pCur->info.nKey, 0); + } + + /* Make the page containing the entry to be deleted writable. Then free any + ** overflow pages associated with the entry and finally remove the cell + ** itself from within the page. */ + rc = sqlite3PagerWrite(pPage->pDbPage); + if( rc ) return rc; + BTREE_CLEAR_CELL(rc, pPage, pCell, info); + dropCell(pPage, iCellIdx, info.nSize, &rc); + if( rc ) return rc; + + /* If the cell deleted was not located on a leaf page, then the cursor + ** is currently pointing to the largest entry in the sub-tree headed + ** by the child-page of the cell that was just deleted from an internal + ** node. The cell from the leaf node needs to be moved to the internal + ** node to replace the deleted cell. */ + if( !pPage->leaf ){ + MemPage *pLeaf = pCur->pPage; + int nCell; + Pgno n; + unsigned char *pTmp; + + if( pLeaf->nFree<0 ){ + rc = btreeComputeFreeSpace(pLeaf); + if( rc ) return rc; + } + if( iCellDepthiPage-1 ){ + n = pCur->apPage[iCellDepth+1]->pgno; + }else{ + n = pCur->pPage->pgno; + } + pCell = findCell(pLeaf, pLeaf->nCell-1); + if( pCell<&pLeaf->aData[4] ) return SQLITE_CORRUPT_BKPT; + nCell = pLeaf->xCellSize(pLeaf, pCell); + assert( MX_CELL_SIZE(pBt) >= nCell ); + pTmp = pBt->pTmpSpace; + assert( pTmp!=0 ); + rc = sqlite3PagerWrite(pLeaf->pDbPage); + if( rc==SQLITE_OK ){ + rc = insertCell(pPage, iCellIdx, pCell-4, nCell+4, pTmp, n); + } + dropCell(pLeaf, pLeaf->nCell-1, nCell, &rc); + if( rc ) return rc; + } + + /* Balance the tree. If the entry deleted was located on a leaf page, + ** then the cursor still points to that page. In this case the first + ** call to balance() repairs the tree, and the if(...) condition is + ** never true. + ** + ** Otherwise, if the entry deleted was on an internal node page, then + ** pCur is pointing to the leaf page from which a cell was removed to + ** replace the cell deleted from the internal node. This is slightly + ** tricky as the leaf node may be underfull, and the internal node may + ** be either under or overfull. In this case run the balancing algorithm + ** on the leaf node first. If the balance proceeds far enough up the + ** tree that we can be sure that any problem in the internal node has + ** been corrected, so be it. Otherwise, after balancing the leaf node, + ** walk the cursor up the tree to the internal node and balance it as + ** well. */ + assert( pCur->pPage->nOverflow==0 ); + assert( pCur->pPage->nFree>=0 ); + if( pCur->pPage->nFree*3<=(int)pCur->pBt->usableSize*2 ){ + /* Optimization: If the free space is less than 2/3rds of the page, + ** then balance() will always be a no-op. No need to invoke it. */ + rc = SQLITE_OK; + }else{ + rc = balance(pCur); + } + if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){ + releasePageNotNull(pCur->pPage); + pCur->iPage--; + while( pCur->iPage>iCellDepth ){ + releasePage(pCur->apPage[pCur->iPage--]); + } + pCur->pPage = pCur->apPage[pCur->iPage]; + rc = balance(pCur); + } + + if( rc==SQLITE_OK ){ + if( bPreserve>1 ){ + assert( (pCur->iPage==iCellDepth || CORRUPT_DB) ); + assert( pPage==pCur->pPage || CORRUPT_DB ); + assert( (pPage->nCell>0 || CORRUPT_DB) && iCellIdx<=pPage->nCell ); + pCur->eState = CURSOR_SKIPNEXT; + if( iCellIdx>=pPage->nCell ){ + pCur->skipNext = -1; + pCur->ix = pPage->nCell-1; + }else{ + pCur->skipNext = 1; + } + }else{ + rc = moveToRoot(pCur); + if( bPreserve ){ + btreeReleaseAllCursorPages(pCur); + pCur->eState = CURSOR_REQUIRESEEK; + } + if( rc==SQLITE_EMPTY ) rc = SQLITE_OK; + } + } + return rc; +} + +/* +** Create a new BTree table. Write into *piTable the page +** number for the root page of the new table. +** +** The type of type is determined by the flags parameter. Only the +** following values of flags are currently in use. Other values for +** flags might not work: +** +** BTREE_INTKEY|BTREE_LEAFDATA Used for SQL tables with rowid keys +** BTREE_ZERODATA Used for SQL indices +*/ +static int btreeCreateTable(Btree *p, Pgno *piTable, int createTabFlags){ + BtShared *pBt = p->pBt; + MemPage *pRoot; + Pgno pgnoRoot; + int rc; + int ptfFlags; /* Page-type flage for the root page of new table */ + + assert( sqlite3BtreeHoldsMutex(p) ); + assert( pBt->inTransaction==TRANS_WRITE ); + assert( (pBt->btsFlags & BTS_READ_ONLY)==0 ); + +#ifdef SQLITE_OMIT_AUTOVACUUM + rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0); + if( rc ){ + return rc; + } +#else + if( pBt->autoVacuum ){ + Pgno pgnoMove; /* Move a page here to make room for the root-page */ + MemPage *pPageMove; /* The page to move to. */ + + /* Creating a new table may probably require moving an existing database + ** to make room for the new tables root page. In case this page turns + ** out to be an overflow page, delete all overflow page-map caches + ** held by open cursors. + */ + invalidateAllOverflowCache(pBt); + + /* Read the value of meta[3] from the database to determine where the + ** root page of the new table should go. meta[3] is the largest root-page + ** created so far, so the new root-page is (meta[3]+1). + */ + sqlite3BtreeGetMeta(p, BTREE_LARGEST_ROOT_PAGE, &pgnoRoot); + if( pgnoRoot>btreePagecount(pBt) ){ + return SQLITE_CORRUPT_BKPT; + } + pgnoRoot++; + + /* The new root-page may not be allocated on a pointer-map page, or the + ** PENDING_BYTE page. + */ + while( pgnoRoot==PTRMAP_PAGENO(pBt, pgnoRoot) || + pgnoRoot==PENDING_BYTE_PAGE(pBt) ){ + pgnoRoot++; + } + assert( pgnoRoot>=3 ); + + /* Allocate a page. The page that currently resides at pgnoRoot will + ** be moved to the allocated page (unless the allocated page happens + ** to reside at pgnoRoot). + */ + rc = allocateBtreePage(pBt, &pPageMove, &pgnoMove, pgnoRoot, BTALLOC_EXACT); + if( rc!=SQLITE_OK ){ + return rc; + } + + if( pgnoMove!=pgnoRoot ){ + /* pgnoRoot is the page that will be used for the root-page of + ** the new table (assuming an error did not occur). But we were + ** allocated pgnoMove. If required (i.e. if it was not allocated + ** by extending the file), the current page at position pgnoMove + ** is already journaled. + */ + u8 eType = 0; + Pgno iPtrPage = 0; + + /* Save the positions of any open cursors. This is required in + ** case they are holding a reference to an xFetch reference + ** corresponding to page pgnoRoot. */ + rc = saveAllCursors(pBt, 0, 0); + releasePage(pPageMove); + if( rc!=SQLITE_OK ){ + return rc; + } + + /* Move the page currently at pgnoRoot to pgnoMove. */ + rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = ptrmapGet(pBt, pgnoRoot, &eType, &iPtrPage); + if( eType==PTRMAP_ROOTPAGE || eType==PTRMAP_FREEPAGE ){ + rc = SQLITE_CORRUPT_BKPT; + } + if( rc!=SQLITE_OK ){ + releasePage(pRoot); + return rc; + } + assert( eType!=PTRMAP_ROOTPAGE ); + assert( eType!=PTRMAP_FREEPAGE ); + rc = relocatePage(pBt, pRoot, eType, iPtrPage, pgnoMove, 0); + releasePage(pRoot); + + /* Obtain the page at pgnoRoot */ + if( rc!=SQLITE_OK ){ + return rc; + } + rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = sqlite3PagerWrite(pRoot->pDbPage); + if( rc!=SQLITE_OK ){ + releasePage(pRoot); + return rc; + } + }else{ + pRoot = pPageMove; + } + + /* Update the pointer-map and meta-data with the new root-page number. */ + ptrmapPut(pBt, pgnoRoot, PTRMAP_ROOTPAGE, 0, &rc); + if( rc ){ + releasePage(pRoot); + return rc; + } + + /* When the new root page was allocated, page 1 was made writable in + ** order either to increase the database filesize, or to decrement the + ** freelist count. Hence, the sqlite3BtreeUpdateMeta() call cannot fail. + */ + assert( sqlite3PagerIswriteable(pBt->pPage1->pDbPage) ); + rc = sqlite3BtreeUpdateMeta(p, 4, pgnoRoot); + if( NEVER(rc) ){ + releasePage(pRoot); + return rc; + } + + }else{ + rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0); + if( rc ) return rc; + } +#endif + assert( sqlite3PagerIswriteable(pRoot->pDbPage) ); + if( createTabFlags & BTREE_INTKEY ){ + ptfFlags = PTF_INTKEY | PTF_LEAFDATA | PTF_LEAF; + }else{ + ptfFlags = PTF_ZERODATA | PTF_LEAF; + } + zeroPage(pRoot, ptfFlags); + sqlite3PagerUnref(pRoot->pDbPage); + assert( (pBt->openFlags & BTREE_SINGLE)==0 || pgnoRoot==2 ); + *piTable = pgnoRoot; + return SQLITE_OK; +} +SQLITE_PRIVATE int sqlite3BtreeCreateTable(Btree *p, Pgno *piTable, int flags){ + int rc; + sqlite3BtreeEnter(p); + rc = btreeCreateTable(p, piTable, flags); + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Erase the given database page and all its children. Return +** the page to the freelist. +*/ +static int clearDatabasePage( + BtShared *pBt, /* The BTree that contains the table */ + Pgno pgno, /* Page number to clear */ + int freePageFlag, /* Deallocate page if true */ + i64 *pnChange /* Add number of Cells freed to this counter */ +){ + MemPage *pPage; + int rc; + unsigned char *pCell; + int i; + int hdr; + CellInfo info; + + assert( sqlite3_mutex_held(pBt->mutex) ); + if( pgno>btreePagecount(pBt) ){ + return SQLITE_CORRUPT_BKPT; + } + rc = getAndInitPage(pBt, pgno, &pPage, 0, 0); + if( rc ) return rc; + if( (pBt->openFlags & BTREE_SINGLE)==0 + && sqlite3PagerPageRefcount(pPage->pDbPage) != (1 + (pgno==1)) + ){ + rc = SQLITE_CORRUPT_BKPT; + goto cleardatabasepage_out; + } + hdr = pPage->hdrOffset; + for(i=0; inCell; i++){ + pCell = findCell(pPage, i); + if( !pPage->leaf ){ + rc = clearDatabasePage(pBt, get4byte(pCell), 1, pnChange); + if( rc ) goto cleardatabasepage_out; + } + BTREE_CLEAR_CELL(rc, pPage, pCell, info); + if( rc ) goto cleardatabasepage_out; + } + if( !pPage->leaf ){ + rc = clearDatabasePage(pBt, get4byte(&pPage->aData[hdr+8]), 1, pnChange); + if( rc ) goto cleardatabasepage_out; + if( pPage->intKey ) pnChange = 0; + } + if( pnChange ){ + testcase( !pPage->intKey ); + *pnChange += pPage->nCell; + } + if( freePageFlag ){ + freePage(pPage, &rc); + }else if( (rc = sqlite3PagerWrite(pPage->pDbPage))==0 ){ + zeroPage(pPage, pPage->aData[hdr] | PTF_LEAF); + } + +cleardatabasepage_out: + releasePage(pPage); + return rc; +} + +/* +** Delete all information from a single table in the database. iTable is +** the page number of the root of the table. After this routine returns, +** the root page is empty, but still exists. +** +** This routine will fail with SQLITE_LOCKED if there are any open +** read cursors on the table. Open write cursors are moved to the +** root of the table. +** +** If pnChange is not NULL, then the integer value pointed to by pnChange +** is incremented by the number of entries in the table. +*/ +SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree *p, int iTable, i64 *pnChange){ + int rc; + BtShared *pBt = p->pBt; + sqlite3BtreeEnter(p); + assert( p->inTrans==TRANS_WRITE ); + + rc = saveAllCursors(pBt, (Pgno)iTable, 0); + + if( SQLITE_OK==rc ){ + /* Invalidate all incrblob cursors open on table iTable (assuming iTable + ** is the root of a table b-tree - if it is not, the following call is + ** a no-op). */ + if( p->hasIncrblobCur ){ + invalidateIncrblobCursors(p, (Pgno)iTable, 0, 1); + } + rc = clearDatabasePage(pBt, (Pgno)iTable, 0, pnChange); + } + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Delete all information from the single table that pCur is open on. +** +** This routine only work for pCur on an ephemeral table. +*/ +SQLITE_PRIVATE int sqlite3BtreeClearTableOfCursor(BtCursor *pCur){ + return sqlite3BtreeClearTable(pCur->pBtree, pCur->pgnoRoot, 0); +} + +/* +** Erase all information in a table and add the root of the table to +** the freelist. Except, the root of the principle table (the one on +** page 1) is never added to the freelist. +** +** This routine will fail with SQLITE_LOCKED if there are any open +** cursors on the table. +** +** If AUTOVACUUM is enabled and the page at iTable is not the last +** root page in the database file, then the last root page +** in the database file is moved into the slot formerly occupied by +** iTable and that last slot formerly occupied by the last root page +** is added to the freelist instead of iTable. In this say, all +** root pages are kept at the beginning of the database file, which +** is necessary for AUTOVACUUM to work right. *piMoved is set to the +** page number that used to be the last root page in the file before +** the move. If no page gets moved, *piMoved is set to 0. +** The last root page is recorded in meta[3] and the value of +** meta[3] is updated by this procedure. +*/ +static int btreeDropTable(Btree *p, Pgno iTable, int *piMoved){ + int rc; + MemPage *pPage = 0; + BtShared *pBt = p->pBt; + + assert( sqlite3BtreeHoldsMutex(p) ); + assert( p->inTrans==TRANS_WRITE ); + assert( iTable>=2 ); + if( iTable>btreePagecount(pBt) ){ + return SQLITE_CORRUPT_BKPT; + } + + rc = sqlite3BtreeClearTable(p, iTable, 0); + if( rc ) return rc; + rc = btreeGetPage(pBt, (Pgno)iTable, &pPage, 0); + if( NEVER(rc) ){ + releasePage(pPage); + return rc; + } + + *piMoved = 0; + +#ifdef SQLITE_OMIT_AUTOVACUUM + freePage(pPage, &rc); + releasePage(pPage); +#else + if( pBt->autoVacuum ){ + Pgno maxRootPgno; + sqlite3BtreeGetMeta(p, BTREE_LARGEST_ROOT_PAGE, &maxRootPgno); + + if( iTable==maxRootPgno ){ + /* If the table being dropped is the table with the largest root-page + ** number in the database, put the root page on the free list. + */ + freePage(pPage, &rc); + releasePage(pPage); + if( rc!=SQLITE_OK ){ + return rc; + } + }else{ + /* The table being dropped does not have the largest root-page + ** number in the database. So move the page that does into the + ** gap left by the deleted root-page. + */ + MemPage *pMove; + releasePage(pPage); + rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = relocatePage(pBt, pMove, PTRMAP_ROOTPAGE, 0, iTable, 0); + releasePage(pMove); + if( rc!=SQLITE_OK ){ + return rc; + } + pMove = 0; + rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0); + freePage(pMove, &rc); + releasePage(pMove); + if( rc!=SQLITE_OK ){ + return rc; + } + *piMoved = maxRootPgno; + } + + /* Set the new 'max-root-page' value in the database header. This + ** is the old value less one, less one more if that happens to + ** be a root-page number, less one again if that is the + ** PENDING_BYTE_PAGE. + */ + maxRootPgno--; + while( maxRootPgno==PENDING_BYTE_PAGE(pBt) + || PTRMAP_ISPAGE(pBt, maxRootPgno) ){ + maxRootPgno--; + } + assert( maxRootPgno!=PENDING_BYTE_PAGE(pBt) ); + + rc = sqlite3BtreeUpdateMeta(p, 4, maxRootPgno); + }else{ + freePage(pPage, &rc); + releasePage(pPage); + } +#endif + return rc; +} +SQLITE_PRIVATE int sqlite3BtreeDropTable(Btree *p, int iTable, int *piMoved){ + int rc; + sqlite3BtreeEnter(p); + rc = btreeDropTable(p, iTable, piMoved); + sqlite3BtreeLeave(p); + return rc; +} + + +/* +** This function may only be called if the b-tree connection already +** has a read or write transaction open on the database. +** +** Read the meta-information out of a database file. Meta[0] +** is the number of free pages currently in the database. Meta[1] +** through meta[15] are available for use by higher layers. Meta[0] +** is read-only, the others are read/write. +** +** The schema layer numbers meta values differently. At the schema +** layer (and the SetCookie and ReadCookie opcodes) the number of +** free pages is not visible. So Cookie[0] is the same as Meta[1]. +** +** This routine treats Meta[BTREE_DATA_VERSION] as a special case. Instead +** of reading the value out of the header, it instead loads the "DataVersion" +** from the pager. The BTREE_DATA_VERSION value is not actually stored in the +** database file. It is a number computed by the pager. But its access +** pattern is the same as header meta values, and so it is convenient to +** read it from this routine. +*/ +SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){ + BtShared *pBt = p->pBt; + + sqlite3BtreeEnter(p); + assert( p->inTrans>TRANS_NONE ); + assert( SQLITE_OK==querySharedCacheTableLock(p, SCHEMA_ROOT, READ_LOCK) ); + assert( pBt->pPage1 ); + assert( idx>=0 && idx<=15 ); + + if( idx==BTREE_DATA_VERSION ){ + *pMeta = sqlite3PagerDataVersion(pBt->pPager) + p->iBDataVersion; + }else{ + *pMeta = get4byte(&pBt->pPage1->aData[36 + idx*4]); + } + + /* If auto-vacuum is disabled in this build and this is an auto-vacuum + ** database, mark the database as read-only. */ +#ifdef SQLITE_OMIT_AUTOVACUUM + if( idx==BTREE_LARGEST_ROOT_PAGE && *pMeta>0 ){ + pBt->btsFlags |= BTS_READ_ONLY; + } +#endif + + sqlite3BtreeLeave(p); +} + +/* +** Write meta-information back into the database. Meta[0] is +** read-only and may not be written. +*/ +SQLITE_PRIVATE int sqlite3BtreeUpdateMeta(Btree *p, int idx, u32 iMeta){ + BtShared *pBt = p->pBt; + unsigned char *pP1; + int rc; + assert( idx>=1 && idx<=15 ); + sqlite3BtreeEnter(p); + assert( p->inTrans==TRANS_WRITE ); + assert( pBt->pPage1!=0 ); + pP1 = pBt->pPage1->aData; + rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); + if( rc==SQLITE_OK ){ + put4byte(&pP1[36 + idx*4], iMeta); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( idx==BTREE_INCR_VACUUM ){ + assert( pBt->autoVacuum || iMeta==0 ); + assert( iMeta==0 || iMeta==1 ); + pBt->incrVacuum = (u8)iMeta; + } +#endif + } + sqlite3BtreeLeave(p); + return rc; +} + +/* +** The first argument, pCur, is a cursor opened on some b-tree. Count the +** number of entries in the b-tree and write the result to *pnEntry. +** +** SQLITE_OK is returned if the operation is successfully executed. +** Otherwise, if an error is encountered (i.e. an IO error or database +** corruption) an SQLite error code is returned. +*/ +SQLITE_PRIVATE int sqlite3BtreeCount(sqlite3 *db, BtCursor *pCur, i64 *pnEntry){ + i64 nEntry = 0; /* Value to return in *pnEntry */ + int rc; /* Return code */ + + rc = moveToRoot(pCur); + if( rc==SQLITE_EMPTY ){ + *pnEntry = 0; + return SQLITE_OK; + } + + /* Unless an error occurs, the following loop runs one iteration for each + ** page in the B-Tree structure (not including overflow pages). + */ + while( rc==SQLITE_OK && !AtomicLoad(&db->u1.isInterrupted) ){ + int iIdx; /* Index of child node in parent */ + MemPage *pPage; /* Current page of the b-tree */ + + /* If this is a leaf page or the tree is not an int-key tree, then + ** this page contains countable entries. Increment the entry counter + ** accordingly. + */ + pPage = pCur->pPage; + if( pPage->leaf || !pPage->intKey ){ + nEntry += pPage->nCell; + } + + /* pPage is a leaf node. This loop navigates the cursor so that it + ** points to the first interior cell that it points to the parent of + ** the next page in the tree that has not yet been visited. The + ** pCur->aiIdx[pCur->iPage] value is set to the index of the parent cell + ** of the page, or to the number of cells in the page if the next page + ** to visit is the right-child of its parent. + ** + ** If all pages in the tree have been visited, return SQLITE_OK to the + ** caller. + */ + if( pPage->leaf ){ + do { + if( pCur->iPage==0 ){ + /* All pages of the b-tree have been visited. Return successfully. */ + *pnEntry = nEntry; + return moveToRoot(pCur); + } + moveToParent(pCur); + }while ( pCur->ix>=pCur->pPage->nCell ); + + pCur->ix++; + pPage = pCur->pPage; + } + + /* Descend to the child node of the cell that the cursor currently + ** points at. This is the right-child if (iIdx==pPage->nCell). + */ + iIdx = pCur->ix; + if( iIdx==pPage->nCell ){ + rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8])); + }else{ + rc = moveToChild(pCur, get4byte(findCell(pPage, iIdx))); + } + } + + /* An error has occurred. Return an error code. */ + return rc; +} + +/* +** Return the pager associated with a BTree. This routine is used for +** testing and debugging only. +*/ +SQLITE_PRIVATE Pager *sqlite3BtreePager(Btree *p){ + return p->pBt->pPager; +} + +#ifndef SQLITE_OMIT_INTEGRITY_CHECK +/* +** Record an OOM error during integrity_check +*/ +static void checkOom(IntegrityCk *pCheck){ + pCheck->rc = SQLITE_NOMEM; + pCheck->mxErr = 0; /* Causes integrity_check processing to stop */ + if( pCheck->nErr==0 ) pCheck->nErr++; +} + +/* +** Invoke the progress handler, if appropriate. Also check for an +** interrupt. +*/ +static void checkProgress(IntegrityCk *pCheck){ + sqlite3 *db = pCheck->db; + if( AtomicLoad(&db->u1.isInterrupted) ){ + pCheck->rc = SQLITE_INTERRUPT; + pCheck->nErr++; + pCheck->mxErr = 0; + } +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + if( db->xProgress ){ + assert( db->nProgressOps>0 ); + pCheck->nStep++; + if( (pCheck->nStep % db->nProgressOps)==0 + && db->xProgress(db->pProgressArg) + ){ + pCheck->rc = SQLITE_INTERRUPT; + pCheck->nErr++; + pCheck->mxErr = 0; + } + } +#endif +} + +/* +** Append a message to the error message string. +*/ +static void checkAppendMsg( + IntegrityCk *pCheck, + const char *zFormat, + ... +){ + va_list ap; + checkProgress(pCheck); + if( !pCheck->mxErr ) return; + pCheck->mxErr--; + pCheck->nErr++; + va_start(ap, zFormat); + if( pCheck->errMsg.nChar ){ + sqlite3_str_append(&pCheck->errMsg, "\n", 1); + } + if( pCheck->zPfx ){ + sqlite3_str_appendf(&pCheck->errMsg, pCheck->zPfx, + pCheck->v0, pCheck->v1, pCheck->v2); + } + sqlite3_str_vappendf(&pCheck->errMsg, zFormat, ap); + va_end(ap); + if( pCheck->errMsg.accError==SQLITE_NOMEM ){ + checkOom(pCheck); + } +} +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +#ifndef SQLITE_OMIT_INTEGRITY_CHECK + +/* +** Return non-zero if the bit in the IntegrityCk.aPgRef[] array that +** corresponds to page iPg is already set. +*/ +static int getPageReferenced(IntegrityCk *pCheck, Pgno iPg){ + assert( iPg<=pCheck->nPage && sizeof(pCheck->aPgRef[0])==1 ); + return (pCheck->aPgRef[iPg/8] & (1 << (iPg & 0x07))); +} + +/* +** Set the bit in the IntegrityCk.aPgRef[] array that corresponds to page iPg. +*/ +static void setPageReferenced(IntegrityCk *pCheck, Pgno iPg){ + assert( iPg<=pCheck->nPage && sizeof(pCheck->aPgRef[0])==1 ); + pCheck->aPgRef[iPg/8] |= (1 << (iPg & 0x07)); +} + + +/* +** Add 1 to the reference count for page iPage. If this is the second +** reference to the page, add an error message to pCheck->zErrMsg. +** Return 1 if there are 2 or more references to the page and 0 if +** if this is the first reference to the page. +** +** Also check that the page number is in bounds. +*/ +static int checkRef(IntegrityCk *pCheck, Pgno iPage){ + if( iPage>pCheck->nPage || iPage==0 ){ + checkAppendMsg(pCheck, "invalid page number %u", iPage); + return 1; + } + if( getPageReferenced(pCheck, iPage) ){ + checkAppendMsg(pCheck, "2nd reference to page %u", iPage); + return 1; + } + setPageReferenced(pCheck, iPage); + return 0; +} + +#ifndef SQLITE_OMIT_AUTOVACUUM +/* +** Check that the entry in the pointer-map for page iChild maps to +** page iParent, pointer type ptrType. If not, append an error message +** to pCheck. +*/ +static void checkPtrmap( + IntegrityCk *pCheck, /* Integrity check context */ + Pgno iChild, /* Child page number */ + u8 eType, /* Expected pointer map type */ + Pgno iParent /* Expected pointer map parent page number */ +){ + int rc; + u8 ePtrmapType; + Pgno iPtrmapParent; + + rc = ptrmapGet(pCheck->pBt, iChild, &ePtrmapType, &iPtrmapParent); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ) checkOom(pCheck); + checkAppendMsg(pCheck, "Failed to read ptrmap key=%u", iChild); + return; + } + + if( ePtrmapType!=eType || iPtrmapParent!=iParent ){ + checkAppendMsg(pCheck, + "Bad ptr map entry key=%u expected=(%u,%u) got=(%u,%u)", + iChild, eType, iParent, ePtrmapType, iPtrmapParent); + } +} +#endif + +/* +** Check the integrity of the freelist or of an overflow page list. +** Verify that the number of pages on the list is N. +*/ +static void checkList( + IntegrityCk *pCheck, /* Integrity checking context */ + int isFreeList, /* True for a freelist. False for overflow page list */ + Pgno iPage, /* Page number for first page in the list */ + u32 N /* Expected number of pages in the list */ +){ + int i; + u32 expected = N; + int nErrAtStart = pCheck->nErr; + while( iPage!=0 && pCheck->mxErr ){ + DbPage *pOvflPage; + unsigned char *pOvflData; + if( checkRef(pCheck, iPage) ) break; + N--; + if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage, 0) ){ + checkAppendMsg(pCheck, "failed to get page %u", iPage); + break; + } + pOvflData = (unsigned char *)sqlite3PagerGetData(pOvflPage); + if( isFreeList ){ + u32 n = (u32)get4byte(&pOvflData[4]); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pCheck->pBt->autoVacuum ){ + checkPtrmap(pCheck, iPage, PTRMAP_FREEPAGE, 0); + } +#endif + if( n>pCheck->pBt->usableSize/4-2 ){ + checkAppendMsg(pCheck, + "freelist leaf count too big on page %u", iPage); + N--; + }else{ + for(i=0; i<(int)n; i++){ + Pgno iFreePage = get4byte(&pOvflData[8+i*4]); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pCheck->pBt->autoVacuum ){ + checkPtrmap(pCheck, iFreePage, PTRMAP_FREEPAGE, 0); + } +#endif + checkRef(pCheck, iFreePage); + } + N -= n; + } + } +#ifndef SQLITE_OMIT_AUTOVACUUM + else{ + /* If this database supports auto-vacuum and iPage is not the last + ** page in this overflow list, check that the pointer-map entry for + ** the following page matches iPage. + */ + if( pCheck->pBt->autoVacuum && N>0 ){ + i = get4byte(pOvflData); + checkPtrmap(pCheck, i, PTRMAP_OVERFLOW2, iPage); + } + } +#endif + iPage = get4byte(pOvflData); + sqlite3PagerUnref(pOvflPage); + } + if( N && nErrAtStart==pCheck->nErr ){ + checkAppendMsg(pCheck, + "%s is %u but should be %u", + isFreeList ? "size" : "overflow list length", + expected-N, expected); + } +} +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +/* +** An implementation of a min-heap. +** +** aHeap[0] is the number of elements on the heap. aHeap[1] is the +** root element. The daughter nodes of aHeap[N] are aHeap[N*2] +** and aHeap[N*2+1]. +** +** The heap property is this: Every node is less than or equal to both +** of its daughter nodes. A consequence of the heap property is that the +** root node aHeap[1] is always the minimum value currently in the heap. +** +** The btreeHeapInsert() routine inserts an unsigned 32-bit number onto +** the heap, preserving the heap property. The btreeHeapPull() routine +** removes the root element from the heap (the minimum value in the heap) +** and then moves other nodes around as necessary to preserve the heap +** property. +** +** This heap is used for cell overlap and coverage testing. Each u32 +** entry represents the span of a cell or freeblock on a btree page. +** The upper 16 bits are the index of the first byte of a range and the +** lower 16 bits are the index of the last byte of that range. +*/ +static void btreeHeapInsert(u32 *aHeap, u32 x){ + u32 j, i; + assert( aHeap!=0 ); + i = ++aHeap[0]; + aHeap[i] = x; + while( (j = i/2)>0 && aHeap[j]>aHeap[i] ){ + x = aHeap[j]; + aHeap[j] = aHeap[i]; + aHeap[i] = x; + i = j; + } +} +static int btreeHeapPull(u32 *aHeap, u32 *pOut){ + u32 j, i, x; + if( (x = aHeap[0])==0 ) return 0; + *pOut = aHeap[1]; + aHeap[1] = aHeap[x]; + aHeap[x] = 0xffffffff; + aHeap[0]--; + i = 1; + while( (j = i*2)<=aHeap[0] ){ + if( aHeap[j]>aHeap[j+1] ) j++; + if( aHeap[i]zPfx; + int saved_v1 = pCheck->v1; + int saved_v2 = pCheck->v2; + u8 savedIsInit = 0; + + /* Check that the page exists + */ + checkProgress(pCheck); + if( pCheck->mxErr==0 ) goto end_of_check; + pBt = pCheck->pBt; + usableSize = pBt->usableSize; + if( iPage==0 ) return 0; + if( checkRef(pCheck, iPage) ) return 0; + pCheck->zPfx = "Tree %u page %u: "; + pCheck->v0 = pCheck->v1 = iPage; + if( (rc = btreeGetPage(pBt, iPage, &pPage, 0))!=0 ){ + checkAppendMsg(pCheck, + "unable to get the page. error code=%d", rc); + goto end_of_check; + } + + /* Clear MemPage.isInit to make sure the corruption detection code in + ** btreeInitPage() is executed. */ + savedIsInit = pPage->isInit; + pPage->isInit = 0; + if( (rc = btreeInitPage(pPage))!=0 ){ + assert( rc==SQLITE_CORRUPT ); /* The only possible error from InitPage */ + checkAppendMsg(pCheck, + "btreeInitPage() returns error code %d", rc); + goto end_of_check; + } + if( (rc = btreeComputeFreeSpace(pPage))!=0 ){ + assert( rc==SQLITE_CORRUPT ); + checkAppendMsg(pCheck, "free space corruption", rc); + goto end_of_check; + } + data = pPage->aData; + hdr = pPage->hdrOffset; + + /* Set up for cell analysis */ + pCheck->zPfx = "Tree %u page %u cell %u: "; + contentOffset = get2byteNotZero(&data[hdr+5]); + assert( contentOffset<=usableSize ); /* Enforced by btreeInitPage() */ + + /* EVIDENCE-OF: R-37002-32774 The two-byte integer at offset 3 gives the + ** number of cells on the page. */ + nCell = get2byte(&data[hdr+3]); + assert( pPage->nCell==nCell ); + + /* EVIDENCE-OF: R-23882-45353 The cell pointer array of a b-tree page + ** immediately follows the b-tree page header. */ + cellStart = hdr + 12 - 4*pPage->leaf; + assert( pPage->aCellIdx==&data[cellStart] ); + pCellIdx = &data[cellStart + 2*(nCell-1)]; + + if( !pPage->leaf ){ + /* Analyze the right-child page of internal pages */ + pgno = get4byte(&data[hdr+8]); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + pCheck->zPfx = "Tree %u page %u right child: "; + checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage); + } +#endif + depth = checkTreePage(pCheck, pgno, &maxKey, maxKey); + keyCanBeEqual = 0; + }else{ + /* For leaf pages, the coverage check will occur in the same loop + ** as the other cell checks, so initialize the heap. */ + heap = pCheck->heap; + heap[0] = 0; + } + + /* EVIDENCE-OF: R-02776-14802 The cell pointer array consists of K 2-byte + ** integer offsets to the cell contents. */ + for(i=nCell-1; i>=0 && pCheck->mxErr; i--){ + CellInfo info; + + /* Check cell size */ + pCheck->v2 = i; + assert( pCellIdx==&data[cellStart + i*2] ); + pc = get2byteAligned(pCellIdx); + pCellIdx -= 2; + if( pcusableSize-4 ){ + checkAppendMsg(pCheck, "Offset %u out of range %u..%u", + pc, contentOffset, usableSize-4); + doCoverageCheck = 0; + continue; + } + pCell = &data[pc]; + pPage->xParseCell(pPage, pCell, &info); + if( pc+info.nSize>usableSize ){ + checkAppendMsg(pCheck, "Extends off end of page"); + doCoverageCheck = 0; + continue; + } + + /* Check for integer primary key out of range */ + if( pPage->intKey ){ + if( keyCanBeEqual ? (info.nKey > maxKey) : (info.nKey >= maxKey) ){ + checkAppendMsg(pCheck, "Rowid %lld out of order", info.nKey); + } + maxKey = info.nKey; + keyCanBeEqual = 0; /* Only the first key on the page may ==maxKey */ + } + + /* Check the content overflow list */ + if( info.nPayload>info.nLocal ){ + u32 nPage; /* Number of pages on the overflow chain */ + Pgno pgnoOvfl; /* First page of the overflow chain */ + assert( pc + info.nSize - 4 <= usableSize ); + nPage = (info.nPayload - info.nLocal + usableSize - 5)/(usableSize - 4); + pgnoOvfl = get4byte(&pCell[info.nSize - 4]); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + checkPtrmap(pCheck, pgnoOvfl, PTRMAP_OVERFLOW1, iPage); + } +#endif + checkList(pCheck, 0, pgnoOvfl, nPage); + } + + if( !pPage->leaf ){ + /* Check sanity of left child page for internal pages */ + pgno = get4byte(pCell); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage); + } +#endif + d2 = checkTreePage(pCheck, pgno, &maxKey, maxKey); + keyCanBeEqual = 0; + if( d2!=depth ){ + checkAppendMsg(pCheck, "Child page depth differs"); + depth = d2; + } + }else{ + /* Populate the coverage-checking heap for leaf pages */ + btreeHeapInsert(heap, (pc<<16)|(pc+info.nSize-1)); + } + } + *piMinKey = maxKey; + + /* Check for complete coverage of the page + */ + pCheck->zPfx = 0; + if( doCoverageCheck && pCheck->mxErr>0 ){ + /* For leaf pages, the min-heap has already been initialized and the + ** cells have already been inserted. But for internal pages, that has + ** not yet been done, so do it now */ + if( !pPage->leaf ){ + heap = pCheck->heap; + heap[0] = 0; + for(i=nCell-1; i>=0; i--){ + u32 size; + pc = get2byteAligned(&data[cellStart+i*2]); + size = pPage->xCellSize(pPage, &data[pc]); + btreeHeapInsert(heap, (pc<<16)|(pc+size-1)); + } + } + /* Add the freeblocks to the min-heap + ** + ** EVIDENCE-OF: R-20690-50594 The second field of the b-tree page header + ** is the offset of the first freeblock, or zero if there are no + ** freeblocks on the page. + */ + i = get2byte(&data[hdr+1]); + while( i>0 ){ + int size, j; + assert( (u32)i<=usableSize-4 ); /* Enforced by btreeComputeFreeSpace() */ + size = get2byte(&data[i+2]); + assert( (u32)(i+size)<=usableSize ); /* due to btreeComputeFreeSpace() */ + btreeHeapInsert(heap, (((u32)i)<<16)|(i+size-1)); + /* EVIDENCE-OF: R-58208-19414 The first 2 bytes of a freeblock are a + ** big-endian integer which is the offset in the b-tree page of the next + ** freeblock in the chain, or zero if the freeblock is the last on the + ** chain. */ + j = get2byte(&data[i]); + /* EVIDENCE-OF: R-06866-39125 Freeblocks are always connected in order of + ** increasing offset. */ + assert( j==0 || j>i+size ); /* Enforced by btreeComputeFreeSpace() */ + assert( (u32)j<=usableSize-4 ); /* Enforced by btreeComputeFreeSpace() */ + i = j; + } + /* Analyze the min-heap looking for overlap between cells and/or + ** freeblocks, and counting the number of untracked bytes in nFrag. + ** + ** Each min-heap entry is of the form: (start_address<<16)|end_address. + ** There is an implied first entry the covers the page header, the cell + ** pointer index, and the gap between the cell pointer index and the start + ** of cell content. + ** + ** The loop below pulls entries from the min-heap in order and compares + ** the start_address against the previous end_address. If there is an + ** overlap, that means bytes are used multiple times. If there is a gap, + ** that gap is added to the fragmentation count. + */ + nFrag = 0; + prev = contentOffset - 1; /* Implied first min-heap entry */ + while( btreeHeapPull(heap,&x) ){ + if( (prev&0xffff)>=(x>>16) ){ + checkAppendMsg(pCheck, + "Multiple uses for byte %u of page %u", x>>16, iPage); + break; + }else{ + nFrag += (x>>16) - (prev&0xffff) - 1; + prev = x; + } + } + nFrag += usableSize - (prev&0xffff) - 1; + /* EVIDENCE-OF: R-43263-13491 The total number of bytes in all fragments + ** is stored in the fifth field of the b-tree page header. + ** EVIDENCE-OF: R-07161-27322 The one-byte integer at offset 7 gives the + ** number of fragmented free bytes within the cell content area. + */ + if( heap[0]==0 && nFrag!=data[hdr+7] ){ + checkAppendMsg(pCheck, + "Fragmentation of %u bytes reported as %u on page %u", + nFrag, data[hdr+7], iPage); + } + } + +end_of_check: + if( !doCoverageCheck ) pPage->isInit = savedIsInit; + releasePage(pPage); + pCheck->zPfx = saved_zPfx; + pCheck->v1 = saved_v1; + pCheck->v2 = saved_v2; + return depth+1; +} +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +#ifndef SQLITE_OMIT_INTEGRITY_CHECK +/* +** This routine does a complete check of the given BTree file. aRoot[] is +** an array of pages numbers were each page number is the root page of +** a table. nRoot is the number of entries in aRoot. +** +** A read-only or read-write transaction must be opened before calling +** this function. +** +** Write the number of error seen in *pnErr. Except for some memory +** allocation errors, an error message held in memory obtained from +** malloc is returned if *pnErr is non-zero. If *pnErr==0 then NULL is +** returned. If a memory allocation error occurs, NULL is returned. +** +** If the first entry in aRoot[] is 0, that indicates that the list of +** root pages is incomplete. This is a "partial integrity-check". This +** happens when performing an integrity check on a single table. The +** zero is skipped, of course. But in addition, the freelist checks +** and the checks to make sure every page is referenced are also skipped, +** since obviously it is not possible to know which pages are covered by +** the unverified btrees. Except, if aRoot[1] is 1, then the freelist +** checks are still performed. +*/ +SQLITE_PRIVATE int sqlite3BtreeIntegrityCheck( + sqlite3 *db, /* Database connection that is running the check */ + Btree *p, /* The btree to be checked */ + Pgno *aRoot, /* An array of root pages numbers for individual trees */ + int nRoot, /* Number of entries in aRoot[] */ + int mxErr, /* Stop reporting errors after this many */ + int *pnErr, /* OUT: Write number of errors seen to this variable */ + char **pzOut /* OUT: Write the error message string here */ +){ + Pgno i; + IntegrityCk sCheck; + BtShared *pBt = p->pBt; + u64 savedDbFlags = pBt->db->flags; + char zErr[100]; + int bPartial = 0; /* True if not checking all btrees */ + int bCkFreelist = 1; /* True to scan the freelist */ + VVA_ONLY( int nRef ); + assert( nRoot>0 ); + + /* aRoot[0]==0 means this is a partial check */ + if( aRoot[0]==0 ){ + assert( nRoot>1 ); + bPartial = 1; + if( aRoot[1]!=1 ) bCkFreelist = 0; + } + + sqlite3BtreeEnter(p); + assert( p->inTrans>TRANS_NONE && pBt->inTransaction>TRANS_NONE ); + VVA_ONLY( nRef = sqlite3PagerRefcount(pBt->pPager) ); + assert( nRef>=0 ); + memset(&sCheck, 0, sizeof(sCheck)); + sCheck.db = db; + sCheck.pBt = pBt; + sCheck.pPager = pBt->pPager; + sCheck.nPage = btreePagecount(sCheck.pBt); + sCheck.mxErr = mxErr; + sqlite3StrAccumInit(&sCheck.errMsg, 0, zErr, sizeof(zErr), SQLITE_MAX_LENGTH); + sCheck.errMsg.printfFlags = SQLITE_PRINTF_INTERNAL; + if( sCheck.nPage==0 ){ + goto integrity_ck_cleanup; + } + + sCheck.aPgRef = sqlite3MallocZero((sCheck.nPage / 8)+ 1); + if( !sCheck.aPgRef ){ + checkOom(&sCheck); + goto integrity_ck_cleanup; + } + sCheck.heap = (u32*)sqlite3PageMalloc( pBt->pageSize ); + if( sCheck.heap==0 ){ + checkOom(&sCheck); + goto integrity_ck_cleanup; + } + + i = PENDING_BYTE_PAGE(pBt); + if( i<=sCheck.nPage ) setPageReferenced(&sCheck, i); + + /* Check the integrity of the freelist + */ + if( bCkFreelist ){ + sCheck.zPfx = "Freelist: "; + checkList(&sCheck, 1, get4byte(&pBt->pPage1->aData[32]), + get4byte(&pBt->pPage1->aData[36])); + sCheck.zPfx = 0; + } + + /* Check all the tables. + */ +#ifndef SQLITE_OMIT_AUTOVACUUM + if( !bPartial ){ + if( pBt->autoVacuum ){ + Pgno mx = 0; + Pgno mxInHdr; + for(i=0; (int)ipPage1->aData[52]); + if( mx!=mxInHdr ){ + checkAppendMsg(&sCheck, + "max rootpage (%u) disagrees with header (%u)", + mx, mxInHdr + ); + } + }else if( get4byte(&pBt->pPage1->aData[64])!=0 ){ + checkAppendMsg(&sCheck, + "incremental_vacuum enabled with a max rootpage of zero" + ); + } + } +#endif + testcase( pBt->db->flags & SQLITE_CellSizeCk ); + pBt->db->flags &= ~(u64)SQLITE_CellSizeCk; + for(i=0; (int)iautoVacuum && aRoot[i]>1 && !bPartial ){ + checkPtrmap(&sCheck, aRoot[i], PTRMAP_ROOTPAGE, 0); + } +#endif + checkTreePage(&sCheck, aRoot[i], ¬Used, LARGEST_INT64); + } + pBt->db->flags = savedDbFlags; + + /* Make sure every page in the file is referenced + */ + if( !bPartial ){ + for(i=1; i<=sCheck.nPage && sCheck.mxErr; i++){ +#ifdef SQLITE_OMIT_AUTOVACUUM + if( getPageReferenced(&sCheck, i)==0 ){ + checkAppendMsg(&sCheck, "Page %u: never used", i); + } +#else + /* If the database supports auto-vacuum, make sure no tables contain + ** references to pointer-map pages. + */ + if( getPageReferenced(&sCheck, i)==0 && + (PTRMAP_PAGENO(pBt, i)!=i || !pBt->autoVacuum) ){ + checkAppendMsg(&sCheck, "Page %u: never used", i); + } + if( getPageReferenced(&sCheck, i)!=0 && + (PTRMAP_PAGENO(pBt, i)==i && pBt->autoVacuum) ){ + checkAppendMsg(&sCheck, "Page %u: pointer map referenced", i); + } +#endif + } + } + + /* Clean up and report errors. + */ +integrity_ck_cleanup: + sqlite3PageFree(sCheck.heap); + sqlite3_free(sCheck.aPgRef); + *pnErr = sCheck.nErr; + if( sCheck.nErr==0 ){ + sqlite3_str_reset(&sCheck.errMsg); + *pzOut = 0; + }else{ + *pzOut = sqlite3StrAccumFinish(&sCheck.errMsg); + } + /* Make sure this analysis did not leave any unref() pages. */ + assert( nRef==sqlite3PagerRefcount(pBt->pPager) ); + sqlite3BtreeLeave(p); + return sCheck.rc; +} +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +/* +** Return the full pathname of the underlying database file. Return +** an empty string if the database is in-memory or a TEMP database. +** +** The pager filename is invariant as long as the pager is +** open so it is safe to access without the BtShared mutex. +*/ +SQLITE_PRIVATE const char *sqlite3BtreeGetFilename(Btree *p){ + assert( p->pBt->pPager!=0 ); + return sqlite3PagerFilename(p->pBt->pPager, 1); +} + +/* +** Return the pathname of the journal file for this database. The return +** value of this routine is the same regardless of whether the journal file +** has been created or not. +** +** The pager journal filename is invariant as long as the pager is +** open so it is safe to access without the BtShared mutex. +*/ +SQLITE_PRIVATE const char *sqlite3BtreeGetJournalname(Btree *p){ + assert( p->pBt->pPager!=0 ); + return sqlite3PagerJournalname(p->pBt->pPager); +} + +/* +** Return one of SQLITE_TXN_NONE, SQLITE_TXN_READ, or SQLITE_TXN_WRITE +** to describe the current transaction state of Btree p. +*/ +SQLITE_PRIVATE int sqlite3BtreeTxnState(Btree *p){ + assert( p==0 || sqlite3_mutex_held(p->db->mutex) ); + return p ? p->inTrans : 0; +} + +#ifndef SQLITE_OMIT_WAL +/* +** Run a checkpoint on the Btree passed as the first argument. +** +** Return SQLITE_LOCKED if this or any other connection has an open +** transaction on the shared-cache the argument Btree is connected to. +** +** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART. +*/ +SQLITE_PRIVATE int sqlite3BtreeCheckpoint(Btree *p, int eMode, int *pnLog, int *pnCkpt){ + int rc = SQLITE_OK; + if( p ){ + BtShared *pBt = p->pBt; + sqlite3BtreeEnter(p); + if( pBt->inTransaction!=TRANS_NONE ){ + rc = SQLITE_LOCKED; + }else{ + rc = sqlite3PagerCheckpoint(pBt->pPager, p->db, eMode, pnLog, pnCkpt); + } + sqlite3BtreeLeave(p); + } + return rc; +} +#endif + +/* +** Return true if there is currently a backup running on Btree p. +*/ +SQLITE_PRIVATE int sqlite3BtreeIsInBackup(Btree *p){ + assert( p ); + assert( sqlite3_mutex_held(p->db->mutex) ); + return p->nBackup!=0; +} + +/* +** This function returns a pointer to a blob of memory associated with +** a single shared-btree. The memory is used by client code for its own +** purposes (for example, to store a high-level schema associated with +** the shared-btree). The btree layer manages reference counting issues. +** +** The first time this is called on a shared-btree, nBytes bytes of memory +** are allocated, zeroed, and returned to the caller. For each subsequent +** call the nBytes parameter is ignored and a pointer to the same blob +** of memory returned. +** +** If the nBytes parameter is 0 and the blob of memory has not yet been +** allocated, a null pointer is returned. If the blob has already been +** allocated, it is returned as normal. +** +** Just before the shared-btree is closed, the function passed as the +** xFree argument when the memory allocation was made is invoked on the +** blob of allocated memory. The xFree function should not call sqlite3_free() +** on the memory, the btree layer does that. +*/ +SQLITE_PRIVATE void *sqlite3BtreeSchema(Btree *p, int nBytes, void(*xFree)(void *)){ + BtShared *pBt = p->pBt; + sqlite3BtreeEnter(p); + if( !pBt->pSchema && nBytes ){ + pBt->pSchema = sqlite3DbMallocZero(0, nBytes); + pBt->xFreeSchema = xFree; + } + sqlite3BtreeLeave(p); + return pBt->pSchema; +} + +/* +** Return SQLITE_LOCKED_SHAREDCACHE if another user of the same shared +** btree as the argument handle holds an exclusive lock on the +** sqlite_schema table. Otherwise SQLITE_OK. +*/ +SQLITE_PRIVATE int sqlite3BtreeSchemaLocked(Btree *p){ + int rc; + assert( sqlite3_mutex_held(p->db->mutex) ); + sqlite3BtreeEnter(p); + rc = querySharedCacheTableLock(p, SCHEMA_ROOT, READ_LOCK); + assert( rc==SQLITE_OK || rc==SQLITE_LOCKED_SHAREDCACHE ); + sqlite3BtreeLeave(p); + return rc; +} + + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** Obtain a lock on the table whose root page is iTab. The +** lock is a write lock if isWritelock is true or a read lock +** if it is false. +*/ +SQLITE_PRIVATE int sqlite3BtreeLockTable(Btree *p, int iTab, u8 isWriteLock){ + int rc = SQLITE_OK; + assert( p->inTrans!=TRANS_NONE ); + if( p->sharable ){ + u8 lockType = READ_LOCK + isWriteLock; + assert( READ_LOCK+1==WRITE_LOCK ); + assert( isWriteLock==0 || isWriteLock==1 ); + + sqlite3BtreeEnter(p); + rc = querySharedCacheTableLock(p, iTab, lockType); + if( rc==SQLITE_OK ){ + rc = setSharedCacheTableLock(p, iTab, lockType); + } + sqlite3BtreeLeave(p); + } + return rc; +} +#endif + +#ifndef SQLITE_OMIT_INCRBLOB +/* +** Argument pCsr must be a cursor opened for writing on an +** INTKEY table currently pointing at a valid table entry. +** This function modifies the data stored as part of that entry. +** +** Only the data content may only be modified, it is not possible to +** change the length of the data stored. If this function is called with +** parameters that attempt to write past the end of the existing data, +** no modifications are made and SQLITE_CORRUPT is returned. +*/ +SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor *pCsr, u32 offset, u32 amt, void *z){ + int rc; + assert( cursorOwnsBtShared(pCsr) ); + assert( sqlite3_mutex_held(pCsr->pBtree->db->mutex) ); + assert( pCsr->curFlags & BTCF_Incrblob ); + + rc = restoreCursorPosition(pCsr); + if( rc!=SQLITE_OK ){ + return rc; + } + assert( pCsr->eState!=CURSOR_REQUIRESEEK ); + if( pCsr->eState!=CURSOR_VALID ){ + return SQLITE_ABORT; + } + + /* Save the positions of all other cursors open on this table. This is + ** required in case any of them are holding references to an xFetch + ** version of the b-tree page modified by the accessPayload call below. + ** + ** Note that pCsr must be open on a INTKEY table and saveCursorPosition() + ** and hence saveAllCursors() cannot fail on a BTREE_INTKEY table, hence + ** saveAllCursors can only return SQLITE_OK. + */ + VVA_ONLY(rc =) saveAllCursors(pCsr->pBt, pCsr->pgnoRoot, pCsr); + assert( rc==SQLITE_OK ); + + /* Check some assumptions: + ** (a) the cursor is open for writing, + ** (b) there is a read/write transaction open, + ** (c) the connection holds a write-lock on the table (if required), + ** (d) there are no conflicting read-locks, and + ** (e) the cursor points at a valid row of an intKey table. + */ + if( (pCsr->curFlags & BTCF_WriteFlag)==0 ){ + return SQLITE_READONLY; + } + assert( (pCsr->pBt->btsFlags & BTS_READ_ONLY)==0 + && pCsr->pBt->inTransaction==TRANS_WRITE ); + assert( hasSharedCacheTableLock(pCsr->pBtree, pCsr->pgnoRoot, 0, 2) ); + assert( !hasReadConflicts(pCsr->pBtree, pCsr->pgnoRoot) ); + assert( pCsr->pPage->intKey ); + + return accessPayload(pCsr, offset, amt, (unsigned char *)z, 1); +} + +/* +** Mark this cursor as an incremental blob cursor. +*/ +SQLITE_PRIVATE void sqlite3BtreeIncrblobCursor(BtCursor *pCur){ + pCur->curFlags |= BTCF_Incrblob; + pCur->pBtree->hasIncrblobCur = 1; +} +#endif + +/* +** Set both the "read version" (single byte at byte offset 18) and +** "write version" (single byte at byte offset 19) fields in the database +** header to iVersion. +*/ +SQLITE_PRIVATE int sqlite3BtreeSetVersion(Btree *pBtree, int iVersion){ + BtShared *pBt = pBtree->pBt; + int rc; /* Return code */ + + assert( iVersion==1 || iVersion==2 ); + + /* If setting the version fields to 1, do not automatically open the + ** WAL connection, even if the version fields are currently set to 2. + */ + pBt->btsFlags &= ~BTS_NO_WAL; + if( iVersion==1 ) pBt->btsFlags |= BTS_NO_WAL; + + rc = sqlite3BtreeBeginTrans(pBtree, 0, 0); + if( rc==SQLITE_OK ){ + u8 *aData = pBt->pPage1->aData; + if( aData[18]!=(u8)iVersion || aData[19]!=(u8)iVersion ){ + rc = sqlite3BtreeBeginTrans(pBtree, 2, 0); + if( rc==SQLITE_OK ){ + rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); + if( rc==SQLITE_OK ){ + aData[18] = (u8)iVersion; + aData[19] = (u8)iVersion; + } + } + } + } + + pBt->btsFlags &= ~BTS_NO_WAL; + return rc; +} + +/* +** Return true if the cursor has a hint specified. This routine is +** only used from within assert() statements +*/ +SQLITE_PRIVATE int sqlite3BtreeCursorHasHint(BtCursor *pCsr, unsigned int mask){ + return (pCsr->hints & mask)!=0; +} + +/* +** Return true if the given Btree is read-only. +*/ +SQLITE_PRIVATE int sqlite3BtreeIsReadonly(Btree *p){ + return (p->pBt->btsFlags & BTS_READ_ONLY)!=0; +} + +/* +** Return the size of the header added to each page by this module. +*/ +SQLITE_PRIVATE int sqlite3HeaderSizeBtree(void){ return ROUND8(sizeof(MemPage)); } + +/* +** If no transaction is active and the database is not a temp-db, clear +** the in-memory pager cache. +*/ +SQLITE_PRIVATE void sqlite3BtreeClearCache(Btree *p){ + BtShared *pBt = p->pBt; + if( pBt->inTransaction==TRANS_NONE ){ + sqlite3PagerClearCache(pBt->pPager); + } +} + +#if !defined(SQLITE_OMIT_SHARED_CACHE) +/* +** Return true if the Btree passed as the only argument is sharable. +*/ +SQLITE_PRIVATE int sqlite3BtreeSharable(Btree *p){ + return p->sharable; +} + +/* +** Return the number of connections to the BtShared object accessed by +** the Btree handle passed as the only argument. For private caches +** this is always 1. For shared caches it may be 1 or greater. +*/ +SQLITE_PRIVATE int sqlite3BtreeConnectionCount(Btree *p){ + testcase( p->sharable ); + return p->pBt->nRef; +} +#endif + +/************** End of btree.c ***********************************************/ +/************** Begin file backup.c ******************************************/ +/* +** 2009 January 28 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the implementation of the sqlite3_backup_XXX() +** API functions and the related features. +*/ +/* #include "sqliteInt.h" */ +/* #include "btreeInt.h" */ + +/* +** Structure allocated for each backup operation. +*/ +struct sqlite3_backup { + sqlite3* pDestDb; /* Destination database handle */ + Btree *pDest; /* Destination b-tree file */ + u32 iDestSchema; /* Original schema cookie in destination */ + int bDestLocked; /* True once a write-transaction is open on pDest */ + + Pgno iNext; /* Page number of the next source page to copy */ + sqlite3* pSrcDb; /* Source database handle */ + Btree *pSrc; /* Source b-tree file */ + + int rc; /* Backup process error code */ + + /* These two variables are set by every call to backup_step(). They are + ** read by calls to backup_remaining() and backup_pagecount(). + */ + Pgno nRemaining; /* Number of pages left to copy */ + Pgno nPagecount; /* Total number of pages to copy */ + + int isAttached; /* True once backup has been registered with pager */ + sqlite3_backup *pNext; /* Next backup associated with source pager */ +}; + +/* +** THREAD SAFETY NOTES: +** +** Once it has been created using backup_init(), a single sqlite3_backup +** structure may be accessed via two groups of thread-safe entry points: +** +** * Via the sqlite3_backup_XXX() API function backup_step() and +** backup_finish(). Both these functions obtain the source database +** handle mutex and the mutex associated with the source BtShared +** structure, in that order. +** +** * Via the BackupUpdate() and BackupRestart() functions, which are +** invoked by the pager layer to report various state changes in +** the page cache associated with the source database. The mutex +** associated with the source database BtShared structure will always +** be held when either of these functions are invoked. +** +** The other sqlite3_backup_XXX() API functions, backup_remaining() and +** backup_pagecount() are not thread-safe functions. If they are called +** while some other thread is calling backup_step() or backup_finish(), +** the values returned may be invalid. There is no way for a call to +** BackupUpdate() or BackupRestart() to interfere with backup_remaining() +** or backup_pagecount(). +** +** Depending on the SQLite configuration, the database handles and/or +** the Btree objects may have their own mutexes that require locking. +** Non-sharable Btrees (in-memory databases for example), do not have +** associated mutexes. +*/ + +/* +** Return a pointer corresponding to database zDb (i.e. "main", "temp") +** in connection handle pDb. If such a database cannot be found, return +** a NULL pointer and write an error message to pErrorDb. +** +** If the "temp" database is requested, it may need to be opened by this +** function. If an error occurs while doing so, return 0 and write an +** error message to pErrorDb. +*/ +static Btree *findBtree(sqlite3 *pErrorDb, sqlite3 *pDb, const char *zDb){ + int i = sqlite3FindDbName(pDb, zDb); + + if( i==1 ){ + Parse sParse; + int rc = 0; + sqlite3ParseObjectInit(&sParse,pDb); + if( sqlite3OpenTempDatabase(&sParse) ){ + sqlite3ErrorWithMsg(pErrorDb, sParse.rc, "%s", sParse.zErrMsg); + rc = SQLITE_ERROR; + } + sqlite3DbFree(pErrorDb, sParse.zErrMsg); + sqlite3ParseObjectReset(&sParse); + if( rc ){ + return 0; + } + } + + if( i<0 ){ + sqlite3ErrorWithMsg(pErrorDb, SQLITE_ERROR, "unknown database %s", zDb); + return 0; + } + + return pDb->aDb[i].pBt; +} + +/* +** Attempt to set the page size of the destination to match the page size +** of the source. +*/ +static int setDestPgsz(sqlite3_backup *p){ + int rc; + rc = sqlite3BtreeSetPageSize(p->pDest,sqlite3BtreeGetPageSize(p->pSrc),0,0); + return rc; +} + +/* +** Check that there is no open read-transaction on the b-tree passed as the +** second argument. If there is not, return SQLITE_OK. Otherwise, if there +** is an open read-transaction, return SQLITE_ERROR and leave an error +** message in database handle db. +*/ +static int checkReadTransaction(sqlite3 *db, Btree *p){ + if( sqlite3BtreeTxnState(p)!=SQLITE_TXN_NONE ){ + sqlite3ErrorWithMsg(db, SQLITE_ERROR, "destination database is in use"); + return SQLITE_ERROR; + } + return SQLITE_OK; +} + +/* +** Create an sqlite3_backup process to copy the contents of zSrcDb from +** connection handle pSrcDb to zDestDb in pDestDb. If successful, return +** a pointer to the new sqlite3_backup object. +** +** If an error occurs, NULL is returned and an error code and error message +** stored in database handle pDestDb. +*/ +SQLITE_API sqlite3_backup *sqlite3_backup_init( + sqlite3* pDestDb, /* Database to write to */ + const char *zDestDb, /* Name of database within pDestDb */ + sqlite3* pSrcDb, /* Database connection to read from */ + const char *zSrcDb /* Name of database within pSrcDb */ +){ + sqlite3_backup *p; /* Value to return */ + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(pSrcDb)||!sqlite3SafetyCheckOk(pDestDb) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC + { + extern int sqlcipher_find_db_index(sqlite3*, const char*); + extern void sqlcipherCodecGetKey(sqlite3*, int, void**, int*); + int srcNKey, destNKey; + void *zKey; + + sqlcipherCodecGetKey(pSrcDb, sqlcipher_find_db_index(pSrcDb, zSrcDb), &zKey, &srcNKey); + sqlcipherCodecGetKey(pDestDb, sqlcipher_find_db_index(pDestDb, zDestDb), &zKey, &destNKey); + zKey = NULL; + + /* either both databases must be plaintext, or both must be encrypted */ + if((srcNKey == 0 && destNKey > 0) || (srcNKey > 0 && destNKey == 0)) { + sqlite3ErrorWithMsg(pDestDb, SQLITE_ERROR, "backup is not supported with encrypted databases"); + return NULL; + } + } +#endif +/* END SQLCIPHER */ + + /* Lock the source database handle. The destination database + ** handle is not locked in this routine, but it is locked in + ** sqlite3_backup_step(). The user is required to ensure that no + ** other thread accesses the destination handle for the duration + ** of the backup operation. Any attempt to use the destination + ** database connection while a backup is in progress may cause + ** a malfunction or a deadlock. + */ + sqlite3_mutex_enter(pSrcDb->mutex); + sqlite3_mutex_enter(pDestDb->mutex); + + if( pSrcDb==pDestDb ){ + sqlite3ErrorWithMsg( + pDestDb, SQLITE_ERROR, "source and destination must be distinct" + ); + p = 0; + }else { + /* Allocate space for a new sqlite3_backup object... + ** EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a + ** call to sqlite3_backup_init() and is destroyed by a call to + ** sqlite3_backup_finish(). */ + p = (sqlite3_backup *)sqlite3MallocZero(sizeof(sqlite3_backup)); + if( !p ){ + sqlite3Error(pDestDb, SQLITE_NOMEM_BKPT); + } + } + + /* If the allocation succeeded, populate the new object. */ + if( p ){ + p->pSrc = findBtree(pDestDb, pSrcDb, zSrcDb); + p->pDest = findBtree(pDestDb, pDestDb, zDestDb); + p->pDestDb = pDestDb; + p->pSrcDb = pSrcDb; + p->iNext = 1; + p->isAttached = 0; + + if( 0==p->pSrc || 0==p->pDest + || checkReadTransaction(pDestDb, p->pDest)!=SQLITE_OK + ){ + /* One (or both) of the named databases did not exist or an OOM + ** error was hit. Or there is a transaction open on the destination + ** database. The error has already been written into the pDestDb + ** handle. All that is left to do here is free the sqlite3_backup + ** structure. */ + sqlite3_free(p); + p = 0; + } + } + if( p ){ + p->pSrc->nBackup++; + } + + sqlite3_mutex_leave(pDestDb->mutex); + sqlite3_mutex_leave(pSrcDb->mutex); + return p; +} + +/* +** Argument rc is an SQLite error code. Return true if this error is +** considered fatal if encountered during a backup operation. All errors +** are considered fatal except for SQLITE_BUSY and SQLITE_LOCKED. +*/ +static int isFatalError(int rc){ + return (rc!=SQLITE_OK && rc!=SQLITE_BUSY && ALWAYS(rc!=SQLITE_LOCKED)); +} + +/* +** Parameter zSrcData points to a buffer containing the data for +** page iSrcPg from the source database. Copy this data into the +** destination database. +*/ +static int backupOnePage( + sqlite3_backup *p, /* Backup handle */ + Pgno iSrcPg, /* Source database page to backup */ + const u8 *zSrcData, /* Source database page data */ + int bUpdate /* True for an update, false otherwise */ +){ + Pager * const pDestPager = sqlite3BtreePager(p->pDest); + const int nSrcPgsz = sqlite3BtreeGetPageSize(p->pSrc); + int nDestPgsz = sqlite3BtreeGetPageSize(p->pDest); + const int nCopy = MIN(nSrcPgsz, nDestPgsz); + const i64 iEnd = (i64)iSrcPg*(i64)nSrcPgsz; +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC + extern void *sqlcipherPagerGetCodec(Pager*); + /* Use BtreeGetReserveNoMutex() for the source b-tree, as although it is + ** guaranteed that the shared-mutex is held by this thread, handle + ** p->pSrc may not actually be the owner. */ + int nSrcReserve = sqlite3BtreeGetReserveNoMutex(p->pSrc); + int nDestReserve = sqlite3BtreeGetRequestedReserve(p->pDest); +#endif +/* END SQLCIPHER */ + int rc = SQLITE_OK; + i64 iOff; + + assert( sqlite3BtreeGetReserveNoMutex(p->pSrc)>=0 ); + assert( p->bDestLocked ); + assert( !isFatalError(p->rc) ); + assert( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ); + assert( zSrcData ); + assert( nSrcPgsz==nDestPgsz || sqlite3PagerIsMemdb(pDestPager)==0 ); + +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC + /* Backup is not possible if the page size of the destination is changing + ** and a codec is in use. + */ + if( nSrcPgsz!=nDestPgsz && sqlcipherPagerGetCodec(pDestPager)!=0 ){ + rc = SQLITE_READONLY; + } + + /* Backup is not possible if the number of bytes of reserve space differ + ** between source and destination. If there is a difference, try to + ** fix the destination to agree with the source. If that is not possible, + ** then the backup cannot proceed. + */ + if( nSrcReserve!=nDestReserve ){ + u32 newPgsz = nSrcPgsz; + rc = sqlite3PagerSetPagesize(pDestPager, &newPgsz, nSrcReserve); + if( rc==SQLITE_OK && newPgsz!=(u32)nSrcPgsz ) rc = SQLITE_READONLY; + } +#endif +/* END SQLCIPHER */ + + /* This loop runs once for each destination page spanned by the source + ** page. For each iteration, variable iOff is set to the byte offset + ** of the destination page. + */ + for(iOff=iEnd-(i64)nSrcPgsz; rc==SQLITE_OK && iOffpDest->pBt) ) continue; + if( SQLITE_OK==(rc = sqlite3PagerGet(pDestPager, iDest, &pDestPg, 0)) + && SQLITE_OK==(rc = sqlite3PagerWrite(pDestPg)) + ){ + const u8 *zIn = &zSrcData[iOff%nSrcPgsz]; + u8 *zDestData = sqlite3PagerGetData(pDestPg); + u8 *zOut = &zDestData[iOff%nDestPgsz]; + + /* Copy the data from the source page into the destination page. + ** Then clear the Btree layer MemPage.isInit flag. Both this module + ** and the pager code use this trick (clearing the first byte + ** of the page 'extra' space to invalidate the Btree layers + ** cached parse of the page). MemPage.isInit is marked + ** "MUST BE FIRST" for this purpose. + */ + memcpy(zOut, zIn, nCopy); + ((u8 *)sqlite3PagerGetExtra(pDestPg))[0] = 0; + if( iOff==0 && bUpdate==0 ){ + sqlite3Put4byte(&zOut[28], sqlite3BtreeLastPage(p->pSrc)); + } + } + sqlite3PagerUnref(pDestPg); + } + + return rc; +} + +/* +** If pFile is currently larger than iSize bytes, then truncate it to +** exactly iSize bytes. If pFile is not larger than iSize bytes, then +** this function is a no-op. +** +** Return SQLITE_OK if everything is successful, or an SQLite error +** code if an error occurs. +*/ +static int backupTruncateFile(sqlite3_file *pFile, i64 iSize){ + i64 iCurrent; + int rc = sqlite3OsFileSize(pFile, &iCurrent); + if( rc==SQLITE_OK && iCurrent>iSize ){ + rc = sqlite3OsTruncate(pFile, iSize); + } + return rc; +} + +/* +** Register this backup object with the associated source pager for +** callbacks when pages are changed or the cache invalidated. +*/ +static void attachBackupObject(sqlite3_backup *p){ + sqlite3_backup **pp; + assert( sqlite3BtreeHoldsMutex(p->pSrc) ); + pp = sqlite3PagerBackupPtr(sqlite3BtreePager(p->pSrc)); + p->pNext = *pp; + *pp = p; + p->isAttached = 1; +} + +/* +** Copy nPage pages from the source b-tree to the destination. +*/ +SQLITE_API int sqlite3_backup_step(sqlite3_backup *p, int nPage){ + int rc; + int destMode; /* Destination journal mode */ + int pgszSrc = 0; /* Source page size */ + int pgszDest = 0; /* Destination page size */ + +#ifdef SQLITE_ENABLE_API_ARMOR + if( p==0 ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(p->pSrcDb->mutex); + sqlite3BtreeEnter(p->pSrc); + if( p->pDestDb ){ + sqlite3_mutex_enter(p->pDestDb->mutex); + } + + rc = p->rc; + if( !isFatalError(rc) ){ + Pager * const pSrcPager = sqlite3BtreePager(p->pSrc); /* Source pager */ + Pager * const pDestPager = sqlite3BtreePager(p->pDest); /* Dest pager */ + int ii; /* Iterator variable */ + int nSrcPage = -1; /* Size of source db in pages */ + int bCloseTrans = 0; /* True if src db requires unlocking */ + + /* If the source pager is currently in a write-transaction, return + ** SQLITE_BUSY immediately. + */ + if( p->pDestDb && p->pSrc->pBt->inTransaction==TRANS_WRITE ){ + rc = SQLITE_BUSY; + }else{ + rc = SQLITE_OK; + } + + /* If there is no open read-transaction on the source database, open + ** one now. If a transaction is opened here, then it will be closed + ** before this function exits. + */ + if( rc==SQLITE_OK && SQLITE_TXN_NONE==sqlite3BtreeTxnState(p->pSrc) ){ + rc = sqlite3BtreeBeginTrans(p->pSrc, 0, 0); + bCloseTrans = 1; + } + + /* If the destination database has not yet been locked (i.e. if this + ** is the first call to backup_step() for the current backup operation), + ** try to set its page size to the same as the source database. This + ** is especially important on ZipVFS systems, as in that case it is + ** not possible to create a database file that uses one page size by + ** writing to it with another. */ + if( p->bDestLocked==0 && rc==SQLITE_OK && setDestPgsz(p)==SQLITE_NOMEM ){ + rc = SQLITE_NOMEM; + } + + /* Lock the destination database, if it is not locked already. */ + if( SQLITE_OK==rc && p->bDestLocked==0 + && SQLITE_OK==(rc = sqlite3BtreeBeginTrans(p->pDest, 2, + (int*)&p->iDestSchema)) + ){ + p->bDestLocked = 1; + } + + /* Do not allow backup if the destination database is in WAL mode + ** and the page sizes are different between source and destination */ + pgszSrc = sqlite3BtreeGetPageSize(p->pSrc); + pgszDest = sqlite3BtreeGetPageSize(p->pDest); + destMode = sqlite3PagerGetJournalMode(sqlite3BtreePager(p->pDest)); + if( SQLITE_OK==rc + && (destMode==PAGER_JOURNALMODE_WAL || sqlite3PagerIsMemdb(pDestPager)) + && pgszSrc!=pgszDest + ){ + rc = SQLITE_READONLY; + } + + /* Now that there is a read-lock on the source database, query the + ** source pager for the number of pages in the database. + */ + nSrcPage = (int)sqlite3BtreeLastPage(p->pSrc); + assert( nSrcPage>=0 ); + for(ii=0; (nPage<0 || iiiNext<=(Pgno)nSrcPage && !rc; ii++){ + const Pgno iSrcPg = p->iNext; /* Source page number */ + if( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ){ + DbPage *pSrcPg; /* Source page object */ + rc = sqlite3PagerGet(pSrcPager, iSrcPg, &pSrcPg,PAGER_GET_READONLY); + if( rc==SQLITE_OK ){ + rc = backupOnePage(p, iSrcPg, sqlite3PagerGetData(pSrcPg), 0); + sqlite3PagerUnref(pSrcPg); + } + } + p->iNext++; + } + if( rc==SQLITE_OK ){ + p->nPagecount = nSrcPage; + p->nRemaining = nSrcPage+1-p->iNext; + if( p->iNext>(Pgno)nSrcPage ){ + rc = SQLITE_DONE; + }else if( !p->isAttached ){ + attachBackupObject(p); + } + } + + /* Update the schema version field in the destination database. This + ** is to make sure that the schema-version really does change in + ** the case where the source and destination databases have the + ** same schema version. + */ + if( rc==SQLITE_DONE ){ + if( nSrcPage==0 ){ + rc = sqlite3BtreeNewDb(p->pDest); + nSrcPage = 1; + } + if( rc==SQLITE_OK || rc==SQLITE_DONE ){ + rc = sqlite3BtreeUpdateMeta(p->pDest,1,p->iDestSchema+1); + } + if( rc==SQLITE_OK ){ + if( p->pDestDb ){ + sqlite3ResetAllSchemasOfConnection(p->pDestDb); + } + if( destMode==PAGER_JOURNALMODE_WAL ){ + rc = sqlite3BtreeSetVersion(p->pDest, 2); + } + } + if( rc==SQLITE_OK ){ + int nDestTruncate; + /* Set nDestTruncate to the final number of pages in the destination + ** database. The complication here is that the destination page + ** size may be different to the source page size. + ** + ** If the source page size is smaller than the destination page size, + ** round up. In this case the call to sqlite3OsTruncate() below will + ** fix the size of the file. However it is important to call + ** sqlite3PagerTruncateImage() here so that any pages in the + ** destination file that lie beyond the nDestTruncate page mark are + ** journalled by PagerCommitPhaseOne() before they are destroyed + ** by the file truncation. + */ + assert( pgszSrc==sqlite3BtreeGetPageSize(p->pSrc) ); + assert( pgszDest==sqlite3BtreeGetPageSize(p->pDest) ); + if( pgszSrcpDest->pBt) ){ + nDestTruncate--; + } + }else{ + nDestTruncate = nSrcPage * (pgszSrc/pgszDest); + } + assert( nDestTruncate>0 ); + + if( pgszSrc= iSize || ( + nDestTruncate==(int)(PENDING_BYTE_PAGE(p->pDest->pBt)-1) + && iSize>=PENDING_BYTE && iSize<=PENDING_BYTE+pgszDest + )); + + /* This block ensures that all data required to recreate the original + ** database has been stored in the journal for pDestPager and the + ** journal synced to disk. So at this point we may safely modify + ** the database file in any way, knowing that if a power failure + ** occurs, the original database will be reconstructed from the + ** journal file. */ + sqlite3PagerPagecount(pDestPager, &nDstPage); + for(iPg=nDestTruncate; rc==SQLITE_OK && iPg<=(Pgno)nDstPage; iPg++){ + if( iPg!=PENDING_BYTE_PAGE(p->pDest->pBt) ){ + DbPage *pPg; + rc = sqlite3PagerGet(pDestPager, iPg, &pPg, 0); + if( rc==SQLITE_OK ){ + rc = sqlite3PagerWrite(pPg); + sqlite3PagerUnref(pPg); + } + } + } + if( rc==SQLITE_OK ){ + rc = sqlite3PagerCommitPhaseOne(pDestPager, 0, 1); + } + + /* Write the extra pages and truncate the database file as required */ + iEnd = MIN(PENDING_BYTE + pgszDest, iSize); + for( + iOff=PENDING_BYTE+pgszSrc; + rc==SQLITE_OK && iOffpDest, 0)) + ){ + rc = SQLITE_DONE; + } + } + } + + /* If bCloseTrans is true, then this function opened a read transaction + ** on the source database. Close the read transaction here. There is + ** no need to check the return values of the btree methods here, as + ** "committing" a read-only transaction cannot fail. + */ + if( bCloseTrans ){ + TESTONLY( int rc2 ); + TESTONLY( rc2 = ) sqlite3BtreeCommitPhaseOne(p->pSrc, 0); + TESTONLY( rc2 |= ) sqlite3BtreeCommitPhaseTwo(p->pSrc, 0); + assert( rc2==SQLITE_OK ); + } + + if( rc==SQLITE_IOERR_NOMEM ){ + rc = SQLITE_NOMEM_BKPT; + } + p->rc = rc; + } + if( p->pDestDb ){ + sqlite3_mutex_leave(p->pDestDb->mutex); + } + sqlite3BtreeLeave(p->pSrc); + sqlite3_mutex_leave(p->pSrcDb->mutex); + return rc; +} + +/* +** Release all resources associated with an sqlite3_backup* handle. +*/ +SQLITE_API int sqlite3_backup_finish(sqlite3_backup *p){ + sqlite3_backup **pp; /* Ptr to head of pagers backup list */ + sqlite3 *pSrcDb; /* Source database connection */ + int rc; /* Value to return */ + + /* Enter the mutexes */ + if( p==0 ) return SQLITE_OK; + pSrcDb = p->pSrcDb; + sqlite3_mutex_enter(pSrcDb->mutex); + sqlite3BtreeEnter(p->pSrc); + if( p->pDestDb ){ + sqlite3_mutex_enter(p->pDestDb->mutex); + } + + /* Detach this backup from the source pager. */ + if( p->pDestDb ){ + p->pSrc->nBackup--; + } + if( p->isAttached ){ + pp = sqlite3PagerBackupPtr(sqlite3BtreePager(p->pSrc)); + assert( pp!=0 ); + while( *pp!=p ){ + pp = &(*pp)->pNext; + assert( pp!=0 ); + } + *pp = p->pNext; + } + + /* If a transaction is still open on the Btree, roll it back. */ + sqlite3BtreeRollback(p->pDest, SQLITE_OK, 0); + + /* Set the error code of the destination database handle. */ + rc = (p->rc==SQLITE_DONE) ? SQLITE_OK : p->rc; + if( p->pDestDb ){ + sqlite3Error(p->pDestDb, rc); + + /* Exit the mutexes and free the backup context structure. */ + sqlite3LeaveMutexAndCloseZombie(p->pDestDb); + } + sqlite3BtreeLeave(p->pSrc); + if( p->pDestDb ){ + /* EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a + ** call to sqlite3_backup_init() and is destroyed by a call to + ** sqlite3_backup_finish(). */ + sqlite3_free(p); + } + sqlite3LeaveMutexAndCloseZombie(pSrcDb); + return rc; +} + +/* +** Return the number of pages still to be backed up as of the most recent +** call to sqlite3_backup_step(). +*/ +SQLITE_API int sqlite3_backup_remaining(sqlite3_backup *p){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( p==0 ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + return p->nRemaining; +} + +/* +** Return the total number of pages in the source database as of the most +** recent call to sqlite3_backup_step(). +*/ +SQLITE_API int sqlite3_backup_pagecount(sqlite3_backup *p){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( p==0 ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + return p->nPagecount; +} + +/* +** This function is called after the contents of page iPage of the +** source database have been modified. If page iPage has already been +** copied into the destination database, then the data written to the +** destination is now invalidated. The destination copy of iPage needs +** to be updated with the new data before the backup operation is +** complete. +** +** It is assumed that the mutex associated with the BtShared object +** corresponding to the source database is held when this function is +** called. +*/ +static SQLITE_NOINLINE void backupUpdate( + sqlite3_backup *p, + Pgno iPage, + const u8 *aData +){ + assert( p!=0 ); + do{ + assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) ); + if( !isFatalError(p->rc) && iPageiNext ){ + /* The backup process p has already copied page iPage. But now it + ** has been modified by a transaction on the source pager. Copy + ** the new data into the backup. + */ + int rc; + assert( p->pDestDb ); + sqlite3_mutex_enter(p->pDestDb->mutex); + rc = backupOnePage(p, iPage, aData, 1); + sqlite3_mutex_leave(p->pDestDb->mutex); + assert( rc!=SQLITE_BUSY && rc!=SQLITE_LOCKED ); + if( rc!=SQLITE_OK ){ + p->rc = rc; + } + } + }while( (p = p->pNext)!=0 ); +} +SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *pBackup, Pgno iPage, const u8 *aData){ + if( pBackup ) backupUpdate(pBackup, iPage, aData); +} + +/* +** Restart the backup process. This is called when the pager layer +** detects that the database has been modified by an external database +** connection. In this case there is no way of knowing which of the +** pages that have been copied into the destination database are still +** valid and which are not, so the entire process needs to be restarted. +** +** It is assumed that the mutex associated with the BtShared object +** corresponding to the source database is held when this function is +** called. +*/ +SQLITE_PRIVATE void sqlite3BackupRestart(sqlite3_backup *pBackup){ + sqlite3_backup *p; /* Iterator variable */ + for(p=pBackup; p; p=p->pNext){ + assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) ); + p->iNext = 1; + } +} + +#ifndef SQLITE_OMIT_VACUUM +/* +** Copy the complete content of pBtFrom into pBtTo. A transaction +** must be active for both files. +** +** The size of file pTo may be reduced by this operation. If anything +** goes wrong, the transaction on pTo is rolled back. If successful, the +** transaction is committed before returning. +*/ +SQLITE_PRIVATE int sqlite3BtreeCopyFile(Btree *pTo, Btree *pFrom){ + int rc; + sqlite3_file *pFd; /* File descriptor for database pTo */ + sqlite3_backup b; + sqlite3BtreeEnter(pTo); + sqlite3BtreeEnter(pFrom); + + assert( sqlite3BtreeTxnState(pTo)==SQLITE_TXN_WRITE ); + pFd = sqlite3PagerFile(sqlite3BtreePager(pTo)); + if( pFd->pMethods ){ + i64 nByte = sqlite3BtreeGetPageSize(pFrom)*(i64)sqlite3BtreeLastPage(pFrom); + rc = sqlite3OsFileControl(pFd, SQLITE_FCNTL_OVERWRITE, &nByte); + if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK; + if( rc ) goto copy_finished; + } + + /* Set up an sqlite3_backup object. sqlite3_backup.pDestDb must be set + ** to 0. This is used by the implementations of sqlite3_backup_step() + ** and sqlite3_backup_finish() to detect that they are being called + ** from this function, not directly by the user. + */ + memset(&b, 0, sizeof(b)); + b.pSrcDb = pFrom->db; + b.pSrc = pFrom; + b.pDest = pTo; + b.iNext = 1; + +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC + sqlite3PagerAlignReserve(sqlite3BtreePager(pTo), sqlite3BtreePager(pFrom)); +#endif +/* END SQLCIPHER */ + + /* 0x7FFFFFFF is the hard limit for the number of pages in a database + ** file. By passing this as the number of pages to copy to + ** sqlite3_backup_step(), we can guarantee that the copy finishes + ** within a single call (unless an error occurs). The assert() statement + ** checks this assumption - (p->rc) should be set to either SQLITE_DONE + ** or an error code. */ + sqlite3_backup_step(&b, 0x7FFFFFFF); + assert( b.rc!=SQLITE_OK ); + + rc = sqlite3_backup_finish(&b); + if( rc==SQLITE_OK ){ + pTo->pBt->btsFlags &= ~BTS_PAGESIZE_FIXED; + }else{ + sqlite3PagerClearCache(sqlite3BtreePager(b.pDest)); + } + + assert( sqlite3BtreeTxnState(pTo)!=SQLITE_TXN_WRITE ); +copy_finished: + sqlite3BtreeLeave(pFrom); + sqlite3BtreeLeave(pTo); + return rc; +} +#endif /* SQLITE_OMIT_VACUUM */ + +/************** End of backup.c **********************************************/ +/************** Begin file vdbemem.c *****************************************/ +/* +** 2004 May 26 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains code use to manipulate "Mem" structure. A "Mem" +** stores a single value in the VDBE. Mem is an opaque structure visible +** only within the VDBE. Interface routines refer to a Mem using the +** name sqlite_value +*/ +/* #include "sqliteInt.h" */ +/* #include "vdbeInt.h" */ + +/* True if X is a power of two. 0 is considered a power of two here. +** In other words, return true if X has at most one bit set. +*/ +#define ISPOWEROF2(X) (((X)&((X)-1))==0) + +#ifdef SQLITE_DEBUG +/* +** Check invariants on a Mem object. +** +** This routine is intended for use inside of assert() statements, like +** this: assert( sqlite3VdbeCheckMemInvariants(pMem) ); +*/ +SQLITE_PRIVATE int sqlite3VdbeCheckMemInvariants(Mem *p){ + /* If MEM_Dyn is set then Mem.xDel!=0. + ** Mem.xDel might not be initialized if MEM_Dyn is clear. + */ + assert( (p->flags & MEM_Dyn)==0 || p->xDel!=0 ); + + /* MEM_Dyn may only be set if Mem.szMalloc==0. In this way we + ** ensure that if Mem.szMalloc>0 then it is safe to do + ** Mem.z = Mem.zMalloc without having to check Mem.flags&MEM_Dyn. + ** That saves a few cycles in inner loops. */ + assert( (p->flags & MEM_Dyn)==0 || p->szMalloc==0 ); + + /* Cannot have more than one of MEM_Int, MEM_Real, or MEM_IntReal */ + assert( ISPOWEROF2(p->flags & (MEM_Int|MEM_Real|MEM_IntReal)) ); + + if( p->flags & MEM_Null ){ + /* Cannot be both MEM_Null and some other type */ + assert( (p->flags & (MEM_Int|MEM_Real|MEM_Str|MEM_Blob|MEM_Agg))==0 ); + + /* If MEM_Null is set, then either the value is a pure NULL (the usual + ** case) or it is a pointer set using sqlite3_bind_pointer() or + ** sqlite3_result_pointer(). If a pointer, then MEM_Term must also be + ** set. + */ + if( (p->flags & (MEM_Term|MEM_Subtype))==(MEM_Term|MEM_Subtype) ){ + /* This is a pointer type. There may be a flag to indicate what to + ** do with the pointer. */ + assert( ((p->flags&MEM_Dyn)!=0 ? 1 : 0) + + ((p->flags&MEM_Ephem)!=0 ? 1 : 0) + + ((p->flags&MEM_Static)!=0 ? 1 : 0) <= 1 ); + + /* No other bits set */ + assert( (p->flags & ~(MEM_Null|MEM_Term|MEM_Subtype|MEM_FromBind + |MEM_Dyn|MEM_Ephem|MEM_Static))==0 ); + }else{ + /* A pure NULL might have other flags, such as MEM_Static, MEM_Dyn, + ** MEM_Ephem, MEM_Cleared, or MEM_Subtype */ + } + }else{ + /* The MEM_Cleared bit is only allowed on NULLs */ + assert( (p->flags & MEM_Cleared)==0 ); + } + + /* The szMalloc field holds the correct memory allocation size */ + assert( p->szMalloc==0 + || (p->flags==MEM_Undefined + && p->szMalloc<=sqlite3DbMallocSize(p->db,p->zMalloc)) + || p->szMalloc==sqlite3DbMallocSize(p->db,p->zMalloc)); + + /* If p holds a string or blob, the Mem.z must point to exactly + ** one of the following: + ** + ** (1) Memory in Mem.zMalloc and managed by the Mem object + ** (2) Memory to be freed using Mem.xDel + ** (3) An ephemeral string or blob + ** (4) A static string or blob + */ + if( (p->flags & (MEM_Str|MEM_Blob)) && p->n>0 ){ + assert( + ((p->szMalloc>0 && p->z==p->zMalloc)? 1 : 0) + + ((p->flags&MEM_Dyn)!=0 ? 1 : 0) + + ((p->flags&MEM_Ephem)!=0 ? 1 : 0) + + ((p->flags&MEM_Static)!=0 ? 1 : 0) == 1 + ); + } + return 1; +} +#endif + +/* +** Render a Mem object which is one of MEM_Int, MEM_Real, or MEM_IntReal +** into a buffer. +*/ +static void vdbeMemRenderNum(int sz, char *zBuf, Mem *p){ + StrAccum acc; + assert( p->flags & (MEM_Int|MEM_Real|MEM_IntReal) ); + assert( sz>22 ); + if( p->flags & MEM_Int ){ +#if GCC_VERSION>=7000000 + /* Work-around for GCC bug + ** https://gcc.gnu.org/bugzilla/show_bug.cgi?id=96270 */ + i64 x; + assert( (p->flags&MEM_Int)*2==sizeof(x) ); + memcpy(&x, (char*)&p->u, (p->flags&MEM_Int)*2); + p->n = sqlite3Int64ToText(x, zBuf); +#else + p->n = sqlite3Int64ToText(p->u.i, zBuf); +#endif + }else{ + sqlite3StrAccumInit(&acc, 0, zBuf, sz, 0); + sqlite3_str_appendf(&acc, "%!.15g", + (p->flags & MEM_IntReal)!=0 ? (double)p->u.i : p->u.r); + assert( acc.zText==zBuf && acc.mxAlloc<=0 ); + zBuf[acc.nChar] = 0; /* Fast version of sqlite3StrAccumFinish(&acc) */ + p->n = acc.nChar; + } +} + +#ifdef SQLITE_DEBUG +/* +** Validity checks on pMem. pMem holds a string. +** +** (1) Check that string value of pMem agrees with its integer or real value. +** (2) Check that the string is correctly zero terminated +** +** A single int or real value always converts to the same strings. But +** many different strings can be converted into the same int or real. +** If a table contains a numeric value and an index is based on the +** corresponding string value, then it is important that the string be +** derived from the numeric value, not the other way around, to ensure +** that the index and table are consistent. See ticket +** https://www.sqlite.org/src/info/343634942dd54ab (2018-01-31) for +** an example. +** +** This routine looks at pMem to verify that if it has both a numeric +** representation and a string representation then the string rep has +** been derived from the numeric and not the other way around. It returns +** true if everything is ok and false if there is a problem. +** +** This routine is for use inside of assert() statements only. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemValidStrRep(Mem *p){ + Mem tmp; + char zBuf[100]; + char *z; + int i, j, incr; + if( (p->flags & MEM_Str)==0 ) return 1; + if( p->db && p->db->mallocFailed ) return 1; + if( p->flags & MEM_Term ){ + /* Insure that the string is properly zero-terminated. Pay particular + ** attention to the case where p->n is odd */ + if( p->szMalloc>0 && p->z==p->zMalloc ){ + assert( p->enc==SQLITE_UTF8 || p->szMalloc >= ((p->n+1)&~1)+2 ); + assert( p->enc!=SQLITE_UTF8 || p->szMalloc >= p->n+1 ); + } + assert( p->z[p->n]==0 ); + assert( p->enc==SQLITE_UTF8 || p->z[(p->n+1)&~1]==0 ); + assert( p->enc==SQLITE_UTF8 || p->z[((p->n+1)&~1)+1]==0 ); + } + if( (p->flags & (MEM_Int|MEM_Real|MEM_IntReal))==0 ) return 1; + memcpy(&tmp, p, sizeof(tmp)); + vdbeMemRenderNum(sizeof(zBuf), zBuf, &tmp); + z = p->z; + i = j = 0; + incr = 1; + if( p->enc!=SQLITE_UTF8 ){ + incr = 2; + if( p->enc==SQLITE_UTF16BE ) z++; + } + while( zBuf[j] ){ + if( zBuf[j++]!=z[i] ) return 0; + i += incr; + } + return 1; +} +#endif /* SQLITE_DEBUG */ + +/* +** If pMem is an object with a valid string representation, this routine +** ensures the internal encoding for the string representation is +** 'desiredEnc', one of SQLITE_UTF8, SQLITE_UTF16LE or SQLITE_UTF16BE. +** +** If pMem is not a string object, or the encoding of the string +** representation is already stored using the requested encoding, then this +** routine is a no-op. +** +** SQLITE_OK is returned if the conversion is successful (or not required). +** SQLITE_NOMEM may be returned if a malloc() fails during conversion +** between formats. +*/ +SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){ +#ifndef SQLITE_OMIT_UTF16 + int rc; +#endif + assert( pMem!=0 ); + assert( !sqlite3VdbeMemIsRowSet(pMem) ); + assert( desiredEnc==SQLITE_UTF8 || desiredEnc==SQLITE_UTF16LE + || desiredEnc==SQLITE_UTF16BE ); + if( !(pMem->flags&MEM_Str) ){ + pMem->enc = desiredEnc; + return SQLITE_OK; + } + if( pMem->enc==desiredEnc ){ + return SQLITE_OK; + } + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); +#ifdef SQLITE_OMIT_UTF16 + return SQLITE_ERROR; +#else + + /* MemTranslate() may return SQLITE_OK or SQLITE_NOMEM. If NOMEM is returned, + ** then the encoding of the value may not have changed. + */ + rc = sqlite3VdbeMemTranslate(pMem, (u8)desiredEnc); + assert(rc==SQLITE_OK || rc==SQLITE_NOMEM); + assert(rc==SQLITE_OK || pMem->enc!=desiredEnc); + assert(rc==SQLITE_NOMEM || pMem->enc==desiredEnc); + return rc; +#endif +} + +/* +** Make sure pMem->z points to a writable allocation of at least n bytes. +** +** If the bPreserve argument is true, then copy of the content of +** pMem->z into the new allocation. pMem must be either a string or +** blob if bPreserve is true. If bPreserve is false, any prior content +** in pMem->z is discarded. +*/ +SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3VdbeMemGrow(Mem *pMem, int n, int bPreserve){ + assert( sqlite3VdbeCheckMemInvariants(pMem) ); + assert( !sqlite3VdbeMemIsRowSet(pMem) ); + testcase( pMem->db==0 ); + + /* If the bPreserve flag is set to true, then the memory cell must already + ** contain a valid string or blob value. */ + assert( bPreserve==0 || pMem->flags&(MEM_Blob|MEM_Str) ); + testcase( bPreserve && pMem->z==0 ); + + assert( pMem->szMalloc==0 + || (pMem->flags==MEM_Undefined + && pMem->szMalloc<=sqlite3DbMallocSize(pMem->db,pMem->zMalloc)) + || pMem->szMalloc==sqlite3DbMallocSize(pMem->db,pMem->zMalloc)); + if( pMem->szMalloc>0 && bPreserve && pMem->z==pMem->zMalloc ){ + if( pMem->db ){ + pMem->z = pMem->zMalloc = sqlite3DbReallocOrFree(pMem->db, pMem->z, n); + }else{ + pMem->zMalloc = sqlite3Realloc(pMem->z, n); + if( pMem->zMalloc==0 ) sqlite3_free(pMem->z); + pMem->z = pMem->zMalloc; + } + bPreserve = 0; + }else{ + if( pMem->szMalloc>0 ) sqlite3DbFreeNN(pMem->db, pMem->zMalloc); + pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, n); + } + if( pMem->zMalloc==0 ){ + sqlite3VdbeMemSetNull(pMem); + pMem->z = 0; + pMem->szMalloc = 0; + return SQLITE_NOMEM_BKPT; + }else{ + pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc); + } + + if( bPreserve && pMem->z ){ + assert( pMem->z!=pMem->zMalloc ); + memcpy(pMem->zMalloc, pMem->z, pMem->n); + } + if( (pMem->flags&MEM_Dyn)!=0 ){ + assert( pMem->xDel!=0 && pMem->xDel!=SQLITE_DYNAMIC ); + pMem->xDel((void *)(pMem->z)); + } + + pMem->z = pMem->zMalloc; + pMem->flags &= ~(MEM_Dyn|MEM_Ephem|MEM_Static); + return SQLITE_OK; +} + +/* +** Change the pMem->zMalloc allocation to be at least szNew bytes. +** If pMem->zMalloc already meets or exceeds the requested size, this +** routine is a no-op. +** +** Any prior string or blob content in the pMem object may be discarded. +** The pMem->xDel destructor is called, if it exists. Though MEM_Str +** and MEM_Blob values may be discarded, MEM_Int, MEM_Real, MEM_IntReal, +** and MEM_Null values are preserved. +** +** Return SQLITE_OK on success or an error code (probably SQLITE_NOMEM) +** if unable to complete the resizing. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemClearAndResize(Mem *pMem, int szNew){ + assert( CORRUPT_DB || szNew>0 ); + assert( (pMem->flags & MEM_Dyn)==0 || pMem->szMalloc==0 ); + if( pMem->szMallocflags & MEM_Dyn)==0 ); + pMem->z = pMem->zMalloc; + pMem->flags &= (MEM_Null|MEM_Int|MEM_Real|MEM_IntReal); + return SQLITE_OK; +} + +/* +** It is already known that pMem contains an unterminated string. +** Add the zero terminator. +** +** Three bytes of zero are added. In this way, there is guaranteed +** to be a double-zero byte at an even byte boundary in order to +** terminate a UTF16 string, even if the initial size of the buffer +** is an odd number of bytes. +*/ +static SQLITE_NOINLINE int vdbeMemAddTerminator(Mem *pMem){ + if( sqlite3VdbeMemGrow(pMem, pMem->n+3, 1) ){ + return SQLITE_NOMEM_BKPT; + } + pMem->z[pMem->n] = 0; + pMem->z[pMem->n+1] = 0; + pMem->z[pMem->n+2] = 0; + pMem->flags |= MEM_Term; + return SQLITE_OK; +} + +/* +** Change pMem so that its MEM_Str or MEM_Blob value is stored in +** MEM.zMalloc, where it can be safely written. +** +** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem *pMem){ + assert( pMem!=0 ); + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( !sqlite3VdbeMemIsRowSet(pMem) ); + if( (pMem->flags & (MEM_Str|MEM_Blob))!=0 ){ + if( ExpandBlob(pMem) ) return SQLITE_NOMEM; + if( pMem->szMalloc==0 || pMem->z!=pMem->zMalloc ){ + int rc = vdbeMemAddTerminator(pMem); + if( rc ) return rc; + } + } + pMem->flags &= ~MEM_Ephem; +#ifdef SQLITE_DEBUG + pMem->pScopyFrom = 0; +#endif + + return SQLITE_OK; +} + +/* +** If the given Mem* has a zero-filled tail, turn it into an ordinary +** blob stored in dynamically allocated space. +*/ +#ifndef SQLITE_OMIT_INCRBLOB +SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *pMem){ + int nByte; + assert( pMem!=0 ); + assert( pMem->flags & MEM_Zero ); + assert( (pMem->flags&MEM_Blob)!=0 || MemNullNochng(pMem) ); + testcase( sqlite3_value_nochange(pMem) ); + assert( !sqlite3VdbeMemIsRowSet(pMem) ); + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + + /* Set nByte to the number of bytes required to store the expanded blob. */ + nByte = pMem->n + pMem->u.nZero; + if( nByte<=0 ){ + if( (pMem->flags & MEM_Blob)==0 ) return SQLITE_OK; + nByte = 1; + } + if( sqlite3VdbeMemGrow(pMem, nByte, 1) ){ + return SQLITE_NOMEM_BKPT; + } + assert( pMem->z!=0 ); + assert( sqlite3DbMallocSize(pMem->db,pMem->z) >= nByte ); + + memset(&pMem->z[pMem->n], 0, pMem->u.nZero); + pMem->n += pMem->u.nZero; + pMem->flags &= ~(MEM_Zero|MEM_Term); + return SQLITE_OK; +} +#endif + +/* +** Make sure the given Mem is \u0000 terminated. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem *pMem){ + assert( pMem!=0 ); + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + testcase( (pMem->flags & (MEM_Term|MEM_Str))==(MEM_Term|MEM_Str) ); + testcase( (pMem->flags & (MEM_Term|MEM_Str))==0 ); + if( (pMem->flags & (MEM_Term|MEM_Str))!=MEM_Str ){ + return SQLITE_OK; /* Nothing to do */ + }else{ + return vdbeMemAddTerminator(pMem); + } +} + +/* +** Add MEM_Str to the set of representations for the given Mem. This +** routine is only called if pMem is a number of some kind, not a NULL +** or a BLOB. +** +** Existing representations MEM_Int, MEM_Real, or MEM_IntReal are invalidated +** if bForce is true but are retained if bForce is false. +** +** A MEM_Null value will never be passed to this function. This function is +** used for converting values to text for returning to the user (i.e. via +** sqlite3_value_text()), or for ensuring that values to be used as btree +** keys are strings. In the former case a NULL pointer is returned the +** user and the latter is an internal programming error. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem *pMem, u8 enc, u8 bForce){ + const int nByte = 32; + + assert( pMem!=0 ); + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( !(pMem->flags&MEM_Zero) ); + assert( !(pMem->flags&(MEM_Str|MEM_Blob)) ); + assert( pMem->flags&(MEM_Int|MEM_Real|MEM_IntReal) ); + assert( !sqlite3VdbeMemIsRowSet(pMem) ); + assert( EIGHT_BYTE_ALIGNMENT(pMem) ); + + + if( sqlite3VdbeMemClearAndResize(pMem, nByte) ){ + pMem->enc = 0; + return SQLITE_NOMEM_BKPT; + } + + vdbeMemRenderNum(nByte, pMem->z, pMem); + assert( pMem->z!=0 ); + assert( pMem->n==(int)sqlite3Strlen30NN(pMem->z) ); + pMem->enc = SQLITE_UTF8; + pMem->flags |= MEM_Str|MEM_Term; + if( bForce ) pMem->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal); + sqlite3VdbeChangeEncoding(pMem, enc); + return SQLITE_OK; +} + +/* +** Memory cell pMem contains the context of an aggregate function. +** This routine calls the finalize method for that function. The +** result of the aggregate is stored back into pMem. +** +** Return SQLITE_ERROR if the finalizer reports an error. SQLITE_OK +** otherwise. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){ + sqlite3_context ctx; + Mem t; + assert( pFunc!=0 ); + assert( pMem!=0 ); + assert( pMem->db!=0 ); + assert( pFunc->xFinalize!=0 ); + assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef ); + assert( sqlite3_mutex_held(pMem->db->mutex) ); + memset(&ctx, 0, sizeof(ctx)); + memset(&t, 0, sizeof(t)); + t.flags = MEM_Null; + t.db = pMem->db; + ctx.pOut = &t; + ctx.pMem = pMem; + ctx.pFunc = pFunc; + ctx.enc = ENC(t.db); + pFunc->xFinalize(&ctx); /* IMP: R-24505-23230 */ + assert( (pMem->flags & MEM_Dyn)==0 ); + if( pMem->szMalloc>0 ) sqlite3DbFreeNN(pMem->db, pMem->zMalloc); + memcpy(pMem, &t, sizeof(t)); + return ctx.isError; +} + +/* +** Memory cell pAccum contains the context of an aggregate function. +** This routine calls the xValue method for that function and stores +** the results in memory cell pMem. +** +** SQLITE_ERROR is returned if xValue() reports an error. SQLITE_OK +** otherwise. +*/ +#ifndef SQLITE_OMIT_WINDOWFUNC +SQLITE_PRIVATE int sqlite3VdbeMemAggValue(Mem *pAccum, Mem *pOut, FuncDef *pFunc){ + sqlite3_context ctx; + assert( pFunc!=0 ); + assert( pFunc->xValue!=0 ); + assert( (pAccum->flags & MEM_Null)!=0 || pFunc==pAccum->u.pDef ); + assert( pAccum->db!=0 ); + assert( sqlite3_mutex_held(pAccum->db->mutex) ); + memset(&ctx, 0, sizeof(ctx)); + sqlite3VdbeMemSetNull(pOut); + ctx.pOut = pOut; + ctx.pMem = pAccum; + ctx.pFunc = pFunc; + ctx.enc = ENC(pAccum->db); + pFunc->xValue(&ctx); + return ctx.isError; +} +#endif /* SQLITE_OMIT_WINDOWFUNC */ + +/* +** If the memory cell contains a value that must be freed by +** invoking the external callback in Mem.xDel, then this routine +** will free that value. It also sets Mem.flags to MEM_Null. +** +** This is a helper routine for sqlite3VdbeMemSetNull() and +** for sqlite3VdbeMemRelease(). Use those other routines as the +** entry point for releasing Mem resources. +*/ +static SQLITE_NOINLINE void vdbeMemClearExternAndSetNull(Mem *p){ + assert( p->db==0 || sqlite3_mutex_held(p->db->mutex) ); + assert( VdbeMemDynamic(p) ); + if( p->flags&MEM_Agg ){ + sqlite3VdbeMemFinalize(p, p->u.pDef); + assert( (p->flags & MEM_Agg)==0 ); + testcase( p->flags & MEM_Dyn ); + } + if( p->flags&MEM_Dyn ){ + assert( p->xDel!=SQLITE_DYNAMIC && p->xDel!=0 ); + p->xDel((void *)p->z); + } + p->flags = MEM_Null; +} + +/* +** Release memory held by the Mem p, both external memory cleared +** by p->xDel and memory in p->zMalloc. +** +** This is a helper routine invoked by sqlite3VdbeMemRelease() in +** the unusual case where there really is memory in p that needs +** to be freed. +*/ +static SQLITE_NOINLINE void vdbeMemClear(Mem *p){ + if( VdbeMemDynamic(p) ){ + vdbeMemClearExternAndSetNull(p); + } + if( p->szMalloc ){ + sqlite3DbFreeNN(p->db, p->zMalloc); + p->szMalloc = 0; + } + p->z = 0; +} + +/* +** Release any memory resources held by the Mem. Both the memory that is +** free by Mem.xDel and the Mem.zMalloc allocation are freed. +** +** Use this routine prior to clean up prior to abandoning a Mem, or to +** reset a Mem back to its minimum memory utilization. +** +** Use sqlite3VdbeMemSetNull() to release just the Mem.xDel space +** prior to inserting new content into the Mem. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p){ + assert( sqlite3VdbeCheckMemInvariants(p) ); + if( VdbeMemDynamic(p) || p->szMalloc ){ + vdbeMemClear(p); + } +} + +/* Like sqlite3VdbeMemRelease() but faster for cases where we +** know in advance that the Mem is not MEM_Dyn or MEM_Agg. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemReleaseMalloc(Mem *p){ + assert( !VdbeMemDynamic(p) ); + if( p->szMalloc ) vdbeMemClear(p); +} + +/* +** Convert a 64-bit IEEE double into a 64-bit signed integer. +** If the double is out of range of a 64-bit signed integer then +** return the closest available 64-bit signed integer. +*/ +static SQLITE_NOINLINE i64 doubleToInt64(double r){ +#ifdef SQLITE_OMIT_FLOATING_POINT + /* When floating-point is omitted, double and int64 are the same thing */ + return r; +#else + /* + ** Many compilers we encounter do not define constants for the + ** minimum and maximum 64-bit integers, or they define them + ** inconsistently. And many do not understand the "LL" notation. + ** So we define our own static constants here using nothing + ** larger than a 32-bit integer constant. + */ + static const i64 maxInt = LARGEST_INT64; + static const i64 minInt = SMALLEST_INT64; + + if( r<=(double)minInt ){ + return minInt; + }else if( r>=(double)maxInt ){ + return maxInt; + }else{ + return (i64)r; + } +#endif +} + +/* +** Return some kind of integer value which is the best we can do +** at representing the value that *pMem describes as an integer. +** If pMem is an integer, then the value is exact. If pMem is +** a floating-point then the value returned is the integer part. +** If pMem is a string or blob, then we make an attempt to convert +** it into an integer and return that. If pMem represents an +** an SQL-NULL value, return 0. +** +** If pMem represents a string value, its encoding might be changed. +*/ +static SQLITE_NOINLINE i64 memIntValue(const Mem *pMem){ + i64 value = 0; + sqlite3Atoi64(pMem->z, &value, pMem->n, pMem->enc); + return value; +} +SQLITE_PRIVATE i64 sqlite3VdbeIntValue(const Mem *pMem){ + int flags; + assert( pMem!=0 ); + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( EIGHT_BYTE_ALIGNMENT(pMem) ); + flags = pMem->flags; + if( flags & (MEM_Int|MEM_IntReal) ){ + testcase( flags & MEM_IntReal ); + return pMem->u.i; + }else if( flags & MEM_Real ){ + return doubleToInt64(pMem->u.r); + }else if( (flags & (MEM_Str|MEM_Blob))!=0 && pMem->z!=0 ){ + return memIntValue(pMem); + }else{ + return 0; + } +} + +/* +** Return the best representation of pMem that we can get into a +** double. If pMem is already a double or an integer, return its +** value. If it is a string or blob, try to convert it to a double. +** If it is a NULL, return 0.0. +*/ +static SQLITE_NOINLINE double memRealValue(Mem *pMem){ + /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */ + double val = (double)0; + sqlite3AtoF(pMem->z, &val, pMem->n, pMem->enc); + return val; +} +SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem *pMem){ + assert( pMem!=0 ); + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( EIGHT_BYTE_ALIGNMENT(pMem) ); + if( pMem->flags & MEM_Real ){ + return pMem->u.r; + }else if( pMem->flags & (MEM_Int|MEM_IntReal) ){ + testcase( pMem->flags & MEM_IntReal ); + return (double)pMem->u.i; + }else if( pMem->flags & (MEM_Str|MEM_Blob) ){ + return memRealValue(pMem); + }else{ + /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */ + return (double)0; + } +} + +/* +** Return 1 if pMem represents true, and return 0 if pMem represents false. +** Return the value ifNull if pMem is NULL. +*/ +SQLITE_PRIVATE int sqlite3VdbeBooleanValue(Mem *pMem, int ifNull){ + testcase( pMem->flags & MEM_IntReal ); + if( pMem->flags & (MEM_Int|MEM_IntReal) ) return pMem->u.i!=0; + if( pMem->flags & MEM_Null ) return ifNull; + return sqlite3VdbeRealValue(pMem)!=0.0; +} + +/* +** The MEM structure is already a MEM_Real or MEM_IntReal. Try to +** make it a MEM_Int if we can. +*/ +SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem *pMem){ + assert( pMem!=0 ); + assert( pMem->flags & (MEM_Real|MEM_IntReal) ); + assert( !sqlite3VdbeMemIsRowSet(pMem) ); + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( EIGHT_BYTE_ALIGNMENT(pMem) ); + + if( pMem->flags & MEM_IntReal ){ + MemSetTypeFlag(pMem, MEM_Int); + }else{ + i64 ix = doubleToInt64(pMem->u.r); + + /* Only mark the value as an integer if + ** + ** (1) the round-trip conversion real->int->real is a no-op, and + ** (2) The integer is neither the largest nor the smallest + ** possible integer (ticket #3922) + ** + ** The second and third terms in the following conditional enforces + ** the second condition under the assumption that addition overflow causes + ** values to wrap around. + */ + if( pMem->u.r==ix && ix>SMALLEST_INT64 && ixu.i = ix; + MemSetTypeFlag(pMem, MEM_Int); + } + } +} + +/* +** Convert pMem to type integer. Invalidate any prior representations. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem *pMem){ + assert( pMem!=0 ); + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( !sqlite3VdbeMemIsRowSet(pMem) ); + assert( EIGHT_BYTE_ALIGNMENT(pMem) ); + + pMem->u.i = sqlite3VdbeIntValue(pMem); + MemSetTypeFlag(pMem, MEM_Int); + return SQLITE_OK; +} + +/* +** Convert pMem so that it is of type MEM_Real. +** Invalidate any prior representations. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemRealify(Mem *pMem){ + assert( pMem!=0 ); + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( EIGHT_BYTE_ALIGNMENT(pMem) ); + + pMem->u.r = sqlite3VdbeRealValue(pMem); + MemSetTypeFlag(pMem, MEM_Real); + return SQLITE_OK; +} + +/* Compare a floating point value to an integer. Return true if the two +** values are the same within the precision of the floating point value. +** +** This function assumes that i was obtained by assignment from r1. +** +** For some versions of GCC on 32-bit machines, if you do the more obvious +** comparison of "r1==(double)i" you sometimes get an answer of false even +** though the r1 and (double)i values are bit-for-bit the same. +*/ +SQLITE_PRIVATE int sqlite3RealSameAsInt(double r1, sqlite3_int64 i){ + double r2 = (double)i; + return r1==0.0 + || (memcmp(&r1, &r2, sizeof(r1))==0 + && i >= -2251799813685248LL && i < 2251799813685248LL); +} + +/* Convert a floating point value to its closest integer. Do so in +** a way that avoids 'outside the range of representable values' warnings +** from UBSAN. +*/ +SQLITE_PRIVATE i64 sqlite3RealToI64(double r){ + if( r<=(double)SMALLEST_INT64 ) return SMALLEST_INT64; + if( r>=(double)LARGEST_INT64) return LARGEST_INT64; + return (i64)r; +} + +/* +** Convert pMem so that it has type MEM_Real or MEM_Int. +** Invalidate any prior representations. +** +** Every effort is made to force the conversion, even if the input +** is a string that does not look completely like a number. Convert +** as much of the string as we can and ignore the rest. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem *pMem){ + assert( pMem!=0 ); + testcase( pMem->flags & MEM_Int ); + testcase( pMem->flags & MEM_Real ); + testcase( pMem->flags & MEM_IntReal ); + testcase( pMem->flags & MEM_Null ); + if( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null))==0 ){ + int rc; + sqlite3_int64 ix; + assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 ); + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc); + if( ((rc==0 || rc==1) && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1) + || sqlite3RealSameAsInt(pMem->u.r, (ix = sqlite3RealToI64(pMem->u.r))) + ){ + pMem->u.i = ix; + MemSetTypeFlag(pMem, MEM_Int); + }else{ + MemSetTypeFlag(pMem, MEM_Real); + } + } + assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null))!=0 ); + pMem->flags &= ~(MEM_Str|MEM_Blob|MEM_Zero); + return SQLITE_OK; +} + +/* +** Cast the datatype of the value in pMem according to the affinity +** "aff". Casting is different from applying affinity in that a cast +** is forced. In other words, the value is converted into the desired +** affinity even if that results in loss of data. This routine is +** used (for example) to implement the SQL "cast()" operator. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemCast(Mem *pMem, u8 aff, u8 encoding){ + if( pMem->flags & MEM_Null ) return SQLITE_OK; + switch( aff ){ + case SQLITE_AFF_BLOB: { /* Really a cast to BLOB */ + if( (pMem->flags & MEM_Blob)==0 ){ + sqlite3ValueApplyAffinity(pMem, SQLITE_AFF_TEXT, encoding); + assert( pMem->flags & MEM_Str || pMem->db->mallocFailed ); + if( pMem->flags & MEM_Str ) MemSetTypeFlag(pMem, MEM_Blob); + }else{ + pMem->flags &= ~(MEM_TypeMask&~MEM_Blob); + } + break; + } + case SQLITE_AFF_NUMERIC: { + sqlite3VdbeMemNumerify(pMem); + break; + } + case SQLITE_AFF_INTEGER: { + sqlite3VdbeMemIntegerify(pMem); + break; + } + case SQLITE_AFF_REAL: { + sqlite3VdbeMemRealify(pMem); + break; + } + default: { + assert( aff==SQLITE_AFF_TEXT ); + assert( MEM_Str==(MEM_Blob>>3) ); + pMem->flags |= (pMem->flags&MEM_Blob)>>3; + sqlite3ValueApplyAffinity(pMem, SQLITE_AFF_TEXT, encoding); + assert( pMem->flags & MEM_Str || pMem->db->mallocFailed ); + pMem->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal|MEM_Blob|MEM_Zero); + if( encoding!=SQLITE_UTF8 ) pMem->n &= ~1; + return sqlite3VdbeChangeEncoding(pMem, encoding); + } + } + return SQLITE_OK; +} + +/* +** Initialize bulk memory to be a consistent Mem object. +** +** The minimum amount of initialization feasible is performed. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemInit(Mem *pMem, sqlite3 *db, u16 flags){ + assert( (flags & ~MEM_TypeMask)==0 ); + pMem->flags = flags; + pMem->db = db; + pMem->szMalloc = 0; +} + + +/* +** Delete any previous value and set the value stored in *pMem to NULL. +** +** This routine calls the Mem.xDel destructor to dispose of values that +** require the destructor. But it preserves the Mem.zMalloc memory allocation. +** To free all resources, use sqlite3VdbeMemRelease(), which both calls this +** routine to invoke the destructor and deallocates Mem.zMalloc. +** +** Use this routine to reset the Mem prior to insert a new value. +** +** Use sqlite3VdbeMemRelease() to complete erase the Mem prior to abandoning it. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem *pMem){ + if( VdbeMemDynamic(pMem) ){ + vdbeMemClearExternAndSetNull(pMem); + }else{ + pMem->flags = MEM_Null; + } +} +SQLITE_PRIVATE void sqlite3ValueSetNull(sqlite3_value *p){ + sqlite3VdbeMemSetNull((Mem*)p); +} + +/* +** Delete any previous value and set the value to be a BLOB of length +** n containing all zeros. +*/ +#ifndef SQLITE_OMIT_INCRBLOB +SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){ + sqlite3VdbeMemRelease(pMem); + pMem->flags = MEM_Blob|MEM_Zero; + pMem->n = 0; + if( n<0 ) n = 0; + pMem->u.nZero = n; + pMem->enc = SQLITE_UTF8; + pMem->z = 0; +} +#else +SQLITE_PRIVATE int sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){ + int nByte = n>0?n:1; + if( sqlite3VdbeMemGrow(pMem, nByte, 0) ){ + return SQLITE_NOMEM_BKPT; + } + assert( pMem->z!=0 ); + assert( sqlite3DbMallocSize(pMem->db, pMem->z)>=nByte ); + memset(pMem->z, 0, nByte); + pMem->n = n>0?n:0; + pMem->flags = MEM_Blob; + pMem->enc = SQLITE_UTF8; + return SQLITE_OK; +} +#endif + +/* +** The pMem is known to contain content that needs to be destroyed prior +** to a value change. So invoke the destructor, then set the value to +** a 64-bit integer. +*/ +static SQLITE_NOINLINE void vdbeReleaseAndSetInt64(Mem *pMem, i64 val){ + sqlite3VdbeMemSetNull(pMem); + pMem->u.i = val; + pMem->flags = MEM_Int; +} + +/* +** Delete any previous value and set the value stored in *pMem to val, +** manifest type INTEGER. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){ + if( VdbeMemDynamic(pMem) ){ + vdbeReleaseAndSetInt64(pMem, val); + }else{ + pMem->u.i = val; + pMem->flags = MEM_Int; + } +} + +/* A no-op destructor */ +SQLITE_PRIVATE void sqlite3NoopDestructor(void *p){ UNUSED_PARAMETER(p); } + +/* +** Set the value stored in *pMem should already be a NULL. +** Also store a pointer to go with it. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemSetPointer( + Mem *pMem, + void *pPtr, + const char *zPType, + void (*xDestructor)(void*) +){ + assert( pMem->flags==MEM_Null ); + vdbeMemClear(pMem); + pMem->u.zPType = zPType ? zPType : ""; + pMem->z = pPtr; + pMem->flags = MEM_Null|MEM_Dyn|MEM_Subtype|MEM_Term; + pMem->eSubtype = 'p'; + pMem->xDel = xDestructor ? xDestructor : sqlite3NoopDestructor; +} + +#ifndef SQLITE_OMIT_FLOATING_POINT +/* +** Delete any previous value and set the value stored in *pMem to val, +** manifest type REAL. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem *pMem, double val){ + sqlite3VdbeMemSetNull(pMem); + if( !sqlite3IsNaN(val) ){ + pMem->u.r = val; + pMem->flags = MEM_Real; + } +} +#endif + +#ifdef SQLITE_DEBUG +/* +** Return true if the Mem holds a RowSet object. This routine is intended +** for use inside of assert() statements. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemIsRowSet(const Mem *pMem){ + return (pMem->flags&(MEM_Blob|MEM_Dyn))==(MEM_Blob|MEM_Dyn) + && pMem->xDel==sqlite3RowSetDelete; +} +#endif + +/* +** Delete any previous value and set the value of pMem to be an +** empty boolean index. +** +** Return SQLITE_OK on success and SQLITE_NOMEM if a memory allocation +** error occurs. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemSetRowSet(Mem *pMem){ + sqlite3 *db = pMem->db; + RowSet *p; + assert( db!=0 ); + assert( !sqlite3VdbeMemIsRowSet(pMem) ); + sqlite3VdbeMemRelease(pMem); + p = sqlite3RowSetInit(db); + if( p==0 ) return SQLITE_NOMEM; + pMem->z = (char*)p; + pMem->flags = MEM_Blob|MEM_Dyn; + pMem->xDel = sqlite3RowSetDelete; + return SQLITE_OK; +} + +/* +** Return true if the Mem object contains a TEXT or BLOB that is +** too large - whose size exceeds SQLITE_MAX_LENGTH. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemTooBig(Mem *p){ + assert( p->db!=0 ); + if( p->flags & (MEM_Str|MEM_Blob) ){ + int n = p->n; + if( p->flags & MEM_Zero ){ + n += p->u.nZero; + } + return n>p->db->aLimit[SQLITE_LIMIT_LENGTH]; + } + return 0; +} + +#ifdef SQLITE_DEBUG +/* +** This routine prepares a memory cell for modification by breaking +** its link to a shallow copy and by marking any current shallow +** copies of this cell as invalid. +** +** This is used for testing and debugging only - to help ensure that shallow +** copies (created by OP_SCopy) are not misused. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemAboutToChange(Vdbe *pVdbe, Mem *pMem){ + int i; + Mem *pX; + for(i=1, pX=pVdbe->aMem+1; inMem; i++, pX++){ + if( pX->pScopyFrom==pMem ){ + u16 mFlags; + if( pVdbe->db->flags & SQLITE_VdbeTrace ){ + sqlite3DebugPrintf("Invalidate R[%d] due to change in R[%d]\n", + (int)(pX - pVdbe->aMem), (int)(pMem - pVdbe->aMem)); + } + /* If pX is marked as a shallow copy of pMem, then try to verify that + ** no significant changes have been made to pX since the OP_SCopy. + ** A significant change would indicated a missed call to this + ** function for pX. Minor changes, such as adding or removing a + ** dual type, are allowed, as long as the underlying value is the + ** same. */ + mFlags = pMem->flags & pX->flags & pX->mScopyFlags; + assert( (mFlags&(MEM_Int|MEM_IntReal))==0 || pMem->u.i==pX->u.i ); + + /* pMem is the register that is changing. But also mark pX as + ** undefined so that we can quickly detect the shallow-copy error */ + pX->flags = MEM_Undefined; + pX->pScopyFrom = 0; + } + } + pMem->pScopyFrom = 0; +} +#endif /* SQLITE_DEBUG */ + +/* +** Make an shallow copy of pFrom into pTo. Prior contents of +** pTo are freed. The pFrom->z field is not duplicated. If +** pFrom->z is used, then pTo->z points to the same thing as pFrom->z +** and flags gets srcType (either MEM_Ephem or MEM_Static). +*/ +static SQLITE_NOINLINE void vdbeClrCopy(Mem *pTo, const Mem *pFrom, int eType){ + vdbeMemClearExternAndSetNull(pTo); + assert( !VdbeMemDynamic(pTo) ); + sqlite3VdbeMemShallowCopy(pTo, pFrom, eType); +} +SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){ + assert( !sqlite3VdbeMemIsRowSet(pFrom) ); + assert( pTo->db==pFrom->db ); + if( VdbeMemDynamic(pTo) ){ vdbeClrCopy(pTo,pFrom,srcType); return; } + memcpy(pTo, pFrom, MEMCELLSIZE); + if( (pFrom->flags&MEM_Static)==0 ){ + pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Ephem); + assert( srcType==MEM_Ephem || srcType==MEM_Static ); + pTo->flags |= srcType; + } +} + +/* +** Make a full copy of pFrom into pTo. Prior contents of pTo are +** freed before the copy is made. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){ + int rc = SQLITE_OK; + + assert( !sqlite3VdbeMemIsRowSet(pFrom) ); + if( VdbeMemDynamic(pTo) ) vdbeMemClearExternAndSetNull(pTo); + memcpy(pTo, pFrom, MEMCELLSIZE); + pTo->flags &= ~MEM_Dyn; + if( pTo->flags&(MEM_Str|MEM_Blob) ){ + if( 0==(pFrom->flags&MEM_Static) ){ + pTo->flags |= MEM_Ephem; + rc = sqlite3VdbeMemMakeWriteable(pTo); + } + } + + return rc; +} + +/* +** Transfer the contents of pFrom to pTo. Any existing value in pTo is +** freed. If pFrom contains ephemeral data, a copy is made. +** +** pFrom contains an SQL NULL when this routine returns. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){ + assert( pFrom->db==0 || sqlite3_mutex_held(pFrom->db->mutex) ); + assert( pTo->db==0 || sqlite3_mutex_held(pTo->db->mutex) ); + assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db ); + + sqlite3VdbeMemRelease(pTo); + memcpy(pTo, pFrom, sizeof(Mem)); + pFrom->flags = MEM_Null; + pFrom->szMalloc = 0; +} + +/* +** Change the value of a Mem to be a string or a BLOB. +** +** The memory management strategy depends on the value of the xDel +** parameter. If the value passed is SQLITE_TRANSIENT, then the +** string is copied into a (possibly existing) buffer managed by the +** Mem structure. Otherwise, any existing buffer is freed and the +** pointer copied. +** +** If the string is too large (if it exceeds the SQLITE_LIMIT_LENGTH +** size limit) then no memory allocation occurs. If the string can be +** stored without allocating memory, then it is. If a memory allocation +** is required to store the string, then value of pMem is unchanged. In +** either case, SQLITE_TOOBIG is returned. +** +** The "enc" parameter is the text encoding for the string, or zero +** to store a blob. +** +** If n is negative, then the string consists of all bytes up to but +** excluding the first zero character. The n parameter must be +** non-negative for blobs. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemSetStr( + Mem *pMem, /* Memory cell to set to string value */ + const char *z, /* String pointer */ + i64 n, /* Bytes in string, or negative */ + u8 enc, /* Encoding of z. 0 for BLOBs */ + void (*xDel)(void*) /* Destructor function */ +){ + i64 nByte = n; /* New value for pMem->n */ + int iLimit; /* Maximum allowed string or blob size */ + u16 flags; /* New value for pMem->flags */ + + assert( pMem!=0 ); + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); + assert( !sqlite3VdbeMemIsRowSet(pMem) ); + assert( enc!=0 || n>=0 ); + + /* If z is a NULL pointer, set pMem to contain an SQL NULL. */ + if( !z ){ + sqlite3VdbeMemSetNull(pMem); + return SQLITE_OK; + } + + if( pMem->db ){ + iLimit = pMem->db->aLimit[SQLITE_LIMIT_LENGTH]; + }else{ + iLimit = SQLITE_MAX_LENGTH; + } + if( nByte<0 ){ + assert( enc!=0 ); + if( enc==SQLITE_UTF8 ){ + nByte = strlen(z); + }else{ + for(nByte=0; nByte<=iLimit && (z[nByte] | z[nByte+1]); nByte+=2){} + } + flags= MEM_Str|MEM_Term; + }else if( enc==0 ){ + flags = MEM_Blob; + enc = SQLITE_UTF8; + }else{ + flags = MEM_Str; + } + if( nByte>iLimit ){ + if( xDel && xDel!=SQLITE_TRANSIENT ){ + if( xDel==SQLITE_DYNAMIC ){ + sqlite3DbFree(pMem->db, (void*)z); + }else{ + xDel((void*)z); + } + } + sqlite3VdbeMemSetNull(pMem); + return sqlite3ErrorToParser(pMem->db, SQLITE_TOOBIG); + } + + /* The following block sets the new values of Mem.z and Mem.xDel. It + ** also sets a flag in local variable "flags" to indicate the memory + ** management (one of MEM_Dyn or MEM_Static). + */ + if( xDel==SQLITE_TRANSIENT ){ + i64 nAlloc = nByte; + if( flags&MEM_Term ){ + nAlloc += (enc==SQLITE_UTF8?1:2); + } + testcase( nAlloc==0 ); + testcase( nAlloc==31 ); + testcase( nAlloc==32 ); + if( sqlite3VdbeMemClearAndResize(pMem, (int)MAX(nAlloc,32)) ){ + return SQLITE_NOMEM_BKPT; + } + memcpy(pMem->z, z, nAlloc); + }else{ + sqlite3VdbeMemRelease(pMem); + pMem->z = (char *)z; + if( xDel==SQLITE_DYNAMIC ){ + pMem->zMalloc = pMem->z; + pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc); + }else{ + pMem->xDel = xDel; + flags |= ((xDel==SQLITE_STATIC)?MEM_Static:MEM_Dyn); + } + } + + pMem->n = (int)(nByte & 0x7fffffff); + pMem->flags = flags; + pMem->enc = enc; + +#ifndef SQLITE_OMIT_UTF16 + if( enc>SQLITE_UTF8 && sqlite3VdbeMemHandleBom(pMem) ){ + return SQLITE_NOMEM_BKPT; + } +#endif + + + return SQLITE_OK; +} + +/* +** Move data out of a btree key or data field and into a Mem structure. +** The data is payload from the entry that pCur is currently pointing +** to. offset and amt determine what portion of the data or key to retrieve. +** The result is written into the pMem element. +** +** The pMem object must have been initialized. This routine will use +** pMem->zMalloc to hold the content from the btree, if possible. New +** pMem->zMalloc space will be allocated if necessary. The calling routine +** is responsible for making sure that the pMem object is eventually +** destroyed. +** +** If this routine fails for any reason (malloc returns NULL or unable +** to read from the disk) then the pMem is left in an inconsistent state. +*/ +SQLITE_PRIVATE int sqlite3VdbeMemFromBtree( + BtCursor *pCur, /* Cursor pointing at record to retrieve. */ + u32 offset, /* Offset from the start of data to return bytes from. */ + u32 amt, /* Number of bytes to return. */ + Mem *pMem /* OUT: Return data in this Mem structure. */ +){ + int rc; + pMem->flags = MEM_Null; + if( sqlite3BtreeMaxRecordSize(pCur)z); + if( rc==SQLITE_OK ){ + pMem->z[amt] = 0; /* Overrun area used when reading malformed records */ + pMem->flags = MEM_Blob; + pMem->n = (int)amt; + }else{ + sqlite3VdbeMemRelease(pMem); + } + } + return rc; +} +SQLITE_PRIVATE int sqlite3VdbeMemFromBtreeZeroOffset( + BtCursor *pCur, /* Cursor pointing at record to retrieve. */ + u32 amt, /* Number of bytes to return. */ + Mem *pMem /* OUT: Return data in this Mem structure. */ +){ + u32 available = 0; /* Number of bytes available on the local btree page */ + int rc = SQLITE_OK; /* Return code */ + + assert( sqlite3BtreeCursorIsValid(pCur) ); + assert( !VdbeMemDynamic(pMem) ); + + /* Note: the calls to BtreeKeyFetch() and DataFetch() below assert() + ** that both the BtShared and database handle mutexes are held. */ + assert( !sqlite3VdbeMemIsRowSet(pMem) ); + pMem->z = (char *)sqlite3BtreePayloadFetch(pCur, &available); + assert( pMem->z!=0 ); + + if( amt<=available ){ + pMem->flags = MEM_Blob|MEM_Ephem; + pMem->n = (int)amt; + }else{ + rc = sqlite3VdbeMemFromBtree(pCur, 0, amt, pMem); + } + + return rc; +} + +/* +** The pVal argument is known to be a value other than NULL. +** Convert it into a string with encoding enc and return a pointer +** to a zero-terminated version of that string. +*/ +static SQLITE_NOINLINE const void *valueToText(sqlite3_value* pVal, u8 enc){ + assert( pVal!=0 ); + assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) ); + assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) ); + assert( !sqlite3VdbeMemIsRowSet(pVal) ); + assert( (pVal->flags & (MEM_Null))==0 ); + if( pVal->flags & (MEM_Blob|MEM_Str) ){ + if( ExpandBlob(pVal) ) return 0; + pVal->flags |= MEM_Str; + if( pVal->enc != (enc & ~SQLITE_UTF16_ALIGNED) ){ + sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED); + } + if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&SQLITE_PTR_TO_INT(pVal->z)) ){ + assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 ); + if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){ + return 0; + } + } + sqlite3VdbeMemNulTerminate(pVal); /* IMP: R-31275-44060 */ + }else{ + sqlite3VdbeMemStringify(pVal, enc, 0); + assert( 0==(1&SQLITE_PTR_TO_INT(pVal->z)) ); + } + assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0 + || pVal->db->mallocFailed ); + if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){ + assert( sqlite3VdbeMemValidStrRep(pVal) ); + return pVal->z; + }else{ + return 0; + } +} + +/* This function is only available internally, it is not part of the +** external API. It works in a similar way to sqlite3_value_text(), +** except the data returned is in the encoding specified by the second +** parameter, which must be one of SQLITE_UTF16BE, SQLITE_UTF16LE or +** SQLITE_UTF8. +** +** (2006-02-16:) The enc value can be or-ed with SQLITE_UTF16_ALIGNED. +** If that is the case, then the result must be aligned on an even byte +** boundary. +*/ +SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){ + if( !pVal ) return 0; + assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) ); + assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) ); + assert( !sqlite3VdbeMemIsRowSet(pVal) ); + if( (pVal->flags&(MEM_Str|MEM_Term))==(MEM_Str|MEM_Term) && pVal->enc==enc ){ + assert( sqlite3VdbeMemValidStrRep(pVal) ); + return pVal->z; + } + if( pVal->flags&MEM_Null ){ + return 0; + } + return valueToText(pVal, enc); +} + +/* +** Create a new sqlite3_value object. +*/ +SQLITE_PRIVATE sqlite3_value *sqlite3ValueNew(sqlite3 *db){ + Mem *p = sqlite3DbMallocZero(db, sizeof(*p)); + if( p ){ + p->flags = MEM_Null; + p->db = db; + } + return p; +} + +/* +** Context object passed by sqlite3Stat4ProbeSetValue() through to +** valueNew(). See comments above valueNew() for details. +*/ +struct ValueNewStat4Ctx { + Parse *pParse; + Index *pIdx; + UnpackedRecord **ppRec; + int iVal; +}; + +/* +** Allocate and return a pointer to a new sqlite3_value object. If +** the second argument to this function is NULL, the object is allocated +** by calling sqlite3ValueNew(). +** +** Otherwise, if the second argument is non-zero, then this function is +** being called indirectly by sqlite3Stat4ProbeSetValue(). If it has not +** already been allocated, allocate the UnpackedRecord structure that +** that function will return to its caller here. Then return a pointer to +** an sqlite3_value within the UnpackedRecord.a[] array. +*/ +static sqlite3_value *valueNew(sqlite3 *db, struct ValueNewStat4Ctx *p){ +#ifdef SQLITE_ENABLE_STAT4 + if( p ){ + UnpackedRecord *pRec = p->ppRec[0]; + + if( pRec==0 ){ + Index *pIdx = p->pIdx; /* Index being probed */ + int nByte; /* Bytes of space to allocate */ + int i; /* Counter variable */ + int nCol = pIdx->nColumn; /* Number of index columns including rowid */ + + nByte = sizeof(Mem) * nCol + ROUND8(sizeof(UnpackedRecord)); + pRec = (UnpackedRecord*)sqlite3DbMallocZero(db, nByte); + if( pRec ){ + pRec->pKeyInfo = sqlite3KeyInfoOfIndex(p->pParse, pIdx); + if( pRec->pKeyInfo ){ + assert( pRec->pKeyInfo->nAllField==nCol ); + assert( pRec->pKeyInfo->enc==ENC(db) ); + pRec->aMem = (Mem *)((u8*)pRec + ROUND8(sizeof(UnpackedRecord))); + for(i=0; iaMem[i].flags = MEM_Null; + pRec->aMem[i].db = db; + } + }else{ + sqlite3DbFreeNN(db, pRec); + pRec = 0; + } + } + if( pRec==0 ) return 0; + p->ppRec[0] = pRec; + } + + pRec->nField = p->iVal+1; + return &pRec->aMem[p->iVal]; + } +#else + UNUSED_PARAMETER(p); +#endif /* defined(SQLITE_ENABLE_STAT4) */ + return sqlite3ValueNew(db); +} + +/* +** The expression object indicated by the second argument is guaranteed +** to be a scalar SQL function. If +** +** * all function arguments are SQL literals, +** * one of the SQLITE_FUNC_CONSTANT or _SLOCHNG function flags is set, and +** * the SQLITE_FUNC_NEEDCOLL function flag is not set, +** +** then this routine attempts to invoke the SQL function. Assuming no +** error occurs, output parameter (*ppVal) is set to point to a value +** object containing the result before returning SQLITE_OK. +** +** Affinity aff is applied to the result of the function before returning. +** If the result is a text value, the sqlite3_value object uses encoding +** enc. +** +** If the conditions above are not met, this function returns SQLITE_OK +** and sets (*ppVal) to NULL. Or, if an error occurs, (*ppVal) is set to +** NULL and an SQLite error code returned. +*/ +#ifdef SQLITE_ENABLE_STAT4 +static int valueFromFunction( + sqlite3 *db, /* The database connection */ + const Expr *p, /* The expression to evaluate */ + u8 enc, /* Encoding to use */ + u8 aff, /* Affinity to use */ + sqlite3_value **ppVal, /* Write the new value here */ + struct ValueNewStat4Ctx *pCtx /* Second argument for valueNew() */ +){ + sqlite3_context ctx; /* Context object for function invocation */ + sqlite3_value **apVal = 0; /* Function arguments */ + int nVal = 0; /* Size of apVal[] array */ + FuncDef *pFunc = 0; /* Function definition */ + sqlite3_value *pVal = 0; /* New value */ + int rc = SQLITE_OK; /* Return code */ + ExprList *pList = 0; /* Function arguments */ + int i; /* Iterator variable */ + + assert( pCtx!=0 ); + assert( (p->flags & EP_TokenOnly)==0 ); + assert( ExprUseXList(p) ); + pList = p->x.pList; + if( pList ) nVal = pList->nExpr; + assert( !ExprHasProperty(p, EP_IntValue) ); + pFunc = sqlite3FindFunction(db, p->u.zToken, nVal, enc, 0); +#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION + if( pFunc==0 ) return SQLITE_OK; +#endif + assert( pFunc ); + if( (pFunc->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG))==0 + || (pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL) + ){ + return SQLITE_OK; + } + + if( pList ){ + apVal = (sqlite3_value**)sqlite3DbMallocZero(db, sizeof(apVal[0]) * nVal); + if( apVal==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto value_from_function_out; + } + for(i=0; ia[i].pExpr, enc, aff, &apVal[i]); + if( apVal[i]==0 || rc!=SQLITE_OK ) goto value_from_function_out; + } + } + + pVal = valueNew(db, pCtx); + if( pVal==0 ){ + rc = SQLITE_NOMEM_BKPT; + goto value_from_function_out; + } + + memset(&ctx, 0, sizeof(ctx)); + ctx.pOut = pVal; + ctx.pFunc = pFunc; + ctx.enc = ENC(db); + pFunc->xSFunc(&ctx, nVal, apVal); + if( ctx.isError ){ + rc = ctx.isError; + sqlite3ErrorMsg(pCtx->pParse, "%s", sqlite3_value_text(pVal)); + }else{ + sqlite3ValueApplyAffinity(pVal, aff, SQLITE_UTF8); + assert( rc==SQLITE_OK ); + rc = sqlite3VdbeChangeEncoding(pVal, enc); + if( NEVER(rc==SQLITE_OK && sqlite3VdbeMemTooBig(pVal)) ){ + rc = SQLITE_TOOBIG; + pCtx->pParse->nErr++; + } + } + + value_from_function_out: + if( rc!=SQLITE_OK ){ + pVal = 0; + pCtx->pParse->rc = rc; + } + if( apVal ){ + for(i=0; iop)==TK_UPLUS || op==TK_SPAN ) pExpr = pExpr->pLeft; + if( op==TK_REGISTER ) op = pExpr->op2; + + /* Compressed expressions only appear when parsing the DEFAULT clause + ** on a table column definition, and hence only when pCtx==0. This + ** check ensures that an EP_TokenOnly expression is never passed down + ** into valueFromFunction(). */ + assert( (pExpr->flags & EP_TokenOnly)==0 || pCtx==0 ); + + if( op==TK_CAST ){ + u8 aff; + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + aff = sqlite3AffinityType(pExpr->u.zToken,0); + rc = valueFromExpr(db, pExpr->pLeft, enc, aff, ppVal, pCtx); + testcase( rc!=SQLITE_OK ); + if( *ppVal ){ +#ifdef SQLITE_ENABLE_STAT4 + rc = ExpandBlob(*ppVal); +#else + /* zero-blobs only come from functions, not literal values. And + ** functions are only processed under STAT4 */ + assert( (ppVal[0][0].flags & MEM_Zero)==0 ); +#endif + sqlite3VdbeMemCast(*ppVal, aff, enc); + sqlite3ValueApplyAffinity(*ppVal, affinity, enc); + } + return rc; + } + + /* Handle negative integers in a single step. This is needed in the + ** case when the value is -9223372036854775808. + */ + if( op==TK_UMINUS + && (pExpr->pLeft->op==TK_INTEGER || pExpr->pLeft->op==TK_FLOAT) ){ + pExpr = pExpr->pLeft; + op = pExpr->op; + negInt = -1; + zNeg = "-"; + } + + if( op==TK_STRING || op==TK_FLOAT || op==TK_INTEGER ){ + pVal = valueNew(db, pCtx); + if( pVal==0 ) goto no_mem; + if( ExprHasProperty(pExpr, EP_IntValue) ){ + sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt); + }else{ + zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken); + if( zVal==0 ) goto no_mem; + sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, SQLITE_DYNAMIC); + } + if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_BLOB ){ + sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, SQLITE_UTF8); + }else{ + sqlite3ValueApplyAffinity(pVal, affinity, SQLITE_UTF8); + } + assert( (pVal->flags & MEM_IntReal)==0 ); + if( pVal->flags & (MEM_Int|MEM_IntReal|MEM_Real) ){ + testcase( pVal->flags & MEM_Int ); + testcase( pVal->flags & MEM_Real ); + pVal->flags &= ~MEM_Str; + } + if( enc!=SQLITE_UTF8 ){ + rc = sqlite3VdbeChangeEncoding(pVal, enc); + } + }else if( op==TK_UMINUS ) { + /* This branch happens for multiple negative signs. Ex: -(-5) */ + if( SQLITE_OK==valueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal,pCtx) + && pVal!=0 + ){ + sqlite3VdbeMemNumerify(pVal); + if( pVal->flags & MEM_Real ){ + pVal->u.r = -pVal->u.r; + }else if( pVal->u.i==SMALLEST_INT64 ){ +#ifndef SQLITE_OMIT_FLOATING_POINT + pVal->u.r = -(double)SMALLEST_INT64; +#else + pVal->u.r = LARGEST_INT64; +#endif + MemSetTypeFlag(pVal, MEM_Real); + }else{ + pVal->u.i = -pVal->u.i; + } + sqlite3ValueApplyAffinity(pVal, affinity, enc); + } + }else if( op==TK_NULL ){ + pVal = valueNew(db, pCtx); + if( pVal==0 ) goto no_mem; + sqlite3VdbeMemSetNull(pVal); + } +#ifndef SQLITE_OMIT_BLOB_LITERAL + else if( op==TK_BLOB ){ + int nVal; + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' ); + assert( pExpr->u.zToken[1]=='\'' ); + pVal = valueNew(db, pCtx); + if( !pVal ) goto no_mem; + zVal = &pExpr->u.zToken[2]; + nVal = sqlite3Strlen30(zVal)-1; + assert( zVal[nVal]=='\'' ); + sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(db, zVal, nVal), nVal/2, + 0, SQLITE_DYNAMIC); + } +#endif +#ifdef SQLITE_ENABLE_STAT4 + else if( op==TK_FUNCTION && pCtx!=0 ){ + rc = valueFromFunction(db, pExpr, enc, affinity, &pVal, pCtx); + } +#endif + else if( op==TK_TRUEFALSE ){ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + pVal = valueNew(db, pCtx); + if( pVal ){ + pVal->flags = MEM_Int; + pVal->u.i = pExpr->u.zToken[4]==0; + } + } + + *ppVal = pVal; + return rc; + +no_mem: +#ifdef SQLITE_ENABLE_STAT4 + if( pCtx==0 || NEVER(pCtx->pParse->nErr==0) ) +#endif + sqlite3OomFault(db); + sqlite3DbFree(db, zVal); + assert( *ppVal==0 ); +#ifdef SQLITE_ENABLE_STAT4 + if( pCtx==0 ) sqlite3ValueFree(pVal); +#else + assert( pCtx==0 ); sqlite3ValueFree(pVal); +#endif + return SQLITE_NOMEM_BKPT; +} + +/* +** Create a new sqlite3_value object, containing the value of pExpr. +** +** This only works for very simple expressions that consist of one constant +** token (i.e. "5", "5.1", "'a string'"). If the expression can +** be converted directly into a value, then the value is allocated and +** a pointer written to *ppVal. The caller is responsible for deallocating +** the value by passing it to sqlite3ValueFree() later on. If the expression +** cannot be converted to a value, then *ppVal is set to NULL. +*/ +SQLITE_PRIVATE int sqlite3ValueFromExpr( + sqlite3 *db, /* The database connection */ + const Expr *pExpr, /* The expression to evaluate */ + u8 enc, /* Encoding to use */ + u8 affinity, /* Affinity to use */ + sqlite3_value **ppVal /* Write the new value here */ +){ + return pExpr ? valueFromExpr(db, pExpr, enc, affinity, ppVal, 0) : 0; +} + +#ifdef SQLITE_ENABLE_STAT4 +/* +** Attempt to extract a value from pExpr and use it to construct *ppVal. +** +** If pAlloc is not NULL, then an UnpackedRecord object is created for +** pAlloc if one does not exist and the new value is added to the +** UnpackedRecord object. +** +** A value is extracted in the following cases: +** +** * (pExpr==0). In this case the value is assumed to be an SQL NULL, +** +** * The expression is a bound variable, and this is a reprepare, or +** +** * The expression is a literal value. +** +** On success, *ppVal is made to point to the extracted value. The caller +** is responsible for ensuring that the value is eventually freed. +*/ +static int stat4ValueFromExpr( + Parse *pParse, /* Parse context */ + Expr *pExpr, /* The expression to extract a value from */ + u8 affinity, /* Affinity to use */ + struct ValueNewStat4Ctx *pAlloc,/* How to allocate space. Or NULL */ + sqlite3_value **ppVal /* OUT: New value object (or NULL) */ +){ + int rc = SQLITE_OK; + sqlite3_value *pVal = 0; + sqlite3 *db = pParse->db; + + /* Skip over any TK_COLLATE nodes */ + pExpr = sqlite3ExprSkipCollate(pExpr); + + assert( pExpr==0 || pExpr->op!=TK_REGISTER || pExpr->op2!=TK_VARIABLE ); + if( !pExpr ){ + pVal = valueNew(db, pAlloc); + if( pVal ){ + sqlite3VdbeMemSetNull((Mem*)pVal); + } + }else if( pExpr->op==TK_VARIABLE && (db->flags & SQLITE_EnableQPSG)==0 ){ + Vdbe *v; + int iBindVar = pExpr->iColumn; + sqlite3VdbeSetVarmask(pParse->pVdbe, iBindVar); + if( (v = pParse->pReprepare)!=0 ){ + pVal = valueNew(db, pAlloc); + if( pVal ){ + rc = sqlite3VdbeMemCopy((Mem*)pVal, &v->aVar[iBindVar-1]); + sqlite3ValueApplyAffinity(pVal, affinity, ENC(db)); + pVal->db = pParse->db; + } + } + }else{ + rc = valueFromExpr(db, pExpr, ENC(db), affinity, &pVal, pAlloc); + } + + assert( pVal==0 || pVal->db==db ); + *ppVal = pVal; + return rc; +} + +/* +** This function is used to allocate and populate UnpackedRecord +** structures intended to be compared against sample index keys stored +** in the sqlite_stat4 table. +** +** A single call to this function populates zero or more fields of the +** record starting with field iVal (fields are numbered from left to +** right starting with 0). A single field is populated if: +** +** * (pExpr==0). In this case the value is assumed to be an SQL NULL, +** +** * The expression is a bound variable, and this is a reprepare, or +** +** * The sqlite3ValueFromExpr() function is able to extract a value +** from the expression (i.e. the expression is a literal value). +** +** Or, if pExpr is a TK_VECTOR, one field is populated for each of the +** vector components that match either of the two latter criteria listed +** above. +** +** Before any value is appended to the record, the affinity of the +** corresponding column within index pIdx is applied to it. Before +** this function returns, output parameter *pnExtract is set to the +** number of values appended to the record. +** +** When this function is called, *ppRec must either point to an object +** allocated by an earlier call to this function, or must be NULL. If it +** is NULL and a value can be successfully extracted, a new UnpackedRecord +** is allocated (and *ppRec set to point to it) before returning. +** +** Unless an error is encountered, SQLITE_OK is returned. It is not an +** error if a value cannot be extracted from pExpr. If an error does +** occur, an SQLite error code is returned. +*/ +SQLITE_PRIVATE int sqlite3Stat4ProbeSetValue( + Parse *pParse, /* Parse context */ + Index *pIdx, /* Index being probed */ + UnpackedRecord **ppRec, /* IN/OUT: Probe record */ + Expr *pExpr, /* The expression to extract a value from */ + int nElem, /* Maximum number of values to append */ + int iVal, /* Array element to populate */ + int *pnExtract /* OUT: Values appended to the record */ +){ + int rc = SQLITE_OK; + int nExtract = 0; + + if( pExpr==0 || pExpr->op!=TK_SELECT ){ + int i; + struct ValueNewStat4Ctx alloc; + + alloc.pParse = pParse; + alloc.pIdx = pIdx; + alloc.ppRec = ppRec; + + for(i=0; idb, pIdx, iVal+i); + alloc.iVal = iVal+i; + rc = stat4ValueFromExpr(pParse, pElem, aff, &alloc, &pVal); + if( !pVal ) break; + nExtract++; + } + } + + *pnExtract = nExtract; + return rc; +} + +/* +** Attempt to extract a value from expression pExpr using the methods +** as described for sqlite3Stat4ProbeSetValue() above. +** +** If successful, set *ppVal to point to a new value object and return +** SQLITE_OK. If no value can be extracted, but no other error occurs +** (e.g. OOM), return SQLITE_OK and set *ppVal to NULL. Or, if an error +** does occur, return an SQLite error code. The final value of *ppVal +** is undefined in this case. +*/ +SQLITE_PRIVATE int sqlite3Stat4ValueFromExpr( + Parse *pParse, /* Parse context */ + Expr *pExpr, /* The expression to extract a value from */ + u8 affinity, /* Affinity to use */ + sqlite3_value **ppVal /* OUT: New value object (or NULL) */ +){ + return stat4ValueFromExpr(pParse, pExpr, affinity, 0, ppVal); +} + +/* +** Extract the iCol-th column from the nRec-byte record in pRec. Write +** the column value into *ppVal. If *ppVal is initially NULL then a new +** sqlite3_value object is allocated. +** +** If *ppVal is initially NULL then the caller is responsible for +** ensuring that the value written into *ppVal is eventually freed. +*/ +SQLITE_PRIVATE int sqlite3Stat4Column( + sqlite3 *db, /* Database handle */ + const void *pRec, /* Pointer to buffer containing record */ + int nRec, /* Size of buffer pRec in bytes */ + int iCol, /* Column to extract */ + sqlite3_value **ppVal /* OUT: Extracted value */ +){ + u32 t = 0; /* a column type code */ + int nHdr; /* Size of the header in the record */ + int iHdr; /* Next unread header byte */ + int iField; /* Next unread data byte */ + int szField = 0; /* Size of the current data field */ + int i; /* Column index */ + u8 *a = (u8*)pRec; /* Typecast byte array */ + Mem *pMem = *ppVal; /* Write result into this Mem object */ + + assert( iCol>0 ); + iHdr = getVarint32(a, nHdr); + if( nHdr>nRec || iHdr>=nHdr ) return SQLITE_CORRUPT_BKPT; + iField = nHdr; + for(i=0; i<=iCol; i++){ + iHdr += getVarint32(&a[iHdr], t); + testcase( iHdr==nHdr ); + testcase( iHdr==nHdr+1 ); + if( iHdr>nHdr ) return SQLITE_CORRUPT_BKPT; + szField = sqlite3VdbeSerialTypeLen(t); + iField += szField; + } + testcase( iField==nRec ); + testcase( iField==nRec+1 ); + if( iField>nRec ) return SQLITE_CORRUPT_BKPT; + if( pMem==0 ){ + pMem = *ppVal = sqlite3ValueNew(db); + if( pMem==0 ) return SQLITE_NOMEM_BKPT; + } + sqlite3VdbeSerialGet(&a[iField-szField], t, pMem); + pMem->enc = ENC(db); + return SQLITE_OK; +} + +/* +** Unless it is NULL, the argument must be an UnpackedRecord object returned +** by an earlier call to sqlite3Stat4ProbeSetValue(). This call deletes +** the object. +*/ +SQLITE_PRIVATE void sqlite3Stat4ProbeFree(UnpackedRecord *pRec){ + if( pRec ){ + int i; + int nCol = pRec->pKeyInfo->nAllField; + Mem *aMem = pRec->aMem; + sqlite3 *db = aMem[0].db; + for(i=0; ipKeyInfo); + sqlite3DbFreeNN(db, pRec); + } +} +#endif /* ifdef SQLITE_ENABLE_STAT4 */ + +/* +** Change the string value of an sqlite3_value object +*/ +SQLITE_PRIVATE void sqlite3ValueSetStr( + sqlite3_value *v, /* Value to be set */ + int n, /* Length of string z */ + const void *z, /* Text of the new string */ + u8 enc, /* Encoding to use */ + void (*xDel)(void*) /* Destructor for the string */ +){ + if( v ) sqlite3VdbeMemSetStr((Mem *)v, z, n, enc, xDel); +} + +/* +** Free an sqlite3_value object +*/ +SQLITE_PRIVATE void sqlite3ValueFree(sqlite3_value *v){ + if( !v ) return; + sqlite3VdbeMemRelease((Mem *)v); + sqlite3DbFreeNN(((Mem*)v)->db, v); +} + +/* +** The sqlite3ValueBytes() routine returns the number of bytes in the +** sqlite3_value object assuming that it uses the encoding "enc". +** The valueBytes() routine is a helper function. +*/ +static SQLITE_NOINLINE int valueBytes(sqlite3_value *pVal, u8 enc){ + return valueToText(pVal, enc)!=0 ? pVal->n : 0; +} +SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){ + Mem *p = (Mem*)pVal; + assert( (p->flags & MEM_Null)==0 || (p->flags & (MEM_Str|MEM_Blob))==0 ); + if( (p->flags & MEM_Str)!=0 && pVal->enc==enc ){ + return p->n; + } + if( (p->flags & MEM_Str)!=0 && enc!=SQLITE_UTF8 && pVal->enc!=SQLITE_UTF8 ){ + return p->n; + } + if( (p->flags & MEM_Blob)!=0 ){ + if( p->flags & MEM_Zero ){ + return p->n + p->u.nZero; + }else{ + return p->n; + } + } + if( p->flags & MEM_Null ) return 0; + return valueBytes(pVal, enc); +} + +/************** End of vdbemem.c *********************************************/ +/************** Begin file vdbeaux.c *****************************************/ +/* +** 2003 September 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used for creating, destroying, and populating +** a VDBE (or an "sqlite3_stmt" as it is known to the outside world.) +*/ +/* #include "sqliteInt.h" */ +/* #include "vdbeInt.h" */ + +/* Forward references */ +static void freeEphemeralFunction(sqlite3 *db, FuncDef *pDef); +static void vdbeFreeOpArray(sqlite3 *, Op *, int); + +/* +** Create a new virtual database engine. +*/ +SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(Parse *pParse){ + sqlite3 *db = pParse->db; + Vdbe *p; + p = sqlite3DbMallocRawNN(db, sizeof(Vdbe) ); + if( p==0 ) return 0; + memset(&p->aOp, 0, sizeof(Vdbe)-offsetof(Vdbe,aOp)); + p->db = db; + if( db->pVdbe ){ + db->pVdbe->ppVPrev = &p->pVNext; + } + p->pVNext = db->pVdbe; + p->ppVPrev = &db->pVdbe; + db->pVdbe = p; + assert( p->eVdbeState==VDBE_INIT_STATE ); + p->pParse = pParse; + pParse->pVdbe = p; + assert( pParse->aLabel==0 ); + assert( pParse->nLabel==0 ); + assert( p->nOpAlloc==0 ); + assert( pParse->szOpAlloc==0 ); + sqlite3VdbeAddOp2(p, OP_Init, 0, 1); + return p; +} + +/* +** Return the Parse object that owns a Vdbe object. +*/ +SQLITE_PRIVATE Parse *sqlite3VdbeParser(Vdbe *p){ + return p->pParse; +} + +/* +** Change the error string stored in Vdbe.zErrMsg +*/ +SQLITE_PRIVATE void sqlite3VdbeError(Vdbe *p, const char *zFormat, ...){ + va_list ap; + sqlite3DbFree(p->db, p->zErrMsg); + va_start(ap, zFormat); + p->zErrMsg = sqlite3VMPrintf(p->db, zFormat, ap); + va_end(ap); +} + +/* +** Remember the SQL string for a prepared statement. +*/ +SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe *p, const char *z, int n, u8 prepFlags){ + if( p==0 ) return; + p->prepFlags = prepFlags; + if( (prepFlags & SQLITE_PREPARE_SAVESQL)==0 ){ + p->expmask = 0; + } + assert( p->zSql==0 ); + p->zSql = sqlite3DbStrNDup(p->db, z, n); +} + +#ifdef SQLITE_ENABLE_NORMALIZE +/* +** Add a new element to the Vdbe->pDblStr list. +*/ +SQLITE_PRIVATE void sqlite3VdbeAddDblquoteStr(sqlite3 *db, Vdbe *p, const char *z){ + if( p ){ + int n = sqlite3Strlen30(z); + DblquoteStr *pStr = sqlite3DbMallocRawNN(db, + sizeof(*pStr)+n+1-sizeof(pStr->z)); + if( pStr ){ + pStr->pNextStr = p->pDblStr; + p->pDblStr = pStr; + memcpy(pStr->z, z, n+1); + } + } +} +#endif + +#ifdef SQLITE_ENABLE_NORMALIZE +/* +** zId of length nId is a double-quoted identifier. Check to see if +** that identifier is really used as a string literal. +*/ +SQLITE_PRIVATE int sqlite3VdbeUsesDoubleQuotedString( + Vdbe *pVdbe, /* The prepared statement */ + const char *zId /* The double-quoted identifier, already dequoted */ +){ + DblquoteStr *pStr; + assert( zId!=0 ); + if( pVdbe->pDblStr==0 ) return 0; + for(pStr=pVdbe->pDblStr; pStr; pStr=pStr->pNextStr){ + if( strcmp(zId, pStr->z)==0 ) return 1; + } + return 0; +} +#endif + +/* +** Swap byte-code between two VDBE structures. +** +** This happens after pB was previously run and returned +** SQLITE_SCHEMA. The statement was then reprepared in pA. +** This routine transfers the new bytecode in pA over to pB +** so that pB can be run again. The old pB byte code is +** moved back to pA so that it will be cleaned up when pA is +** finalized. +*/ +SQLITE_PRIVATE void sqlite3VdbeSwap(Vdbe *pA, Vdbe *pB){ + Vdbe tmp, *pTmp, **ppTmp; + char *zTmp; + assert( pA->db==pB->db ); + tmp = *pA; + *pA = *pB; + *pB = tmp; + pTmp = pA->pVNext; + pA->pVNext = pB->pVNext; + pB->pVNext = pTmp; + ppTmp = pA->ppVPrev; + pA->ppVPrev = pB->ppVPrev; + pB->ppVPrev = ppTmp; + zTmp = pA->zSql; + pA->zSql = pB->zSql; + pB->zSql = zTmp; +#ifdef SQLITE_ENABLE_NORMALIZE + zTmp = pA->zNormSql; + pA->zNormSql = pB->zNormSql; + pB->zNormSql = zTmp; +#endif + pB->expmask = pA->expmask; + pB->prepFlags = pA->prepFlags; + memcpy(pB->aCounter, pA->aCounter, sizeof(pB->aCounter)); + pB->aCounter[SQLITE_STMTSTATUS_REPREPARE]++; +} + +/* +** Resize the Vdbe.aOp array so that it is at least nOp elements larger +** than its current size. nOp is guaranteed to be less than or equal +** to 1024/sizeof(Op). +** +** If an out-of-memory error occurs while resizing the array, return +** SQLITE_NOMEM. In this case Vdbe.aOp and Vdbe.nOpAlloc remain +** unchanged (this is so that any opcodes already allocated can be +** correctly deallocated along with the rest of the Vdbe). +*/ +static int growOpArray(Vdbe *v, int nOp){ + VdbeOp *pNew; + Parse *p = v->pParse; + + /* The SQLITE_TEST_REALLOC_STRESS compile-time option is designed to force + ** more frequent reallocs and hence provide more opportunities for + ** simulated OOM faults. SQLITE_TEST_REALLOC_STRESS is generally used + ** during testing only. With SQLITE_TEST_REALLOC_STRESS grow the op array + ** by the minimum* amount required until the size reaches 512. Normal + ** operation (without SQLITE_TEST_REALLOC_STRESS) is to double the current + ** size of the op array or add 1KB of space, whichever is smaller. */ +#ifdef SQLITE_TEST_REALLOC_STRESS + sqlite3_int64 nNew = (v->nOpAlloc>=512 ? 2*(sqlite3_int64)v->nOpAlloc + : (sqlite3_int64)v->nOpAlloc+nOp); +#else + sqlite3_int64 nNew = (v->nOpAlloc ? 2*(sqlite3_int64)v->nOpAlloc + : (sqlite3_int64)(1024/sizeof(Op))); + UNUSED_PARAMETER(nOp); +#endif + + /* Ensure that the size of a VDBE does not grow too large */ + if( nNew > p->db->aLimit[SQLITE_LIMIT_VDBE_OP] ){ + sqlite3OomFault(p->db); + return SQLITE_NOMEM; + } + + assert( nOp<=(int)(1024/sizeof(Op)) ); + assert( nNew>=(v->nOpAlloc+nOp) ); + pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op)); + if( pNew ){ + p->szOpAlloc = sqlite3DbMallocSize(p->db, pNew); + v->nOpAlloc = p->szOpAlloc/sizeof(Op); + v->aOp = pNew; + } + return (pNew ? SQLITE_OK : SQLITE_NOMEM_BKPT); +} + +#ifdef SQLITE_DEBUG +/* This routine is just a convenient place to set a breakpoint that will +** fire after each opcode is inserted and displayed using +** "PRAGMA vdbe_addoptrace=on". Parameters "pc" (program counter) and +** pOp are available to make the breakpoint conditional. +** +** Other useful labels for breakpoints include: +** test_trace_breakpoint(pc,pOp) +** sqlite3CorruptError(lineno) +** sqlite3MisuseError(lineno) +** sqlite3CantopenError(lineno) +*/ +static void test_addop_breakpoint(int pc, Op *pOp){ + static int n = 0; + (void)pc; + (void)pOp; + n++; +} +#endif + +/* +** Add a new instruction to the list of instructions current in the +** VDBE. Return the address of the new instruction. +** +** Parameters: +** +** p Pointer to the VDBE +** +** op The opcode for this instruction +** +** p1, p2, p3 Operands +** +** Use the sqlite3VdbeResolveLabel() function to fix an address and +** the sqlite3VdbeChangeP4() function to change the value of the P4 +** operand. +*/ +static SQLITE_NOINLINE int growOp3(Vdbe *p, int op, int p1, int p2, int p3){ + assert( p->nOpAlloc<=p->nOp ); + if( growOpArray(p, 1) ) return 1; + assert( p->nOpAlloc>p->nOp ); + return sqlite3VdbeAddOp3(p, op, p1, p2, p3); +} +SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){ + int i; + VdbeOp *pOp; + + i = p->nOp; + assert( p->eVdbeState==VDBE_INIT_STATE ); + assert( op>=0 && op<0xff ); + if( p->nOpAlloc<=i ){ + return growOp3(p, op, p1, p2, p3); + } + assert( p->aOp!=0 ); + p->nOp++; + pOp = &p->aOp[i]; + assert( pOp!=0 ); + pOp->opcode = (u8)op; + pOp->p5 = 0; + pOp->p1 = p1; + pOp->p2 = p2; + pOp->p3 = p3; + pOp->p4.p = 0; + pOp->p4type = P4_NOTUSED; +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + pOp->zComment = 0; +#endif +#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || defined(VDBE_PROFILE) + pOp->nExec = 0; + pOp->nCycle = 0; +#endif +#ifdef SQLITE_DEBUG + if( p->db->flags & SQLITE_VdbeAddopTrace ){ + sqlite3VdbePrintOp(0, i, &p->aOp[i]); + test_addop_breakpoint(i, &p->aOp[i]); + } +#endif +#ifdef SQLITE_VDBE_COVERAGE + pOp->iSrcLine = 0; +#endif + return i; +} +SQLITE_PRIVATE int sqlite3VdbeAddOp0(Vdbe *p, int op){ + return sqlite3VdbeAddOp3(p, op, 0, 0, 0); +} +SQLITE_PRIVATE int sqlite3VdbeAddOp1(Vdbe *p, int op, int p1){ + return sqlite3VdbeAddOp3(p, op, p1, 0, 0); +} +SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe *p, int op, int p1, int p2){ + return sqlite3VdbeAddOp3(p, op, p1, p2, 0); +} + +/* Generate code for an unconditional jump to instruction iDest +*/ +SQLITE_PRIVATE int sqlite3VdbeGoto(Vdbe *p, int iDest){ + return sqlite3VdbeAddOp3(p, OP_Goto, 0, iDest, 0); +} + +/* Generate code to cause the string zStr to be loaded into +** register iDest +*/ +SQLITE_PRIVATE int sqlite3VdbeLoadString(Vdbe *p, int iDest, const char *zStr){ + return sqlite3VdbeAddOp4(p, OP_String8, 0, iDest, 0, zStr, 0); +} + +/* +** Generate code that initializes multiple registers to string or integer +** constants. The registers begin with iDest and increase consecutively. +** One register is initialized for each characgter in zTypes[]. For each +** "s" character in zTypes[], the register is a string if the argument is +** not NULL, or OP_Null if the value is a null pointer. For each "i" character +** in zTypes[], the register is initialized to an integer. +** +** If the input string does not end with "X" then an OP_ResultRow instruction +** is generated for the values inserted. +*/ +SQLITE_PRIVATE void sqlite3VdbeMultiLoad(Vdbe *p, int iDest, const char *zTypes, ...){ + va_list ap; + int i; + char c; + va_start(ap, zTypes); + for(i=0; (c = zTypes[i])!=0; i++){ + if( c=='s' ){ + const char *z = va_arg(ap, const char*); + sqlite3VdbeAddOp4(p, z==0 ? OP_Null : OP_String8, 0, iDest+i, 0, z, 0); + }else if( c=='i' ){ + sqlite3VdbeAddOp2(p, OP_Integer, va_arg(ap, int), iDest+i); + }else{ + goto skip_op_resultrow; + } + } + sqlite3VdbeAddOp2(p, OP_ResultRow, iDest, i); +skip_op_resultrow: + va_end(ap); +} + +/* +** Add an opcode that includes the p4 value as a pointer. +*/ +SQLITE_PRIVATE int sqlite3VdbeAddOp4( + Vdbe *p, /* Add the opcode to this VM */ + int op, /* The new opcode */ + int p1, /* The P1 operand */ + int p2, /* The P2 operand */ + int p3, /* The P3 operand */ + const char *zP4, /* The P4 operand */ + int p4type /* P4 operand type */ +){ + int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3); + sqlite3VdbeChangeP4(p, addr, zP4, p4type); + return addr; +} + +/* +** Add an OP_Function or OP_PureFunc opcode. +** +** The eCallCtx argument is information (typically taken from Expr.op2) +** that describes the calling context of the function. 0 means a general +** function call. NC_IsCheck means called by a check constraint, +** NC_IdxExpr means called as part of an index expression. NC_PartIdx +** means in the WHERE clause of a partial index. NC_GenCol means called +** while computing a generated column value. 0 is the usual case. +*/ +SQLITE_PRIVATE int sqlite3VdbeAddFunctionCall( + Parse *pParse, /* Parsing context */ + int p1, /* Constant argument mask */ + int p2, /* First argument register */ + int p3, /* Register into which results are written */ + int nArg, /* Number of argument */ + const FuncDef *pFunc, /* The function to be invoked */ + int eCallCtx /* Calling context */ +){ + Vdbe *v = pParse->pVdbe; + int nByte; + int addr; + sqlite3_context *pCtx; + assert( v ); + nByte = sizeof(*pCtx) + (nArg-1)*sizeof(sqlite3_value*); + pCtx = sqlite3DbMallocRawNN(pParse->db, nByte); + if( pCtx==0 ){ + assert( pParse->db->mallocFailed ); + freeEphemeralFunction(pParse->db, (FuncDef*)pFunc); + return 0; + } + pCtx->pOut = 0; + pCtx->pFunc = (FuncDef*)pFunc; + pCtx->pVdbe = 0; + pCtx->isError = 0; + pCtx->argc = nArg; + pCtx->iOp = sqlite3VdbeCurrentAddr(v); + addr = sqlite3VdbeAddOp4(v, eCallCtx ? OP_PureFunc : OP_Function, + p1, p2, p3, (char*)pCtx, P4_FUNCCTX); + sqlite3VdbeChangeP5(v, eCallCtx & NC_SelfRef); + sqlite3MayAbort(pParse); + return addr; +} + +/* +** Add an opcode that includes the p4 value with a P4_INT64 or +** P4_REAL type. +*/ +SQLITE_PRIVATE int sqlite3VdbeAddOp4Dup8( + Vdbe *p, /* Add the opcode to this VM */ + int op, /* The new opcode */ + int p1, /* The P1 operand */ + int p2, /* The P2 operand */ + int p3, /* The P3 operand */ + const u8 *zP4, /* The P4 operand */ + int p4type /* P4 operand type */ +){ + char *p4copy = sqlite3DbMallocRawNN(sqlite3VdbeDb(p), 8); + if( p4copy ) memcpy(p4copy, zP4, 8); + return sqlite3VdbeAddOp4(p, op, p1, p2, p3, p4copy, p4type); +} + +#ifndef SQLITE_OMIT_EXPLAIN +/* +** Return the address of the current EXPLAIN QUERY PLAN baseline. +** 0 means "none". +*/ +SQLITE_PRIVATE int sqlite3VdbeExplainParent(Parse *pParse){ + VdbeOp *pOp; + if( pParse->addrExplain==0 ) return 0; + pOp = sqlite3VdbeGetOp(pParse->pVdbe, pParse->addrExplain); + return pOp->p2; +} + +/* +** Set a debugger breakpoint on the following routine in order to +** monitor the EXPLAIN QUERY PLAN code generation. +*/ +#if defined(SQLITE_DEBUG) +SQLITE_PRIVATE void sqlite3ExplainBreakpoint(const char *z1, const char *z2){ + (void)z1; + (void)z2; +} +#endif + +/* +** Add a new OP_Explain opcode. +** +** If the bPush flag is true, then make this opcode the parent for +** subsequent Explains until sqlite3VdbeExplainPop() is called. +*/ +SQLITE_PRIVATE int sqlite3VdbeExplain(Parse *pParse, u8 bPush, const char *zFmt, ...){ + int addr = 0; +#if !defined(SQLITE_DEBUG) + /* Always include the OP_Explain opcodes if SQLITE_DEBUG is defined. + ** But omit them (for performance) during production builds */ + if( pParse->explain==2 || IS_STMT_SCANSTATUS(pParse->db) ) +#endif + { + char *zMsg; + Vdbe *v; + va_list ap; + int iThis; + va_start(ap, zFmt); + zMsg = sqlite3VMPrintf(pParse->db, zFmt, ap); + va_end(ap); + v = pParse->pVdbe; + iThis = v->nOp; + addr = sqlite3VdbeAddOp4(v, OP_Explain, iThis, pParse->addrExplain, 0, + zMsg, P4_DYNAMIC); + sqlite3ExplainBreakpoint(bPush?"PUSH":"", sqlite3VdbeGetLastOp(v)->p4.z); + if( bPush){ + pParse->addrExplain = iThis; + } + sqlite3VdbeScanStatus(v, iThis, 0, 0, 0, 0); + } + return addr; +} + +/* +** Pop the EXPLAIN QUERY PLAN stack one level. +*/ +SQLITE_PRIVATE void sqlite3VdbeExplainPop(Parse *pParse){ + sqlite3ExplainBreakpoint("POP", 0); + pParse->addrExplain = sqlite3VdbeExplainParent(pParse); +} +#endif /* SQLITE_OMIT_EXPLAIN */ + +/* +** Add an OP_ParseSchema opcode. This routine is broken out from +** sqlite3VdbeAddOp4() since it needs to also needs to mark all btrees +** as having been used. +** +** The zWhere string must have been obtained from sqlite3_malloc(). +** This routine will take ownership of the allocated memory. +*/ +SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere, u16 p5){ + int j; + sqlite3VdbeAddOp4(p, OP_ParseSchema, iDb, 0, 0, zWhere, P4_DYNAMIC); + sqlite3VdbeChangeP5(p, p5); + for(j=0; jdb->nDb; j++) sqlite3VdbeUsesBtree(p, j); + sqlite3MayAbort(p->pParse); +} + +/* +** Add an opcode that includes the p4 value as an integer. +*/ +SQLITE_PRIVATE int sqlite3VdbeAddOp4Int( + Vdbe *p, /* Add the opcode to this VM */ + int op, /* The new opcode */ + int p1, /* The P1 operand */ + int p2, /* The P2 operand */ + int p3, /* The P3 operand */ + int p4 /* The P4 operand as an integer */ +){ + int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3); + if( p->db->mallocFailed==0 ){ + VdbeOp *pOp = &p->aOp[addr]; + pOp->p4type = P4_INT32; + pOp->p4.i = p4; + } + return addr; +} + +/* Insert the end of a co-routine +*/ +SQLITE_PRIVATE void sqlite3VdbeEndCoroutine(Vdbe *v, int regYield){ + sqlite3VdbeAddOp1(v, OP_EndCoroutine, regYield); + + /* Clear the temporary register cache, thereby ensuring that each + ** co-routine has its own independent set of registers, because co-routines + ** might expect their registers to be preserved across an OP_Yield, and + ** that could cause problems if two or more co-routines are using the same + ** temporary register. + */ + v->pParse->nTempReg = 0; + v->pParse->nRangeReg = 0; +} + +/* +** Create a new symbolic label for an instruction that has yet to be +** coded. The symbolic label is really just a negative number. The +** label can be used as the P2 value of an operation. Later, when +** the label is resolved to a specific address, the VDBE will scan +** through its operation list and change all values of P2 which match +** the label into the resolved address. +** +** The VDBE knows that a P2 value is a label because labels are +** always negative and P2 values are suppose to be non-negative. +** Hence, a negative P2 value is a label that has yet to be resolved. +** (Later:) This is only true for opcodes that have the OPFLG_JUMP +** property. +** +** Variable usage notes: +** +** Parse.aLabel[x] Stores the address that the x-th label resolves +** into. For testing (SQLITE_DEBUG), unresolved +** labels stores -1, but that is not required. +** Parse.nLabelAlloc Number of slots allocated to Parse.aLabel[] +** Parse.nLabel The *negative* of the number of labels that have +** been issued. The negative is stored because +** that gives a performance improvement over storing +** the equivalent positive value. +*/ +SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Parse *pParse){ + return --pParse->nLabel; +} + +/* +** Resolve label "x" to be the address of the next instruction to +** be inserted. The parameter "x" must have been obtained from +** a prior call to sqlite3VdbeMakeLabel(). +*/ +static SQLITE_NOINLINE void resizeResolveLabel(Parse *p, Vdbe *v, int j){ + int nNewSize = 10 - p->nLabel; + p->aLabel = sqlite3DbReallocOrFree(p->db, p->aLabel, + nNewSize*sizeof(p->aLabel[0])); + if( p->aLabel==0 ){ + p->nLabelAlloc = 0; + }else{ +#ifdef SQLITE_DEBUG + int i; + for(i=p->nLabelAlloc; iaLabel[i] = -1; +#endif + if( nNewSize>=100 && (nNewSize/100)>(p->nLabelAlloc/100) ){ + sqlite3ProgressCheck(p); + } + p->nLabelAlloc = nNewSize; + p->aLabel[j] = v->nOp; + } +} +SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe *v, int x){ + Parse *p = v->pParse; + int j = ADDR(x); + assert( v->eVdbeState==VDBE_INIT_STATE ); + assert( j<-p->nLabel ); + assert( j>=0 ); +#ifdef SQLITE_DEBUG + if( p->db->flags & SQLITE_VdbeAddopTrace ){ + printf("RESOLVE LABEL %d to %d\n", x, v->nOp); + } +#endif + if( p->nLabelAlloc + p->nLabel < 0 ){ + resizeResolveLabel(p,v,j); + }else{ + assert( p->aLabel[j]==(-1) ); /* Labels may only be resolved once */ + p->aLabel[j] = v->nOp; + } +} + +/* +** Mark the VDBE as one that can only be run one time. +*/ +SQLITE_PRIVATE void sqlite3VdbeRunOnlyOnce(Vdbe *p){ + sqlite3VdbeAddOp2(p, OP_Expire, 1, 1); +} + +/* +** Mark the VDBE as one that can be run multiple times. +*/ +SQLITE_PRIVATE void sqlite3VdbeReusable(Vdbe *p){ + int i; + for(i=1; ALWAYS(inOp); i++){ + if( ALWAYS(p->aOp[i].opcode==OP_Expire) ){ + p->aOp[1].opcode = OP_Noop; + break; + } + } +} + +#ifdef SQLITE_DEBUG /* sqlite3AssertMayAbort() logic */ + +/* +** The following type and function are used to iterate through all opcodes +** in a Vdbe main program and each of the sub-programs (triggers) it may +** invoke directly or indirectly. It should be used as follows: +** +** Op *pOp; +** VdbeOpIter sIter; +** +** memset(&sIter, 0, sizeof(sIter)); +** sIter.v = v; // v is of type Vdbe* +** while( (pOp = opIterNext(&sIter)) ){ +** // Do something with pOp +** } +** sqlite3DbFree(v->db, sIter.apSub); +** +*/ +typedef struct VdbeOpIter VdbeOpIter; +struct VdbeOpIter { + Vdbe *v; /* Vdbe to iterate through the opcodes of */ + SubProgram **apSub; /* Array of subprograms */ + int nSub; /* Number of entries in apSub */ + int iAddr; /* Address of next instruction to return */ + int iSub; /* 0 = main program, 1 = first sub-program etc. */ +}; +static Op *opIterNext(VdbeOpIter *p){ + Vdbe *v = p->v; + Op *pRet = 0; + Op *aOp; + int nOp; + + if( p->iSub<=p->nSub ){ + + if( p->iSub==0 ){ + aOp = v->aOp; + nOp = v->nOp; + }else{ + aOp = p->apSub[p->iSub-1]->aOp; + nOp = p->apSub[p->iSub-1]->nOp; + } + assert( p->iAddriAddr]; + p->iAddr++; + if( p->iAddr==nOp ){ + p->iSub++; + p->iAddr = 0; + } + + if( pRet->p4type==P4_SUBPROGRAM ){ + int nByte = (p->nSub+1)*sizeof(SubProgram*); + int j; + for(j=0; jnSub; j++){ + if( p->apSub[j]==pRet->p4.pProgram ) break; + } + if( j==p->nSub ){ + p->apSub = sqlite3DbReallocOrFree(v->db, p->apSub, nByte); + if( !p->apSub ){ + pRet = 0; + }else{ + p->apSub[p->nSub++] = pRet->p4.pProgram; + } + } + } + } + + return pRet; +} + +/* +** Check if the program stored in the VM associated with pParse may +** throw an ABORT exception (causing the statement, but not entire transaction +** to be rolled back). This condition is true if the main program or any +** sub-programs contains any of the following: +** +** * OP_Halt with P1=SQLITE_CONSTRAINT and P2=OE_Abort. +** * OP_HaltIfNull with P1=SQLITE_CONSTRAINT and P2=OE_Abort. +** * OP_Destroy +** * OP_VUpdate +** * OP_VCreate +** * OP_VRename +** * OP_FkCounter with P2==0 (immediate foreign key constraint) +** * OP_CreateBtree/BTREE_INTKEY and OP_InitCoroutine +** (for CREATE TABLE AS SELECT ...) +** +** Then check that the value of Parse.mayAbort is true if an +** ABORT may be thrown, or false otherwise. Return true if it does +** match, or false otherwise. This function is intended to be used as +** part of an assert statement in the compiler. Similar to: +** +** assert( sqlite3VdbeAssertMayAbort(pParse->pVdbe, pParse->mayAbort) ); +*/ +SQLITE_PRIVATE int sqlite3VdbeAssertMayAbort(Vdbe *v, int mayAbort){ + int hasAbort = 0; + int hasFkCounter = 0; + int hasCreateTable = 0; + int hasCreateIndex = 0; + int hasInitCoroutine = 0; + Op *pOp; + VdbeOpIter sIter; + + if( v==0 ) return 0; + memset(&sIter, 0, sizeof(sIter)); + sIter.v = v; + + while( (pOp = opIterNext(&sIter))!=0 ){ + int opcode = pOp->opcode; + if( opcode==OP_Destroy || opcode==OP_VUpdate || opcode==OP_VRename + || opcode==OP_VDestroy + || opcode==OP_VCreate + || opcode==OP_ParseSchema + || opcode==OP_Function || opcode==OP_PureFunc + || ((opcode==OP_Halt || opcode==OP_HaltIfNull) + && ((pOp->p1)!=SQLITE_OK && pOp->p2==OE_Abort)) + ){ + hasAbort = 1; + break; + } + if( opcode==OP_CreateBtree && pOp->p3==BTREE_INTKEY ) hasCreateTable = 1; + if( mayAbort ){ + /* hasCreateIndex may also be set for some DELETE statements that use + ** OP_Clear. So this routine may end up returning true in the case + ** where a "DELETE FROM tbl" has a statement-journal but does not + ** require one. This is not so bad - it is an inefficiency, not a bug. */ + if( opcode==OP_CreateBtree && pOp->p3==BTREE_BLOBKEY ) hasCreateIndex = 1; + if( opcode==OP_Clear ) hasCreateIndex = 1; + } + if( opcode==OP_InitCoroutine ) hasInitCoroutine = 1; +#ifndef SQLITE_OMIT_FOREIGN_KEY + if( opcode==OP_FkCounter && pOp->p1==0 && pOp->p2==1 ){ + hasFkCounter = 1; + } +#endif + } + sqlite3DbFree(v->db, sIter.apSub); + + /* Return true if hasAbort==mayAbort. Or if a malloc failure occurred. + ** If malloc failed, then the while() loop above may not have iterated + ** through all opcodes and hasAbort may be set incorrectly. Return + ** true for this case to prevent the assert() in the callers frame + ** from failing. */ + return ( v->db->mallocFailed || hasAbort==mayAbort || hasFkCounter + || (hasCreateTable && hasInitCoroutine) || hasCreateIndex + ); +} +#endif /* SQLITE_DEBUG - the sqlite3AssertMayAbort() function */ + +#ifdef SQLITE_DEBUG +/* +** Increment the nWrite counter in the VDBE if the cursor is not an +** ephemeral cursor, or if the cursor argument is NULL. +*/ +SQLITE_PRIVATE void sqlite3VdbeIncrWriteCounter(Vdbe *p, VdbeCursor *pC){ + if( pC==0 + || (pC->eCurType!=CURTYPE_SORTER + && pC->eCurType!=CURTYPE_PSEUDO + && !pC->isEphemeral) + ){ + p->nWrite++; + } +} +#endif + +#ifdef SQLITE_DEBUG +/* +** Assert if an Abort at this point in time might result in a corrupt +** database. +*/ +SQLITE_PRIVATE void sqlite3VdbeAssertAbortable(Vdbe *p){ + assert( p->nWrite==0 || p->usesStmtJournal ); +} +#endif + +/* +** This routine is called after all opcodes have been inserted. It loops +** through all the opcodes and fixes up some details. +** +** (1) For each jump instruction with a negative P2 value (a label) +** resolve the P2 value to an actual address. +** +** (2) Compute the maximum number of arguments used by any SQL function +** and store that value in *pMaxFuncArgs. +** +** (3) Update the Vdbe.readOnly and Vdbe.bIsReader flags to accurately +** indicate what the prepared statement actually does. +** +** (4) (discontinued) +** +** (5) Reclaim the memory allocated for storing labels. +** +** This routine will only function correctly if the mkopcodeh.tcl generator +** script numbers the opcodes correctly. Changes to this routine must be +** coordinated with changes to mkopcodeh.tcl. +*/ +static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){ + int nMaxArgs = *pMaxFuncArgs; + Op *pOp; + Parse *pParse = p->pParse; + int *aLabel = pParse->aLabel; + + assert( pParse->db->mallocFailed==0 ); /* tag-20230419-1 */ + p->readOnly = 1; + p->bIsReader = 0; + pOp = &p->aOp[p->nOp-1]; + assert( p->aOp[0].opcode==OP_Init ); + while( 1 /* Loop termates when it reaches the OP_Init opcode */ ){ + /* Only JUMP opcodes and the short list of special opcodes in the switch + ** below need to be considered. The mkopcodeh.tcl generator script groups + ** all these opcodes together near the front of the opcode list. Skip + ** any opcode that does not need processing by virtual of the fact that + ** it is larger than SQLITE_MX_JUMP_OPCODE, as a performance optimization. + */ + if( pOp->opcode<=SQLITE_MX_JUMP_OPCODE ){ + /* NOTE: Be sure to update mkopcodeh.tcl when adding or removing + ** cases from this switch! */ + switch( pOp->opcode ){ + case OP_Transaction: { + if( pOp->p2!=0 ) p->readOnly = 0; + /* no break */ deliberate_fall_through + } + case OP_AutoCommit: + case OP_Savepoint: { + p->bIsReader = 1; + break; + } +#ifndef SQLITE_OMIT_WAL + case OP_Checkpoint: +#endif + case OP_Vacuum: + case OP_JournalMode: { + p->readOnly = 0; + p->bIsReader = 1; + break; + } + case OP_Init: { + assert( pOp->p2>=0 ); + goto resolve_p2_values_loop_exit; + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + case OP_VUpdate: { + if( pOp->p2>nMaxArgs ) nMaxArgs = pOp->p2; + break; + } + case OP_VFilter: { + int n; + assert( (pOp - p->aOp) >= 3 ); + assert( pOp[-1].opcode==OP_Integer ); + n = pOp[-1].p1; + if( n>nMaxArgs ) nMaxArgs = n; + /* Fall through into the default case */ + /* no break */ deliberate_fall_through + } +#endif + default: { + if( pOp->p2<0 ){ + /* The mkopcodeh.tcl script has so arranged things that the only + ** non-jump opcodes less than SQLITE_MX_JUMP_CODE are guaranteed to + ** have non-negative values for P2. */ + assert( (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_JUMP)!=0 ); + assert( ADDR(pOp->p2)<-pParse->nLabel ); + assert( aLabel!=0 ); /* True because of tag-20230419-1 */ + pOp->p2 = aLabel[ADDR(pOp->p2)]; + } + break; + } + } + /* The mkopcodeh.tcl script has so arranged things that the only + ** non-jump opcodes less than SQLITE_MX_JUMP_CODE are guaranteed to + ** have non-negative values for P2. */ + assert( (sqlite3OpcodeProperty[pOp->opcode]&OPFLG_JUMP)==0 || pOp->p2>=0); + } + assert( pOp>p->aOp ); + pOp--; + } +resolve_p2_values_loop_exit: + if( aLabel ){ + sqlite3DbNNFreeNN(p->db, pParse->aLabel); + pParse->aLabel = 0; + } + pParse->nLabel = 0; + *pMaxFuncArgs = nMaxArgs; + assert( p->bIsReader!=0 || DbMaskAllZero(p->btreeMask) ); +} + +#ifdef SQLITE_DEBUG +/* +** Check to see if a subroutine contains a jump to a location outside of +** the subroutine. If a jump outside the subroutine is detected, add code +** that will cause the program to halt with an error message. +** +** The subroutine consists of opcodes between iFirst and iLast. Jumps to +** locations within the subroutine are acceptable. iRetReg is a register +** that contains the return address. Jumps to outside the range of iFirst +** through iLast are also acceptable as long as the jump destination is +** an OP_Return to iReturnAddr. +** +** A jump to an unresolved label means that the jump destination will be +** beyond the current address. That is normally a jump to an early +** termination and is consider acceptable. +** +** This routine only runs during debug builds. The purpose is (of course) +** to detect invalid escapes out of a subroutine. The OP_Halt opcode +** is generated rather than an assert() or other error, so that ".eqp full" +** will still work to show the original bytecode, to aid in debugging. +*/ +SQLITE_PRIVATE void sqlite3VdbeNoJumpsOutsideSubrtn( + Vdbe *v, /* The byte-code program under construction */ + int iFirst, /* First opcode of the subroutine */ + int iLast, /* Last opcode of the subroutine */ + int iRetReg /* Subroutine return address register */ +){ + VdbeOp *pOp; + Parse *pParse; + int i; + sqlite3_str *pErr = 0; + assert( v!=0 ); + pParse = v->pParse; + assert( pParse!=0 ); + if( pParse->nErr ) return; + assert( iLast>=iFirst ); + assert( iLastnOp ); + pOp = &v->aOp[iFirst]; + for(i=iFirst; i<=iLast; i++, pOp++){ + if( (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_JUMP)!=0 ){ + int iDest = pOp->p2; /* Jump destination */ + if( iDest==0 ) continue; + if( pOp->opcode==OP_Gosub ) continue; + if( iDest<0 ){ + int j = ADDR(iDest); + assert( j>=0 ); + if( j>=-pParse->nLabel || pParse->aLabel[j]<0 ){ + continue; + } + iDest = pParse->aLabel[j]; + } + if( iDestiLast ){ + int j = iDest; + for(; jnOp; j++){ + VdbeOp *pX = &v->aOp[j]; + if( pX->opcode==OP_Return ){ + if( pX->p1==iRetReg ) break; + continue; + } + if( pX->opcode==OP_Noop ) continue; + if( pX->opcode==OP_Explain ) continue; + if( pErr==0 ){ + pErr = sqlite3_str_new(0); + }else{ + sqlite3_str_appendchar(pErr, 1, '\n'); + } + sqlite3_str_appendf(pErr, + "Opcode at %d jumps to %d which is outside the " + "subroutine at %d..%d", + i, iDest, iFirst, iLast); + break; + } + } + } + } + if( pErr ){ + char *zErr = sqlite3_str_finish(pErr); + sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_INTERNAL, OE_Abort, 0, zErr, 0); + sqlite3_free(zErr); + sqlite3MayAbort(pParse); + } +} +#endif /* SQLITE_DEBUG */ + +/* +** Return the address of the next instruction to be inserted. +*/ +SQLITE_PRIVATE int sqlite3VdbeCurrentAddr(Vdbe *p){ + assert( p->eVdbeState==VDBE_INIT_STATE ); + return p->nOp; +} + +/* +** Verify that at least N opcode slots are available in p without +** having to malloc for more space (except when compiled using +** SQLITE_TEST_REALLOC_STRESS). This interface is used during testing +** to verify that certain calls to sqlite3VdbeAddOpList() can never +** fail due to a OOM fault and hence that the return value from +** sqlite3VdbeAddOpList() will always be non-NULL. +*/ +#if defined(SQLITE_DEBUG) && !defined(SQLITE_TEST_REALLOC_STRESS) +SQLITE_PRIVATE void sqlite3VdbeVerifyNoMallocRequired(Vdbe *p, int N){ + assert( p->nOp + N <= p->nOpAlloc ); +} +#endif + +/* +** Verify that the VM passed as the only argument does not contain +** an OP_ResultRow opcode. Fail an assert() if it does. This is used +** by code in pragma.c to ensure that the implementation of certain +** pragmas comports with the flags specified in the mkpragmatab.tcl +** script. +*/ +#if defined(SQLITE_DEBUG) && !defined(SQLITE_TEST_REALLOC_STRESS) +SQLITE_PRIVATE void sqlite3VdbeVerifyNoResultRow(Vdbe *p){ + int i; + for(i=0; inOp; i++){ + assert( p->aOp[i].opcode!=OP_ResultRow ); + } +} +#endif + +/* +** Generate code (a single OP_Abortable opcode) that will +** verify that the VDBE program can safely call Abort in the current +** context. +*/ +#if defined(SQLITE_DEBUG) +SQLITE_PRIVATE void sqlite3VdbeVerifyAbortable(Vdbe *p, int onError){ + if( onError==OE_Abort ) sqlite3VdbeAddOp0(p, OP_Abortable); +} +#endif + +/* +** This function returns a pointer to the array of opcodes associated with +** the Vdbe passed as the first argument. It is the callers responsibility +** to arrange for the returned array to be eventually freed using the +** vdbeFreeOpArray() function. +** +** Before returning, *pnOp is set to the number of entries in the returned +** array. Also, *pnMaxArg is set to the larger of its current value and +** the number of entries in the Vdbe.apArg[] array required to execute the +** returned program. +*/ +SQLITE_PRIVATE VdbeOp *sqlite3VdbeTakeOpArray(Vdbe *p, int *pnOp, int *pnMaxArg){ + VdbeOp *aOp = p->aOp; + assert( aOp && !p->db->mallocFailed ); + + /* Check that sqlite3VdbeUsesBtree() was not called on this VM */ + assert( DbMaskAllZero(p->btreeMask) ); + + resolveP2Values(p, pnMaxArg); + *pnOp = p->nOp; + p->aOp = 0; + return aOp; +} + +/* +** Add a whole list of operations to the operation stack. Return a +** pointer to the first operation inserted. +** +** Non-zero P2 arguments to jump instructions are automatically adjusted +** so that the jump target is relative to the first operation inserted. +*/ +SQLITE_PRIVATE VdbeOp *sqlite3VdbeAddOpList( + Vdbe *p, /* Add opcodes to the prepared statement */ + int nOp, /* Number of opcodes to add */ + VdbeOpList const *aOp, /* The opcodes to be added */ + int iLineno /* Source-file line number of first opcode */ +){ + int i; + VdbeOp *pOut, *pFirst; + assert( nOp>0 ); + assert( p->eVdbeState==VDBE_INIT_STATE ); + if( p->nOp + nOp > p->nOpAlloc && growOpArray(p, nOp) ){ + return 0; + } + pFirst = pOut = &p->aOp[p->nOp]; + for(i=0; iopcode = aOp->opcode; + pOut->p1 = aOp->p1; + pOut->p2 = aOp->p2; + assert( aOp->p2>=0 ); + if( (sqlite3OpcodeProperty[aOp->opcode] & OPFLG_JUMP)!=0 && aOp->p2>0 ){ + pOut->p2 += p->nOp; + } + pOut->p3 = aOp->p3; + pOut->p4type = P4_NOTUSED; + pOut->p4.p = 0; + pOut->p5 = 0; +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + pOut->zComment = 0; +#endif +#ifdef SQLITE_VDBE_COVERAGE + pOut->iSrcLine = iLineno+i; +#else + (void)iLineno; +#endif +#ifdef SQLITE_DEBUG + if( p->db->flags & SQLITE_VdbeAddopTrace ){ + sqlite3VdbePrintOp(0, i+p->nOp, &p->aOp[i+p->nOp]); + } +#endif + } + p->nOp += nOp; + return pFirst; +} + +#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) +/* +** Add an entry to the array of counters managed by sqlite3_stmt_scanstatus(). +*/ +SQLITE_PRIVATE void sqlite3VdbeScanStatus( + Vdbe *p, /* VM to add scanstatus() to */ + int addrExplain, /* Address of OP_Explain (or 0) */ + int addrLoop, /* Address of loop counter */ + int addrVisit, /* Address of rows visited counter */ + LogEst nEst, /* Estimated number of output rows */ + const char *zName /* Name of table or index being scanned */ +){ + if( IS_STMT_SCANSTATUS(p->db) ){ + sqlite3_int64 nByte = (p->nScan+1) * sizeof(ScanStatus); + ScanStatus *aNew; + aNew = (ScanStatus*)sqlite3DbRealloc(p->db, p->aScan, nByte); + if( aNew ){ + ScanStatus *pNew = &aNew[p->nScan++]; + memset(pNew, 0, sizeof(ScanStatus)); + pNew->addrExplain = addrExplain; + pNew->addrLoop = addrLoop; + pNew->addrVisit = addrVisit; + pNew->nEst = nEst; + pNew->zName = sqlite3DbStrDup(p->db, zName); + p->aScan = aNew; + } + } +} + +/* +** Add the range of instructions from addrStart to addrEnd (inclusive) to +** the set of those corresponding to the sqlite3_stmt_scanstatus() counters +** associated with the OP_Explain instruction at addrExplain. The +** sum of the sqlite3Hwtime() values for each of these instructions +** will be returned for SQLITE_SCANSTAT_NCYCLE requests. +*/ +SQLITE_PRIVATE void sqlite3VdbeScanStatusRange( + Vdbe *p, + int addrExplain, + int addrStart, + int addrEnd +){ + if( IS_STMT_SCANSTATUS(p->db) ){ + ScanStatus *pScan = 0; + int ii; + for(ii=p->nScan-1; ii>=0; ii--){ + pScan = &p->aScan[ii]; + if( pScan->addrExplain==addrExplain ) break; + pScan = 0; + } + if( pScan ){ + if( addrEnd<0 ) addrEnd = sqlite3VdbeCurrentAddr(p)-1; + for(ii=0; iiaAddrRange); ii+=2){ + if( pScan->aAddrRange[ii]==0 ){ + pScan->aAddrRange[ii] = addrStart; + pScan->aAddrRange[ii+1] = addrEnd; + break; + } + } + } + } +} + +/* +** Set the addresses for the SQLITE_SCANSTAT_NLOOP and SQLITE_SCANSTAT_NROW +** counters for the query element associated with the OP_Explain at +** addrExplain. +*/ +SQLITE_PRIVATE void sqlite3VdbeScanStatusCounters( + Vdbe *p, + int addrExplain, + int addrLoop, + int addrVisit +){ + if( IS_STMT_SCANSTATUS(p->db) ){ + ScanStatus *pScan = 0; + int ii; + for(ii=p->nScan-1; ii>=0; ii--){ + pScan = &p->aScan[ii]; + if( pScan->addrExplain==addrExplain ) break; + pScan = 0; + } + if( pScan ){ + pScan->addrLoop = addrLoop; + pScan->addrVisit = addrVisit; + } + } +} +#endif /* defined(SQLITE_ENABLE_STMT_SCANSTATUS) */ + + +/* +** Change the value of the opcode, or P1, P2, P3, or P5 operands +** for a specific instruction. +*/ +SQLITE_PRIVATE void sqlite3VdbeChangeOpcode(Vdbe *p, int addr, u8 iNewOpcode){ + assert( addr>=0 ); + sqlite3VdbeGetOp(p,addr)->opcode = iNewOpcode; +} +SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe *p, int addr, int val){ + assert( addr>=0 ); + sqlite3VdbeGetOp(p,addr)->p1 = val; +} +SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe *p, int addr, int val){ + assert( addr>=0 || p->db->mallocFailed ); + sqlite3VdbeGetOp(p,addr)->p2 = val; +} +SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe *p, int addr, int val){ + assert( addr>=0 ); + sqlite3VdbeGetOp(p,addr)->p3 = val; +} +SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe *p, u16 p5){ + assert( p->nOp>0 || p->db->mallocFailed ); + if( p->nOp>0 ) p->aOp[p->nOp-1].p5 = p5; +} + +/* +** If the previous opcode is an OP_Column that delivers results +** into register iDest, then add the OPFLAG_TYPEOFARG flag to that +** opcode. +*/ +SQLITE_PRIVATE void sqlite3VdbeTypeofColumn(Vdbe *p, int iDest){ + VdbeOp *pOp = sqlite3VdbeGetLastOp(p); + if( pOp->p3==iDest && pOp->opcode==OP_Column ){ + pOp->p5 |= OPFLAG_TYPEOFARG; + } +} + +/* +** Change the P2 operand of instruction addr so that it points to +** the address of the next instruction to be coded. +*/ +SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe *p, int addr){ + sqlite3VdbeChangeP2(p, addr, p->nOp); +} + +/* +** Change the P2 operand of the jump instruction at addr so that +** the jump lands on the next opcode. Or if the jump instruction was +** the previous opcode (and is thus a no-op) then simply back up +** the next instruction counter by one slot so that the jump is +** overwritten by the next inserted opcode. +** +** This routine is an optimization of sqlite3VdbeJumpHere() that +** strives to omit useless byte-code like this: +** +** 7 Once 0 8 0 +** 8 ... +*/ +SQLITE_PRIVATE void sqlite3VdbeJumpHereOrPopInst(Vdbe *p, int addr){ + if( addr==p->nOp-1 ){ + assert( p->aOp[addr].opcode==OP_Once + || p->aOp[addr].opcode==OP_If + || p->aOp[addr].opcode==OP_FkIfZero ); + assert( p->aOp[addr].p4type==0 ); +#ifdef SQLITE_VDBE_COVERAGE + sqlite3VdbeGetLastOp(p)->iSrcLine = 0; /* Erase VdbeCoverage() macros */ +#endif + p->nOp--; + }else{ + sqlite3VdbeChangeP2(p, addr, p->nOp); + } +} + + +/* +** If the input FuncDef structure is ephemeral, then free it. If +** the FuncDef is not ephermal, then do nothing. +*/ +static void freeEphemeralFunction(sqlite3 *db, FuncDef *pDef){ + assert( db!=0 ); + if( (pDef->funcFlags & SQLITE_FUNC_EPHEM)!=0 ){ + sqlite3DbNNFreeNN(db, pDef); + } +} + +/* +** Delete a P4 value if necessary. +*/ +static SQLITE_NOINLINE void freeP4Mem(sqlite3 *db, Mem *p){ + if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc); + sqlite3DbNNFreeNN(db, p); +} +static SQLITE_NOINLINE void freeP4FuncCtx(sqlite3 *db, sqlite3_context *p){ + assert( db!=0 ); + freeEphemeralFunction(db, p->pFunc); + sqlite3DbNNFreeNN(db, p); +} +static void freeP4(sqlite3 *db, int p4type, void *p4){ + assert( db ); + switch( p4type ){ + case P4_FUNCCTX: { + freeP4FuncCtx(db, (sqlite3_context*)p4); + break; + } + case P4_REAL: + case P4_INT64: + case P4_DYNAMIC: + case P4_INTARRAY: { + if( p4 ) sqlite3DbNNFreeNN(db, p4); + break; + } + case P4_KEYINFO: { + if( db->pnBytesFreed==0 ) sqlite3KeyInfoUnref((KeyInfo*)p4); + break; + } +#ifdef SQLITE_ENABLE_CURSOR_HINTS + case P4_EXPR: { + sqlite3ExprDelete(db, (Expr*)p4); + break; + } +#endif + case P4_FUNCDEF: { + freeEphemeralFunction(db, (FuncDef*)p4); + break; + } + case P4_MEM: { + if( db->pnBytesFreed==0 ){ + sqlite3ValueFree((sqlite3_value*)p4); + }else{ + freeP4Mem(db, (Mem*)p4); + } + break; + } + case P4_VTAB : { + if( db->pnBytesFreed==0 ) sqlite3VtabUnlock((VTable *)p4); + break; + } + } +} + +/* +** Free the space allocated for aOp and any p4 values allocated for the +** opcodes contained within. If aOp is not NULL it is assumed to contain +** nOp entries. +*/ +static void vdbeFreeOpArray(sqlite3 *db, Op *aOp, int nOp){ + assert( nOp>=0 ); + assert( db!=0 ); + if( aOp ){ + Op *pOp = &aOp[nOp-1]; + while(1){ /* Exit via break */ + if( pOp->p4type <= P4_FREE_IF_LE ) freeP4(db, pOp->p4type, pOp->p4.p); +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + sqlite3DbFree(db, pOp->zComment); +#endif + if( pOp==aOp ) break; + pOp--; + } + sqlite3DbNNFreeNN(db, aOp); + } +} + +/* +** Link the SubProgram object passed as the second argument into the linked +** list at Vdbe.pSubProgram. This list is used to delete all sub-program +** objects when the VM is no longer required. +*/ +SQLITE_PRIVATE void sqlite3VdbeLinkSubProgram(Vdbe *pVdbe, SubProgram *p){ + p->pNext = pVdbe->pProgram; + pVdbe->pProgram = p; +} + +/* +** Return true if the given Vdbe has any SubPrograms. +*/ +SQLITE_PRIVATE int sqlite3VdbeHasSubProgram(Vdbe *pVdbe){ + return pVdbe->pProgram!=0; +} + +/* +** Change the opcode at addr into OP_Noop +*/ +SQLITE_PRIVATE int sqlite3VdbeChangeToNoop(Vdbe *p, int addr){ + VdbeOp *pOp; + if( p->db->mallocFailed ) return 0; + assert( addr>=0 && addrnOp ); + pOp = &p->aOp[addr]; + freeP4(p->db, pOp->p4type, pOp->p4.p); + pOp->p4type = P4_NOTUSED; + pOp->p4.z = 0; + pOp->opcode = OP_Noop; + return 1; +} + +/* +** If the last opcode is "op" and it is not a jump destination, +** then remove it. Return true if and only if an opcode was removed. +*/ +SQLITE_PRIVATE int sqlite3VdbeDeletePriorOpcode(Vdbe *p, u8 op){ + if( p->nOp>0 && p->aOp[p->nOp-1].opcode==op ){ + return sqlite3VdbeChangeToNoop(p, p->nOp-1); + }else{ + return 0; + } +} + +#ifdef SQLITE_DEBUG +/* +** Generate an OP_ReleaseReg opcode to indicate that a range of +** registers, except any identified by mask, are no longer in use. +*/ +SQLITE_PRIVATE void sqlite3VdbeReleaseRegisters( + Parse *pParse, /* Parsing context */ + int iFirst, /* Index of first register to be released */ + int N, /* Number of registers to release */ + u32 mask, /* Mask of registers to NOT release */ + int bUndefine /* If true, mark registers as undefined */ +){ + if( N==0 || OptimizationDisabled(pParse->db, SQLITE_ReleaseReg) ) return; + assert( pParse->pVdbe ); + assert( iFirst>=1 ); + assert( iFirst+N-1<=pParse->nMem ); + if( N<=31 && mask!=0 ){ + while( N>0 && (mask&1)!=0 ){ + mask >>= 1; + iFirst++; + N--; + } + while( N>0 && N<=32 && (mask & MASKBIT32(N-1))!=0 ){ + mask &= ~MASKBIT32(N-1); + N--; + } + } + if( N>0 ){ + sqlite3VdbeAddOp3(pParse->pVdbe, OP_ReleaseReg, iFirst, N, *(int*)&mask); + if( bUndefine ) sqlite3VdbeChangeP5(pParse->pVdbe, 1); + } +} +#endif /* SQLITE_DEBUG */ + + +/* +** Change the value of the P4 operand for a specific instruction. +** This routine is useful when a large program is loaded from a +** static array using sqlite3VdbeAddOpList but we want to make a +** few minor changes to the program. +** +** If n>=0 then the P4 operand is dynamic, meaning that a copy of +** the string is made into memory obtained from sqlite3_malloc(). +** A value of n==0 means copy bytes of zP4 up to and including the +** first null byte. If n>0 then copy n+1 bytes of zP4. +** +** Other values of n (P4_STATIC, P4_COLLSEQ etc.) indicate that zP4 points +** to a string or structure that is guaranteed to exist for the lifetime of +** the Vdbe. In these cases we can just copy the pointer. +** +** If addr<0 then change P4 on the most recently inserted instruction. +*/ +static void SQLITE_NOINLINE vdbeChangeP4Full( + Vdbe *p, + Op *pOp, + const char *zP4, + int n +){ + if( pOp->p4type ){ + freeP4(p->db, pOp->p4type, pOp->p4.p); + pOp->p4type = 0; + pOp->p4.p = 0; + } + if( n<0 ){ + sqlite3VdbeChangeP4(p, (int)(pOp - p->aOp), zP4, n); + }else{ + if( n==0 ) n = sqlite3Strlen30(zP4); + pOp->p4.z = sqlite3DbStrNDup(p->db, zP4, n); + pOp->p4type = P4_DYNAMIC; + } +} +SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int n){ + Op *pOp; + sqlite3 *db; + assert( p!=0 ); + db = p->db; + assert( p->eVdbeState==VDBE_INIT_STATE ); + assert( p->aOp!=0 || db->mallocFailed ); + if( db->mallocFailed ){ + if( n!=P4_VTAB ) freeP4(db, n, (void*)*(char**)&zP4); + return; + } + assert( p->nOp>0 ); + assert( addrnOp ); + if( addr<0 ){ + addr = p->nOp - 1; + } + pOp = &p->aOp[addr]; + if( n>=0 || pOp->p4type ){ + vdbeChangeP4Full(p, pOp, zP4, n); + return; + } + if( n==P4_INT32 ){ + /* Note: this cast is safe, because the origin data point was an int + ** that was cast to a (const char *). */ + pOp->p4.i = SQLITE_PTR_TO_INT(zP4); + pOp->p4type = P4_INT32; + }else if( zP4!=0 ){ + assert( n<0 ); + pOp->p4.p = (void*)zP4; + pOp->p4type = (signed char)n; + if( n==P4_VTAB ) sqlite3VtabLock((VTable*)zP4); + } +} + +/* +** Change the P4 operand of the most recently coded instruction +** to the value defined by the arguments. This is a high-speed +** version of sqlite3VdbeChangeP4(). +** +** The P4 operand must not have been previously defined. And the new +** P4 must not be P4_INT32. Use sqlite3VdbeChangeP4() in either of +** those cases. +*/ +SQLITE_PRIVATE void sqlite3VdbeAppendP4(Vdbe *p, void *pP4, int n){ + VdbeOp *pOp; + assert( n!=P4_INT32 && n!=P4_VTAB ); + assert( n<=0 ); + if( p->db->mallocFailed ){ + freeP4(p->db, n, pP4); + }else{ + assert( pP4!=0 || n==P4_DYNAMIC ); + assert( p->nOp>0 ); + pOp = &p->aOp[p->nOp-1]; + assert( pOp->p4type==P4_NOTUSED ); + pOp->p4type = n; + pOp->p4.p = pP4; + } +} + +/* +** Set the P4 on the most recently added opcode to the KeyInfo for the +** index given. +*/ +SQLITE_PRIVATE void sqlite3VdbeSetP4KeyInfo(Parse *pParse, Index *pIdx){ + Vdbe *v = pParse->pVdbe; + KeyInfo *pKeyInfo; + assert( v!=0 ); + assert( pIdx!=0 ); + pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pIdx); + if( pKeyInfo ) sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO); +} + +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS +/* +** Change the comment on the most recently coded instruction. Or +** insert a No-op and add the comment to that new instruction. This +** makes the code easier to read during debugging. None of this happens +** in a production build. +*/ +static void vdbeVComment(Vdbe *p, const char *zFormat, va_list ap){ + assert( p->nOp>0 || p->aOp==0 ); + assert( p->aOp==0 || p->aOp[p->nOp-1].zComment==0 || p->pParse->nErr>0 ); + if( p->nOp ){ + assert( p->aOp ); + sqlite3DbFree(p->db, p->aOp[p->nOp-1].zComment); + p->aOp[p->nOp-1].zComment = sqlite3VMPrintf(p->db, zFormat, ap); + } +} +SQLITE_PRIVATE void sqlite3VdbeComment(Vdbe *p, const char *zFormat, ...){ + va_list ap; + if( p ){ + va_start(ap, zFormat); + vdbeVComment(p, zFormat, ap); + va_end(ap); + } +} +SQLITE_PRIVATE void sqlite3VdbeNoopComment(Vdbe *p, const char *zFormat, ...){ + va_list ap; + if( p ){ + sqlite3VdbeAddOp0(p, OP_Noop); + va_start(ap, zFormat); + vdbeVComment(p, zFormat, ap); + va_end(ap); + } +} +#endif /* NDEBUG */ + +#ifdef SQLITE_VDBE_COVERAGE +/* +** Set the value if the iSrcLine field for the previously coded instruction. +*/ +SQLITE_PRIVATE void sqlite3VdbeSetLineNumber(Vdbe *v, int iLine){ + sqlite3VdbeGetLastOp(v)->iSrcLine = iLine; +} +#endif /* SQLITE_VDBE_COVERAGE */ + +/* +** Return the opcode for a given address. The address must be non-negative. +** See sqlite3VdbeGetLastOp() to get the most recently added opcode. +** +** If a memory allocation error has occurred prior to the calling of this +** routine, then a pointer to a dummy VdbeOp will be returned. That opcode +** is readable but not writable, though it is cast to a writable value. +** The return of a dummy opcode allows the call to continue functioning +** after an OOM fault without having to check to see if the return from +** this routine is a valid pointer. But because the dummy.opcode is 0, +** dummy will never be written to. This is verified by code inspection and +** by running with Valgrind. +*/ +SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe *p, int addr){ + /* C89 specifies that the constant "dummy" will be initialized to all + ** zeros, which is correct. MSVC generates a warning, nevertheless. */ + static VdbeOp dummy; /* Ignore the MSVC warning about no initializer */ + assert( p->eVdbeState==VDBE_INIT_STATE ); + assert( (addr>=0 && addrnOp) || p->db->mallocFailed ); + if( p->db->mallocFailed ){ + return (VdbeOp*)&dummy; + }else{ + return &p->aOp[addr]; + } +} + +/* Return the most recently added opcode +*/ +SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetLastOp(Vdbe *p){ + return sqlite3VdbeGetOp(p, p->nOp - 1); +} + +#if defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) +/* +** Return an integer value for one of the parameters to the opcode pOp +** determined by character c. +*/ +static int translateP(char c, const Op *pOp){ + if( c=='1' ) return pOp->p1; + if( c=='2' ) return pOp->p2; + if( c=='3' ) return pOp->p3; + if( c=='4' ) return pOp->p4.i; + return pOp->p5; +} + +/* +** Compute a string for the "comment" field of a VDBE opcode listing. +** +** The Synopsis: field in comments in the vdbe.c source file gets converted +** to an extra string that is appended to the sqlite3OpcodeName(). In the +** absence of other comments, this synopsis becomes the comment on the opcode. +** Some translation occurs: +** +** "PX" -> "r[X]" +** "PX@PY" -> "r[X..X+Y-1]" or "r[x]" if y is 0 or 1 +** "PX@PY+1" -> "r[X..X+Y]" or "r[x]" if y is 0 +** "PY..PY" -> "r[X..Y]" or "r[x]" if y<=x +*/ +SQLITE_PRIVATE char *sqlite3VdbeDisplayComment( + sqlite3 *db, /* Optional - Oom error reporting only */ + const Op *pOp, /* The opcode to be commented */ + const char *zP4 /* Previously obtained value for P4 */ +){ + const char *zOpName; + const char *zSynopsis; + int nOpName; + int ii; + char zAlt[50]; + StrAccum x; + + sqlite3StrAccumInit(&x, 0, 0, 0, SQLITE_MAX_LENGTH); + zOpName = sqlite3OpcodeName(pOp->opcode); + nOpName = sqlite3Strlen30(zOpName); + if( zOpName[nOpName+1] ){ + int seenCom = 0; + char c; + zSynopsis = zOpName + nOpName + 1; + if( strncmp(zSynopsis,"IF ",3)==0 ){ + sqlite3_snprintf(sizeof(zAlt), zAlt, "if %s goto P2", zSynopsis+3); + zSynopsis = zAlt; + } + for(ii=0; (c = zSynopsis[ii])!=0; ii++){ + if( c=='P' ){ + c = zSynopsis[++ii]; + if( c=='4' ){ + sqlite3_str_appendall(&x, zP4); + }else if( c=='X' ){ + if( pOp->zComment && pOp->zComment[0] ){ + sqlite3_str_appendall(&x, pOp->zComment); + seenCom = 1; + break; + } + }else{ + int v1 = translateP(c, pOp); + int v2; + if( strncmp(zSynopsis+ii+1, "@P", 2)==0 ){ + ii += 3; + v2 = translateP(zSynopsis[ii], pOp); + if( strncmp(zSynopsis+ii+1,"+1",2)==0 ){ + ii += 2; + v2++; + } + if( v2<2 ){ + sqlite3_str_appendf(&x, "%d", v1); + }else{ + sqlite3_str_appendf(&x, "%d..%d", v1, v1+v2-1); + } + }else if( strncmp(zSynopsis+ii+1, "@NP", 3)==0 ){ + sqlite3_context *pCtx = pOp->p4.pCtx; + if( pOp->p4type!=P4_FUNCCTX || pCtx->argc==1 ){ + sqlite3_str_appendf(&x, "%d", v1); + }else if( pCtx->argc>1 ){ + sqlite3_str_appendf(&x, "%d..%d", v1, v1+pCtx->argc-1); + }else if( x.accError==0 ){ + assert( x.nChar>2 ); + x.nChar -= 2; + ii++; + } + ii += 3; + }else{ + sqlite3_str_appendf(&x, "%d", v1); + if( strncmp(zSynopsis+ii+1, "..P3", 4)==0 && pOp->p3==0 ){ + ii += 4; + } + } + } + }else{ + sqlite3_str_appendchar(&x, 1, c); + } + } + if( !seenCom && pOp->zComment ){ + sqlite3_str_appendf(&x, "; %s", pOp->zComment); + } + }else if( pOp->zComment ){ + sqlite3_str_appendall(&x, pOp->zComment); + } + if( (x.accError & SQLITE_NOMEM)!=0 && db!=0 ){ + sqlite3OomFault(db); + } + return sqlite3StrAccumFinish(&x); +} +#endif /* SQLITE_ENABLE_EXPLAIN_COMMENTS */ + +#if VDBE_DISPLAY_P4 && defined(SQLITE_ENABLE_CURSOR_HINTS) +/* +** Translate the P4.pExpr value for an OP_CursorHint opcode into text +** that can be displayed in the P4 column of EXPLAIN output. +*/ +static void displayP4Expr(StrAccum *p, Expr *pExpr){ + const char *zOp = 0; + switch( pExpr->op ){ + case TK_STRING: + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + sqlite3_str_appendf(p, "%Q", pExpr->u.zToken); + break; + case TK_INTEGER: + sqlite3_str_appendf(p, "%d", pExpr->u.iValue); + break; + case TK_NULL: + sqlite3_str_appendf(p, "NULL"); + break; + case TK_REGISTER: { + sqlite3_str_appendf(p, "r[%d]", pExpr->iTable); + break; + } + case TK_COLUMN: { + if( pExpr->iColumn<0 ){ + sqlite3_str_appendf(p, "rowid"); + }else{ + sqlite3_str_appendf(p, "c%d", (int)pExpr->iColumn); + } + break; + } + case TK_LT: zOp = "LT"; break; + case TK_LE: zOp = "LE"; break; + case TK_GT: zOp = "GT"; break; + case TK_GE: zOp = "GE"; break; + case TK_NE: zOp = "NE"; break; + case TK_EQ: zOp = "EQ"; break; + case TK_IS: zOp = "IS"; break; + case TK_ISNOT: zOp = "ISNOT"; break; + case TK_AND: zOp = "AND"; break; + case TK_OR: zOp = "OR"; break; + case TK_PLUS: zOp = "ADD"; break; + case TK_STAR: zOp = "MUL"; break; + case TK_MINUS: zOp = "SUB"; break; + case TK_REM: zOp = "REM"; break; + case TK_BITAND: zOp = "BITAND"; break; + case TK_BITOR: zOp = "BITOR"; break; + case TK_SLASH: zOp = "DIV"; break; + case TK_LSHIFT: zOp = "LSHIFT"; break; + case TK_RSHIFT: zOp = "RSHIFT"; break; + case TK_CONCAT: zOp = "CONCAT"; break; + case TK_UMINUS: zOp = "MINUS"; break; + case TK_UPLUS: zOp = "PLUS"; break; + case TK_BITNOT: zOp = "BITNOT"; break; + case TK_NOT: zOp = "NOT"; break; + case TK_ISNULL: zOp = "ISNULL"; break; + case TK_NOTNULL: zOp = "NOTNULL"; break; + + default: + sqlite3_str_appendf(p, "%s", "expr"); + break; + } + + if( zOp ){ + sqlite3_str_appendf(p, "%s(", zOp); + displayP4Expr(p, pExpr->pLeft); + if( pExpr->pRight ){ + sqlite3_str_append(p, ",", 1); + displayP4Expr(p, pExpr->pRight); + } + sqlite3_str_append(p, ")", 1); + } +} +#endif /* VDBE_DISPLAY_P4 && defined(SQLITE_ENABLE_CURSOR_HINTS) */ + + +#if VDBE_DISPLAY_P4 +/* +** Compute a string that describes the P4 parameter for an opcode. +** Use zTemp for any required temporary buffer space. +*/ +SQLITE_PRIVATE char *sqlite3VdbeDisplayP4(sqlite3 *db, Op *pOp){ + char *zP4 = 0; + StrAccum x; + + sqlite3StrAccumInit(&x, 0, 0, 0, SQLITE_MAX_LENGTH); + switch( pOp->p4type ){ + case P4_KEYINFO: { + int j; + KeyInfo *pKeyInfo = pOp->p4.pKeyInfo; + assert( pKeyInfo->aSortFlags!=0 ); + sqlite3_str_appendf(&x, "k(%d", pKeyInfo->nKeyField); + for(j=0; jnKeyField; j++){ + CollSeq *pColl = pKeyInfo->aColl[j]; + const char *zColl = pColl ? pColl->zName : ""; + if( strcmp(zColl, "BINARY")==0 ) zColl = "B"; + sqlite3_str_appendf(&x, ",%s%s%s", + (pKeyInfo->aSortFlags[j] & KEYINFO_ORDER_DESC) ? "-" : "", + (pKeyInfo->aSortFlags[j] & KEYINFO_ORDER_BIGNULL)? "N." : "", + zColl); + } + sqlite3_str_append(&x, ")", 1); + break; + } +#ifdef SQLITE_ENABLE_CURSOR_HINTS + case P4_EXPR: { + displayP4Expr(&x, pOp->p4.pExpr); + break; + } +#endif + case P4_COLLSEQ: { + static const char *const encnames[] = {"?", "8", "16LE", "16BE"}; + CollSeq *pColl = pOp->p4.pColl; + assert( pColl->enc<4 ); + sqlite3_str_appendf(&x, "%.18s-%s", pColl->zName, + encnames[pColl->enc]); + break; + } + case P4_FUNCDEF: { + FuncDef *pDef = pOp->p4.pFunc; + sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg); + break; + } + case P4_FUNCCTX: { + FuncDef *pDef = pOp->p4.pCtx->pFunc; + sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg); + break; + } + case P4_INT64: { + sqlite3_str_appendf(&x, "%lld", *pOp->p4.pI64); + break; + } + case P4_INT32: { + sqlite3_str_appendf(&x, "%d", pOp->p4.i); + break; + } + case P4_REAL: { + sqlite3_str_appendf(&x, "%.16g", *pOp->p4.pReal); + break; + } + case P4_MEM: { + Mem *pMem = pOp->p4.pMem; + if( pMem->flags & MEM_Str ){ + zP4 = pMem->z; + }else if( pMem->flags & (MEM_Int|MEM_IntReal) ){ + sqlite3_str_appendf(&x, "%lld", pMem->u.i); + }else if( pMem->flags & MEM_Real ){ + sqlite3_str_appendf(&x, "%.16g", pMem->u.r); + }else if( pMem->flags & MEM_Null ){ + zP4 = "NULL"; + }else{ + assert( pMem->flags & MEM_Blob ); + zP4 = "(blob)"; + } + break; + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + case P4_VTAB: { + sqlite3_vtab *pVtab = pOp->p4.pVtab->pVtab; + sqlite3_str_appendf(&x, "vtab:%p", pVtab); + break; + } +#endif + case P4_INTARRAY: { + u32 i; + u32 *ai = pOp->p4.ai; + u32 n = ai[0]; /* The first element of an INTARRAY is always the + ** count of the number of elements to follow */ + for(i=1; i<=n; i++){ + sqlite3_str_appendf(&x, "%c%u", (i==1 ? '[' : ','), ai[i]); + } + sqlite3_str_append(&x, "]", 1); + break; + } + case P4_SUBPROGRAM: { + zP4 = "program"; + break; + } + case P4_TABLE: { + zP4 = pOp->p4.pTab->zName; + break; + } + default: { + zP4 = pOp->p4.z; + } + } + if( zP4 ) sqlite3_str_appendall(&x, zP4); + if( (x.accError & SQLITE_NOMEM)!=0 ){ + sqlite3OomFault(db); + } + return sqlite3StrAccumFinish(&x); +} +#endif /* VDBE_DISPLAY_P4 */ + +/* +** Declare to the Vdbe that the BTree object at db->aDb[i] is used. +** +** The prepared statements need to know in advance the complete set of +** attached databases that will be use. A mask of these databases +** is maintained in p->btreeMask. The p->lockMask value is the subset of +** p->btreeMask of databases that will require a lock. +*/ +SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe *p, int i){ + assert( i>=0 && idb->nDb && i<(int)sizeof(yDbMask)*8 ); + assert( i<(int)sizeof(p->btreeMask)*8 ); + DbMaskSet(p->btreeMask, i); + if( i!=1 && sqlite3BtreeSharable(p->db->aDb[i].pBt) ){ + DbMaskSet(p->lockMask, i); + } +} + +#if !defined(SQLITE_OMIT_SHARED_CACHE) +/* +** If SQLite is compiled to support shared-cache mode and to be threadsafe, +** this routine obtains the mutex associated with each BtShared structure +** that may be accessed by the VM passed as an argument. In doing so it also +** sets the BtShared.db member of each of the BtShared structures, ensuring +** that the correct busy-handler callback is invoked if required. +** +** If SQLite is not threadsafe but does support shared-cache mode, then +** sqlite3BtreeEnter() is invoked to set the BtShared.db variables +** of all of BtShared structures accessible via the database handle +** associated with the VM. +** +** If SQLite is not threadsafe and does not support shared-cache mode, this +** function is a no-op. +** +** The p->btreeMask field is a bitmask of all btrees that the prepared +** statement p will ever use. Let N be the number of bits in p->btreeMask +** corresponding to btrees that use shared cache. Then the runtime of +** this routine is N*N. But as N is rarely more than 1, this should not +** be a problem. +*/ +SQLITE_PRIVATE void sqlite3VdbeEnter(Vdbe *p){ + int i; + sqlite3 *db; + Db *aDb; + int nDb; + if( DbMaskAllZero(p->lockMask) ) return; /* The common case */ + db = p->db; + aDb = db->aDb; + nDb = db->nDb; + for(i=0; ilockMask,i) && ALWAYS(aDb[i].pBt!=0) ){ + sqlite3BtreeEnter(aDb[i].pBt); + } + } +} +#endif + +#if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0 +/* +** Unlock all of the btrees previously locked by a call to sqlite3VdbeEnter(). +*/ +static SQLITE_NOINLINE void vdbeLeave(Vdbe *p){ + int i; + sqlite3 *db; + Db *aDb; + int nDb; + db = p->db; + aDb = db->aDb; + nDb = db->nDb; + for(i=0; ilockMask,i) && ALWAYS(aDb[i].pBt!=0) ){ + sqlite3BtreeLeave(aDb[i].pBt); + } + } +} +SQLITE_PRIVATE void sqlite3VdbeLeave(Vdbe *p){ + if( DbMaskAllZero(p->lockMask) ) return; /* The common case */ + vdbeLeave(p); +} +#endif + +#if defined(VDBE_PROFILE) || defined(SQLITE_DEBUG) +/* +** Print a single opcode. This routine is used for debugging only. +*/ +SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE *pOut, int pc, VdbeOp *pOp){ + char *zP4; + char *zCom; + sqlite3 dummyDb; + static const char *zFormat1 = "%4d %-13s %4d %4d %4d %-13s %.2X %s\n"; + if( pOut==0 ) pOut = stdout; + sqlite3BeginBenignMalloc(); + dummyDb.mallocFailed = 1; + zP4 = sqlite3VdbeDisplayP4(&dummyDb, pOp); +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + zCom = sqlite3VdbeDisplayComment(0, pOp, zP4); +#else + zCom = 0; +#endif + /* NB: The sqlite3OpcodeName() function is implemented by code created + ** by the mkopcodeh.awk and mkopcodec.awk scripts which extract the + ** information from the vdbe.c source text */ + fprintf(pOut, zFormat1, pc, + sqlite3OpcodeName(pOp->opcode), pOp->p1, pOp->p2, pOp->p3, + zP4 ? zP4 : "", pOp->p5, + zCom ? zCom : "" + ); + fflush(pOut); + sqlite3_free(zP4); + sqlite3_free(zCom); + sqlite3EndBenignMalloc(); +} +#endif + +/* +** Initialize an array of N Mem element. +** +** This is a high-runner, so only those fields that really do need to +** be initialized are set. The Mem structure is organized so that +** the fields that get initialized are nearby and hopefully on the same +** cache line. +** +** Mem.flags = flags +** Mem.db = db +** Mem.szMalloc = 0 +** +** All other fields of Mem can safely remain uninitialized for now. They +** will be initialized before use. +*/ +static void initMemArray(Mem *p, int N, sqlite3 *db, u16 flags){ + if( N>0 ){ + do{ + p->flags = flags; + p->db = db; + p->szMalloc = 0; +#ifdef SQLITE_DEBUG + p->pScopyFrom = 0; +#endif + p++; + }while( (--N)>0 ); + } +} + +/* +** Release auxiliary memory held in an array of N Mem elements. +** +** After this routine returns, all Mem elements in the array will still +** be valid. Those Mem elements that were not holding auxiliary resources +** will be unchanged. Mem elements which had something freed will be +** set to MEM_Undefined. +*/ +static void releaseMemArray(Mem *p, int N){ + if( p && N ){ + Mem *pEnd = &p[N]; + sqlite3 *db = p->db; + if( db->pnBytesFreed ){ + do{ + if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc); + }while( (++p)flags & MEM_Agg ); + testcase( p->flags & MEM_Dyn ); + if( p->flags&(MEM_Agg|MEM_Dyn) ){ + testcase( (p->flags & MEM_Dyn)!=0 && p->xDel==sqlite3VdbeFrameMemDel ); + sqlite3VdbeMemRelease(p); + p->flags = MEM_Undefined; + }else if( p->szMalloc ){ + sqlite3DbNNFreeNN(db, p->zMalloc); + p->szMalloc = 0; + p->flags = MEM_Undefined; + } +#ifdef SQLITE_DEBUG + else{ + p->flags = MEM_Undefined; + } +#endif + }while( (++p)iFrameMagic!=SQLITE_FRAME_MAGIC ) return 0; + return 1; +} +#endif + + +/* +** This is a destructor on a Mem object (which is really an sqlite3_value) +** that deletes the Frame object that is attached to it as a blob. +** +** This routine does not delete the Frame right away. It merely adds the +** frame to a list of frames to be deleted when the Vdbe halts. +*/ +SQLITE_PRIVATE void sqlite3VdbeFrameMemDel(void *pArg){ + VdbeFrame *pFrame = (VdbeFrame*)pArg; + assert( sqlite3VdbeFrameIsValid(pFrame) ); + pFrame->pParent = pFrame->v->pDelFrame; + pFrame->v->pDelFrame = pFrame; +} + +#if defined(SQLITE_ENABLE_BYTECODE_VTAB) || !defined(SQLITE_OMIT_EXPLAIN) +/* +** Locate the next opcode to be displayed in EXPLAIN or EXPLAIN +** QUERY PLAN output. +** +** Return SQLITE_ROW on success. Return SQLITE_DONE if there are no +** more opcodes to be displayed. +*/ +SQLITE_PRIVATE int sqlite3VdbeNextOpcode( + Vdbe *p, /* The statement being explained */ + Mem *pSub, /* Storage for keeping track of subprogram nesting */ + int eMode, /* 0: normal. 1: EQP. 2: TablesUsed */ + int *piPc, /* IN/OUT: Current rowid. Overwritten with next rowid */ + int *piAddr, /* OUT: Write index into (*paOp)[] here */ + Op **paOp /* OUT: Write the opcode array here */ +){ + int nRow; /* Stop when row count reaches this */ + int nSub = 0; /* Number of sub-vdbes seen so far */ + SubProgram **apSub = 0; /* Array of sub-vdbes */ + int i; /* Next instruction address */ + int rc = SQLITE_OK; /* Result code */ + Op *aOp = 0; /* Opcode array */ + int iPc; /* Rowid. Copy of value in *piPc */ + + /* When the number of output rows reaches nRow, that means the + ** listing has finished and sqlite3_step() should return SQLITE_DONE. + ** nRow is the sum of the number of rows in the main program, plus + ** the sum of the number of rows in all trigger subprograms encountered + ** so far. The nRow value will increase as new trigger subprograms are + ** encountered, but p->pc will eventually catch up to nRow. + */ + nRow = p->nOp; + if( pSub!=0 ){ + if( pSub->flags&MEM_Blob ){ + /* pSub is initiallly NULL. It is initialized to a BLOB by + ** the P4_SUBPROGRAM processing logic below */ + nSub = pSub->n/sizeof(Vdbe*); + apSub = (SubProgram **)pSub->z; + } + for(i=0; inOp; + } + } + iPc = *piPc; + while(1){ /* Loop exits via break */ + i = iPc++; + if( i>=nRow ){ + p->rc = SQLITE_OK; + rc = SQLITE_DONE; + break; + } + if( inOp ){ + /* The rowid is small enough that we are still in the + ** main program. */ + aOp = p->aOp; + }else{ + /* We are currently listing subprograms. Figure out which one and + ** pick up the appropriate opcode. */ + int j; + i -= p->nOp; + assert( apSub!=0 ); + assert( nSub>0 ); + for(j=0; i>=apSub[j]->nOp; j++){ + i -= apSub[j]->nOp; + assert( inOp || j+1aOp; + } + + /* When an OP_Program opcode is encounter (the only opcode that has + ** a P4_SUBPROGRAM argument), expand the size of the array of subprograms + ** kept in p->aMem[9].z to hold the new program - assuming this subprogram + ** has not already been seen. + */ + if( pSub!=0 && aOp[i].p4type==P4_SUBPROGRAM ){ + int nByte = (nSub+1)*sizeof(SubProgram*); + int j; + for(j=0; jrc = sqlite3VdbeMemGrow(pSub, nByte, nSub!=0); + if( p->rc!=SQLITE_OK ){ + rc = SQLITE_ERROR; + break; + } + apSub = (SubProgram **)pSub->z; + apSub[nSub++] = aOp[i].p4.pProgram; + MemSetTypeFlag(pSub, MEM_Blob); + pSub->n = nSub*sizeof(SubProgram*); + nRow += aOp[i].p4.pProgram->nOp; + } + } + if( eMode==0 ) break; +#ifdef SQLITE_ENABLE_BYTECODE_VTAB + if( eMode==2 ){ + Op *pOp = aOp + i; + if( pOp->opcode==OP_OpenRead ) break; + if( pOp->opcode==OP_OpenWrite && (pOp->p5 & OPFLAG_P2ISREG)==0 ) break; + if( pOp->opcode==OP_ReopenIdx ) break; + }else +#endif + { + assert( eMode==1 ); + if( aOp[i].opcode==OP_Explain ) break; + if( aOp[i].opcode==OP_Init && iPc>1 ) break; + } + } + *piPc = iPc; + *piAddr = i; + *paOp = aOp; + return rc; +} +#endif /* SQLITE_ENABLE_BYTECODE_VTAB || !SQLITE_OMIT_EXPLAIN */ + + +/* +** Delete a VdbeFrame object and its contents. VdbeFrame objects are +** allocated by the OP_Program opcode in sqlite3VdbeExec(). +*/ +SQLITE_PRIVATE void sqlite3VdbeFrameDelete(VdbeFrame *p){ + int i; + Mem *aMem = VdbeFrameMem(p); + VdbeCursor **apCsr = (VdbeCursor **)&aMem[p->nChildMem]; + assert( sqlite3VdbeFrameIsValid(p) ); + for(i=0; inChildCsr; i++){ + if( apCsr[i] ) sqlite3VdbeFreeCursorNN(p->v, apCsr[i]); + } + releaseMemArray(aMem, p->nChildMem); + sqlite3VdbeDeleteAuxData(p->v->db, &p->pAuxData, -1, 0); + sqlite3DbFree(p->v->db, p); +} + +#ifndef SQLITE_OMIT_EXPLAIN +/* +** Give a listing of the program in the virtual machine. +** +** The interface is the same as sqlite3VdbeExec(). But instead of +** running the code, it invokes the callback once for each instruction. +** This feature is used to implement "EXPLAIN". +** +** When p->explain==1, each instruction is listed. When +** p->explain==2, only OP_Explain instructions are listed and these +** are shown in a different format. p->explain==2 is used to implement +** EXPLAIN QUERY PLAN. +** 2018-04-24: In p->explain==2 mode, the OP_Init opcodes of triggers +** are also shown, so that the boundaries between the main program and +** each trigger are clear. +** +** When p->explain==1, first the main program is listed, then each of +** the trigger subprograms are listed one by one. +*/ +SQLITE_PRIVATE int sqlite3VdbeList( + Vdbe *p /* The VDBE */ +){ + Mem *pSub = 0; /* Memory cell hold array of subprogs */ + sqlite3 *db = p->db; /* The database connection */ + int i; /* Loop counter */ + int rc = SQLITE_OK; /* Return code */ + Mem *pMem = &p->aMem[1]; /* First Mem of result set */ + int bListSubprogs = (p->explain==1 || (db->flags & SQLITE_TriggerEQP)!=0); + Op *aOp; /* Array of opcodes */ + Op *pOp; /* Current opcode */ + + assert( p->explain ); + assert( p->eVdbeState==VDBE_RUN_STATE ); + assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || p->rc==SQLITE_NOMEM ); + + /* Even though this opcode does not use dynamic strings for + ** the result, result columns may become dynamic if the user calls + ** sqlite3_column_text16(), causing a translation to UTF-16 encoding. + */ + releaseMemArray(pMem, 8); + + if( p->rc==SQLITE_NOMEM ){ + /* This happens if a malloc() inside a call to sqlite3_column_text() or + ** sqlite3_column_text16() failed. */ + sqlite3OomFault(db); + return SQLITE_ERROR; + } + + if( bListSubprogs ){ + /* The first 8 memory cells are used for the result set. So we will + ** commandeer the 9th cell to use as storage for an array of pointers + ** to trigger subprograms. The VDBE is guaranteed to have at least 9 + ** cells. */ + assert( p->nMem>9 ); + pSub = &p->aMem[9]; + }else{ + pSub = 0; + } + + /* Figure out which opcode is next to display */ + rc = sqlite3VdbeNextOpcode(p, pSub, p->explain==2, &p->pc, &i, &aOp); + + if( rc==SQLITE_OK ){ + pOp = aOp + i; + if( AtomicLoad(&db->u1.isInterrupted) ){ + p->rc = SQLITE_INTERRUPT; + rc = SQLITE_ERROR; + sqlite3VdbeError(p, sqlite3ErrStr(p->rc)); + }else{ + char *zP4 = sqlite3VdbeDisplayP4(db, pOp); + if( p->explain==2 ){ + sqlite3VdbeMemSetInt64(pMem, pOp->p1); + sqlite3VdbeMemSetInt64(pMem+1, pOp->p2); + sqlite3VdbeMemSetInt64(pMem+2, pOp->p3); + sqlite3VdbeMemSetStr(pMem+3, zP4, -1, SQLITE_UTF8, sqlite3_free); + p->nResColumn = 4; + }else{ + sqlite3VdbeMemSetInt64(pMem+0, i); + sqlite3VdbeMemSetStr(pMem+1, (char*)sqlite3OpcodeName(pOp->opcode), + -1, SQLITE_UTF8, SQLITE_STATIC); + sqlite3VdbeMemSetInt64(pMem+2, pOp->p1); + sqlite3VdbeMemSetInt64(pMem+3, pOp->p2); + sqlite3VdbeMemSetInt64(pMem+4, pOp->p3); + /* pMem+5 for p4 is done last */ + sqlite3VdbeMemSetInt64(pMem+6, pOp->p5); +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + { + char *zCom = sqlite3VdbeDisplayComment(db, pOp, zP4); + sqlite3VdbeMemSetStr(pMem+7, zCom, -1, SQLITE_UTF8, sqlite3_free); + } +#else + sqlite3VdbeMemSetNull(pMem+7); +#endif + sqlite3VdbeMemSetStr(pMem+5, zP4, -1, SQLITE_UTF8, sqlite3_free); + p->nResColumn = 8; + } + p->pResultRow = pMem; + if( db->mallocFailed ){ + p->rc = SQLITE_NOMEM; + rc = SQLITE_ERROR; + }else{ + p->rc = SQLITE_OK; + rc = SQLITE_ROW; + } + } + } + return rc; +} +#endif /* SQLITE_OMIT_EXPLAIN */ + +#ifdef SQLITE_DEBUG +/* +** Print the SQL that was used to generate a VDBE program. +*/ +SQLITE_PRIVATE void sqlite3VdbePrintSql(Vdbe *p){ + const char *z = 0; + if( p->zSql ){ + z = p->zSql; + }else if( p->nOp>=1 ){ + const VdbeOp *pOp = &p->aOp[0]; + if( pOp->opcode==OP_Init && pOp->p4.z!=0 ){ + z = pOp->p4.z; + while( sqlite3Isspace(*z) ) z++; + } + } + if( z ) printf("SQL: [%s]\n", z); +} +#endif + +#if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE) +/* +** Print an IOTRACE message showing SQL content. +*/ +SQLITE_PRIVATE void sqlite3VdbeIOTraceSql(Vdbe *p){ + int nOp = p->nOp; + VdbeOp *pOp; + if( sqlite3IoTrace==0 ) return; + if( nOp<1 ) return; + pOp = &p->aOp[0]; + if( pOp->opcode==OP_Init && pOp->p4.z!=0 ){ + int i, j; + char z[1000]; + sqlite3_snprintf(sizeof(z), z, "%s", pOp->p4.z); + for(i=0; sqlite3Isspace(z[i]); i++){} + for(j=0; z[i]; i++){ + if( sqlite3Isspace(z[i]) ){ + if( z[i-1]!=' ' ){ + z[j++] = ' '; + } + }else{ + z[j++] = z[i]; + } + } + z[j] = 0; + sqlite3IoTrace("SQL %s\n", z); + } +} +#endif /* !SQLITE_OMIT_TRACE && SQLITE_ENABLE_IOTRACE */ + +/* An instance of this object describes bulk memory available for use +** by subcomponents of a prepared statement. Space is allocated out +** of a ReusableSpace object by the allocSpace() routine below. +*/ +struct ReusableSpace { + u8 *pSpace; /* Available memory */ + sqlite3_int64 nFree; /* Bytes of available memory */ + sqlite3_int64 nNeeded; /* Total bytes that could not be allocated */ +}; + +/* Try to allocate nByte bytes of 8-byte aligned bulk memory for pBuf +** from the ReusableSpace object. Return a pointer to the allocated +** memory on success. If insufficient memory is available in the +** ReusableSpace object, increase the ReusableSpace.nNeeded +** value by the amount needed and return NULL. +** +** If pBuf is not initially NULL, that means that the memory has already +** been allocated by a prior call to this routine, so just return a copy +** of pBuf and leave ReusableSpace unchanged. +** +** This allocator is employed to repurpose unused slots at the end of the +** opcode array of prepared state for other memory needs of the prepared +** statement. +*/ +static void *allocSpace( + struct ReusableSpace *p, /* Bulk memory available for allocation */ + void *pBuf, /* Pointer to a prior allocation */ + sqlite3_int64 nByte /* Bytes of memory needed. */ +){ + assert( EIGHT_BYTE_ALIGNMENT(p->pSpace) ); + if( pBuf==0 ){ + nByte = ROUND8P(nByte); + if( nByte <= p->nFree ){ + p->nFree -= nByte; + pBuf = &p->pSpace[p->nFree]; + }else{ + p->nNeeded += nByte; + } + } + assert( EIGHT_BYTE_ALIGNMENT(pBuf) ); + return pBuf; +} + +/* +** Rewind the VDBE back to the beginning in preparation for +** running it. +*/ +SQLITE_PRIVATE void sqlite3VdbeRewind(Vdbe *p){ +#if defined(SQLITE_DEBUG) + int i; +#endif + assert( p!=0 ); + assert( p->eVdbeState==VDBE_INIT_STATE + || p->eVdbeState==VDBE_READY_STATE + || p->eVdbeState==VDBE_HALT_STATE ); + + /* There should be at least one opcode. + */ + assert( p->nOp>0 ); + + p->eVdbeState = VDBE_READY_STATE; + +#ifdef SQLITE_DEBUG + for(i=0; inMem; i++){ + assert( p->aMem[i].db==p->db ); + } +#endif + p->pc = -1; + p->rc = SQLITE_OK; + p->errorAction = OE_Abort; + p->nChange = 0; + p->cacheCtr = 1; + p->minWriteFileFormat = 255; + p->iStatement = 0; + p->nFkConstraint = 0; +#ifdef VDBE_PROFILE + for(i=0; inOp; i++){ + p->aOp[i].nExec = 0; + p->aOp[i].nCycle = 0; + } +#endif +} + +/* +** Prepare a virtual machine for execution for the first time after +** creating the virtual machine. This involves things such +** as allocating registers and initializing the program counter. +** After the VDBE has be prepped, it can be executed by one or more +** calls to sqlite3VdbeExec(). +** +** This function may be called exactly once on each virtual machine. +** After this routine is called the VM has been "packaged" and is ready +** to run. After this routine is called, further calls to +** sqlite3VdbeAddOp() functions are prohibited. This routine disconnects +** the Vdbe from the Parse object that helped generate it so that the +** the Vdbe becomes an independent entity and the Parse object can be +** destroyed. +** +** Use the sqlite3VdbeRewind() procedure to restore a virtual machine back +** to its initial state after it has been run. +*/ +SQLITE_PRIVATE void sqlite3VdbeMakeReady( + Vdbe *p, /* The VDBE */ + Parse *pParse /* Parsing context */ +){ + sqlite3 *db; /* The database connection */ + int nVar; /* Number of parameters */ + int nMem; /* Number of VM memory registers */ + int nCursor; /* Number of cursors required */ + int nArg; /* Number of arguments in subprograms */ + int n; /* Loop counter */ + struct ReusableSpace x; /* Reusable bulk memory */ + + assert( p!=0 ); + assert( p->nOp>0 ); + assert( pParse!=0 ); + assert( p->eVdbeState==VDBE_INIT_STATE ); + assert( pParse==p->pParse ); + p->pVList = pParse->pVList; + pParse->pVList = 0; + db = p->db; + assert( db->mallocFailed==0 ); + nVar = pParse->nVar; + nMem = pParse->nMem; + nCursor = pParse->nTab; + nArg = pParse->nMaxArg; + + /* Each cursor uses a memory cell. The first cursor (cursor 0) can + ** use aMem[0] which is not otherwise used by the VDBE program. Allocate + ** space at the end of aMem[] for cursors 1 and greater. + ** See also: allocateCursor(). + */ + nMem += nCursor; + if( nCursor==0 && nMem>0 ) nMem++; /* Space for aMem[0] even if not used */ + + /* Figure out how much reusable memory is available at the end of the + ** opcode array. This extra memory will be reallocated for other elements + ** of the prepared statement. + */ + n = ROUND8P(sizeof(Op)*p->nOp); /* Bytes of opcode memory used */ + x.pSpace = &((u8*)p->aOp)[n]; /* Unused opcode memory */ + assert( EIGHT_BYTE_ALIGNMENT(x.pSpace) ); + x.nFree = ROUNDDOWN8(pParse->szOpAlloc - n); /* Bytes of unused memory */ + assert( x.nFree>=0 ); + assert( EIGHT_BYTE_ALIGNMENT(&x.pSpace[x.nFree]) ); + + resolveP2Values(p, &nArg); + p->usesStmtJournal = (u8)(pParse->isMultiWrite && pParse->mayAbort); + if( pParse->explain ){ + static const char * const azColName[] = { + "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment", + "id", "parent", "notused", "detail" + }; + int iFirst, mx, i; + if( nMem<10 ) nMem = 10; + p->explain = pParse->explain; + if( pParse->explain==2 ){ + sqlite3VdbeSetNumCols(p, 4); + iFirst = 8; + mx = 12; + }else{ + sqlite3VdbeSetNumCols(p, 8); + iFirst = 0; + mx = 8; + } + for(i=iFirst; iexpired = 0; + + /* Memory for registers, parameters, cursor, etc, is allocated in one or two + ** passes. On the first pass, we try to reuse unused memory at the + ** end of the opcode array. If we are unable to satisfy all memory + ** requirements by reusing the opcode array tail, then the second + ** pass will fill in the remainder using a fresh memory allocation. + ** + ** This two-pass approach that reuses as much memory as possible from + ** the leftover memory at the end of the opcode array. This can significantly + ** reduce the amount of memory held by a prepared statement. + */ + x.nNeeded = 0; + p->aMem = allocSpace(&x, 0, nMem*sizeof(Mem)); + p->aVar = allocSpace(&x, 0, nVar*sizeof(Mem)); + p->apArg = allocSpace(&x, 0, nArg*sizeof(Mem*)); + p->apCsr = allocSpace(&x, 0, nCursor*sizeof(VdbeCursor*)); + if( x.nNeeded ){ + x.pSpace = p->pFree = sqlite3DbMallocRawNN(db, x.nNeeded); + x.nFree = x.nNeeded; + if( !db->mallocFailed ){ + p->aMem = allocSpace(&x, p->aMem, nMem*sizeof(Mem)); + p->aVar = allocSpace(&x, p->aVar, nVar*sizeof(Mem)); + p->apArg = allocSpace(&x, p->apArg, nArg*sizeof(Mem*)); + p->apCsr = allocSpace(&x, p->apCsr, nCursor*sizeof(VdbeCursor*)); + } + } + + if( db->mallocFailed ){ + p->nVar = 0; + p->nCursor = 0; + p->nMem = 0; + }else{ + p->nCursor = nCursor; + p->nVar = (ynVar)nVar; + initMemArray(p->aVar, nVar, db, MEM_Null); + p->nMem = nMem; + initMemArray(p->aMem, nMem, db, MEM_Undefined); + memset(p->apCsr, 0, nCursor*sizeof(VdbeCursor*)); + } + sqlite3VdbeRewind(p); +} + +/* +** Close a VDBE cursor and release all the resources that cursor +** happens to hold. +*/ +SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){ + if( pCx ) sqlite3VdbeFreeCursorNN(p,pCx); +} +SQLITE_PRIVATE void sqlite3VdbeFreeCursorNN(Vdbe *p, VdbeCursor *pCx){ + switch( pCx->eCurType ){ + case CURTYPE_SORTER: { + sqlite3VdbeSorterClose(p->db, pCx); + break; + } + case CURTYPE_BTREE: { + assert( pCx->uc.pCursor!=0 ); + sqlite3BtreeCloseCursor(pCx->uc.pCursor); + break; + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + case CURTYPE_VTAB: { + sqlite3_vtab_cursor *pVCur = pCx->uc.pVCur; + const sqlite3_module *pModule = pVCur->pVtab->pModule; + assert( pVCur->pVtab->nRef>0 ); + pVCur->pVtab->nRef--; + pModule->xClose(pVCur); + break; + } +#endif + } +} + +/* +** Close all cursors in the current frame. +*/ +static void closeCursorsInFrame(Vdbe *p){ + int i; + for(i=0; inCursor; i++){ + VdbeCursor *pC = p->apCsr[i]; + if( pC ){ + sqlite3VdbeFreeCursorNN(p, pC); + p->apCsr[i] = 0; + } + } +} + +/* +** Copy the values stored in the VdbeFrame structure to its Vdbe. This +** is used, for example, when a trigger sub-program is halted to restore +** control to the main program. +*/ +SQLITE_PRIVATE int sqlite3VdbeFrameRestore(VdbeFrame *pFrame){ + Vdbe *v = pFrame->v; + closeCursorsInFrame(v); + v->aOp = pFrame->aOp; + v->nOp = pFrame->nOp; + v->aMem = pFrame->aMem; + v->nMem = pFrame->nMem; + v->apCsr = pFrame->apCsr; + v->nCursor = pFrame->nCursor; + v->db->lastRowid = pFrame->lastRowid; + v->nChange = pFrame->nChange; + v->db->nChange = pFrame->nDbChange; + sqlite3VdbeDeleteAuxData(v->db, &v->pAuxData, -1, 0); + v->pAuxData = pFrame->pAuxData; + pFrame->pAuxData = 0; + return pFrame->pc; +} + +/* +** Close all cursors. +** +** Also release any dynamic memory held by the VM in the Vdbe.aMem memory +** cell array. This is necessary as the memory cell array may contain +** pointers to VdbeFrame objects, which may in turn contain pointers to +** open cursors. +*/ +static void closeAllCursors(Vdbe *p){ + if( p->pFrame ){ + VdbeFrame *pFrame; + for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent); + sqlite3VdbeFrameRestore(pFrame); + p->pFrame = 0; + p->nFrame = 0; + } + assert( p->nFrame==0 ); + closeCursorsInFrame(p); + releaseMemArray(p->aMem, p->nMem); + while( p->pDelFrame ){ + VdbeFrame *pDel = p->pDelFrame; + p->pDelFrame = pDel->pParent; + sqlite3VdbeFrameDelete(pDel); + } + + /* Delete any auxdata allocations made by the VM */ + if( p->pAuxData ) sqlite3VdbeDeleteAuxData(p->db, &p->pAuxData, -1, 0); + assert( p->pAuxData==0 ); +} + +/* +** Set the number of result columns that will be returned by this SQL +** statement. This is now set at compile time, rather than during +** execution of the vdbe program so that sqlite3_column_count() can +** be called on an SQL statement before sqlite3_step(). +*/ +SQLITE_PRIVATE void sqlite3VdbeSetNumCols(Vdbe *p, int nResColumn){ + int n; + sqlite3 *db = p->db; + + if( p->nResColumn ){ + releaseMemArray(p->aColName, p->nResColumn*COLNAME_N); + sqlite3DbFree(db, p->aColName); + } + n = nResColumn*COLNAME_N; + p->nResColumn = (u16)nResColumn; + p->aColName = (Mem*)sqlite3DbMallocRawNN(db, sizeof(Mem)*n ); + if( p->aColName==0 ) return; + initMemArray(p->aColName, n, db, MEM_Null); +} + +/* +** Set the name of the idx'th column to be returned by the SQL statement. +** zName must be a pointer to a nul terminated string. +** +** This call must be made after a call to sqlite3VdbeSetNumCols(). +** +** The final parameter, xDel, must be one of SQLITE_DYNAMIC, SQLITE_STATIC +** or SQLITE_TRANSIENT. If it is SQLITE_DYNAMIC, then the buffer pointed +** to by zName will be freed by sqlite3DbFree() when the vdbe is destroyed. +*/ +SQLITE_PRIVATE int sqlite3VdbeSetColName( + Vdbe *p, /* Vdbe being configured */ + int idx, /* Index of column zName applies to */ + int var, /* One of the COLNAME_* constants */ + const char *zName, /* Pointer to buffer containing name */ + void (*xDel)(void*) /* Memory management strategy for zName */ +){ + int rc; + Mem *pColName; + assert( idxnResColumn ); + assert( vardb->mallocFailed ){ + assert( !zName || xDel!=SQLITE_DYNAMIC ); + return SQLITE_NOMEM_BKPT; + } + assert( p->aColName!=0 ); + pColName = &(p->aColName[idx+var*p->nResColumn]); + rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, xDel); + assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 ); + return rc; +} + +/* +** A read or write transaction may or may not be active on database handle +** db. If a transaction is active, commit it. If there is a +** write-transaction spanning more than one database file, this routine +** takes care of the super-journal trickery. +*/ +static int vdbeCommit(sqlite3 *db, Vdbe *p){ + int i; + int nTrans = 0; /* Number of databases with an active write-transaction + ** that are candidates for a two-phase commit using a + ** super-journal */ + int rc = SQLITE_OK; + int needXcommit = 0; + +#ifdef SQLITE_OMIT_VIRTUALTABLE + /* With this option, sqlite3VtabSync() is defined to be simply + ** SQLITE_OK so p is not used. + */ + UNUSED_PARAMETER(p); +#endif + + /* Before doing anything else, call the xSync() callback for any + ** virtual module tables written in this transaction. This has to + ** be done before determining whether a super-journal file is + ** required, as an xSync() callback may add an attached database + ** to the transaction. + */ + rc = sqlite3VtabSync(db, p); + + /* This loop determines (a) if the commit hook should be invoked and + ** (b) how many database files have open write transactions, not + ** including the temp database. (b) is important because if more than + ** one database file has an open write transaction, a super-journal + ** file is required for an atomic commit. + */ + for(i=0; rc==SQLITE_OK && inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( sqlite3BtreeTxnState(pBt)==SQLITE_TXN_WRITE ){ + /* Whether or not a database might need a super-journal depends upon + ** its journal mode (among other things). This matrix determines which + ** journal modes use a super-journal and which do not */ + static const u8 aMJNeeded[] = { + /* DELETE */ 1, + /* PERSIST */ 1, + /* OFF */ 0, + /* TRUNCATE */ 1, + /* MEMORY */ 0, + /* WAL */ 0 + }; + Pager *pPager; /* Pager associated with pBt */ + needXcommit = 1; + sqlite3BtreeEnter(pBt); + pPager = sqlite3BtreePager(pBt); + if( db->aDb[i].safety_level!=PAGER_SYNCHRONOUS_OFF + && aMJNeeded[sqlite3PagerGetJournalMode(pPager)] + && sqlite3PagerIsMemdb(pPager)==0 + ){ + assert( i!=1 ); + nTrans++; + } + rc = sqlite3PagerExclusiveLock(pPager); + sqlite3BtreeLeave(pBt); + } + } + if( rc!=SQLITE_OK ){ + return rc; + } + + /* If there are any write-transactions at all, invoke the commit hook */ + if( needXcommit && db->xCommitCallback ){ + rc = db->xCommitCallback(db->pCommitArg); + if( rc ){ + return SQLITE_CONSTRAINT_COMMITHOOK; + } + } + + /* The simple case - no more than one database file (not counting the + ** TEMP database) has a transaction active. There is no need for the + ** super-journal. + ** + ** If the return value of sqlite3BtreeGetFilename() is a zero length + ** string, it means the main database is :memory: or a temp file. In + ** that case we do not support atomic multi-file commits, so use the + ** simple case then too. + */ + if( 0==sqlite3Strlen30(sqlite3BtreeGetFilename(db->aDb[0].pBt)) + || nTrans<=1 + ){ + for(i=0; rc==SQLITE_OK && inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + rc = sqlite3BtreeCommitPhaseOne(pBt, 0); + } + } + + /* Do the commit only if all databases successfully complete phase 1. + ** If one of the BtreeCommitPhaseOne() calls fails, this indicates an + ** IO error while deleting or truncating a journal file. It is unlikely, + ** but could happen. In this case abandon processing and return the error. + */ + for(i=0; rc==SQLITE_OK && inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + rc = sqlite3BtreeCommitPhaseTwo(pBt, 0); + } + } + if( rc==SQLITE_OK ){ + sqlite3VtabCommit(db); + } + } + + /* The complex case - There is a multi-file write-transaction active. + ** This requires a super-journal file to ensure the transaction is + ** committed atomically. + */ +#ifndef SQLITE_OMIT_DISKIO + else{ + sqlite3_vfs *pVfs = db->pVfs; + char *zSuper = 0; /* File-name for the super-journal */ + char const *zMainFile = sqlite3BtreeGetFilename(db->aDb[0].pBt); + sqlite3_file *pSuperJrnl = 0; + i64 offset = 0; + int res; + int retryCount = 0; + int nMainFile; + + /* Select a super-journal file name */ + nMainFile = sqlite3Strlen30(zMainFile); + zSuper = sqlite3MPrintf(db, "%.4c%s%.16c", 0,zMainFile,0); + if( zSuper==0 ) return SQLITE_NOMEM_BKPT; + zSuper += 4; + do { + u32 iRandom; + if( retryCount ){ + if( retryCount>100 ){ + sqlite3_log(SQLITE_FULL, "MJ delete: %s", zSuper); + sqlite3OsDelete(pVfs, zSuper, 0); + break; + }else if( retryCount==1 ){ + sqlite3_log(SQLITE_FULL, "MJ collide: %s", zSuper); + } + } + retryCount++; + sqlite3_randomness(sizeof(iRandom), &iRandom); + sqlite3_snprintf(13, &zSuper[nMainFile], "-mj%06X9%02X", + (iRandom>>8)&0xffffff, iRandom&0xff); + /* The antipenultimate character of the super-journal name must + ** be "9" to avoid name collisions when using 8+3 filenames. */ + assert( zSuper[sqlite3Strlen30(zSuper)-3]=='9' ); + sqlite3FileSuffix3(zMainFile, zSuper); + rc = sqlite3OsAccess(pVfs, zSuper, SQLITE_ACCESS_EXISTS, &res); + }while( rc==SQLITE_OK && res ); + if( rc==SQLITE_OK ){ + /* Open the super-journal. */ + rc = sqlite3OsOpenMalloc(pVfs, zSuper, &pSuperJrnl, + SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE| + SQLITE_OPEN_EXCLUSIVE|SQLITE_OPEN_SUPER_JOURNAL, 0 + ); + } + if( rc!=SQLITE_OK ){ + sqlite3DbFree(db, zSuper-4); + return rc; + } + + /* Write the name of each database file in the transaction into the new + ** super-journal file. If an error occurs at this point close + ** and delete the super-journal file. All the individual journal files + ** still have 'null' as the super-journal pointer, so they will roll + ** back independently if a failure occurs. + */ + for(i=0; inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( sqlite3BtreeTxnState(pBt)==SQLITE_TXN_WRITE ){ + char const *zFile = sqlite3BtreeGetJournalname(pBt); + if( zFile==0 ){ + continue; /* Ignore TEMP and :memory: databases */ + } + assert( zFile[0]!=0 ); + rc = sqlite3OsWrite(pSuperJrnl, zFile, sqlite3Strlen30(zFile)+1,offset); + offset += sqlite3Strlen30(zFile)+1; + if( rc!=SQLITE_OK ){ + sqlite3OsCloseFree(pSuperJrnl); + sqlite3OsDelete(pVfs, zSuper, 0); + sqlite3DbFree(db, zSuper-4); + return rc; + } + } + } + + /* Sync the super-journal file. If the IOCAP_SEQUENTIAL device + ** flag is set this is not required. + */ + if( 0==(sqlite3OsDeviceCharacteristics(pSuperJrnl)&SQLITE_IOCAP_SEQUENTIAL) + && SQLITE_OK!=(rc = sqlite3OsSync(pSuperJrnl, SQLITE_SYNC_NORMAL)) + ){ + sqlite3OsCloseFree(pSuperJrnl); + sqlite3OsDelete(pVfs, zSuper, 0); + sqlite3DbFree(db, zSuper-4); + return rc; + } + + /* Sync all the db files involved in the transaction. The same call + ** sets the super-journal pointer in each individual journal. If + ** an error occurs here, do not delete the super-journal file. + ** + ** If the error occurs during the first call to + ** sqlite3BtreeCommitPhaseOne(), then there is a chance that the + ** super-journal file will be orphaned. But we cannot delete it, + ** in case the super-journal file name was written into the journal + ** file before the failure occurred. + */ + for(i=0; rc==SQLITE_OK && inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + rc = sqlite3BtreeCommitPhaseOne(pBt, zSuper); + } + } + sqlite3OsCloseFree(pSuperJrnl); + assert( rc!=SQLITE_BUSY ); + if( rc!=SQLITE_OK ){ + sqlite3DbFree(db, zSuper-4); + return rc; + } + + /* Delete the super-journal file. This commits the transaction. After + ** doing this the directory is synced again before any individual + ** transaction files are deleted. + */ + rc = sqlite3OsDelete(pVfs, zSuper, 1); + sqlite3DbFree(db, zSuper-4); + zSuper = 0; + if( rc ){ + return rc; + } + + /* All files and directories have already been synced, so the following + ** calls to sqlite3BtreeCommitPhaseTwo() are only closing files and + ** deleting or truncating journals. If something goes wrong while + ** this is happening we don't really care. The integrity of the + ** transaction is already guaranteed, but some stray 'cold' journals + ** may be lying around. Returning an error code won't help matters. + */ + disable_simulated_io_errors(); + sqlite3BeginBenignMalloc(); + for(i=0; inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + sqlite3BtreeCommitPhaseTwo(pBt, 1); + } + } + sqlite3EndBenignMalloc(); + enable_simulated_io_errors(); + + sqlite3VtabCommit(db); + } +#endif + + return rc; +} + +/* +** This routine checks that the sqlite3.nVdbeActive count variable +** matches the number of vdbe's in the list sqlite3.pVdbe that are +** currently active. An assertion fails if the two counts do not match. +** This is an internal self-check only - it is not an essential processing +** step. +** +** This is a no-op if NDEBUG is defined. +*/ +#ifndef NDEBUG +static void checkActiveVdbeCnt(sqlite3 *db){ + Vdbe *p; + int cnt = 0; + int nWrite = 0; + int nRead = 0; + p = db->pVdbe; + while( p ){ + if( sqlite3_stmt_busy((sqlite3_stmt*)p) ){ + cnt++; + if( p->readOnly==0 ) nWrite++; + if( p->bIsReader ) nRead++; + } + p = p->pVNext; + } + assert( cnt==db->nVdbeActive ); + assert( nWrite==db->nVdbeWrite ); + assert( nRead==db->nVdbeRead ); +} +#else +#define checkActiveVdbeCnt(x) +#endif + +/* +** If the Vdbe passed as the first argument opened a statement-transaction, +** close it now. Argument eOp must be either SAVEPOINT_ROLLBACK or +** SAVEPOINT_RELEASE. If it is SAVEPOINT_ROLLBACK, then the statement +** transaction is rolled back. If eOp is SAVEPOINT_RELEASE, then the +** statement transaction is committed. +** +** If an IO error occurs, an SQLITE_IOERR_XXX error code is returned. +** Otherwise SQLITE_OK. +*/ +static SQLITE_NOINLINE int vdbeCloseStatement(Vdbe *p, int eOp){ + sqlite3 *const db = p->db; + int rc = SQLITE_OK; + int i; + const int iSavepoint = p->iStatement-1; + + assert( eOp==SAVEPOINT_ROLLBACK || eOp==SAVEPOINT_RELEASE); + assert( db->nStatement>0 ); + assert( p->iStatement==(db->nStatement+db->nSavepoint) ); + + for(i=0; inDb; i++){ + int rc2 = SQLITE_OK; + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + if( eOp==SAVEPOINT_ROLLBACK ){ + rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_ROLLBACK, iSavepoint); + } + if( rc2==SQLITE_OK ){ + rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_RELEASE, iSavepoint); + } + if( rc==SQLITE_OK ){ + rc = rc2; + } + } + } + db->nStatement--; + p->iStatement = 0; + + if( rc==SQLITE_OK ){ + if( eOp==SAVEPOINT_ROLLBACK ){ + rc = sqlite3VtabSavepoint(db, SAVEPOINT_ROLLBACK, iSavepoint); + } + if( rc==SQLITE_OK ){ + rc = sqlite3VtabSavepoint(db, SAVEPOINT_RELEASE, iSavepoint); + } + } + + /* If the statement transaction is being rolled back, also restore the + ** database handles deferred constraint counter to the value it had when + ** the statement transaction was opened. */ + if( eOp==SAVEPOINT_ROLLBACK ){ + db->nDeferredCons = p->nStmtDefCons; + db->nDeferredImmCons = p->nStmtDefImmCons; + } + return rc; +} +SQLITE_PRIVATE int sqlite3VdbeCloseStatement(Vdbe *p, int eOp){ + if( p->db->nStatement && p->iStatement ){ + return vdbeCloseStatement(p, eOp); + } + return SQLITE_OK; +} + + +/* +** This function is called when a transaction opened by the database +** handle associated with the VM passed as an argument is about to be +** committed. If there are outstanding deferred foreign key constraint +** violations, return SQLITE_ERROR. Otherwise, SQLITE_OK. +** +** If there are outstanding FK violations and this function returns +** SQLITE_ERROR, set the result of the VM to SQLITE_CONSTRAINT_FOREIGNKEY +** and write an error message to it. Then return SQLITE_ERROR. +*/ +#ifndef SQLITE_OMIT_FOREIGN_KEY +SQLITE_PRIVATE int sqlite3VdbeCheckFk(Vdbe *p, int deferred){ + sqlite3 *db = p->db; + if( (deferred && (db->nDeferredCons+db->nDeferredImmCons)>0) + || (!deferred && p->nFkConstraint>0) + ){ + p->rc = SQLITE_CONSTRAINT_FOREIGNKEY; + p->errorAction = OE_Abort; + sqlite3VdbeError(p, "FOREIGN KEY constraint failed"); + if( (p->prepFlags & SQLITE_PREPARE_SAVESQL)==0 ) return SQLITE_ERROR; + return SQLITE_CONSTRAINT_FOREIGNKEY; + } + return SQLITE_OK; +} +#endif + +/* +** This routine is called the when a VDBE tries to halt. If the VDBE +** has made changes and is in autocommit mode, then commit those +** changes. If a rollback is needed, then do the rollback. +** +** This routine is the only way to move the sqlite3eOpenState of a VM from +** SQLITE_STATE_RUN to SQLITE_STATE_HALT. It is harmless to +** call this on a VM that is in the SQLITE_STATE_HALT state. +** +** Return an error code. If the commit could not complete because of +** lock contention, return SQLITE_BUSY. If SQLITE_BUSY is returned, it +** means the close did not happen and needs to be repeated. +*/ +SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe *p){ + int rc; /* Used to store transient return codes */ + sqlite3 *db = p->db; + + /* This function contains the logic that determines if a statement or + ** transaction will be committed or rolled back as a result of the + ** execution of this virtual machine. + ** + ** If any of the following errors occur: + ** + ** SQLITE_NOMEM + ** SQLITE_IOERR + ** SQLITE_FULL + ** SQLITE_INTERRUPT + ** + ** Then the internal cache might have been left in an inconsistent + ** state. We need to rollback the statement transaction, if there is + ** one, or the complete transaction if there is no statement transaction. + */ + + assert( p->eVdbeState==VDBE_RUN_STATE ); + if( db->mallocFailed ){ + p->rc = SQLITE_NOMEM_BKPT; + } + closeAllCursors(p); + checkActiveVdbeCnt(db); + + /* No commit or rollback needed if the program never started or if the + ** SQL statement does not read or write a database file. */ + if( p->bIsReader ){ + int mrc; /* Primary error code from p->rc */ + int eStatementOp = 0; + int isSpecialError; /* Set to true if a 'special' error */ + + /* Lock all btrees used by the statement */ + sqlite3VdbeEnter(p); + + /* Check for one of the special errors */ + if( p->rc ){ + mrc = p->rc & 0xff; + isSpecialError = mrc==SQLITE_NOMEM + || mrc==SQLITE_IOERR + || mrc==SQLITE_INTERRUPT + || mrc==SQLITE_FULL; + }else{ + mrc = isSpecialError = 0; + } + if( isSpecialError ){ + /* If the query was read-only and the error code is SQLITE_INTERRUPT, + ** no rollback is necessary. Otherwise, at least a savepoint + ** transaction must be rolled back to restore the database to a + ** consistent state. + ** + ** Even if the statement is read-only, it is important to perform + ** a statement or transaction rollback operation. If the error + ** occurred while writing to the journal, sub-journal or database + ** file as part of an effort to free up cache space (see function + ** pagerStress() in pager.c), the rollback is required to restore + ** the pager to a consistent state. + */ + if( !p->readOnly || mrc!=SQLITE_INTERRUPT ){ + if( (mrc==SQLITE_NOMEM || mrc==SQLITE_FULL) && p->usesStmtJournal ){ + eStatementOp = SAVEPOINT_ROLLBACK; + }else{ + /* We are forced to roll back the active transaction. Before doing + ** so, abort any other statements this handle currently has active. + */ + sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK); + sqlite3CloseSavepoints(db); + db->autoCommit = 1; + p->nChange = 0; + } + } + } + + /* Check for immediate foreign key violations. */ + if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){ + sqlite3VdbeCheckFk(p, 0); + } + + /* If the auto-commit flag is set and this is the only active writer + ** VM, then we do either a commit or rollback of the current transaction. + ** + ** Note: This block also runs if one of the special errors handled + ** above has occurred. + */ + if( !sqlite3VtabInSync(db) + && db->autoCommit + && db->nVdbeWrite==(p->readOnly==0) + ){ + if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){ + rc = sqlite3VdbeCheckFk(p, 1); + if( rc!=SQLITE_OK ){ + if( NEVER(p->readOnly) ){ + sqlite3VdbeLeave(p); + return SQLITE_ERROR; + } + rc = SQLITE_CONSTRAINT_FOREIGNKEY; + }else if( db->flags & SQLITE_CorruptRdOnly ){ + rc = SQLITE_CORRUPT; + db->flags &= ~SQLITE_CorruptRdOnly; + }else{ + /* The auto-commit flag is true, the vdbe program was successful + ** or hit an 'OR FAIL' constraint and there are no deferred foreign + ** key constraints to hold up the transaction. This means a commit + ** is required. */ + rc = vdbeCommit(db, p); + } + if( rc==SQLITE_BUSY && p->readOnly ){ + sqlite3VdbeLeave(p); + return SQLITE_BUSY; + }else if( rc!=SQLITE_OK ){ + p->rc = rc; + sqlite3RollbackAll(db, SQLITE_OK); + p->nChange = 0; + }else{ + db->nDeferredCons = 0; + db->nDeferredImmCons = 0; + db->flags &= ~(u64)SQLITE_DeferFKs; + sqlite3CommitInternalChanges(db); + } + }else if( p->rc==SQLITE_SCHEMA && db->nVdbeActive>1 ){ + p->nChange = 0; + }else{ + sqlite3RollbackAll(db, SQLITE_OK); + p->nChange = 0; + } + db->nStatement = 0; + }else if( eStatementOp==0 ){ + if( p->rc==SQLITE_OK || p->errorAction==OE_Fail ){ + eStatementOp = SAVEPOINT_RELEASE; + }else if( p->errorAction==OE_Abort ){ + eStatementOp = SAVEPOINT_ROLLBACK; + }else{ + sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK); + sqlite3CloseSavepoints(db); + db->autoCommit = 1; + p->nChange = 0; + } + } + + /* If eStatementOp is non-zero, then a statement transaction needs to + ** be committed or rolled back. Call sqlite3VdbeCloseStatement() to + ** do so. If this operation returns an error, and the current statement + ** error code is SQLITE_OK or SQLITE_CONSTRAINT, then promote the + ** current statement error code. + */ + if( eStatementOp ){ + rc = sqlite3VdbeCloseStatement(p, eStatementOp); + if( rc ){ + if( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT ){ + p->rc = rc; + sqlite3DbFree(db, p->zErrMsg); + p->zErrMsg = 0; + } + sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK); + sqlite3CloseSavepoints(db); + db->autoCommit = 1; + p->nChange = 0; + } + } + + /* If this was an INSERT, UPDATE or DELETE and no statement transaction + ** has been rolled back, update the database connection change-counter. + */ + if( p->changeCntOn ){ + if( eStatementOp!=SAVEPOINT_ROLLBACK ){ + sqlite3VdbeSetChanges(db, p->nChange); + }else{ + sqlite3VdbeSetChanges(db, 0); + } + p->nChange = 0; + } + + /* Release the locks */ + sqlite3VdbeLeave(p); + } + + /* We have successfully halted and closed the VM. Record this fact. */ + db->nVdbeActive--; + if( !p->readOnly ) db->nVdbeWrite--; + if( p->bIsReader ) db->nVdbeRead--; + assert( db->nVdbeActive>=db->nVdbeRead ); + assert( db->nVdbeRead>=db->nVdbeWrite ); + assert( db->nVdbeWrite>=0 ); + p->eVdbeState = VDBE_HALT_STATE; + checkActiveVdbeCnt(db); + if( db->mallocFailed ){ + p->rc = SQLITE_NOMEM_BKPT; + } + + /* If the auto-commit flag is set to true, then any locks that were held + ** by connection db have now been released. Call sqlite3ConnectionUnlocked() + ** to invoke any required unlock-notify callbacks. + */ + if( db->autoCommit ){ + sqlite3ConnectionUnlocked(db); + } + + assert( db->nVdbeActive>0 || db->autoCommit==0 || db->nStatement==0 ); + return (p->rc==SQLITE_BUSY ? SQLITE_BUSY : SQLITE_OK); +} + + +/* +** Each VDBE holds the result of the most recent sqlite3_step() call +** in p->rc. This routine sets that result back to SQLITE_OK. +*/ +SQLITE_PRIVATE void sqlite3VdbeResetStepResult(Vdbe *p){ + p->rc = SQLITE_OK; +} + +/* +** Copy the error code and error message belonging to the VDBE passed +** as the first argument to its database handle (so that they will be +** returned by calls to sqlite3_errcode() and sqlite3_errmsg()). +** +** This function does not clear the VDBE error code or message, just +** copies them to the database handle. +*/ +SQLITE_PRIVATE int sqlite3VdbeTransferError(Vdbe *p){ + sqlite3 *db = p->db; + int rc = p->rc; + if( p->zErrMsg ){ + db->bBenignMalloc++; + sqlite3BeginBenignMalloc(); + if( db->pErr==0 ) db->pErr = sqlite3ValueNew(db); + sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, SQLITE_TRANSIENT); + sqlite3EndBenignMalloc(); + db->bBenignMalloc--; + }else if( db->pErr ){ + sqlite3ValueSetNull(db->pErr); + } + db->errCode = rc; + db->errByteOffset = -1; + return rc; +} + +#ifdef SQLITE_ENABLE_SQLLOG +/* +** If an SQLITE_CONFIG_SQLLOG hook is registered and the VM has been run, +** invoke it. +*/ +static void vdbeInvokeSqllog(Vdbe *v){ + if( sqlite3GlobalConfig.xSqllog && v->rc==SQLITE_OK && v->zSql && v->pc>=0 ){ + char *zExpanded = sqlite3VdbeExpandSql(v, v->zSql); + assert( v->db->init.busy==0 ); + if( zExpanded ){ + sqlite3GlobalConfig.xSqllog( + sqlite3GlobalConfig.pSqllogArg, v->db, zExpanded, 1 + ); + sqlite3DbFree(v->db, zExpanded); + } + } +} +#else +# define vdbeInvokeSqllog(x) +#endif + +/* +** Clean up a VDBE after execution but do not delete the VDBE just yet. +** Write any error messages into *pzErrMsg. Return the result code. +** +** After this routine is run, the VDBE should be ready to be executed +** again. +** +** To look at it another way, this routine resets the state of the +** virtual machine from VDBE_RUN_STATE or VDBE_HALT_STATE back to +** VDBE_READY_STATE. +*/ +SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe *p){ +#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE) + int i; +#endif + + sqlite3 *db; + db = p->db; + + /* If the VM did not run to completion or if it encountered an + ** error, then it might not have been halted properly. So halt + ** it now. + */ + if( p->eVdbeState==VDBE_RUN_STATE ) sqlite3VdbeHalt(p); + + /* If the VDBE has been run even partially, then transfer the error code + ** and error message from the VDBE into the main database structure. But + ** if the VDBE has just been set to run but has not actually executed any + ** instructions yet, leave the main database error information unchanged. + */ + if( p->pc>=0 ){ + vdbeInvokeSqllog(p); + if( db->pErr || p->zErrMsg ){ + sqlite3VdbeTransferError(p); + }else{ + db->errCode = p->rc; + } + } + + /* Reset register contents and reclaim error message memory. + */ +#ifdef SQLITE_DEBUG + /* Execute assert() statements to ensure that the Vdbe.apCsr[] and + ** Vdbe.aMem[] arrays have already been cleaned up. */ + if( p->apCsr ) for(i=0; inCursor; i++) assert( p->apCsr[i]==0 ); + if( p->aMem ){ + for(i=0; inMem; i++) assert( p->aMem[i].flags==MEM_Undefined ); + } +#endif + if( p->zErrMsg ){ + sqlite3DbFree(db, p->zErrMsg); + p->zErrMsg = 0; + } + p->pResultRow = 0; +#ifdef SQLITE_DEBUG + p->nWrite = 0; +#endif + + /* Save profiling information from this VDBE run. + */ +#ifdef VDBE_PROFILE + { + FILE *out = fopen("vdbe_profile.out", "a"); + if( out ){ + fprintf(out, "---- "); + for(i=0; inOp; i++){ + fprintf(out, "%02x", p->aOp[i].opcode); + } + fprintf(out, "\n"); + if( p->zSql ){ + char c, pc = 0; + fprintf(out, "-- "); + for(i=0; (c = p->zSql[i])!=0; i++){ + if( pc=='\n' ) fprintf(out, "-- "); + putc(c, out); + pc = c; + } + if( pc!='\n' ) fprintf(out, "\n"); + } + for(i=0; inOp; i++){ + char zHdr[100]; + i64 cnt = p->aOp[i].nExec; + i64 cycles = p->aOp[i].nCycle; + sqlite3_snprintf(sizeof(zHdr), zHdr, "%6u %12llu %8llu ", + cnt, + cycles, + cnt>0 ? cycles/cnt : 0 + ); + fprintf(out, "%s", zHdr); + sqlite3VdbePrintOp(out, i, &p->aOp[i]); + } + fclose(out); + } + } +#endif + return p->rc & db->errMask; +} + +/* +** Clean up and delete a VDBE after execution. Return an integer which is +** the result code. Write any error message text into *pzErrMsg. +*/ +SQLITE_PRIVATE int sqlite3VdbeFinalize(Vdbe *p){ + int rc = SQLITE_OK; + assert( VDBE_RUN_STATE>VDBE_READY_STATE ); + assert( VDBE_HALT_STATE>VDBE_READY_STATE ); + assert( VDBE_INIT_STATEeVdbeState>=VDBE_READY_STATE ){ + rc = sqlite3VdbeReset(p); + assert( (rc & p->db->errMask)==rc ); + } + sqlite3VdbeDelete(p); + return rc; +} + +/* +** If parameter iOp is less than zero, then invoke the destructor for +** all auxiliary data pointers currently cached by the VM passed as +** the first argument. +** +** Or, if iOp is greater than or equal to zero, then the destructor is +** only invoked for those auxiliary data pointers created by the user +** function invoked by the OP_Function opcode at instruction iOp of +** VM pVdbe, and only then if: +** +** * the associated function parameter is the 32nd or later (counting +** from left to right), or +** +** * the corresponding bit in argument mask is clear (where the first +** function parameter corresponds to bit 0 etc.). +*/ +SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData(sqlite3 *db, AuxData **pp, int iOp, int mask){ + while( *pp ){ + AuxData *pAux = *pp; + if( (iOp<0) + || (pAux->iAuxOp==iOp + && pAux->iAuxArg>=0 + && (pAux->iAuxArg>31 || !(mask & MASKBIT32(pAux->iAuxArg)))) + ){ + testcase( pAux->iAuxArg==31 ); + if( pAux->xDeleteAux ){ + pAux->xDeleteAux(pAux->pAux); + } + *pp = pAux->pNextAux; + sqlite3DbFree(db, pAux); + }else{ + pp= &pAux->pNextAux; + } + } +} + +/* +** Free all memory associated with the Vdbe passed as the second argument, +** except for object itself, which is preserved. +** +** The difference between this function and sqlite3VdbeDelete() is that +** VdbeDelete() also unlinks the Vdbe from the list of VMs associated with +** the database connection and frees the object itself. +*/ +static void sqlite3VdbeClearObject(sqlite3 *db, Vdbe *p){ + SubProgram *pSub, *pNext; + assert( db!=0 ); + assert( p->db==0 || p->db==db ); + if( p->aColName ){ + releaseMemArray(p->aColName, p->nResColumn*COLNAME_N); + sqlite3DbNNFreeNN(db, p->aColName); + } + for(pSub=p->pProgram; pSub; pSub=pNext){ + pNext = pSub->pNext; + vdbeFreeOpArray(db, pSub->aOp, pSub->nOp); + sqlite3DbFree(db, pSub); + } + if( p->eVdbeState!=VDBE_INIT_STATE ){ + releaseMemArray(p->aVar, p->nVar); + if( p->pVList ) sqlite3DbNNFreeNN(db, p->pVList); + if( p->pFree ) sqlite3DbNNFreeNN(db, p->pFree); + } + vdbeFreeOpArray(db, p->aOp, p->nOp); + if( p->zSql ) sqlite3DbNNFreeNN(db, p->zSql); +#ifdef SQLITE_ENABLE_NORMALIZE + sqlite3DbFree(db, p->zNormSql); + { + DblquoteStr *pThis, *pNxt; + for(pThis=p->pDblStr; pThis; pThis=pNxt){ + pNxt = pThis->pNextStr; + sqlite3DbFree(db, pThis); + } + } +#endif +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + { + int i; + for(i=0; inScan; i++){ + sqlite3DbFree(db, p->aScan[i].zName); + } + sqlite3DbFree(db, p->aScan); + } +#endif +} + +/* +** Delete an entire VDBE. +*/ +SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe *p){ + sqlite3 *db; + + assert( p!=0 ); + db = p->db; + assert( db!=0 ); + assert( sqlite3_mutex_held(db->mutex) ); + sqlite3VdbeClearObject(db, p); + if( db->pnBytesFreed==0 ){ + assert( p->ppVPrev!=0 ); + *p->ppVPrev = p->pVNext; + if( p->pVNext ){ + p->pVNext->ppVPrev = p->ppVPrev; + } + } + sqlite3DbNNFreeNN(db, p); +} + +/* +** The cursor "p" has a pending seek operation that has not yet been +** carried out. Seek the cursor now. If an error occurs, return +** the appropriate error code. +*/ +SQLITE_PRIVATE int SQLITE_NOINLINE sqlite3VdbeFinishMoveto(VdbeCursor *p){ + int res, rc; +#ifdef SQLITE_TEST + extern int sqlite3_search_count; +#endif + assert( p->deferredMoveto ); + assert( p->isTable ); + assert( p->eCurType==CURTYPE_BTREE ); + rc = sqlite3BtreeTableMoveto(p->uc.pCursor, p->movetoTarget, 0, &res); + if( rc ) return rc; + if( res!=0 ) return SQLITE_CORRUPT_BKPT; +#ifdef SQLITE_TEST + sqlite3_search_count++; +#endif + p->deferredMoveto = 0; + p->cacheStatus = CACHE_STALE; + return SQLITE_OK; +} + +/* +** Something has moved cursor "p" out of place. Maybe the row it was +** pointed to was deleted out from under it. Or maybe the btree was +** rebalanced. Whatever the cause, try to restore "p" to the place it +** is supposed to be pointing. If the row was deleted out from under the +** cursor, set the cursor to point to a NULL row. +*/ +SQLITE_PRIVATE int SQLITE_NOINLINE sqlite3VdbeHandleMovedCursor(VdbeCursor *p){ + int isDifferentRow, rc; + assert( p->eCurType==CURTYPE_BTREE ); + assert( p->uc.pCursor!=0 ); + assert( sqlite3BtreeCursorHasMoved(p->uc.pCursor) ); + rc = sqlite3BtreeCursorRestore(p->uc.pCursor, &isDifferentRow); + p->cacheStatus = CACHE_STALE; + if( isDifferentRow ) p->nullRow = 1; + return rc; +} + +/* +** Check to ensure that the cursor is valid. Restore the cursor +** if need be. Return any I/O error from the restore operation. +*/ +SQLITE_PRIVATE int sqlite3VdbeCursorRestore(VdbeCursor *p){ + assert( p->eCurType==CURTYPE_BTREE || IsNullCursor(p) ); + if( sqlite3BtreeCursorHasMoved(p->uc.pCursor) ){ + return sqlite3VdbeHandleMovedCursor(p); + } + return SQLITE_OK; +} + +/* +** The following functions: +** +** sqlite3VdbeSerialType() +** sqlite3VdbeSerialTypeLen() +** sqlite3VdbeSerialLen() +** sqlite3VdbeSerialPut() <--- in-lined into OP_MakeRecord as of 2022-04-02 +** sqlite3VdbeSerialGet() +** +** encapsulate the code that serializes values for storage in SQLite +** data and index records. Each serialized value consists of a +** 'serial-type' and a blob of data. The serial type is an 8-byte unsigned +** integer, stored as a varint. +** +** In an SQLite index record, the serial type is stored directly before +** the blob of data that it corresponds to. In a table record, all serial +** types are stored at the start of the record, and the blobs of data at +** the end. Hence these functions allow the caller to handle the +** serial-type and data blob separately. +** +** The following table describes the various storage classes for data: +** +** serial type bytes of data type +** -------------- --------------- --------------- +** 0 0 NULL +** 1 1 signed integer +** 2 2 signed integer +** 3 3 signed integer +** 4 4 signed integer +** 5 6 signed integer +** 6 8 signed integer +** 7 8 IEEE float +** 8 0 Integer constant 0 +** 9 0 Integer constant 1 +** 10,11 reserved for expansion +** N>=12 and even (N-12)/2 BLOB +** N>=13 and odd (N-13)/2 text +** +** The 8 and 9 types were added in 3.3.0, file format 4. Prior versions +** of SQLite will not understand those serial types. +*/ + +#if 0 /* Inlined into the OP_MakeRecord opcode */ +/* +** Return the serial-type for the value stored in pMem. +** +** This routine might convert a large MEM_IntReal value into MEM_Real. +** +** 2019-07-11: The primary user of this subroutine was the OP_MakeRecord +** opcode in the byte-code engine. But by moving this routine in-line, we +** can omit some redundant tests and make that opcode a lot faster. So +** this routine is now only used by the STAT3 logic and STAT3 support has +** ended. The code is kept here for historical reference only. +*/ +SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem *pMem, int file_format, u32 *pLen){ + int flags = pMem->flags; + u32 n; + + assert( pLen!=0 ); + if( flags&MEM_Null ){ + *pLen = 0; + return 0; + } + if( flags&(MEM_Int|MEM_IntReal) ){ + /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */ +# define MAX_6BYTE ((((i64)0x00008000)<<32)-1) + i64 i = pMem->u.i; + u64 u; + testcase( flags & MEM_Int ); + testcase( flags & MEM_IntReal ); + if( i<0 ){ + u = ~i; + }else{ + u = i; + } + if( u<=127 ){ + if( (i&1)==i && file_format>=4 ){ + *pLen = 0; + return 8+(u32)u; + }else{ + *pLen = 1; + return 1; + } + } + if( u<=32767 ){ *pLen = 2; return 2; } + if( u<=8388607 ){ *pLen = 3; return 3; } + if( u<=2147483647 ){ *pLen = 4; return 4; } + if( u<=MAX_6BYTE ){ *pLen = 6; return 5; } + *pLen = 8; + if( flags&MEM_IntReal ){ + /* If the value is IntReal and is going to take up 8 bytes to store + ** as an integer, then we might as well make it an 8-byte floating + ** point value */ + pMem->u.r = (double)pMem->u.i; + pMem->flags &= ~MEM_IntReal; + pMem->flags |= MEM_Real; + return 7; + } + return 6; + } + if( flags&MEM_Real ){ + *pLen = 8; + return 7; + } + assert( pMem->db->mallocFailed || flags&(MEM_Str|MEM_Blob) ); + assert( pMem->n>=0 ); + n = (u32)pMem->n; + if( flags & MEM_Zero ){ + n += pMem->u.nZero; + } + *pLen = n; + return ((n*2) + 12 + ((flags&MEM_Str)!=0)); +} +#endif /* inlined into OP_MakeRecord */ + +/* +** The sizes for serial types less than 128 +*/ +SQLITE_PRIVATE const u8 sqlite3SmallTypeSizes[128] = { + /* 0 1 2 3 4 5 6 7 8 9 */ +/* 0 */ 0, 1, 2, 3, 4, 6, 8, 8, 0, 0, +/* 10 */ 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, +/* 20 */ 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, +/* 30 */ 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, +/* 40 */ 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, +/* 50 */ 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, +/* 60 */ 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, +/* 70 */ 29, 29, 30, 30, 31, 31, 32, 32, 33, 33, +/* 80 */ 34, 34, 35, 35, 36, 36, 37, 37, 38, 38, +/* 90 */ 39, 39, 40, 40, 41, 41, 42, 42, 43, 43, +/* 100 */ 44, 44, 45, 45, 46, 46, 47, 47, 48, 48, +/* 110 */ 49, 49, 50, 50, 51, 51, 52, 52, 53, 53, +/* 120 */ 54, 54, 55, 55, 56, 56, 57, 57 +}; + +/* +** Return the length of the data corresponding to the supplied serial-type. +*/ +SQLITE_PRIVATE u32 sqlite3VdbeSerialTypeLen(u32 serial_type){ + if( serial_type>=128 ){ + return (serial_type-12)/2; + }else{ + assert( serial_type<12 + || sqlite3SmallTypeSizes[serial_type]==(serial_type - 12)/2 ); + return sqlite3SmallTypeSizes[serial_type]; + } +} +SQLITE_PRIVATE u8 sqlite3VdbeOneByteSerialTypeLen(u8 serial_type){ + assert( serial_type<128 ); + return sqlite3SmallTypeSizes[serial_type]; +} + +/* +** If we are on an architecture with mixed-endian floating +** points (ex: ARM7) then swap the lower 4 bytes with the +** upper 4 bytes. Return the result. +** +** For most architectures, this is a no-op. +** +** (later): It is reported to me that the mixed-endian problem +** on ARM7 is an issue with GCC, not with the ARM7 chip. It seems +** that early versions of GCC stored the two words of a 64-bit +** float in the wrong order. And that error has been propagated +** ever since. The blame is not necessarily with GCC, though. +** GCC might have just copying the problem from a prior compiler. +** I am also told that newer versions of GCC that follow a different +** ABI get the byte order right. +** +** Developers using SQLite on an ARM7 should compile and run their +** application using -DSQLITE_DEBUG=1 at least once. With DEBUG +** enabled, some asserts below will ensure that the byte order of +** floating point values is correct. +** +** (2007-08-30) Frank van Vugt has studied this problem closely +** and has send his findings to the SQLite developers. Frank +** writes that some Linux kernels offer floating point hardware +** emulation that uses only 32-bit mantissas instead of a full +** 48-bits as required by the IEEE standard. (This is the +** CONFIG_FPE_FASTFPE option.) On such systems, floating point +** byte swapping becomes very complicated. To avoid problems, +** the necessary byte swapping is carried out using a 64-bit integer +** rather than a 64-bit float. Frank assures us that the code here +** works for him. We, the developers, have no way to independently +** verify this, but Frank seems to know what he is talking about +** so we trust him. +*/ +#ifdef SQLITE_MIXED_ENDIAN_64BIT_FLOAT +SQLITE_PRIVATE u64 sqlite3FloatSwap(u64 in){ + union { + u64 r; + u32 i[2]; + } u; + u32 t; + + u.r = in; + t = u.i[0]; + u.i[0] = u.i[1]; + u.i[1] = t; + return u.r; +} +#endif /* SQLITE_MIXED_ENDIAN_64BIT_FLOAT */ + + +/* Input "x" is a sequence of unsigned characters that represent a +** big-endian integer. Return the equivalent native integer +*/ +#define ONE_BYTE_INT(x) ((i8)(x)[0]) +#define TWO_BYTE_INT(x) (256*(i8)((x)[0])|(x)[1]) +#define THREE_BYTE_INT(x) (65536*(i8)((x)[0])|((x)[1]<<8)|(x)[2]) +#define FOUR_BYTE_UINT(x) (((u32)(x)[0]<<24)|((x)[1]<<16)|((x)[2]<<8)|(x)[3]) +#define FOUR_BYTE_INT(x) (16777216*(i8)((x)[0])|((x)[1]<<16)|((x)[2]<<8)|(x)[3]) + +/* +** Deserialize the data blob pointed to by buf as serial type serial_type +** and store the result in pMem. +** +** This function is implemented as two separate routines for performance. +** The few cases that require local variables are broken out into a separate +** routine so that in most cases the overhead of moving the stack pointer +** is avoided. +*/ +static void serialGet( + const unsigned char *buf, /* Buffer to deserialize from */ + u32 serial_type, /* Serial type to deserialize */ + Mem *pMem /* Memory cell to write value into */ +){ + u64 x = FOUR_BYTE_UINT(buf); + u32 y = FOUR_BYTE_UINT(buf+4); + x = (x<<32) + y; + if( serial_type==6 ){ + /* EVIDENCE-OF: R-29851-52272 Value is a big-endian 64-bit + ** twos-complement integer. */ + pMem->u.i = *(i64*)&x; + pMem->flags = MEM_Int; + testcase( pMem->u.i<0 ); + }else{ + /* EVIDENCE-OF: R-57343-49114 Value is a big-endian IEEE 754-2008 64-bit + ** floating point number. */ +#if !defined(NDEBUG) && !defined(SQLITE_OMIT_FLOATING_POINT) + /* Verify that integers and floating point values use the same + ** byte order. Or, that if SQLITE_MIXED_ENDIAN_64BIT_FLOAT is + ** defined that 64-bit floating point values really are mixed + ** endian. + */ + static const u64 t1 = ((u64)0x3ff00000)<<32; + static const double r1 = 1.0; + u64 t2 = t1; + swapMixedEndianFloat(t2); + assert( sizeof(r1)==sizeof(t2) && memcmp(&r1, &t2, sizeof(r1))==0 ); +#endif + assert( sizeof(x)==8 && sizeof(pMem->u.r)==8 ); + swapMixedEndianFloat(x); + memcpy(&pMem->u.r, &x, sizeof(x)); + pMem->flags = IsNaN(x) ? MEM_Null : MEM_Real; + } +} +SQLITE_PRIVATE void sqlite3VdbeSerialGet( + const unsigned char *buf, /* Buffer to deserialize from */ + u32 serial_type, /* Serial type to deserialize */ + Mem *pMem /* Memory cell to write value into */ +){ + switch( serial_type ){ + case 10: { /* Internal use only: NULL with virtual table + ** UPDATE no-change flag set */ + pMem->flags = MEM_Null|MEM_Zero; + pMem->n = 0; + pMem->u.nZero = 0; + return; + } + case 11: /* Reserved for future use */ + case 0: { /* Null */ + /* EVIDENCE-OF: R-24078-09375 Value is a NULL. */ + pMem->flags = MEM_Null; + return; + } + case 1: { + /* EVIDENCE-OF: R-44885-25196 Value is an 8-bit twos-complement + ** integer. */ + pMem->u.i = ONE_BYTE_INT(buf); + pMem->flags = MEM_Int; + testcase( pMem->u.i<0 ); + return; + } + case 2: { /* 2-byte signed integer */ + /* EVIDENCE-OF: R-49794-35026 Value is a big-endian 16-bit + ** twos-complement integer. */ + pMem->u.i = TWO_BYTE_INT(buf); + pMem->flags = MEM_Int; + testcase( pMem->u.i<0 ); + return; + } + case 3: { /* 3-byte signed integer */ + /* EVIDENCE-OF: R-37839-54301 Value is a big-endian 24-bit + ** twos-complement integer. */ + pMem->u.i = THREE_BYTE_INT(buf); + pMem->flags = MEM_Int; + testcase( pMem->u.i<0 ); + return; + } + case 4: { /* 4-byte signed integer */ + /* EVIDENCE-OF: R-01849-26079 Value is a big-endian 32-bit + ** twos-complement integer. */ + pMem->u.i = FOUR_BYTE_INT(buf); +#ifdef __HP_cc + /* Work around a sign-extension bug in the HP compiler for HP/UX */ + if( buf[0]&0x80 ) pMem->u.i |= 0xffffffff80000000LL; +#endif + pMem->flags = MEM_Int; + testcase( pMem->u.i<0 ); + return; + } + case 5: { /* 6-byte signed integer */ + /* EVIDENCE-OF: R-50385-09674 Value is a big-endian 48-bit + ** twos-complement integer. */ + pMem->u.i = FOUR_BYTE_UINT(buf+2) + (((i64)1)<<32)*TWO_BYTE_INT(buf); + pMem->flags = MEM_Int; + testcase( pMem->u.i<0 ); + return; + } + case 6: /* 8-byte signed integer */ + case 7: { /* IEEE floating point */ + /* These use local variables, so do them in a separate routine + ** to avoid having to move the frame pointer in the common case */ + serialGet(buf,serial_type,pMem); + return; + } + case 8: /* Integer 0 */ + case 9: { /* Integer 1 */ + /* EVIDENCE-OF: R-12976-22893 Value is the integer 0. */ + /* EVIDENCE-OF: R-18143-12121 Value is the integer 1. */ + pMem->u.i = serial_type-8; + pMem->flags = MEM_Int; + return; + } + default: { + /* EVIDENCE-OF: R-14606-31564 Value is a BLOB that is (N-12)/2 bytes in + ** length. + ** EVIDENCE-OF: R-28401-00140 Value is a string in the text encoding and + ** (N-13)/2 bytes in length. */ + static const u16 aFlag[] = { MEM_Blob|MEM_Ephem, MEM_Str|MEM_Ephem }; + pMem->z = (char *)buf; + pMem->n = (serial_type-12)/2; + pMem->flags = aFlag[serial_type&1]; + return; + } + } + return; +} +/* +** This routine is used to allocate sufficient space for an UnpackedRecord +** structure large enough to be used with sqlite3VdbeRecordUnpack() if +** the first argument is a pointer to KeyInfo structure pKeyInfo. +** +** The space is either allocated using sqlite3DbMallocRaw() or from within +** the unaligned buffer passed via the second and third arguments (presumably +** stack space). If the former, then *ppFree is set to a pointer that should +** be eventually freed by the caller using sqlite3DbFree(). Or, if the +** allocation comes from the pSpace/szSpace buffer, *ppFree is set to NULL +** before returning. +** +** If an OOM error occurs, NULL is returned. +*/ +SQLITE_PRIVATE UnpackedRecord *sqlite3VdbeAllocUnpackedRecord( + KeyInfo *pKeyInfo /* Description of the record */ +){ + UnpackedRecord *p; /* Unpacked record to return */ + int nByte; /* Number of bytes required for *p */ + nByte = ROUND8P(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nKeyField+1); + p = (UnpackedRecord *)sqlite3DbMallocRaw(pKeyInfo->db, nByte); + if( !p ) return 0; + p->aMem = (Mem*)&((char*)p)[ROUND8P(sizeof(UnpackedRecord))]; + assert( pKeyInfo->aSortFlags!=0 ); + p->pKeyInfo = pKeyInfo; + p->nField = pKeyInfo->nKeyField + 1; + return p; +} + +/* +** Given the nKey-byte encoding of a record in pKey[], populate the +** UnpackedRecord structure indicated by the fourth argument with the +** contents of the decoded record. +*/ +SQLITE_PRIVATE void sqlite3VdbeRecordUnpack( + KeyInfo *pKeyInfo, /* Information about the record format */ + int nKey, /* Size of the binary record */ + const void *pKey, /* The binary record */ + UnpackedRecord *p /* Populate this structure before returning. */ +){ + const unsigned char *aKey = (const unsigned char *)pKey; + u32 d; + u32 idx; /* Offset in aKey[] to read from */ + u16 u; /* Unsigned loop counter */ + u32 szHdr; + Mem *pMem = p->aMem; + + p->default_rc = 0; + assert( EIGHT_BYTE_ALIGNMENT(pMem) ); + idx = getVarint32(aKey, szHdr); + d = szHdr; + u = 0; + while( idxenc = pKeyInfo->enc; + pMem->db = pKeyInfo->db; + /* pMem->flags = 0; // sqlite3VdbeSerialGet() will set this for us */ + pMem->szMalloc = 0; + pMem->z = 0; + sqlite3VdbeSerialGet(&aKey[d], serial_type, pMem); + d += sqlite3VdbeSerialTypeLen(serial_type); + pMem++; + if( (++u)>=p->nField ) break; + } + if( d>(u32)nKey && u ){ + assert( CORRUPT_DB ); + /* In a corrupt record entry, the last pMem might have been set up using + ** uninitialized memory. Overwrite its value with NULL, to prevent + ** warnings from MSAN. */ + sqlite3VdbeMemSetNull(pMem-1); + } + assert( u<=pKeyInfo->nKeyField + 1 ); + p->nField = u; +} + +#ifdef SQLITE_DEBUG +/* +** This function compares two index or table record keys in the same way +** as the sqlite3VdbeRecordCompare() routine. Unlike VdbeRecordCompare(), +** this function deserializes and compares values using the +** sqlite3VdbeSerialGet() and sqlite3MemCompare() functions. It is used +** in assert() statements to ensure that the optimized code in +** sqlite3VdbeRecordCompare() returns results with these two primitives. +** +** Return true if the result of comparison is equivalent to desiredResult. +** Return false if there is a disagreement. +*/ +static int vdbeRecordCompareDebug( + int nKey1, const void *pKey1, /* Left key */ + const UnpackedRecord *pPKey2, /* Right key */ + int desiredResult /* Correct answer */ +){ + u32 d1; /* Offset into aKey[] of next data element */ + u32 idx1; /* Offset into aKey[] of next header element */ + u32 szHdr1; /* Number of bytes in header */ + int i = 0; + int rc = 0; + const unsigned char *aKey1 = (const unsigned char *)pKey1; + KeyInfo *pKeyInfo; + Mem mem1; + + pKeyInfo = pPKey2->pKeyInfo; + if( pKeyInfo->db==0 ) return 1; + mem1.enc = pKeyInfo->enc; + mem1.db = pKeyInfo->db; + /* mem1.flags = 0; // Will be initialized by sqlite3VdbeSerialGet() */ + VVA_ONLY( mem1.szMalloc = 0; ) /* Only needed by assert() statements */ + + /* Compilers may complain that mem1.u.i is potentially uninitialized. + ** We could initialize it, as shown here, to silence those complaints. + ** But in fact, mem1.u.i will never actually be used uninitialized, and doing + ** the unnecessary initialization has a measurable negative performance + ** impact, since this routine is a very high runner. And so, we choose + ** to ignore the compiler warnings and leave this variable uninitialized. + */ + /* mem1.u.i = 0; // not needed, here to silence compiler warning */ + + idx1 = getVarint32(aKey1, szHdr1); + if( szHdr1>98307 ) return SQLITE_CORRUPT; + d1 = szHdr1; + assert( pKeyInfo->nAllField>=pPKey2->nField || CORRUPT_DB ); + assert( pKeyInfo->aSortFlags!=0 ); + assert( pKeyInfo->nKeyField>0 ); + assert( idx1<=szHdr1 || CORRUPT_DB ); + do{ + u32 serial_type1; + + /* Read the serial types for the next element in each key. */ + idx1 += getVarint32( aKey1+idx1, serial_type1 ); + + /* Verify that there is enough key space remaining to avoid + ** a buffer overread. The "d1+serial_type1+2" subexpression will + ** always be greater than or equal to the amount of required key space. + ** Use that approximation to avoid the more expensive call to + ** sqlite3VdbeSerialTypeLen() in the common case. + */ + if( d1+(u64)serial_type1+2>(u64)nKey1 + && d1+(u64)sqlite3VdbeSerialTypeLen(serial_type1)>(u64)nKey1 + ){ + break; + } + + /* Extract the values to be compared. + */ + sqlite3VdbeSerialGet(&aKey1[d1], serial_type1, &mem1); + d1 += sqlite3VdbeSerialTypeLen(serial_type1); + + /* Do the comparison + */ + rc = sqlite3MemCompare(&mem1, &pPKey2->aMem[i], + pKeyInfo->nAllField>i ? pKeyInfo->aColl[i] : 0); + if( rc!=0 ){ + assert( mem1.szMalloc==0 ); /* See comment below */ + if( (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_BIGNULL) + && ((mem1.flags & MEM_Null) || (pPKey2->aMem[i].flags & MEM_Null)) + ){ + rc = -rc; + } + if( pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_DESC ){ + rc = -rc; /* Invert the result for DESC sort order. */ + } + goto debugCompareEnd; + } + i++; + }while( idx1nField ); + + /* No memory allocation is ever used on mem1. Prove this using + ** the following assert(). If the assert() fails, it indicates a + ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1). + */ + assert( mem1.szMalloc==0 ); + + /* rc==0 here means that one of the keys ran out of fields and + ** all the fields up to that point were equal. Return the default_rc + ** value. */ + rc = pPKey2->default_rc; + +debugCompareEnd: + if( desiredResult==0 && rc==0 ) return 1; + if( desiredResult<0 && rc<0 ) return 1; + if( desiredResult>0 && rc>0 ) return 1; + if( CORRUPT_DB ) return 1; + if( pKeyInfo->db->mallocFailed ) return 1; + return 0; +} +#endif + +#ifdef SQLITE_DEBUG +/* +** Count the number of fields (a.k.a. columns) in the record given by +** pKey,nKey. The verify that this count is less than or equal to the +** limit given by pKeyInfo->nAllField. +** +** If this constraint is not satisfied, it means that the high-speed +** vdbeRecordCompareInt() and vdbeRecordCompareString() routines will +** not work correctly. If this assert() ever fires, it probably means +** that the KeyInfo.nKeyField or KeyInfo.nAllField values were computed +** incorrectly. +*/ +static void vdbeAssertFieldCountWithinLimits( + int nKey, const void *pKey, /* The record to verify */ + const KeyInfo *pKeyInfo /* Compare size with this KeyInfo */ +){ + int nField = 0; + u32 szHdr; + u32 idx; + u32 notUsed; + const unsigned char *aKey = (const unsigned char*)pKey; + + if( CORRUPT_DB ) return; + idx = getVarint32(aKey, szHdr); + assert( nKey>=0 ); + assert( szHdr<=(u32)nKey ); + while( idxnAllField ); +} +#else +# define vdbeAssertFieldCountWithinLimits(A,B,C) +#endif + +/* +** Both *pMem1 and *pMem2 contain string values. Compare the two values +** using the collation sequence pColl. As usual, return a negative , zero +** or positive value if *pMem1 is less than, equal to or greater than +** *pMem2, respectively. Similar in spirit to "rc = (*pMem1) - (*pMem2);". +*/ +static int vdbeCompareMemString( + const Mem *pMem1, + const Mem *pMem2, + const CollSeq *pColl, + u8 *prcErr /* If an OOM occurs, set to SQLITE_NOMEM */ +){ + if( pMem1->enc==pColl->enc ){ + /* The strings are already in the correct encoding. Call the + ** comparison function directly */ + return pColl->xCmp(pColl->pUser,pMem1->n,pMem1->z,pMem2->n,pMem2->z); + }else{ + int rc; + const void *v1, *v2; + Mem c1; + Mem c2; + sqlite3VdbeMemInit(&c1, pMem1->db, MEM_Null); + sqlite3VdbeMemInit(&c2, pMem1->db, MEM_Null); + sqlite3VdbeMemShallowCopy(&c1, pMem1, MEM_Ephem); + sqlite3VdbeMemShallowCopy(&c2, pMem2, MEM_Ephem); + v1 = sqlite3ValueText((sqlite3_value*)&c1, pColl->enc); + v2 = sqlite3ValueText((sqlite3_value*)&c2, pColl->enc); + if( (v1==0 || v2==0) ){ + if( prcErr ) *prcErr = SQLITE_NOMEM_BKPT; + rc = 0; + }else{ + rc = pColl->xCmp(pColl->pUser, c1.n, v1, c2.n, v2); + } + sqlite3VdbeMemReleaseMalloc(&c1); + sqlite3VdbeMemReleaseMalloc(&c2); + return rc; + } +} + +/* +** The input pBlob is guaranteed to be a Blob that is not marked +** with MEM_Zero. Return true if it could be a zero-blob. +*/ +static int isAllZero(const char *z, int n){ + int i; + for(i=0; in; + int n2 = pB2->n; + + /* It is possible to have a Blob value that has some non-zero content + ** followed by zero content. But that only comes up for Blobs formed + ** by the OP_MakeRecord opcode, and such Blobs never get passed into + ** sqlite3MemCompare(). */ + assert( (pB1->flags & MEM_Zero)==0 || n1==0 ); + assert( (pB2->flags & MEM_Zero)==0 || n2==0 ); + + if( (pB1->flags|pB2->flags) & MEM_Zero ){ + if( pB1->flags & pB2->flags & MEM_Zero ){ + return pB1->u.nZero - pB2->u.nZero; + }else if( pB1->flags & MEM_Zero ){ + if( !isAllZero(pB2->z, pB2->n) ) return -1; + return pB1->u.nZero - n2; + }else{ + if( !isAllZero(pB1->z, pB1->n) ) return +1; + return n1 - pB2->u.nZero; + } + } + c = memcmp(pB1->z, pB2->z, n1>n2 ? n2 : n1); + if( c ) return c; + return n1 - n2; +} + +/* +** Do a comparison between a 64-bit signed integer and a 64-bit floating-point +** number. Return negative, zero, or positive if the first (i64) is less than, +** equal to, or greater than the second (double). +*/ +SQLITE_PRIVATE int sqlite3IntFloatCompare(i64 i, double r){ + if( sizeof(LONGDOUBLE_TYPE)>8 ){ + LONGDOUBLE_TYPE x = (LONGDOUBLE_TYPE)i; + testcase( xr ); + testcase( x==r ); + if( xr ) return +1; /*NO_TEST*/ /* work around bugs in gcov */ + return 0; /*NO_TEST*/ /* work around bugs in gcov */ + }else{ + i64 y; + double s; + if( r<-9223372036854775808.0 ) return +1; + if( r>=9223372036854775808.0 ) return -1; + y = (i64)r; + if( iy ) return +1; + s = (double)i; + if( sr ) return +1; + return 0; + } +} + +/* +** Compare the values contained by the two memory cells, returning +** negative, zero or positive if pMem1 is less than, equal to, or greater +** than pMem2. Sorting order is NULL's first, followed by numbers (integers +** and reals) sorted numerically, followed by text ordered by the collating +** sequence pColl and finally blob's ordered by memcmp(). +** +** Two NULL values are considered equal by this function. +*/ +SQLITE_PRIVATE int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){ + int f1, f2; + int combined_flags; + + f1 = pMem1->flags; + f2 = pMem2->flags; + combined_flags = f1|f2; + assert( !sqlite3VdbeMemIsRowSet(pMem1) && !sqlite3VdbeMemIsRowSet(pMem2) ); + + /* If one value is NULL, it is less than the other. If both values + ** are NULL, return 0. + */ + if( combined_flags&MEM_Null ){ + return (f2&MEM_Null) - (f1&MEM_Null); + } + + /* At least one of the two values is a number + */ + if( combined_flags&(MEM_Int|MEM_Real|MEM_IntReal) ){ + testcase( combined_flags & MEM_Int ); + testcase( combined_flags & MEM_Real ); + testcase( combined_flags & MEM_IntReal ); + if( (f1 & f2 & (MEM_Int|MEM_IntReal))!=0 ){ + testcase( f1 & f2 & MEM_Int ); + testcase( f1 & f2 & MEM_IntReal ); + if( pMem1->u.i < pMem2->u.i ) return -1; + if( pMem1->u.i > pMem2->u.i ) return +1; + return 0; + } + if( (f1 & f2 & MEM_Real)!=0 ){ + if( pMem1->u.r < pMem2->u.r ) return -1; + if( pMem1->u.r > pMem2->u.r ) return +1; + return 0; + } + if( (f1&(MEM_Int|MEM_IntReal))!=0 ){ + testcase( f1 & MEM_Int ); + testcase( f1 & MEM_IntReal ); + if( (f2&MEM_Real)!=0 ){ + return sqlite3IntFloatCompare(pMem1->u.i, pMem2->u.r); + }else if( (f2&(MEM_Int|MEM_IntReal))!=0 ){ + if( pMem1->u.i < pMem2->u.i ) return -1; + if( pMem1->u.i > pMem2->u.i ) return +1; + return 0; + }else{ + return -1; + } + } + if( (f1&MEM_Real)!=0 ){ + if( (f2&(MEM_Int|MEM_IntReal))!=0 ){ + testcase( f2 & MEM_Int ); + testcase( f2 & MEM_IntReal ); + return -sqlite3IntFloatCompare(pMem2->u.i, pMem1->u.r); + }else{ + return -1; + } + } + return +1; + } + + /* If one value is a string and the other is a blob, the string is less. + ** If both are strings, compare using the collating functions. + */ + if( combined_flags&MEM_Str ){ + if( (f1 & MEM_Str)==0 ){ + return 1; + } + if( (f2 & MEM_Str)==0 ){ + return -1; + } + + assert( pMem1->enc==pMem2->enc || pMem1->db->mallocFailed ); + assert( pMem1->enc==SQLITE_UTF8 || + pMem1->enc==SQLITE_UTF16LE || pMem1->enc==SQLITE_UTF16BE ); + + /* The collation sequence must be defined at this point, even if + ** the user deletes the collation sequence after the vdbe program is + ** compiled (this was not always the case). + */ + assert( !pColl || pColl->xCmp ); + + if( pColl ){ + return vdbeCompareMemString(pMem1, pMem2, pColl, 0); + } + /* If a NULL pointer was passed as the collate function, fall through + ** to the blob case and use memcmp(). */ + } + + /* Both values must be blobs. Compare using memcmp(). */ + return sqlite3BlobCompare(pMem1, pMem2); +} + + +/* +** The first argument passed to this function is a serial-type that +** corresponds to an integer - all values between 1 and 9 inclusive +** except 7. The second points to a buffer containing an integer value +** serialized according to serial_type. This function deserializes +** and returns the value. +*/ +static i64 vdbeRecordDecodeInt(u32 serial_type, const u8 *aKey){ + u32 y; + assert( CORRUPT_DB || (serial_type>=1 && serial_type<=9 && serial_type!=7) ); + switch( serial_type ){ + case 0: + case 1: + testcase( aKey[0]&0x80 ); + return ONE_BYTE_INT(aKey); + case 2: + testcase( aKey[0]&0x80 ); + return TWO_BYTE_INT(aKey); + case 3: + testcase( aKey[0]&0x80 ); + return THREE_BYTE_INT(aKey); + case 4: { + testcase( aKey[0]&0x80 ); + y = FOUR_BYTE_UINT(aKey); + return (i64)*(int*)&y; + } + case 5: { + testcase( aKey[0]&0x80 ); + return FOUR_BYTE_UINT(aKey+2) + (((i64)1)<<32)*TWO_BYTE_INT(aKey); + } + case 6: { + u64 x = FOUR_BYTE_UINT(aKey); + testcase( aKey[0]&0x80 ); + x = (x<<32) | FOUR_BYTE_UINT(aKey+4); + return (i64)*(i64*)&x; + } + } + + return (serial_type - 8); +} + +/* +** This function compares the two table rows or index records +** specified by {nKey1, pKey1} and pPKey2. It returns a negative, zero +** or positive integer if key1 is less than, equal to or +** greater than key2. The {nKey1, pKey1} key must be a blob +** created by the OP_MakeRecord opcode of the VDBE. The pPKey2 +** key must be a parsed key such as obtained from +** sqlite3VdbeParseRecord. +** +** If argument bSkip is non-zero, it is assumed that the caller has already +** determined that the first fields of the keys are equal. +** +** Key1 and Key2 do not have to contain the same number of fields. If all +** fields that appear in both keys are equal, then pPKey2->default_rc is +** returned. +** +** If database corruption is discovered, set pPKey2->errCode to +** SQLITE_CORRUPT and return 0. If an OOM error is encountered, +** pPKey2->errCode is set to SQLITE_NOMEM and, if it is not NULL, the +** malloc-failed flag set on database handle (pPKey2->pKeyInfo->db). +*/ +SQLITE_PRIVATE int sqlite3VdbeRecordCompareWithSkip( + int nKey1, const void *pKey1, /* Left key */ + UnpackedRecord *pPKey2, /* Right key */ + int bSkip /* If true, skip the first field */ +){ + u32 d1; /* Offset into aKey[] of next data element */ + int i; /* Index of next field to compare */ + u32 szHdr1; /* Size of record header in bytes */ + u32 idx1; /* Offset of first type in header */ + int rc = 0; /* Return value */ + Mem *pRhs = pPKey2->aMem; /* Next field of pPKey2 to compare */ + KeyInfo *pKeyInfo; + const unsigned char *aKey1 = (const unsigned char *)pKey1; + Mem mem1; + + /* If bSkip is true, then the caller has already determined that the first + ** two elements in the keys are equal. Fix the various stack variables so + ** that this routine begins comparing at the second field. */ + if( bSkip ){ + u32 s1 = aKey1[1]; + if( s1<0x80 ){ + idx1 = 2; + }else{ + idx1 = 1 + sqlite3GetVarint32(&aKey1[1], &s1); + } + szHdr1 = aKey1[0]; + d1 = szHdr1 + sqlite3VdbeSerialTypeLen(s1); + i = 1; + pRhs++; + }else{ + if( (szHdr1 = aKey1[0])<0x80 ){ + idx1 = 1; + }else{ + idx1 = sqlite3GetVarint32(aKey1, &szHdr1); + } + d1 = szHdr1; + i = 0; + } + if( d1>(unsigned)nKey1 ){ + pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT; + return 0; /* Corruption */ + } + + VVA_ONLY( mem1.szMalloc = 0; ) /* Only needed by assert() statements */ + assert( pPKey2->pKeyInfo->nAllField>=pPKey2->nField + || CORRUPT_DB ); + assert( pPKey2->pKeyInfo->aSortFlags!=0 ); + assert( pPKey2->pKeyInfo->nKeyField>0 ); + assert( idx1<=szHdr1 || CORRUPT_DB ); + while( 1 /*exit-by-break*/ ){ + u32 serial_type; + + /* RHS is an integer */ + if( pRhs->flags & (MEM_Int|MEM_IntReal) ){ + testcase( pRhs->flags & MEM_Int ); + testcase( pRhs->flags & MEM_IntReal ); + serial_type = aKey1[idx1]; + testcase( serial_type==12 ); + if( serial_type>=10 ){ + rc = serial_type==10 ? -1 : +1; + }else if( serial_type==0 ){ + rc = -1; + }else if( serial_type==7 ){ + sqlite3VdbeSerialGet(&aKey1[d1], serial_type, &mem1); + rc = -sqlite3IntFloatCompare(pRhs->u.i, mem1.u.r); + }else{ + i64 lhs = vdbeRecordDecodeInt(serial_type, &aKey1[d1]); + i64 rhs = pRhs->u.i; + if( lhsrhs ){ + rc = +1; + } + } + } + + /* RHS is real */ + else if( pRhs->flags & MEM_Real ){ + serial_type = aKey1[idx1]; + if( serial_type>=10 ){ + /* Serial types 12 or greater are strings and blobs (greater than + ** numbers). Types 10 and 11 are currently "reserved for future + ** use", so it doesn't really matter what the results of comparing + ** them to numberic values are. */ + rc = serial_type==10 ? -1 : +1; + }else if( serial_type==0 ){ + rc = -1; + }else{ + sqlite3VdbeSerialGet(&aKey1[d1], serial_type, &mem1); + if( serial_type==7 ){ + if( mem1.u.ru.r ){ + rc = -1; + }else if( mem1.u.r>pRhs->u.r ){ + rc = +1; + } + }else{ + rc = sqlite3IntFloatCompare(mem1.u.i, pRhs->u.r); + } + } + } + + /* RHS is a string */ + else if( pRhs->flags & MEM_Str ){ + getVarint32NR(&aKey1[idx1], serial_type); + testcase( serial_type==12 ); + if( serial_type<12 ){ + rc = -1; + }else if( !(serial_type & 0x01) ){ + rc = +1; + }else{ + mem1.n = (serial_type - 12) / 2; + testcase( (d1+mem1.n)==(unsigned)nKey1 ); + testcase( (d1+mem1.n+1)==(unsigned)nKey1 ); + if( (d1+mem1.n) > (unsigned)nKey1 + || (pKeyInfo = pPKey2->pKeyInfo)->nAllField<=i + ){ + pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT; + return 0; /* Corruption */ + }else if( pKeyInfo->aColl[i] ){ + mem1.enc = pKeyInfo->enc; + mem1.db = pKeyInfo->db; + mem1.flags = MEM_Str; + mem1.z = (char*)&aKey1[d1]; + rc = vdbeCompareMemString( + &mem1, pRhs, pKeyInfo->aColl[i], &pPKey2->errCode + ); + }else{ + int nCmp = MIN(mem1.n, pRhs->n); + rc = memcmp(&aKey1[d1], pRhs->z, nCmp); + if( rc==0 ) rc = mem1.n - pRhs->n; + } + } + } + + /* RHS is a blob */ + else if( pRhs->flags & MEM_Blob ){ + assert( (pRhs->flags & MEM_Zero)==0 || pRhs->n==0 ); + getVarint32NR(&aKey1[idx1], serial_type); + testcase( serial_type==12 ); + if( serial_type<12 || (serial_type & 0x01) ){ + rc = -1; + }else{ + int nStr = (serial_type - 12) / 2; + testcase( (d1+nStr)==(unsigned)nKey1 ); + testcase( (d1+nStr+1)==(unsigned)nKey1 ); + if( (d1+nStr) > (unsigned)nKey1 ){ + pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT; + return 0; /* Corruption */ + }else if( pRhs->flags & MEM_Zero ){ + if( !isAllZero((const char*)&aKey1[d1],nStr) ){ + rc = 1; + }else{ + rc = nStr - pRhs->u.nZero; + } + }else{ + int nCmp = MIN(nStr, pRhs->n); + rc = memcmp(&aKey1[d1], pRhs->z, nCmp); + if( rc==0 ) rc = nStr - pRhs->n; + } + } + } + + /* RHS is null */ + else{ + serial_type = aKey1[idx1]; + rc = (serial_type!=0 && serial_type!=10); + } + + if( rc!=0 ){ + int sortFlags = pPKey2->pKeyInfo->aSortFlags[i]; + if( sortFlags ){ + if( (sortFlags & KEYINFO_ORDER_BIGNULL)==0 + || ((sortFlags & KEYINFO_ORDER_DESC) + !=(serial_type==0 || (pRhs->flags&MEM_Null))) + ){ + rc = -rc; + } + } + assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, rc) ); + assert( mem1.szMalloc==0 ); /* See comment below */ + return rc; + } + + i++; + if( i==pPKey2->nField ) break; + pRhs++; + d1 += sqlite3VdbeSerialTypeLen(serial_type); + if( d1>(unsigned)nKey1 ) break; + idx1 += sqlite3VarintLen(serial_type); + if( idx1>=(unsigned)szHdr1 ){ + pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT; + return 0; /* Corrupt index */ + } + } + + /* No memory allocation is ever used on mem1. Prove this using + ** the following assert(). If the assert() fails, it indicates a + ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1). */ + assert( mem1.szMalloc==0 ); + + /* rc==0 here means that one or both of the keys ran out of fields and + ** all the fields up to that point were equal. Return the default_rc + ** value. */ + assert( CORRUPT_DB + || vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, pPKey2->default_rc) + || pPKey2->pKeyInfo->db->mallocFailed + ); + pPKey2->eqSeen = 1; + return pPKey2->default_rc; +} +SQLITE_PRIVATE int sqlite3VdbeRecordCompare( + int nKey1, const void *pKey1, /* Left key */ + UnpackedRecord *pPKey2 /* Right key */ +){ + return sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, pPKey2, 0); +} + + +/* +** This function is an optimized version of sqlite3VdbeRecordCompare() +** that (a) the first field of pPKey2 is an integer, and (b) the +** size-of-header varint at the start of (pKey1/nKey1) fits in a single +** byte (i.e. is less than 128). +** +** To avoid concerns about buffer overreads, this routine is only used +** on schemas where the maximum valid header size is 63 bytes or less. +*/ +static int vdbeRecordCompareInt( + int nKey1, const void *pKey1, /* Left key */ + UnpackedRecord *pPKey2 /* Right key */ +){ + const u8 *aKey = &((const u8*)pKey1)[*(const u8*)pKey1 & 0x3F]; + int serial_type = ((const u8*)pKey1)[1]; + int res; + u32 y; + u64 x; + i64 v; + i64 lhs; + + vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo); + assert( (*(u8*)pKey1)<=0x3F || CORRUPT_DB ); + switch( serial_type ){ + case 1: { /* 1-byte signed integer */ + lhs = ONE_BYTE_INT(aKey); + testcase( lhs<0 ); + break; + } + case 2: { /* 2-byte signed integer */ + lhs = TWO_BYTE_INT(aKey); + testcase( lhs<0 ); + break; + } + case 3: { /* 3-byte signed integer */ + lhs = THREE_BYTE_INT(aKey); + testcase( lhs<0 ); + break; + } + case 4: { /* 4-byte signed integer */ + y = FOUR_BYTE_UINT(aKey); + lhs = (i64)*(int*)&y; + testcase( lhs<0 ); + break; + } + case 5: { /* 6-byte signed integer */ + lhs = FOUR_BYTE_UINT(aKey+2) + (((i64)1)<<32)*TWO_BYTE_INT(aKey); + testcase( lhs<0 ); + break; + } + case 6: { /* 8-byte signed integer */ + x = FOUR_BYTE_UINT(aKey); + x = (x<<32) | FOUR_BYTE_UINT(aKey+4); + lhs = *(i64*)&x; + testcase( lhs<0 ); + break; + } + case 8: + lhs = 0; + break; + case 9: + lhs = 1; + break; + + /* This case could be removed without changing the results of running + ** this code. Including it causes gcc to generate a faster switch + ** statement (since the range of switch targets now starts at zero and + ** is contiguous) but does not cause any duplicate code to be generated + ** (as gcc is clever enough to combine the two like cases). Other + ** compilers might be similar. */ + case 0: case 7: + return sqlite3VdbeRecordCompare(nKey1, pKey1, pPKey2); + + default: + return sqlite3VdbeRecordCompare(nKey1, pKey1, pPKey2); + } + + assert( pPKey2->u.i == pPKey2->aMem[0].u.i ); + v = pPKey2->u.i; + if( v>lhs ){ + res = pPKey2->r1; + }else if( vr2; + }else if( pPKey2->nField>1 ){ + /* The first fields of the two keys are equal. Compare the trailing + ** fields. */ + res = sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, pPKey2, 1); + }else{ + /* The first fields of the two keys are equal and there are no trailing + ** fields. Return pPKey2->default_rc in this case. */ + res = pPKey2->default_rc; + pPKey2->eqSeen = 1; + } + + assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, res) ); + return res; +} + +/* +** This function is an optimized version of sqlite3VdbeRecordCompare() +** that (a) the first field of pPKey2 is a string, that (b) the first field +** uses the collation sequence BINARY and (c) that the size-of-header varint +** at the start of (pKey1/nKey1) fits in a single byte. +*/ +static int vdbeRecordCompareString( + int nKey1, const void *pKey1, /* Left key */ + UnpackedRecord *pPKey2 /* Right key */ +){ + const u8 *aKey1 = (const u8*)pKey1; + int serial_type; + int res; + + assert( pPKey2->aMem[0].flags & MEM_Str ); + assert( pPKey2->aMem[0].n == pPKey2->n ); + assert( pPKey2->aMem[0].z == pPKey2->u.z ); + vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo); + serial_type = (signed char)(aKey1[1]); + +vrcs_restart: + if( serial_type<12 ){ + if( serial_type<0 ){ + sqlite3GetVarint32(&aKey1[1], (u32*)&serial_type); + if( serial_type>=12 ) goto vrcs_restart; + assert( CORRUPT_DB ); + } + res = pPKey2->r1; /* (pKey1/nKey1) is a number or a null */ + }else if( !(serial_type & 0x01) ){ + res = pPKey2->r2; /* (pKey1/nKey1) is a blob */ + }else{ + int nCmp; + int nStr; + int szHdr = aKey1[0]; + + nStr = (serial_type-12) / 2; + if( (szHdr + nStr) > nKey1 ){ + pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT; + return 0; /* Corruption */ + } + nCmp = MIN( pPKey2->n, nStr ); + res = memcmp(&aKey1[szHdr], pPKey2->u.z, nCmp); + + if( res>0 ){ + res = pPKey2->r2; + }else if( res<0 ){ + res = pPKey2->r1; + }else{ + res = nStr - pPKey2->n; + if( res==0 ){ + if( pPKey2->nField>1 ){ + res = sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, pPKey2, 1); + }else{ + res = pPKey2->default_rc; + pPKey2->eqSeen = 1; + } + }else if( res>0 ){ + res = pPKey2->r2; + }else{ + res = pPKey2->r1; + } + } + } + + assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, res) + || CORRUPT_DB + || pPKey2->pKeyInfo->db->mallocFailed + ); + return res; +} + +/* +** Return a pointer to an sqlite3VdbeRecordCompare() compatible function +** suitable for comparing serialized records to the unpacked record passed +** as the only argument. +*/ +SQLITE_PRIVATE RecordCompare sqlite3VdbeFindCompare(UnpackedRecord *p){ + /* varintRecordCompareInt() and varintRecordCompareString() both assume + ** that the size-of-header varint that occurs at the start of each record + ** fits in a single byte (i.e. is 127 or less). varintRecordCompareInt() + ** also assumes that it is safe to overread a buffer by at least the + ** maximum possible legal header size plus 8 bytes. Because there is + ** guaranteed to be at least 74 (but not 136) bytes of padding following each + ** buffer passed to varintRecordCompareInt() this makes it convenient to + ** limit the size of the header to 64 bytes in cases where the first field + ** is an integer. + ** + ** The easiest way to enforce this limit is to consider only records with + ** 13 fields or less. If the first field is an integer, the maximum legal + ** header size is (12*5 + 1 + 1) bytes. */ + if( p->pKeyInfo->nAllField<=13 ){ + int flags = p->aMem[0].flags; + if( p->pKeyInfo->aSortFlags[0] ){ + if( p->pKeyInfo->aSortFlags[0] & KEYINFO_ORDER_BIGNULL ){ + return sqlite3VdbeRecordCompare; + } + p->r1 = 1; + p->r2 = -1; + }else{ + p->r1 = -1; + p->r2 = 1; + } + if( (flags & MEM_Int) ){ + p->u.i = p->aMem[0].u.i; + return vdbeRecordCompareInt; + } + testcase( flags & MEM_Real ); + testcase( flags & MEM_Null ); + testcase( flags & MEM_Blob ); + if( (flags & (MEM_Real|MEM_IntReal|MEM_Null|MEM_Blob))==0 + && p->pKeyInfo->aColl[0]==0 + ){ + assert( flags & MEM_Str ); + p->u.z = p->aMem[0].z; + p->n = p->aMem[0].n; + return vdbeRecordCompareString; + } + } + + return sqlite3VdbeRecordCompare; +} + +/* +** pCur points at an index entry created using the OP_MakeRecord opcode. +** Read the rowid (the last field in the record) and store it in *rowid. +** Return SQLITE_OK if everything works, or an error code otherwise. +** +** pCur might be pointing to text obtained from a corrupt database file. +** So the content cannot be trusted. Do appropriate checks on the content. +*/ +SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){ + i64 nCellKey = 0; + int rc; + u32 szHdr; /* Size of the header */ + u32 typeRowid; /* Serial type of the rowid */ + u32 lenRowid; /* Size of the rowid */ + Mem m, v; + + /* Get the size of the index entry. Only indices entries of less + ** than 2GiB are support - anything large must be database corruption. + ** Any corruption is detected in sqlite3BtreeParseCellPtr(), though, so + ** this code can safely assume that nCellKey is 32-bits + */ + assert( sqlite3BtreeCursorIsValid(pCur) ); + nCellKey = sqlite3BtreePayloadSize(pCur); + assert( (nCellKey & SQLITE_MAX_U32)==(u64)nCellKey ); + + /* Read in the complete content of the index entry */ + sqlite3VdbeMemInit(&m, db, 0); + rc = sqlite3VdbeMemFromBtreeZeroOffset(pCur, (u32)nCellKey, &m); + if( rc ){ + return rc; + } + + /* The index entry must begin with a header size */ + getVarint32NR((u8*)m.z, szHdr); + testcase( szHdr==3 ); + testcase( szHdr==(u32)m.n ); + testcase( szHdr>0x7fffffff ); + assert( m.n>=0 ); + if( unlikely(szHdr<3 || szHdr>(unsigned)m.n) ){ + goto idx_rowid_corruption; + } + + /* The last field of the index should be an integer - the ROWID. + ** Verify that the last entry really is an integer. */ + getVarint32NR((u8*)&m.z[szHdr-1], typeRowid); + testcase( typeRowid==1 ); + testcase( typeRowid==2 ); + testcase( typeRowid==3 ); + testcase( typeRowid==4 ); + testcase( typeRowid==5 ); + testcase( typeRowid==6 ); + testcase( typeRowid==8 ); + testcase( typeRowid==9 ); + if( unlikely(typeRowid<1 || typeRowid>9 || typeRowid==7) ){ + goto idx_rowid_corruption; + } + lenRowid = sqlite3SmallTypeSizes[typeRowid]; + testcase( (u32)m.n==szHdr+lenRowid ); + if( unlikely((u32)m.neCurType==CURTYPE_BTREE ); + pCur = pC->uc.pCursor; + assert( sqlite3BtreeCursorIsValid(pCur) ); + nCellKey = sqlite3BtreePayloadSize(pCur); + /* nCellKey will always be between 0 and 0xffffffff because of the way + ** that btreeParseCellPtr() and sqlite3GetVarint32() are implemented */ + if( nCellKey<=0 || nCellKey>0x7fffffff ){ + *res = 0; + return SQLITE_CORRUPT_BKPT; + } + sqlite3VdbeMemInit(&m, db, 0); + rc = sqlite3VdbeMemFromBtreeZeroOffset(pCur, (u32)nCellKey, &m); + if( rc ){ + return rc; + } + *res = sqlite3VdbeRecordCompareWithSkip(m.n, m.z, pUnpacked, 0); + sqlite3VdbeMemReleaseMalloc(&m); + return SQLITE_OK; +} + +/* +** This routine sets the value to be returned by subsequent calls to +** sqlite3_changes() on the database handle 'db'. +*/ +SQLITE_PRIVATE void sqlite3VdbeSetChanges(sqlite3 *db, i64 nChange){ + assert( sqlite3_mutex_held(db->mutex) ); + db->nChange = nChange; + db->nTotalChange += nChange; +} + +/* +** Set a flag in the vdbe to update the change counter when it is finalised +** or reset. +*/ +SQLITE_PRIVATE void sqlite3VdbeCountChanges(Vdbe *v){ + v->changeCntOn = 1; +} + +/* +** Mark every prepared statement associated with a database connection +** as expired. +** +** An expired statement means that recompilation of the statement is +** recommend. Statements expire when things happen that make their +** programs obsolete. Removing user-defined functions or collating +** sequences, or changing an authorization function are the types of +** things that make prepared statements obsolete. +** +** If iCode is 1, then expiration is advisory. The statement should +** be reprepared before being restarted, but if it is already running +** it is allowed to run to completion. +** +** Internally, this function just sets the Vdbe.expired flag on all +** prepared statements. The flag is set to 1 for an immediate expiration +** and set to 2 for an advisory expiration. +*/ +SQLITE_PRIVATE void sqlite3ExpirePreparedStatements(sqlite3 *db, int iCode){ + Vdbe *p; + for(p = db->pVdbe; p; p=p->pVNext){ + p->expired = iCode+1; + } +} + +/* +** Return the database associated with the Vdbe. +*/ +SQLITE_PRIVATE sqlite3 *sqlite3VdbeDb(Vdbe *v){ + return v->db; +} + +/* +** Return the SQLITE_PREPARE flags for a Vdbe. +*/ +SQLITE_PRIVATE u8 sqlite3VdbePrepareFlags(Vdbe *v){ + return v->prepFlags; +} + +/* +** Return a pointer to an sqlite3_value structure containing the value bound +** parameter iVar of VM v. Except, if the value is an SQL NULL, return +** 0 instead. Unless it is NULL, apply affinity aff (one of the SQLITE_AFF_* +** constants) to the value before returning it. +** +** The returned value must be freed by the caller using sqlite3ValueFree(). +*/ +SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetBoundValue(Vdbe *v, int iVar, u8 aff){ + assert( iVar>0 ); + if( v ){ + Mem *pMem = &v->aVar[iVar-1]; + assert( (v->db->flags & SQLITE_EnableQPSG)==0 ); + if( 0==(pMem->flags & MEM_Null) ){ + sqlite3_value *pRet = sqlite3ValueNew(v->db); + if( pRet ){ + sqlite3VdbeMemCopy((Mem *)pRet, pMem); + sqlite3ValueApplyAffinity(pRet, aff, SQLITE_UTF8); + } + return pRet; + } + } + return 0; +} + +/* +** Configure SQL variable iVar so that binding a new value to it signals +** to sqlite3_reoptimize() that re-preparing the statement may result +** in a better query plan. +*/ +SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe *v, int iVar){ + assert( iVar>0 ); + assert( (v->db->flags & SQLITE_EnableQPSG)==0 ); + if( iVar>=32 ){ + v->expmask |= 0x80000000; + }else{ + v->expmask |= ((u32)1 << (iVar-1)); + } +} + +/* +** Cause a function to throw an error if it was call from OP_PureFunc +** rather than OP_Function. +** +** OP_PureFunc means that the function must be deterministic, and should +** throw an error if it is given inputs that would make it non-deterministic. +** This routine is invoked by date/time functions that use non-deterministic +** features such as 'now'. +*/ +SQLITE_PRIVATE int sqlite3NotPureFunc(sqlite3_context *pCtx){ + const VdbeOp *pOp; +#ifdef SQLITE_ENABLE_STAT4 + if( pCtx->pVdbe==0 ) return 1; +#endif + pOp = pCtx->pVdbe->aOp + pCtx->iOp; + if( pOp->opcode==OP_PureFunc ){ + const char *zContext; + char *zMsg; + if( pOp->p5 & NC_IsCheck ){ + zContext = "a CHECK constraint"; + }else if( pOp->p5 & NC_GenCol ){ + zContext = "a generated column"; + }else{ + zContext = "an index"; + } + zMsg = sqlite3_mprintf("non-deterministic use of %s() in %s", + pCtx->pFunc->zName, zContext); + sqlite3_result_error(pCtx, zMsg, -1); + sqlite3_free(zMsg); + return 0; + } + return 1; +} + +#if defined(SQLITE_ENABLE_CURSOR_HINTS) && defined(SQLITE_DEBUG) +/* +** This Walker callback is used to help verify that calls to +** sqlite3BtreeCursorHint() with opcode BTREE_HINT_RANGE have +** byte-code register values correctly initialized. +*/ +SQLITE_PRIVATE int sqlite3CursorRangeHintExprCheck(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_REGISTER ){ + assert( (pWalker->u.aMem[pExpr->iTable].flags & MEM_Undefined)==0 ); + } + return WRC_Continue; +} +#endif /* SQLITE_ENABLE_CURSOR_HINTS && SQLITE_DEBUG */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* +** Transfer error message text from an sqlite3_vtab.zErrMsg (text stored +** in memory obtained from sqlite3_malloc) into a Vdbe.zErrMsg (text stored +** in memory obtained from sqlite3DbMalloc). +*/ +SQLITE_PRIVATE void sqlite3VtabImportErrmsg(Vdbe *p, sqlite3_vtab *pVtab){ + if( pVtab->zErrMsg ){ + sqlite3 *db = p->db; + sqlite3DbFree(db, p->zErrMsg); + p->zErrMsg = sqlite3DbStrDup(db, pVtab->zErrMsg); + sqlite3_free(pVtab->zErrMsg); + pVtab->zErrMsg = 0; + } +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + +/* +** If the second argument is not NULL, release any allocations associated +** with the memory cells in the p->aMem[] array. Also free the UnpackedRecord +** structure itself, using sqlite3DbFree(). +** +** This function is used to free UnpackedRecord structures allocated by +** the vdbeUnpackRecord() function found in vdbeapi.c. +*/ +static void vdbeFreeUnpacked(sqlite3 *db, int nField, UnpackedRecord *p){ + assert( db!=0 ); + if( p ){ + int i; + for(i=0; iaMem[i]; + if( pMem->zMalloc ) sqlite3VdbeMemReleaseMalloc(pMem); + } + sqlite3DbNNFreeNN(db, p); + } +} +#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ + +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK +/* +** Invoke the pre-update hook. If this is an UPDATE or DELETE pre-update call, +** then cursor passed as the second argument should point to the row about +** to be update or deleted. If the application calls sqlite3_preupdate_old(), +** the required value will be read from the row the cursor points to. +*/ +SQLITE_PRIVATE void sqlite3VdbePreUpdateHook( + Vdbe *v, /* Vdbe pre-update hook is invoked by */ + VdbeCursor *pCsr, /* Cursor to grab old.* values from */ + int op, /* SQLITE_INSERT, UPDATE or DELETE */ + const char *zDb, /* Database name */ + Table *pTab, /* Modified table */ + i64 iKey1, /* Initial key value */ + int iReg, /* Register for new.* record */ + int iBlobWrite +){ + sqlite3 *db = v->db; + i64 iKey2; + PreUpdate preupdate; + const char *zTbl = pTab->zName; + static const u8 fakeSortOrder = 0; +#ifdef SQLITE_DEBUG + int nRealCol; + if( pTab->tabFlags & TF_WithoutRowid ){ + nRealCol = sqlite3PrimaryKeyIndex(pTab)->nColumn; + }else if( pTab->tabFlags & TF_HasVirtual ){ + nRealCol = pTab->nNVCol; + }else{ + nRealCol = pTab->nCol; + } +#endif + + assert( db->pPreUpdate==0 ); + memset(&preupdate, 0, sizeof(PreUpdate)); + if( HasRowid(pTab)==0 ){ + iKey1 = iKey2 = 0; + preupdate.pPk = sqlite3PrimaryKeyIndex(pTab); + }else{ + if( op==SQLITE_UPDATE ){ + iKey2 = v->aMem[iReg].u.i; + }else{ + iKey2 = iKey1; + } + } + + assert( pCsr!=0 ); + assert( pCsr->eCurType==CURTYPE_BTREE ); + assert( pCsr->nField==nRealCol + || (pCsr->nField==nRealCol+1 && op==SQLITE_DELETE && iReg==-1) + ); + + preupdate.v = v; + preupdate.pCsr = pCsr; + preupdate.op = op; + preupdate.iNewReg = iReg; + preupdate.keyinfo.db = db; + preupdate.keyinfo.enc = ENC(db); + preupdate.keyinfo.nKeyField = pTab->nCol; + preupdate.keyinfo.aSortFlags = (u8*)&fakeSortOrder; + preupdate.iKey1 = iKey1; + preupdate.iKey2 = iKey2; + preupdate.pTab = pTab; + preupdate.iBlobWrite = iBlobWrite; + + db->pPreUpdate = &preupdate; + db->xPreUpdateCallback(db->pPreUpdateArg, db, op, zDb, zTbl, iKey1, iKey2); + db->pPreUpdate = 0; + sqlite3DbFree(db, preupdate.aRecord); + vdbeFreeUnpacked(db, preupdate.keyinfo.nKeyField+1, preupdate.pUnpacked); + vdbeFreeUnpacked(db, preupdate.keyinfo.nKeyField+1, preupdate.pNewUnpacked); + if( preupdate.aNew ){ + int i; + for(i=0; inField; i++){ + sqlite3VdbeMemRelease(&preupdate.aNew[i]); + } + sqlite3DbNNFreeNN(db, preupdate.aNew); + } +} +#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ + +/************** End of vdbeaux.c *********************************************/ +/************** Begin file vdbeapi.c *****************************************/ +/* +** 2004 May 26 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains code use to implement APIs that are part of the +** VDBE. +*/ +/* #include "sqliteInt.h" */ +/* #include "vdbeInt.h" */ +/* #include "opcodes.h" */ + +#ifndef SQLITE_OMIT_DEPRECATED +/* +** Return TRUE (non-zero) of the statement supplied as an argument needs +** to be recompiled. A statement needs to be recompiled whenever the +** execution environment changes in a way that would alter the program +** that sqlite3_prepare() generates. For example, if new functions or +** collating sequences are registered or if an authorizer function is +** added or changed. +*/ +SQLITE_API int sqlite3_expired(sqlite3_stmt *pStmt){ + Vdbe *p = (Vdbe*)pStmt; + return p==0 || p->expired; +} +#endif + +/* +** Check on a Vdbe to make sure it has not been finalized. Log +** an error and return true if it has been finalized (or is otherwise +** invalid). Return false if it is ok. +*/ +static int vdbeSafety(Vdbe *p){ + if( p->db==0 ){ + sqlite3_log(SQLITE_MISUSE, "API called with finalized prepared statement"); + return 1; + }else{ + return 0; + } +} +static int vdbeSafetyNotNull(Vdbe *p){ + if( p==0 ){ + sqlite3_log(SQLITE_MISUSE, "API called with NULL prepared statement"); + return 1; + }else{ + return vdbeSafety(p); + } +} + +#ifndef SQLITE_OMIT_TRACE +/* +** Invoke the profile callback. This routine is only called if we already +** know that the profile callback is defined and needs to be invoked. +*/ +static SQLITE_NOINLINE void invokeProfileCallback(sqlite3 *db, Vdbe *p){ + sqlite3_int64 iNow; + sqlite3_int64 iElapse; + assert( p->startTime>0 ); + assert( (db->mTrace & (SQLITE_TRACE_PROFILE|SQLITE_TRACE_XPROFILE))!=0 ); + assert( db->init.busy==0 ); + assert( p->zSql!=0 ); + sqlite3OsCurrentTimeInt64(db->pVfs, &iNow); + iElapse = (iNow - p->startTime)*1000000; +#ifndef SQLITE_OMIT_DEPRECATED + if( db->xProfile ){ + db->xProfile(db->pProfileArg, p->zSql, iElapse); + } +#endif + if( db->mTrace & SQLITE_TRACE_PROFILE ){ + db->trace.xV2(SQLITE_TRACE_PROFILE, db->pTraceArg, p, (void*)&iElapse); + } + p->startTime = 0; +} +/* +** The checkProfileCallback(DB,P) macro checks to see if a profile callback +** is needed, and it invokes the callback if it is needed. +*/ +# define checkProfileCallback(DB,P) \ + if( ((P)->startTime)>0 ){ invokeProfileCallback(DB,P); } +#else +# define checkProfileCallback(DB,P) /*no-op*/ +#endif + +/* +** The following routine destroys a virtual machine that is created by +** the sqlite3_compile() routine. The integer returned is an SQLITE_ +** success/failure code that describes the result of executing the virtual +** machine. +** +** This routine sets the error code and string returned by +** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16(). +*/ +SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt){ + int rc; + if( pStmt==0 ){ + /* IMPLEMENTATION-OF: R-57228-12904 Invoking sqlite3_finalize() on a NULL + ** pointer is a harmless no-op. */ + rc = SQLITE_OK; + }else{ + Vdbe *v = (Vdbe*)pStmt; + sqlite3 *db = v->db; + if( vdbeSafety(v) ) return SQLITE_MISUSE_BKPT; + sqlite3_mutex_enter(db->mutex); + checkProfileCallback(db, v); + assert( v->eVdbeState>=VDBE_READY_STATE ); + rc = sqlite3VdbeReset(v); + sqlite3VdbeDelete(v); + rc = sqlite3ApiExit(db, rc); + sqlite3LeaveMutexAndCloseZombie(db); + } + return rc; +} + +/* +** Terminate the current execution of an SQL statement and reset it +** back to its starting state so that it can be reused. A success code from +** the prior execution is returned. +** +** This routine sets the error code and string returned by +** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16(). +*/ +SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt){ + int rc; + if( pStmt==0 ){ + rc = SQLITE_OK; + }else{ + Vdbe *v = (Vdbe*)pStmt; + sqlite3 *db = v->db; + sqlite3_mutex_enter(db->mutex); + checkProfileCallback(db, v); + rc = sqlite3VdbeReset(v); + sqlite3VdbeRewind(v); + assert( (rc & (db->errMask))==rc ); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + } + return rc; +} + +/* +** Set all the parameters in the compiled SQL statement to NULL. +*/ +SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt *pStmt){ + int i; + int rc = SQLITE_OK; + Vdbe *p = (Vdbe*)pStmt; +#if SQLITE_THREADSAFE + sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex; +#endif + sqlite3_mutex_enter(mutex); + for(i=0; inVar; i++){ + sqlite3VdbeMemRelease(&p->aVar[i]); + p->aVar[i].flags = MEM_Null; + } + assert( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || p->expmask==0 ); + if( p->expmask ){ + p->expired = 1; + } + sqlite3_mutex_leave(mutex); + return rc; +} + + +/**************************** sqlite3_value_ ******************************* +** The following routines extract information from a Mem or sqlite3_value +** structure. +*/ +SQLITE_API const void *sqlite3_value_blob(sqlite3_value *pVal){ + Mem *p = (Mem*)pVal; + if( p->flags & (MEM_Blob|MEM_Str) ){ + if( ExpandBlob(p)!=SQLITE_OK ){ + assert( p->flags==MEM_Null && p->z==0 ); + return 0; + } + p->flags |= MEM_Blob; + return p->n ? p->z : 0; + }else{ + return sqlite3_value_text(pVal); + } +} +SQLITE_API int sqlite3_value_bytes(sqlite3_value *pVal){ + return sqlite3ValueBytes(pVal, SQLITE_UTF8); +} +SQLITE_API int sqlite3_value_bytes16(sqlite3_value *pVal){ + return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE); +} +SQLITE_API double sqlite3_value_double(sqlite3_value *pVal){ + return sqlite3VdbeRealValue((Mem*)pVal); +} +SQLITE_API int sqlite3_value_int(sqlite3_value *pVal){ + return (int)sqlite3VdbeIntValue((Mem*)pVal); +} +SQLITE_API sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){ + return sqlite3VdbeIntValue((Mem*)pVal); +} +SQLITE_API unsigned int sqlite3_value_subtype(sqlite3_value *pVal){ + Mem *pMem = (Mem*)pVal; + return ((pMem->flags & MEM_Subtype) ? pMem->eSubtype : 0); +} +SQLITE_API void *sqlite3_value_pointer(sqlite3_value *pVal, const char *zPType){ + Mem *p = (Mem*)pVal; + if( (p->flags&(MEM_TypeMask|MEM_Term|MEM_Subtype)) == + (MEM_Null|MEM_Term|MEM_Subtype) + && zPType!=0 + && p->eSubtype=='p' + && strcmp(p->u.zPType, zPType)==0 + ){ + return (void*)p->z; + }else{ + return 0; + } +} +SQLITE_API const unsigned char *sqlite3_value_text(sqlite3_value *pVal){ + return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8); +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API const void *sqlite3_value_text16(sqlite3_value* pVal){ + return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE); +} +SQLITE_API const void *sqlite3_value_text16be(sqlite3_value *pVal){ + return sqlite3ValueText(pVal, SQLITE_UTF16BE); +} +SQLITE_API const void *sqlite3_value_text16le(sqlite3_value *pVal){ + return sqlite3ValueText(pVal, SQLITE_UTF16LE); +} +#endif /* SQLITE_OMIT_UTF16 */ +/* EVIDENCE-OF: R-12793-43283 Every value in SQLite has one of five +** fundamental datatypes: 64-bit signed integer 64-bit IEEE floating +** point number string BLOB NULL +*/ +SQLITE_API int sqlite3_value_type(sqlite3_value* pVal){ + static const u8 aType[] = { + SQLITE_BLOB, /* 0x00 (not possible) */ + SQLITE_NULL, /* 0x01 NULL */ + SQLITE_TEXT, /* 0x02 TEXT */ + SQLITE_NULL, /* 0x03 (not possible) */ + SQLITE_INTEGER, /* 0x04 INTEGER */ + SQLITE_NULL, /* 0x05 (not possible) */ + SQLITE_INTEGER, /* 0x06 INTEGER + TEXT */ + SQLITE_NULL, /* 0x07 (not possible) */ + SQLITE_FLOAT, /* 0x08 FLOAT */ + SQLITE_NULL, /* 0x09 (not possible) */ + SQLITE_FLOAT, /* 0x0a FLOAT + TEXT */ + SQLITE_NULL, /* 0x0b (not possible) */ + SQLITE_INTEGER, /* 0x0c (not possible) */ + SQLITE_NULL, /* 0x0d (not possible) */ + SQLITE_INTEGER, /* 0x0e (not possible) */ + SQLITE_NULL, /* 0x0f (not possible) */ + SQLITE_BLOB, /* 0x10 BLOB */ + SQLITE_NULL, /* 0x11 (not possible) */ + SQLITE_TEXT, /* 0x12 (not possible) */ + SQLITE_NULL, /* 0x13 (not possible) */ + SQLITE_INTEGER, /* 0x14 INTEGER + BLOB */ + SQLITE_NULL, /* 0x15 (not possible) */ + SQLITE_INTEGER, /* 0x16 (not possible) */ + SQLITE_NULL, /* 0x17 (not possible) */ + SQLITE_FLOAT, /* 0x18 FLOAT + BLOB */ + SQLITE_NULL, /* 0x19 (not possible) */ + SQLITE_FLOAT, /* 0x1a (not possible) */ + SQLITE_NULL, /* 0x1b (not possible) */ + SQLITE_INTEGER, /* 0x1c (not possible) */ + SQLITE_NULL, /* 0x1d (not possible) */ + SQLITE_INTEGER, /* 0x1e (not possible) */ + SQLITE_NULL, /* 0x1f (not possible) */ + SQLITE_FLOAT, /* 0x20 INTREAL */ + SQLITE_NULL, /* 0x21 (not possible) */ + SQLITE_FLOAT, /* 0x22 INTREAL + TEXT */ + SQLITE_NULL, /* 0x23 (not possible) */ + SQLITE_FLOAT, /* 0x24 (not possible) */ + SQLITE_NULL, /* 0x25 (not possible) */ + SQLITE_FLOAT, /* 0x26 (not possible) */ + SQLITE_NULL, /* 0x27 (not possible) */ + SQLITE_FLOAT, /* 0x28 (not possible) */ + SQLITE_NULL, /* 0x29 (not possible) */ + SQLITE_FLOAT, /* 0x2a (not possible) */ + SQLITE_NULL, /* 0x2b (not possible) */ + SQLITE_FLOAT, /* 0x2c (not possible) */ + SQLITE_NULL, /* 0x2d (not possible) */ + SQLITE_FLOAT, /* 0x2e (not possible) */ + SQLITE_NULL, /* 0x2f (not possible) */ + SQLITE_BLOB, /* 0x30 (not possible) */ + SQLITE_NULL, /* 0x31 (not possible) */ + SQLITE_TEXT, /* 0x32 (not possible) */ + SQLITE_NULL, /* 0x33 (not possible) */ + SQLITE_FLOAT, /* 0x34 (not possible) */ + SQLITE_NULL, /* 0x35 (not possible) */ + SQLITE_FLOAT, /* 0x36 (not possible) */ + SQLITE_NULL, /* 0x37 (not possible) */ + SQLITE_FLOAT, /* 0x38 (not possible) */ + SQLITE_NULL, /* 0x39 (not possible) */ + SQLITE_FLOAT, /* 0x3a (not possible) */ + SQLITE_NULL, /* 0x3b (not possible) */ + SQLITE_FLOAT, /* 0x3c (not possible) */ + SQLITE_NULL, /* 0x3d (not possible) */ + SQLITE_FLOAT, /* 0x3e (not possible) */ + SQLITE_NULL, /* 0x3f (not possible) */ + }; +#ifdef SQLITE_DEBUG + { + int eType = SQLITE_BLOB; + if( pVal->flags & MEM_Null ){ + eType = SQLITE_NULL; + }else if( pVal->flags & (MEM_Real|MEM_IntReal) ){ + eType = SQLITE_FLOAT; + }else if( pVal->flags & MEM_Int ){ + eType = SQLITE_INTEGER; + }else if( pVal->flags & MEM_Str ){ + eType = SQLITE_TEXT; + } + assert( eType == aType[pVal->flags&MEM_AffMask] ); + } +#endif + return aType[pVal->flags&MEM_AffMask]; +} +SQLITE_API int sqlite3_value_encoding(sqlite3_value *pVal){ + return pVal->enc; +} + +/* Return true if a parameter to xUpdate represents an unchanged column */ +SQLITE_API int sqlite3_value_nochange(sqlite3_value *pVal){ + return (pVal->flags&(MEM_Null|MEM_Zero))==(MEM_Null|MEM_Zero); +} + +/* Return true if a parameter value originated from an sqlite3_bind() */ +SQLITE_API int sqlite3_value_frombind(sqlite3_value *pVal){ + return (pVal->flags&MEM_FromBind)!=0; +} + +/* Make a copy of an sqlite3_value object +*/ +SQLITE_API sqlite3_value *sqlite3_value_dup(const sqlite3_value *pOrig){ + sqlite3_value *pNew; + if( pOrig==0 ) return 0; + pNew = sqlite3_malloc( sizeof(*pNew) ); + if( pNew==0 ) return 0; + memset(pNew, 0, sizeof(*pNew)); + memcpy(pNew, pOrig, MEMCELLSIZE); + pNew->flags &= ~MEM_Dyn; + pNew->db = 0; + if( pNew->flags&(MEM_Str|MEM_Blob) ){ + pNew->flags &= ~(MEM_Static|MEM_Dyn); + pNew->flags |= MEM_Ephem; + if( sqlite3VdbeMemMakeWriteable(pNew)!=SQLITE_OK ){ + sqlite3ValueFree(pNew); + pNew = 0; + } + }else if( pNew->flags & MEM_Null ){ + /* Do not duplicate pointer values */ + pNew->flags &= ~(MEM_Term|MEM_Subtype); + } + return pNew; +} + +/* Destroy an sqlite3_value object previously obtained from +** sqlite3_value_dup(). +*/ +SQLITE_API void sqlite3_value_free(sqlite3_value *pOld){ + sqlite3ValueFree(pOld); +} + + +/**************************** sqlite3_result_ ******************************* +** The following routines are used by user-defined functions to specify +** the function result. +** +** The setStrOrError() function calls sqlite3VdbeMemSetStr() to store the +** result as a string or blob. Appropriate errors are set if the string/blob +** is too big or if an OOM occurs. +** +** The invokeValueDestructor(P,X) routine invokes destructor function X() +** on value P is not going to be used and need to be destroyed. +*/ +static void setResultStrOrError( + sqlite3_context *pCtx, /* Function context */ + const char *z, /* String pointer */ + int n, /* Bytes in string, or negative */ + u8 enc, /* Encoding of z. 0 for BLOBs */ + void (*xDel)(void*) /* Destructor function */ +){ + Mem *pOut = pCtx->pOut; + int rc = sqlite3VdbeMemSetStr(pOut, z, n, enc, xDel); + if( rc ){ + if( rc==SQLITE_TOOBIG ){ + sqlite3_result_error_toobig(pCtx); + }else{ + /* The only errors possible from sqlite3VdbeMemSetStr are + ** SQLITE_TOOBIG and SQLITE_NOMEM */ + assert( rc==SQLITE_NOMEM ); + sqlite3_result_error_nomem(pCtx); + } + return; + } + sqlite3VdbeChangeEncoding(pOut, pCtx->enc); + if( sqlite3VdbeMemTooBig(pOut) ){ + sqlite3_result_error_toobig(pCtx); + } +} +static int invokeValueDestructor( + const void *p, /* Value to destroy */ + void (*xDel)(void*), /* The destructor */ + sqlite3_context *pCtx /* Set a SQLITE_TOOBIG error if no NULL */ +){ + assert( xDel!=SQLITE_DYNAMIC ); + if( xDel==0 ){ + /* noop */ + }else if( xDel==SQLITE_TRANSIENT ){ + /* noop */ + }else{ + xDel((void*)p); + } + sqlite3_result_error_toobig(pCtx); + return SQLITE_TOOBIG; +} +SQLITE_API void sqlite3_result_blob( + sqlite3_context *pCtx, + const void *z, + int n, + void (*xDel)(void *) +){ + assert( n>=0 ); + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + setResultStrOrError(pCtx, z, n, 0, xDel); +} +SQLITE_API void sqlite3_result_blob64( + sqlite3_context *pCtx, + const void *z, + sqlite3_uint64 n, + void (*xDel)(void *) +){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + assert( xDel!=SQLITE_DYNAMIC ); + if( n>0x7fffffff ){ + (void)invokeValueDestructor(z, xDel, pCtx); + }else{ + setResultStrOrError(pCtx, z, (int)n, 0, xDel); + } +} +SQLITE_API void sqlite3_result_double(sqlite3_context *pCtx, double rVal){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + sqlite3VdbeMemSetDouble(pCtx->pOut, rVal); +} +SQLITE_API void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + pCtx->isError = SQLITE_ERROR; + sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF8, SQLITE_TRANSIENT); +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + pCtx->isError = SQLITE_ERROR; + sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT); +} +#endif +SQLITE_API void sqlite3_result_int(sqlite3_context *pCtx, int iVal){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + sqlite3VdbeMemSetInt64(pCtx->pOut, (i64)iVal); +} +SQLITE_API void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + sqlite3VdbeMemSetInt64(pCtx->pOut, iVal); +} +SQLITE_API void sqlite3_result_null(sqlite3_context *pCtx){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + sqlite3VdbeMemSetNull(pCtx->pOut); +} +SQLITE_API void sqlite3_result_pointer( + sqlite3_context *pCtx, + void *pPtr, + const char *zPType, + void (*xDestructor)(void*) +){ + Mem *pOut = pCtx->pOut; + assert( sqlite3_mutex_held(pOut->db->mutex) ); + sqlite3VdbeMemRelease(pOut); + pOut->flags = MEM_Null; + sqlite3VdbeMemSetPointer(pOut, pPtr, zPType, xDestructor); +} +SQLITE_API void sqlite3_result_subtype(sqlite3_context *pCtx, unsigned int eSubtype){ + Mem *pOut = pCtx->pOut; + assert( sqlite3_mutex_held(pOut->db->mutex) ); + pOut->eSubtype = eSubtype & 0xff; + pOut->flags |= MEM_Subtype; +} +SQLITE_API void sqlite3_result_text( + sqlite3_context *pCtx, + const char *z, + int n, + void (*xDel)(void *) +){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + setResultStrOrError(pCtx, z, n, SQLITE_UTF8, xDel); +} +SQLITE_API void sqlite3_result_text64( + sqlite3_context *pCtx, + const char *z, + sqlite3_uint64 n, + void (*xDel)(void *), + unsigned char enc +){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + assert( xDel!=SQLITE_DYNAMIC ); + if( enc!=SQLITE_UTF8 ){ + if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE; + n &= ~(u64)1; + } + if( n>0x7fffffff ){ + (void)invokeValueDestructor(z, xDel, pCtx); + }else{ + setResultStrOrError(pCtx, z, (int)n, enc, xDel); + } +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API void sqlite3_result_text16( + sqlite3_context *pCtx, + const void *z, + int n, + void (*xDel)(void *) +){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + setResultStrOrError(pCtx, z, n & ~(u64)1, SQLITE_UTF16NATIVE, xDel); +} +SQLITE_API void sqlite3_result_text16be( + sqlite3_context *pCtx, + const void *z, + int n, + void (*xDel)(void *) +){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + setResultStrOrError(pCtx, z, n & ~(u64)1, SQLITE_UTF16BE, xDel); +} +SQLITE_API void sqlite3_result_text16le( + sqlite3_context *pCtx, + const void *z, + int n, + void (*xDel)(void *) +){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + setResultStrOrError(pCtx, z, n & ~(u64)1, SQLITE_UTF16LE, xDel); +} +#endif /* SQLITE_OMIT_UTF16 */ +SQLITE_API void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){ + Mem *pOut = pCtx->pOut; + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + sqlite3VdbeMemCopy(pOut, pValue); + sqlite3VdbeChangeEncoding(pOut, pCtx->enc); + if( sqlite3VdbeMemTooBig(pOut) ){ + sqlite3_result_error_toobig(pCtx); + } +} +SQLITE_API void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){ + sqlite3_result_zeroblob64(pCtx, n>0 ? n : 0); +} +SQLITE_API int sqlite3_result_zeroblob64(sqlite3_context *pCtx, u64 n){ + Mem *pOut = pCtx->pOut; + assert( sqlite3_mutex_held(pOut->db->mutex) ); + if( n>(u64)pOut->db->aLimit[SQLITE_LIMIT_LENGTH] ){ + sqlite3_result_error_toobig(pCtx); + return SQLITE_TOOBIG; + } +#ifndef SQLITE_OMIT_INCRBLOB + sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n); + return SQLITE_OK; +#else + return sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n); +#endif +} +SQLITE_API void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){ + pCtx->isError = errCode ? errCode : -1; +#ifdef SQLITE_DEBUG + if( pCtx->pVdbe ) pCtx->pVdbe->rcApp = errCode; +#endif + if( pCtx->pOut->flags & MEM_Null ){ + setResultStrOrError(pCtx, sqlite3ErrStr(errCode), -1, SQLITE_UTF8, + SQLITE_STATIC); + } +} + +/* Force an SQLITE_TOOBIG error. */ +SQLITE_API void sqlite3_result_error_toobig(sqlite3_context *pCtx){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + pCtx->isError = SQLITE_TOOBIG; + sqlite3VdbeMemSetStr(pCtx->pOut, "string or blob too big", -1, + SQLITE_UTF8, SQLITE_STATIC); +} + +/* An SQLITE_NOMEM error. */ +SQLITE_API void sqlite3_result_error_nomem(sqlite3_context *pCtx){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + sqlite3VdbeMemSetNull(pCtx->pOut); + pCtx->isError = SQLITE_NOMEM_BKPT; + sqlite3OomFault(pCtx->pOut->db); +} + +#ifndef SQLITE_UNTESTABLE +/* Force the INT64 value currently stored as the result to be +** a MEM_IntReal value. See the SQLITE_TESTCTRL_RESULT_INTREAL +** test-control. +*/ +SQLITE_PRIVATE void sqlite3ResultIntReal(sqlite3_context *pCtx){ + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); + if( pCtx->pOut->flags & MEM_Int ){ + pCtx->pOut->flags &= ~MEM_Int; + pCtx->pOut->flags |= MEM_IntReal; + } +} +#endif + + +/* +** This function is called after a transaction has been committed. It +** invokes callbacks registered with sqlite3_wal_hook() as required. +*/ +static int doWalCallbacks(sqlite3 *db){ + int rc = SQLITE_OK; +#ifndef SQLITE_OMIT_WAL + int i; + for(i=0; inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + int nEntry; + sqlite3BtreeEnter(pBt); + nEntry = sqlite3PagerWalCallback(sqlite3BtreePager(pBt)); + sqlite3BtreeLeave(pBt); + if( nEntry>0 && db->xWalCallback && rc==SQLITE_OK ){ + rc = db->xWalCallback(db->pWalArg, db, db->aDb[i].zDbSName, nEntry); + } + } + } +#endif + return rc; +} + + +/* +** Execute the statement pStmt, either until a row of data is ready, the +** statement is completely executed or an error occurs. +** +** This routine implements the bulk of the logic behind the sqlite_step() +** API. The only thing omitted is the automatic recompile if a +** schema change has occurred. That detail is handled by the +** outer sqlite3_step() wrapper procedure. +*/ +static int sqlite3Step(Vdbe *p){ + sqlite3 *db; + int rc; + + assert(p); + db = p->db; + if( p->eVdbeState!=VDBE_RUN_STATE ){ + restart_step: + if( p->eVdbeState==VDBE_READY_STATE ){ + if( p->expired ){ + p->rc = SQLITE_SCHEMA; + rc = SQLITE_ERROR; + if( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 ){ + /* If this statement was prepared using saved SQL and an + ** error has occurred, then return the error code in p->rc to the + ** caller. Set the error code in the database handle to the same + ** value. + */ + rc = sqlite3VdbeTransferError(p); + } + goto end_of_step; + } + + /* If there are no other statements currently running, then + ** reset the interrupt flag. This prevents a call to sqlite3_interrupt + ** from interrupting a statement that has not yet started. + */ + if( db->nVdbeActive==0 ){ + AtomicStore(&db->u1.isInterrupted, 0); + } + + assert( db->nVdbeWrite>0 || db->autoCommit==0 + || (db->nDeferredCons==0 && db->nDeferredImmCons==0) + ); + +#ifndef SQLITE_OMIT_TRACE + if( (db->mTrace & (SQLITE_TRACE_PROFILE|SQLITE_TRACE_XPROFILE))!=0 + && !db->init.busy && p->zSql ){ + sqlite3OsCurrentTimeInt64(db->pVfs, &p->startTime); + }else{ + assert( p->startTime==0 ); + } +#endif + + db->nVdbeActive++; + if( p->readOnly==0 ) db->nVdbeWrite++; + if( p->bIsReader ) db->nVdbeRead++; + p->pc = 0; + p->eVdbeState = VDBE_RUN_STATE; + }else + + if( ALWAYS(p->eVdbeState==VDBE_HALT_STATE) ){ + /* We used to require that sqlite3_reset() be called before retrying + ** sqlite3_step() after any error or after SQLITE_DONE. But beginning + ** with version 3.7.0, we changed this so that sqlite3_reset() would + ** be called automatically instead of throwing the SQLITE_MISUSE error. + ** This "automatic-reset" change is not technically an incompatibility, + ** since any application that receives an SQLITE_MISUSE is broken by + ** definition. + ** + ** Nevertheless, some published applications that were originally written + ** for version 3.6.23 or earlier do in fact depend on SQLITE_MISUSE + ** returns, and those were broken by the automatic-reset change. As a + ** a work-around, the SQLITE_OMIT_AUTORESET compile-time restores the + ** legacy behavior of returning SQLITE_MISUSE for cases where the + ** previous sqlite3_step() returned something other than a SQLITE_LOCKED + ** or SQLITE_BUSY error. + */ +#ifdef SQLITE_OMIT_AUTORESET + if( (rc = p->rc&0xff)==SQLITE_BUSY || rc==SQLITE_LOCKED ){ + sqlite3_reset((sqlite3_stmt*)p); + }else{ + return SQLITE_MISUSE_BKPT; + } +#else + sqlite3_reset((sqlite3_stmt*)p); +#endif + assert( p->eVdbeState==VDBE_READY_STATE ); + goto restart_step; + } + } + +#ifdef SQLITE_DEBUG + p->rcApp = SQLITE_OK; +#endif +#ifndef SQLITE_OMIT_EXPLAIN + if( p->explain ){ + rc = sqlite3VdbeList(p); + }else +#endif /* SQLITE_OMIT_EXPLAIN */ + { + db->nVdbeExec++; + rc = sqlite3VdbeExec(p); + db->nVdbeExec--; + } + + if( rc==SQLITE_ROW ){ + assert( p->rc==SQLITE_OK ); + assert( db->mallocFailed==0 ); + db->errCode = SQLITE_ROW; + return SQLITE_ROW; + }else{ +#ifndef SQLITE_OMIT_TRACE + /* If the statement completed successfully, invoke the profile callback */ + checkProfileCallback(db, p); +#endif + p->pResultRow = 0; + if( rc==SQLITE_DONE && db->autoCommit ){ + assert( p->rc==SQLITE_OK ); + p->rc = doWalCallbacks(db); + if( p->rc!=SQLITE_OK ){ + rc = SQLITE_ERROR; + } + }else if( rc!=SQLITE_DONE && (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 ){ + /* If this statement was prepared using saved SQL and an + ** error has occurred, then return the error code in p->rc to the + ** caller. Set the error code in the database handle to the same value. + */ + rc = sqlite3VdbeTransferError(p); + } + } + + db->errCode = rc; + if( SQLITE_NOMEM==sqlite3ApiExit(p->db, p->rc) ){ + p->rc = SQLITE_NOMEM_BKPT; + if( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 ) rc = p->rc; + } +end_of_step: + /* There are only a limited number of result codes allowed from the + ** statements prepared using the legacy sqlite3_prepare() interface */ + assert( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 + || rc==SQLITE_ROW || rc==SQLITE_DONE || rc==SQLITE_ERROR + || (rc&0xff)==SQLITE_BUSY || rc==SQLITE_MISUSE + ); + return (rc&db->errMask); +} + +/* +** This is the top-level implementation of sqlite3_step(). Call +** sqlite3Step() to do most of the work. If a schema error occurs, +** call sqlite3Reprepare() and try again. +*/ +SQLITE_API int sqlite3_step(sqlite3_stmt *pStmt){ + int rc = SQLITE_OK; /* Result from sqlite3Step() */ + Vdbe *v = (Vdbe*)pStmt; /* the prepared statement */ + int cnt = 0; /* Counter to prevent infinite loop of reprepares */ + sqlite3 *db; /* The database connection */ + + if( vdbeSafetyNotNull(v) ){ + return SQLITE_MISUSE_BKPT; + } + db = v->db; + sqlite3_mutex_enter(db->mutex); + while( (rc = sqlite3Step(v))==SQLITE_SCHEMA + && cnt++ < SQLITE_MAX_SCHEMA_RETRY ){ + int savedPc = v->pc; + rc = sqlite3Reprepare(v); + if( rc!=SQLITE_OK ){ + /* This case occurs after failing to recompile an sql statement. + ** The error message from the SQL compiler has already been loaded + ** into the database handle. This block copies the error message + ** from the database handle into the statement and sets the statement + ** program counter to 0 to ensure that when the statement is + ** finalized or reset the parser error message is available via + ** sqlite3_errmsg() and sqlite3_errcode(). + */ + const char *zErr = (const char *)sqlite3_value_text(db->pErr); + sqlite3DbFree(db, v->zErrMsg); + if( !db->mallocFailed ){ + v->zErrMsg = sqlite3DbStrDup(db, zErr); + v->rc = rc = sqlite3ApiExit(db, rc); + } else { + v->zErrMsg = 0; + v->rc = rc = SQLITE_NOMEM_BKPT; + } + break; + } + sqlite3_reset(pStmt); + if( savedPc>=0 ){ + /* Setting minWriteFileFormat to 254 is a signal to the OP_Init and + ** OP_Trace opcodes to *not* perform SQLITE_TRACE_STMT because it has + ** already been done once on a prior invocation that failed due to + ** SQLITE_SCHEMA. tag-20220401a */ + v->minWriteFileFormat = 254; + } + assert( v->expired==0 ); + } + sqlite3_mutex_leave(db->mutex); + return rc; +} + + +/* +** Extract the user data from a sqlite3_context structure and return a +** pointer to it. +*/ +SQLITE_API void *sqlite3_user_data(sqlite3_context *p){ + assert( p && p->pFunc ); + return p->pFunc->pUserData; +} + +/* +** Extract the user data from a sqlite3_context structure and return a +** pointer to it. +** +** IMPLEMENTATION-OF: R-46798-50301 The sqlite3_context_db_handle() interface +** returns a copy of the pointer to the database connection (the 1st +** parameter) of the sqlite3_create_function() and +** sqlite3_create_function16() routines that originally registered the +** application defined function. +*/ +SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context *p){ + assert( p && p->pOut ); + return p->pOut->db; +} + +/* +** If this routine is invoked from within an xColumn method of a virtual +** table, then it returns true if and only if the the call is during an +** UPDATE operation and the value of the column will not be modified +** by the UPDATE. +** +** If this routine is called from any context other than within the +** xColumn method of a virtual table, then the return value is meaningless +** and arbitrary. +** +** Virtual table implements might use this routine to optimize their +** performance by substituting a NULL result, or some other light-weight +** value, as a signal to the xUpdate routine that the column is unchanged. +*/ +SQLITE_API int sqlite3_vtab_nochange(sqlite3_context *p){ + assert( p ); + return sqlite3_value_nochange(p->pOut); +} + +/* +** The destructor function for a ValueList object. This needs to be +** a separate function, unknowable to the application, to ensure that +** calls to sqlite3_vtab_in_first()/sqlite3_vtab_in_next() that are not +** preceeded by activation of IN processing via sqlite3_vtab_int() do not +** try to access a fake ValueList object inserted by a hostile extension. +*/ +SQLITE_PRIVATE void sqlite3VdbeValueListFree(void *pToDelete){ + sqlite3_free(pToDelete); +} + +/* +** Implementation of sqlite3_vtab_in_first() (if bNext==0) and +** sqlite3_vtab_in_next() (if bNext!=0). +*/ +static int valueFromValueList( + sqlite3_value *pVal, /* Pointer to the ValueList object */ + sqlite3_value **ppOut, /* Store the next value from the list here */ + int bNext /* 1 for _next(). 0 for _first() */ +){ + int rc; + ValueList *pRhs; + + *ppOut = 0; + if( pVal==0 ) return SQLITE_MISUSE; + if( (pVal->flags & MEM_Dyn)==0 || pVal->xDel!=sqlite3VdbeValueListFree ){ + return SQLITE_ERROR; + }else{ + assert( (pVal->flags&(MEM_TypeMask|MEM_Term|MEM_Subtype)) == + (MEM_Null|MEM_Term|MEM_Subtype) ); + assert( pVal->eSubtype=='p' ); + assert( pVal->u.zPType!=0 && strcmp(pVal->u.zPType,"ValueList")==0 ); + pRhs = (ValueList*)pVal->z; + } + if( bNext ){ + rc = sqlite3BtreeNext(pRhs->pCsr, 0); + }else{ + int dummy = 0; + rc = sqlite3BtreeFirst(pRhs->pCsr, &dummy); + assert( rc==SQLITE_OK || sqlite3BtreeEof(pRhs->pCsr) ); + if( sqlite3BtreeEof(pRhs->pCsr) ) rc = SQLITE_DONE; + } + if( rc==SQLITE_OK ){ + u32 sz; /* Size of current row in bytes */ + Mem sMem; /* Raw content of current row */ + memset(&sMem, 0, sizeof(sMem)); + sz = sqlite3BtreePayloadSize(pRhs->pCsr); + rc = sqlite3VdbeMemFromBtreeZeroOffset(pRhs->pCsr,(int)sz,&sMem); + if( rc==SQLITE_OK ){ + u8 *zBuf = (u8*)sMem.z; + u32 iSerial; + sqlite3_value *pOut = pRhs->pOut; + int iOff = 1 + getVarint32(&zBuf[1], iSerial); + sqlite3VdbeSerialGet(&zBuf[iOff], iSerial, pOut); + pOut->enc = ENC(pOut->db); + if( (pOut->flags & MEM_Ephem)!=0 && sqlite3VdbeMemMakeWriteable(pOut) ){ + rc = SQLITE_NOMEM; + }else{ + *ppOut = pOut; + } + } + sqlite3VdbeMemRelease(&sMem); + } + return rc; +} + +/* +** Set the iterator value pVal to point to the first value in the set. +** Set (*ppOut) to point to this value before returning. +*/ +SQLITE_API int sqlite3_vtab_in_first(sqlite3_value *pVal, sqlite3_value **ppOut){ + return valueFromValueList(pVal, ppOut, 0); +} + +/* +** Set the iterator value pVal to point to the next value in the set. +** Set (*ppOut) to point to this value before returning. +*/ +SQLITE_API int sqlite3_vtab_in_next(sqlite3_value *pVal, sqlite3_value **ppOut){ + return valueFromValueList(pVal, ppOut, 1); +} + +/* +** Return the current time for a statement. If the current time +** is requested more than once within the same run of a single prepared +** statement, the exact same time is returned for each invocation regardless +** of the amount of time that elapses between invocations. In other words, +** the time returned is always the time of the first call. +*/ +SQLITE_PRIVATE sqlite3_int64 sqlite3StmtCurrentTime(sqlite3_context *p){ + int rc; +#ifndef SQLITE_ENABLE_STAT4 + sqlite3_int64 *piTime = &p->pVdbe->iCurrentTime; + assert( p->pVdbe!=0 ); +#else + sqlite3_int64 iTime = 0; + sqlite3_int64 *piTime = p->pVdbe!=0 ? &p->pVdbe->iCurrentTime : &iTime; +#endif + if( *piTime==0 ){ + rc = sqlite3OsCurrentTimeInt64(p->pOut->db->pVfs, piTime); + if( rc ) *piTime = 0; + } + return *piTime; +} + +/* +** Create a new aggregate context for p and return a pointer to +** its pMem->z element. +*/ +static SQLITE_NOINLINE void *createAggContext(sqlite3_context *p, int nByte){ + Mem *pMem = p->pMem; + assert( (pMem->flags & MEM_Agg)==0 ); + if( nByte<=0 ){ + sqlite3VdbeMemSetNull(pMem); + pMem->z = 0; + }else{ + sqlite3VdbeMemClearAndResize(pMem, nByte); + pMem->flags = MEM_Agg; + pMem->u.pDef = p->pFunc; + if( pMem->z ){ + memset(pMem->z, 0, nByte); + } + } + return (void*)pMem->z; +} + +/* +** Allocate or return the aggregate context for a user function. A new +** context is allocated on the first call. Subsequent calls return the +** same context that was returned on prior calls. +*/ +SQLITE_API void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){ + assert( p && p->pFunc && p->pFunc->xFinalize ); + assert( sqlite3_mutex_held(p->pOut->db->mutex) ); + testcase( nByte<0 ); + if( (p->pMem->flags & MEM_Agg)==0 ){ + return createAggContext(p, nByte); + }else{ + return (void*)p->pMem->z; + } +} + +/* +** Return the auxiliary data pointer, if any, for the iArg'th argument to +** the user-function defined by pCtx. +** +** The left-most argument is 0. +** +** Undocumented behavior: If iArg is negative then access a cache of +** auxiliary data pointers that is available to all functions within a +** single prepared statement. The iArg values must match. +*/ +SQLITE_API void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){ + AuxData *pAuxData; + + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); +#if SQLITE_ENABLE_STAT4 + if( pCtx->pVdbe==0 ) return 0; +#else + assert( pCtx->pVdbe!=0 ); +#endif + for(pAuxData=pCtx->pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNextAux){ + if( pAuxData->iAuxArg==iArg && (pAuxData->iAuxOp==pCtx->iOp || iArg<0) ){ + return pAuxData->pAux; + } + } + return 0; +} + +/* +** Set the auxiliary data pointer and delete function, for the iArg'th +** argument to the user-function defined by pCtx. Any previous value is +** deleted by calling the delete function specified when it was set. +** +** The left-most argument is 0. +** +** Undocumented behavior: If iArg is negative then make the data available +** to all functions within the current prepared statement using iArg as an +** access code. +*/ +SQLITE_API void sqlite3_set_auxdata( + sqlite3_context *pCtx, + int iArg, + void *pAux, + void (*xDelete)(void*) +){ + AuxData *pAuxData; + Vdbe *pVdbe = pCtx->pVdbe; + + assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); +#ifdef SQLITE_ENABLE_STAT4 + if( pVdbe==0 ) goto failed; +#else + assert( pVdbe!=0 ); +#endif + + for(pAuxData=pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNextAux){ + if( pAuxData->iAuxArg==iArg && (pAuxData->iAuxOp==pCtx->iOp || iArg<0) ){ + break; + } + } + if( pAuxData==0 ){ + pAuxData = sqlite3DbMallocZero(pVdbe->db, sizeof(AuxData)); + if( !pAuxData ) goto failed; + pAuxData->iAuxOp = pCtx->iOp; + pAuxData->iAuxArg = iArg; + pAuxData->pNextAux = pVdbe->pAuxData; + pVdbe->pAuxData = pAuxData; + if( pCtx->isError==0 ) pCtx->isError = -1; + }else if( pAuxData->xDeleteAux ){ + pAuxData->xDeleteAux(pAuxData->pAux); + } + + pAuxData->pAux = pAux; + pAuxData->xDeleteAux = xDelete; + return; + +failed: + if( xDelete ){ + xDelete(pAux); + } +} + +#ifndef SQLITE_OMIT_DEPRECATED +/* +** Return the number of times the Step function of an aggregate has been +** called. +** +** This function is deprecated. Do not use it for new code. It is +** provide only to avoid breaking legacy code. New aggregate function +** implementations should keep their own counts within their aggregate +** context. +*/ +SQLITE_API int sqlite3_aggregate_count(sqlite3_context *p){ + assert( p && p->pMem && p->pFunc && p->pFunc->xFinalize ); + return p->pMem->n; +} +#endif + +/* +** Return the number of columns in the result set for the statement pStmt. +*/ +SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt){ + Vdbe *pVm = (Vdbe *)pStmt; + return pVm ? pVm->nResColumn : 0; +} + +/* +** Return the number of values available from the current row of the +** currently executing statement pStmt. +*/ +SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt){ + Vdbe *pVm = (Vdbe *)pStmt; + if( pVm==0 || pVm->pResultRow==0 ) return 0; + return pVm->nResColumn; +} + +/* +** Return a pointer to static memory containing an SQL NULL value. +*/ +static const Mem *columnNullValue(void){ + /* Even though the Mem structure contains an element + ** of type i64, on certain architectures (x86) with certain compiler + ** switches (-Os), gcc may align this Mem object on a 4-byte boundary + ** instead of an 8-byte one. This all works fine, except that when + ** running with SQLITE_DEBUG defined the SQLite code sometimes assert()s + ** that a Mem structure is located on an 8-byte boundary. To prevent + ** these assert()s from failing, when building with SQLITE_DEBUG defined + ** using gcc, we force nullMem to be 8-byte aligned using the magical + ** __attribute__((aligned(8))) macro. */ + static const Mem nullMem +#if defined(SQLITE_DEBUG) && defined(__GNUC__) + __attribute__((aligned(8))) +#endif + = { + /* .u = */ {0}, + /* .z = */ (char*)0, + /* .n = */ (int)0, + /* .flags = */ (u16)MEM_Null, + /* .enc = */ (u8)0, + /* .eSubtype = */ (u8)0, + /* .db = */ (sqlite3*)0, + /* .szMalloc = */ (int)0, + /* .uTemp = */ (u32)0, + /* .zMalloc = */ (char*)0, + /* .xDel = */ (void(*)(void*))0, +#ifdef SQLITE_DEBUG + /* .pScopyFrom = */ (Mem*)0, + /* .mScopyFlags= */ 0, +#endif + }; + return &nullMem; +} + +/* +** Check to see if column iCol of the given statement is valid. If +** it is, return a pointer to the Mem for the value of that column. +** If iCol is not valid, return a pointer to a Mem which has a value +** of NULL. +*/ +static Mem *columnMem(sqlite3_stmt *pStmt, int i){ + Vdbe *pVm; + Mem *pOut; + + pVm = (Vdbe *)pStmt; + if( pVm==0 ) return (Mem*)columnNullValue(); + assert( pVm->db ); + sqlite3_mutex_enter(pVm->db->mutex); + if( pVm->pResultRow!=0 && inResColumn && i>=0 ){ + pOut = &pVm->pResultRow[i]; + }else{ + sqlite3Error(pVm->db, SQLITE_RANGE); + pOut = (Mem*)columnNullValue(); + } + return pOut; +} + +/* +** This function is called after invoking an sqlite3_value_XXX function on a +** column value (i.e. a value returned by evaluating an SQL expression in the +** select list of a SELECT statement) that may cause a malloc() failure. If +** malloc() has failed, the threads mallocFailed flag is cleared and the result +** code of statement pStmt set to SQLITE_NOMEM. +** +** Specifically, this is called from within: +** +** sqlite3_column_int() +** sqlite3_column_int64() +** sqlite3_column_text() +** sqlite3_column_text16() +** sqlite3_column_real() +** sqlite3_column_bytes() +** sqlite3_column_bytes16() +** sqiite3_column_blob() +*/ +static void columnMallocFailure(sqlite3_stmt *pStmt) +{ + /* If malloc() failed during an encoding conversion within an + ** sqlite3_column_XXX API, then set the return code of the statement to + ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR + ** and _finalize() will return NOMEM. + */ + Vdbe *p = (Vdbe *)pStmt; + if( p ){ + assert( p->db!=0 ); + assert( sqlite3_mutex_held(p->db->mutex) ); + p->rc = sqlite3ApiExit(p->db, p->rc); + sqlite3_mutex_leave(p->db->mutex); + } +} + +/**************************** sqlite3_column_ ******************************* +** The following routines are used to access elements of the current row +** in the result set. +*/ +SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){ + const void *val; + val = sqlite3_value_blob( columnMem(pStmt,i) ); + /* Even though there is no encoding conversion, value_blob() might + ** need to call malloc() to expand the result of a zeroblob() + ** expression. + */ + columnMallocFailure(pStmt); + return val; +} +SQLITE_API int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){ + int val = sqlite3_value_bytes( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return val; +} +SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){ + int val = sqlite3_value_bytes16( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return val; +} +SQLITE_API double sqlite3_column_double(sqlite3_stmt *pStmt, int i){ + double val = sqlite3_value_double( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return val; +} +SQLITE_API int sqlite3_column_int(sqlite3_stmt *pStmt, int i){ + int val = sqlite3_value_int( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return val; +} +SQLITE_API sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i){ + sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return val; +} +SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){ + const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return val; +} +SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){ + Mem *pOut = columnMem(pStmt, i); + if( pOut->flags&MEM_Static ){ + pOut->flags &= ~MEM_Static; + pOut->flags |= MEM_Ephem; + } + columnMallocFailure(pStmt); + return (sqlite3_value *)pOut; +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){ + const void *val = sqlite3_value_text16( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return val; +} +#endif /* SQLITE_OMIT_UTF16 */ +SQLITE_API int sqlite3_column_type(sqlite3_stmt *pStmt, int i){ + int iType = sqlite3_value_type( columnMem(pStmt,i) ); + columnMallocFailure(pStmt); + return iType; +} + +/* +** Convert the N-th element of pStmt->pColName[] into a string using +** xFunc() then return that string. If N is out of range, return 0. +** +** There are up to 5 names for each column. useType determines which +** name is returned. Here are the names: +** +** 0 The column name as it should be displayed for output +** 1 The datatype name for the column +** 2 The name of the database that the column derives from +** 3 The name of the table that the column derives from +** 4 The name of the table column that the result column derives from +** +** If the result is not a simple column reference (if it is an expression +** or a constant) then useTypes 2, 3, and 4 return NULL. +*/ +static const void *columnName( + sqlite3_stmt *pStmt, /* The statement */ + int N, /* Which column to get the name for */ + int useUtf16, /* True to return the name as UTF16 */ + int useType /* What type of name */ +){ + const void *ret; + Vdbe *p; + int n; + sqlite3 *db; +#ifdef SQLITE_ENABLE_API_ARMOR + if( pStmt==0 ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + ret = 0; + p = (Vdbe *)pStmt; + db = p->db; + assert( db!=0 ); + n = sqlite3_column_count(pStmt); + if( N=0 ){ + u8 prior_mallocFailed = db->mallocFailed; + N += useType*n; + sqlite3_mutex_enter(db->mutex); +#ifndef SQLITE_OMIT_UTF16 + if( useUtf16 ){ + ret = sqlite3_value_text16((sqlite3_value*)&p->aColName[N]); + }else +#endif + { + ret = sqlite3_value_text((sqlite3_value*)&p->aColName[N]); + } + /* A malloc may have failed inside of the _text() call. If this + ** is the case, clear the mallocFailed flag and return NULL. + */ + assert( db->mallocFailed==0 || db->mallocFailed==1 ); + if( db->mallocFailed > prior_mallocFailed ){ + sqlite3OomClear(db); + ret = 0; + } + sqlite3_mutex_leave(db->mutex); + } + return ret; +} + +/* +** Return the name of the Nth column of the result set returned by SQL +** statement pStmt. +*/ +SQLITE_API const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){ + return columnName(pStmt, N, 0, COLNAME_NAME); +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){ + return columnName(pStmt, N, 1, COLNAME_NAME); +} +#endif + +/* +** Constraint: If you have ENABLE_COLUMN_METADATA then you must +** not define OMIT_DECLTYPE. +*/ +#if defined(SQLITE_OMIT_DECLTYPE) && defined(SQLITE_ENABLE_COLUMN_METADATA) +# error "Must not define both SQLITE_OMIT_DECLTYPE \ + and SQLITE_ENABLE_COLUMN_METADATA" +#endif + +#ifndef SQLITE_OMIT_DECLTYPE +/* +** Return the column declaration type (if applicable) of the 'i'th column +** of the result set of SQL statement pStmt. +*/ +SQLITE_API const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){ + return columnName(pStmt, N, 0, COLNAME_DECLTYPE); +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){ + return columnName(pStmt, N, 1, COLNAME_DECLTYPE); +} +#endif /* SQLITE_OMIT_UTF16 */ +#endif /* SQLITE_OMIT_DECLTYPE */ + +#ifdef SQLITE_ENABLE_COLUMN_METADATA +/* +** Return the name of the database from which a result column derives. +** NULL is returned if the result column is an expression or constant or +** anything else which is not an unambiguous reference to a database column. +*/ +SQLITE_API const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){ + return columnName(pStmt, N, 0, COLNAME_DATABASE); +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){ + return columnName(pStmt, N, 1, COLNAME_DATABASE); +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** Return the name of the table from which a result column derives. +** NULL is returned if the result column is an expression or constant or +** anything else which is not an unambiguous reference to a database column. +*/ +SQLITE_API const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){ + return columnName(pStmt, N, 0, COLNAME_TABLE); +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){ + return columnName(pStmt, N, 1, COLNAME_TABLE); +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** Return the name of the table column from which a result column derives. +** NULL is returned if the result column is an expression or constant or +** anything else which is not an unambiguous reference to a database column. +*/ +SQLITE_API const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){ + return columnName(pStmt, N, 0, COLNAME_COLUMN); +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){ + return columnName(pStmt, N, 1, COLNAME_COLUMN); +} +#endif /* SQLITE_OMIT_UTF16 */ +#endif /* SQLITE_ENABLE_COLUMN_METADATA */ + + +/******************************* sqlite3_bind_ *************************** +** +** Routines used to attach values to wildcards in a compiled SQL statement. +*/ +/* +** Unbind the value bound to variable i in virtual machine p. This is the +** the same as binding a NULL value to the column. If the "i" parameter is +** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK. +** +** A successful evaluation of this routine acquires the mutex on p. +** the mutex is released if any kind of error occurs. +** +** The error code stored in database p->db is overwritten with the return +** value in any case. +*/ +static int vdbeUnbind(Vdbe *p, unsigned int i){ + Mem *pVar; + if( vdbeSafetyNotNull(p) ){ + return SQLITE_MISUSE_BKPT; + } + sqlite3_mutex_enter(p->db->mutex); + if( p->eVdbeState!=VDBE_READY_STATE ){ + sqlite3Error(p->db, SQLITE_MISUSE); + sqlite3_mutex_leave(p->db->mutex); + sqlite3_log(SQLITE_MISUSE, + "bind on a busy prepared statement: [%s]", p->zSql); + return SQLITE_MISUSE_BKPT; + } + if( i>=(unsigned int)p->nVar ){ + sqlite3Error(p->db, SQLITE_RANGE); + sqlite3_mutex_leave(p->db->mutex); + return SQLITE_RANGE; + } + pVar = &p->aVar[i]; + sqlite3VdbeMemRelease(pVar); + pVar->flags = MEM_Null; + p->db->errCode = SQLITE_OK; + + /* If the bit corresponding to this variable in Vdbe.expmask is set, then + ** binding a new value to this variable invalidates the current query plan. + ** + ** IMPLEMENTATION-OF: R-57496-20354 If the specific value bound to a host + ** parameter in the WHERE clause might influence the choice of query plan + ** for a statement, then the statement will be automatically recompiled, + ** as if there had been a schema change, on the first sqlite3_step() call + ** following any change to the bindings of that parameter. + */ + assert( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || p->expmask==0 ); + if( p->expmask!=0 && (p->expmask & (i>=31 ? 0x80000000 : (u32)1<expired = 1; + } + return SQLITE_OK; +} + +/* +** Bind a text or BLOB value. +*/ +static int bindText( + sqlite3_stmt *pStmt, /* The statement to bind against */ + int i, /* Index of the parameter to bind */ + const void *zData, /* Pointer to the data to be bound */ + i64 nData, /* Number of bytes of data to be bound */ + void (*xDel)(void*), /* Destructor for the data */ + u8 encoding /* Encoding for the data */ +){ + Vdbe *p = (Vdbe *)pStmt; + Mem *pVar; + int rc; + + rc = vdbeUnbind(p, (u32)(i-1)); + if( rc==SQLITE_OK ){ + if( zData!=0 ){ + pVar = &p->aVar[i-1]; + rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel); + if( rc==SQLITE_OK && encoding!=0 ){ + rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db)); + } + if( rc ){ + sqlite3Error(p->db, rc); + rc = sqlite3ApiExit(p->db, rc); + } + } + sqlite3_mutex_leave(p->db->mutex); + }else if( xDel!=SQLITE_STATIC && xDel!=SQLITE_TRANSIENT ){ + xDel((void*)zData); + } + return rc; +} + + +/* +** Bind a blob value to an SQL statement variable. +*/ +SQLITE_API int sqlite3_bind_blob( + sqlite3_stmt *pStmt, + int i, + const void *zData, + int nData, + void (*xDel)(void*) +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( nData<0 ) return SQLITE_MISUSE_BKPT; +#endif + return bindText(pStmt, i, zData, nData, xDel, 0); +} +SQLITE_API int sqlite3_bind_blob64( + sqlite3_stmt *pStmt, + int i, + const void *zData, + sqlite3_uint64 nData, + void (*xDel)(void*) +){ + assert( xDel!=SQLITE_DYNAMIC ); + return bindText(pStmt, i, zData, nData, xDel, 0); +} +SQLITE_API int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){ + int rc; + Vdbe *p = (Vdbe *)pStmt; + rc = vdbeUnbind(p, (u32)(i-1)); + if( rc==SQLITE_OK ){ + sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue); + sqlite3_mutex_leave(p->db->mutex); + } + return rc; +} +SQLITE_API int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){ + return sqlite3_bind_int64(p, i, (i64)iValue); +} +SQLITE_API int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){ + int rc; + Vdbe *p = (Vdbe *)pStmt; + rc = vdbeUnbind(p, (u32)(i-1)); + if( rc==SQLITE_OK ){ + sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue); + sqlite3_mutex_leave(p->db->mutex); + } + return rc; +} +SQLITE_API int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){ + int rc; + Vdbe *p = (Vdbe*)pStmt; + rc = vdbeUnbind(p, (u32)(i-1)); + if( rc==SQLITE_OK ){ + sqlite3_mutex_leave(p->db->mutex); + } + return rc; +} +SQLITE_API int sqlite3_bind_pointer( + sqlite3_stmt *pStmt, + int i, + void *pPtr, + const char *zPTtype, + void (*xDestructor)(void*) +){ + int rc; + Vdbe *p = (Vdbe*)pStmt; + rc = vdbeUnbind(p, (u32)(i-1)); + if( rc==SQLITE_OK ){ + sqlite3VdbeMemSetPointer(&p->aVar[i-1], pPtr, zPTtype, xDestructor); + sqlite3_mutex_leave(p->db->mutex); + }else if( xDestructor ){ + xDestructor(pPtr); + } + return rc; +} +SQLITE_API int sqlite3_bind_text( + sqlite3_stmt *pStmt, + int i, + const char *zData, + int nData, + void (*xDel)(void*) +){ + return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8); +} +SQLITE_API int sqlite3_bind_text64( + sqlite3_stmt *pStmt, + int i, + const char *zData, + sqlite3_uint64 nData, + void (*xDel)(void*), + unsigned char enc +){ + assert( xDel!=SQLITE_DYNAMIC ); + if( enc!=SQLITE_UTF8 ){ + if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE; + nData &= ~(u16)1; + } + return bindText(pStmt, i, zData, nData, xDel, enc); +} +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API int sqlite3_bind_text16( + sqlite3_stmt *pStmt, + int i, + const void *zData, + int n, + void (*xDel)(void*) +){ + return bindText(pStmt, i, zData, n & ~(u64)1, xDel, SQLITE_UTF16NATIVE); +} +#endif /* SQLITE_OMIT_UTF16 */ +SQLITE_API int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){ + int rc; + switch( sqlite3_value_type((sqlite3_value*)pValue) ){ + case SQLITE_INTEGER: { + rc = sqlite3_bind_int64(pStmt, i, pValue->u.i); + break; + } + case SQLITE_FLOAT: { + assert( pValue->flags & (MEM_Real|MEM_IntReal) ); + rc = sqlite3_bind_double(pStmt, i, + (pValue->flags & MEM_Real) ? pValue->u.r : (double)pValue->u.i + ); + break; + } + case SQLITE_BLOB: { + if( pValue->flags & MEM_Zero ){ + rc = sqlite3_bind_zeroblob(pStmt, i, pValue->u.nZero); + }else{ + rc = sqlite3_bind_blob(pStmt, i, pValue->z, pValue->n,SQLITE_TRANSIENT); + } + break; + } + case SQLITE_TEXT: { + rc = bindText(pStmt,i, pValue->z, pValue->n, SQLITE_TRANSIENT, + pValue->enc); + break; + } + default: { + rc = sqlite3_bind_null(pStmt, i); + break; + } + } + return rc; +} +SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){ + int rc; + Vdbe *p = (Vdbe *)pStmt; + rc = vdbeUnbind(p, (u32)(i-1)); + if( rc==SQLITE_OK ){ +#ifndef SQLITE_OMIT_INCRBLOB + sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n); +#else + rc = sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n); +#endif + sqlite3_mutex_leave(p->db->mutex); + } + return rc; +} +SQLITE_API int sqlite3_bind_zeroblob64(sqlite3_stmt *pStmt, int i, sqlite3_uint64 n){ + int rc; + Vdbe *p = (Vdbe *)pStmt; + sqlite3_mutex_enter(p->db->mutex); + if( n>(u64)p->db->aLimit[SQLITE_LIMIT_LENGTH] ){ + rc = SQLITE_TOOBIG; + }else{ + assert( (n & 0x7FFFFFFF)==n ); + rc = sqlite3_bind_zeroblob(pStmt, i, n); + } + rc = sqlite3ApiExit(p->db, rc); + sqlite3_mutex_leave(p->db->mutex); + return rc; +} + +/* +** Return the number of wildcards that can be potentially bound to. +** This routine is added to support DBD::SQLite. +*/ +SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){ + Vdbe *p = (Vdbe*)pStmt; + return p ? p->nVar : 0; +} + +/* +** Return the name of a wildcard parameter. Return NULL if the index +** is out of range or if the wildcard is unnamed. +** +** The result is always UTF-8. +*/ +SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i){ + Vdbe *p = (Vdbe*)pStmt; + if( p==0 ) return 0; + return sqlite3VListNumToName(p->pVList, i); +} + +/* +** Given a wildcard parameter name, return the index of the variable +** with that name. If there is no variable with the given name, +** return 0. +*/ +SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nName){ + if( p==0 || zName==0 ) return 0; + return sqlite3VListNameToNum(p->pVList, zName, nName); +} +SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){ + return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName)); +} + +/* +** Transfer all bindings from the first statement over to the second. +*/ +SQLITE_PRIVATE int sqlite3TransferBindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){ + Vdbe *pFrom = (Vdbe*)pFromStmt; + Vdbe *pTo = (Vdbe*)pToStmt; + int i; + assert( pTo->db==pFrom->db ); + assert( pTo->nVar==pFrom->nVar ); + sqlite3_mutex_enter(pTo->db->mutex); + for(i=0; inVar; i++){ + sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]); + } + sqlite3_mutex_leave(pTo->db->mutex); + return SQLITE_OK; +} + +#ifndef SQLITE_OMIT_DEPRECATED +/* +** Deprecated external interface. Internal/core SQLite code +** should call sqlite3TransferBindings. +** +** It is misuse to call this routine with statements from different +** database connections. But as this is a deprecated interface, we +** will not bother to check for that condition. +** +** If the two statements contain a different number of bindings, then +** an SQLITE_ERROR is returned. Nothing else can go wrong, so otherwise +** SQLITE_OK is returned. +*/ +SQLITE_API int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){ + Vdbe *pFrom = (Vdbe*)pFromStmt; + Vdbe *pTo = (Vdbe*)pToStmt; + if( pFrom->nVar!=pTo->nVar ){ + return SQLITE_ERROR; + } + assert( (pTo->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || pTo->expmask==0 ); + if( pTo->expmask ){ + pTo->expired = 1; + } + assert( (pFrom->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || pFrom->expmask==0 ); + if( pFrom->expmask ){ + pFrom->expired = 1; + } + return sqlite3TransferBindings(pFromStmt, pToStmt); +} +#endif + +/* +** Return the sqlite3* database handle to which the prepared statement given +** in the argument belongs. This is the same database handle that was +** the first argument to the sqlite3_prepare() that was used to create +** the statement in the first place. +*/ +SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt *pStmt){ + return pStmt ? ((Vdbe*)pStmt)->db : 0; +} + +/* +** Return true if the prepared statement is guaranteed to not modify the +** database. +*/ +SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt){ + return pStmt ? ((Vdbe*)pStmt)->readOnly : 1; +} + +/* +** Return 1 if the statement is an EXPLAIN and return 2 if the +** statement is an EXPLAIN QUERY PLAN +*/ +SQLITE_API int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt){ + return pStmt ? ((Vdbe*)pStmt)->explain : 0; +} + +/* +** Return true if the prepared statement is in need of being reset. +*/ +SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt *pStmt){ + Vdbe *v = (Vdbe*)pStmt; + return v!=0 && v->eVdbeState==VDBE_RUN_STATE; +} + +/* +** Return a pointer to the next prepared statement after pStmt associated +** with database connection pDb. If pStmt is NULL, return the first +** prepared statement for the database connection. Return NULL if there +** are no more. +*/ +SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt){ + sqlite3_stmt *pNext; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(pDb) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + sqlite3_mutex_enter(pDb->mutex); + if( pStmt==0 ){ + pNext = (sqlite3_stmt*)pDb->pVdbe; + }else{ + pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pVNext; + } + sqlite3_mutex_leave(pDb->mutex); + return pNext; +} + +/* +** Return the value of a status counter for a prepared statement +*/ +SQLITE_API int sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){ + Vdbe *pVdbe = (Vdbe*)pStmt; + u32 v; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !pStmt + || (op!=SQLITE_STMTSTATUS_MEMUSED && (op<0||op>=ArraySize(pVdbe->aCounter))) + ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + if( op==SQLITE_STMTSTATUS_MEMUSED ){ + sqlite3 *db = pVdbe->db; + sqlite3_mutex_enter(db->mutex); + v = 0; + db->pnBytesFreed = (int*)&v; + assert( db->lookaside.pEnd==db->lookaside.pTrueEnd ); + db->lookaside.pEnd = db->lookaside.pStart; + sqlite3VdbeDelete(pVdbe); + db->pnBytesFreed = 0; + db->lookaside.pEnd = db->lookaside.pTrueEnd; + sqlite3_mutex_leave(db->mutex); + }else{ + v = pVdbe->aCounter[op]; + if( resetFlag ) pVdbe->aCounter[op] = 0; + } + return (int)v; +} + +/* +** Return the SQL associated with a prepared statement +*/ +SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt){ + Vdbe *p = (Vdbe *)pStmt; + return p ? p->zSql : 0; +} + +/* +** Return the SQL associated with a prepared statement with +** bound parameters expanded. Space to hold the returned string is +** obtained from sqlite3_malloc(). The caller is responsible for +** freeing the returned string by passing it to sqlite3_free(). +** +** The SQLITE_TRACE_SIZE_LIMIT puts an upper bound on the size of +** expanded bound parameters. +*/ +SQLITE_API char *sqlite3_expanded_sql(sqlite3_stmt *pStmt){ +#ifdef SQLITE_OMIT_TRACE + return 0; +#else + char *z = 0; + const char *zSql = sqlite3_sql(pStmt); + if( zSql ){ + Vdbe *p = (Vdbe *)pStmt; + sqlite3_mutex_enter(p->db->mutex); + z = sqlite3VdbeExpandSql(p, zSql); + sqlite3_mutex_leave(p->db->mutex); + } + return z; +#endif +} + +#ifdef SQLITE_ENABLE_NORMALIZE +/* +** Return the normalized SQL associated with a prepared statement. +*/ +SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt){ + Vdbe *p = (Vdbe *)pStmt; + if( p==0 ) return 0; + if( p->zNormSql==0 && ALWAYS(p->zSql!=0) ){ + sqlite3_mutex_enter(p->db->mutex); + p->zNormSql = sqlite3Normalize(p, p->zSql); + sqlite3_mutex_leave(p->db->mutex); + } + return p->zNormSql; +} +#endif /* SQLITE_ENABLE_NORMALIZE */ + +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK +/* +** Allocate and populate an UnpackedRecord structure based on the serialized +** record in nKey/pKey. Return a pointer to the new UnpackedRecord structure +** if successful, or a NULL pointer if an OOM error is encountered. +*/ +static UnpackedRecord *vdbeUnpackRecord( + KeyInfo *pKeyInfo, + int nKey, + const void *pKey +){ + UnpackedRecord *pRet; /* Return value */ + + pRet = sqlite3VdbeAllocUnpackedRecord(pKeyInfo); + if( pRet ){ + memset(pRet->aMem, 0, sizeof(Mem)*(pKeyInfo->nKeyField+1)); + sqlite3VdbeRecordUnpack(pKeyInfo, nKey, pKey, pRet); + } + return pRet; +} + +/* +** This function is called from within a pre-update callback to retrieve +** a field of the row currently being updated or deleted. +*/ +SQLITE_API int sqlite3_preupdate_old(sqlite3 *db, int iIdx, sqlite3_value **ppValue){ + PreUpdate *p = db->pPreUpdate; + Mem *pMem; + int rc = SQLITE_OK; + + /* Test that this call is being made from within an SQLITE_DELETE or + ** SQLITE_UPDATE pre-update callback, and that iIdx is within range. */ + if( !p || p->op==SQLITE_INSERT ){ + rc = SQLITE_MISUSE_BKPT; + goto preupdate_old_out; + } + if( p->pPk ){ + iIdx = sqlite3TableColumnToIndex(p->pPk, iIdx); + } + if( iIdx>=p->pCsr->nField || iIdx<0 ){ + rc = SQLITE_RANGE; + goto preupdate_old_out; + } + + /* If the old.* record has not yet been loaded into memory, do so now. */ + if( p->pUnpacked==0 ){ + u32 nRec; + u8 *aRec; + + assert( p->pCsr->eCurType==CURTYPE_BTREE ); + nRec = sqlite3BtreePayloadSize(p->pCsr->uc.pCursor); + aRec = sqlite3DbMallocRaw(db, nRec); + if( !aRec ) goto preupdate_old_out; + rc = sqlite3BtreePayload(p->pCsr->uc.pCursor, 0, nRec, aRec); + if( rc==SQLITE_OK ){ + p->pUnpacked = vdbeUnpackRecord(&p->keyinfo, nRec, aRec); + if( !p->pUnpacked ) rc = SQLITE_NOMEM; + } + if( rc!=SQLITE_OK ){ + sqlite3DbFree(db, aRec); + goto preupdate_old_out; + } + p->aRecord = aRec; + } + + pMem = *ppValue = &p->pUnpacked->aMem[iIdx]; + if( iIdx==p->pTab->iPKey ){ + sqlite3VdbeMemSetInt64(pMem, p->iKey1); + }else if( iIdx>=p->pUnpacked->nField ){ + *ppValue = (sqlite3_value *)columnNullValue(); + }else if( p->pTab->aCol[iIdx].affinity==SQLITE_AFF_REAL ){ + if( pMem->flags & (MEM_Int|MEM_IntReal) ){ + testcase( pMem->flags & MEM_Int ); + testcase( pMem->flags & MEM_IntReal ); + sqlite3VdbeMemRealify(pMem); + } + } + + preupdate_old_out: + sqlite3Error(db, rc); + return sqlite3ApiExit(db, rc); +} +#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ + +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK +/* +** This function is called from within a pre-update callback to retrieve +** the number of columns in the row being updated, deleted or inserted. +*/ +SQLITE_API int sqlite3_preupdate_count(sqlite3 *db){ + PreUpdate *p = db->pPreUpdate; + return (p ? p->keyinfo.nKeyField : 0); +} +#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ + +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK +/* +** This function is designed to be called from within a pre-update callback +** only. It returns zero if the change that caused the callback was made +** immediately by a user SQL statement. Or, if the change was made by a +** trigger program, it returns the number of trigger programs currently +** on the stack (1 for a top-level trigger, 2 for a trigger fired by a +** top-level trigger etc.). +** +** For the purposes of the previous paragraph, a foreign key CASCADE, SET NULL +** or SET DEFAULT action is considered a trigger. +*/ +SQLITE_API int sqlite3_preupdate_depth(sqlite3 *db){ + PreUpdate *p = db->pPreUpdate; + return (p ? p->v->nFrame : 0); +} +#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ + +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK +/* +** This function is designed to be called from within a pre-update callback +** only. +*/ +SQLITE_API int sqlite3_preupdate_blobwrite(sqlite3 *db){ + PreUpdate *p = db->pPreUpdate; + return (p ? p->iBlobWrite : -1); +} +#endif + +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK +/* +** This function is called from within a pre-update callback to retrieve +** a field of the row currently being updated or inserted. +*/ +SQLITE_API int sqlite3_preupdate_new(sqlite3 *db, int iIdx, sqlite3_value **ppValue){ + PreUpdate *p = db->pPreUpdate; + int rc = SQLITE_OK; + Mem *pMem; + + if( !p || p->op==SQLITE_DELETE ){ + rc = SQLITE_MISUSE_BKPT; + goto preupdate_new_out; + } + if( p->pPk && p->op!=SQLITE_UPDATE ){ + iIdx = sqlite3TableColumnToIndex(p->pPk, iIdx); + } + if( iIdx>=p->pCsr->nField || iIdx<0 ){ + rc = SQLITE_RANGE; + goto preupdate_new_out; + } + + if( p->op==SQLITE_INSERT ){ + /* For an INSERT, memory cell p->iNewReg contains the serialized record + ** that is being inserted. Deserialize it. */ + UnpackedRecord *pUnpack = p->pNewUnpacked; + if( !pUnpack ){ + Mem *pData = &p->v->aMem[p->iNewReg]; + rc = ExpandBlob(pData); + if( rc!=SQLITE_OK ) goto preupdate_new_out; + pUnpack = vdbeUnpackRecord(&p->keyinfo, pData->n, pData->z); + if( !pUnpack ){ + rc = SQLITE_NOMEM; + goto preupdate_new_out; + } + p->pNewUnpacked = pUnpack; + } + pMem = &pUnpack->aMem[iIdx]; + if( iIdx==p->pTab->iPKey ){ + sqlite3VdbeMemSetInt64(pMem, p->iKey2); + }else if( iIdx>=pUnpack->nField ){ + pMem = (sqlite3_value *)columnNullValue(); + } + }else{ + /* For an UPDATE, memory cell (p->iNewReg+1+iIdx) contains the required + ** value. Make a copy of the cell contents and return a pointer to it. + ** It is not safe to return a pointer to the memory cell itself as the + ** caller may modify the value text encoding. + */ + assert( p->op==SQLITE_UPDATE ); + if( !p->aNew ){ + p->aNew = (Mem *)sqlite3DbMallocZero(db, sizeof(Mem) * p->pCsr->nField); + if( !p->aNew ){ + rc = SQLITE_NOMEM; + goto preupdate_new_out; + } + } + assert( iIdx>=0 && iIdxpCsr->nField ); + pMem = &p->aNew[iIdx]; + if( pMem->flags==0 ){ + if( iIdx==p->pTab->iPKey ){ + sqlite3VdbeMemSetInt64(pMem, p->iKey2); + }else{ + rc = sqlite3VdbeMemCopy(pMem, &p->v->aMem[p->iNewReg+1+iIdx]); + if( rc!=SQLITE_OK ) goto preupdate_new_out; + } + } + } + *ppValue = pMem; + + preupdate_new_out: + sqlite3Error(db, rc); + return sqlite3ApiExit(db, rc); +} +#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ + +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS +/* +** Return status data for a single loop within query pStmt. +*/ +SQLITE_API int sqlite3_stmt_scanstatus_v2( + sqlite3_stmt *pStmt, /* Prepared statement being queried */ + int iScan, /* Index of loop to report on */ + int iScanStatusOp, /* Which metric to return */ + int flags, + void *pOut /* OUT: Write the answer here */ +){ + Vdbe *p = (Vdbe*)pStmt; + VdbeOp *aOp = p->aOp; + int nOp = p->nOp; + ScanStatus *pScan = 0; + int idx; + + if( p->pFrame ){ + VdbeFrame *pFrame; + for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent); + aOp = pFrame->aOp; + nOp = pFrame->nOp; + } + + if( iScan<0 ){ + int ii; + if( iScanStatusOp==SQLITE_SCANSTAT_NCYCLE ){ + i64 res = 0; + for(ii=0; iiaScan[idx]; + }else{ + /* If the COMPLEX flag is clear, then this function must ignore any + ** ScanStatus structures with ScanStatus.addrLoop set to 0. */ + for(idx=0; idxnScan; idx++){ + pScan = &p->aScan[idx]; + if( pScan->zName ){ + iScan--; + if( iScan<0 ) break; + } + } + } + if( idx>=p->nScan ) return 1; + + switch( iScanStatusOp ){ + case SQLITE_SCANSTAT_NLOOP: { + if( pScan->addrLoop>0 ){ + *(sqlite3_int64*)pOut = aOp[pScan->addrLoop].nExec; + }else{ + *(sqlite3_int64*)pOut = -1; + } + break; + } + case SQLITE_SCANSTAT_NVISIT: { + if( pScan->addrVisit>0 ){ + *(sqlite3_int64*)pOut = aOp[pScan->addrVisit].nExec; + }else{ + *(sqlite3_int64*)pOut = -1; + } + break; + } + case SQLITE_SCANSTAT_EST: { + double r = 1.0; + LogEst x = pScan->nEst; + while( x<100 ){ + x += 10; + r *= 0.5; + } + *(double*)pOut = r*sqlite3LogEstToInt(x); + break; + } + case SQLITE_SCANSTAT_NAME: { + *(const char**)pOut = pScan->zName; + break; + } + case SQLITE_SCANSTAT_EXPLAIN: { + if( pScan->addrExplain ){ + *(const char**)pOut = aOp[ pScan->addrExplain ].p4.z; + }else{ + *(const char**)pOut = 0; + } + break; + } + case SQLITE_SCANSTAT_SELECTID: { + if( pScan->addrExplain ){ + *(int*)pOut = aOp[ pScan->addrExplain ].p1; + }else{ + *(int*)pOut = -1; + } + break; + } + case SQLITE_SCANSTAT_PARENTID: { + if( pScan->addrExplain ){ + *(int*)pOut = aOp[ pScan->addrExplain ].p2; + }else{ + *(int*)pOut = -1; + } + break; + } + case SQLITE_SCANSTAT_NCYCLE: { + i64 res = 0; + if( pScan->aAddrRange[0]==0 ){ + res = -1; + }else{ + int ii; + for(ii=0; iiaAddrRange); ii+=2){ + int iIns = pScan->aAddrRange[ii]; + int iEnd = pScan->aAddrRange[ii+1]; + if( iIns==0 ) break; + if( iIns>0 ){ + while( iIns<=iEnd ){ + res += aOp[iIns].nCycle; + iIns++; + } + }else{ + int iOp; + for(iOp=0; iOpp1!=iEnd ) continue; + if( (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_NCYCLE)==0 ){ + continue; + } + res += aOp[iOp].nCycle; + } + } + } + } + *(i64*)pOut = res; + break; + } + default: { + return 1; + } + } + return 0; +} + +/* +** Return status data for a single loop within query pStmt. +*/ +SQLITE_API int sqlite3_stmt_scanstatus( + sqlite3_stmt *pStmt, /* Prepared statement being queried */ + int iScan, /* Index of loop to report on */ + int iScanStatusOp, /* Which metric to return */ + void *pOut /* OUT: Write the answer here */ +){ + return sqlite3_stmt_scanstatus_v2(pStmt, iScan, iScanStatusOp, 0, pOut); +} + +/* +** Zero all counters associated with the sqlite3_stmt_scanstatus() data. +*/ +SQLITE_API void sqlite3_stmt_scanstatus_reset(sqlite3_stmt *pStmt){ + Vdbe *p = (Vdbe*)pStmt; + int ii; + for(ii=0; iinOp; ii++){ + Op *pOp = &p->aOp[ii]; + pOp->nExec = 0; + pOp->nCycle = 0; + } +} +#endif /* SQLITE_ENABLE_STMT_SCANSTATUS */ + +/************** End of vdbeapi.c *********************************************/ +/************** Begin file vdbetrace.c ***************************************/ +/* +** 2009 November 25 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains code used to insert the values of host parameters +** (aka "wildcards") into the SQL text output by sqlite3_trace(). +** +** The Vdbe parse-tree explainer is also found here. +*/ +/* #include "sqliteInt.h" */ +/* #include "vdbeInt.h" */ + +#ifndef SQLITE_OMIT_TRACE + +/* +** zSql is a zero-terminated string of UTF-8 SQL text. Return the number of +** bytes in this text up to but excluding the first character in +** a host parameter. If the text contains no host parameters, return +** the total number of bytes in the text. +*/ +static int findNextHostParameter(const char *zSql, int *pnToken){ + int tokenType; + int nTotal = 0; + int n; + + *pnToken = 0; + while( zSql[0] ){ + n = sqlite3GetToken((u8*)zSql, &tokenType); + assert( n>0 && tokenType!=TK_ILLEGAL ); + if( tokenType==TK_VARIABLE ){ + *pnToken = n; + break; + } + nTotal += n; + zSql += n; + } + return nTotal; +} + +/* +** This function returns a pointer to a nul-terminated string in memory +** obtained from sqlite3DbMalloc(). If sqlite3.nVdbeExec is 1, then the +** string contains a copy of zRawSql but with host parameters expanded to +** their current bindings. Or, if sqlite3.nVdbeExec is greater than 1, +** then the returned string holds a copy of zRawSql with "-- " prepended +** to each line of text. +** +** If the SQLITE_TRACE_SIZE_LIMIT macro is defined to an integer, then +** then long strings and blobs are truncated to that many bytes. This +** can be used to prevent unreasonably large trace strings when dealing +** with large (multi-megabyte) strings and blobs. +** +** The calling function is responsible for making sure the memory returned +** is eventually freed. +** +** ALGORITHM: Scan the input string looking for host parameters in any of +** these forms: ?, ?N, $A, @A, :A. Take care to avoid text within +** string literals, quoted identifier names, and comments. For text forms, +** the host parameter index is found by scanning the prepared +** statement for the corresponding OP_Variable opcode. Once the host +** parameter index is known, locate the value in p->aVar[]. Then render +** the value as a literal in place of the host parameter name. +*/ +SQLITE_PRIVATE char *sqlite3VdbeExpandSql( + Vdbe *p, /* The prepared statement being evaluated */ + const char *zRawSql /* Raw text of the SQL statement */ +){ + sqlite3 *db; /* The database connection */ + int idx = 0; /* Index of a host parameter */ + int nextIndex = 1; /* Index of next ? host parameter */ + int n; /* Length of a token prefix */ + int nToken; /* Length of the parameter token */ + int i; /* Loop counter */ + Mem *pVar; /* Value of a host parameter */ + StrAccum out; /* Accumulate the output here */ +#ifndef SQLITE_OMIT_UTF16 + Mem utf8; /* Used to convert UTF16 into UTF8 for display */ +#endif + + db = p->db; + sqlite3StrAccumInit(&out, 0, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]); + if( db->nVdbeExec>1 ){ + while( *zRawSql ){ + const char *zStart = zRawSql; + while( *(zRawSql++)!='\n' && *zRawSql ); + sqlite3_str_append(&out, "-- ", 3); + assert( (zRawSql - zStart) > 0 ); + sqlite3_str_append(&out, zStart, (int)(zRawSql-zStart)); + } + }else if( p->nVar==0 ){ + sqlite3_str_append(&out, zRawSql, sqlite3Strlen30(zRawSql)); + }else{ + while( zRawSql[0] ){ + n = findNextHostParameter(zRawSql, &nToken); + assert( n>0 ); + sqlite3_str_append(&out, zRawSql, n); + zRawSql += n; + assert( zRawSql[0] || nToken==0 ); + if( nToken==0 ) break; + if( zRawSql[0]=='?' ){ + if( nToken>1 ){ + assert( sqlite3Isdigit(zRawSql[1]) ); + sqlite3GetInt32(&zRawSql[1], &idx); + }else{ + idx = nextIndex; + } + }else{ + assert( zRawSql[0]==':' || zRawSql[0]=='$' || + zRawSql[0]=='@' || zRawSql[0]=='#' ); + testcase( zRawSql[0]==':' ); + testcase( zRawSql[0]=='$' ); + testcase( zRawSql[0]=='@' ); + testcase( zRawSql[0]=='#' ); + idx = sqlite3VdbeParameterIndex(p, zRawSql, nToken); + assert( idx>0 ); + } + zRawSql += nToken; + nextIndex = MAX(idx + 1, nextIndex); + assert( idx>0 && idx<=p->nVar ); + pVar = &p->aVar[idx-1]; + if( pVar->flags & MEM_Null ){ + sqlite3_str_append(&out, "NULL", 4); + }else if( pVar->flags & (MEM_Int|MEM_IntReal) ){ + sqlite3_str_appendf(&out, "%lld", pVar->u.i); + }else if( pVar->flags & MEM_Real ){ + sqlite3_str_appendf(&out, "%!.15g", pVar->u.r); + }else if( pVar->flags & MEM_Str ){ + int nOut; /* Number of bytes of the string text to include in output */ +#ifndef SQLITE_OMIT_UTF16 + u8 enc = ENC(db); + if( enc!=SQLITE_UTF8 ){ + memset(&utf8, 0, sizeof(utf8)); + utf8.db = db; + sqlite3VdbeMemSetStr(&utf8, pVar->z, pVar->n, enc, SQLITE_STATIC); + if( SQLITE_NOMEM==sqlite3VdbeChangeEncoding(&utf8, SQLITE_UTF8) ){ + out.accError = SQLITE_NOMEM; + out.nAlloc = 0; + } + pVar = &utf8; + } +#endif + nOut = pVar->n; +#ifdef SQLITE_TRACE_SIZE_LIMIT + if( nOut>SQLITE_TRACE_SIZE_LIMIT ){ + nOut = SQLITE_TRACE_SIZE_LIMIT; + while( nOutn && (pVar->z[nOut]&0xc0)==0x80 ){ nOut++; } + } +#endif + sqlite3_str_appendf(&out, "'%.*q'", nOut, pVar->z); +#ifdef SQLITE_TRACE_SIZE_LIMIT + if( nOutn ){ + sqlite3_str_appendf(&out, "/*+%d bytes*/", pVar->n-nOut); + } +#endif +#ifndef SQLITE_OMIT_UTF16 + if( enc!=SQLITE_UTF8 ) sqlite3VdbeMemRelease(&utf8); +#endif + }else if( pVar->flags & MEM_Zero ){ + sqlite3_str_appendf(&out, "zeroblob(%d)", pVar->u.nZero); + }else{ + int nOut; /* Number of bytes of the blob to include in output */ + assert( pVar->flags & MEM_Blob ); + sqlite3_str_append(&out, "x'", 2); + nOut = pVar->n; +#ifdef SQLITE_TRACE_SIZE_LIMIT + if( nOut>SQLITE_TRACE_SIZE_LIMIT ) nOut = SQLITE_TRACE_SIZE_LIMIT; +#endif + for(i=0; iz[i]&0xff); + } + sqlite3_str_append(&out, "'", 1); +#ifdef SQLITE_TRACE_SIZE_LIMIT + if( nOutn ){ + sqlite3_str_appendf(&out, "/*+%d bytes*/", pVar->n-nOut); + } +#endif + } + } + } + if( out.accError ) sqlite3_str_reset(&out); + return sqlite3StrAccumFinish(&out); +} + +#endif /* #ifndef SQLITE_OMIT_TRACE */ + +/************** End of vdbetrace.c *******************************************/ +/************** Begin file vdbe.c ********************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** The code in this file implements the function that runs the +** bytecode of a prepared statement. +** +** Various scripts scan this source file in order to generate HTML +** documentation, headers files, or other derived files. The formatting +** of the code in this file is, therefore, important. See other comments +** in this file for details. If in doubt, do not deviate from existing +** commenting and indentation practices when changing or adding code. +*/ +/* #include "sqliteInt.h" */ +/* #include "vdbeInt.h" */ + +/* +** Invoke this macro on memory cells just prior to changing the +** value of the cell. This macro verifies that shallow copies are +** not misused. A shallow copy of a string or blob just copies a +** pointer to the string or blob, not the content. If the original +** is changed while the copy is still in use, the string or blob might +** be changed out from under the copy. This macro verifies that nothing +** like that ever happens. +*/ +#ifdef SQLITE_DEBUG +# define memAboutToChange(P,M) sqlite3VdbeMemAboutToChange(P,M) +#else +# define memAboutToChange(P,M) +#endif + +/* +** The following global variable is incremented every time a cursor +** moves, either by the OP_SeekXX, OP_Next, or OP_Prev opcodes. The test +** procedures use this information to make sure that indices are +** working correctly. This variable has no function other than to +** help verify the correct operation of the library. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_search_count = 0; +#endif + +/* +** When this global variable is positive, it gets decremented once before +** each instruction in the VDBE. When it reaches zero, the u1.isInterrupted +** field of the sqlite3 structure is set in order to simulate an interrupt. +** +** This facility is used for testing purposes only. It does not function +** in an ordinary build. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_interrupt_count = 0; +#endif + +/* +** The next global variable is incremented each type the OP_Sort opcode +** is executed. The test procedures use this information to make sure that +** sorting is occurring or not occurring at appropriate times. This variable +** has no function other than to help verify the correct operation of the +** library. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_sort_count = 0; +#endif + +/* +** The next global variable records the size of the largest MEM_Blob +** or MEM_Str that has been used by a VDBE opcode. The test procedures +** use this information to make sure that the zero-blob functionality +** is working correctly. This variable has no function other than to +** help verify the correct operation of the library. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_max_blobsize = 0; +static void updateMaxBlobsize(Mem *p){ + if( (p->flags & (MEM_Str|MEM_Blob))!=0 && p->n>sqlite3_max_blobsize ){ + sqlite3_max_blobsize = p->n; + } +} +#endif + +/* +** This macro evaluates to true if either the update hook or the preupdate +** hook are enabled for database connect DB. +*/ +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK +# define HAS_UPDATE_HOOK(DB) ((DB)->xPreUpdateCallback||(DB)->xUpdateCallback) +#else +# define HAS_UPDATE_HOOK(DB) ((DB)->xUpdateCallback) +#endif + +/* +** The next global variable is incremented each time the OP_Found opcode +** is executed. This is used to test whether or not the foreign key +** operation implemented using OP_FkIsZero is working. This variable +** has no function other than to help verify the correct operation of the +** library. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_found_count = 0; +#endif + +/* +** Test a register to see if it exceeds the current maximum blob size. +** If it does, record the new maximum blob size. +*/ +#if defined(SQLITE_TEST) && !defined(SQLITE_UNTESTABLE) +# define UPDATE_MAX_BLOBSIZE(P) updateMaxBlobsize(P) +#else +# define UPDATE_MAX_BLOBSIZE(P) +#endif + +#ifdef SQLITE_DEBUG +/* This routine provides a convenient place to set a breakpoint during +** tracing with PRAGMA vdbe_trace=on. The breakpoint fires right after +** each opcode is printed. Variables "pc" (program counter) and pOp are +** available to add conditionals to the breakpoint. GDB example: +** +** break test_trace_breakpoint if pc=22 +** +** Other useful labels for breakpoints include: +** test_addop_breakpoint(pc,pOp) +** sqlite3CorruptError(lineno) +** sqlite3MisuseError(lineno) +** sqlite3CantopenError(lineno) +*/ +static void test_trace_breakpoint(int pc, Op *pOp, Vdbe *v){ + static int n = 0; + (void)pc; + (void)pOp; + (void)v; + n++; +} +#endif + +/* +** Invoke the VDBE coverage callback, if that callback is defined. This +** feature is used for test suite validation only and does not appear an +** production builds. +** +** M is the type of branch. I is the direction taken for this instance of +** the branch. +** +** M: 2 - two-way branch (I=0: fall-thru 1: jump ) +** 3 - two-way + NULL (I=0: fall-thru 1: jump 2: NULL ) +** 4 - OP_Jump (I=0: jump p1 1: jump p2 2: jump p3) +** +** In other words, if M is 2, then I is either 0 (for fall-through) or +** 1 (for when the branch is taken). If M is 3, the I is 0 for an +** ordinary fall-through, I is 1 if the branch was taken, and I is 2 +** if the result of comparison is NULL. For M=3, I=2 the jump may or +** may not be taken, depending on the SQLITE_JUMPIFNULL flags in p5. +** When M is 4, that means that an OP_Jump is being run. I is 0, 1, or 2 +** depending on if the operands are less than, equal, or greater than. +** +** iSrcLine is the source code line (from the __LINE__ macro) that +** generated the VDBE instruction combined with flag bits. The source +** code line number is in the lower 24 bits of iSrcLine and the upper +** 8 bytes are flags. The lower three bits of the flags indicate +** values for I that should never occur. For example, if the branch is +** always taken, the flags should be 0x05 since the fall-through and +** alternate branch are never taken. If a branch is never taken then +** flags should be 0x06 since only the fall-through approach is allowed. +** +** Bit 0x08 of the flags indicates an OP_Jump opcode that is only +** interested in equal or not-equal. In other words, I==0 and I==2 +** should be treated as equivalent +** +** Since only a line number is retained, not the filename, this macro +** only works for amalgamation builds. But that is ok, since these macros +** should be no-ops except for special builds used to measure test coverage. +*/ +#if !defined(SQLITE_VDBE_COVERAGE) +# define VdbeBranchTaken(I,M) +#else +# define VdbeBranchTaken(I,M) vdbeTakeBranch(pOp->iSrcLine,I,M) + static void vdbeTakeBranch(u32 iSrcLine, u8 I, u8 M){ + u8 mNever; + assert( I<=2 ); /* 0: fall through, 1: taken, 2: alternate taken */ + assert( M<=4 ); /* 2: two-way branch, 3: three-way branch, 4: OP_Jump */ + assert( I> 24; + assert( (I & mNever)==0 ); + if( sqlite3GlobalConfig.xVdbeBranch==0 ) return; /*NO_TEST*/ + /* Invoke the branch coverage callback with three arguments: + ** iSrcLine - the line number of the VdbeCoverage() macro, with + ** flags removed. + ** I - Mask of bits 0x07 indicating which cases are are + ** fulfilled by this instance of the jump. 0x01 means + ** fall-thru, 0x02 means taken, 0x04 means NULL. Any + ** impossible cases (ex: if the comparison is never NULL) + ** are filled in automatically so that the coverage + ** measurement logic does not flag those impossible cases + ** as missed coverage. + ** M - Type of jump. Same as M argument above + */ + I |= mNever; + if( M==2 ) I |= 0x04; + if( M==4 ){ + I |= 0x08; + if( (mNever&0x08)!=0 && (I&0x05)!=0) I |= 0x05; /*NO_TEST*/ + } + sqlite3GlobalConfig.xVdbeBranch(sqlite3GlobalConfig.pVdbeBranchArg, + iSrcLine&0xffffff, I, M); + } +#endif + +/* +** An ephemeral string value (signified by the MEM_Ephem flag) contains +** a pointer to a dynamically allocated string where some other entity +** is responsible for deallocating that string. Because the register +** does not control the string, it might be deleted without the register +** knowing it. +** +** This routine converts an ephemeral string into a dynamically allocated +** string that the register itself controls. In other words, it +** converts an MEM_Ephem string into a string with P.z==P.zMalloc. +*/ +#define Deephemeralize(P) \ + if( ((P)->flags&MEM_Ephem)!=0 \ + && sqlite3VdbeMemMakeWriteable(P) ){ goto no_mem;} + +/* Return true if the cursor was opened using the OP_OpenSorter opcode. */ +#define isSorter(x) ((x)->eCurType==CURTYPE_SORTER) + +/* +** Allocate VdbeCursor number iCur. Return a pointer to it. Return NULL +** if we run out of memory. +*/ +static VdbeCursor *allocateCursor( + Vdbe *p, /* The virtual machine */ + int iCur, /* Index of the new VdbeCursor */ + int nField, /* Number of fields in the table or index */ + u8 eCurType /* Type of the new cursor */ +){ + /* Find the memory cell that will be used to store the blob of memory + ** required for this VdbeCursor structure. It is convenient to use a + ** vdbe memory cell to manage the memory allocation required for a + ** VdbeCursor structure for the following reasons: + ** + ** * Sometimes cursor numbers are used for a couple of different + ** purposes in a vdbe program. The different uses might require + ** different sized allocations. Memory cells provide growable + ** allocations. + ** + ** * When using ENABLE_MEMORY_MANAGEMENT, memory cell buffers can + ** be freed lazily via the sqlite3_release_memory() API. This + ** minimizes the number of malloc calls made by the system. + ** + ** The memory cell for cursor 0 is aMem[0]. The rest are allocated from + ** the top of the register space. Cursor 1 is at Mem[p->nMem-1]. + ** Cursor 2 is at Mem[p->nMem-2]. And so forth. + */ + Mem *pMem = iCur>0 ? &p->aMem[p->nMem-iCur] : p->aMem; + + int nByte; + VdbeCursor *pCx = 0; + nByte = + ROUND8P(sizeof(VdbeCursor)) + 2*sizeof(u32)*nField + + (eCurType==CURTYPE_BTREE?sqlite3BtreeCursorSize():0); + + assert( iCur>=0 && iCurnCursor ); + if( p->apCsr[iCur] ){ /*OPTIMIZATION-IF-FALSE*/ + sqlite3VdbeFreeCursorNN(p, p->apCsr[iCur]); + p->apCsr[iCur] = 0; + } + + /* There used to be a call to sqlite3VdbeMemClearAndResize() to make sure + ** the pMem used to hold space for the cursor has enough storage available + ** in pMem->zMalloc. But for the special case of the aMem[] entries used + ** to hold cursors, it is faster to in-line the logic. */ + assert( pMem->flags==MEM_Undefined ); + assert( (pMem->flags & MEM_Dyn)==0 ); + assert( pMem->szMalloc==0 || pMem->z==pMem->zMalloc ); + if( pMem->szMallocszMalloc>0 ){ + sqlite3DbFreeNN(pMem->db, pMem->zMalloc); + } + pMem->z = pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, nByte); + if( pMem->zMalloc==0 ){ + pMem->szMalloc = 0; + return 0; + } + pMem->szMalloc = nByte; + } + + p->apCsr[iCur] = pCx = (VdbeCursor*)pMem->zMalloc; + memset(pCx, 0, offsetof(VdbeCursor,pAltCursor)); + pCx->eCurType = eCurType; + pCx->nField = nField; + pCx->aOffset = &pCx->aType[nField]; + if( eCurType==CURTYPE_BTREE ){ + pCx->uc.pCursor = (BtCursor*) + &pMem->z[ROUND8P(sizeof(VdbeCursor))+2*sizeof(u32)*nField]; + sqlite3BtreeCursorZero(pCx->uc.pCursor); + } + return pCx; +} + +/* +** The string in pRec is known to look like an integer and to have a +** floating point value of rValue. Return true and set *piValue to the +** integer value if the string is in range to be an integer. Otherwise, +** return false. +*/ +static int alsoAnInt(Mem *pRec, double rValue, i64 *piValue){ + i64 iValue; + iValue = sqlite3RealToI64(rValue); + if( sqlite3RealSameAsInt(rValue,iValue) ){ + *piValue = iValue; + return 1; + } + return 0==sqlite3Atoi64(pRec->z, piValue, pRec->n, pRec->enc); +} + +/* +** Try to convert a value into a numeric representation if we can +** do so without loss of information. In other words, if the string +** looks like a number, convert it into a number. If it does not +** look like a number, leave it alone. +** +** If the bTryForInt flag is true, then extra effort is made to give +** an integer representation. Strings that look like floating point +** values but which have no fractional component (example: '48.00') +** will have a MEM_Int representation when bTryForInt is true. +** +** If bTryForInt is false, then if the input string contains a decimal +** point or exponential notation, the result is only MEM_Real, even +** if there is an exact integer representation of the quantity. +*/ +static void applyNumericAffinity(Mem *pRec, int bTryForInt){ + double rValue; + u8 enc = pRec->enc; + int rc; + assert( (pRec->flags & (MEM_Str|MEM_Int|MEM_Real|MEM_IntReal))==MEM_Str ); + rc = sqlite3AtoF(pRec->z, &rValue, pRec->n, enc); + if( rc<=0 ) return; + if( rc==1 && alsoAnInt(pRec, rValue, &pRec->u.i) ){ + pRec->flags |= MEM_Int; + }else{ + pRec->u.r = rValue; + pRec->flags |= MEM_Real; + if( bTryForInt ) sqlite3VdbeIntegerAffinity(pRec); + } + /* TEXT->NUMERIC is many->one. Hence, it is important to invalidate the + ** string representation after computing a numeric equivalent, because the + ** string representation might not be the canonical representation for the + ** numeric value. Ticket [343634942dd54ab57b7024] 2018-01-31. */ + pRec->flags &= ~MEM_Str; +} + +/* +** Processing is determine by the affinity parameter: +** +** SQLITE_AFF_INTEGER: +** SQLITE_AFF_REAL: +** SQLITE_AFF_NUMERIC: +** Try to convert pRec to an integer representation or a +** floating-point representation if an integer representation +** is not possible. Note that the integer representation is +** always preferred, even if the affinity is REAL, because +** an integer representation is more space efficient on disk. +** +** SQLITE_AFF_FLEXNUM: +** If the value is text, then try to convert it into a number of +** some kind (integer or real) but do not make any other changes. +** +** SQLITE_AFF_TEXT: +** Convert pRec to a text representation. +** +** SQLITE_AFF_BLOB: +** SQLITE_AFF_NONE: +** No-op. pRec is unchanged. +*/ +static void applyAffinity( + Mem *pRec, /* The value to apply affinity to */ + char affinity, /* The affinity to be applied */ + u8 enc /* Use this text encoding */ +){ + if( affinity>=SQLITE_AFF_NUMERIC ){ + assert( affinity==SQLITE_AFF_INTEGER || affinity==SQLITE_AFF_REAL + || affinity==SQLITE_AFF_NUMERIC || affinity==SQLITE_AFF_FLEXNUM ); + if( (pRec->flags & MEM_Int)==0 ){ /*OPTIMIZATION-IF-FALSE*/ + if( (pRec->flags & (MEM_Real|MEM_IntReal))==0 ){ + if( pRec->flags & MEM_Str ) applyNumericAffinity(pRec,1); + }else if( affinity<=SQLITE_AFF_REAL ){ + sqlite3VdbeIntegerAffinity(pRec); + } + } + }else if( affinity==SQLITE_AFF_TEXT ){ + /* Only attempt the conversion to TEXT if there is an integer or real + ** representation (blob and NULL do not get converted) but no string + ** representation. It would be harmless to repeat the conversion if + ** there is already a string rep, but it is pointless to waste those + ** CPU cycles. */ + if( 0==(pRec->flags&MEM_Str) ){ /*OPTIMIZATION-IF-FALSE*/ + if( (pRec->flags&(MEM_Real|MEM_Int|MEM_IntReal)) ){ + testcase( pRec->flags & MEM_Int ); + testcase( pRec->flags & MEM_Real ); + testcase( pRec->flags & MEM_IntReal ); + sqlite3VdbeMemStringify(pRec, enc, 1); + } + } + pRec->flags &= ~(MEM_Real|MEM_Int|MEM_IntReal); + } +} + +/* +** Try to convert the type of a function argument or a result column +** into a numeric representation. Use either INTEGER or REAL whichever +** is appropriate. But only do the conversion if it is possible without +** loss of information and return the revised type of the argument. +*/ +SQLITE_API int sqlite3_value_numeric_type(sqlite3_value *pVal){ + int eType = sqlite3_value_type(pVal); + if( eType==SQLITE_TEXT ){ + Mem *pMem = (Mem*)pVal; + applyNumericAffinity(pMem, 0); + eType = sqlite3_value_type(pVal); + } + return eType; +} + +/* +** Exported version of applyAffinity(). This one works on sqlite3_value*, +** not the internal Mem* type. +*/ +SQLITE_PRIVATE void sqlite3ValueApplyAffinity( + sqlite3_value *pVal, + u8 affinity, + u8 enc +){ + applyAffinity((Mem *)pVal, affinity, enc); +} + +/* +** pMem currently only holds a string type (or maybe a BLOB that we can +** interpret as a string if we want to). Compute its corresponding +** numeric type, if has one. Set the pMem->u.r and pMem->u.i fields +** accordingly. +*/ +static u16 SQLITE_NOINLINE computeNumericType(Mem *pMem){ + int rc; + sqlite3_int64 ix; + assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal))==0 ); + assert( (pMem->flags & (MEM_Str|MEM_Blob))!=0 ); + if( ExpandBlob(pMem) ){ + pMem->u.i = 0; + return MEM_Int; + } + rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc); + if( rc<=0 ){ + if( rc==0 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1 ){ + pMem->u.i = ix; + return MEM_Int; + }else{ + return MEM_Real; + } + }else if( rc==1 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)==0 ){ + pMem->u.i = ix; + return MEM_Int; + } + return MEM_Real; +} + +/* +** Return the numeric type for pMem, either MEM_Int or MEM_Real or both or +** none. +** +** Unlike applyNumericAffinity(), this routine does not modify pMem->flags. +** But it does set pMem->u.r and pMem->u.i appropriately. +*/ +static u16 numericType(Mem *pMem){ + assert( (pMem->flags & MEM_Null)==0 + || pMem->db==0 || pMem->db->mallocFailed ); + if( pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null) ){ + testcase( pMem->flags & MEM_Int ); + testcase( pMem->flags & MEM_Real ); + testcase( pMem->flags & MEM_IntReal ); + return pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null); + } + assert( pMem->flags & (MEM_Str|MEM_Blob) ); + testcase( pMem->flags & MEM_Str ); + testcase( pMem->flags & MEM_Blob ); + return computeNumericType(pMem); + return 0; +} + +#ifdef SQLITE_DEBUG +/* +** Write a nice string representation of the contents of cell pMem +** into buffer zBuf, length nBuf. +*/ +SQLITE_PRIVATE void sqlite3VdbeMemPrettyPrint(Mem *pMem, StrAccum *pStr){ + int f = pMem->flags; + static const char *const encnames[] = {"(X)", "(8)", "(16LE)", "(16BE)"}; + if( f&MEM_Blob ){ + int i; + char c; + if( f & MEM_Dyn ){ + c = 'z'; + assert( (f & (MEM_Static|MEM_Ephem))==0 ); + }else if( f & MEM_Static ){ + c = 't'; + assert( (f & (MEM_Dyn|MEM_Ephem))==0 ); + }else if( f & MEM_Ephem ){ + c = 'e'; + assert( (f & (MEM_Static|MEM_Dyn))==0 ); + }else{ + c = 's'; + } + sqlite3_str_appendf(pStr, "%cx[", c); + for(i=0; i<25 && in; i++){ + sqlite3_str_appendf(pStr, "%02X", ((int)pMem->z[i] & 0xFF)); + } + sqlite3_str_appendf(pStr, "|"); + for(i=0; i<25 && in; i++){ + char z = pMem->z[i]; + sqlite3_str_appendchar(pStr, 1, (z<32||z>126)?'.':z); + } + sqlite3_str_appendf(pStr,"]"); + if( f & MEM_Zero ){ + sqlite3_str_appendf(pStr, "+%dz",pMem->u.nZero); + } + }else if( f & MEM_Str ){ + int j; + u8 c; + if( f & MEM_Dyn ){ + c = 'z'; + assert( (f & (MEM_Static|MEM_Ephem))==0 ); + }else if( f & MEM_Static ){ + c = 't'; + assert( (f & (MEM_Dyn|MEM_Ephem))==0 ); + }else if( f & MEM_Ephem ){ + c = 'e'; + assert( (f & (MEM_Static|MEM_Dyn))==0 ); + }else{ + c = 's'; + } + sqlite3_str_appendf(pStr, " %c%d[", c, pMem->n); + for(j=0; j<25 && jn; j++){ + c = pMem->z[j]; + sqlite3_str_appendchar(pStr, 1, (c>=0x20&&c<=0x7f) ? c : '.'); + } + sqlite3_str_appendf(pStr, "]%s", encnames[pMem->enc]); + } +} +#endif + +#ifdef SQLITE_DEBUG +/* +** Print the value of a register for tracing purposes: +*/ +static void memTracePrint(Mem *p){ + if( p->flags & MEM_Undefined ){ + printf(" undefined"); + }else if( p->flags & MEM_Null ){ + printf(p->flags & MEM_Zero ? " NULL-nochng" : " NULL"); + }else if( (p->flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){ + printf(" si:%lld", p->u.i); + }else if( (p->flags & (MEM_IntReal))!=0 ){ + printf(" ir:%lld", p->u.i); + }else if( p->flags & MEM_Int ){ + printf(" i:%lld", p->u.i); +#ifndef SQLITE_OMIT_FLOATING_POINT + }else if( p->flags & MEM_Real ){ + printf(" r:%.17g", p->u.r); +#endif + }else if( sqlite3VdbeMemIsRowSet(p) ){ + printf(" (rowset)"); + }else{ + StrAccum acc; + char zBuf[1000]; + sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0); + sqlite3VdbeMemPrettyPrint(p, &acc); + printf(" %s", sqlite3StrAccumFinish(&acc)); + } + if( p->flags & MEM_Subtype ) printf(" subtype=0x%02x", p->eSubtype); +} +static void registerTrace(int iReg, Mem *p){ + printf("R[%d] = ", iReg); + memTracePrint(p); + if( p->pScopyFrom ){ + printf(" <== R[%d]", (int)(p->pScopyFrom - &p[-iReg])); + } + printf("\n"); + sqlite3VdbeCheckMemInvariants(p); +} +/**/ void sqlite3PrintMem(Mem *pMem){ + memTracePrint(pMem); + printf("\n"); + fflush(stdout); +} +#endif + +#ifdef SQLITE_DEBUG +/* +** Show the values of all registers in the virtual machine. Used for +** interactive debugging. +*/ +SQLITE_PRIVATE void sqlite3VdbeRegisterDump(Vdbe *v){ + int i; + for(i=1; inMem; i++) registerTrace(i, v->aMem+i); +} +#endif /* SQLITE_DEBUG */ + + +#ifdef SQLITE_DEBUG +# define REGISTER_TRACE(R,M) if(db->flags&SQLITE_VdbeTrace)registerTrace(R,M) +#else +# define REGISTER_TRACE(R,M) +#endif + +#ifndef NDEBUG +/* +** This function is only called from within an assert() expression. It +** checks that the sqlite3.nTransaction variable is correctly set to +** the number of non-transaction savepoints currently in the +** linked list starting at sqlite3.pSavepoint. +** +** Usage: +** +** assert( checkSavepointCount(db) ); +*/ +static int checkSavepointCount(sqlite3 *db){ + int n = 0; + Savepoint *p; + for(p=db->pSavepoint; p; p=p->pNext) n++; + assert( n==(db->nSavepoint + db->isTransactionSavepoint) ); + return 1; +} +#endif + +/* +** Return the register of pOp->p2 after first preparing it to be +** overwritten with an integer value. +*/ +static SQLITE_NOINLINE Mem *out2PrereleaseWithClear(Mem *pOut){ + sqlite3VdbeMemSetNull(pOut); + pOut->flags = MEM_Int; + return pOut; +} +static Mem *out2Prerelease(Vdbe *p, VdbeOp *pOp){ + Mem *pOut; + assert( pOp->p2>0 ); + assert( pOp->p2<=(p->nMem+1 - p->nCursor) ); + pOut = &p->aMem[pOp->p2]; + memAboutToChange(p, pOut); + if( VdbeMemDynamic(pOut) ){ /*OPTIMIZATION-IF-FALSE*/ + return out2PrereleaseWithClear(pOut); + }else{ + pOut->flags = MEM_Int; + return pOut; + } +} + +/* +** Compute a bloom filter hash using pOp->p4.i registers from aMem[] beginning +** with pOp->p3. Return the hash. +*/ +static u64 filterHash(const Mem *aMem, const Op *pOp){ + int i, mx; + u64 h = 0; + + assert( pOp->p4type==P4_INT32 ); + for(i=pOp->p3, mx=i+pOp->p4.i; iflags & (MEM_Int|MEM_IntReal) ){ + h += p->u.i; + }else if( p->flags & MEM_Real ){ + h += sqlite3VdbeIntValue(p); + }else if( p->flags & (MEM_Str|MEM_Blob) ){ + /* All strings have the same hash and all blobs have the same hash, + ** though, at least, those hashes are different from each other and + ** from NULL. */ + h += 4093 + (p->flags & (MEM_Str|MEM_Blob)); + } + } + return h; +} + +/* +** Return the symbolic name for the data type of a pMem +*/ +static const char *vdbeMemTypeName(Mem *pMem){ + static const char *azTypes[] = { + /* SQLITE_INTEGER */ "INT", + /* SQLITE_FLOAT */ "REAL", + /* SQLITE_TEXT */ "TEXT", + /* SQLITE_BLOB */ "BLOB", + /* SQLITE_NULL */ "NULL" + }; + return azTypes[sqlite3_value_type(pMem)-1]; +} + +/* +** Execute as much of a VDBE program as we can. +** This is the core of sqlite3_step(). +*/ +SQLITE_PRIVATE int sqlite3VdbeExec( + Vdbe *p /* The VDBE */ +){ + Op *aOp = p->aOp; /* Copy of p->aOp */ + Op *pOp = aOp; /* Current operation */ +#ifdef SQLITE_DEBUG + Op *pOrigOp; /* Value of pOp at the top of the loop */ + int nExtraDelete = 0; /* Verifies FORDELETE and AUXDELETE flags */ + u8 iCompareIsInit = 0; /* iCompare is initialized */ +#endif + int rc = SQLITE_OK; /* Value to return */ + sqlite3 *db = p->db; /* The database */ + u8 resetSchemaOnFault = 0; /* Reset schema after an error if positive */ + u8 encoding = ENC(db); /* The database encoding */ + int iCompare = 0; /* Result of last comparison */ + u64 nVmStep = 0; /* Number of virtual machine steps */ +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + u64 nProgressLimit; /* Invoke xProgress() when nVmStep reaches this */ +#endif + Mem *aMem = p->aMem; /* Copy of p->aMem */ + Mem *pIn1 = 0; /* 1st input operand */ + Mem *pIn2 = 0; /* 2nd input operand */ + Mem *pIn3 = 0; /* 3rd input operand */ + Mem *pOut = 0; /* Output operand */ +#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || defined(VDBE_PROFILE) + u64 *pnCycle = 0; + int bStmtScanStatus = IS_STMT_SCANSTATUS(db)!=0; +#endif + /*** INSERT STACK UNION HERE ***/ + + assert( p->eVdbeState==VDBE_RUN_STATE ); /* sqlite3_step() verifies this */ + if( DbMaskNonZero(p->lockMask) ){ + sqlite3VdbeEnter(p); + } +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + if( db->xProgress ){ + u32 iPrior = p->aCounter[SQLITE_STMTSTATUS_VM_STEP]; + assert( 0 < db->nProgressOps ); + nProgressLimit = db->nProgressOps - (iPrior % db->nProgressOps); + }else{ + nProgressLimit = LARGEST_UINT64; + } +#endif + if( p->rc==SQLITE_NOMEM ){ + /* This happens if a malloc() inside a call to sqlite3_column_text() or + ** sqlite3_column_text16() failed. */ + goto no_mem; + } + assert( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_BUSY ); + testcase( p->rc!=SQLITE_OK ); + p->rc = SQLITE_OK; + assert( p->bIsReader || p->readOnly!=0 ); + p->iCurrentTime = 0; + assert( p->explain==0 ); + db->busyHandler.nBusy = 0; + if( AtomicLoad(&db->u1.isInterrupted) ) goto abort_due_to_interrupt; + sqlite3VdbeIOTraceSql(p); +#ifdef SQLITE_DEBUG + sqlite3BeginBenignMalloc(); + if( p->pc==0 + && (p->db->flags & (SQLITE_VdbeListing|SQLITE_VdbeEQP|SQLITE_VdbeTrace))!=0 + ){ + int i; + int once = 1; + sqlite3VdbePrintSql(p); + if( p->db->flags & SQLITE_VdbeListing ){ + printf("VDBE Program Listing:\n"); + for(i=0; inOp; i++){ + sqlite3VdbePrintOp(stdout, i, &aOp[i]); + } + } + if( p->db->flags & SQLITE_VdbeEQP ){ + for(i=0; inOp; i++){ + if( aOp[i].opcode==OP_Explain ){ + if( once ) printf("VDBE Query Plan:\n"); + printf("%s\n", aOp[i].p4.z); + once = 0; + } + } + } + if( p->db->flags & SQLITE_VdbeTrace ) printf("VDBE Trace:\n"); + } + sqlite3EndBenignMalloc(); +#endif + for(pOp=&aOp[p->pc]; 1; pOp++){ + /* Errors are detected by individual opcodes, with an immediate + ** jumps to abort_due_to_error. */ + assert( rc==SQLITE_OK ); + + assert( pOp>=aOp && pOp<&aOp[p->nOp]); + nVmStep++; + +#if defined(VDBE_PROFILE) + pOp->nExec++; + pnCycle = &pOp->nCycle; + if( sqlite3NProfileCnt==0 ) *pnCycle -= sqlite3Hwtime(); +#elif defined(SQLITE_ENABLE_STMT_SCANSTATUS) + if( bStmtScanStatus ){ + pOp->nExec++; + pnCycle = &pOp->nCycle; + *pnCycle -= sqlite3Hwtime(); + } +#endif + + /* Only allow tracing if SQLITE_DEBUG is defined. + */ +#ifdef SQLITE_DEBUG + if( db->flags & SQLITE_VdbeTrace ){ + sqlite3VdbePrintOp(stdout, (int)(pOp - aOp), pOp); + test_trace_breakpoint((int)(pOp - aOp),pOp,p); + } +#endif + + + /* Check to see if we need to simulate an interrupt. This only happens + ** if we have a special test build. + */ +#ifdef SQLITE_TEST + if( sqlite3_interrupt_count>0 ){ + sqlite3_interrupt_count--; + if( sqlite3_interrupt_count==0 ){ + sqlite3_interrupt(db); + } + } +#endif + + /* Sanity checking on other operands */ +#ifdef SQLITE_DEBUG + { + u8 opProperty = sqlite3OpcodeProperty[pOp->opcode]; + if( (opProperty & OPFLG_IN1)!=0 ){ + assert( pOp->p1>0 ); + assert( pOp->p1<=(p->nMem+1 - p->nCursor) ); + assert( memIsValid(&aMem[pOp->p1]) ); + assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p1]) ); + REGISTER_TRACE(pOp->p1, &aMem[pOp->p1]); + } + if( (opProperty & OPFLG_IN2)!=0 ){ + assert( pOp->p2>0 ); + assert( pOp->p2<=(p->nMem+1 - p->nCursor) ); + assert( memIsValid(&aMem[pOp->p2]) ); + assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p2]) ); + REGISTER_TRACE(pOp->p2, &aMem[pOp->p2]); + } + if( (opProperty & OPFLG_IN3)!=0 ){ + assert( pOp->p3>0 ); + assert( pOp->p3<=(p->nMem+1 - p->nCursor) ); + assert( memIsValid(&aMem[pOp->p3]) ); + assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p3]) ); + REGISTER_TRACE(pOp->p3, &aMem[pOp->p3]); + } + if( (opProperty & OPFLG_OUT2)!=0 ){ + assert( pOp->p2>0 ); + assert( pOp->p2<=(p->nMem+1 - p->nCursor) ); + memAboutToChange(p, &aMem[pOp->p2]); + } + if( (opProperty & OPFLG_OUT3)!=0 ){ + assert( pOp->p3>0 ); + assert( pOp->p3<=(p->nMem+1 - p->nCursor) ); + memAboutToChange(p, &aMem[pOp->p3]); + } + } +#endif +#ifdef SQLITE_DEBUG + pOrigOp = pOp; +#endif + + switch( pOp->opcode ){ + +/***************************************************************************** +** What follows is a massive switch statement where each case implements a +** separate instruction in the virtual machine. If we follow the usual +** indentation conventions, each case should be indented by 6 spaces. But +** that is a lot of wasted space on the left margin. So the code within +** the switch statement will break with convention and be flush-left. Another +** big comment (similar to this one) will mark the point in the code where +** we transition back to normal indentation. +** +** The formatting of each case is important. The makefile for SQLite +** generates two C files "opcodes.h" and "opcodes.c" by scanning this +** file looking for lines that begin with "case OP_". The opcodes.h files +** will be filled with #defines that give unique integer values to each +** opcode and the opcodes.c file is filled with an array of strings where +** each string is the symbolic name for the corresponding opcode. If the +** case statement is followed by a comment of the form "/# same as ... #/" +** that comment is used to determine the particular value of the opcode. +** +** Other keywords in the comment that follows each case are used to +** construct the OPFLG_INITIALIZER value that initializes opcodeProperty[]. +** Keywords include: in1, in2, in3, out2, out3. See +** the mkopcodeh.awk script for additional information. +** +** Documentation about VDBE opcodes is generated by scanning this file +** for lines of that contain "Opcode:". That line and all subsequent +** comment lines are used in the generation of the opcode.html documentation +** file. +** +** SUMMARY: +** +** Formatting is important to scripts that scan this file. +** Do not deviate from the formatting style currently in use. +** +*****************************************************************************/ + +/* Opcode: Goto * P2 * * * +** +** An unconditional jump to address P2. +** The next instruction executed will be +** the one at index P2 from the beginning of +** the program. +** +** The P1 parameter is not actually used by this opcode. However, it +** is sometimes set to 1 instead of 0 as a hint to the command-line shell +** that this Goto is the bottom of a loop and that the lines from P2 down +** to the current line should be indented for EXPLAIN output. +*/ +case OP_Goto: { /* jump */ + +#ifdef SQLITE_DEBUG + /* In debuggging mode, when the p5 flags is set on an OP_Goto, that + ** means we should really jump back to the preceeding OP_ReleaseReg + ** instruction. */ + if( pOp->p5 ){ + assert( pOp->p2 < (int)(pOp - aOp) ); + assert( pOp->p2 > 1 ); + pOp = &aOp[pOp->p2 - 2]; + assert( pOp[1].opcode==OP_ReleaseReg ); + goto check_for_interrupt; + } +#endif + +jump_to_p2_and_check_for_interrupt: + pOp = &aOp[pOp->p2 - 1]; + + /* Opcodes that are used as the bottom of a loop (OP_Next, OP_Prev, + ** OP_VNext, or OP_SorterNext) all jump here upon + ** completion. Check to see if sqlite3_interrupt() has been called + ** or if the progress callback needs to be invoked. + ** + ** This code uses unstructured "goto" statements and does not look clean. + ** But that is not due to sloppy coding habits. The code is written this + ** way for performance, to avoid having to run the interrupt and progress + ** checks on every opcode. This helps sqlite3_step() to run about 1.5% + ** faster according to "valgrind --tool=cachegrind" */ +check_for_interrupt: + if( AtomicLoad(&db->u1.isInterrupted) ) goto abort_due_to_interrupt; +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + /* Call the progress callback if it is configured and the required number + ** of VDBE ops have been executed (either since this invocation of + ** sqlite3VdbeExec() or since last time the progress callback was called). + ** If the progress callback returns non-zero, exit the virtual machine with + ** a return code SQLITE_ABORT. + */ + while( nVmStep>=nProgressLimit && db->xProgress!=0 ){ + assert( db->nProgressOps!=0 ); + nProgressLimit += db->nProgressOps; + if( db->xProgress(db->pProgressArg) ){ + nProgressLimit = LARGEST_UINT64; + rc = SQLITE_INTERRUPT; + goto abort_due_to_error; + } + } +#endif + + break; +} + +/* Opcode: Gosub P1 P2 * * * +** +** Write the current address onto register P1 +** and then jump to address P2. +*/ +case OP_Gosub: { /* jump */ + assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) ); + pIn1 = &aMem[pOp->p1]; + assert( VdbeMemDynamic(pIn1)==0 ); + memAboutToChange(p, pIn1); + pIn1->flags = MEM_Int; + pIn1->u.i = (int)(pOp-aOp); + REGISTER_TRACE(pOp->p1, pIn1); + goto jump_to_p2_and_check_for_interrupt; +} + +/* Opcode: Return P1 P2 P3 * * +** +** Jump to the address stored in register P1. If P1 is a return address +** register, then this accomplishes a return from a subroutine. +** +** If P3 is 1, then the jump is only taken if register P1 holds an integer +** values, otherwise execution falls through to the next opcode, and the +** OP_Return becomes a no-op. If P3 is 0, then register P1 must hold an +** integer or else an assert() is raised. P3 should be set to 1 when +** this opcode is used in combination with OP_BeginSubrtn, and set to 0 +** otherwise. +** +** The value in register P1 is unchanged by this opcode. +** +** P2 is not used by the byte-code engine. However, if P2 is positive +** and also less than the current address, then the "EXPLAIN" output +** formatter in the CLI will indent all opcodes from the P2 opcode up +** to be not including the current Return. P2 should be the first opcode +** in the subroutine from which this opcode is returning. Thus the P2 +** value is a byte-code indentation hint. See tag-20220407a in +** wherecode.c and shell.c. +*/ +case OP_Return: { /* in1 */ + pIn1 = &aMem[pOp->p1]; + if( pIn1->flags & MEM_Int ){ + if( pOp->p3 ){ VdbeBranchTaken(1, 2); } + pOp = &aOp[pIn1->u.i]; + }else if( ALWAYS(pOp->p3) ){ + VdbeBranchTaken(0, 2); + } + break; +} + +/* Opcode: InitCoroutine P1 P2 P3 * * +** +** Set up register P1 so that it will Yield to the coroutine +** located at address P3. +** +** If P2!=0 then the coroutine implementation immediately follows +** this opcode. So jump over the coroutine implementation to +** address P2. +** +** See also: EndCoroutine +*/ +case OP_InitCoroutine: { /* jump */ + assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) ); + assert( pOp->p2>=0 && pOp->p2nOp ); + assert( pOp->p3>=0 && pOp->p3nOp ); + pOut = &aMem[pOp->p1]; + assert( !VdbeMemDynamic(pOut) ); + pOut->u.i = pOp->p3 - 1; + pOut->flags = MEM_Int; + if( pOp->p2==0 ) break; + + /* Most jump operations do a goto to this spot in order to update + ** the pOp pointer. */ +jump_to_p2: + assert( pOp->p2>0 ); /* There are never any jumps to instruction 0 */ + assert( pOp->p2nOp ); /* Jumps must be in range */ + pOp = &aOp[pOp->p2 - 1]; + break; +} + +/* Opcode: EndCoroutine P1 * * * * +** +** The instruction at the address in register P1 is a Yield. +** Jump to the P2 parameter of that Yield. +** After the jump, register P1 becomes undefined. +** +** See also: InitCoroutine +*/ +case OP_EndCoroutine: { /* in1 */ + VdbeOp *pCaller; + pIn1 = &aMem[pOp->p1]; + assert( pIn1->flags==MEM_Int ); + assert( pIn1->u.i>=0 && pIn1->u.inOp ); + pCaller = &aOp[pIn1->u.i]; + assert( pCaller->opcode==OP_Yield ); + assert( pCaller->p2>=0 && pCaller->p2nOp ); + pOp = &aOp[pCaller->p2 - 1]; + pIn1->flags = MEM_Undefined; + break; +} + +/* Opcode: Yield P1 P2 * * * +** +** Swap the program counter with the value in register P1. This +** has the effect of yielding to a coroutine. +** +** If the coroutine that is launched by this instruction ends with +** Yield or Return then continue to the next instruction. But if +** the coroutine launched by this instruction ends with +** EndCoroutine, then jump to P2 rather than continuing with the +** next instruction. +** +** See also: InitCoroutine +*/ +case OP_Yield: { /* in1, jump */ + int pcDest; + pIn1 = &aMem[pOp->p1]; + assert( VdbeMemDynamic(pIn1)==0 ); + pIn1->flags = MEM_Int; + pcDest = (int)pIn1->u.i; + pIn1->u.i = (int)(pOp - aOp); + REGISTER_TRACE(pOp->p1, pIn1); + pOp = &aOp[pcDest]; + break; +} + +/* Opcode: HaltIfNull P1 P2 P3 P4 P5 +** Synopsis: if r[P3]=null halt +** +** Check the value in register P3. If it is NULL then Halt using +** parameter P1, P2, and P4 as if this were a Halt instruction. If the +** value in register P3 is not NULL, then this routine is a no-op. +** The P5 parameter should be 1. +*/ +case OP_HaltIfNull: { /* in3 */ + pIn3 = &aMem[pOp->p3]; +#ifdef SQLITE_DEBUG + if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); } +#endif + if( (pIn3->flags & MEM_Null)==0 ) break; + /* Fall through into OP_Halt */ + /* no break */ deliberate_fall_through +} + +/* Opcode: Halt P1 P2 * P4 P5 +** +** Exit immediately. All open cursors, etc are closed +** automatically. +** +** P1 is the result code returned by sqlite3_exec(), sqlite3_reset(), +** or sqlite3_finalize(). For a normal halt, this should be SQLITE_OK (0). +** For errors, it can be some other value. If P1!=0 then P2 will determine +** whether or not to rollback the current transaction. Do not rollback +** if P2==OE_Fail. Do the rollback if P2==OE_Rollback. If P2==OE_Abort, +** then back out all changes that have occurred during this execution of the +** VDBE, but do not rollback the transaction. +** +** If P4 is not null then it is an error message string. +** +** P5 is a value between 0 and 4, inclusive, that modifies the P4 string. +** +** 0: (no change) +** 1: NOT NULL contraint failed: P4 +** 2: UNIQUE constraint failed: P4 +** 3: CHECK constraint failed: P4 +** 4: FOREIGN KEY constraint failed: P4 +** +** If P5 is not zero and P4 is NULL, then everything after the ":" is +** omitted. +** +** There is an implied "Halt 0 0 0" instruction inserted at the very end of +** every program. So a jump past the last instruction of the program +** is the same as executing Halt. +*/ +case OP_Halt: { + VdbeFrame *pFrame; + int pcx; + +#ifdef SQLITE_DEBUG + if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); } +#endif + + /* A deliberately coded "OP_Halt SQLITE_INTERNAL * * * *" opcode indicates + ** something is wrong with the code generator. Raise an assertion in order + ** to bring this to the attention of fuzzers and other testing tools. */ + assert( pOp->p1!=SQLITE_INTERNAL ); + + if( p->pFrame && pOp->p1==SQLITE_OK ){ + /* Halt the sub-program. Return control to the parent frame. */ + pFrame = p->pFrame; + p->pFrame = pFrame->pParent; + p->nFrame--; + sqlite3VdbeSetChanges(db, p->nChange); + pcx = sqlite3VdbeFrameRestore(pFrame); + if( pOp->p2==OE_Ignore ){ + /* Instruction pcx is the OP_Program that invoked the sub-program + ** currently being halted. If the p2 instruction of this OP_Halt + ** instruction is set to OE_Ignore, then the sub-program is throwing + ** an IGNORE exception. In this case jump to the address specified + ** as the p2 of the calling OP_Program. */ + pcx = p->aOp[pcx].p2-1; + } + aOp = p->aOp; + aMem = p->aMem; + pOp = &aOp[pcx]; + break; + } + p->rc = pOp->p1; + p->errorAction = (u8)pOp->p2; + assert( pOp->p5<=4 ); + if( p->rc ){ + if( pOp->p5 ){ + static const char * const azType[] = { "NOT NULL", "UNIQUE", "CHECK", + "FOREIGN KEY" }; + testcase( pOp->p5==1 ); + testcase( pOp->p5==2 ); + testcase( pOp->p5==3 ); + testcase( pOp->p5==4 ); + sqlite3VdbeError(p, "%s constraint failed", azType[pOp->p5-1]); + if( pOp->p4.z ){ + p->zErrMsg = sqlite3MPrintf(db, "%z: %s", p->zErrMsg, pOp->p4.z); + } + }else{ + sqlite3VdbeError(p, "%s", pOp->p4.z); + } + pcx = (int)(pOp - aOp); + sqlite3_log(pOp->p1, "abort at %d in [%s]: %s", pcx, p->zSql, p->zErrMsg); + } + rc = sqlite3VdbeHalt(p); + assert( rc==SQLITE_BUSY || rc==SQLITE_OK || rc==SQLITE_ERROR ); + if( rc==SQLITE_BUSY ){ + p->rc = SQLITE_BUSY; + }else{ + assert( rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT ); + assert( rc==SQLITE_OK || db->nDeferredCons>0 || db->nDeferredImmCons>0 ); + rc = p->rc ? SQLITE_ERROR : SQLITE_DONE; + } + goto vdbe_return; +} + +/* Opcode: Integer P1 P2 * * * +** Synopsis: r[P2]=P1 +** +** The 32-bit integer value P1 is written into register P2. +*/ +case OP_Integer: { /* out2 */ + pOut = out2Prerelease(p, pOp); + pOut->u.i = pOp->p1; + break; +} + +/* Opcode: Int64 * P2 * P4 * +** Synopsis: r[P2]=P4 +** +** P4 is a pointer to a 64-bit integer value. +** Write that value into register P2. +*/ +case OP_Int64: { /* out2 */ + pOut = out2Prerelease(p, pOp); + assert( pOp->p4.pI64!=0 ); + pOut->u.i = *pOp->p4.pI64; + break; +} + +#ifndef SQLITE_OMIT_FLOATING_POINT +/* Opcode: Real * P2 * P4 * +** Synopsis: r[P2]=P4 +** +** P4 is a pointer to a 64-bit floating point value. +** Write that value into register P2. +*/ +case OP_Real: { /* same as TK_FLOAT, out2 */ + pOut = out2Prerelease(p, pOp); + pOut->flags = MEM_Real; + assert( !sqlite3IsNaN(*pOp->p4.pReal) ); + pOut->u.r = *pOp->p4.pReal; + break; +} +#endif + +/* Opcode: String8 * P2 * P4 * +** Synopsis: r[P2]='P4' +** +** P4 points to a nul terminated UTF-8 string. This opcode is transformed +** into a String opcode before it is executed for the first time. During +** this transformation, the length of string P4 is computed and stored +** as the P1 parameter. +*/ +case OP_String8: { /* same as TK_STRING, out2 */ + assert( pOp->p4.z!=0 ); + pOut = out2Prerelease(p, pOp); + pOp->p1 = sqlite3Strlen30(pOp->p4.z); + +#ifndef SQLITE_OMIT_UTF16 + if( encoding!=SQLITE_UTF8 ){ + rc = sqlite3VdbeMemSetStr(pOut, pOp->p4.z, -1, SQLITE_UTF8, SQLITE_STATIC); + assert( rc==SQLITE_OK || rc==SQLITE_TOOBIG ); + if( rc ) goto too_big; + if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pOut, encoding) ) goto no_mem; + assert( pOut->szMalloc>0 && pOut->zMalloc==pOut->z ); + assert( VdbeMemDynamic(pOut)==0 ); + pOut->szMalloc = 0; + pOut->flags |= MEM_Static; + if( pOp->p4type==P4_DYNAMIC ){ + sqlite3DbFree(db, pOp->p4.z); + } + pOp->p4type = P4_DYNAMIC; + pOp->p4.z = pOut->z; + pOp->p1 = pOut->n; + } +#endif + if( pOp->p1>db->aLimit[SQLITE_LIMIT_LENGTH] ){ + goto too_big; + } + pOp->opcode = OP_String; + assert( rc==SQLITE_OK ); + /* Fall through to the next case, OP_String */ + /* no break */ deliberate_fall_through +} + +/* Opcode: String P1 P2 P3 P4 P5 +** Synopsis: r[P2]='P4' (len=P1) +** +** The string value P4 of length P1 (bytes) is stored in register P2. +** +** If P3 is not zero and the content of register P3 is equal to P5, then +** the datatype of the register P2 is converted to BLOB. The content is +** the same sequence of bytes, it is merely interpreted as a BLOB instead +** of a string, as if it had been CAST. In other words: +** +** if( P3!=0 and reg[P3]==P5 ) reg[P2] := CAST(reg[P2] as BLOB) +*/ +case OP_String: { /* out2 */ + assert( pOp->p4.z!=0 ); + pOut = out2Prerelease(p, pOp); + pOut->flags = MEM_Str|MEM_Static|MEM_Term; + pOut->z = pOp->p4.z; + pOut->n = pOp->p1; + pOut->enc = encoding; + UPDATE_MAX_BLOBSIZE(pOut); +#ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS + if( pOp->p3>0 ){ + assert( pOp->p3<=(p->nMem+1 - p->nCursor) ); + pIn3 = &aMem[pOp->p3]; + assert( pIn3->flags & MEM_Int ); + if( pIn3->u.i==pOp->p5 ) pOut->flags = MEM_Blob|MEM_Static|MEM_Term; + } +#endif + break; +} + +/* Opcode: BeginSubrtn * P2 * * * +** Synopsis: r[P2]=NULL +** +** Mark the beginning of a subroutine that can be entered in-line +** or that can be called using OP_Gosub. The subroutine should +** be terminated by an OP_Return instruction that has a P1 operand that +** is the same as the P2 operand to this opcode and that has P3 set to 1. +** If the subroutine is entered in-line, then the OP_Return will simply +** fall through. But if the subroutine is entered using OP_Gosub, then +** the OP_Return will jump back to the first instruction after the OP_Gosub. +** +** This routine works by loading a NULL into the P2 register. When the +** return address register contains a NULL, the OP_Return instruction is +** a no-op that simply falls through to the next instruction (assuming that +** the OP_Return opcode has a P3 value of 1). Thus if the subroutine is +** entered in-line, then the OP_Return will cause in-line execution to +** continue. But if the subroutine is entered via OP_Gosub, then the +** OP_Return will cause a return to the address following the OP_Gosub. +** +** This opcode is identical to OP_Null. It has a different name +** only to make the byte code easier to read and verify. +*/ +/* Opcode: Null P1 P2 P3 * * +** Synopsis: r[P2..P3]=NULL +** +** Write a NULL into registers P2. If P3 greater than P2, then also write +** NULL into register P3 and every register in between P2 and P3. If P3 +** is less than P2 (typically P3 is zero) then only register P2 is +** set to NULL. +** +** If the P1 value is non-zero, then also set the MEM_Cleared flag so that +** NULL values will not compare equal even if SQLITE_NULLEQ is set on +** OP_Ne or OP_Eq. +*/ +case OP_BeginSubrtn: +case OP_Null: { /* out2 */ + int cnt; + u16 nullFlag; + pOut = out2Prerelease(p, pOp); + cnt = pOp->p3-pOp->p2; + assert( pOp->p3<=(p->nMem+1 - p->nCursor) ); + pOut->flags = nullFlag = pOp->p1 ? (MEM_Null|MEM_Cleared) : MEM_Null; + pOut->n = 0; +#ifdef SQLITE_DEBUG + pOut->uTemp = 0; +#endif + while( cnt>0 ){ + pOut++; + memAboutToChange(p, pOut); + sqlite3VdbeMemSetNull(pOut); + pOut->flags = nullFlag; + pOut->n = 0; + cnt--; + } + break; +} + +/* Opcode: SoftNull P1 * * * * +** Synopsis: r[P1]=NULL +** +** Set register P1 to have the value NULL as seen by the OP_MakeRecord +** instruction, but do not free any string or blob memory associated with +** the register, so that if the value was a string or blob that was +** previously copied using OP_SCopy, the copies will continue to be valid. +*/ +case OP_SoftNull: { + assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) ); + pOut = &aMem[pOp->p1]; + pOut->flags = (pOut->flags&~(MEM_Undefined|MEM_AffMask))|MEM_Null; + break; +} + +/* Opcode: Blob P1 P2 * P4 * +** Synopsis: r[P2]=P4 (len=P1) +** +** P4 points to a blob of data P1 bytes long. Store this +** blob in register P2. If P4 is a NULL pointer, then construct +** a zero-filled blob that is P1 bytes long in P2. +*/ +case OP_Blob: { /* out2 */ + assert( pOp->p1 <= SQLITE_MAX_LENGTH ); + pOut = out2Prerelease(p, pOp); + if( pOp->p4.z==0 ){ + sqlite3VdbeMemSetZeroBlob(pOut, pOp->p1); + if( sqlite3VdbeMemExpandBlob(pOut) ) goto no_mem; + }else{ + sqlite3VdbeMemSetStr(pOut, pOp->p4.z, pOp->p1, 0, 0); + } + pOut->enc = encoding; + UPDATE_MAX_BLOBSIZE(pOut); + break; +} + +/* Opcode: Variable P1 P2 * P4 * +** Synopsis: r[P2]=parameter(P1,P4) +** +** Transfer the values of bound parameter P1 into register P2 +** +** If the parameter is named, then its name appears in P4. +** The P4 value is used by sqlite3_bind_parameter_name(). +*/ +case OP_Variable: { /* out2 */ + Mem *pVar; /* Value being transferred */ + + assert( pOp->p1>0 && pOp->p1<=p->nVar ); + assert( pOp->p4.z==0 || pOp->p4.z==sqlite3VListNumToName(p->pVList,pOp->p1) ); + pVar = &p->aVar[pOp->p1 - 1]; + if( sqlite3VdbeMemTooBig(pVar) ){ + goto too_big; + } + pOut = &aMem[pOp->p2]; + if( VdbeMemDynamic(pOut) ) sqlite3VdbeMemSetNull(pOut); + memcpy(pOut, pVar, MEMCELLSIZE); + pOut->flags &= ~(MEM_Dyn|MEM_Ephem); + pOut->flags |= MEM_Static|MEM_FromBind; + UPDATE_MAX_BLOBSIZE(pOut); + break; +} + +/* Opcode: Move P1 P2 P3 * * +** Synopsis: r[P2@P3]=r[P1@P3] +** +** Move the P3 values in register P1..P1+P3-1 over into +** registers P2..P2+P3-1. Registers P1..P1+P3-1 are +** left holding a NULL. It is an error for register ranges +** P1..P1+P3-1 and P2..P2+P3-1 to overlap. It is an error +** for P3 to be less than 1. +*/ +case OP_Move: { + int n; /* Number of registers left to copy */ + int p1; /* Register to copy from */ + int p2; /* Register to copy to */ + + n = pOp->p3; + p1 = pOp->p1; + p2 = pOp->p2; + assert( n>0 && p1>0 && p2>0 ); + assert( p1+n<=p2 || p2+n<=p1 ); + + pIn1 = &aMem[p1]; + pOut = &aMem[p2]; + do{ + assert( pOut<=&aMem[(p->nMem+1 - p->nCursor)] ); + assert( pIn1<=&aMem[(p->nMem+1 - p->nCursor)] ); + assert( memIsValid(pIn1) ); + memAboutToChange(p, pOut); + sqlite3VdbeMemMove(pOut, pIn1); +#ifdef SQLITE_DEBUG + pIn1->pScopyFrom = 0; + { int i; + for(i=1; inMem; i++){ + if( aMem[i].pScopyFrom==pIn1 ){ + aMem[i].pScopyFrom = pOut; + } + } + } +#endif + Deephemeralize(pOut); + REGISTER_TRACE(p2++, pOut); + pIn1++; + pOut++; + }while( --n ); + break; +} + +/* Opcode: Copy P1 P2 P3 * P5 +** Synopsis: r[P2@P3+1]=r[P1@P3+1] +** +** Make a copy of registers P1..P1+P3 into registers P2..P2+P3. +** +** If the 0x0002 bit of P5 is set then also clear the MEM_Subtype flag in the +** destination. The 0x0001 bit of P5 indicates that this Copy opcode cannot +** be merged. The 0x0001 bit is used by the query planner and does not +** come into play during query execution. +** +** This instruction makes a deep copy of the value. A duplicate +** is made of any string or blob constant. See also OP_SCopy. +*/ +case OP_Copy: { + int n; + + n = pOp->p3; + pIn1 = &aMem[pOp->p1]; + pOut = &aMem[pOp->p2]; + assert( pOut!=pIn1 ); + while( 1 ){ + memAboutToChange(p, pOut); + sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem); + Deephemeralize(pOut); + if( (pOut->flags & MEM_Subtype)!=0 && (pOp->p5 & 0x0002)!=0 ){ + pOut->flags &= ~MEM_Subtype; + } +#ifdef SQLITE_DEBUG + pOut->pScopyFrom = 0; +#endif + REGISTER_TRACE(pOp->p2+pOp->p3-n, pOut); + if( (n--)==0 ) break; + pOut++; + pIn1++; + } + break; +} + +/* Opcode: SCopy P1 P2 * * * +** Synopsis: r[P2]=r[P1] +** +** Make a shallow copy of register P1 into register P2. +** +** This instruction makes a shallow copy of the value. If the value +** is a string or blob, then the copy is only a pointer to the +** original and hence if the original changes so will the copy. +** Worse, if the original is deallocated, the copy becomes invalid. +** Thus the program must guarantee that the original will not change +** during the lifetime of the copy. Use OP_Copy to make a complete +** copy. +*/ +case OP_SCopy: { /* out2 */ + pIn1 = &aMem[pOp->p1]; + pOut = &aMem[pOp->p2]; + assert( pOut!=pIn1 ); + sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem); +#ifdef SQLITE_DEBUG + pOut->pScopyFrom = pIn1; + pOut->mScopyFlags = pIn1->flags; +#endif + break; +} + +/* Opcode: IntCopy P1 P2 * * * +** Synopsis: r[P2]=r[P1] +** +** Transfer the integer value held in register P1 into register P2. +** +** This is an optimized version of SCopy that works only for integer +** values. +*/ +case OP_IntCopy: { /* out2 */ + pIn1 = &aMem[pOp->p1]; + assert( (pIn1->flags & MEM_Int)!=0 ); + pOut = &aMem[pOp->p2]; + sqlite3VdbeMemSetInt64(pOut, pIn1->u.i); + break; +} + +/* Opcode: FkCheck * * * * * +** +** Halt with an SQLITE_CONSTRAINT error if there are any unresolved +** foreign key constraint violations. If there are no foreign key +** constraint violations, this is a no-op. +** +** FK constraint violations are also checked when the prepared statement +** exits. This opcode is used to raise foreign key constraint errors prior +** to returning results such as a row change count or the result of a +** RETURNING clause. +*/ +case OP_FkCheck: { + if( (rc = sqlite3VdbeCheckFk(p,0))!=SQLITE_OK ){ + goto abort_due_to_error; + } + break; +} + +/* Opcode: ResultRow P1 P2 * * * +** Synopsis: output=r[P1@P2] +** +** The registers P1 through P1+P2-1 contain a single row of +** results. This opcode causes the sqlite3_step() call to terminate +** with an SQLITE_ROW return code and it sets up the sqlite3_stmt +** structure to provide access to the r(P1)..r(P1+P2-1) values as +** the result row. +*/ +case OP_ResultRow: { + assert( p->nResColumn==pOp->p2 ); + assert( pOp->p1>0 || CORRUPT_DB ); + assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 ); + + p->cacheCtr = (p->cacheCtr + 2)|1; + p->pResultRow = &aMem[pOp->p1]; +#ifdef SQLITE_DEBUG + { + Mem *pMem = p->pResultRow; + int i; + for(i=0; ip2; i++){ + assert( memIsValid(&pMem[i]) ); + REGISTER_TRACE(pOp->p1+i, &pMem[i]); + /* The registers in the result will not be used again when the + ** prepared statement restarts. This is because sqlite3_column() + ** APIs might have caused type conversions of made other changes to + ** the register values. Therefore, we can go ahead and break any + ** OP_SCopy dependencies. */ + pMem[i].pScopyFrom = 0; + } + } +#endif + if( db->mallocFailed ) goto no_mem; + if( db->mTrace & SQLITE_TRACE_ROW ){ + db->trace.xV2(SQLITE_TRACE_ROW, db->pTraceArg, p, 0); + } + p->pc = (int)(pOp - aOp) + 1; + rc = SQLITE_ROW; + goto vdbe_return; +} + +/* Opcode: Concat P1 P2 P3 * * +** Synopsis: r[P3]=r[P2]+r[P1] +** +** Add the text in register P1 onto the end of the text in +** register P2 and store the result in register P3. +** If either the P1 or P2 text are NULL then store NULL in P3. +** +** P3 = P2 || P1 +** +** It is illegal for P1 and P3 to be the same register. Sometimes, +** if P3 is the same register as P2, the implementation is able +** to avoid a memcpy(). +*/ +case OP_Concat: { /* same as TK_CONCAT, in1, in2, out3 */ + i64 nByte; /* Total size of the output string or blob */ + u16 flags1; /* Initial flags for P1 */ + u16 flags2; /* Initial flags for P2 */ + + pIn1 = &aMem[pOp->p1]; + pIn2 = &aMem[pOp->p2]; + pOut = &aMem[pOp->p3]; + testcase( pOut==pIn2 ); + assert( pIn1!=pOut ); + flags1 = pIn1->flags; + testcase( flags1 & MEM_Null ); + testcase( pIn2->flags & MEM_Null ); + if( (flags1 | pIn2->flags) & MEM_Null ){ + sqlite3VdbeMemSetNull(pOut); + break; + } + if( (flags1 & (MEM_Str|MEM_Blob))==0 ){ + if( sqlite3VdbeMemStringify(pIn1,encoding,0) ) goto no_mem; + flags1 = pIn1->flags & ~MEM_Str; + }else if( (flags1 & MEM_Zero)!=0 ){ + if( sqlite3VdbeMemExpandBlob(pIn1) ) goto no_mem; + flags1 = pIn1->flags & ~MEM_Str; + } + flags2 = pIn2->flags; + if( (flags2 & (MEM_Str|MEM_Blob))==0 ){ + if( sqlite3VdbeMemStringify(pIn2,encoding,0) ) goto no_mem; + flags2 = pIn2->flags & ~MEM_Str; + }else if( (flags2 & MEM_Zero)!=0 ){ + if( sqlite3VdbeMemExpandBlob(pIn2) ) goto no_mem; + flags2 = pIn2->flags & ~MEM_Str; + } + nByte = pIn1->n + pIn2->n; + if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){ + goto too_big; + } + if( sqlite3VdbeMemGrow(pOut, (int)nByte+2, pOut==pIn2) ){ + goto no_mem; + } + MemSetTypeFlag(pOut, MEM_Str); + if( pOut!=pIn2 ){ + memcpy(pOut->z, pIn2->z, pIn2->n); + assert( (pIn2->flags & MEM_Dyn) == (flags2 & MEM_Dyn) ); + pIn2->flags = flags2; + } + memcpy(&pOut->z[pIn2->n], pIn1->z, pIn1->n); + assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) ); + pIn1->flags = flags1; + if( encoding>SQLITE_UTF8 ) nByte &= ~1; + pOut->z[nByte]=0; + pOut->z[nByte+1] = 0; + pOut->flags |= MEM_Term; + pOut->n = (int)nByte; + pOut->enc = encoding; + UPDATE_MAX_BLOBSIZE(pOut); + break; +} + +/* Opcode: Add P1 P2 P3 * * +** Synopsis: r[P3]=r[P1]+r[P2] +** +** Add the value in register P1 to the value in register P2 +** and store the result in register P3. +** If either input is NULL, the result is NULL. +*/ +/* Opcode: Multiply P1 P2 P3 * * +** Synopsis: r[P3]=r[P1]*r[P2] +** +** +** Multiply the value in register P1 by the value in register P2 +** and store the result in register P3. +** If either input is NULL, the result is NULL. +*/ +/* Opcode: Subtract P1 P2 P3 * * +** Synopsis: r[P3]=r[P2]-r[P1] +** +** Subtract the value in register P1 from the value in register P2 +** and store the result in register P3. +** If either input is NULL, the result is NULL. +*/ +/* Opcode: Divide P1 P2 P3 * * +** Synopsis: r[P3]=r[P2]/r[P1] +** +** Divide the value in register P1 by the value in register P2 +** and store the result in register P3 (P3=P2/P1). If the value in +** register P1 is zero, then the result is NULL. If either input is +** NULL, the result is NULL. +*/ +/* Opcode: Remainder P1 P2 P3 * * +** Synopsis: r[P3]=r[P2]%r[P1] +** +** Compute the remainder after integer register P2 is divided by +** register P1 and store the result in register P3. +** If the value in register P1 is zero the result is NULL. +** If either operand is NULL, the result is NULL. +*/ +case OP_Add: /* same as TK_PLUS, in1, in2, out3 */ +case OP_Subtract: /* same as TK_MINUS, in1, in2, out3 */ +case OP_Multiply: /* same as TK_STAR, in1, in2, out3 */ +case OP_Divide: /* same as TK_SLASH, in1, in2, out3 */ +case OP_Remainder: { /* same as TK_REM, in1, in2, out3 */ + u16 type1; /* Numeric type of left operand */ + u16 type2; /* Numeric type of right operand */ + i64 iA; /* Integer value of left operand */ + i64 iB; /* Integer value of right operand */ + double rA; /* Real value of left operand */ + double rB; /* Real value of right operand */ + + pIn1 = &aMem[pOp->p1]; + type1 = pIn1->flags; + pIn2 = &aMem[pOp->p2]; + type2 = pIn2->flags; + pOut = &aMem[pOp->p3]; + if( (type1 & type2 & MEM_Int)!=0 ){ +int_math: + iA = pIn1->u.i; + iB = pIn2->u.i; + switch( pOp->opcode ){ + case OP_Add: if( sqlite3AddInt64(&iB,iA) ) goto fp_math; break; + case OP_Subtract: if( sqlite3SubInt64(&iB,iA) ) goto fp_math; break; + case OP_Multiply: if( sqlite3MulInt64(&iB,iA) ) goto fp_math; break; + case OP_Divide: { + if( iA==0 ) goto arithmetic_result_is_null; + if( iA==-1 && iB==SMALLEST_INT64 ) goto fp_math; + iB /= iA; + break; + } + default: { + if( iA==0 ) goto arithmetic_result_is_null; + if( iA==-1 ) iA = 1; + iB %= iA; + break; + } + } + pOut->u.i = iB; + MemSetTypeFlag(pOut, MEM_Int); + }else if( ((type1 | type2) & MEM_Null)!=0 ){ + goto arithmetic_result_is_null; + }else{ + type1 = numericType(pIn1); + type2 = numericType(pIn2); + if( (type1 & type2 & MEM_Int)!=0 ) goto int_math; +fp_math: + rA = sqlite3VdbeRealValue(pIn1); + rB = sqlite3VdbeRealValue(pIn2); + switch( pOp->opcode ){ + case OP_Add: rB += rA; break; + case OP_Subtract: rB -= rA; break; + case OP_Multiply: rB *= rA; break; + case OP_Divide: { + /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */ + if( rA==(double)0 ) goto arithmetic_result_is_null; + rB /= rA; + break; + } + default: { + iA = sqlite3VdbeIntValue(pIn1); + iB = sqlite3VdbeIntValue(pIn2); + if( iA==0 ) goto arithmetic_result_is_null; + if( iA==-1 ) iA = 1; + rB = (double)(iB % iA); + break; + } + } +#ifdef SQLITE_OMIT_FLOATING_POINT + pOut->u.i = rB; + MemSetTypeFlag(pOut, MEM_Int); +#else + if( sqlite3IsNaN(rB) ){ + goto arithmetic_result_is_null; + } + pOut->u.r = rB; + MemSetTypeFlag(pOut, MEM_Real); +#endif + } + break; + +arithmetic_result_is_null: + sqlite3VdbeMemSetNull(pOut); + break; +} + +/* Opcode: CollSeq P1 * * P4 +** +** P4 is a pointer to a CollSeq object. If the next call to a user function +** or aggregate calls sqlite3GetFuncCollSeq(), this collation sequence will +** be returned. This is used by the built-in min(), max() and nullif() +** functions. +** +** If P1 is not zero, then it is a register that a subsequent min() or +** max() aggregate will set to 1 if the current row is not the minimum or +** maximum. The P1 register is initialized to 0 by this instruction. +** +** The interface used by the implementation of the aforementioned functions +** to retrieve the collation sequence set by this opcode is not available +** publicly. Only built-in functions have access to this feature. +*/ +case OP_CollSeq: { + assert( pOp->p4type==P4_COLLSEQ ); + if( pOp->p1 ){ + sqlite3VdbeMemSetInt64(&aMem[pOp->p1], 0); + } + break; +} + +/* Opcode: BitAnd P1 P2 P3 * * +** Synopsis: r[P3]=r[P1]&r[P2] +** +** Take the bit-wise AND of the values in register P1 and P2 and +** store the result in register P3. +** If either input is NULL, the result is NULL. +*/ +/* Opcode: BitOr P1 P2 P3 * * +** Synopsis: r[P3]=r[P1]|r[P2] +** +** Take the bit-wise OR of the values in register P1 and P2 and +** store the result in register P3. +** If either input is NULL, the result is NULL. +*/ +/* Opcode: ShiftLeft P1 P2 P3 * * +** Synopsis: r[P3]=r[P2]<>r[P1] +** +** Shift the integer value in register P2 to the right by the +** number of bits specified by the integer in register P1. +** Store the result in register P3. +** If either input is NULL, the result is NULL. +*/ +case OP_BitAnd: /* same as TK_BITAND, in1, in2, out3 */ +case OP_BitOr: /* same as TK_BITOR, in1, in2, out3 */ +case OP_ShiftLeft: /* same as TK_LSHIFT, in1, in2, out3 */ +case OP_ShiftRight: { /* same as TK_RSHIFT, in1, in2, out3 */ + i64 iA; + u64 uA; + i64 iB; + u8 op; + + pIn1 = &aMem[pOp->p1]; + pIn2 = &aMem[pOp->p2]; + pOut = &aMem[pOp->p3]; + if( (pIn1->flags | pIn2->flags) & MEM_Null ){ + sqlite3VdbeMemSetNull(pOut); + break; + } + iA = sqlite3VdbeIntValue(pIn2); + iB = sqlite3VdbeIntValue(pIn1); + op = pOp->opcode; + if( op==OP_BitAnd ){ + iA &= iB; + }else if( op==OP_BitOr ){ + iA |= iB; + }else if( iB!=0 ){ + assert( op==OP_ShiftRight || op==OP_ShiftLeft ); + + /* If shifting by a negative amount, shift in the other direction */ + if( iB<0 ){ + assert( OP_ShiftRight==OP_ShiftLeft+1 ); + op = 2*OP_ShiftLeft + 1 - op; + iB = iB>(-64) ? -iB : 64; + } + + if( iB>=64 ){ + iA = (iA>=0 || op==OP_ShiftLeft) ? 0 : -1; + }else{ + memcpy(&uA, &iA, sizeof(uA)); + if( op==OP_ShiftLeft ){ + uA <<= iB; + }else{ + uA >>= iB; + /* Sign-extend on a right shift of a negative number */ + if( iA<0 ) uA |= ((((u64)0xffffffff)<<32)|0xffffffff) << (64-iB); + } + memcpy(&iA, &uA, sizeof(iA)); + } + } + pOut->u.i = iA; + MemSetTypeFlag(pOut, MEM_Int); + break; +} + +/* Opcode: AddImm P1 P2 * * * +** Synopsis: r[P1]=r[P1]+P2 +** +** Add the constant P2 to the value in register P1. +** The result is always an integer. +** +** To force any register to be an integer, just add 0. +*/ +case OP_AddImm: { /* in1 */ + pIn1 = &aMem[pOp->p1]; + memAboutToChange(p, pIn1); + sqlite3VdbeMemIntegerify(pIn1); + pIn1->u.i += pOp->p2; + break; +} + +/* Opcode: MustBeInt P1 P2 * * * +** +** Force the value in register P1 to be an integer. If the value +** in P1 is not an integer and cannot be converted into an integer +** without data loss, then jump immediately to P2, or if P2==0 +** raise an SQLITE_MISMATCH exception. +*/ +case OP_MustBeInt: { /* jump, in1 */ + pIn1 = &aMem[pOp->p1]; + if( (pIn1->flags & MEM_Int)==0 ){ + applyAffinity(pIn1, SQLITE_AFF_NUMERIC, encoding); + if( (pIn1->flags & MEM_Int)==0 ){ + VdbeBranchTaken(1, 2); + if( pOp->p2==0 ){ + rc = SQLITE_MISMATCH; + goto abort_due_to_error; + }else{ + goto jump_to_p2; + } + } + } + VdbeBranchTaken(0, 2); + MemSetTypeFlag(pIn1, MEM_Int); + break; +} + +#ifndef SQLITE_OMIT_FLOATING_POINT +/* Opcode: RealAffinity P1 * * * * +** +** If register P1 holds an integer convert it to a real value. +** +** This opcode is used when extracting information from a column that +** has REAL affinity. Such column values may still be stored as +** integers, for space efficiency, but after extraction we want them +** to have only a real value. +*/ +case OP_RealAffinity: { /* in1 */ + pIn1 = &aMem[pOp->p1]; + if( pIn1->flags & (MEM_Int|MEM_IntReal) ){ + testcase( pIn1->flags & MEM_Int ); + testcase( pIn1->flags & MEM_IntReal ); + sqlite3VdbeMemRealify(pIn1); + REGISTER_TRACE(pOp->p1, pIn1); + } + break; +} +#endif + +#ifndef SQLITE_OMIT_CAST +/* Opcode: Cast P1 P2 * * * +** Synopsis: affinity(r[P1]) +** +** Force the value in register P1 to be the type defined by P2. +** +**
    +**
  • P2=='A' → BLOB +**
  • P2=='B' → TEXT +**
  • P2=='C' → NUMERIC +**
  • P2=='D' → INTEGER +**
  • P2=='E' → REAL +**
+** +** A NULL value is not changed by this routine. It remains NULL. +*/ +case OP_Cast: { /* in1 */ + assert( pOp->p2>=SQLITE_AFF_BLOB && pOp->p2<=SQLITE_AFF_REAL ); + testcase( pOp->p2==SQLITE_AFF_TEXT ); + testcase( pOp->p2==SQLITE_AFF_BLOB ); + testcase( pOp->p2==SQLITE_AFF_NUMERIC ); + testcase( pOp->p2==SQLITE_AFF_INTEGER ); + testcase( pOp->p2==SQLITE_AFF_REAL ); + pIn1 = &aMem[pOp->p1]; + memAboutToChange(p, pIn1); + rc = ExpandBlob(pIn1); + if( rc ) goto abort_due_to_error; + rc = sqlite3VdbeMemCast(pIn1, pOp->p2, encoding); + if( rc ) goto abort_due_to_error; + UPDATE_MAX_BLOBSIZE(pIn1); + REGISTER_TRACE(pOp->p1, pIn1); + break; +} +#endif /* SQLITE_OMIT_CAST */ + +/* Opcode: Eq P1 P2 P3 P4 P5 +** Synopsis: IF r[P3]==r[P1] +** +** Compare the values in register P1 and P3. If reg(P3)==reg(P1) then +** jump to address P2. +** +** The SQLITE_AFF_MASK portion of P5 must be an affinity character - +** SQLITE_AFF_TEXT, SQLITE_AFF_INTEGER, and so forth. An attempt is made +** to coerce both inputs according to this affinity before the +** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric +** affinity is used. Note that the affinity conversions are stored +** back into the input registers P1 and P3. So this opcode can cause +** persistent changes to registers P1 and P3. +** +** Once any conversions have taken place, and neither value is NULL, +** the values are compared. If both values are blobs then memcmp() is +** used to determine the results of the comparison. If both values +** are text, then the appropriate collating function specified in +** P4 is used to do the comparison. If P4 is not specified then +** memcmp() is used to compare text string. If both values are +** numeric, then a numeric comparison is used. If the two values +** are of different types, then numbers are considered less than +** strings and strings are considered less than blobs. +** +** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either +** true or false and is never NULL. If both operands are NULL then the result +** of comparison is true. If either operand is NULL then the result is false. +** If neither operand is NULL the result is the same as it would be if +** the SQLITE_NULLEQ flag were omitted from P5. +** +** This opcode saves the result of comparison for use by the new +** OP_Jump opcode. +*/ +/* Opcode: Ne P1 P2 P3 P4 P5 +** Synopsis: IF r[P3]!=r[P1] +** +** This works just like the Eq opcode except that the jump is taken if +** the operands in registers P1 and P3 are not equal. See the Eq opcode for +** additional information. +*/ +/* Opcode: Lt P1 P2 P3 P4 P5 +** Synopsis: IF r[P3]r[P1] +** +** This works just like the Lt opcode except that the jump is taken if +** the content of register P3 is greater than the content of +** register P1. See the Lt opcode for additional information. +*/ +/* Opcode: Ge P1 P2 P3 P4 P5 +** Synopsis: IF r[P3]>=r[P1] +** +** This works just like the Lt opcode except that the jump is taken if +** the content of register P3 is greater than or equal to the content of +** register P1. See the Lt opcode for additional information. +*/ +case OP_Eq: /* same as TK_EQ, jump, in1, in3 */ +case OP_Ne: /* same as TK_NE, jump, in1, in3 */ +case OP_Lt: /* same as TK_LT, jump, in1, in3 */ +case OP_Le: /* same as TK_LE, jump, in1, in3 */ +case OP_Gt: /* same as TK_GT, jump, in1, in3 */ +case OP_Ge: { /* same as TK_GE, jump, in1, in3 */ + int res, res2; /* Result of the comparison of pIn1 against pIn3 */ + char affinity; /* Affinity to use for comparison */ + u16 flags1; /* Copy of initial value of pIn1->flags */ + u16 flags3; /* Copy of initial value of pIn3->flags */ + + pIn1 = &aMem[pOp->p1]; + pIn3 = &aMem[pOp->p3]; + flags1 = pIn1->flags; + flags3 = pIn3->flags; + if( (flags1 & flags3 & MEM_Int)!=0 ){ + /* Common case of comparison of two integers */ + if( pIn3->u.i > pIn1->u.i ){ + if( sqlite3aGTb[pOp->opcode] ){ + VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3); + goto jump_to_p2; + } + iCompare = +1; + VVA_ONLY( iCompareIsInit = 1; ) + }else if( pIn3->u.i < pIn1->u.i ){ + if( sqlite3aLTb[pOp->opcode] ){ + VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3); + goto jump_to_p2; + } + iCompare = -1; + VVA_ONLY( iCompareIsInit = 1; ) + }else{ + if( sqlite3aEQb[pOp->opcode] ){ + VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3); + goto jump_to_p2; + } + iCompare = 0; + VVA_ONLY( iCompareIsInit = 1; ) + } + VdbeBranchTaken(0, (pOp->p5 & SQLITE_NULLEQ)?2:3); + break; + } + if( (flags1 | flags3)&MEM_Null ){ + /* One or both operands are NULL */ + if( pOp->p5 & SQLITE_NULLEQ ){ + /* If SQLITE_NULLEQ is set (which will only happen if the operator is + ** OP_Eq or OP_Ne) then take the jump or not depending on whether + ** or not both operands are null. + */ + assert( (flags1 & MEM_Cleared)==0 ); + assert( (pOp->p5 & SQLITE_JUMPIFNULL)==0 || CORRUPT_DB ); + testcase( (pOp->p5 & SQLITE_JUMPIFNULL)!=0 ); + if( (flags1&flags3&MEM_Null)!=0 + && (flags3&MEM_Cleared)==0 + ){ + res = 0; /* Operands are equal */ + }else{ + res = ((flags3 & MEM_Null) ? -1 : +1); /* Operands are not equal */ + } + }else{ + /* SQLITE_NULLEQ is clear and at least one operand is NULL, + ** then the result is always NULL. + ** The jump is taken if the SQLITE_JUMPIFNULL bit is set. + */ + VdbeBranchTaken(2,3); + if( pOp->p5 & SQLITE_JUMPIFNULL ){ + goto jump_to_p2; + } + iCompare = 1; /* Operands are not equal */ + VVA_ONLY( iCompareIsInit = 1; ) + break; + } + }else{ + /* Neither operand is NULL and we couldn't do the special high-speed + ** integer comparison case. So do a general-case comparison. */ + affinity = pOp->p5 & SQLITE_AFF_MASK; + if( affinity>=SQLITE_AFF_NUMERIC ){ + if( (flags1 | flags3)&MEM_Str ){ + if( (flags1 & (MEM_Int|MEM_IntReal|MEM_Real|MEM_Str))==MEM_Str ){ + applyNumericAffinity(pIn1,0); + assert( flags3==pIn3->flags || CORRUPT_DB ); + flags3 = pIn3->flags; + } + if( (flags3 & (MEM_Int|MEM_IntReal|MEM_Real|MEM_Str))==MEM_Str ){ + applyNumericAffinity(pIn3,0); + } + } + }else if( affinity==SQLITE_AFF_TEXT && ((flags1 | flags3) & MEM_Str)!=0 ){ + if( (flags1 & MEM_Str)==0 && (flags1&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){ + testcase( pIn1->flags & MEM_Int ); + testcase( pIn1->flags & MEM_Real ); + testcase( pIn1->flags & MEM_IntReal ); + sqlite3VdbeMemStringify(pIn1, encoding, 1); + testcase( (flags1&MEM_Dyn) != (pIn1->flags&MEM_Dyn) ); + flags1 = (pIn1->flags & ~MEM_TypeMask) | (flags1 & MEM_TypeMask); + if( NEVER(pIn1==pIn3) ) flags3 = flags1 | MEM_Str; + } + if( (flags3 & MEM_Str)==0 && (flags3&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){ + testcase( pIn3->flags & MEM_Int ); + testcase( pIn3->flags & MEM_Real ); + testcase( pIn3->flags & MEM_IntReal ); + sqlite3VdbeMemStringify(pIn3, encoding, 1); + testcase( (flags3&MEM_Dyn) != (pIn3->flags&MEM_Dyn) ); + flags3 = (pIn3->flags & ~MEM_TypeMask) | (flags3 & MEM_TypeMask); + } + } + assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 ); + res = sqlite3MemCompare(pIn3, pIn1, pOp->p4.pColl); + } + + /* At this point, res is negative, zero, or positive if reg[P1] is + ** less than, equal to, or greater than reg[P3], respectively. Compute + ** the answer to this operator in res2, depending on what the comparison + ** operator actually is. The next block of code depends on the fact + ** that the 6 comparison operators are consecutive integers in this + ** order: NE, EQ, GT, LE, LT, GE */ + assert( OP_Eq==OP_Ne+1 ); assert( OP_Gt==OP_Ne+2 ); assert( OP_Le==OP_Ne+3 ); + assert( OP_Lt==OP_Ne+4 ); assert( OP_Ge==OP_Ne+5 ); + if( res<0 ){ + res2 = sqlite3aLTb[pOp->opcode]; + }else if( res==0 ){ + res2 = sqlite3aEQb[pOp->opcode]; + }else{ + res2 = sqlite3aGTb[pOp->opcode]; + } + iCompare = res; + VVA_ONLY( iCompareIsInit = 1; ) + + /* Undo any changes made by applyAffinity() to the input registers. */ + assert( (pIn3->flags & MEM_Dyn) == (flags3 & MEM_Dyn) ); + pIn3->flags = flags3; + assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) ); + pIn1->flags = flags1; + + VdbeBranchTaken(res2!=0, (pOp->p5 & SQLITE_NULLEQ)?2:3); + if( res2 ){ + goto jump_to_p2; + } + break; +} + +/* Opcode: ElseEq * P2 * * * +** +** This opcode must follow an OP_Lt or OP_Gt comparison operator. There +** can be zero or more OP_ReleaseReg opcodes intervening, but no other +** opcodes are allowed to occur between this instruction and the previous +** OP_Lt or OP_Gt. +** +** If result of an OP_Eq comparison on the same two operands as the +** prior OP_Lt or OP_Gt would have been true, then jump to P2. +** If the result of an OP_Eq comparison on the two previous +** operands would have been false or NULL, then fall through. +*/ +case OP_ElseEq: { /* same as TK_ESCAPE, jump */ + +#ifdef SQLITE_DEBUG + /* Verify the preconditions of this opcode - that it follows an OP_Lt or + ** OP_Gt with zero or more intervening OP_ReleaseReg opcodes */ + int iAddr; + for(iAddr = (int)(pOp - aOp) - 1; ALWAYS(iAddr>=0); iAddr--){ + if( aOp[iAddr].opcode==OP_ReleaseReg ) continue; + assert( aOp[iAddr].opcode==OP_Lt || aOp[iAddr].opcode==OP_Gt ); + break; + } +#endif /* SQLITE_DEBUG */ + assert( iCompareIsInit ); + VdbeBranchTaken(iCompare==0, 2); + if( iCompare==0 ) goto jump_to_p2; + break; +} + + +/* Opcode: Permutation * * * P4 * +** +** Set the permutation used by the OP_Compare operator in the next +** instruction. The permutation is stored in the P4 operand. +** +** The permutation is only valid for the next opcode which must be +** an OP_Compare that has the OPFLAG_PERMUTE bit set in P5. +** +** The first integer in the P4 integer array is the length of the array +** and does not become part of the permutation. +*/ +case OP_Permutation: { + assert( pOp->p4type==P4_INTARRAY ); + assert( pOp->p4.ai ); + assert( pOp[1].opcode==OP_Compare ); + assert( pOp[1].p5 & OPFLAG_PERMUTE ); + break; +} + +/* Opcode: Compare P1 P2 P3 P4 P5 +** Synopsis: r[P1@P3] <-> r[P2@P3] +** +** Compare two vectors of registers in reg(P1)..reg(P1+P3-1) (call this +** vector "A") and in reg(P2)..reg(P2+P3-1) ("B"). Save the result of +** the comparison for use by the next OP_Jump instruct. +** +** If P5 has the OPFLAG_PERMUTE bit set, then the order of comparison is +** determined by the most recent OP_Permutation operator. If the +** OPFLAG_PERMUTE bit is clear, then register are compared in sequential +** order. +** +** P4 is a KeyInfo structure that defines collating sequences and sort +** orders for the comparison. The permutation applies to registers +** only. The KeyInfo elements are used sequentially. +** +** The comparison is a sort comparison, so NULLs compare equal, +** NULLs are less than numbers, numbers are less than strings, +** and strings are less than blobs. +** +** This opcode must be immediately followed by an OP_Jump opcode. +*/ +case OP_Compare: { + int n; + int i; + int p1; + int p2; + const KeyInfo *pKeyInfo; + u32 idx; + CollSeq *pColl; /* Collating sequence to use on this term */ + int bRev; /* True for DESCENDING sort order */ + u32 *aPermute; /* The permutation */ + + if( (pOp->p5 & OPFLAG_PERMUTE)==0 ){ + aPermute = 0; + }else{ + assert( pOp>aOp ); + assert( pOp[-1].opcode==OP_Permutation ); + assert( pOp[-1].p4type==P4_INTARRAY ); + aPermute = pOp[-1].p4.ai + 1; + assert( aPermute!=0 ); + } + n = pOp->p3; + pKeyInfo = pOp->p4.pKeyInfo; + assert( n>0 ); + assert( pKeyInfo!=0 ); + p1 = pOp->p1; + p2 = pOp->p2; +#ifdef SQLITE_DEBUG + if( aPermute ){ + int k, mx = 0; + for(k=0; k(u32)mx ) mx = aPermute[k]; + assert( p1>0 && p1+mx<=(p->nMem+1 - p->nCursor)+1 ); + assert( p2>0 && p2+mx<=(p->nMem+1 - p->nCursor)+1 ); + }else{ + assert( p1>0 && p1+n<=(p->nMem+1 - p->nCursor)+1 ); + assert( p2>0 && p2+n<=(p->nMem+1 - p->nCursor)+1 ); + } +#endif /* SQLITE_DEBUG */ + for(i=0; inKeyField ); + pColl = pKeyInfo->aColl[i]; + bRev = (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_DESC); + iCompare = sqlite3MemCompare(&aMem[p1+idx], &aMem[p2+idx], pColl); + VVA_ONLY( iCompareIsInit = 1; ) + if( iCompare ){ + if( (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_BIGNULL) + && ((aMem[p1+idx].flags & MEM_Null) || (aMem[p2+idx].flags & MEM_Null)) + ){ + iCompare = -iCompare; + } + if( bRev ) iCompare = -iCompare; + break; + } + } + assert( pOp[1].opcode==OP_Jump ); + break; +} + +/* Opcode: Jump P1 P2 P3 * * +** +** Jump to the instruction at address P1, P2, or P3 depending on whether +** in the most recent OP_Compare instruction the P1 vector was less than, +** equal to, or greater than the P2 vector, respectively. +** +** This opcode must immediately follow an OP_Compare opcode. +*/ +case OP_Jump: { /* jump */ + assert( pOp>aOp && pOp[-1].opcode==OP_Compare ); + assert( iCompareIsInit ); + if( iCompare<0 ){ + VdbeBranchTaken(0,4); pOp = &aOp[pOp->p1 - 1]; + }else if( iCompare==0 ){ + VdbeBranchTaken(1,4); pOp = &aOp[pOp->p2 - 1]; + }else{ + VdbeBranchTaken(2,4); pOp = &aOp[pOp->p3 - 1]; + } + break; +} + +/* Opcode: And P1 P2 P3 * * +** Synopsis: r[P3]=(r[P1] && r[P2]) +** +** Take the logical AND of the values in registers P1 and P2 and +** write the result into register P3. +** +** If either P1 or P2 is 0 (false) then the result is 0 even if +** the other input is NULL. A NULL and true or two NULLs give +** a NULL output. +*/ +/* Opcode: Or P1 P2 P3 * * +** Synopsis: r[P3]=(r[P1] || r[P2]) +** +** Take the logical OR of the values in register P1 and P2 and +** store the answer in register P3. +** +** If either P1 or P2 is nonzero (true) then the result is 1 (true) +** even if the other input is NULL. A NULL and false or two NULLs +** give a NULL output. +*/ +case OP_And: /* same as TK_AND, in1, in2, out3 */ +case OP_Or: { /* same as TK_OR, in1, in2, out3 */ + int v1; /* Left operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */ + int v2; /* Right operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */ + + v1 = sqlite3VdbeBooleanValue(&aMem[pOp->p1], 2); + v2 = sqlite3VdbeBooleanValue(&aMem[pOp->p2], 2); + if( pOp->opcode==OP_And ){ + static const unsigned char and_logic[] = { 0, 0, 0, 0, 1, 2, 0, 2, 2 }; + v1 = and_logic[v1*3+v2]; + }else{ + static const unsigned char or_logic[] = { 0, 1, 2, 1, 1, 1, 2, 1, 2 }; + v1 = or_logic[v1*3+v2]; + } + pOut = &aMem[pOp->p3]; + if( v1==2 ){ + MemSetTypeFlag(pOut, MEM_Null); + }else{ + pOut->u.i = v1; + MemSetTypeFlag(pOut, MEM_Int); + } + break; +} + +/* Opcode: IsTrue P1 P2 P3 P4 * +** Synopsis: r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4 +** +** This opcode implements the IS TRUE, IS FALSE, IS NOT TRUE, and +** IS NOT FALSE operators. +** +** Interpret the value in register P1 as a boolean value. Store that +** boolean (a 0 or 1) in register P2. Or if the value in register P1 is +** NULL, then the P3 is stored in register P2. Invert the answer if P4 +** is 1. +** +** The logic is summarized like this: +** +**
    +**
  • If P3==0 and P4==0 then r[P2] := r[P1] IS TRUE +**
  • If P3==1 and P4==1 then r[P2] := r[P1] IS FALSE +**
  • If P3==0 and P4==1 then r[P2] := r[P1] IS NOT TRUE +**
  • If P3==1 and P4==0 then r[P2] := r[P1] IS NOT FALSE +**
+*/ +case OP_IsTrue: { /* in1, out2 */ + assert( pOp->p4type==P4_INT32 ); + assert( pOp->p4.i==0 || pOp->p4.i==1 ); + assert( pOp->p3==0 || pOp->p3==1 ); + sqlite3VdbeMemSetInt64(&aMem[pOp->p2], + sqlite3VdbeBooleanValue(&aMem[pOp->p1], pOp->p3) ^ pOp->p4.i); + break; +} + +/* Opcode: Not P1 P2 * * * +** Synopsis: r[P2]= !r[P1] +** +** Interpret the value in register P1 as a boolean value. Store the +** boolean complement in register P2. If the value in register P1 is +** NULL, then a NULL is stored in P2. +*/ +case OP_Not: { /* same as TK_NOT, in1, out2 */ + pIn1 = &aMem[pOp->p1]; + pOut = &aMem[pOp->p2]; + if( (pIn1->flags & MEM_Null)==0 ){ + sqlite3VdbeMemSetInt64(pOut, !sqlite3VdbeBooleanValue(pIn1,0)); + }else{ + sqlite3VdbeMemSetNull(pOut); + } + break; +} + +/* Opcode: BitNot P1 P2 * * * +** Synopsis: r[P2]= ~r[P1] +** +** Interpret the content of register P1 as an integer. Store the +** ones-complement of the P1 value into register P2. If P1 holds +** a NULL then store a NULL in P2. +*/ +case OP_BitNot: { /* same as TK_BITNOT, in1, out2 */ + pIn1 = &aMem[pOp->p1]; + pOut = &aMem[pOp->p2]; + sqlite3VdbeMemSetNull(pOut); + if( (pIn1->flags & MEM_Null)==0 ){ + pOut->flags = MEM_Int; + pOut->u.i = ~sqlite3VdbeIntValue(pIn1); + } + break; +} + +/* Opcode: Once P1 P2 * * * +** +** Fall through to the next instruction the first time this opcode is +** encountered on each invocation of the byte-code program. Jump to P2 +** on the second and all subsequent encounters during the same invocation. +** +** Top-level programs determine first invocation by comparing the P1 +** operand against the P1 operand on the OP_Init opcode at the beginning +** of the program. If the P1 values differ, then fall through and make +** the P1 of this opcode equal to the P1 of OP_Init. If P1 values are +** the same then take the jump. +** +** For subprograms, there is a bitmask in the VdbeFrame that determines +** whether or not the jump should be taken. The bitmask is necessary +** because the self-altering code trick does not work for recursive +** triggers. +*/ +case OP_Once: { /* jump */ + u32 iAddr; /* Address of this instruction */ + assert( p->aOp[0].opcode==OP_Init ); + if( p->pFrame ){ + iAddr = (int)(pOp - p->aOp); + if( (p->pFrame->aOnce[iAddr/8] & (1<<(iAddr & 7)))!=0 ){ + VdbeBranchTaken(1, 2); + goto jump_to_p2; + } + p->pFrame->aOnce[iAddr/8] |= 1<<(iAddr & 7); + }else{ + if( p->aOp[0].p1==pOp->p1 ){ + VdbeBranchTaken(1, 2); + goto jump_to_p2; + } + } + VdbeBranchTaken(0, 2); + pOp->p1 = p->aOp[0].p1; + break; +} + +/* Opcode: If P1 P2 P3 * * +** +** Jump to P2 if the value in register P1 is true. The value +** is considered true if it is numeric and non-zero. If the value +** in P1 is NULL then take the jump if and only if P3 is non-zero. +*/ +case OP_If: { /* jump, in1 */ + int c; + c = sqlite3VdbeBooleanValue(&aMem[pOp->p1], pOp->p3); + VdbeBranchTaken(c!=0, 2); + if( c ) goto jump_to_p2; + break; +} + +/* Opcode: IfNot P1 P2 P3 * * +** +** Jump to P2 if the value in register P1 is False. The value +** is considered false if it has a numeric value of zero. If the value +** in P1 is NULL then take the jump if and only if P3 is non-zero. +*/ +case OP_IfNot: { /* jump, in1 */ + int c; + c = !sqlite3VdbeBooleanValue(&aMem[pOp->p1], !pOp->p3); + VdbeBranchTaken(c!=0, 2); + if( c ) goto jump_to_p2; + break; +} + +/* Opcode: IsNull P1 P2 * * * +** Synopsis: if r[P1]==NULL goto P2 +** +** Jump to P2 if the value in register P1 is NULL. +*/ +case OP_IsNull: { /* same as TK_ISNULL, jump, in1 */ + pIn1 = &aMem[pOp->p1]; + VdbeBranchTaken( (pIn1->flags & MEM_Null)!=0, 2); + if( (pIn1->flags & MEM_Null)!=0 ){ + goto jump_to_p2; + } + break; +} + +/* Opcode: IsType P1 P2 P3 P4 P5 +** Synopsis: if typeof(P1.P3) in P5 goto P2 +** +** Jump to P2 if the type of a column in a btree is one of the types specified +** by the P5 bitmask. +** +** P1 is normally a cursor on a btree for which the row decode cache is +** valid through at least column P3. In other words, there should have been +** a prior OP_Column for column P3 or greater. If the cursor is not valid, +** then this opcode might give spurious results. +** The the btree row has fewer than P3 columns, then use P4 as the +** datatype. +** +** If P1 is -1, then P3 is a register number and the datatype is taken +** from the value in that register. +** +** P5 is a bitmask of data types. SQLITE_INTEGER is the least significant +** (0x01) bit. SQLITE_FLOAT is the 0x02 bit. SQLITE_TEXT is 0x04. +** SQLITE_BLOB is 0x08. SQLITE_NULL is 0x10. +** +** WARNING: This opcode does not reliably distinguish between NULL and REAL +** when P1>=0. If the database contains a NaN value, this opcode will think +** that the datatype is REAL when it should be NULL. When P1<0 and the value +** is already stored in register P3, then this opcode does reliably +** distinguish between NULL and REAL. The problem only arises then P1>=0. +** +** Take the jump to address P2 if and only if the datatype of the +** value determined by P1 and P3 corresponds to one of the bits in the +** P5 bitmask. +** +*/ +case OP_IsType: { /* jump */ + VdbeCursor *pC; + u16 typeMask; + u32 serialType; + + assert( pOp->p1>=(-1) && pOp->p1nCursor ); + assert( pOp->p1>=0 || (pOp->p3>=0 && pOp->p3<=(p->nMem+1 - p->nCursor)) ); + if( pOp->p1>=0 ){ + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pOp->p3>=0 ); + if( pOp->p3nHdrParsed ){ + serialType = pC->aType[pOp->p3]; + if( serialType>=12 ){ + if( serialType&1 ){ + typeMask = 0x04; /* SQLITE_TEXT */ + }else{ + typeMask = 0x08; /* SQLITE_BLOB */ + } + }else{ + static const unsigned char aMask[] = { + 0x10, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x2, + 0x01, 0x01, 0x10, 0x10 + }; + testcase( serialType==0 ); + testcase( serialType==1 ); + testcase( serialType==2 ); + testcase( serialType==3 ); + testcase( serialType==4 ); + testcase( serialType==5 ); + testcase( serialType==6 ); + testcase( serialType==7 ); + testcase( serialType==8 ); + testcase( serialType==9 ); + testcase( serialType==10 ); + testcase( serialType==11 ); + typeMask = aMask[serialType]; + } + }else{ + typeMask = 1 << (pOp->p4.i - 1); + testcase( typeMask==0x01 ); + testcase( typeMask==0x02 ); + testcase( typeMask==0x04 ); + testcase( typeMask==0x08 ); + testcase( typeMask==0x10 ); + } + }else{ + assert( memIsValid(&aMem[pOp->p3]) ); + typeMask = 1 << (sqlite3_value_type((sqlite3_value*)&aMem[pOp->p3])-1); + testcase( typeMask==0x01 ); + testcase( typeMask==0x02 ); + testcase( typeMask==0x04 ); + testcase( typeMask==0x08 ); + testcase( typeMask==0x10 ); + } + VdbeBranchTaken( (typeMask & pOp->p5)!=0, 2); + if( typeMask & pOp->p5 ){ + goto jump_to_p2; + } + break; +} + +/* Opcode: ZeroOrNull P1 P2 P3 * * +** Synopsis: r[P2] = 0 OR NULL +** +** If all both registers P1 and P3 are NOT NULL, then store a zero in +** register P2. If either registers P1 or P3 are NULL then put +** a NULL in register P2. +*/ +case OP_ZeroOrNull: { /* in1, in2, out2, in3 */ + if( (aMem[pOp->p1].flags & MEM_Null)!=0 + || (aMem[pOp->p3].flags & MEM_Null)!=0 + ){ + sqlite3VdbeMemSetNull(aMem + pOp->p2); + }else{ + sqlite3VdbeMemSetInt64(aMem + pOp->p2, 0); + } + break; +} + +/* Opcode: NotNull P1 P2 * * * +** Synopsis: if r[P1]!=NULL goto P2 +** +** Jump to P2 if the value in register P1 is not NULL. +*/ +case OP_NotNull: { /* same as TK_NOTNULL, jump, in1 */ + pIn1 = &aMem[pOp->p1]; + VdbeBranchTaken( (pIn1->flags & MEM_Null)==0, 2); + if( (pIn1->flags & MEM_Null)==0 ){ + goto jump_to_p2; + } + break; +} + +/* Opcode: IfNullRow P1 P2 P3 * * +** Synopsis: if P1.nullRow then r[P3]=NULL, goto P2 +** +** Check the cursor P1 to see if it is currently pointing at a NULL row. +** If it is, then set register P3 to NULL and jump immediately to P2. +** If P1 is not on a NULL row, then fall through without making any +** changes. +** +** If P1 is not an open cursor, then this opcode is a no-op. +*/ +case OP_IfNullRow: { /* jump */ + VdbeCursor *pC; + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + if( pC && pC->nullRow ){ + sqlite3VdbeMemSetNull(aMem + pOp->p3); + goto jump_to_p2; + } + break; +} + +#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC +/* Opcode: Offset P1 P2 P3 * * +** Synopsis: r[P3] = sqlite_offset(P1) +** +** Store in register r[P3] the byte offset into the database file that is the +** start of the payload for the record at which that cursor P1 is currently +** pointing. +** +** P2 is the column number for the argument to the sqlite_offset() function. +** This opcode does not use P2 itself, but the P2 value is used by the +** code generator. The P1, P2, and P3 operands to this opcode are the +** same as for OP_Column. +** +** This opcode is only available if SQLite is compiled with the +** -DSQLITE_ENABLE_OFFSET_SQL_FUNC option. +*/ +case OP_Offset: { /* out3 */ + VdbeCursor *pC; /* The VDBE cursor */ + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + pOut = &p->aMem[pOp->p3]; + if( pC==0 || pC->eCurType!=CURTYPE_BTREE ){ + sqlite3VdbeMemSetNull(pOut); + }else{ + if( pC->deferredMoveto ){ + rc = sqlite3VdbeFinishMoveto(pC); + if( rc ) goto abort_due_to_error; + } + if( sqlite3BtreeEof(pC->uc.pCursor) ){ + sqlite3VdbeMemSetNull(pOut); + }else{ + sqlite3VdbeMemSetInt64(pOut, sqlite3BtreeOffset(pC->uc.pCursor)); + } + } + break; +} +#endif /* SQLITE_ENABLE_OFFSET_SQL_FUNC */ + +/* Opcode: Column P1 P2 P3 P4 P5 +** Synopsis: r[P3]=PX cursor P1 column P2 +** +** Interpret the data that cursor P1 points to as a structure built using +** the MakeRecord instruction. (See the MakeRecord opcode for additional +** information about the format of the data.) Extract the P2-th column +** from this record. If there are less than (P2+1) +** values in the record, extract a NULL. +** +** The value extracted is stored in register P3. +** +** If the record contains fewer than P2 fields, then extract a NULL. Or, +** if the P4 argument is a P4_MEM use the value of the P4 argument as +** the result. +** +** If the OPFLAG_LENGTHARG bit is set in P5 then the result is guaranteed +** to only be used by the length() function or the equivalent. The content +** of large blobs is not loaded, thus saving CPU cycles. If the +** OPFLAG_TYPEOFARG bit is set then the result will only be used by the +** typeof() function or the IS NULL or IS NOT NULL operators or the +** equivalent. In this case, all content loading can be omitted. +*/ +case OP_Column: { /* ncycle */ + u32 p2; /* column number to retrieve */ + VdbeCursor *pC; /* The VDBE cursor */ + BtCursor *pCrsr; /* The B-Tree cursor corresponding to pC */ + u32 *aOffset; /* aOffset[i] is offset to start of data for i-th column */ + int len; /* The length of the serialized data for the column */ + int i; /* Loop counter */ + Mem *pDest; /* Where to write the extracted value */ + Mem sMem; /* For storing the record being decoded */ + const u8 *zData; /* Part of the record being decoded */ + const u8 *zHdr; /* Next unparsed byte of the header */ + const u8 *zEndHdr; /* Pointer to first byte after the header */ + u64 offset64; /* 64-bit offset */ + u32 t; /* A type code from the record header */ + Mem *pReg; /* PseudoTable input register */ + + assert( pOp->p1>=0 && pOp->p1nCursor ); + assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) ); + pC = p->apCsr[pOp->p1]; + p2 = (u32)pOp->p2; + +op_column_restart: + assert( pC!=0 ); + assert( p2<(u32)pC->nField + || (pC->eCurType==CURTYPE_PSEUDO && pC->seekResult==0) ); + aOffset = pC->aOffset; + assert( aOffset==pC->aType+pC->nField ); + assert( pC->eCurType!=CURTYPE_VTAB ); + assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow ); + assert( pC->eCurType!=CURTYPE_SORTER ); + + if( pC->cacheStatus!=p->cacheCtr ){ /*OPTIMIZATION-IF-FALSE*/ + if( pC->nullRow ){ + if( pC->eCurType==CURTYPE_PSEUDO && pC->seekResult>0 ){ + /* For the special case of as pseudo-cursor, the seekResult field + ** identifies the register that holds the record */ + pReg = &aMem[pC->seekResult]; + assert( pReg->flags & MEM_Blob ); + assert( memIsValid(pReg) ); + pC->payloadSize = pC->szRow = pReg->n; + pC->aRow = (u8*)pReg->z; + }else{ + pDest = &aMem[pOp->p3]; + memAboutToChange(p, pDest); + sqlite3VdbeMemSetNull(pDest); + goto op_column_out; + } + }else{ + pCrsr = pC->uc.pCursor; + if( pC->deferredMoveto ){ + u32 iMap; + assert( !pC->isEphemeral ); + if( pC->ub.aAltMap && (iMap = pC->ub.aAltMap[1+p2])>0 ){ + pC = pC->pAltCursor; + p2 = iMap - 1; + goto op_column_restart; + } + rc = sqlite3VdbeFinishMoveto(pC); + if( rc ) goto abort_due_to_error; + }else if( sqlite3BtreeCursorHasMoved(pCrsr) ){ + rc = sqlite3VdbeHandleMovedCursor(pC); + if( rc ) goto abort_due_to_error; + goto op_column_restart; + } + assert( pC->eCurType==CURTYPE_BTREE ); + assert( pCrsr ); + assert( sqlite3BtreeCursorIsValid(pCrsr) ); + pC->payloadSize = sqlite3BtreePayloadSize(pCrsr); + pC->aRow = sqlite3BtreePayloadFetch(pCrsr, &pC->szRow); + assert( pC->szRow<=pC->payloadSize ); + assert( pC->szRow<=65536 ); /* Maximum page size is 64KiB */ + } + pC->cacheStatus = p->cacheCtr; + if( (aOffset[0] = pC->aRow[0])<0x80 ){ + pC->iHdrOffset = 1; + }else{ + pC->iHdrOffset = sqlite3GetVarint32(pC->aRow, aOffset); + } + pC->nHdrParsed = 0; + + if( pC->szRowaRow does not have to hold the entire row, but it does at least + ** need to cover the header of the record. If pC->aRow does not contain + ** the complete header, then set it to zero, forcing the header to be + ** dynamically allocated. */ + pC->aRow = 0; + pC->szRow = 0; + + /* Make sure a corrupt database has not given us an oversize header. + ** Do this now to avoid an oversize memory allocation. + ** + ** Type entries can be between 1 and 5 bytes each. But 4 and 5 byte + ** types use so much data space that there can only be 4096 and 32 of + ** them, respectively. So the maximum header length results from a + ** 3-byte type for each of the maximum of 32768 columns plus three + ** extra bytes for the header length itself. 32768*3 + 3 = 98307. + */ + if( aOffset[0] > 98307 || aOffset[0] > pC->payloadSize ){ + goto op_column_corrupt; + } + }else{ + /* This is an optimization. By skipping over the first few tests + ** (ex: pC->nHdrParsed<=p2) in the next section, we achieve a + ** measurable performance gain. + ** + ** This branch is taken even if aOffset[0]==0. Such a record is never + ** generated by SQLite, and could be considered corruption, but we + ** accept it for historical reasons. When aOffset[0]==0, the code this + ** branch jumps to reads past the end of the record, but never more + ** than a few bytes. Even if the record occurs at the end of the page + ** content area, the "page header" comes after the page content and so + ** this overread is harmless. Similar overreads can occur for a corrupt + ** database file. + */ + zData = pC->aRow; + assert( pC->nHdrParsed<=p2 ); /* Conditional skipped */ + testcase( aOffset[0]==0 ); + goto op_column_read_header; + } + }else if( sqlite3BtreeCursorHasMoved(pC->uc.pCursor) ){ + rc = sqlite3VdbeHandleMovedCursor(pC); + if( rc ) goto abort_due_to_error; + goto op_column_restart; + } + + /* Make sure at least the first p2+1 entries of the header have been + ** parsed and valid information is in aOffset[] and pC->aType[]. + */ + if( pC->nHdrParsed<=p2 ){ + /* If there is more header available for parsing in the record, try + ** to extract additional fields up through the p2+1-th field + */ + if( pC->iHdrOffsetaRow==0 ){ + memset(&sMem, 0, sizeof(sMem)); + rc = sqlite3VdbeMemFromBtreeZeroOffset(pC->uc.pCursor,aOffset[0],&sMem); + if( rc!=SQLITE_OK ) goto abort_due_to_error; + zData = (u8*)sMem.z; + }else{ + zData = pC->aRow; + } + + /* Fill in pC->aType[i] and aOffset[i] values through the p2-th field. */ + op_column_read_header: + i = pC->nHdrParsed; + offset64 = aOffset[i]; + zHdr = zData + pC->iHdrOffset; + zEndHdr = zData + aOffset[0]; + testcase( zHdr>=zEndHdr ); + do{ + if( (pC->aType[i] = t = zHdr[0])<0x80 ){ + zHdr++; + offset64 += sqlite3VdbeOneByteSerialTypeLen(t); + }else{ + zHdr += sqlite3GetVarint32(zHdr, &t); + pC->aType[i] = t; + offset64 += sqlite3VdbeSerialTypeLen(t); + } + aOffset[++i] = (u32)(offset64 & 0xffffffff); + }while( (u32)i<=p2 && zHdr=zEndHdr && (zHdr>zEndHdr || offset64!=pC->payloadSize)) + || (offset64 > pC->payloadSize) + ){ + if( aOffset[0]==0 ){ + i = 0; + zHdr = zEndHdr; + }else{ + if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem); + goto op_column_corrupt; + } + } + + pC->nHdrParsed = i; + pC->iHdrOffset = (u32)(zHdr - zData); + if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem); + }else{ + t = 0; + } + + /* If after trying to extract new entries from the header, nHdrParsed is + ** still not up to p2, that means that the record has fewer than p2 + ** columns. So the result will be either the default value or a NULL. + */ + if( pC->nHdrParsed<=p2 ){ + pDest = &aMem[pOp->p3]; + memAboutToChange(p, pDest); + if( pOp->p4type==P4_MEM ){ + sqlite3VdbeMemShallowCopy(pDest, pOp->p4.pMem, MEM_Static); + }else{ + sqlite3VdbeMemSetNull(pDest); + } + goto op_column_out; + } + }else{ + t = pC->aType[p2]; + } + + /* Extract the content for the p2+1-th column. Control can only + ** reach this point if aOffset[p2], aOffset[p2+1], and pC->aType[p2] are + ** all valid. + */ + assert( p2nHdrParsed ); + assert( rc==SQLITE_OK ); + pDest = &aMem[pOp->p3]; + memAboutToChange(p, pDest); + assert( sqlite3VdbeCheckMemInvariants(pDest) ); + if( VdbeMemDynamic(pDest) ){ + sqlite3VdbeMemSetNull(pDest); + } + assert( t==pC->aType[p2] ); + if( pC->szRow>=aOffset[p2+1] ){ + /* This is the common case where the desired content fits on the original + ** page - where the content is not on an overflow page */ + zData = pC->aRow + aOffset[p2]; + if( t<12 ){ + sqlite3VdbeSerialGet(zData, t, pDest); + }else{ + /* If the column value is a string, we need a persistent value, not + ** a MEM_Ephem value. This branch is a fast short-cut that is equivalent + ** to calling sqlite3VdbeSerialGet() and sqlite3VdbeDeephemeralize(). + */ + static const u16 aFlag[] = { MEM_Blob, MEM_Str|MEM_Term }; + pDest->n = len = (t-12)/2; + pDest->enc = encoding; + if( pDest->szMalloc < len+2 ){ + if( len>db->aLimit[SQLITE_LIMIT_LENGTH] ) goto too_big; + pDest->flags = MEM_Null; + if( sqlite3VdbeMemGrow(pDest, len+2, 0) ) goto no_mem; + }else{ + pDest->z = pDest->zMalloc; + } + memcpy(pDest->z, zData, len); + pDest->z[len] = 0; + pDest->z[len+1] = 0; + pDest->flags = aFlag[t&1]; + } + }else{ + pDest->enc = encoding; + /* This branch happens only when content is on overflow pages */ + if( ((pOp->p5 & (OPFLAG_LENGTHARG|OPFLAG_TYPEOFARG))!=0 + && ((t>=12 && (t&1)==0) || (pOp->p5 & OPFLAG_TYPEOFARG)!=0)) + || (len = sqlite3VdbeSerialTypeLen(t))==0 + ){ + /* Content is irrelevant for + ** 1. the typeof() function, + ** 2. the length(X) function if X is a blob, and + ** 3. if the content length is zero. + ** So we might as well use bogus content rather than reading + ** content from disk. + ** + ** Although sqlite3VdbeSerialGet() may read at most 8 bytes from the + ** buffer passed to it, debugging function VdbeMemPrettyPrint() may + ** read more. Use the global constant sqlite3CtypeMap[] as the array, + ** as that array is 256 bytes long (plenty for VdbeMemPrettyPrint()) + ** and it begins with a bunch of zeros. + */ + sqlite3VdbeSerialGet((u8*)sqlite3CtypeMap, t, pDest); + }else{ + if( len>db->aLimit[SQLITE_LIMIT_LENGTH] ) goto too_big; + rc = sqlite3VdbeMemFromBtree(pC->uc.pCursor, aOffset[p2], len, pDest); + if( rc!=SQLITE_OK ) goto abort_due_to_error; + sqlite3VdbeSerialGet((const u8*)pDest->z, t, pDest); + pDest->flags &= ~MEM_Ephem; + } + } + +op_column_out: + UPDATE_MAX_BLOBSIZE(pDest); + REGISTER_TRACE(pOp->p3, pDest); + break; + +op_column_corrupt: + if( aOp[0].p3>0 ){ + pOp = &aOp[aOp[0].p3-1]; + break; + }else{ + rc = SQLITE_CORRUPT_BKPT; + goto abort_due_to_error; + } +} + +/* Opcode: TypeCheck P1 P2 P3 P4 * +** Synopsis: typecheck(r[P1@P2]) +** +** Apply affinities to the range of P2 registers beginning with P1. +** Take the affinities from the Table object in P4. If any value +** cannot be coerced into the correct type, then raise an error. +** +** This opcode is similar to OP_Affinity except that this opcode +** forces the register type to the Table column type. This is used +** to implement "strict affinity". +** +** GENERATED ALWAYS AS ... STATIC columns are only checked if P3 +** is zero. When P3 is non-zero, no type checking occurs for +** static generated columns. Virtual columns are computed at query time +** and so they are never checked. +** +** Preconditions: +** +**
    +**
  • P2 should be the number of non-virtual columns in the +** table of P4. +**
  • Table P4 should be a STRICT table. +**
+** +** If any precondition is false, an assertion fault occurs. +*/ +case OP_TypeCheck: { + Table *pTab; + Column *aCol; + int i; + + assert( pOp->p4type==P4_TABLE ); + pTab = pOp->p4.pTab; + assert( pTab->tabFlags & TF_Strict ); + assert( pTab->nNVCol==pOp->p2 ); + aCol = pTab->aCol; + pIn1 = &aMem[pOp->p1]; + for(i=0; inCol; i++){ + if( aCol[i].colFlags & COLFLAG_GENERATED ){ + if( aCol[i].colFlags & COLFLAG_VIRTUAL ) continue; + if( pOp->p3 ){ pIn1++; continue; } + } + assert( pIn1 < &aMem[pOp->p1+pOp->p2] ); + applyAffinity(pIn1, aCol[i].affinity, encoding); + if( (pIn1->flags & MEM_Null)==0 ){ + switch( aCol[i].eCType ){ + case COLTYPE_BLOB: { + if( (pIn1->flags & MEM_Blob)==0 ) goto vdbe_type_error; + break; + } + case COLTYPE_INTEGER: + case COLTYPE_INT: { + if( (pIn1->flags & MEM_Int)==0 ) goto vdbe_type_error; + break; + } + case COLTYPE_TEXT: { + if( (pIn1->flags & MEM_Str)==0 ) goto vdbe_type_error; + break; + } + case COLTYPE_REAL: { + testcase( (pIn1->flags & (MEM_Real|MEM_IntReal))==MEM_Real ); + assert( (pIn1->flags & MEM_IntReal)==0 ); + if( pIn1->flags & MEM_Int ){ + /* When applying REAL affinity, if the result is still an MEM_Int + ** that will fit in 6 bytes, then change the type to MEM_IntReal + ** so that we keep the high-resolution integer value but know that + ** the type really wants to be REAL. */ + testcase( pIn1->u.i==140737488355328LL ); + testcase( pIn1->u.i==140737488355327LL ); + testcase( pIn1->u.i==-140737488355328LL ); + testcase( pIn1->u.i==-140737488355329LL ); + if( pIn1->u.i<=140737488355327LL && pIn1->u.i>=-140737488355328LL){ + pIn1->flags |= MEM_IntReal; + pIn1->flags &= ~MEM_Int; + }else{ + pIn1->u.r = (double)pIn1->u.i; + pIn1->flags |= MEM_Real; + pIn1->flags &= ~MEM_Int; + } + }else if( (pIn1->flags & (MEM_Real|MEM_IntReal))==0 ){ + goto vdbe_type_error; + } + break; + } + default: { + /* COLTYPE_ANY. Accept anything. */ + break; + } + } + } + REGISTER_TRACE((int)(pIn1-aMem), pIn1); + pIn1++; + } + assert( pIn1 == &aMem[pOp->p1+pOp->p2] ); + break; + +vdbe_type_error: + sqlite3VdbeError(p, "cannot store %s value in %s column %s.%s", + vdbeMemTypeName(pIn1), sqlite3StdType[aCol[i].eCType-1], + pTab->zName, aCol[i].zCnName); + rc = SQLITE_CONSTRAINT_DATATYPE; + goto abort_due_to_error; +} + +/* Opcode: Affinity P1 P2 * P4 * +** Synopsis: affinity(r[P1@P2]) +** +** Apply affinities to a range of P2 registers starting with P1. +** +** P4 is a string that is P2 characters long. The N-th character of the +** string indicates the column affinity that should be used for the N-th +** memory cell in the range. +*/ +case OP_Affinity: { + const char *zAffinity; /* The affinity to be applied */ + + zAffinity = pOp->p4.z; + assert( zAffinity!=0 ); + assert( pOp->p2>0 ); + assert( zAffinity[pOp->p2]==0 ); + pIn1 = &aMem[pOp->p1]; + while( 1 /*exit-by-break*/ ){ + assert( pIn1 <= &p->aMem[(p->nMem+1 - p->nCursor)] ); + assert( zAffinity[0]==SQLITE_AFF_NONE || memIsValid(pIn1) ); + applyAffinity(pIn1, zAffinity[0], encoding); + if( zAffinity[0]==SQLITE_AFF_REAL && (pIn1->flags & MEM_Int)!=0 ){ + /* When applying REAL affinity, if the result is still an MEM_Int + ** that will fit in 6 bytes, then change the type to MEM_IntReal + ** so that we keep the high-resolution integer value but know that + ** the type really wants to be REAL. */ + testcase( pIn1->u.i==140737488355328LL ); + testcase( pIn1->u.i==140737488355327LL ); + testcase( pIn1->u.i==-140737488355328LL ); + testcase( pIn1->u.i==-140737488355329LL ); + if( pIn1->u.i<=140737488355327LL && pIn1->u.i>=-140737488355328LL ){ + pIn1->flags |= MEM_IntReal; + pIn1->flags &= ~MEM_Int; + }else{ + pIn1->u.r = (double)pIn1->u.i; + pIn1->flags |= MEM_Real; + pIn1->flags &= ~(MEM_Int|MEM_Str); + } + } + REGISTER_TRACE((int)(pIn1-aMem), pIn1); + zAffinity++; + if( zAffinity[0]==0 ) break; + pIn1++; + } + break; +} + +/* Opcode: MakeRecord P1 P2 P3 P4 * +** Synopsis: r[P3]=mkrec(r[P1@P2]) +** +** Convert P2 registers beginning with P1 into the [record format] +** use as a data record in a database table or as a key +** in an index. The OP_Column opcode can decode the record later. +** +** P4 may be a string that is P2 characters long. The N-th character of the +** string indicates the column affinity that should be used for the N-th +** field of the index key. +** +** The mapping from character to affinity is given by the SQLITE_AFF_ +** macros defined in sqliteInt.h. +** +** If P4 is NULL then all index fields have the affinity BLOB. +** +** The meaning of P5 depends on whether or not the SQLITE_ENABLE_NULL_TRIM +** compile-time option is enabled: +** +** * If SQLITE_ENABLE_NULL_TRIM is enabled, then the P5 is the index +** of the right-most table that can be null-trimmed. +** +** * If SQLITE_ENABLE_NULL_TRIM is omitted, then P5 has the value +** OPFLAG_NOCHNG_MAGIC if the OP_MakeRecord opcode is allowed to +** accept no-change records with serial_type 10. This value is +** only used inside an assert() and does not affect the end result. +*/ +case OP_MakeRecord: { + Mem *pRec; /* The new record */ + u64 nData; /* Number of bytes of data space */ + int nHdr; /* Number of bytes of header space */ + i64 nByte; /* Data space required for this record */ + i64 nZero; /* Number of zero bytes at the end of the record */ + int nVarint; /* Number of bytes in a varint */ + u32 serial_type; /* Type field */ + Mem *pData0; /* First field to be combined into the record */ + Mem *pLast; /* Last field of the record */ + int nField; /* Number of fields in the record */ + char *zAffinity; /* The affinity string for the record */ + u32 len; /* Length of a field */ + u8 *zHdr; /* Where to write next byte of the header */ + u8 *zPayload; /* Where to write next byte of the payload */ + + /* Assuming the record contains N fields, the record format looks + ** like this: + ** + ** ------------------------------------------------------------------------ + ** | hdr-size | type 0 | type 1 | ... | type N-1 | data0 | ... | data N-1 | + ** ------------------------------------------------------------------------ + ** + ** Data(0) is taken from register P1. Data(1) comes from register P1+1 + ** and so forth. + ** + ** Each type field is a varint representing the serial type of the + ** corresponding data element (see sqlite3VdbeSerialType()). The + ** hdr-size field is also a varint which is the offset from the beginning + ** of the record to data0. + */ + nData = 0; /* Number of bytes of data space */ + nHdr = 0; /* Number of bytes of header space */ + nZero = 0; /* Number of zero bytes at the end of the record */ + nField = pOp->p1; + zAffinity = pOp->p4.z; + assert( nField>0 && pOp->p2>0 && pOp->p2+nField<=(p->nMem+1 - p->nCursor)+1 ); + pData0 = &aMem[nField]; + nField = pOp->p2; + pLast = &pData0[nField-1]; + + /* Identify the output register */ + assert( pOp->p3p1 || pOp->p3>=pOp->p1+pOp->p2 ); + pOut = &aMem[pOp->p3]; + memAboutToChange(p, pOut); + + /* Apply the requested affinity to all inputs + */ + assert( pData0<=pLast ); + if( zAffinity ){ + pRec = pData0; + do{ + applyAffinity(pRec, zAffinity[0], encoding); + if( zAffinity[0]==SQLITE_AFF_REAL && (pRec->flags & MEM_Int) ){ + pRec->flags |= MEM_IntReal; + pRec->flags &= ~(MEM_Int); + } + REGISTER_TRACE((int)(pRec-aMem), pRec); + zAffinity++; + pRec++; + assert( zAffinity[0]==0 || pRec<=pLast ); + }while( zAffinity[0] ); + } + +#ifdef SQLITE_ENABLE_NULL_TRIM + /* NULLs can be safely trimmed from the end of the record, as long as + ** as the schema format is 2 or more and none of the omitted columns + ** have a non-NULL default value. Also, the record must be left with + ** at least one field. If P5>0 then it will be one more than the + ** index of the right-most column with a non-NULL default value */ + if( pOp->p5 ){ + while( (pLast->flags & MEM_Null)!=0 && nField>pOp->p5 ){ + pLast--; + nField--; + } + } +#endif + + /* Loop through the elements that will make up the record to figure + ** out how much space is required for the new record. After this loop, + ** the Mem.uTemp field of each term should hold the serial-type that will + ** be used for that term in the generated record: + ** + ** Mem.uTemp value type + ** --------------- --------------- + ** 0 NULL + ** 1 1-byte signed integer + ** 2 2-byte signed integer + ** 3 3-byte signed integer + ** 4 4-byte signed integer + ** 5 6-byte signed integer + ** 6 8-byte signed integer + ** 7 IEEE float + ** 8 Integer constant 0 + ** 9 Integer constant 1 + ** 10,11 reserved for expansion + ** N>=12 and even BLOB + ** N>=13 and odd text + ** + ** The following additional values are computed: + ** nHdr Number of bytes needed for the record header + ** nData Number of bytes of data space needed for the record + ** nZero Zero bytes at the end of the record + */ + pRec = pLast; + do{ + assert( memIsValid(pRec) ); + if( pRec->flags & MEM_Null ){ + if( pRec->flags & MEM_Zero ){ + /* Values with MEM_Null and MEM_Zero are created by xColumn virtual + ** table methods that never invoke sqlite3_result_xxxxx() while + ** computing an unchanging column value in an UPDATE statement. + ** Give such values a special internal-use-only serial-type of 10 + ** so that they can be passed through to xUpdate and have + ** a true sqlite3_value_nochange(). */ +#ifndef SQLITE_ENABLE_NULL_TRIM + assert( pOp->p5==OPFLAG_NOCHNG_MAGIC || CORRUPT_DB ); +#endif + pRec->uTemp = 10; + }else{ + pRec->uTemp = 0; + } + nHdr++; + }else if( pRec->flags & (MEM_Int|MEM_IntReal) ){ + /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */ + i64 i = pRec->u.i; + u64 uu; + testcase( pRec->flags & MEM_Int ); + testcase( pRec->flags & MEM_IntReal ); + if( i<0 ){ + uu = ~i; + }else{ + uu = i; + } + nHdr++; + testcase( uu==127 ); testcase( uu==128 ); + testcase( uu==32767 ); testcase( uu==32768 ); + testcase( uu==8388607 ); testcase( uu==8388608 ); + testcase( uu==2147483647 ); testcase( uu==2147483648LL ); + testcase( uu==140737488355327LL ); testcase( uu==140737488355328LL ); + if( uu<=127 ){ + if( (i&1)==i && p->minWriteFileFormat>=4 ){ + pRec->uTemp = 8+(u32)uu; + }else{ + nData++; + pRec->uTemp = 1; + } + }else if( uu<=32767 ){ + nData += 2; + pRec->uTemp = 2; + }else if( uu<=8388607 ){ + nData += 3; + pRec->uTemp = 3; + }else if( uu<=2147483647 ){ + nData += 4; + pRec->uTemp = 4; + }else if( uu<=140737488355327LL ){ + nData += 6; + pRec->uTemp = 5; + }else{ + nData += 8; + if( pRec->flags & MEM_IntReal ){ + /* If the value is IntReal and is going to take up 8 bytes to store + ** as an integer, then we might as well make it an 8-byte floating + ** point value */ + pRec->u.r = (double)pRec->u.i; + pRec->flags &= ~MEM_IntReal; + pRec->flags |= MEM_Real; + pRec->uTemp = 7; + }else{ + pRec->uTemp = 6; + } + } + }else if( pRec->flags & MEM_Real ){ + nHdr++; + nData += 8; + pRec->uTemp = 7; + }else{ + assert( db->mallocFailed || pRec->flags&(MEM_Str|MEM_Blob) ); + assert( pRec->n>=0 ); + len = (u32)pRec->n; + serial_type = (len*2) + 12 + ((pRec->flags & MEM_Str)!=0); + if( pRec->flags & MEM_Zero ){ + serial_type += pRec->u.nZero*2; + if( nData ){ + if( sqlite3VdbeMemExpandBlob(pRec) ) goto no_mem; + len += pRec->u.nZero; + }else{ + nZero += pRec->u.nZero; + } + } + nData += len; + nHdr += sqlite3VarintLen(serial_type); + pRec->uTemp = serial_type; + } + if( pRec==pData0 ) break; + pRec--; + }while(1); + + /* EVIDENCE-OF: R-22564-11647 The header begins with a single varint + ** which determines the total number of bytes in the header. The varint + ** value is the size of the header in bytes including the size varint + ** itself. */ + testcase( nHdr==126 ); + testcase( nHdr==127 ); + if( nHdr<=126 ){ + /* The common case */ + nHdr += 1; + }else{ + /* Rare case of a really large header */ + nVarint = sqlite3VarintLen(nHdr); + nHdr += nVarint; + if( nVarintp3) is not allowed to + ** be one of the input registers (because the following call to + ** sqlite3VdbeMemClearAndResize() could clobber the value before it is used). + */ + if( nByte+nZero<=pOut->szMalloc ){ + /* The output register is already large enough to hold the record. + ** No error checks or buffer enlargement is required */ + pOut->z = pOut->zMalloc; + }else{ + /* Need to make sure that the output is not too big and then enlarge + ** the output register to hold the full result */ + if( nByte+nZero>db->aLimit[SQLITE_LIMIT_LENGTH] ){ + goto too_big; + } + if( sqlite3VdbeMemClearAndResize(pOut, (int)nByte) ){ + goto no_mem; + } + } + pOut->n = (int)nByte; + pOut->flags = MEM_Blob; + if( nZero ){ + pOut->u.nZero = nZero; + pOut->flags |= MEM_Zero; + } + UPDATE_MAX_BLOBSIZE(pOut); + zHdr = (u8 *)pOut->z; + zPayload = zHdr + nHdr; + + /* Write the record */ + if( nHdr<0x80 ){ + *(zHdr++) = nHdr; + }else{ + zHdr += sqlite3PutVarint(zHdr,nHdr); + } + assert( pData0<=pLast ); + pRec = pData0; + while( 1 /*exit-by-break*/ ){ + serial_type = pRec->uTemp; + /* EVIDENCE-OF: R-06529-47362 Following the size varint are one or more + ** additional varints, one per column. + ** EVIDENCE-OF: R-64536-51728 The values for each column in the record + ** immediately follow the header. */ + if( serial_type<=7 ){ + *(zHdr++) = serial_type; + if( serial_type==0 ){ + /* NULL value. No change in zPayload */ + }else{ + u64 v; + u32 i; + if( serial_type==7 ){ + assert( sizeof(v)==sizeof(pRec->u.r) ); + memcpy(&v, &pRec->u.r, sizeof(v)); + swapMixedEndianFloat(v); + }else{ + v = pRec->u.i; + } + len = i = sqlite3SmallTypeSizes[serial_type]; + assert( i>0 ); + while( 1 /*exit-by-break*/ ){ + zPayload[--i] = (u8)(v&0xFF); + if( i==0 ) break; + v >>= 8; + } + zPayload += len; + } + }else if( serial_type<0x80 ){ + *(zHdr++) = serial_type; + if( serial_type>=14 && pRec->n>0 ){ + assert( pRec->z!=0 ); + memcpy(zPayload, pRec->z, pRec->n); + zPayload += pRec->n; + } + }else{ + zHdr += sqlite3PutVarint(zHdr, serial_type); + if( pRec->n ){ + assert( pRec->z!=0 ); + memcpy(zPayload, pRec->z, pRec->n); + zPayload += pRec->n; + } + } + if( pRec==pLast ) break; + pRec++; + } + assert( nHdr==(int)(zHdr - (u8*)pOut->z) ); + assert( nByte==(int)(zPayload - (u8*)pOut->z) ); + + assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) ); + REGISTER_TRACE(pOp->p3, pOut); + break; +} + +/* Opcode: Count P1 P2 P3 * * +** Synopsis: r[P2]=count() +** +** Store the number of entries (an integer value) in the table or index +** opened by cursor P1 in register P2. +** +** If P3==0, then an exact count is obtained, which involves visiting +** every btree page of the table. But if P3 is non-zero, an estimate +** is returned based on the current cursor position. +*/ +case OP_Count: { /* out2 */ + i64 nEntry; + BtCursor *pCrsr; + + assert( p->apCsr[pOp->p1]->eCurType==CURTYPE_BTREE ); + pCrsr = p->apCsr[pOp->p1]->uc.pCursor; + assert( pCrsr ); + if( pOp->p3 ){ + nEntry = sqlite3BtreeRowCountEst(pCrsr); + }else{ + nEntry = 0; /* Not needed. Only used to silence a warning. */ + rc = sqlite3BtreeCount(db, pCrsr, &nEntry); + if( rc ) goto abort_due_to_error; + } + pOut = out2Prerelease(p, pOp); + pOut->u.i = nEntry; + goto check_for_interrupt; +} + +/* Opcode: Savepoint P1 * * P4 * +** +** Open, release or rollback the savepoint named by parameter P4, depending +** on the value of P1. To open a new savepoint set P1==0 (SAVEPOINT_BEGIN). +** To release (commit) an existing savepoint set P1==1 (SAVEPOINT_RELEASE). +** To rollback an existing savepoint set P1==2 (SAVEPOINT_ROLLBACK). +*/ +case OP_Savepoint: { + int p1; /* Value of P1 operand */ + char *zName; /* Name of savepoint */ + int nName; + Savepoint *pNew; + Savepoint *pSavepoint; + Savepoint *pTmp; + int iSavepoint; + int ii; + + p1 = pOp->p1; + zName = pOp->p4.z; + + /* Assert that the p1 parameter is valid. Also that if there is no open + ** transaction, then there cannot be any savepoints. + */ + assert( db->pSavepoint==0 || db->autoCommit==0 ); + assert( p1==SAVEPOINT_BEGIN||p1==SAVEPOINT_RELEASE||p1==SAVEPOINT_ROLLBACK ); + assert( db->pSavepoint || db->isTransactionSavepoint==0 ); + assert( checkSavepointCount(db) ); + assert( p->bIsReader ); + + if( p1==SAVEPOINT_BEGIN ){ + if( db->nVdbeWrite>0 ){ + /* A new savepoint cannot be created if there are active write + ** statements (i.e. open read/write incremental blob handles). + */ + sqlite3VdbeError(p, "cannot open savepoint - SQL statements in progress"); + rc = SQLITE_BUSY; + }else{ + nName = sqlite3Strlen30(zName); + +#ifndef SQLITE_OMIT_VIRTUALTABLE + /* This call is Ok even if this savepoint is actually a transaction + ** savepoint (and therefore should not prompt xSavepoint()) callbacks. + ** If this is a transaction savepoint being opened, it is guaranteed + ** that the db->aVTrans[] array is empty. */ + assert( db->autoCommit==0 || db->nVTrans==0 ); + rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN, + db->nStatement+db->nSavepoint); + if( rc!=SQLITE_OK ) goto abort_due_to_error; +#endif + + /* Create a new savepoint structure. */ + pNew = sqlite3DbMallocRawNN(db, sizeof(Savepoint)+nName+1); + if( pNew ){ + pNew->zName = (char *)&pNew[1]; + memcpy(pNew->zName, zName, nName+1); + + /* If there is no open transaction, then mark this as a special + ** "transaction savepoint". */ + if( db->autoCommit ){ + db->autoCommit = 0; + db->isTransactionSavepoint = 1; + }else{ + db->nSavepoint++; + } + + /* Link the new savepoint into the database handle's list. */ + pNew->pNext = db->pSavepoint; + db->pSavepoint = pNew; + pNew->nDeferredCons = db->nDeferredCons; + pNew->nDeferredImmCons = db->nDeferredImmCons; + } + } + }else{ + assert( p1==SAVEPOINT_RELEASE || p1==SAVEPOINT_ROLLBACK ); + iSavepoint = 0; + + /* Find the named savepoint. If there is no such savepoint, then an + ** an error is returned to the user. */ + for( + pSavepoint = db->pSavepoint; + pSavepoint && sqlite3StrICmp(pSavepoint->zName, zName); + pSavepoint = pSavepoint->pNext + ){ + iSavepoint++; + } + if( !pSavepoint ){ + sqlite3VdbeError(p, "no such savepoint: %s", zName); + rc = SQLITE_ERROR; + }else if( db->nVdbeWrite>0 && p1==SAVEPOINT_RELEASE ){ + /* It is not possible to release (commit) a savepoint if there are + ** active write statements. + */ + sqlite3VdbeError(p, "cannot release savepoint - " + "SQL statements in progress"); + rc = SQLITE_BUSY; + }else{ + + /* Determine whether or not this is a transaction savepoint. If so, + ** and this is a RELEASE command, then the current transaction + ** is committed. + */ + int isTransaction = pSavepoint->pNext==0 && db->isTransactionSavepoint; + if( isTransaction && p1==SAVEPOINT_RELEASE ){ + if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){ + goto vdbe_return; + } + db->autoCommit = 1; + if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){ + p->pc = (int)(pOp - aOp); + db->autoCommit = 0; + p->rc = rc = SQLITE_BUSY; + goto vdbe_return; + } + rc = p->rc; + if( rc ){ + db->autoCommit = 0; + }else{ + db->isTransactionSavepoint = 0; + } + }else{ + int isSchemaChange; + iSavepoint = db->nSavepoint - iSavepoint - 1; + if( p1==SAVEPOINT_ROLLBACK ){ + isSchemaChange = (db->mDbFlags & DBFLAG_SchemaChange)!=0; + for(ii=0; iinDb; ii++){ + rc = sqlite3BtreeTripAllCursors(db->aDb[ii].pBt, + SQLITE_ABORT_ROLLBACK, + isSchemaChange==0); + if( rc!=SQLITE_OK ) goto abort_due_to_error; + } + }else{ + assert( p1==SAVEPOINT_RELEASE ); + isSchemaChange = 0; + } + for(ii=0; iinDb; ii++){ + rc = sqlite3BtreeSavepoint(db->aDb[ii].pBt, p1, iSavepoint); + if( rc!=SQLITE_OK ){ + goto abort_due_to_error; + } + } + if( isSchemaChange ){ + sqlite3ExpirePreparedStatements(db, 0); + sqlite3ResetAllSchemasOfConnection(db); + db->mDbFlags |= DBFLAG_SchemaChange; + } + } + if( rc ) goto abort_due_to_error; + + /* Regardless of whether this is a RELEASE or ROLLBACK, destroy all + ** savepoints nested inside of the savepoint being operated on. */ + while( db->pSavepoint!=pSavepoint ){ + pTmp = db->pSavepoint; + db->pSavepoint = pTmp->pNext; + sqlite3DbFree(db, pTmp); + db->nSavepoint--; + } + + /* If it is a RELEASE, then destroy the savepoint being operated on + ** too. If it is a ROLLBACK TO, then set the number of deferred + ** constraint violations present in the database to the value stored + ** when the savepoint was created. */ + if( p1==SAVEPOINT_RELEASE ){ + assert( pSavepoint==db->pSavepoint ); + db->pSavepoint = pSavepoint->pNext; + sqlite3DbFree(db, pSavepoint); + if( !isTransaction ){ + db->nSavepoint--; + } + }else{ + assert( p1==SAVEPOINT_ROLLBACK ); + db->nDeferredCons = pSavepoint->nDeferredCons; + db->nDeferredImmCons = pSavepoint->nDeferredImmCons; + } + + if( !isTransaction || p1==SAVEPOINT_ROLLBACK ){ + rc = sqlite3VtabSavepoint(db, p1, iSavepoint); + if( rc!=SQLITE_OK ) goto abort_due_to_error; + } + } + } + if( rc ) goto abort_due_to_error; + if( p->eVdbeState==VDBE_HALT_STATE ){ + rc = SQLITE_DONE; + goto vdbe_return; + } + break; +} + +/* Opcode: AutoCommit P1 P2 * * * +** +** Set the database auto-commit flag to P1 (1 or 0). If P2 is true, roll +** back any currently active btree transactions. If there are any active +** VMs (apart from this one), then a ROLLBACK fails. A COMMIT fails if +** there are active writing VMs or active VMs that use shared cache. +** +** This instruction causes the VM to halt. +*/ +case OP_AutoCommit: { + int desiredAutoCommit; + int iRollback; + + desiredAutoCommit = pOp->p1; + iRollback = pOp->p2; + assert( desiredAutoCommit==1 || desiredAutoCommit==0 ); + assert( desiredAutoCommit==1 || iRollback==0 ); + assert( db->nVdbeActive>0 ); /* At least this one VM is active */ + assert( p->bIsReader ); + + if( desiredAutoCommit!=db->autoCommit ){ + if( iRollback ){ + assert( desiredAutoCommit==1 ); + sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK); + db->autoCommit = 1; + }else if( desiredAutoCommit && db->nVdbeWrite>0 ){ + /* If this instruction implements a COMMIT and other VMs are writing + ** return an error indicating that the other VMs must complete first. + */ + sqlite3VdbeError(p, "cannot commit transaction - " + "SQL statements in progress"); + rc = SQLITE_BUSY; + goto abort_due_to_error; + }else if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){ + goto vdbe_return; + }else{ + db->autoCommit = (u8)desiredAutoCommit; + } + if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){ + p->pc = (int)(pOp - aOp); + db->autoCommit = (u8)(1-desiredAutoCommit); + p->rc = rc = SQLITE_BUSY; + goto vdbe_return; + } + sqlite3CloseSavepoints(db); + if( p->rc==SQLITE_OK ){ + rc = SQLITE_DONE; + }else{ + rc = SQLITE_ERROR; + } + goto vdbe_return; + }else{ + sqlite3VdbeError(p, + (!desiredAutoCommit)?"cannot start a transaction within a transaction":( + (iRollback)?"cannot rollback - no transaction is active": + "cannot commit - no transaction is active")); + + rc = SQLITE_ERROR; + goto abort_due_to_error; + } + /*NOTREACHED*/ assert(0); +} + +/* Opcode: Transaction P1 P2 P3 P4 P5 +** +** Begin a transaction on database P1 if a transaction is not already +** active. +** If P2 is non-zero, then a write-transaction is started, or if a +** read-transaction is already active, it is upgraded to a write-transaction. +** If P2 is zero, then a read-transaction is started. If P2 is 2 or more +** then an exclusive transaction is started. +** +** P1 is the index of the database file on which the transaction is +** started. Index 0 is the main database file and index 1 is the +** file used for temporary tables. Indices of 2 or more are used for +** attached databases. +** +** If a write-transaction is started and the Vdbe.usesStmtJournal flag is +** true (this flag is set if the Vdbe may modify more than one row and may +** throw an ABORT exception), a statement transaction may also be opened. +** More specifically, a statement transaction is opened iff the database +** connection is currently not in autocommit mode, or if there are other +** active statements. A statement transaction allows the changes made by this +** VDBE to be rolled back after an error without having to roll back the +** entire transaction. If no error is encountered, the statement transaction +** will automatically commit when the VDBE halts. +** +** If P5!=0 then this opcode also checks the schema cookie against P3 +** and the schema generation counter against P4. +** The cookie changes its value whenever the database schema changes. +** This operation is used to detect when that the cookie has changed +** and that the current process needs to reread the schema. If the schema +** cookie in P3 differs from the schema cookie in the database header or +** if the schema generation counter in P4 differs from the current +** generation counter, then an SQLITE_SCHEMA error is raised and execution +** halts. The sqlite3_step() wrapper function might then reprepare the +** statement and rerun it from the beginning. +*/ +case OP_Transaction: { + Btree *pBt; + Db *pDb; + int iMeta = 0; + + assert( p->bIsReader ); + assert( p->readOnly==0 || pOp->p2==0 ); + assert( pOp->p2>=0 && pOp->p2<=2 ); + assert( pOp->p1>=0 && pOp->p1nDb ); + assert( DbMaskTest(p->btreeMask, pOp->p1) ); + assert( rc==SQLITE_OK ); + if( pOp->p2 && (db->flags & (SQLITE_QueryOnly|SQLITE_CorruptRdOnly))!=0 ){ + if( db->flags & SQLITE_QueryOnly ){ + /* Writes prohibited by the "PRAGMA query_only=TRUE" statement */ + rc = SQLITE_READONLY; + }else{ + /* Writes prohibited due to a prior SQLITE_CORRUPT in the current + ** transaction */ + rc = SQLITE_CORRUPT; + } + goto abort_due_to_error; + } + pDb = &db->aDb[pOp->p1]; + pBt = pDb->pBt; + + if( pBt ){ + rc = sqlite3BtreeBeginTrans(pBt, pOp->p2, &iMeta); + testcase( rc==SQLITE_BUSY_SNAPSHOT ); + testcase( rc==SQLITE_BUSY_RECOVERY ); + if( rc!=SQLITE_OK ){ + if( (rc&0xff)==SQLITE_BUSY ){ + p->pc = (int)(pOp - aOp); + p->rc = rc; + goto vdbe_return; + } + goto abort_due_to_error; + } + + if( p->usesStmtJournal + && pOp->p2 + && (db->autoCommit==0 || db->nVdbeRead>1) + ){ + assert( sqlite3BtreeTxnState(pBt)==SQLITE_TXN_WRITE ); + if( p->iStatement==0 ){ + assert( db->nStatement>=0 && db->nSavepoint>=0 ); + db->nStatement++; + p->iStatement = db->nSavepoint + db->nStatement; + } + + rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN, p->iStatement-1); + if( rc==SQLITE_OK ){ + rc = sqlite3BtreeBeginStmt(pBt, p->iStatement); + } + + /* Store the current value of the database handles deferred constraint + ** counter. If the statement transaction needs to be rolled back, + ** the value of this counter needs to be restored too. */ + p->nStmtDefCons = db->nDeferredCons; + p->nStmtDefImmCons = db->nDeferredImmCons; + } + } + assert( pOp->p5==0 || pOp->p4type==P4_INT32 ); + if( rc==SQLITE_OK + && pOp->p5 + && (iMeta!=pOp->p3 || pDb->pSchema->iGeneration!=pOp->p4.i) + ){ + /* + ** IMPLEMENTATION-OF: R-03189-51135 As each SQL statement runs, the schema + ** version is checked to ensure that the schema has not changed since the + ** SQL statement was prepared. + */ + sqlite3DbFree(db, p->zErrMsg); + p->zErrMsg = sqlite3DbStrDup(db, "database schema has changed"); + /* If the schema-cookie from the database file matches the cookie + ** stored with the in-memory representation of the schema, do + ** not reload the schema from the database file. + ** + ** If virtual-tables are in use, this is not just an optimization. + ** Often, v-tables store their data in other SQLite tables, which + ** are queried from within xNext() and other v-table methods using + ** prepared queries. If such a query is out-of-date, we do not want to + ** discard the database schema, as the user code implementing the + ** v-table would have to be ready for the sqlite3_vtab structure itself + ** to be invalidated whenever sqlite3_step() is called from within + ** a v-table method. + */ + if( db->aDb[pOp->p1].pSchema->schema_cookie!=iMeta ){ + sqlite3ResetOneSchema(db, pOp->p1); + } + p->expired = 1; + rc = SQLITE_SCHEMA; + + /* Set changeCntOn to 0 to prevent the value returned by sqlite3_changes() + ** from being modified in sqlite3VdbeHalt(). If this statement is + ** reprepared, changeCntOn will be set again. */ + p->changeCntOn = 0; + } + if( rc ) goto abort_due_to_error; + break; +} + +/* Opcode: ReadCookie P1 P2 P3 * * +** +** Read cookie number P3 from database P1 and write it into register P2. +** P3==1 is the schema version. P3==2 is the database format. +** P3==3 is the recommended pager cache size, and so forth. P1==0 is +** the main database file and P1==1 is the database file used to store +** temporary tables. +** +** There must be a read-lock on the database (either a transaction +** must be started or there must be an open cursor) before +** executing this instruction. +*/ +case OP_ReadCookie: { /* out2 */ + int iMeta; + int iDb; + int iCookie; + + assert( p->bIsReader ); + iDb = pOp->p1; + iCookie = pOp->p3; + assert( pOp->p3=0 && iDbnDb ); + assert( db->aDb[iDb].pBt!=0 ); + assert( DbMaskTest(p->btreeMask, iDb) ); + + sqlite3BtreeGetMeta(db->aDb[iDb].pBt, iCookie, (u32 *)&iMeta); + pOut = out2Prerelease(p, pOp); + pOut->u.i = iMeta; + break; +} + +/* Opcode: SetCookie P1 P2 P3 * P5 +** +** Write the integer value P3 into cookie number P2 of database P1. +** P2==1 is the schema version. P2==2 is the database format. +** P2==3 is the recommended pager cache +** size, and so forth. P1==0 is the main database file and P1==1 is the +** database file used to store temporary tables. +** +** A transaction must be started before executing this opcode. +** +** If P2 is the SCHEMA_VERSION cookie (cookie number 1) then the internal +** schema version is set to P3-P5. The "PRAGMA schema_version=N" statement +** has P5 set to 1, so that the internal schema version will be different +** from the database schema version, resulting in a schema reset. +*/ +case OP_SetCookie: { + Db *pDb; + + sqlite3VdbeIncrWriteCounter(p, 0); + assert( pOp->p2p1>=0 && pOp->p1nDb ); + assert( DbMaskTest(p->btreeMask, pOp->p1) ); + assert( p->readOnly==0 ); + pDb = &db->aDb[pOp->p1]; + assert( pDb->pBt!=0 ); + assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) ); + /* See note about index shifting on OP_ReadCookie */ + rc = sqlite3BtreeUpdateMeta(pDb->pBt, pOp->p2, pOp->p3); + if( pOp->p2==BTREE_SCHEMA_VERSION ){ + /* When the schema cookie changes, record the new cookie internally */ + *(u32*)&pDb->pSchema->schema_cookie = *(u32*)&pOp->p3 - pOp->p5; + db->mDbFlags |= DBFLAG_SchemaChange; + sqlite3FkClearTriggerCache(db, pOp->p1); + }else if( pOp->p2==BTREE_FILE_FORMAT ){ + /* Record changes in the file format */ + pDb->pSchema->file_format = pOp->p3; + } + if( pOp->p1==1 ){ + /* Invalidate all prepared statements whenever the TEMP database + ** schema is changed. Ticket #1644 */ + sqlite3ExpirePreparedStatements(db, 0); + p->expired = 0; + } + if( rc ) goto abort_due_to_error; + break; +} + +/* Opcode: OpenRead P1 P2 P3 P4 P5 +** Synopsis: root=P2 iDb=P3 +** +** Open a read-only cursor for the database table whose root page is +** P2 in a database file. The database file is determined by P3. +** P3==0 means the main database, P3==1 means the database used for +** temporary tables, and P3>1 means used the corresponding attached +** database. Give the new cursor an identifier of P1. The P1 +** values need not be contiguous but all P1 values should be small integers. +** It is an error for P1 to be negative. +** +** Allowed P5 bits: +**
    +**
  • 0x02 OPFLAG_SEEKEQ: This cursor will only be used for +** equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT +** of OP_SeekLE/OP_IdxLT) +**
+** +** The P4 value may be either an integer (P4_INT32) or a pointer to +** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo +** object, then table being opened must be an [index b-tree] where the +** KeyInfo object defines the content and collating +** sequence of that index b-tree. Otherwise, if P4 is an integer +** value, then the table being opened must be a [table b-tree] with a +** number of columns no less than the value of P4. +** +** See also: OpenWrite, ReopenIdx +*/ +/* Opcode: ReopenIdx P1 P2 P3 P4 P5 +** Synopsis: root=P2 iDb=P3 +** +** The ReopenIdx opcode works like OP_OpenRead except that it first +** checks to see if the cursor on P1 is already open on the same +** b-tree and if it is this opcode becomes a no-op. In other words, +** if the cursor is already open, do not reopen it. +** +** The ReopenIdx opcode may only be used with P5==0 or P5==OPFLAG_SEEKEQ +** and with P4 being a P4_KEYINFO object. Furthermore, the P3 value must +** be the same as every other ReopenIdx or OpenRead for the same cursor +** number. +** +** Allowed P5 bits: +**
    +**
  • 0x02 OPFLAG_SEEKEQ: This cursor will only be used for +** equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT +** of OP_SeekLE/OP_IdxLT) +**
+** +** See also: OP_OpenRead, OP_OpenWrite +*/ +/* Opcode: OpenWrite P1 P2 P3 P4 P5 +** Synopsis: root=P2 iDb=P3 +** +** Open a read/write cursor named P1 on the table or index whose root +** page is P2 (or whose root page is held in register P2 if the +** OPFLAG_P2ISREG bit is set in P5 - see below). +** +** The P4 value may be either an integer (P4_INT32) or a pointer to +** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo +** object, then table being opened must be an [index b-tree] where the +** KeyInfo object defines the content and collating +** sequence of that index b-tree. Otherwise, if P4 is an integer +** value, then the table being opened must be a [table b-tree] with a +** number of columns no less than the value of P4. +** +** Allowed P5 bits: +**
    +**
  • 0x02 OPFLAG_SEEKEQ: This cursor will only be used for +** equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT +** of OP_SeekLE/OP_IdxLT) +**
  • 0x08 OPFLAG_FORDELETE: This cursor is used only to seek +** and subsequently delete entries in an index btree. This is a +** hint to the storage engine that the storage engine is allowed to +** ignore. The hint is not used by the official SQLite b*tree storage +** engine, but is used by COMDB2. +**
  • 0x10 OPFLAG_P2ISREG: Use the content of register P2 +** as the root page, not the value of P2 itself. +**
+** +** This instruction works like OpenRead except that it opens the cursor +** in read/write mode. +** +** See also: OP_OpenRead, OP_ReopenIdx +*/ +case OP_ReopenIdx: { /* ncycle */ + int nField; + KeyInfo *pKeyInfo; + u32 p2; + int iDb; + int wrFlag; + Btree *pX; + VdbeCursor *pCur; + Db *pDb; + + assert( pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ ); + assert( pOp->p4type==P4_KEYINFO ); + pCur = p->apCsr[pOp->p1]; + if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){ + assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */ + assert( pCur->eCurType==CURTYPE_BTREE ); + sqlite3BtreeClearCursor(pCur->uc.pCursor); + goto open_cursor_set_hints; + } + /* If the cursor is not currently open or is open on a different + ** index, then fall through into OP_OpenRead to force a reopen */ +case OP_OpenRead: /* ncycle */ +case OP_OpenWrite: + + assert( pOp->opcode==OP_OpenWrite || pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ ); + assert( p->bIsReader ); + assert( pOp->opcode==OP_OpenRead || pOp->opcode==OP_ReopenIdx + || p->readOnly==0 ); + + if( p->expired==1 ){ + rc = SQLITE_ABORT_ROLLBACK; + goto abort_due_to_error; + } + + nField = 0; + pKeyInfo = 0; + p2 = (u32)pOp->p2; + iDb = pOp->p3; + assert( iDb>=0 && iDbnDb ); + assert( DbMaskTest(p->btreeMask, iDb) ); + pDb = &db->aDb[iDb]; + pX = pDb->pBt; + assert( pX!=0 ); + if( pOp->opcode==OP_OpenWrite ){ + assert( OPFLAG_FORDELETE==BTREE_FORDELETE ); + wrFlag = BTREE_WRCSR | (pOp->p5 & OPFLAG_FORDELETE); + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + if( pDb->pSchema->file_format < p->minWriteFileFormat ){ + p->minWriteFileFormat = pDb->pSchema->file_format; + } + }else{ + wrFlag = 0; + } + if( pOp->p5 & OPFLAG_P2ISREG ){ + assert( p2>0 ); + assert( p2<=(u32)(p->nMem+1 - p->nCursor) ); + assert( pOp->opcode==OP_OpenWrite ); + pIn2 = &aMem[p2]; + assert( memIsValid(pIn2) ); + assert( (pIn2->flags & MEM_Int)!=0 ); + sqlite3VdbeMemIntegerify(pIn2); + p2 = (int)pIn2->u.i; + /* The p2 value always comes from a prior OP_CreateBtree opcode and + ** that opcode will always set the p2 value to 2 or more or else fail. + ** If there were a failure, the prepared statement would have halted + ** before reaching this instruction. */ + assert( p2>=2 ); + } + if( pOp->p4type==P4_KEYINFO ){ + pKeyInfo = pOp->p4.pKeyInfo; + assert( pKeyInfo->enc==ENC(db) ); + assert( pKeyInfo->db==db ); + nField = pKeyInfo->nAllField; + }else if( pOp->p4type==P4_INT32 ){ + nField = pOp->p4.i; + } + assert( pOp->p1>=0 ); + assert( nField>=0 ); + testcase( nField==0 ); /* Table with INTEGER PRIMARY KEY and nothing else */ + pCur = allocateCursor(p, pOp->p1, nField, CURTYPE_BTREE); + if( pCur==0 ) goto no_mem; + pCur->iDb = iDb; + pCur->nullRow = 1; + pCur->isOrdered = 1; + pCur->pgnoRoot = p2; +#ifdef SQLITE_DEBUG + pCur->wrFlag = wrFlag; +#endif + rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->uc.pCursor); + pCur->pKeyInfo = pKeyInfo; + /* Set the VdbeCursor.isTable variable. Previous versions of + ** SQLite used to check if the root-page flags were sane at this point + ** and report database corruption if they were not, but this check has + ** since moved into the btree layer. */ + pCur->isTable = pOp->p4type!=P4_KEYINFO; + +open_cursor_set_hints: + assert( OPFLAG_BULKCSR==BTREE_BULKLOAD ); + assert( OPFLAG_SEEKEQ==BTREE_SEEK_EQ ); + testcase( pOp->p5 & OPFLAG_BULKCSR ); + testcase( pOp->p2 & OPFLAG_SEEKEQ ); + sqlite3BtreeCursorHintFlags(pCur->uc.pCursor, + (pOp->p5 & (OPFLAG_BULKCSR|OPFLAG_SEEKEQ))); + if( rc ) goto abort_due_to_error; + break; +} + +/* Opcode: OpenDup P1 P2 * * * +** +** Open a new cursor P1 that points to the same ephemeral table as +** cursor P2. The P2 cursor must have been opened by a prior OP_OpenEphemeral +** opcode. Only ephemeral cursors may be duplicated. +** +** Duplicate ephemeral cursors are used for self-joins of materialized views. +*/ +case OP_OpenDup: { /* ncycle */ + VdbeCursor *pOrig; /* The original cursor to be duplicated */ + VdbeCursor *pCx; /* The new cursor */ + + pOrig = p->apCsr[pOp->p2]; + assert( pOrig ); + assert( pOrig->isEphemeral ); /* Only ephemeral cursors can be duplicated */ + + pCx = allocateCursor(p, pOp->p1, pOrig->nField, CURTYPE_BTREE); + if( pCx==0 ) goto no_mem; + pCx->nullRow = 1; + pCx->isEphemeral = 1; + pCx->pKeyInfo = pOrig->pKeyInfo; + pCx->isTable = pOrig->isTable; + pCx->pgnoRoot = pOrig->pgnoRoot; + pCx->isOrdered = pOrig->isOrdered; + pCx->ub.pBtx = pOrig->ub.pBtx; + pCx->noReuse = 1; + pOrig->noReuse = 1; + rc = sqlite3BtreeCursor(pCx->ub.pBtx, pCx->pgnoRoot, BTREE_WRCSR, + pCx->pKeyInfo, pCx->uc.pCursor); + /* The sqlite3BtreeCursor() routine can only fail for the first cursor + ** opened for a database. Since there is already an open cursor when this + ** opcode is run, the sqlite3BtreeCursor() cannot fail */ + assert( rc==SQLITE_OK ); + break; +} + + +/* Opcode: OpenEphemeral P1 P2 P3 P4 P5 +** Synopsis: nColumn=P2 +** +** Open a new cursor P1 to a transient table. +** The cursor is always opened read/write even if +** the main database is read-only. The ephemeral +** table is deleted automatically when the cursor is closed. +** +** If the cursor P1 is already opened on an ephemeral table, the table +** is cleared (all content is erased). +** +** P2 is the number of columns in the ephemeral table. +** The cursor points to a BTree table if P4==0 and to a BTree index +** if P4 is not 0. If P4 is not NULL, it points to a KeyInfo structure +** that defines the format of keys in the index. +** +** The P5 parameter can be a mask of the BTREE_* flags defined +** in btree.h. These flags control aspects of the operation of +** the btree. The BTREE_OMIT_JOURNAL and BTREE_SINGLE flags are +** added automatically. +** +** If P3 is positive, then reg[P3] is modified slightly so that it +** can be used as zero-length data for OP_Insert. This is an optimization +** that avoids an extra OP_Blob opcode to initialize that register. +*/ +/* Opcode: OpenAutoindex P1 P2 * P4 * +** Synopsis: nColumn=P2 +** +** This opcode works the same as OP_OpenEphemeral. It has a +** different name to distinguish its use. Tables created using +** by this opcode will be used for automatically created transient +** indices in joins. +*/ +case OP_OpenAutoindex: /* ncycle */ +case OP_OpenEphemeral: { /* ncycle */ + VdbeCursor *pCx; + KeyInfo *pKeyInfo; + + static const int vfsFlags = + SQLITE_OPEN_READWRITE | + SQLITE_OPEN_CREATE | + SQLITE_OPEN_EXCLUSIVE | + SQLITE_OPEN_DELETEONCLOSE | + SQLITE_OPEN_TRANSIENT_DB; + assert( pOp->p1>=0 ); + assert( pOp->p2>=0 ); + if( pOp->p3>0 ){ + /* Make register reg[P3] into a value that can be used as the data + ** form sqlite3BtreeInsert() where the length of the data is zero. */ + assert( pOp->p2==0 ); /* Only used when number of columns is zero */ + assert( pOp->opcode==OP_OpenEphemeral ); + assert( aMem[pOp->p3].flags & MEM_Null ); + aMem[pOp->p3].n = 0; + aMem[pOp->p3].z = ""; + } + pCx = p->apCsr[pOp->p1]; + if( pCx && !pCx->noReuse && ALWAYS(pOp->p2<=pCx->nField) ){ + /* If the ephermeral table is already open and has no duplicates from + ** OP_OpenDup, then erase all existing content so that the table is + ** empty again, rather than creating a new table. */ + assert( pCx->isEphemeral ); + pCx->seqCount = 0; + pCx->cacheStatus = CACHE_STALE; + rc = sqlite3BtreeClearTable(pCx->ub.pBtx, pCx->pgnoRoot, 0); + }else{ + pCx = allocateCursor(p, pOp->p1, pOp->p2, CURTYPE_BTREE); + if( pCx==0 ) goto no_mem; + pCx->isEphemeral = 1; + rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pCx->ub.pBtx, + BTREE_OMIT_JOURNAL | BTREE_SINGLE | pOp->p5, + vfsFlags); + if( rc==SQLITE_OK ){ + rc = sqlite3BtreeBeginTrans(pCx->ub.pBtx, 1, 0); + if( rc==SQLITE_OK ){ + /* If a transient index is required, create it by calling + ** sqlite3BtreeCreateTable() with the BTREE_BLOBKEY flag before + ** opening it. If a transient table is required, just use the + ** automatically created table with root-page 1 (an BLOB_INTKEY table). + */ + if( (pCx->pKeyInfo = pKeyInfo = pOp->p4.pKeyInfo)!=0 ){ + assert( pOp->p4type==P4_KEYINFO ); + rc = sqlite3BtreeCreateTable(pCx->ub.pBtx, &pCx->pgnoRoot, + BTREE_BLOBKEY | pOp->p5); + if( rc==SQLITE_OK ){ + assert( pCx->pgnoRoot==SCHEMA_ROOT+1 ); + assert( pKeyInfo->db==db ); + assert( pKeyInfo->enc==ENC(db) ); + rc = sqlite3BtreeCursor(pCx->ub.pBtx, pCx->pgnoRoot, BTREE_WRCSR, + pKeyInfo, pCx->uc.pCursor); + } + pCx->isTable = 0; + }else{ + pCx->pgnoRoot = SCHEMA_ROOT; + rc = sqlite3BtreeCursor(pCx->ub.pBtx, SCHEMA_ROOT, BTREE_WRCSR, + 0, pCx->uc.pCursor); + pCx->isTable = 1; + } + } + pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED); + if( rc ){ + sqlite3BtreeClose(pCx->ub.pBtx); + } + } + } + if( rc ) goto abort_due_to_error; + pCx->nullRow = 1; + break; +} + +/* Opcode: SorterOpen P1 P2 P3 P4 * +** +** This opcode works like OP_OpenEphemeral except that it opens +** a transient index that is specifically designed to sort large +** tables using an external merge-sort algorithm. +** +** If argument P3 is non-zero, then it indicates that the sorter may +** assume that a stable sort considering the first P3 fields of each +** key is sufficient to produce the required results. +*/ +case OP_SorterOpen: { + VdbeCursor *pCx; + + assert( pOp->p1>=0 ); + assert( pOp->p2>=0 ); + pCx = allocateCursor(p, pOp->p1, pOp->p2, CURTYPE_SORTER); + if( pCx==0 ) goto no_mem; + pCx->pKeyInfo = pOp->p4.pKeyInfo; + assert( pCx->pKeyInfo->db==db ); + assert( pCx->pKeyInfo->enc==ENC(db) ); + rc = sqlite3VdbeSorterInit(db, pOp->p3, pCx); + if( rc ) goto abort_due_to_error; + break; +} + +/* Opcode: SequenceTest P1 P2 * * * +** Synopsis: if( cursor[P1].ctr++ ) pc = P2 +** +** P1 is a sorter cursor. If the sequence counter is currently zero, jump +** to P2. Regardless of whether or not the jump is taken, increment the +** the sequence value. +*/ +case OP_SequenceTest: { + VdbeCursor *pC; + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( isSorter(pC) ); + if( (pC->seqCount++)==0 ){ + goto jump_to_p2; + } + break; +} + +/* Opcode: OpenPseudo P1 P2 P3 * * +** Synopsis: P3 columns in r[P2] +** +** Open a new cursor that points to a fake table that contains a single +** row of data. The content of that one row is the content of memory +** register P2. In other words, cursor P1 becomes an alias for the +** MEM_Blob content contained in register P2. +** +** A pseudo-table created by this opcode is used to hold a single +** row output from the sorter so that the row can be decomposed into +** individual columns using the OP_Column opcode. The OP_Column opcode +** is the only cursor opcode that works with a pseudo-table. +** +** P3 is the number of fields in the records that will be stored by +** the pseudo-table. +*/ +case OP_OpenPseudo: { + VdbeCursor *pCx; + + assert( pOp->p1>=0 ); + assert( pOp->p3>=0 ); + pCx = allocateCursor(p, pOp->p1, pOp->p3, CURTYPE_PSEUDO); + if( pCx==0 ) goto no_mem; + pCx->nullRow = 1; + pCx->seekResult = pOp->p2; + pCx->isTable = 1; + /* Give this pseudo-cursor a fake BtCursor pointer so that pCx + ** can be safely passed to sqlite3VdbeCursorMoveto(). This avoids a test + ** for pCx->eCurType==CURTYPE_BTREE inside of sqlite3VdbeCursorMoveto() + ** which is a performance optimization */ + pCx->uc.pCursor = sqlite3BtreeFakeValidCursor(); + assert( pOp->p5==0 ); + break; +} + +/* Opcode: Close P1 * * * * +** +** Close a cursor previously opened as P1. If P1 is not +** currently open, this instruction is a no-op. +*/ +case OP_Close: { /* ncycle */ + assert( pOp->p1>=0 && pOp->p1nCursor ); + sqlite3VdbeFreeCursor(p, p->apCsr[pOp->p1]); + p->apCsr[pOp->p1] = 0; + break; +} + +#ifdef SQLITE_ENABLE_COLUMN_USED_MASK +/* Opcode: ColumnsUsed P1 * * P4 * +** +** This opcode (which only exists if SQLite was compiled with +** SQLITE_ENABLE_COLUMN_USED_MASK) identifies which columns of the +** table or index for cursor P1 are used. P4 is a 64-bit integer +** (P4_INT64) in which the first 63 bits are one for each of the +** first 63 columns of the table or index that are actually used +** by the cursor. The high-order bit is set if any column after +** the 64th is used. +*/ +case OP_ColumnsUsed: { + VdbeCursor *pC; + pC = p->apCsr[pOp->p1]; + assert( pC->eCurType==CURTYPE_BTREE ); + pC->maskUsed = *(u64*)pOp->p4.pI64; + break; +} +#endif + +/* Opcode: SeekGE P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), +** use the value in register P3 as the key. If cursor P1 refers +** to an SQL index, then P3 is the first in an array of P4 registers +** that are used as an unpacked index key. +** +** Reposition cursor P1 so that it points to the smallest entry that +** is greater than or equal to the key value. If there are no records +** greater than or equal to the key and P2 is not zero, then jump to P2. +** +** If the cursor P1 was opened using the OPFLAG_SEEKEQ flag, then this +** opcode will either land on a record that exactly matches the key, or +** else it will cause a jump to P2. When the cursor is OPFLAG_SEEKEQ, +** this opcode must be followed by an IdxLE opcode with the same arguments. +** The IdxGT opcode will be skipped if this opcode succeeds, but the +** IdxGT opcode will be used on subsequent loop iterations. The +** OPFLAG_SEEKEQ flags is a hint to the btree layer to say that this +** is an equality search. +** +** This opcode leaves the cursor configured to move in forward order, +** from the beginning toward the end. In other words, the cursor is +** configured to use Next, not Prev. +** +** See also: Found, NotFound, SeekLt, SeekGt, SeekLe +*/ +/* Opcode: SeekGT P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), +** use the value in register P3 as a key. If cursor P1 refers +** to an SQL index, then P3 is the first in an array of P4 registers +** that are used as an unpacked index key. +** +** Reposition cursor P1 so that it points to the smallest entry that +** is greater than the key value. If there are no records greater than +** the key and P2 is not zero, then jump to P2. +** +** This opcode leaves the cursor configured to move in forward order, +** from the beginning toward the end. In other words, the cursor is +** configured to use Next, not Prev. +** +** See also: Found, NotFound, SeekLt, SeekGe, SeekLe +*/ +/* Opcode: SeekLT P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), +** use the value in register P3 as a key. If cursor P1 refers +** to an SQL index, then P3 is the first in an array of P4 registers +** that are used as an unpacked index key. +** +** Reposition cursor P1 so that it points to the largest entry that +** is less than the key value. If there are no records less than +** the key and P2 is not zero, then jump to P2. +** +** This opcode leaves the cursor configured to move in reverse order, +** from the end toward the beginning. In other words, the cursor is +** configured to use Prev, not Next. +** +** See also: Found, NotFound, SeekGt, SeekGe, SeekLe +*/ +/* Opcode: SeekLE P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), +** use the value in register P3 as a key. If cursor P1 refers +** to an SQL index, then P3 is the first in an array of P4 registers +** that are used as an unpacked index key. +** +** Reposition cursor P1 so that it points to the largest entry that +** is less than or equal to the key value. If there are no records +** less than or equal to the key and P2 is not zero, then jump to P2. +** +** This opcode leaves the cursor configured to move in reverse order, +** from the end toward the beginning. In other words, the cursor is +** configured to use Prev, not Next. +** +** If the cursor P1 was opened using the OPFLAG_SEEKEQ flag, then this +** opcode will either land on a record that exactly matches the key, or +** else it will cause a jump to P2. When the cursor is OPFLAG_SEEKEQ, +** this opcode must be followed by an IdxLE opcode with the same arguments. +** The IdxGE opcode will be skipped if this opcode succeeds, but the +** IdxGE opcode will be used on subsequent loop iterations. The +** OPFLAG_SEEKEQ flags is a hint to the btree layer to say that this +** is an equality search. +** +** See also: Found, NotFound, SeekGt, SeekGe, SeekLt +*/ +case OP_SeekLT: /* jump, in3, group, ncycle */ +case OP_SeekLE: /* jump, in3, group, ncycle */ +case OP_SeekGE: /* jump, in3, group, ncycle */ +case OP_SeekGT: { /* jump, in3, group, ncycle */ + int res; /* Comparison result */ + int oc; /* Opcode */ + VdbeCursor *pC; /* The cursor to seek */ + UnpackedRecord r; /* The key to seek for */ + int nField; /* Number of columns or fields in the key */ + i64 iKey; /* The rowid we are to seek to */ + int eqOnly; /* Only interested in == results */ + + assert( pOp->p1>=0 && pOp->p1nCursor ); + assert( pOp->p2!=0 ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + assert( OP_SeekLE == OP_SeekLT+1 ); + assert( OP_SeekGE == OP_SeekLT+2 ); + assert( OP_SeekGT == OP_SeekLT+3 ); + assert( pC->isOrdered ); + assert( pC->uc.pCursor!=0 ); + oc = pOp->opcode; + eqOnly = 0; + pC->nullRow = 0; +#ifdef SQLITE_DEBUG + pC->seekOp = pOp->opcode; +#endif + + pC->deferredMoveto = 0; + pC->cacheStatus = CACHE_STALE; + if( pC->isTable ){ + u16 flags3, newType; + /* The OPFLAG_SEEKEQ/BTREE_SEEK_EQ flag is only set on index cursors */ + assert( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ)==0 + || CORRUPT_DB ); + + /* The input value in P3 might be of any type: integer, real, string, + ** blob, or NULL. But it needs to be an integer before we can do + ** the seek, so convert it. */ + pIn3 = &aMem[pOp->p3]; + flags3 = pIn3->flags; + if( (flags3 & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Str))==MEM_Str ){ + applyNumericAffinity(pIn3, 0); + } + iKey = sqlite3VdbeIntValue(pIn3); /* Get the integer key value */ + newType = pIn3->flags; /* Record the type after applying numeric affinity */ + pIn3->flags = flags3; /* But convert the type back to its original */ + + /* If the P3 value could not be converted into an integer without + ** loss of information, then special processing is required... */ + if( (newType & (MEM_Int|MEM_IntReal))==0 ){ + int c; + if( (newType & MEM_Real)==0 ){ + if( (newType & MEM_Null) || oc>=OP_SeekGE ){ + VdbeBranchTaken(1,2); + goto jump_to_p2; + }else{ + rc = sqlite3BtreeLast(pC->uc.pCursor, &res); + if( rc!=SQLITE_OK ) goto abort_due_to_error; + goto seek_not_found; + } + } + c = sqlite3IntFloatCompare(iKey, pIn3->u.r); + + /* If the approximation iKey is larger than the actual real search + ** term, substitute >= for > and < for <=. e.g. if the search term + ** is 4.9 and the integer approximation 5: + ** + ** (x > 4.9) -> (x >= 5) + ** (x <= 4.9) -> (x < 5) + */ + if( c>0 ){ + assert( OP_SeekGE==(OP_SeekGT-1) ); + assert( OP_SeekLT==(OP_SeekLE-1) ); + assert( (OP_SeekLE & 0x0001)==(OP_SeekGT & 0x0001) ); + if( (oc & 0x0001)==(OP_SeekGT & 0x0001) ) oc--; + } + + /* If the approximation iKey is smaller than the actual real search + ** term, substitute <= for < and > for >=. */ + else if( c<0 ){ + assert( OP_SeekLE==(OP_SeekLT+1) ); + assert( OP_SeekGT==(OP_SeekGE+1) ); + assert( (OP_SeekLT & 0x0001)==(OP_SeekGE & 0x0001) ); + if( (oc & 0x0001)==(OP_SeekLT & 0x0001) ) oc++; + } + } + rc = sqlite3BtreeTableMoveto(pC->uc.pCursor, (u64)iKey, 0, &res); + pC->movetoTarget = iKey; /* Used by OP_Delete */ + if( rc!=SQLITE_OK ){ + goto abort_due_to_error; + } + }else{ + /* For a cursor with the OPFLAG_SEEKEQ/BTREE_SEEK_EQ hint, only the + ** OP_SeekGE and OP_SeekLE opcodes are allowed, and these must be + ** immediately followed by an OP_IdxGT or OP_IdxLT opcode, respectively, + ** with the same key. + */ + if( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ) ){ + eqOnly = 1; + assert( pOp->opcode==OP_SeekGE || pOp->opcode==OP_SeekLE ); + assert( pOp[1].opcode==OP_IdxLT || pOp[1].opcode==OP_IdxGT ); + assert( pOp->opcode==OP_SeekGE || pOp[1].opcode==OP_IdxLT ); + assert( pOp->opcode==OP_SeekLE || pOp[1].opcode==OP_IdxGT ); + assert( pOp[1].p1==pOp[0].p1 ); + assert( pOp[1].p2==pOp[0].p2 ); + assert( pOp[1].p3==pOp[0].p3 ); + assert( pOp[1].p4.i==pOp[0].p4.i ); + } + + nField = pOp->p4.i; + assert( pOp->p4type==P4_INT32 ); + assert( nField>0 ); + r.pKeyInfo = pC->pKeyInfo; + r.nField = (u16)nField; + + /* The next line of code computes as follows, only faster: + ** if( oc==OP_SeekGT || oc==OP_SeekLE ){ + ** r.default_rc = -1; + ** }else{ + ** r.default_rc = +1; + ** } + */ + r.default_rc = ((1 & (oc - OP_SeekLT)) ? -1 : +1); + assert( oc!=OP_SeekGT || r.default_rc==-1 ); + assert( oc!=OP_SeekLE || r.default_rc==-1 ); + assert( oc!=OP_SeekGE || r.default_rc==+1 ); + assert( oc!=OP_SeekLT || r.default_rc==+1 ); + + r.aMem = &aMem[pOp->p3]; +#ifdef SQLITE_DEBUG + { + int i; + for(i=0; i0 ) REGISTER_TRACE(pOp->p3+i, &r.aMem[i]); + } + } +#endif + r.eqSeen = 0; + rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, &r, &res); + if( rc!=SQLITE_OK ){ + goto abort_due_to_error; + } + if( eqOnly && r.eqSeen==0 ){ + assert( res!=0 ); + goto seek_not_found; + } + } +#ifdef SQLITE_TEST + sqlite3_search_count++; +#endif + if( oc>=OP_SeekGE ){ assert( oc==OP_SeekGE || oc==OP_SeekGT ); + if( res<0 || (res==0 && oc==OP_SeekGT) ){ + res = 0; + rc = sqlite3BtreeNext(pC->uc.pCursor, 0); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_DONE ){ + rc = SQLITE_OK; + res = 1; + }else{ + goto abort_due_to_error; + } + } + }else{ + res = 0; + } + }else{ + assert( oc==OP_SeekLT || oc==OP_SeekLE ); + if( res>0 || (res==0 && oc==OP_SeekLT) ){ + res = 0; + rc = sqlite3BtreePrevious(pC->uc.pCursor, 0); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_DONE ){ + rc = SQLITE_OK; + res = 1; + }else{ + goto abort_due_to_error; + } + } + }else{ + /* res might be negative because the table is empty. Check to + ** see if this is the case. + */ + res = sqlite3BtreeEof(pC->uc.pCursor); + } + } +seek_not_found: + assert( pOp->p2>0 ); + VdbeBranchTaken(res!=0,2); + if( res ){ + goto jump_to_p2; + }else if( eqOnly ){ + assert( pOp[1].opcode==OP_IdxLT || pOp[1].opcode==OP_IdxGT ); + pOp++; /* Skip the OP_IdxLt or OP_IdxGT that follows */ + } + break; +} + + +/* Opcode: SeekScan P1 P2 * * P5 +** Synopsis: Scan-ahead up to P1 rows +** +** This opcode is a prefix opcode to OP_SeekGE. In other words, this +** opcode must be immediately followed by OP_SeekGE. This constraint is +** checked by assert() statements. +** +** This opcode uses the P1 through P4 operands of the subsequent +** OP_SeekGE. In the text that follows, the operands of the subsequent +** OP_SeekGE opcode are denoted as SeekOP.P1 through SeekOP.P4. Only +** the P1, P2 and P5 operands of this opcode are also used, and are called +** This.P1, This.P2 and This.P5. +** +** This opcode helps to optimize IN operators on a multi-column index +** where the IN operator is on the later terms of the index by avoiding +** unnecessary seeks on the btree, substituting steps to the next row +** of the b-tree instead. A correct answer is obtained if this opcode +** is omitted or is a no-op. +** +** The SeekGE.P3 and SeekGE.P4 operands identify an unpacked key which +** is the desired entry that we want the cursor SeekGE.P1 to be pointing +** to. Call this SeekGE.P3/P4 row the "target". +** +** If the SeekGE.P1 cursor is not currently pointing to a valid row, +** then this opcode is a no-op and control passes through into the OP_SeekGE. +** +** If the SeekGE.P1 cursor is pointing to a valid row, then that row +** might be the target row, or it might be near and slightly before the +** target row, or it might be after the target row. If the cursor is +** currently before the target row, then this opcode attempts to position +** the cursor on or after the target row by invoking sqlite3BtreeStep() +** on the cursor between 1 and This.P1 times. +** +** The This.P5 parameter is a flag that indicates what to do if the +** cursor ends up pointing at a valid row that is past the target +** row. If This.P5 is false (0) then a jump is made to SeekGE.P2. If +** This.P5 is true (non-zero) then a jump is made to This.P2. The P5==0 +** case occurs when there are no inequality constraints to the right of +** the IN constraing. The jump to SeekGE.P2 ends the loop. The P5!=0 case +** occurs when there are inequality constraints to the right of the IN +** operator. In that case, the This.P2 will point either directly to or +** to setup code prior to the OP_IdxGT or OP_IdxGE opcode that checks for +** loop terminate. +** +** Possible outcomes from this opcode:
    +** +**
  1. If the cursor is initally not pointed to any valid row, then +** fall through into the subsequent OP_SeekGE opcode. +** +**
  2. If the cursor is left pointing to a row that is before the target +** row, even after making as many as This.P1 calls to +** sqlite3BtreeNext(), then also fall through into OP_SeekGE. +** +**
  3. If the cursor is left pointing at the target row, either because it +** was at the target row to begin with or because one or more +** sqlite3BtreeNext() calls moved the cursor to the target row, +** then jump to This.P2.., +** +**
  4. If the cursor started out before the target row and a call to +** to sqlite3BtreeNext() moved the cursor off the end of the index +** (indicating that the target row definitely does not exist in the +** btree) then jump to SeekGE.P2, ending the loop. +** +**
  5. If the cursor ends up on a valid row that is past the target row +** (indicating that the target row does not exist in the btree) then +** jump to SeekOP.P2 if This.P5==0 or to This.P2 if This.P5>0. +**
+*/ +case OP_SeekScan: { /* ncycle */ + VdbeCursor *pC; + int res; + int nStep; + UnpackedRecord r; + + assert( pOp[1].opcode==OP_SeekGE ); + + /* If pOp->p5 is clear, then pOp->p2 points to the first instruction past the + ** OP_IdxGT that follows the OP_SeekGE. Otherwise, it points to the first + ** opcode past the OP_SeekGE itself. */ + assert( pOp->p2>=(int)(pOp-aOp)+2 ); +#ifdef SQLITE_DEBUG + if( pOp->p5==0 ){ + /* There are no inequality constraints following the IN constraint. */ + assert( pOp[1].p1==aOp[pOp->p2-1].p1 ); + assert( pOp[1].p2==aOp[pOp->p2-1].p2 ); + assert( pOp[1].p3==aOp[pOp->p2-1].p3 ); + assert( aOp[pOp->p2-1].opcode==OP_IdxGT + || aOp[pOp->p2-1].opcode==OP_IdxGE ); + testcase( aOp[pOp->p2-1].opcode==OP_IdxGE ); + }else{ + /* There are inequality constraints. */ + assert( pOp->p2==(int)(pOp-aOp)+2 ); + assert( aOp[pOp->p2-1].opcode==OP_SeekGE ); + } +#endif + + assert( pOp->p1>0 ); + pC = p->apCsr[pOp[1].p1]; + assert( pC!=0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + assert( !pC->isTable ); + if( !sqlite3BtreeCursorIsValidNN(pC->uc.pCursor) ){ +#ifdef SQLITE_DEBUG + if( db->flags&SQLITE_VdbeTrace ){ + printf("... cursor not valid - fall through\n"); + } +#endif + break; + } + nStep = pOp->p1; + assert( nStep>=1 ); + r.pKeyInfo = pC->pKeyInfo; + r.nField = (u16)pOp[1].p4.i; + r.default_rc = 0; + r.aMem = &aMem[pOp[1].p3]; +#ifdef SQLITE_DEBUG + { + int i; + for(i=0; i0 && pOp->p5==0 ){ + seekscan_search_fail: + /* Jump to SeekGE.P2, ending the loop */ +#ifdef SQLITE_DEBUG + if( db->flags&SQLITE_VdbeTrace ){ + printf("... %d steps and then skip\n", pOp->p1 - nStep); + } +#endif + VdbeBranchTaken(1,3); + pOp++; + goto jump_to_p2; + } + if( res>=0 ){ + /* Jump to This.P2, bypassing the OP_SeekGE opcode */ +#ifdef SQLITE_DEBUG + if( db->flags&SQLITE_VdbeTrace ){ + printf("... %d steps and then success\n", pOp->p1 - nStep); + } +#endif + VdbeBranchTaken(2,3); + goto jump_to_p2; + break; + } + if( nStep<=0 ){ +#ifdef SQLITE_DEBUG + if( db->flags&SQLITE_VdbeTrace ){ + printf("... fall through after %d steps\n", pOp->p1); + } +#endif + VdbeBranchTaken(0,3); + break; + } + nStep--; + pC->cacheStatus = CACHE_STALE; + rc = sqlite3BtreeNext(pC->uc.pCursor, 0); + if( rc ){ + if( rc==SQLITE_DONE ){ + rc = SQLITE_OK; + goto seekscan_search_fail; + }else{ + goto abort_due_to_error; + } + } + } + + break; +} + + +/* Opcode: SeekHit P1 P2 P3 * * +** Synopsis: set P2<=seekHit<=P3 +** +** Increase or decrease the seekHit value for cursor P1, if necessary, +** so that it is no less than P2 and no greater than P3. +** +** The seekHit integer represents the maximum of terms in an index for which +** there is known to be at least one match. If the seekHit value is smaller +** than the total number of equality terms in an index lookup, then the +** OP_IfNoHope opcode might run to see if the IN loop can be abandoned +** early, thus saving work. This is part of the IN-early-out optimization. +** +** P1 must be a valid b-tree cursor. +*/ +case OP_SeekHit: { /* ncycle */ + VdbeCursor *pC; + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pOp->p3>=pOp->p2 ); + if( pC->seekHitp2 ){ +#ifdef SQLITE_DEBUG + if( db->flags&SQLITE_VdbeTrace ){ + printf("seekHit changes from %d to %d\n", pC->seekHit, pOp->p2); + } +#endif + pC->seekHit = pOp->p2; + }else if( pC->seekHit>pOp->p3 ){ +#ifdef SQLITE_DEBUG + if( db->flags&SQLITE_VdbeTrace ){ + printf("seekHit changes from %d to %d\n", pC->seekHit, pOp->p3); + } +#endif + pC->seekHit = pOp->p3; + } + break; +} + +/* Opcode: IfNotOpen P1 P2 * * * +** Synopsis: if( !csr[P1] ) goto P2 +** +** If cursor P1 is not open or if P1 is set to a NULL row using the +** OP_NullRow opcode, then jump to instruction P2. Otherwise, fall through. +*/ +case OP_IfNotOpen: { /* jump */ + VdbeCursor *pCur; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pCur = p->apCsr[pOp->p1]; + VdbeBranchTaken(pCur==0 || pCur->nullRow, 2); + if( pCur==0 || pCur->nullRow ){ + goto jump_to_p2_and_check_for_interrupt; + } + break; +} + +/* Opcode: Found P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** If P4==0 then register P3 holds a blob constructed by MakeRecord. If +** P4>0 then register P3 is the first of P4 registers that form an unpacked +** record. +** +** Cursor P1 is on an index btree. If the record identified by P3 and P4 +** is a prefix of any entry in P1 then a jump is made to P2 and +** P1 is left pointing at the matching entry. +** +** This operation leaves the cursor in a state where it can be +** advanced in the forward direction. The Next instruction will work, +** but not the Prev instruction. +** +** See also: NotFound, NoConflict, NotExists. SeekGe +*/ +/* Opcode: NotFound P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** If P4==0 then register P3 holds a blob constructed by MakeRecord. If +** P4>0 then register P3 is the first of P4 registers that form an unpacked +** record. +** +** Cursor P1 is on an index btree. If the record identified by P3 and P4 +** is not the prefix of any entry in P1 then a jump is made to P2. If P1 +** does contain an entry whose prefix matches the P3/P4 record then control +** falls through to the next instruction and P1 is left pointing at the +** matching entry. +** +** This operation leaves the cursor in a state where it cannot be +** advanced in either direction. In other words, the Next and Prev +** opcodes do not work after this operation. +** +** See also: Found, NotExists, NoConflict, IfNoHope +*/ +/* Opcode: IfNoHope P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** Register P3 is the first of P4 registers that form an unpacked +** record. Cursor P1 is an index btree. P2 is a jump destination. +** In other words, the operands to this opcode are the same as the +** operands to OP_NotFound and OP_IdxGT. +** +** This opcode is an optimization attempt only. If this opcode always +** falls through, the correct answer is still obtained, but extra works +** is performed. +** +** A value of N in the seekHit flag of cursor P1 means that there exists +** a key P3:N that will match some record in the index. We want to know +** if it is possible for a record P3:P4 to match some record in the +** index. If it is not possible, we can skips some work. So if seekHit +** is less than P4, attempt to find out if a match is possible by running +** OP_NotFound. +** +** This opcode is used in IN clause processing for a multi-column key. +** If an IN clause is attached to an element of the key other than the +** left-most element, and if there are no matches on the most recent +** seek over the whole key, then it might be that one of the key element +** to the left is prohibiting a match, and hence there is "no hope" of +** any match regardless of how many IN clause elements are checked. +** In such a case, we abandon the IN clause search early, using this +** opcode. The opcode name comes from the fact that the +** jump is taken if there is "no hope" of achieving a match. +** +** See also: NotFound, SeekHit +*/ +/* Opcode: NoConflict P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** If P4==0 then register P3 holds a blob constructed by MakeRecord. If +** P4>0 then register P3 is the first of P4 registers that form an unpacked +** record. +** +** Cursor P1 is on an index btree. If the record identified by P3 and P4 +** contains any NULL value, jump immediately to P2. If all terms of the +** record are not-NULL then a check is done to determine if any row in the +** P1 index btree has a matching key prefix. If there are no matches, jump +** immediately to P2. If there is a match, fall through and leave the P1 +** cursor pointing to the matching row. +** +** This opcode is similar to OP_NotFound with the exceptions that the +** branch is always taken if any part of the search key input is NULL. +** +** This operation leaves the cursor in a state where it cannot be +** advanced in either direction. In other words, the Next and Prev +** opcodes do not work after this operation. +** +** See also: NotFound, Found, NotExists +*/ +case OP_IfNoHope: { /* jump, in3, ncycle */ + VdbeCursor *pC; + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); +#ifdef SQLITE_DEBUG + if( db->flags&SQLITE_VdbeTrace ){ + printf("seekHit is %d\n", pC->seekHit); + } +#endif + if( pC->seekHit>=pOp->p4.i ) break; + /* Fall through into OP_NotFound */ + /* no break */ deliberate_fall_through +} +case OP_NoConflict: /* jump, in3, ncycle */ +case OP_NotFound: /* jump, in3, ncycle */ +case OP_Found: { /* jump, in3, ncycle */ + int alreadyExists; + int ii; + VdbeCursor *pC; + UnpackedRecord *pIdxKey; + UnpackedRecord r; + +#ifdef SQLITE_TEST + if( pOp->opcode!=OP_NoConflict ) sqlite3_found_count++; +#endif + + assert( pOp->p1>=0 && pOp->p1nCursor ); + assert( pOp->p4type==P4_INT32 ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); +#ifdef SQLITE_DEBUG + pC->seekOp = pOp->opcode; +#endif + r.aMem = &aMem[pOp->p3]; + assert( pC->eCurType==CURTYPE_BTREE ); + assert( pC->uc.pCursor!=0 ); + assert( pC->isTable==0 ); + r.nField = (u16)pOp->p4.i; + if( r.nField>0 ){ + /* Key values in an array of registers */ + r.pKeyInfo = pC->pKeyInfo; + r.default_rc = 0; +#ifdef SQLITE_DEBUG + for(ii=0; iip3+ii, &r.aMem[ii]); + } +#endif + rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, &r, &pC->seekResult); + }else{ + /* Composite key generated by OP_MakeRecord */ + assert( r.aMem->flags & MEM_Blob ); + assert( pOp->opcode!=OP_NoConflict ); + rc = ExpandBlob(r.aMem); + assert( rc==SQLITE_OK || rc==SQLITE_NOMEM ); + if( rc ) goto no_mem; + pIdxKey = sqlite3VdbeAllocUnpackedRecord(pC->pKeyInfo); + if( pIdxKey==0 ) goto no_mem; + sqlite3VdbeRecordUnpack(pC->pKeyInfo, r.aMem->n, r.aMem->z, pIdxKey); + pIdxKey->default_rc = 0; + rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, pIdxKey, &pC->seekResult); + sqlite3DbFreeNN(db, pIdxKey); + } + if( rc!=SQLITE_OK ){ + goto abort_due_to_error; + } + alreadyExists = (pC->seekResult==0); + pC->nullRow = 1-alreadyExists; + pC->deferredMoveto = 0; + pC->cacheStatus = CACHE_STALE; + if( pOp->opcode==OP_Found ){ + VdbeBranchTaken(alreadyExists!=0,2); + if( alreadyExists ) goto jump_to_p2; + }else{ + if( !alreadyExists ){ + VdbeBranchTaken(1,2); + goto jump_to_p2; + } + if( pOp->opcode==OP_NoConflict ){ + /* For the OP_NoConflict opcode, take the jump if any of the + ** input fields are NULL, since any key with a NULL will not + ** conflict */ + for(ii=0; iiopcode==OP_IfNoHope ){ + pC->seekHit = pOp->p4.i; + } + } + break; +} + +/* Opcode: SeekRowid P1 P2 P3 * * +** Synopsis: intkey=r[P3] +** +** P1 is the index of a cursor open on an SQL table btree (with integer +** keys). If register P3 does not contain an integer or if P1 does not +** contain a record with rowid P3 then jump immediately to P2. +** Or, if P2 is 0, raise an SQLITE_CORRUPT error. If P1 does contain +** a record with rowid P3 then +** leave the cursor pointing at that record and fall through to the next +** instruction. +** +** The OP_NotExists opcode performs the same operation, but with OP_NotExists +** the P3 register must be guaranteed to contain an integer value. With this +** opcode, register P3 might not contain an integer. +** +** The OP_NotFound opcode performs the same operation on index btrees +** (with arbitrary multi-value keys). +** +** This opcode leaves the cursor in a state where it cannot be advanced +** in either direction. In other words, the Next and Prev opcodes will +** not work following this opcode. +** +** See also: Found, NotFound, NoConflict, SeekRowid +*/ +/* Opcode: NotExists P1 P2 P3 * * +** Synopsis: intkey=r[P3] +** +** P1 is the index of a cursor open on an SQL table btree (with integer +** keys). P3 is an integer rowid. If P1 does not contain a record with +** rowid P3 then jump immediately to P2. Or, if P2 is 0, raise an +** SQLITE_CORRUPT error. If P1 does contain a record with rowid P3 then +** leave the cursor pointing at that record and fall through to the next +** instruction. +** +** The OP_SeekRowid opcode performs the same operation but also allows the +** P3 register to contain a non-integer value, in which case the jump is +** always taken. This opcode requires that P3 always contain an integer. +** +** The OP_NotFound opcode performs the same operation on index btrees +** (with arbitrary multi-value keys). +** +** This opcode leaves the cursor in a state where it cannot be advanced +** in either direction. In other words, the Next and Prev opcodes will +** not work following this opcode. +** +** See also: Found, NotFound, NoConflict, SeekRowid +*/ +case OP_SeekRowid: { /* jump, in3, ncycle */ + VdbeCursor *pC; + BtCursor *pCrsr; + int res; + u64 iKey; + + pIn3 = &aMem[pOp->p3]; + testcase( pIn3->flags & MEM_Int ); + testcase( pIn3->flags & MEM_IntReal ); + testcase( pIn3->flags & MEM_Real ); + testcase( (pIn3->flags & (MEM_Str|MEM_Int))==MEM_Str ); + if( (pIn3->flags & (MEM_Int|MEM_IntReal))==0 ){ + /* If pIn3->u.i does not contain an integer, compute iKey as the + ** integer value of pIn3. Jump to P2 if pIn3 cannot be converted + ** into an integer without loss of information. Take care to avoid + ** changing the datatype of pIn3, however, as it is used by other + ** parts of the prepared statement. */ + Mem x = pIn3[0]; + applyAffinity(&x, SQLITE_AFF_NUMERIC, encoding); + if( (x.flags & MEM_Int)==0 ) goto jump_to_p2; + iKey = x.u.i; + goto notExistsWithKey; + } + /* Fall through into OP_NotExists */ + /* no break */ deliberate_fall_through +case OP_NotExists: /* jump, in3, ncycle */ + pIn3 = &aMem[pOp->p3]; + assert( (pIn3->flags & MEM_Int)!=0 || pOp->opcode==OP_SeekRowid ); + assert( pOp->p1>=0 && pOp->p1nCursor ); + iKey = pIn3->u.i; +notExistsWithKey: + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); +#ifdef SQLITE_DEBUG + if( pOp->opcode==OP_SeekRowid ) pC->seekOp = OP_SeekRowid; +#endif + assert( pC->isTable ); + assert( pC->eCurType==CURTYPE_BTREE ); + pCrsr = pC->uc.pCursor; + assert( pCrsr!=0 ); + res = 0; + rc = sqlite3BtreeTableMoveto(pCrsr, iKey, 0, &res); + assert( rc==SQLITE_OK || res==0 ); + pC->movetoTarget = iKey; /* Used by OP_Delete */ + pC->nullRow = 0; + pC->cacheStatus = CACHE_STALE; + pC->deferredMoveto = 0; + VdbeBranchTaken(res!=0,2); + pC->seekResult = res; + if( res!=0 ){ + assert( rc==SQLITE_OK ); + if( pOp->p2==0 ){ + rc = SQLITE_CORRUPT_BKPT; + }else{ + goto jump_to_p2; + } + } + if( rc ) goto abort_due_to_error; + break; +} + +/* Opcode: Sequence P1 P2 * * * +** Synopsis: r[P2]=cursor[P1].ctr++ +** +** Find the next available sequence number for cursor P1. +** Write the sequence number into register P2. +** The sequence number on the cursor is incremented after this +** instruction. +*/ +case OP_Sequence: { /* out2 */ + assert( pOp->p1>=0 && pOp->p1nCursor ); + assert( p->apCsr[pOp->p1]!=0 ); + assert( p->apCsr[pOp->p1]->eCurType!=CURTYPE_VTAB ); + pOut = out2Prerelease(p, pOp); + pOut->u.i = p->apCsr[pOp->p1]->seqCount++; + break; +} + + +/* Opcode: NewRowid P1 P2 P3 * * +** Synopsis: r[P2]=rowid +** +** Get a new integer record number (a.k.a "rowid") used as the key to a table. +** The record number is not previously used as a key in the database +** table that cursor P1 points to. The new record number is written +** written to register P2. +** +** If P3>0 then P3 is a register in the root frame of this VDBE that holds +** the largest previously generated record number. No new record numbers are +** allowed to be less than this value. When this value reaches its maximum, +** an SQLITE_FULL error is generated. The P3 register is updated with the ' +** generated record number. This P3 mechanism is used to help implement the +** AUTOINCREMENT feature. +*/ +case OP_NewRowid: { /* out2 */ + i64 v; /* The new rowid */ + VdbeCursor *pC; /* Cursor of table to get the new rowid */ + int res; /* Result of an sqlite3BtreeLast() */ + int cnt; /* Counter to limit the number of searches */ +#ifndef SQLITE_OMIT_AUTOINCREMENT + Mem *pMem; /* Register holding largest rowid for AUTOINCREMENT */ + VdbeFrame *pFrame; /* Root frame of VDBE */ +#endif + + v = 0; + res = 0; + pOut = out2Prerelease(p, pOp); + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->isTable ); + assert( pC->eCurType==CURTYPE_BTREE ); + assert( pC->uc.pCursor!=0 ); + { + /* The next rowid or record number (different terms for the same + ** thing) is obtained in a two-step algorithm. + ** + ** First we attempt to find the largest existing rowid and add one + ** to that. But if the largest existing rowid is already the maximum + ** positive integer, we have to fall through to the second + ** probabilistic algorithm + ** + ** The second algorithm is to select a rowid at random and see if + ** it already exists in the table. If it does not exist, we have + ** succeeded. If the random rowid does exist, we select a new one + ** and try again, up to 100 times. + */ + assert( pC->isTable ); + +#ifdef SQLITE_32BIT_ROWID +# define MAX_ROWID 0x7fffffff +#else + /* Some compilers complain about constants of the form 0x7fffffffffffffff. + ** Others complain about 0x7ffffffffffffffffLL. The following macro seems + ** to provide the constant while making all compilers happy. + */ +# define MAX_ROWID (i64)( (((u64)0x7fffffff)<<32) | (u64)0xffffffff ) +#endif + + if( !pC->useRandomRowid ){ + rc = sqlite3BtreeLast(pC->uc.pCursor, &res); + if( rc!=SQLITE_OK ){ + goto abort_due_to_error; + } + if( res ){ + v = 1; /* IMP: R-61914-48074 */ + }else{ + assert( sqlite3BtreeCursorIsValid(pC->uc.pCursor) ); + v = sqlite3BtreeIntegerKey(pC->uc.pCursor); + if( v>=MAX_ROWID ){ + pC->useRandomRowid = 1; + }else{ + v++; /* IMP: R-29538-34987 */ + } + } + } + +#ifndef SQLITE_OMIT_AUTOINCREMENT + if( pOp->p3 ){ + /* Assert that P3 is a valid memory cell. */ + assert( pOp->p3>0 ); + if( p->pFrame ){ + for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent); + /* Assert that P3 is a valid memory cell. */ + assert( pOp->p3<=pFrame->nMem ); + pMem = &pFrame->aMem[pOp->p3]; + }else{ + /* Assert that P3 is a valid memory cell. */ + assert( pOp->p3<=(p->nMem+1 - p->nCursor) ); + pMem = &aMem[pOp->p3]; + memAboutToChange(p, pMem); + } + assert( memIsValid(pMem) ); + + REGISTER_TRACE(pOp->p3, pMem); + sqlite3VdbeMemIntegerify(pMem); + assert( (pMem->flags & MEM_Int)!=0 ); /* mem(P3) holds an integer */ + if( pMem->u.i==MAX_ROWID || pC->useRandomRowid ){ + rc = SQLITE_FULL; /* IMP: R-17817-00630 */ + goto abort_due_to_error; + } + if( vu.i+1 ){ + v = pMem->u.i + 1; + } + pMem->u.i = v; + } +#endif + if( pC->useRandomRowid ){ + /* IMPLEMENTATION-OF: R-07677-41881 If the largest ROWID is equal to the + ** largest possible integer (9223372036854775807) then the database + ** engine starts picking positive candidate ROWIDs at random until + ** it finds one that is not previously used. */ + assert( pOp->p3==0 ); /* We cannot be in random rowid mode if this is + ** an AUTOINCREMENT table. */ + cnt = 0; + do{ + sqlite3_randomness(sizeof(v), &v); + v &= (MAX_ROWID>>1); v++; /* Ensure that v is greater than zero */ + }while( ((rc = sqlite3BtreeTableMoveto(pC->uc.pCursor, (u64)v, + 0, &res))==SQLITE_OK) + && (res==0) + && (++cnt<100)); + if( rc ) goto abort_due_to_error; + if( res==0 ){ + rc = SQLITE_FULL; /* IMP: R-38219-53002 */ + goto abort_due_to_error; + } + assert( v>0 ); /* EV: R-40812-03570 */ + } + pC->deferredMoveto = 0; + pC->cacheStatus = CACHE_STALE; + } + pOut->u.i = v; + break; +} + +/* Opcode: Insert P1 P2 P3 P4 P5 +** Synopsis: intkey=r[P3] data=r[P2] +** +** Write an entry into the table of cursor P1. A new entry is +** created if it doesn't already exist or the data for an existing +** entry is overwritten. The data is the value MEM_Blob stored in register +** number P2. The key is stored in register P3. The key must +** be a MEM_Int. +** +** If the OPFLAG_NCHANGE flag of P5 is set, then the row change count is +** incremented (otherwise not). If the OPFLAG_LASTROWID flag of P5 is set, +** then rowid is stored for subsequent return by the +** sqlite3_last_insert_rowid() function (otherwise it is unmodified). +** +** If the OPFLAG_USESEEKRESULT flag of P5 is set, the implementation might +** run faster by avoiding an unnecessary seek on cursor P1. However, +** the OPFLAG_USESEEKRESULT flag must only be set if there have been no prior +** seeks on the cursor or if the most recent seek used a key equal to P3. +** +** If the OPFLAG_ISUPDATE flag is set, then this opcode is part of an +** UPDATE operation. Otherwise (if the flag is clear) then this opcode +** is part of an INSERT operation. The difference is only important to +** the update hook. +** +** Parameter P4 may point to a Table structure, or may be NULL. If it is +** not NULL, then the update-hook (sqlite3.xUpdateCallback) is invoked +** following a successful insert. +** +** (WARNING/TODO: If P1 is a pseudo-cursor and P2 is dynamically +** allocated, then ownership of P2 is transferred to the pseudo-cursor +** and register P2 becomes ephemeral. If the cursor is changed, the +** value of register P2 will then change. Make sure this does not +** cause any problems.) +** +** This instruction only works on tables. The equivalent instruction +** for indices is OP_IdxInsert. +*/ +case OP_Insert: { + Mem *pData; /* MEM cell holding data for the record to be inserted */ + Mem *pKey; /* MEM cell holding key for the record */ + VdbeCursor *pC; /* Cursor to table into which insert is written */ + int seekResult; /* Result of prior seek or 0 if no USESEEKRESULT flag */ + const char *zDb; /* database name - used by the update hook */ + Table *pTab; /* Table structure - used by update and pre-update hooks */ + BtreePayload x; /* Payload to be inserted */ + + pData = &aMem[pOp->p2]; + assert( pOp->p1>=0 && pOp->p1nCursor ); + assert( memIsValid(pData) ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + assert( pC->deferredMoveto==0 ); + assert( pC->uc.pCursor!=0 ); + assert( (pOp->p5 & OPFLAG_ISNOOP) || pC->isTable ); + assert( pOp->p4type==P4_TABLE || pOp->p4type>=P4_STATIC ); + REGISTER_TRACE(pOp->p2, pData); + sqlite3VdbeIncrWriteCounter(p, pC); + + pKey = &aMem[pOp->p3]; + assert( pKey->flags & MEM_Int ); + assert( memIsValid(pKey) ); + REGISTER_TRACE(pOp->p3, pKey); + x.nKey = pKey->u.i; + + if( pOp->p4type==P4_TABLE && HAS_UPDATE_HOOK(db) ){ + assert( pC->iDb>=0 ); + zDb = db->aDb[pC->iDb].zDbSName; + pTab = pOp->p4.pTab; + assert( (pOp->p5 & OPFLAG_ISNOOP) || HasRowid(pTab) ); + }else{ + pTab = 0; + zDb = 0; + } + +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + /* Invoke the pre-update hook, if any */ + if( pTab ){ + if( db->xPreUpdateCallback && !(pOp->p5 & OPFLAG_ISUPDATE) ){ + sqlite3VdbePreUpdateHook(p,pC,SQLITE_INSERT,zDb,pTab,x.nKey,pOp->p2,-1); + } + if( db->xUpdateCallback==0 || pTab->aCol==0 ){ + /* Prevent post-update hook from running in cases when it should not */ + pTab = 0; + } + } + if( pOp->p5 & OPFLAG_ISNOOP ) break; +#endif + + assert( (pOp->p5 & OPFLAG_LASTROWID)==0 || (pOp->p5 & OPFLAG_NCHANGE)!=0 ); + if( pOp->p5 & OPFLAG_NCHANGE ){ + p->nChange++; + if( pOp->p5 & OPFLAG_LASTROWID ) db->lastRowid = x.nKey; + } + assert( (pData->flags & (MEM_Blob|MEM_Str))!=0 || pData->n==0 ); + x.pData = pData->z; + x.nData = pData->n; + seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0); + if( pData->flags & MEM_Zero ){ + x.nZero = pData->u.nZero; + }else{ + x.nZero = 0; + } + x.pKey = 0; + assert( BTREE_PREFORMAT==OPFLAG_PREFORMAT ); + rc = sqlite3BtreeInsert(pC->uc.pCursor, &x, + (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION|OPFLAG_PREFORMAT)), + seekResult + ); + pC->deferredMoveto = 0; + pC->cacheStatus = CACHE_STALE; + + /* Invoke the update-hook if required. */ + if( rc ) goto abort_due_to_error; + if( pTab ){ + assert( db->xUpdateCallback!=0 ); + assert( pTab->aCol!=0 ); + db->xUpdateCallback(db->pUpdateArg, + (pOp->p5 & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_INSERT, + zDb, pTab->zName, x.nKey); + } + break; +} + +/* Opcode: RowCell P1 P2 P3 * * +** +** P1 and P2 are both open cursors. Both must be opened on the same type +** of table - intkey or index. This opcode is used as part of copying +** the current row from P2 into P1. If the cursors are opened on intkey +** tables, register P3 contains the rowid to use with the new record in +** P1. If they are opened on index tables, P3 is not used. +** +** This opcode must be followed by either an Insert or InsertIdx opcode +** with the OPFLAG_PREFORMAT flag set to complete the insert operation. +*/ +case OP_RowCell: { + VdbeCursor *pDest; /* Cursor to write to */ + VdbeCursor *pSrc; /* Cursor to read from */ + i64 iKey; /* Rowid value to insert with */ + assert( pOp[1].opcode==OP_Insert || pOp[1].opcode==OP_IdxInsert ); + assert( pOp[1].opcode==OP_Insert || pOp->p3==0 ); + assert( pOp[1].opcode==OP_IdxInsert || pOp->p3>0 ); + assert( pOp[1].p5 & OPFLAG_PREFORMAT ); + pDest = p->apCsr[pOp->p1]; + pSrc = p->apCsr[pOp->p2]; + iKey = pOp->p3 ? aMem[pOp->p3].u.i : 0; + rc = sqlite3BtreeTransferRow(pDest->uc.pCursor, pSrc->uc.pCursor, iKey); + if( rc!=SQLITE_OK ) goto abort_due_to_error; + break; +}; + +/* Opcode: Delete P1 P2 P3 P4 P5 +** +** Delete the record at which the P1 cursor is currently pointing. +** +** If the OPFLAG_SAVEPOSITION bit of the P5 parameter is set, then +** the cursor will be left pointing at either the next or the previous +** record in the table. If it is left pointing at the next record, then +** the next Next instruction will be a no-op. As a result, in this case +** it is ok to delete a record from within a Next loop. If +** OPFLAG_SAVEPOSITION bit of P5 is clear, then the cursor will be +** left in an undefined state. +** +** If the OPFLAG_AUXDELETE bit is set on P5, that indicates that this +** delete one of several associated with deleting a table row and all its +** associated index entries. Exactly one of those deletes is the "primary" +** delete. The others are all on OPFLAG_FORDELETE cursors or else are +** marked with the AUXDELETE flag. +** +** If the OPFLAG_NCHANGE flag of P2 (NB: P2 not P5) is set, then the row +** change count is incremented (otherwise not). +** +** P1 must not be pseudo-table. It has to be a real table with +** multiple rows. +** +** If P4 is not NULL then it points to a Table object. In this case either +** the update or pre-update hook, or both, may be invoked. The P1 cursor must +** have been positioned using OP_NotFound prior to invoking this opcode in +** this case. Specifically, if one is configured, the pre-update hook is +** invoked if P4 is not NULL. The update-hook is invoked if one is configured, +** P4 is not NULL, and the OPFLAG_NCHANGE flag is set in P2. +** +** If the OPFLAG_ISUPDATE flag is set in P2, then P3 contains the address +** of the memory cell that contains the value that the rowid of the row will +** be set to by the update. +*/ +case OP_Delete: { + VdbeCursor *pC; + const char *zDb; + Table *pTab; + int opflags; + + opflags = pOp->p2; + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + assert( pC->uc.pCursor!=0 ); + assert( pC->deferredMoveto==0 ); + sqlite3VdbeIncrWriteCounter(p, pC); + +#ifdef SQLITE_DEBUG + if( pOp->p4type==P4_TABLE + && HasRowid(pOp->p4.pTab) + && pOp->p5==0 + && sqlite3BtreeCursorIsValidNN(pC->uc.pCursor) + ){ + /* If p5 is zero, the seek operation that positioned the cursor prior to + ** OP_Delete will have also set the pC->movetoTarget field to the rowid of + ** the row that is being deleted */ + i64 iKey = sqlite3BtreeIntegerKey(pC->uc.pCursor); + assert( CORRUPT_DB || pC->movetoTarget==iKey ); + } +#endif + + /* If the update-hook or pre-update-hook will be invoked, set zDb to + ** the name of the db to pass as to it. Also set local pTab to a copy + ** of p4.pTab. Finally, if p5 is true, indicating that this cursor was + ** last moved with OP_Next or OP_Prev, not Seek or NotFound, set + ** VdbeCursor.movetoTarget to the current rowid. */ + if( pOp->p4type==P4_TABLE && HAS_UPDATE_HOOK(db) ){ + assert( pC->iDb>=0 ); + assert( pOp->p4.pTab!=0 ); + zDb = db->aDb[pC->iDb].zDbSName; + pTab = pOp->p4.pTab; + if( (pOp->p5 & OPFLAG_SAVEPOSITION)!=0 && pC->isTable ){ + pC->movetoTarget = sqlite3BtreeIntegerKey(pC->uc.pCursor); + } + }else{ + zDb = 0; + pTab = 0; + } + +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + /* Invoke the pre-update-hook if required. */ + assert( db->xPreUpdateCallback==0 || pTab==pOp->p4.pTab ); + if( db->xPreUpdateCallback && pTab ){ + assert( !(opflags & OPFLAG_ISUPDATE) + || HasRowid(pTab)==0 + || (aMem[pOp->p3].flags & MEM_Int) + ); + sqlite3VdbePreUpdateHook(p, pC, + (opflags & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_DELETE, + zDb, pTab, pC->movetoTarget, + pOp->p3, -1 + ); + } + if( opflags & OPFLAG_ISNOOP ) break; +#endif + + /* Only flags that can be set are SAVEPOISTION and AUXDELETE */ + assert( (pOp->p5 & ~(OPFLAG_SAVEPOSITION|OPFLAG_AUXDELETE))==0 ); + assert( OPFLAG_SAVEPOSITION==BTREE_SAVEPOSITION ); + assert( OPFLAG_AUXDELETE==BTREE_AUXDELETE ); + +#ifdef SQLITE_DEBUG + if( p->pFrame==0 ){ + if( pC->isEphemeral==0 + && (pOp->p5 & OPFLAG_AUXDELETE)==0 + && (pC->wrFlag & OPFLAG_FORDELETE)==0 + ){ + nExtraDelete++; + } + if( pOp->p2 & OPFLAG_NCHANGE ){ + nExtraDelete--; + } + } +#endif + + rc = sqlite3BtreeDelete(pC->uc.pCursor, pOp->p5); + pC->cacheStatus = CACHE_STALE; + pC->seekResult = 0; + if( rc ) goto abort_due_to_error; + + /* Invoke the update-hook if required. */ + if( opflags & OPFLAG_NCHANGE ){ + p->nChange++; + if( db->xUpdateCallback && ALWAYS(pTab!=0) && HasRowid(pTab) ){ + db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, pTab->zName, + pC->movetoTarget); + assert( pC->iDb>=0 ); + } + } + + break; +} +/* Opcode: ResetCount * * * * * +** +** The value of the change counter is copied to the database handle +** change counter (returned by subsequent calls to sqlite3_changes()). +** Then the VMs internal change counter resets to 0. +** This is used by trigger programs. +*/ +case OP_ResetCount: { + sqlite3VdbeSetChanges(db, p->nChange); + p->nChange = 0; + break; +} + +/* Opcode: SorterCompare P1 P2 P3 P4 +** Synopsis: if key(P1)!=trim(r[P3],P4) goto P2 +** +** P1 is a sorter cursor. This instruction compares a prefix of the +** record blob in register P3 against a prefix of the entry that +** the sorter cursor currently points to. Only the first P4 fields +** of r[P3] and the sorter record are compared. +** +** If either P3 or the sorter contains a NULL in one of their significant +** fields (not counting the P4 fields at the end which are ignored) then +** the comparison is assumed to be equal. +** +** Fall through to next instruction if the two records compare equal to +** each other. Jump to P2 if they are different. +*/ +case OP_SorterCompare: { + VdbeCursor *pC; + int res; + int nKeyCol; + + pC = p->apCsr[pOp->p1]; + assert( isSorter(pC) ); + assert( pOp->p4type==P4_INT32 ); + pIn3 = &aMem[pOp->p3]; + nKeyCol = pOp->p4.i; + res = 0; + rc = sqlite3VdbeSorterCompare(pC, pIn3, nKeyCol, &res); + VdbeBranchTaken(res!=0,2); + if( rc ) goto abort_due_to_error; + if( res ) goto jump_to_p2; + break; +}; + +/* Opcode: SorterData P1 P2 P3 * * +** Synopsis: r[P2]=data +** +** Write into register P2 the current sorter data for sorter cursor P1. +** Then clear the column header cache on cursor P3. +** +** This opcode is normally use to move a record out of the sorter and into +** a register that is the source for a pseudo-table cursor created using +** OpenPseudo. That pseudo-table cursor is the one that is identified by +** parameter P3. Clearing the P3 column cache as part of this opcode saves +** us from having to issue a separate NullRow instruction to clear that cache. +*/ +case OP_SorterData: { + VdbeCursor *pC; + + pOut = &aMem[pOp->p2]; + pC = p->apCsr[pOp->p1]; + assert( isSorter(pC) ); + rc = sqlite3VdbeSorterRowkey(pC, pOut); + assert( rc!=SQLITE_OK || (pOut->flags & MEM_Blob) ); + assert( pOp->p1>=0 && pOp->p1nCursor ); + if( rc ) goto abort_due_to_error; + p->apCsr[pOp->p3]->cacheStatus = CACHE_STALE; + break; +} + +/* Opcode: RowData P1 P2 P3 * * +** Synopsis: r[P2]=data +** +** Write into register P2 the complete row content for the row at +** which cursor P1 is currently pointing. +** There is no interpretation of the data. +** It is just copied onto the P2 register exactly as +** it is found in the database file. +** +** If cursor P1 is an index, then the content is the key of the row. +** If cursor P2 is a table, then the content extracted is the data. +** +** If the P1 cursor must be pointing to a valid row (not a NULL row) +** of a real table, not a pseudo-table. +** +** If P3!=0 then this opcode is allowed to make an ephemeral pointer +** into the database page. That means that the content of the output +** register will be invalidated as soon as the cursor moves - including +** moves caused by other cursors that "save" the current cursors +** position in order that they can write to the same table. If P3==0 +** then a copy of the data is made into memory. P3!=0 is faster, but +** P3==0 is safer. +** +** If P3!=0 then the content of the P2 register is unsuitable for use +** in OP_Result and any OP_Result will invalidate the P2 register content. +** The P2 register content is invalidated by opcodes like OP_Function or +** by any use of another cursor pointing to the same table. +*/ +case OP_RowData: { + VdbeCursor *pC; + BtCursor *pCrsr; + u32 n; + + pOut = out2Prerelease(p, pOp); + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + assert( isSorter(pC)==0 ); + assert( pC->nullRow==0 ); + assert( pC->uc.pCursor!=0 ); + pCrsr = pC->uc.pCursor; + + /* The OP_RowData opcodes always follow OP_NotExists or + ** OP_SeekRowid or OP_Rewind/Op_Next with no intervening instructions + ** that might invalidate the cursor. + ** If this where not the case, on of the following assert()s + ** would fail. Should this ever change (because of changes in the code + ** generator) then the fix would be to insert a call to + ** sqlite3VdbeCursorMoveto(). + */ + assert( pC->deferredMoveto==0 ); + assert( sqlite3BtreeCursorIsValid(pCrsr) ); + + n = sqlite3BtreePayloadSize(pCrsr); + if( n>(u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){ + goto too_big; + } + testcase( n==0 ); + rc = sqlite3VdbeMemFromBtreeZeroOffset(pCrsr, n, pOut); + if( rc ) goto abort_due_to_error; + if( !pOp->p3 ) Deephemeralize(pOut); + UPDATE_MAX_BLOBSIZE(pOut); + REGISTER_TRACE(pOp->p2, pOut); + break; +} + +/* Opcode: Rowid P1 P2 * * * +** Synopsis: r[P2]=PX rowid of P1 +** +** Store in register P2 an integer which is the key of the table entry that +** P1 is currently point to. +** +** P1 can be either an ordinary table or a virtual table. There used to +** be a separate OP_VRowid opcode for use with virtual tables, but this +** one opcode now works for both table types. +*/ +case OP_Rowid: { /* out2, ncycle */ + VdbeCursor *pC; + i64 v; + sqlite3_vtab *pVtab; + const sqlite3_module *pModule; + + pOut = out2Prerelease(p, pOp); + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow ); + if( pC->nullRow ){ + pOut->flags = MEM_Null; + break; + }else if( pC->deferredMoveto ){ + v = pC->movetoTarget; +#ifndef SQLITE_OMIT_VIRTUALTABLE + }else if( pC->eCurType==CURTYPE_VTAB ){ + assert( pC->uc.pVCur!=0 ); + pVtab = pC->uc.pVCur->pVtab; + pModule = pVtab->pModule; + assert( pModule->xRowid ); + rc = pModule->xRowid(pC->uc.pVCur, &v); + sqlite3VtabImportErrmsg(p, pVtab); + if( rc ) goto abort_due_to_error; +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + }else{ + assert( pC->eCurType==CURTYPE_BTREE ); + assert( pC->uc.pCursor!=0 ); + rc = sqlite3VdbeCursorRestore(pC); + if( rc ) goto abort_due_to_error; + if( pC->nullRow ){ + pOut->flags = MEM_Null; + break; + } + v = sqlite3BtreeIntegerKey(pC->uc.pCursor); + } + pOut->u.i = v; + break; +} + +/* Opcode: NullRow P1 * * * * +** +** Move the cursor P1 to a null row. Any OP_Column operations +** that occur while the cursor is on the null row will always +** write a NULL. +** +** If cursor P1 is not previously opened, open it now to a special +** pseudo-cursor that always returns NULL for every column. +*/ +case OP_NullRow: { + VdbeCursor *pC; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + if( pC==0 ){ + /* If the cursor is not already open, create a special kind of + ** pseudo-cursor that always gives null rows. */ + pC = allocateCursor(p, pOp->p1, 1, CURTYPE_PSEUDO); + if( pC==0 ) goto no_mem; + pC->seekResult = 0; + pC->isTable = 1; + pC->noReuse = 1; + pC->uc.pCursor = sqlite3BtreeFakeValidCursor(); + } + pC->nullRow = 1; + pC->cacheStatus = CACHE_STALE; + if( pC->eCurType==CURTYPE_BTREE ){ + assert( pC->uc.pCursor!=0 ); + sqlite3BtreeClearCursor(pC->uc.pCursor); + } +#ifdef SQLITE_DEBUG + if( pC->seekOp==0 ) pC->seekOp = OP_NullRow; +#endif + break; +} + +/* Opcode: SeekEnd P1 * * * * +** +** Position cursor P1 at the end of the btree for the purpose of +** appending a new entry onto the btree. +** +** It is assumed that the cursor is used only for appending and so +** if the cursor is valid, then the cursor must already be pointing +** at the end of the btree and so no changes are made to +** the cursor. +*/ +/* Opcode: Last P1 P2 * * * +** +** The next use of the Rowid or Column or Prev instruction for P1 +** will refer to the last entry in the database table or index. +** If the table or index is empty and P2>0, then jump immediately to P2. +** If P2 is 0 or if the table or index is not empty, fall through +** to the following instruction. +** +** This opcode leaves the cursor configured to move in reverse order, +** from the end toward the beginning. In other words, the cursor is +** configured to use Prev, not Next. +*/ +case OP_SeekEnd: /* ncycle */ +case OP_Last: { /* jump, ncycle */ + VdbeCursor *pC; + BtCursor *pCrsr; + int res; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + pCrsr = pC->uc.pCursor; + res = 0; + assert( pCrsr!=0 ); +#ifdef SQLITE_DEBUG + pC->seekOp = pOp->opcode; +#endif + if( pOp->opcode==OP_SeekEnd ){ + assert( pOp->p2==0 ); + pC->seekResult = -1; + if( sqlite3BtreeCursorIsValidNN(pCrsr) ){ + break; + } + } + rc = sqlite3BtreeLast(pCrsr, &res); + pC->nullRow = (u8)res; + pC->deferredMoveto = 0; + pC->cacheStatus = CACHE_STALE; + if( rc ) goto abort_due_to_error; + if( pOp->p2>0 ){ + VdbeBranchTaken(res!=0,2); + if( res ) goto jump_to_p2; + } + break; +} + +/* Opcode: IfSmaller P1 P2 P3 * * +** +** Estimate the number of rows in the table P1. Jump to P2 if that +** estimate is less than approximately 2**(0.1*P3). +*/ +case OP_IfSmaller: { /* jump */ + VdbeCursor *pC; + BtCursor *pCrsr; + int res; + i64 sz; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + pCrsr = pC->uc.pCursor; + assert( pCrsr ); + rc = sqlite3BtreeFirst(pCrsr, &res); + if( rc ) goto abort_due_to_error; + if( res==0 ){ + sz = sqlite3BtreeRowCountEst(pCrsr); + if( ALWAYS(sz>=0) && sqlite3LogEst((u64)sz)p3 ) res = 1; + } + VdbeBranchTaken(res!=0,2); + if( res ) goto jump_to_p2; + break; +} + + +/* Opcode: SorterSort P1 P2 * * * +** +** After all records have been inserted into the Sorter object +** identified by P1, invoke this opcode to actually do the sorting. +** Jump to P2 if there are no records to be sorted. +** +** This opcode is an alias for OP_Sort and OP_Rewind that is used +** for Sorter objects. +*/ +/* Opcode: Sort P1 P2 * * * +** +** This opcode does exactly the same thing as OP_Rewind except that +** it increments an undocumented global variable used for testing. +** +** Sorting is accomplished by writing records into a sorting index, +** then rewinding that index and playing it back from beginning to +** end. We use the OP_Sort opcode instead of OP_Rewind to do the +** rewinding so that the global variable will be incremented and +** regression tests can determine whether or not the optimizer is +** correctly optimizing out sorts. +*/ +case OP_SorterSort: /* jump */ +case OP_Sort: { /* jump */ +#ifdef SQLITE_TEST + sqlite3_sort_count++; + sqlite3_search_count--; +#endif + p->aCounter[SQLITE_STMTSTATUS_SORT]++; + /* Fall through into OP_Rewind */ + /* no break */ deliberate_fall_through +} +/* Opcode: Rewind P1 P2 * * * +** +** The next use of the Rowid or Column or Next instruction for P1 +** will refer to the first entry in the database table or index. +** If the table or index is empty, jump immediately to P2. +** If the table or index is not empty, fall through to the following +** instruction. +** +** If P2 is zero, that is an assertion that the P1 table is never +** empty and hence the jump will never be taken. +** +** This opcode leaves the cursor configured to move in forward order, +** from the beginning toward the end. In other words, the cursor is +** configured to use Next, not Prev. +*/ +case OP_Rewind: { /* jump, ncycle */ + VdbeCursor *pC; + BtCursor *pCrsr; + int res; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + assert( pOp->p5==0 ); + assert( pOp->p2>=0 && pOp->p2nOp ); + + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( isSorter(pC)==(pOp->opcode==OP_SorterSort) ); + res = 1; +#ifdef SQLITE_DEBUG + pC->seekOp = OP_Rewind; +#endif + if( isSorter(pC) ){ + rc = sqlite3VdbeSorterRewind(pC, &res); + }else{ + assert( pC->eCurType==CURTYPE_BTREE ); + pCrsr = pC->uc.pCursor; + assert( pCrsr ); + rc = sqlite3BtreeFirst(pCrsr, &res); + pC->deferredMoveto = 0; + pC->cacheStatus = CACHE_STALE; + } + if( rc ) goto abort_due_to_error; + pC->nullRow = (u8)res; + if( pOp->p2>0 ){ + VdbeBranchTaken(res!=0,2); + if( res ) goto jump_to_p2; + } + break; +} + +/* Opcode: Next P1 P2 P3 * P5 +** +** Advance cursor P1 so that it points to the next key/data pair in its +** table or index. If there are no more key/value pairs then fall through +** to the following instruction. But if the cursor advance was successful, +** jump immediately to P2. +** +** The Next opcode is only valid following an SeekGT, SeekGE, or +** OP_Rewind opcode used to position the cursor. Next is not allowed +** to follow SeekLT, SeekLE, or OP_Last. +** +** The P1 cursor must be for a real table, not a pseudo-table. P1 must have +** been opened prior to this opcode or the program will segfault. +** +** The P3 value is a hint to the btree implementation. If P3==1, that +** means P1 is an SQL index and that this instruction could have been +** omitted if that index had been unique. P3 is usually 0. P3 is +** always either 0 or 1. +** +** If P5 is positive and the jump is taken, then event counter +** number P5-1 in the prepared statement is incremented. +** +** See also: Prev +*/ +/* Opcode: Prev P1 P2 P3 * P5 +** +** Back up cursor P1 so that it points to the previous key/data pair in its +** table or index. If there is no previous key/value pairs then fall through +** to the following instruction. But if the cursor backup was successful, +** jump immediately to P2. +** +** +** The Prev opcode is only valid following an SeekLT, SeekLE, or +** OP_Last opcode used to position the cursor. Prev is not allowed +** to follow SeekGT, SeekGE, or OP_Rewind. +** +** The P1 cursor must be for a real table, not a pseudo-table. If P1 is +** not open then the behavior is undefined. +** +** The P3 value is a hint to the btree implementation. If P3==1, that +** means P1 is an SQL index and that this instruction could have been +** omitted if that index had been unique. P3 is usually 0. P3 is +** always either 0 or 1. +** +** If P5 is positive and the jump is taken, then event counter +** number P5-1 in the prepared statement is incremented. +*/ +/* Opcode: SorterNext P1 P2 * * P5 +** +** This opcode works just like OP_Next except that P1 must be a +** sorter object for which the OP_SorterSort opcode has been +** invoked. This opcode advances the cursor to the next sorted +** record, or jumps to P2 if there are no more sorted records. +*/ +case OP_SorterNext: { /* jump */ + VdbeCursor *pC; + + pC = p->apCsr[pOp->p1]; + assert( isSorter(pC) ); + rc = sqlite3VdbeSorterNext(db, pC); + goto next_tail; + +case OP_Prev: /* jump, ncycle */ + assert( pOp->p1>=0 && pOp->p1nCursor ); + assert( pOp->p5==0 + || pOp->p5==SQLITE_STMTSTATUS_FULLSCAN_STEP + || pOp->p5==SQLITE_STMTSTATUS_AUTOINDEX); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->deferredMoveto==0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + assert( pC->seekOp==OP_SeekLT || pC->seekOp==OP_SeekLE + || pC->seekOp==OP_Last || pC->seekOp==OP_IfNoHope + || pC->seekOp==OP_NullRow); + rc = sqlite3BtreePrevious(pC->uc.pCursor, pOp->p3); + goto next_tail; + +case OP_Next: /* jump, ncycle */ + assert( pOp->p1>=0 && pOp->p1nCursor ); + assert( pOp->p5==0 + || pOp->p5==SQLITE_STMTSTATUS_FULLSCAN_STEP + || pOp->p5==SQLITE_STMTSTATUS_AUTOINDEX); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->deferredMoveto==0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + assert( pC->seekOp==OP_SeekGT || pC->seekOp==OP_SeekGE + || pC->seekOp==OP_Rewind || pC->seekOp==OP_Found + || pC->seekOp==OP_NullRow|| pC->seekOp==OP_SeekRowid + || pC->seekOp==OP_IfNoHope); + rc = sqlite3BtreeNext(pC->uc.pCursor, pOp->p3); + +next_tail: + pC->cacheStatus = CACHE_STALE; + VdbeBranchTaken(rc==SQLITE_OK,2); + if( rc==SQLITE_OK ){ + pC->nullRow = 0; + p->aCounter[pOp->p5]++; +#ifdef SQLITE_TEST + sqlite3_search_count++; +#endif + goto jump_to_p2_and_check_for_interrupt; + } + if( rc!=SQLITE_DONE ) goto abort_due_to_error; + rc = SQLITE_OK; + pC->nullRow = 1; + goto check_for_interrupt; +} + +/* Opcode: IdxInsert P1 P2 P3 P4 P5 +** Synopsis: key=r[P2] +** +** Register P2 holds an SQL index key made using the +** MakeRecord instructions. This opcode writes that key +** into the index P1. Data for the entry is nil. +** +** If P4 is not zero, then it is the number of values in the unpacked +** key of reg(P2). In that case, P3 is the index of the first register +** for the unpacked key. The availability of the unpacked key can sometimes +** be an optimization. +** +** If P5 has the OPFLAG_APPEND bit set, that is a hint to the b-tree layer +** that this insert is likely to be an append. +** +** If P5 has the OPFLAG_NCHANGE bit set, then the change counter is +** incremented by this instruction. If the OPFLAG_NCHANGE bit is clear, +** then the change counter is unchanged. +** +** If the OPFLAG_USESEEKRESULT flag of P5 is set, the implementation might +** run faster by avoiding an unnecessary seek on cursor P1. However, +** the OPFLAG_USESEEKRESULT flag must only be set if there have been no prior +** seeks on the cursor or if the most recent seek used a key equivalent +** to P2. +** +** This instruction only works for indices. The equivalent instruction +** for tables is OP_Insert. +*/ +case OP_IdxInsert: { /* in2 */ + VdbeCursor *pC; + BtreePayload x; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + sqlite3VdbeIncrWriteCounter(p, pC); + assert( pC!=0 ); + assert( !isSorter(pC) ); + pIn2 = &aMem[pOp->p2]; + assert( (pIn2->flags & MEM_Blob) || (pOp->p5 & OPFLAG_PREFORMAT) ); + if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++; + assert( pC->eCurType==CURTYPE_BTREE ); + assert( pC->isTable==0 ); + rc = ExpandBlob(pIn2); + if( rc ) goto abort_due_to_error; + x.nKey = pIn2->n; + x.pKey = pIn2->z; + x.aMem = aMem + pOp->p3; + x.nMem = (u16)pOp->p4.i; + rc = sqlite3BtreeInsert(pC->uc.pCursor, &x, + (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION|OPFLAG_PREFORMAT)), + ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0) + ); + assert( pC->deferredMoveto==0 ); + pC->cacheStatus = CACHE_STALE; + if( rc) goto abort_due_to_error; + break; +} + +/* Opcode: SorterInsert P1 P2 * * * +** Synopsis: key=r[P2] +** +** Register P2 holds an SQL index key made using the +** MakeRecord instructions. This opcode writes that key +** into the sorter P1. Data for the entry is nil. +*/ +case OP_SorterInsert: { /* in2 */ + VdbeCursor *pC; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + sqlite3VdbeIncrWriteCounter(p, pC); + assert( pC!=0 ); + assert( isSorter(pC) ); + pIn2 = &aMem[pOp->p2]; + assert( pIn2->flags & MEM_Blob ); + assert( pC->isTable==0 ); + rc = ExpandBlob(pIn2); + if( rc ) goto abort_due_to_error; + rc = sqlite3VdbeSorterWrite(pC, pIn2); + if( rc) goto abort_due_to_error; + break; +} + +/* Opcode: IdxDelete P1 P2 P3 * P5 +** Synopsis: key=r[P2@P3] +** +** The content of P3 registers starting at register P2 form +** an unpacked index key. This opcode removes that entry from the +** index opened by cursor P1. +** +** If P5 is not zero, then raise an SQLITE_CORRUPT_INDEX error +** if no matching index entry is found. This happens when running +** an UPDATE or DELETE statement and the index entry to be updated +** or deleted is not found. For some uses of IdxDelete +** (example: the EXCEPT operator) it does not matter that no matching +** entry is found. For those cases, P5 is zero. Also, do not raise +** this (self-correcting and non-critical) error if in writable_schema mode. +*/ +case OP_IdxDelete: { + VdbeCursor *pC; + BtCursor *pCrsr; + int res; + UnpackedRecord r; + + assert( pOp->p3>0 ); + assert( pOp->p2>0 && pOp->p2+pOp->p3<=(p->nMem+1 - p->nCursor)+1 ); + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + sqlite3VdbeIncrWriteCounter(p, pC); + pCrsr = pC->uc.pCursor; + assert( pCrsr!=0 ); + r.pKeyInfo = pC->pKeyInfo; + r.nField = (u16)pOp->p3; + r.default_rc = 0; + r.aMem = &aMem[pOp->p2]; + rc = sqlite3BtreeIndexMoveto(pCrsr, &r, &res); + if( rc ) goto abort_due_to_error; + if( res==0 ){ + rc = sqlite3BtreeDelete(pCrsr, BTREE_AUXDELETE); + if( rc ) goto abort_due_to_error; + }else if( pOp->p5 && !sqlite3WritableSchema(db) ){ + rc = sqlite3ReportError(SQLITE_CORRUPT_INDEX, __LINE__, "index corruption"); + goto abort_due_to_error; + } + assert( pC->deferredMoveto==0 ); + pC->cacheStatus = CACHE_STALE; + pC->seekResult = 0; + break; +} + +/* Opcode: DeferredSeek P1 * P3 P4 * +** Synopsis: Move P3 to P1.rowid if needed +** +** P1 is an open index cursor and P3 is a cursor on the corresponding +** table. This opcode does a deferred seek of the P3 table cursor +** to the row that corresponds to the current row of P1. +** +** This is a deferred seek. Nothing actually happens until +** the cursor is used to read a record. That way, if no reads +** occur, no unnecessary I/O happens. +** +** P4 may be an array of integers (type P4_INTARRAY) containing +** one entry for each column in the P3 table. If array entry a(i) +** is non-zero, then reading column a(i)-1 from cursor P3 is +** equivalent to performing the deferred seek and then reading column i +** from P1. This information is stored in P3 and used to redirect +** reads against P3 over to P1, thus possibly avoiding the need to +** seek and read cursor P3. +*/ +/* Opcode: IdxRowid P1 P2 * * * +** Synopsis: r[P2]=rowid +** +** Write into register P2 an integer which is the last entry in the record at +** the end of the index key pointed to by cursor P1. This integer should be +** the rowid of the table entry to which this index entry points. +** +** See also: Rowid, MakeRecord. +*/ +case OP_DeferredSeek: /* ncycle */ +case OP_IdxRowid: { /* out2, ncycle */ + VdbeCursor *pC; /* The P1 index cursor */ + VdbeCursor *pTabCur; /* The P2 table cursor (OP_DeferredSeek only) */ + i64 rowid; /* Rowid that P1 current points to */ + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->eCurType==CURTYPE_BTREE || IsNullCursor(pC) ); + assert( pC->uc.pCursor!=0 ); + assert( pC->isTable==0 || IsNullCursor(pC) ); + assert( pC->deferredMoveto==0 ); + assert( !pC->nullRow || pOp->opcode==OP_IdxRowid ); + + /* The IdxRowid and Seek opcodes are combined because of the commonality + ** of sqlite3VdbeCursorRestore() and sqlite3VdbeIdxRowid(). */ + rc = sqlite3VdbeCursorRestore(pC); + + /* sqlite3VdbeCursorRestore() may fail if the cursor has been disturbed + ** since it was last positioned and an error (e.g. OOM or an IO error) + ** occurs while trying to reposition it. */ + if( rc!=SQLITE_OK ) goto abort_due_to_error; + + if( !pC->nullRow ){ + rowid = 0; /* Not needed. Only used to silence a warning. */ + rc = sqlite3VdbeIdxRowid(db, pC->uc.pCursor, &rowid); + if( rc!=SQLITE_OK ){ + goto abort_due_to_error; + } + if( pOp->opcode==OP_DeferredSeek ){ + assert( pOp->p3>=0 && pOp->p3nCursor ); + pTabCur = p->apCsr[pOp->p3]; + assert( pTabCur!=0 ); + assert( pTabCur->eCurType==CURTYPE_BTREE ); + assert( pTabCur->uc.pCursor!=0 ); + assert( pTabCur->isTable ); + pTabCur->nullRow = 0; + pTabCur->movetoTarget = rowid; + pTabCur->deferredMoveto = 1; + pTabCur->cacheStatus = CACHE_STALE; + assert( pOp->p4type==P4_INTARRAY || pOp->p4.ai==0 ); + assert( !pTabCur->isEphemeral ); + pTabCur->ub.aAltMap = pOp->p4.ai; + assert( !pC->isEphemeral ); + pTabCur->pAltCursor = pC; + }else{ + pOut = out2Prerelease(p, pOp); + pOut->u.i = rowid; + } + }else{ + assert( pOp->opcode==OP_IdxRowid ); + sqlite3VdbeMemSetNull(&aMem[pOp->p2]); + } + break; +} + +/* Opcode: FinishSeek P1 * * * * +** +** If cursor P1 was previously moved via OP_DeferredSeek, complete that +** seek operation now, without further delay. If the cursor seek has +** already occurred, this instruction is a no-op. +*/ +case OP_FinishSeek: { /* ncycle */ + VdbeCursor *pC; /* The P1 index cursor */ + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + if( pC->deferredMoveto ){ + rc = sqlite3VdbeFinishMoveto(pC); + if( rc ) goto abort_due_to_error; + } + break; +} + +/* Opcode: IdxGE P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** The P4 register values beginning with P3 form an unpacked index +** key that omits the PRIMARY KEY. Compare this key value against the index +** that P1 is currently pointing to, ignoring the PRIMARY KEY or ROWID +** fields at the end. +** +** If the P1 index entry is greater than or equal to the key value +** then jump to P2. Otherwise fall through to the next instruction. +*/ +/* Opcode: IdxGT P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** The P4 register values beginning with P3 form an unpacked index +** key that omits the PRIMARY KEY. Compare this key value against the index +** that P1 is currently pointing to, ignoring the PRIMARY KEY or ROWID +** fields at the end. +** +** If the P1 index entry is greater than the key value +** then jump to P2. Otherwise fall through to the next instruction. +*/ +/* Opcode: IdxLT P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** The P4 register values beginning with P3 form an unpacked index +** key that omits the PRIMARY KEY or ROWID. Compare this key value against +** the index that P1 is currently pointing to, ignoring the PRIMARY KEY or +** ROWID on the P1 index. +** +** If the P1 index entry is less than the key value then jump to P2. +** Otherwise fall through to the next instruction. +*/ +/* Opcode: IdxLE P1 P2 P3 P4 * +** Synopsis: key=r[P3@P4] +** +** The P4 register values beginning with P3 form an unpacked index +** key that omits the PRIMARY KEY or ROWID. Compare this key value against +** the index that P1 is currently pointing to, ignoring the PRIMARY KEY or +** ROWID on the P1 index. +** +** If the P1 index entry is less than or equal to the key value then jump +** to P2. Otherwise fall through to the next instruction. +*/ +case OP_IdxLE: /* jump, ncycle */ +case OP_IdxGT: /* jump, ncycle */ +case OP_IdxLT: /* jump, ncycle */ +case OP_IdxGE: { /* jump, ncycle */ + VdbeCursor *pC; + int res; + UnpackedRecord r; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->isOrdered ); + assert( pC->eCurType==CURTYPE_BTREE ); + assert( pC->uc.pCursor!=0); + assert( pC->deferredMoveto==0 ); + assert( pOp->p4type==P4_INT32 ); + r.pKeyInfo = pC->pKeyInfo; + r.nField = (u16)pOp->p4.i; + if( pOp->opcodeopcode==OP_IdxLE || pOp->opcode==OP_IdxGT ); + r.default_rc = -1; + }else{ + assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxLT ); + r.default_rc = 0; + } + r.aMem = &aMem[pOp->p3]; +#ifdef SQLITE_DEBUG + { + int i; + for(i=0; ip3+i, &aMem[pOp->p3+i]); + } + } +#endif + + /* Inlined version of sqlite3VdbeIdxKeyCompare() */ + { + i64 nCellKey = 0; + BtCursor *pCur; + Mem m; + + assert( pC->eCurType==CURTYPE_BTREE ); + pCur = pC->uc.pCursor; + assert( sqlite3BtreeCursorIsValid(pCur) ); + nCellKey = sqlite3BtreePayloadSize(pCur); + /* nCellKey will always be between 0 and 0xffffffff because of the way + ** that btreeParseCellPtr() and sqlite3GetVarint32() are implemented */ + if( nCellKey<=0 || nCellKey>0x7fffffff ){ + rc = SQLITE_CORRUPT_BKPT; + goto abort_due_to_error; + } + sqlite3VdbeMemInit(&m, db, 0); + rc = sqlite3VdbeMemFromBtreeZeroOffset(pCur, (u32)nCellKey, &m); + if( rc ) goto abort_due_to_error; + res = sqlite3VdbeRecordCompareWithSkip(m.n, m.z, &r, 0); + sqlite3VdbeMemReleaseMalloc(&m); + } + /* End of inlined sqlite3VdbeIdxKeyCompare() */ + + assert( (OP_IdxLE&1)==(OP_IdxLT&1) && (OP_IdxGE&1)==(OP_IdxGT&1) ); + if( (pOp->opcode&1)==(OP_IdxLT&1) ){ + assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxLT ); + res = -res; + }else{ + assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxGT ); + res++; + } + VdbeBranchTaken(res>0,2); + assert( rc==SQLITE_OK ); + if( res>0 ) goto jump_to_p2; + break; +} + +/* Opcode: Destroy P1 P2 P3 * * +** +** Delete an entire database table or index whose root page in the database +** file is given by P1. +** +** The table being destroyed is in the main database file if P3==0. If +** P3==1 then the table to be clear is in the auxiliary database file +** that is used to store tables create using CREATE TEMPORARY TABLE. +** +** If AUTOVACUUM is enabled then it is possible that another root page +** might be moved into the newly deleted root page in order to keep all +** root pages contiguous at the beginning of the database. The former +** value of the root page that moved - its value before the move occurred - +** is stored in register P2. If no page movement was required (because the +** table being dropped was already the last one in the database) then a +** zero is stored in register P2. If AUTOVACUUM is disabled then a zero +** is stored in register P2. +** +** This opcode throws an error if there are any active reader VMs when +** it is invoked. This is done to avoid the difficulty associated with +** updating existing cursors when a root page is moved in an AUTOVACUUM +** database. This error is thrown even if the database is not an AUTOVACUUM +** db in order to avoid introducing an incompatibility between autovacuum +** and non-autovacuum modes. +** +** See also: Clear +*/ +case OP_Destroy: { /* out2 */ + int iMoved; + int iDb; + + sqlite3VdbeIncrWriteCounter(p, 0); + assert( p->readOnly==0 ); + assert( pOp->p1>1 ); + pOut = out2Prerelease(p, pOp); + pOut->flags = MEM_Null; + if( db->nVdbeRead > db->nVDestroy+1 ){ + rc = SQLITE_LOCKED; + p->errorAction = OE_Abort; + goto abort_due_to_error; + }else{ + iDb = pOp->p3; + assert( DbMaskTest(p->btreeMask, iDb) ); + iMoved = 0; /* Not needed. Only to silence a warning. */ + rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved); + pOut->flags = MEM_Int; + pOut->u.i = iMoved; + if( rc ) goto abort_due_to_error; +#ifndef SQLITE_OMIT_AUTOVACUUM + if( iMoved!=0 ){ + sqlite3RootPageMoved(db, iDb, iMoved, pOp->p1); + /* All OP_Destroy operations occur on the same btree */ + assert( resetSchemaOnFault==0 || resetSchemaOnFault==iDb+1 ); + resetSchemaOnFault = iDb+1; + } +#endif + } + break; +} + +/* Opcode: Clear P1 P2 P3 +** +** Delete all contents of the database table or index whose root page +** in the database file is given by P1. But, unlike Destroy, do not +** remove the table or index from the database file. +** +** The table being clear is in the main database file if P2==0. If +** P2==1 then the table to be clear is in the auxiliary database file +** that is used to store tables create using CREATE TEMPORARY TABLE. +** +** If the P3 value is non-zero, then the row change count is incremented +** by the number of rows in the table being cleared. If P3 is greater +** than zero, then the value stored in register P3 is also incremented +** by the number of rows in the table being cleared. +** +** See also: Destroy +*/ +case OP_Clear: { + i64 nChange; + + sqlite3VdbeIncrWriteCounter(p, 0); + nChange = 0; + assert( p->readOnly==0 ); + assert( DbMaskTest(p->btreeMask, pOp->p2) ); + rc = sqlite3BtreeClearTable(db->aDb[pOp->p2].pBt, (u32)pOp->p1, &nChange); + if( pOp->p3 ){ + p->nChange += nChange; + if( pOp->p3>0 ){ + assert( memIsValid(&aMem[pOp->p3]) ); + memAboutToChange(p, &aMem[pOp->p3]); + aMem[pOp->p3].u.i += nChange; + } + } + if( rc ) goto abort_due_to_error; + break; +} + +/* Opcode: ResetSorter P1 * * * * +** +** Delete all contents from the ephemeral table or sorter +** that is open on cursor P1. +** +** This opcode only works for cursors used for sorting and +** opened with OP_OpenEphemeral or OP_SorterOpen. +*/ +case OP_ResetSorter: { + VdbeCursor *pC; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + if( isSorter(pC) ){ + sqlite3VdbeSorterReset(db, pC->uc.pSorter); + }else{ + assert( pC->eCurType==CURTYPE_BTREE ); + assert( pC->isEphemeral ); + rc = sqlite3BtreeClearTableOfCursor(pC->uc.pCursor); + if( rc ) goto abort_due_to_error; + } + break; +} + +/* Opcode: CreateBtree P1 P2 P3 * * +** Synopsis: r[P2]=root iDb=P1 flags=P3 +** +** Allocate a new b-tree in the main database file if P1==0 or in the +** TEMP database file if P1==1 or in an attached database if +** P1>1. The P3 argument must be 1 (BTREE_INTKEY) for a rowid table +** it must be 2 (BTREE_BLOBKEY) for an index or WITHOUT ROWID table. +** The root page number of the new b-tree is stored in register P2. +*/ +case OP_CreateBtree: { /* out2 */ + Pgno pgno; + Db *pDb; + + sqlite3VdbeIncrWriteCounter(p, 0); + pOut = out2Prerelease(p, pOp); + pgno = 0; + assert( pOp->p3==BTREE_INTKEY || pOp->p3==BTREE_BLOBKEY ); + assert( pOp->p1>=0 && pOp->p1nDb ); + assert( DbMaskTest(p->btreeMask, pOp->p1) ); + assert( p->readOnly==0 ); + pDb = &db->aDb[pOp->p1]; + assert( pDb->pBt!=0 ); + rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, pOp->p3); + if( rc ) goto abort_due_to_error; + pOut->u.i = pgno; + break; +} + +/* Opcode: SqlExec * * * P4 * +** +** Run the SQL statement or statements specified in the P4 string. +*/ +case OP_SqlExec: { + sqlite3VdbeIncrWriteCounter(p, 0); + db->nSqlExec++; + rc = sqlite3_exec(db, pOp->p4.z, 0, 0, 0); + db->nSqlExec--; + if( rc ) goto abort_due_to_error; + break; +} + +/* Opcode: ParseSchema P1 * * P4 * +** +** Read and parse all entries from the schema table of database P1 +** that match the WHERE clause P4. If P4 is a NULL pointer, then the +** entire schema for P1 is reparsed. +** +** This opcode invokes the parser to create a new virtual machine, +** then runs the new virtual machine. It is thus a re-entrant opcode. +*/ +case OP_ParseSchema: { + int iDb; + const char *zSchema; + char *zSql; + InitData initData; + + /* Any prepared statement that invokes this opcode will hold mutexes + ** on every btree. This is a prerequisite for invoking + ** sqlite3InitCallback(). + */ +#ifdef SQLITE_DEBUG + for(iDb=0; iDbnDb; iDb++){ + assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) ); + } +#endif + + iDb = pOp->p1; + assert( iDb>=0 && iDbnDb ); + assert( DbHasProperty(db, iDb, DB_SchemaLoaded) + || db->mallocFailed + || (CORRUPT_DB && (db->flags & SQLITE_NoSchemaError)!=0) ); + +#ifndef SQLITE_OMIT_ALTERTABLE + if( pOp->p4.z==0 ){ + sqlite3SchemaClear(db->aDb[iDb].pSchema); + db->mDbFlags &= ~DBFLAG_SchemaKnownOk; + rc = sqlite3InitOne(db, iDb, &p->zErrMsg, pOp->p5); + db->mDbFlags |= DBFLAG_SchemaChange; + p->expired = 0; + }else +#endif + { + zSchema = LEGACY_SCHEMA_TABLE; + initData.db = db; + initData.iDb = iDb; + initData.pzErrMsg = &p->zErrMsg; + initData.mInitFlags = 0; + initData.mxPage = sqlite3BtreeLastPage(db->aDb[iDb].pBt); + zSql = sqlite3MPrintf(db, + "SELECT*FROM\"%w\".%s WHERE %s ORDER BY rowid", + db->aDb[iDb].zDbSName, zSchema, pOp->p4.z); + if( zSql==0 ){ + rc = SQLITE_NOMEM_BKPT; + }else{ + assert( db->init.busy==0 ); + db->init.busy = 1; + initData.rc = SQLITE_OK; + initData.nInitRow = 0; + assert( !db->mallocFailed ); + rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0); + if( rc==SQLITE_OK ) rc = initData.rc; + if( rc==SQLITE_OK && initData.nInitRow==0 ){ + /* The OP_ParseSchema opcode with a non-NULL P4 argument should parse + ** at least one SQL statement. Any less than that indicates that + ** the sqlite_schema table is corrupt. */ + rc = SQLITE_CORRUPT_BKPT; + } + sqlite3DbFreeNN(db, zSql); + db->init.busy = 0; + } + } + if( rc ){ + sqlite3ResetAllSchemasOfConnection(db); + if( rc==SQLITE_NOMEM ){ + goto no_mem; + } + goto abort_due_to_error; + } + break; +} + +#if !defined(SQLITE_OMIT_ANALYZE) +/* Opcode: LoadAnalysis P1 * * * * +** +** Read the sqlite_stat1 table for database P1 and load the content +** of that table into the internal index hash table. This will cause +** the analysis to be used when preparing all subsequent queries. +*/ +case OP_LoadAnalysis: { + assert( pOp->p1>=0 && pOp->p1nDb ); + rc = sqlite3AnalysisLoad(db, pOp->p1); + if( rc ) goto abort_due_to_error; + break; +} +#endif /* !defined(SQLITE_OMIT_ANALYZE) */ + +/* Opcode: DropTable P1 * * P4 * +** +** Remove the internal (in-memory) data structures that describe +** the table named P4 in database P1. This is called after a table +** is dropped from disk (using the Destroy opcode) in order to keep +** the internal representation of the +** schema consistent with what is on disk. +*/ +case OP_DropTable: { + sqlite3VdbeIncrWriteCounter(p, 0); + sqlite3UnlinkAndDeleteTable(db, pOp->p1, pOp->p4.z); + break; +} + +/* Opcode: DropIndex P1 * * P4 * +** +** Remove the internal (in-memory) data structures that describe +** the index named P4 in database P1. This is called after an index +** is dropped from disk (using the Destroy opcode) +** in order to keep the internal representation of the +** schema consistent with what is on disk. +*/ +case OP_DropIndex: { + sqlite3VdbeIncrWriteCounter(p, 0); + sqlite3UnlinkAndDeleteIndex(db, pOp->p1, pOp->p4.z); + break; +} + +/* Opcode: DropTrigger P1 * * P4 * +** +** Remove the internal (in-memory) data structures that describe +** the trigger named P4 in database P1. This is called after a trigger +** is dropped from disk (using the Destroy opcode) in order to keep +** the internal representation of the +** schema consistent with what is on disk. +*/ +case OP_DropTrigger: { + sqlite3VdbeIncrWriteCounter(p, 0); + sqlite3UnlinkAndDeleteTrigger(db, pOp->p1, pOp->p4.z); + break; +} + + +#ifndef SQLITE_OMIT_INTEGRITY_CHECK +/* Opcode: IntegrityCk P1 P2 P3 P4 P5 +** +** Do an analysis of the currently open database. Store in +** register P1 the text of an error message describing any problems. +** If no problems are found, store a NULL in register P1. +** +** The register P3 contains one less than the maximum number of allowed errors. +** At most reg(P3) errors will be reported. +** In other words, the analysis stops as soon as reg(P1) errors are +** seen. Reg(P1) is updated with the number of errors remaining. +** +** The root page numbers of all tables in the database are integers +** stored in P4_INTARRAY argument. +** +** If P5 is not zero, the check is done on the auxiliary database +** file, not the main database file. +** +** This opcode is used to implement the integrity_check pragma. +*/ +case OP_IntegrityCk: { + int nRoot; /* Number of tables to check. (Number of root pages.) */ + Pgno *aRoot; /* Array of rootpage numbers for tables to be checked */ + int nErr; /* Number of errors reported */ + char *z; /* Text of the error report */ + Mem *pnErr; /* Register keeping track of errors remaining */ + + assert( p->bIsReader ); + nRoot = pOp->p2; + aRoot = pOp->p4.ai; + assert( nRoot>0 ); + assert( aRoot[0]==(Pgno)nRoot ); + assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) ); + pnErr = &aMem[pOp->p3]; + assert( (pnErr->flags & MEM_Int)!=0 ); + assert( (pnErr->flags & (MEM_Str|MEM_Blob))==0 ); + pIn1 = &aMem[pOp->p1]; + assert( pOp->p5nDb ); + assert( DbMaskTest(p->btreeMask, pOp->p5) ); + rc = sqlite3BtreeIntegrityCheck(db, db->aDb[pOp->p5].pBt, &aRoot[1], nRoot, + (int)pnErr->u.i+1, &nErr, &z); + sqlite3VdbeMemSetNull(pIn1); + if( nErr==0 ){ + assert( z==0 ); + }else if( rc ){ + sqlite3_free(z); + goto abort_due_to_error; + }else{ + pnErr->u.i -= nErr-1; + sqlite3VdbeMemSetStr(pIn1, z, -1, SQLITE_UTF8, sqlite3_free); + } + UPDATE_MAX_BLOBSIZE(pIn1); + sqlite3VdbeChangeEncoding(pIn1, encoding); + goto check_for_interrupt; +} +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +/* Opcode: RowSetAdd P1 P2 * * * +** Synopsis: rowset(P1)=r[P2] +** +** Insert the integer value held by register P2 into a RowSet object +** held in register P1. +** +** An assertion fails if P2 is not an integer. +*/ +case OP_RowSetAdd: { /* in1, in2 */ + pIn1 = &aMem[pOp->p1]; + pIn2 = &aMem[pOp->p2]; + assert( (pIn2->flags & MEM_Int)!=0 ); + if( (pIn1->flags & MEM_Blob)==0 ){ + if( sqlite3VdbeMemSetRowSet(pIn1) ) goto no_mem; + } + assert( sqlite3VdbeMemIsRowSet(pIn1) ); + sqlite3RowSetInsert((RowSet*)pIn1->z, pIn2->u.i); + break; +} + +/* Opcode: RowSetRead P1 P2 P3 * * +** Synopsis: r[P3]=rowset(P1) +** +** Extract the smallest value from the RowSet object in P1 +** and put that value into register P3. +** Or, if RowSet object P1 is initially empty, leave P3 +** unchanged and jump to instruction P2. +*/ +case OP_RowSetRead: { /* jump, in1, out3 */ + i64 val; + + pIn1 = &aMem[pOp->p1]; + assert( (pIn1->flags & MEM_Blob)==0 || sqlite3VdbeMemIsRowSet(pIn1) ); + if( (pIn1->flags & MEM_Blob)==0 + || sqlite3RowSetNext((RowSet*)pIn1->z, &val)==0 + ){ + /* The boolean index is empty */ + sqlite3VdbeMemSetNull(pIn1); + VdbeBranchTaken(1,2); + goto jump_to_p2_and_check_for_interrupt; + }else{ + /* A value was pulled from the index */ + VdbeBranchTaken(0,2); + sqlite3VdbeMemSetInt64(&aMem[pOp->p3], val); + } + goto check_for_interrupt; +} + +/* Opcode: RowSetTest P1 P2 P3 P4 +** Synopsis: if r[P3] in rowset(P1) goto P2 +** +** Register P3 is assumed to hold a 64-bit integer value. If register P1 +** contains a RowSet object and that RowSet object contains +** the value held in P3, jump to register P2. Otherwise, insert the +** integer in P3 into the RowSet and continue on to the +** next opcode. +** +** The RowSet object is optimized for the case where sets of integers +** are inserted in distinct phases, which each set contains no duplicates. +** Each set is identified by a unique P4 value. The first set +** must have P4==0, the final set must have P4==-1, and for all other sets +** must have P4>0. +** +** This allows optimizations: (a) when P4==0 there is no need to test +** the RowSet object for P3, as it is guaranteed not to contain it, +** (b) when P4==-1 there is no need to insert the value, as it will +** never be tested for, and (c) when a value that is part of set X is +** inserted, there is no need to search to see if the same value was +** previously inserted as part of set X (only if it was previously +** inserted as part of some other set). +*/ +case OP_RowSetTest: { /* jump, in1, in3 */ + int iSet; + int exists; + + pIn1 = &aMem[pOp->p1]; + pIn3 = &aMem[pOp->p3]; + iSet = pOp->p4.i; + assert( pIn3->flags&MEM_Int ); + + /* If there is anything other than a rowset object in memory cell P1, + ** delete it now and initialize P1 with an empty rowset + */ + if( (pIn1->flags & MEM_Blob)==0 ){ + if( sqlite3VdbeMemSetRowSet(pIn1) ) goto no_mem; + } + assert( sqlite3VdbeMemIsRowSet(pIn1) ); + assert( pOp->p4type==P4_INT32 ); + assert( iSet==-1 || iSet>=0 ); + if( iSet ){ + exists = sqlite3RowSetTest((RowSet*)pIn1->z, iSet, pIn3->u.i); + VdbeBranchTaken(exists!=0,2); + if( exists ) goto jump_to_p2; + } + if( iSet>=0 ){ + sqlite3RowSetInsert((RowSet*)pIn1->z, pIn3->u.i); + } + break; +} + + +#ifndef SQLITE_OMIT_TRIGGER + +/* Opcode: Program P1 P2 P3 P4 P5 +** +** Execute the trigger program passed as P4 (type P4_SUBPROGRAM). +** +** P1 contains the address of the memory cell that contains the first memory +** cell in an array of values used as arguments to the sub-program. P2 +** contains the address to jump to if the sub-program throws an IGNORE +** exception using the RAISE() function. Register P3 contains the address +** of a memory cell in this (the parent) VM that is used to allocate the +** memory required by the sub-vdbe at runtime. +** +** P4 is a pointer to the VM containing the trigger program. +** +** If P5 is non-zero, then recursive program invocation is enabled. +*/ +case OP_Program: { /* jump */ + int nMem; /* Number of memory registers for sub-program */ + int nByte; /* Bytes of runtime space required for sub-program */ + Mem *pRt; /* Register to allocate runtime space */ + Mem *pMem; /* Used to iterate through memory cells */ + Mem *pEnd; /* Last memory cell in new array */ + VdbeFrame *pFrame; /* New vdbe frame to execute in */ + SubProgram *pProgram; /* Sub-program to execute */ + void *t; /* Token identifying trigger */ + + pProgram = pOp->p4.pProgram; + pRt = &aMem[pOp->p3]; + assert( pProgram->nOp>0 ); + + /* If the p5 flag is clear, then recursive invocation of triggers is + ** disabled for backwards compatibility (p5 is set if this sub-program + ** is really a trigger, not a foreign key action, and the flag set + ** and cleared by the "PRAGMA recursive_triggers" command is clear). + ** + ** It is recursive invocation of triggers, at the SQL level, that is + ** disabled. In some cases a single trigger may generate more than one + ** SubProgram (if the trigger may be executed with more than one different + ** ON CONFLICT algorithm). SubProgram structures associated with a + ** single trigger all have the same value for the SubProgram.token + ** variable. */ + if( pOp->p5 ){ + t = pProgram->token; + for(pFrame=p->pFrame; pFrame && pFrame->token!=t; pFrame=pFrame->pParent); + if( pFrame ) break; + } + + if( p->nFrame>=db->aLimit[SQLITE_LIMIT_TRIGGER_DEPTH] ){ + rc = SQLITE_ERROR; + sqlite3VdbeError(p, "too many levels of trigger recursion"); + goto abort_due_to_error; + } + + /* Register pRt is used to store the memory required to save the state + ** of the current program, and the memory required at runtime to execute + ** the trigger program. If this trigger has been fired before, then pRt + ** is already allocated. Otherwise, it must be initialized. */ + if( (pRt->flags&MEM_Blob)==0 ){ + /* SubProgram.nMem is set to the number of memory cells used by the + ** program stored in SubProgram.aOp. As well as these, one memory + ** cell is required for each cursor used by the program. Set local + ** variable nMem (and later, VdbeFrame.nChildMem) to this value. + */ + nMem = pProgram->nMem + pProgram->nCsr; + assert( nMem>0 ); + if( pProgram->nCsr==0 ) nMem++; + nByte = ROUND8(sizeof(VdbeFrame)) + + nMem * sizeof(Mem) + + pProgram->nCsr * sizeof(VdbeCursor*) + + (pProgram->nOp + 7)/8; + pFrame = sqlite3DbMallocZero(db, nByte); + if( !pFrame ){ + goto no_mem; + } + sqlite3VdbeMemRelease(pRt); + pRt->flags = MEM_Blob|MEM_Dyn; + pRt->z = (char*)pFrame; + pRt->n = nByte; + pRt->xDel = sqlite3VdbeFrameMemDel; + + pFrame->v = p; + pFrame->nChildMem = nMem; + pFrame->nChildCsr = pProgram->nCsr; + pFrame->pc = (int)(pOp - aOp); + pFrame->aMem = p->aMem; + pFrame->nMem = p->nMem; + pFrame->apCsr = p->apCsr; + pFrame->nCursor = p->nCursor; + pFrame->aOp = p->aOp; + pFrame->nOp = p->nOp; + pFrame->token = pProgram->token; +#ifdef SQLITE_DEBUG + pFrame->iFrameMagic = SQLITE_FRAME_MAGIC; +#endif + + pEnd = &VdbeFrameMem(pFrame)[pFrame->nChildMem]; + for(pMem=VdbeFrameMem(pFrame); pMem!=pEnd; pMem++){ + pMem->flags = MEM_Undefined; + pMem->db = db; + } + }else{ + pFrame = (VdbeFrame*)pRt->z; + assert( pRt->xDel==sqlite3VdbeFrameMemDel ); + assert( pProgram->nMem+pProgram->nCsr==pFrame->nChildMem + || (pProgram->nCsr==0 && pProgram->nMem+1==pFrame->nChildMem) ); + assert( pProgram->nCsr==pFrame->nChildCsr ); + assert( (int)(pOp - aOp)==pFrame->pc ); + } + + p->nFrame++; + pFrame->pParent = p->pFrame; + pFrame->lastRowid = db->lastRowid; + pFrame->nChange = p->nChange; + pFrame->nDbChange = p->db->nChange; + assert( pFrame->pAuxData==0 ); + pFrame->pAuxData = p->pAuxData; + p->pAuxData = 0; + p->nChange = 0; + p->pFrame = pFrame; + p->aMem = aMem = VdbeFrameMem(pFrame); + p->nMem = pFrame->nChildMem; + p->nCursor = (u16)pFrame->nChildCsr; + p->apCsr = (VdbeCursor **)&aMem[p->nMem]; + pFrame->aOnce = (u8*)&p->apCsr[pProgram->nCsr]; + memset(pFrame->aOnce, 0, (pProgram->nOp + 7)/8); + p->aOp = aOp = pProgram->aOp; + p->nOp = pProgram->nOp; +#ifdef SQLITE_DEBUG + /* Verify that second and subsequent executions of the same trigger do not + ** try to reuse register values from the first use. */ + { + int i; + for(i=0; inMem; i++){ + aMem[i].pScopyFrom = 0; /* Prevent false-positive AboutToChange() errs */ + MemSetTypeFlag(&aMem[i], MEM_Undefined); /* Fault if this reg is reused */ + } + } +#endif + pOp = &aOp[-1]; + goto check_for_interrupt; +} + +/* Opcode: Param P1 P2 * * * +** +** This opcode is only ever present in sub-programs called via the +** OP_Program instruction. Copy a value currently stored in a memory +** cell of the calling (parent) frame to cell P2 in the current frames +** address space. This is used by trigger programs to access the new.* +** and old.* values. +** +** The address of the cell in the parent frame is determined by adding +** the value of the P1 argument to the value of the P1 argument to the +** calling OP_Program instruction. +*/ +case OP_Param: { /* out2 */ + VdbeFrame *pFrame; + Mem *pIn; + pOut = out2Prerelease(p, pOp); + pFrame = p->pFrame; + pIn = &pFrame->aMem[pOp->p1 + pFrame->aOp[pFrame->pc].p1]; + sqlite3VdbeMemShallowCopy(pOut, pIn, MEM_Ephem); + break; +} + +#endif /* #ifndef SQLITE_OMIT_TRIGGER */ + +#ifndef SQLITE_OMIT_FOREIGN_KEY +/* Opcode: FkCounter P1 P2 * * * +** Synopsis: fkctr[P1]+=P2 +** +** Increment a "constraint counter" by P2 (P2 may be negative or positive). +** If P1 is non-zero, the database constraint counter is incremented +** (deferred foreign key constraints). Otherwise, if P1 is zero, the +** statement counter is incremented (immediate foreign key constraints). +*/ +case OP_FkCounter: { + if( db->flags & SQLITE_DeferFKs ){ + db->nDeferredImmCons += pOp->p2; + }else if( pOp->p1 ){ + db->nDeferredCons += pOp->p2; + }else{ + p->nFkConstraint += pOp->p2; + } + break; +} + +/* Opcode: FkIfZero P1 P2 * * * +** Synopsis: if fkctr[P1]==0 goto P2 +** +** This opcode tests if a foreign key constraint-counter is currently zero. +** If so, jump to instruction P2. Otherwise, fall through to the next +** instruction. +** +** If P1 is non-zero, then the jump is taken if the database constraint-counter +** is zero (the one that counts deferred constraint violations). If P1 is +** zero, the jump is taken if the statement constraint-counter is zero +** (immediate foreign key constraint violations). +*/ +case OP_FkIfZero: { /* jump */ + if( pOp->p1 ){ + VdbeBranchTaken(db->nDeferredCons==0 && db->nDeferredImmCons==0, 2); + if( db->nDeferredCons==0 && db->nDeferredImmCons==0 ) goto jump_to_p2; + }else{ + VdbeBranchTaken(p->nFkConstraint==0 && db->nDeferredImmCons==0, 2); + if( p->nFkConstraint==0 && db->nDeferredImmCons==0 ) goto jump_to_p2; + } + break; +} +#endif /* #ifndef SQLITE_OMIT_FOREIGN_KEY */ + +#ifndef SQLITE_OMIT_AUTOINCREMENT +/* Opcode: MemMax P1 P2 * * * +** Synopsis: r[P1]=max(r[P1],r[P2]) +** +** P1 is a register in the root frame of this VM (the root frame is +** different from the current frame if this instruction is being executed +** within a sub-program). Set the value of register P1 to the maximum of +** its current value and the value in register P2. +** +** This instruction throws an error if the memory cell is not initially +** an integer. +*/ +case OP_MemMax: { /* in2 */ + VdbeFrame *pFrame; + if( p->pFrame ){ + for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent); + pIn1 = &pFrame->aMem[pOp->p1]; + }else{ + pIn1 = &aMem[pOp->p1]; + } + assert( memIsValid(pIn1) ); + sqlite3VdbeMemIntegerify(pIn1); + pIn2 = &aMem[pOp->p2]; + sqlite3VdbeMemIntegerify(pIn2); + if( pIn1->u.iu.i){ + pIn1->u.i = pIn2->u.i; + } + break; +} +#endif /* SQLITE_OMIT_AUTOINCREMENT */ + +/* Opcode: IfPos P1 P2 P3 * * +** Synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 +** +** Register P1 must contain an integer. +** If the value of register P1 is 1 or greater, subtract P3 from the +** value in P1 and jump to P2. +** +** If the initial value of register P1 is less than 1, then the +** value is unchanged and control passes through to the next instruction. +*/ +case OP_IfPos: { /* jump, in1 */ + pIn1 = &aMem[pOp->p1]; + assert( pIn1->flags&MEM_Int ); + VdbeBranchTaken( pIn1->u.i>0, 2); + if( pIn1->u.i>0 ){ + pIn1->u.i -= pOp->p3; + goto jump_to_p2; + } + break; +} + +/* Opcode: OffsetLimit P1 P2 P3 * * +** Synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1) +** +** This opcode performs a commonly used computation associated with +** LIMIT and OFFSET processing. r[P1] holds the limit counter. r[P3] +** holds the offset counter. The opcode computes the combined value +** of the LIMIT and OFFSET and stores that value in r[P2]. The r[P2] +** value computed is the total number of rows that will need to be +** visited in order to complete the query. +** +** If r[P3] is zero or negative, that means there is no OFFSET +** and r[P2] is set to be the value of the LIMIT, r[P1]. +** +** if r[P1] is zero or negative, that means there is no LIMIT +** and r[P2] is set to -1. +** +** Otherwise, r[P2] is set to the sum of r[P1] and r[P3]. +*/ +case OP_OffsetLimit: { /* in1, out2, in3 */ + i64 x; + pIn1 = &aMem[pOp->p1]; + pIn3 = &aMem[pOp->p3]; + pOut = out2Prerelease(p, pOp); + assert( pIn1->flags & MEM_Int ); + assert( pIn3->flags & MEM_Int ); + x = pIn1->u.i; + if( x<=0 || sqlite3AddInt64(&x, pIn3->u.i>0?pIn3->u.i:0) ){ + /* If the LIMIT is less than or equal to zero, loop forever. This + ** is documented. But also, if the LIMIT+OFFSET exceeds 2^63 then + ** also loop forever. This is undocumented. In fact, one could argue + ** that the loop should terminate. But assuming 1 billion iterations + ** per second (far exceeding the capabilities of any current hardware) + ** it would take nearly 300 years to actually reach the limit. So + ** looping forever is a reasonable approximation. */ + pOut->u.i = -1; + }else{ + pOut->u.i = x; + } + break; +} + +/* Opcode: IfNotZero P1 P2 * * * +** Synopsis: if r[P1]!=0 then r[P1]--, goto P2 +** +** Register P1 must contain an integer. If the content of register P1 is +** initially greater than zero, then decrement the value in register P1. +** If it is non-zero (negative or positive) and then also jump to P2. +** If register P1 is initially zero, leave it unchanged and fall through. +*/ +case OP_IfNotZero: { /* jump, in1 */ + pIn1 = &aMem[pOp->p1]; + assert( pIn1->flags&MEM_Int ); + VdbeBranchTaken(pIn1->u.i<0, 2); + if( pIn1->u.i ){ + if( pIn1->u.i>0 ) pIn1->u.i--; + goto jump_to_p2; + } + break; +} + +/* Opcode: DecrJumpZero P1 P2 * * * +** Synopsis: if (--r[P1])==0 goto P2 +** +** Register P1 must hold an integer. Decrement the value in P1 +** and jump to P2 if the new value is exactly zero. +*/ +case OP_DecrJumpZero: { /* jump, in1 */ + pIn1 = &aMem[pOp->p1]; + assert( pIn1->flags&MEM_Int ); + if( pIn1->u.i>SMALLEST_INT64 ) pIn1->u.i--; + VdbeBranchTaken(pIn1->u.i==0, 2); + if( pIn1->u.i==0 ) goto jump_to_p2; + break; +} + + +/* Opcode: AggStep * P2 P3 P4 P5 +** Synopsis: accum=r[P3] step(r[P2@P5]) +** +** Execute the xStep function for an aggregate. +** The function has P5 arguments. P4 is a pointer to the +** FuncDef structure that specifies the function. Register P3 is the +** accumulator. +** +** The P5 arguments are taken from register P2 and its +** successors. +*/ +/* Opcode: AggInverse * P2 P3 P4 P5 +** Synopsis: accum=r[P3] inverse(r[P2@P5]) +** +** Execute the xInverse function for an aggregate. +** The function has P5 arguments. P4 is a pointer to the +** FuncDef structure that specifies the function. Register P3 is the +** accumulator. +** +** The P5 arguments are taken from register P2 and its +** successors. +*/ +/* Opcode: AggStep1 P1 P2 P3 P4 P5 +** Synopsis: accum=r[P3] step(r[P2@P5]) +** +** Execute the xStep (if P1==0) or xInverse (if P1!=0) function for an +** aggregate. The function has P5 arguments. P4 is a pointer to the +** FuncDef structure that specifies the function. Register P3 is the +** accumulator. +** +** The P5 arguments are taken from register P2 and its +** successors. +** +** This opcode is initially coded as OP_AggStep0. On first evaluation, +** the FuncDef stored in P4 is converted into an sqlite3_context and +** the opcode is changed. In this way, the initialization of the +** sqlite3_context only happens once, instead of on each call to the +** step function. +*/ +case OP_AggInverse: +case OP_AggStep: { + int n; + sqlite3_context *pCtx; + + assert( pOp->p4type==P4_FUNCDEF ); + n = pOp->p5; + assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) ); + assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem+1 - p->nCursor)+1) ); + assert( pOp->p3p2 || pOp->p3>=pOp->p2+n ); + pCtx = sqlite3DbMallocRawNN(db, n*sizeof(sqlite3_value*) + + (sizeof(pCtx[0]) + sizeof(Mem) - sizeof(sqlite3_value*))); + if( pCtx==0 ) goto no_mem; + pCtx->pMem = 0; + pCtx->pOut = (Mem*)&(pCtx->argv[n]); + sqlite3VdbeMemInit(pCtx->pOut, db, MEM_Null); + pCtx->pFunc = pOp->p4.pFunc; + pCtx->iOp = (int)(pOp - aOp); + pCtx->pVdbe = p; + pCtx->skipFlag = 0; + pCtx->isError = 0; + pCtx->enc = encoding; + pCtx->argc = n; + pOp->p4type = P4_FUNCCTX; + pOp->p4.pCtx = pCtx; + + /* OP_AggInverse must have P1==1 and OP_AggStep must have P1==0 */ + assert( pOp->p1==(pOp->opcode==OP_AggInverse) ); + + pOp->opcode = OP_AggStep1; + /* Fall through into OP_AggStep */ + /* no break */ deliberate_fall_through +} +case OP_AggStep1: { + int i; + sqlite3_context *pCtx; + Mem *pMem; + + assert( pOp->p4type==P4_FUNCCTX ); + pCtx = pOp->p4.pCtx; + pMem = &aMem[pOp->p3]; + +#ifdef SQLITE_DEBUG + if( pOp->p1 ){ + /* This is an OP_AggInverse call. Verify that xStep has always + ** been called at least once prior to any xInverse call. */ + assert( pMem->uTemp==0x1122e0e3 ); + }else{ + /* This is an OP_AggStep call. Mark it as such. */ + pMem->uTemp = 0x1122e0e3; + } +#endif + + /* If this function is inside of a trigger, the register array in aMem[] + ** might change from one evaluation to the next. The next block of code + ** checks to see if the register array has changed, and if so it + ** reinitializes the relavant parts of the sqlite3_context object */ + if( pCtx->pMem != pMem ){ + pCtx->pMem = pMem; + for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i]; + } + +#ifdef SQLITE_DEBUG + for(i=0; iargc; i++){ + assert( memIsValid(pCtx->argv[i]) ); + REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]); + } +#endif + + pMem->n++; + assert( pCtx->pOut->flags==MEM_Null ); + assert( pCtx->isError==0 ); + assert( pCtx->skipFlag==0 ); +#ifndef SQLITE_OMIT_WINDOWFUNC + if( pOp->p1 ){ + (pCtx->pFunc->xInverse)(pCtx,pCtx->argc,pCtx->argv); + }else +#endif + (pCtx->pFunc->xSFunc)(pCtx,pCtx->argc,pCtx->argv); /* IMP: R-24505-23230 */ + + if( pCtx->isError ){ + if( pCtx->isError>0 ){ + sqlite3VdbeError(p, "%s", sqlite3_value_text(pCtx->pOut)); + rc = pCtx->isError; + } + if( pCtx->skipFlag ){ + assert( pOp[-1].opcode==OP_CollSeq ); + i = pOp[-1].p1; + if( i ) sqlite3VdbeMemSetInt64(&aMem[i], 1); + pCtx->skipFlag = 0; + } + sqlite3VdbeMemRelease(pCtx->pOut); + pCtx->pOut->flags = MEM_Null; + pCtx->isError = 0; + if( rc ) goto abort_due_to_error; + } + assert( pCtx->pOut->flags==MEM_Null ); + assert( pCtx->skipFlag==0 ); + break; +} + +/* Opcode: AggFinal P1 P2 * P4 * +** Synopsis: accum=r[P1] N=P2 +** +** P1 is the memory location that is the accumulator for an aggregate +** or window function. Execute the finalizer function +** for an aggregate and store the result in P1. +** +** P2 is the number of arguments that the step function takes and +** P4 is a pointer to the FuncDef for this function. The P2 +** argument is not used by this opcode. It is only there to disambiguate +** functions that can take varying numbers of arguments. The +** P4 argument is only needed for the case where +** the step function was not previously called. +*/ +/* Opcode: AggValue * P2 P3 P4 * +** Synopsis: r[P3]=value N=P2 +** +** Invoke the xValue() function and store the result in register P3. +** +** P2 is the number of arguments that the step function takes and +** P4 is a pointer to the FuncDef for this function. The P2 +** argument is not used by this opcode. It is only there to disambiguate +** functions that can take varying numbers of arguments. The +** P4 argument is only needed for the case where +** the step function was not previously called. +*/ +case OP_AggValue: +case OP_AggFinal: { + Mem *pMem; + assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) ); + assert( pOp->p3==0 || pOp->opcode==OP_AggValue ); + pMem = &aMem[pOp->p1]; + assert( (pMem->flags & ~(MEM_Null|MEM_Agg))==0 ); +#ifndef SQLITE_OMIT_WINDOWFUNC + if( pOp->p3 ){ + memAboutToChange(p, &aMem[pOp->p3]); + rc = sqlite3VdbeMemAggValue(pMem, &aMem[pOp->p3], pOp->p4.pFunc); + pMem = &aMem[pOp->p3]; + }else +#endif + { + rc = sqlite3VdbeMemFinalize(pMem, pOp->p4.pFunc); + } + + if( rc ){ + sqlite3VdbeError(p, "%s", sqlite3_value_text(pMem)); + goto abort_due_to_error; + } + sqlite3VdbeChangeEncoding(pMem, encoding); + UPDATE_MAX_BLOBSIZE(pMem); + REGISTER_TRACE((int)(pMem-aMem), pMem); + break; +} + +#ifndef SQLITE_OMIT_WAL +/* Opcode: Checkpoint P1 P2 P3 * * +** +** Checkpoint database P1. This is a no-op if P1 is not currently in +** WAL mode. Parameter P2 is one of SQLITE_CHECKPOINT_PASSIVE, FULL, +** RESTART, or TRUNCATE. Write 1 or 0 into mem[P3] if the checkpoint returns +** SQLITE_BUSY or not, respectively. Write the number of pages in the +** WAL after the checkpoint into mem[P3+1] and the number of pages +** in the WAL that have been checkpointed after the checkpoint +** completes into mem[P3+2]. However on an error, mem[P3+1] and +** mem[P3+2] are initialized to -1. +*/ +case OP_Checkpoint: { + int i; /* Loop counter */ + int aRes[3]; /* Results */ + Mem *pMem; /* Write results here */ + + assert( p->readOnly==0 ); + aRes[0] = 0; + aRes[1] = aRes[2] = -1; + assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE + || pOp->p2==SQLITE_CHECKPOINT_FULL + || pOp->p2==SQLITE_CHECKPOINT_RESTART + || pOp->p2==SQLITE_CHECKPOINT_TRUNCATE + ); + rc = sqlite3Checkpoint(db, pOp->p1, pOp->p2, &aRes[1], &aRes[2]); + if( rc ){ + if( rc!=SQLITE_BUSY ) goto abort_due_to_error; + rc = SQLITE_OK; + aRes[0] = 1; + } + for(i=0, pMem = &aMem[pOp->p3]; i<3; i++, pMem++){ + sqlite3VdbeMemSetInt64(pMem, (i64)aRes[i]); + } + break; +}; +#endif + +#ifndef SQLITE_OMIT_PRAGMA +/* Opcode: JournalMode P1 P2 P3 * * +** +** Change the journal mode of database P1 to P3. P3 must be one of the +** PAGER_JOURNALMODE_XXX values. If changing between the various rollback +** modes (delete, truncate, persist, off and memory), this is a simple +** operation. No IO is required. +** +** If changing into or out of WAL mode the procedure is more complicated. +** +** Write a string containing the final journal-mode to register P2. +*/ +case OP_JournalMode: { /* out2 */ + Btree *pBt; /* Btree to change journal mode of */ + Pager *pPager; /* Pager associated with pBt */ + int eNew; /* New journal mode */ + int eOld; /* The old journal mode */ +#ifndef SQLITE_OMIT_WAL + const char *zFilename; /* Name of database file for pPager */ +#endif + + pOut = out2Prerelease(p, pOp); + eNew = pOp->p3; + assert( eNew==PAGER_JOURNALMODE_DELETE + || eNew==PAGER_JOURNALMODE_TRUNCATE + || eNew==PAGER_JOURNALMODE_PERSIST + || eNew==PAGER_JOURNALMODE_OFF + || eNew==PAGER_JOURNALMODE_MEMORY + || eNew==PAGER_JOURNALMODE_WAL + || eNew==PAGER_JOURNALMODE_QUERY + ); + assert( pOp->p1>=0 && pOp->p1nDb ); + assert( p->readOnly==0 ); + + pBt = db->aDb[pOp->p1].pBt; + pPager = sqlite3BtreePager(pBt); + eOld = sqlite3PagerGetJournalMode(pPager); + if( eNew==PAGER_JOURNALMODE_QUERY ) eNew = eOld; + assert( sqlite3BtreeHoldsMutex(pBt) ); + if( !sqlite3PagerOkToChangeJournalMode(pPager) ) eNew = eOld; + +#ifndef SQLITE_OMIT_WAL + zFilename = sqlite3PagerFilename(pPager, 1); + + /* Do not allow a transition to journal_mode=WAL for a database + ** in temporary storage or if the VFS does not support shared memory + */ + if( eNew==PAGER_JOURNALMODE_WAL + && (sqlite3Strlen30(zFilename)==0 /* Temp file */ + || !sqlite3PagerWalSupported(pPager)) /* No shared-memory support */ + ){ + eNew = eOld; + } + + if( (eNew!=eOld) + && (eOld==PAGER_JOURNALMODE_WAL || eNew==PAGER_JOURNALMODE_WAL) + ){ + if( !db->autoCommit || db->nVdbeRead>1 ){ + rc = SQLITE_ERROR; + sqlite3VdbeError(p, + "cannot change %s wal mode from within a transaction", + (eNew==PAGER_JOURNALMODE_WAL ? "into" : "out of") + ); + goto abort_due_to_error; + }else{ + + if( eOld==PAGER_JOURNALMODE_WAL ){ + /* If leaving WAL mode, close the log file. If successful, the call + ** to PagerCloseWal() checkpoints and deletes the write-ahead-log + ** file. An EXCLUSIVE lock may still be held on the database file + ** after a successful return. + */ + rc = sqlite3PagerCloseWal(pPager, db); + if( rc==SQLITE_OK ){ + sqlite3PagerSetJournalMode(pPager, eNew); + } + }else if( eOld==PAGER_JOURNALMODE_MEMORY ){ + /* Cannot transition directly from MEMORY to WAL. Use mode OFF + ** as an intermediate */ + sqlite3PagerSetJournalMode(pPager, PAGER_JOURNALMODE_OFF); + } + + /* Open a transaction on the database file. Regardless of the journal + ** mode, this transaction always uses a rollback journal. + */ + assert( sqlite3BtreeTxnState(pBt)!=SQLITE_TXN_WRITE ); + if( rc==SQLITE_OK ){ + rc = sqlite3BtreeSetVersion(pBt, (eNew==PAGER_JOURNALMODE_WAL ? 2 : 1)); + } + } + } +#endif /* ifndef SQLITE_OMIT_WAL */ + + if( rc ) eNew = eOld; + eNew = sqlite3PagerSetJournalMode(pPager, eNew); + + pOut->flags = MEM_Str|MEM_Static|MEM_Term; + pOut->z = (char *)sqlite3JournalModename(eNew); + pOut->n = sqlite3Strlen30(pOut->z); + pOut->enc = SQLITE_UTF8; + sqlite3VdbeChangeEncoding(pOut, encoding); + if( rc ) goto abort_due_to_error; + break; +}; +#endif /* SQLITE_OMIT_PRAGMA */ + +#if !defined(SQLITE_OMIT_VACUUM) && !defined(SQLITE_OMIT_ATTACH) +/* Opcode: Vacuum P1 P2 * * * +** +** Vacuum the entire database P1. P1 is 0 for "main", and 2 or more +** for an attached database. The "temp" database may not be vacuumed. +** +** If P2 is not zero, then it is a register holding a string which is +** the file into which the result of vacuum should be written. When +** P2 is zero, the vacuum overwrites the original database. +*/ +case OP_Vacuum: { + assert( p->readOnly==0 ); + rc = sqlite3RunVacuum(&p->zErrMsg, db, pOp->p1, + pOp->p2 ? &aMem[pOp->p2] : 0); + if( rc ) goto abort_due_to_error; + break; +} +#endif + +#if !defined(SQLITE_OMIT_AUTOVACUUM) +/* Opcode: IncrVacuum P1 P2 * * * +** +** Perform a single step of the incremental vacuum procedure on +** the P1 database. If the vacuum has finished, jump to instruction +** P2. Otherwise, fall through to the next instruction. +*/ +case OP_IncrVacuum: { /* jump */ + Btree *pBt; + + assert( pOp->p1>=0 && pOp->p1nDb ); + assert( DbMaskTest(p->btreeMask, pOp->p1) ); + assert( p->readOnly==0 ); + pBt = db->aDb[pOp->p1].pBt; + rc = sqlite3BtreeIncrVacuum(pBt); + VdbeBranchTaken(rc==SQLITE_DONE,2); + if( rc ){ + if( rc!=SQLITE_DONE ) goto abort_due_to_error; + rc = SQLITE_OK; + goto jump_to_p2; + } + break; +} +#endif + +/* Opcode: Expire P1 P2 * * * +** +** Cause precompiled statements to expire. When an expired statement +** is executed using sqlite3_step() it will either automatically +** reprepare itself (if it was originally created using sqlite3_prepare_v2()) +** or it will fail with SQLITE_SCHEMA. +** +** If P1 is 0, then all SQL statements become expired. If P1 is non-zero, +** then only the currently executing statement is expired. +** +** If P2 is 0, then SQL statements are expired immediately. If P2 is 1, +** then running SQL statements are allowed to continue to run to completion. +** The P2==1 case occurs when a CREATE INDEX or similar schema change happens +** that might help the statement run faster but which does not affect the +** correctness of operation. +*/ +case OP_Expire: { + assert( pOp->p2==0 || pOp->p2==1 ); + if( !pOp->p1 ){ + sqlite3ExpirePreparedStatements(db, pOp->p2); + }else{ + p->expired = pOp->p2+1; + } + break; +} + +/* Opcode: CursorLock P1 * * * * +** +** Lock the btree to which cursor P1 is pointing so that the btree cannot be +** written by an other cursor. +*/ +case OP_CursorLock: { + VdbeCursor *pC; + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + sqlite3BtreeCursorPin(pC->uc.pCursor); + break; +} + +/* Opcode: CursorUnlock P1 * * * * +** +** Unlock the btree to which cursor P1 is pointing so that it can be +** written by other cursors. +*/ +case OP_CursorUnlock: { + VdbeCursor *pC; + assert( pOp->p1>=0 && pOp->p1nCursor ); + pC = p->apCsr[pOp->p1]; + assert( pC!=0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + sqlite3BtreeCursorUnpin(pC->uc.pCursor); + break; +} + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* Opcode: TableLock P1 P2 P3 P4 * +** Synopsis: iDb=P1 root=P2 write=P3 +** +** Obtain a lock on a particular table. This instruction is only used when +** the shared-cache feature is enabled. +** +** P1 is the index of the database in sqlite3.aDb[] of the database +** on which the lock is acquired. A readlock is obtained if P3==0 or +** a write lock if P3==1. +** +** P2 contains the root-page of the table to lock. +** +** P4 contains a pointer to the name of the table being locked. This is only +** used to generate an error message if the lock cannot be obtained. +*/ +case OP_TableLock: { + u8 isWriteLock = (u8)pOp->p3; + if( isWriteLock || 0==(db->flags&SQLITE_ReadUncommit) ){ + int p1 = pOp->p1; + assert( p1>=0 && p1nDb ); + assert( DbMaskTest(p->btreeMask, p1) ); + assert( isWriteLock==0 || isWriteLock==1 ); + rc = sqlite3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock); + if( rc ){ + if( (rc&0xFF)==SQLITE_LOCKED ){ + const char *z = pOp->p4.z; + sqlite3VdbeError(p, "database table is locked: %s", z); + } + goto abort_due_to_error; + } + } + break; +} +#endif /* SQLITE_OMIT_SHARED_CACHE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VBegin * * * P4 * +** +** P4 may be a pointer to an sqlite3_vtab structure. If so, call the +** xBegin method for that table. +** +** Also, whether or not P4 is set, check that this is not being called from +** within a callback to a virtual table xSync() method. If it is, the error +** code will be set to SQLITE_LOCKED. +*/ +case OP_VBegin: { + VTable *pVTab; + pVTab = pOp->p4.pVtab; + rc = sqlite3VtabBegin(db, pVTab); + if( pVTab ) sqlite3VtabImportErrmsg(p, pVTab->pVtab); + if( rc ) goto abort_due_to_error; + break; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VCreate P1 P2 * * * +** +** P2 is a register that holds the name of a virtual table in database +** P1. Call the xCreate method for that table. +*/ +case OP_VCreate: { + Mem sMem; /* For storing the record being decoded */ + const char *zTab; /* Name of the virtual table */ + + memset(&sMem, 0, sizeof(sMem)); + sMem.db = db; + /* Because P2 is always a static string, it is impossible for the + ** sqlite3VdbeMemCopy() to fail */ + assert( (aMem[pOp->p2].flags & MEM_Str)!=0 ); + assert( (aMem[pOp->p2].flags & MEM_Static)!=0 ); + rc = sqlite3VdbeMemCopy(&sMem, &aMem[pOp->p2]); + assert( rc==SQLITE_OK ); + zTab = (const char*)sqlite3_value_text(&sMem); + assert( zTab || db->mallocFailed ); + if( zTab ){ + rc = sqlite3VtabCallCreate(db, pOp->p1, zTab, &p->zErrMsg); + } + sqlite3VdbeMemRelease(&sMem); + if( rc ) goto abort_due_to_error; + break; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VDestroy P1 * * P4 * +** +** P4 is the name of a virtual table in database P1. Call the xDestroy method +** of that table. +*/ +case OP_VDestroy: { + db->nVDestroy++; + rc = sqlite3VtabCallDestroy(db, pOp->p1, pOp->p4.z); + db->nVDestroy--; + assert( p->errorAction==OE_Abort && p->usesStmtJournal ); + if( rc ) goto abort_due_to_error; + break; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VOpen P1 * * P4 * +** +** P4 is a pointer to a virtual table object, an sqlite3_vtab structure. +** P1 is a cursor number. This opcode opens a cursor to the virtual +** table and stores that cursor in P1. +*/ +case OP_VOpen: { /* ncycle */ + VdbeCursor *pCur; + sqlite3_vtab_cursor *pVCur; + sqlite3_vtab *pVtab; + const sqlite3_module *pModule; + + assert( p->bIsReader ); + pCur = 0; + pVCur = 0; + pVtab = pOp->p4.pVtab->pVtab; + if( pVtab==0 || NEVER(pVtab->pModule==0) ){ + rc = SQLITE_LOCKED; + goto abort_due_to_error; + } + pModule = pVtab->pModule; + rc = pModule->xOpen(pVtab, &pVCur); + sqlite3VtabImportErrmsg(p, pVtab); + if( rc ) goto abort_due_to_error; + + /* Initialize sqlite3_vtab_cursor base class */ + pVCur->pVtab = pVtab; + + /* Initialize vdbe cursor object */ + pCur = allocateCursor(p, pOp->p1, 0, CURTYPE_VTAB); + if( pCur ){ + pCur->uc.pVCur = pVCur; + pVtab->nRef++; + }else{ + assert( db->mallocFailed ); + pModule->xClose(pVCur); + goto no_mem; + } + break; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VInitIn P1 P2 P3 * * +** Synopsis: r[P2]=ValueList(P1,P3) +** +** Set register P2 to be a pointer to a ValueList object for cursor P1 +** with cache register P3 and output register P3+1. This ValueList object +** can be used as the first argument to sqlite3_vtab_in_first() and +** sqlite3_vtab_in_next() to extract all of the values stored in the P1 +** cursor. Register P3 is used to hold the values returned by +** sqlite3_vtab_in_first() and sqlite3_vtab_in_next(). +*/ +case OP_VInitIn: { /* out2, ncycle */ + VdbeCursor *pC; /* The cursor containing the RHS values */ + ValueList *pRhs; /* New ValueList object to put in reg[P2] */ + + pC = p->apCsr[pOp->p1]; + pRhs = sqlite3_malloc64( sizeof(*pRhs) ); + if( pRhs==0 ) goto no_mem; + pRhs->pCsr = pC->uc.pCursor; + pRhs->pOut = &aMem[pOp->p3]; + pOut = out2Prerelease(p, pOp); + pOut->flags = MEM_Null; + sqlite3VdbeMemSetPointer(pOut, pRhs, "ValueList", sqlite3VdbeValueListFree); + break; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VFilter P1 P2 P3 P4 * +** Synopsis: iplan=r[P3] zplan='P4' +** +** P1 is a cursor opened using VOpen. P2 is an address to jump to if +** the filtered result set is empty. +** +** P4 is either NULL or a string that was generated by the xBestIndex +** method of the module. The interpretation of the P4 string is left +** to the module implementation. +** +** This opcode invokes the xFilter method on the virtual table specified +** by P1. The integer query plan parameter to xFilter is stored in register +** P3. Register P3+1 stores the argc parameter to be passed to the +** xFilter method. Registers P3+2..P3+1+argc are the argc +** additional parameters which are passed to +** xFilter as argv. Register P3+2 becomes argv[0] when passed to xFilter. +** +** A jump is made to P2 if the result set after filtering would be empty. +*/ +case OP_VFilter: { /* jump, ncycle */ + int nArg; + int iQuery; + const sqlite3_module *pModule; + Mem *pQuery; + Mem *pArgc; + sqlite3_vtab_cursor *pVCur; + sqlite3_vtab *pVtab; + VdbeCursor *pCur; + int res; + int i; + Mem **apArg; + + pQuery = &aMem[pOp->p3]; + pArgc = &pQuery[1]; + pCur = p->apCsr[pOp->p1]; + assert( memIsValid(pQuery) ); + REGISTER_TRACE(pOp->p3, pQuery); + assert( pCur!=0 ); + assert( pCur->eCurType==CURTYPE_VTAB ); + pVCur = pCur->uc.pVCur; + pVtab = pVCur->pVtab; + pModule = pVtab->pModule; + + /* Grab the index number and argc parameters */ + assert( (pQuery->flags&MEM_Int)!=0 && pArgc->flags==MEM_Int ); + nArg = (int)pArgc->u.i; + iQuery = (int)pQuery->u.i; + + /* Invoke the xFilter method */ + apArg = p->apArg; + for(i = 0; ixFilter(pVCur, iQuery, pOp->p4.z, nArg, apArg); + sqlite3VtabImportErrmsg(p, pVtab); + if( rc ) goto abort_due_to_error; + res = pModule->xEof(pVCur); + pCur->nullRow = 0; + VdbeBranchTaken(res!=0,2); + if( res ) goto jump_to_p2; + break; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VColumn P1 P2 P3 * P5 +** Synopsis: r[P3]=vcolumn(P2) +** +** Store in register P3 the value of the P2-th column of +** the current row of the virtual-table of cursor P1. +** +** If the VColumn opcode is being used to fetch the value of +** an unchanging column during an UPDATE operation, then the P5 +** value is OPFLAG_NOCHNG. This will cause the sqlite3_vtab_nochange() +** function to return true inside the xColumn method of the virtual +** table implementation. The P5 column might also contain other +** bits (OPFLAG_LENGTHARG or OPFLAG_TYPEOFARG) but those bits are +** unused by OP_VColumn. +*/ +case OP_VColumn: { /* ncycle */ + sqlite3_vtab *pVtab; + const sqlite3_module *pModule; + Mem *pDest; + sqlite3_context sContext; + + VdbeCursor *pCur = p->apCsr[pOp->p1]; + assert( pCur!=0 ); + assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) ); + pDest = &aMem[pOp->p3]; + memAboutToChange(p, pDest); + if( pCur->nullRow ){ + sqlite3VdbeMemSetNull(pDest); + break; + } + assert( pCur->eCurType==CURTYPE_VTAB ); + pVtab = pCur->uc.pVCur->pVtab; + pModule = pVtab->pModule; + assert( pModule->xColumn ); + memset(&sContext, 0, sizeof(sContext)); + sContext.pOut = pDest; + sContext.enc = encoding; + assert( pOp->p5==OPFLAG_NOCHNG || pOp->p5==0 ); + if( pOp->p5 & OPFLAG_NOCHNG ){ + sqlite3VdbeMemSetNull(pDest); + pDest->flags = MEM_Null|MEM_Zero; + pDest->u.nZero = 0; + }else{ + MemSetTypeFlag(pDest, MEM_Null); + } + rc = pModule->xColumn(pCur->uc.pVCur, &sContext, pOp->p2); + sqlite3VtabImportErrmsg(p, pVtab); + if( sContext.isError>0 ){ + sqlite3VdbeError(p, "%s", sqlite3_value_text(pDest)); + rc = sContext.isError; + } + sqlite3VdbeChangeEncoding(pDest, encoding); + REGISTER_TRACE(pOp->p3, pDest); + UPDATE_MAX_BLOBSIZE(pDest); + + if( rc ) goto abort_due_to_error; + break; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VNext P1 P2 * * * +** +** Advance virtual table P1 to the next row in its result set and +** jump to instruction P2. Or, if the virtual table has reached +** the end of its result set, then fall through to the next instruction. +*/ +case OP_VNext: { /* jump, ncycle */ + sqlite3_vtab *pVtab; + const sqlite3_module *pModule; + int res; + VdbeCursor *pCur; + + pCur = p->apCsr[pOp->p1]; + assert( pCur!=0 ); + assert( pCur->eCurType==CURTYPE_VTAB ); + if( pCur->nullRow ){ + break; + } + pVtab = pCur->uc.pVCur->pVtab; + pModule = pVtab->pModule; + assert( pModule->xNext ); + + /* Invoke the xNext() method of the module. There is no way for the + ** underlying implementation to return an error if one occurs during + ** xNext(). Instead, if an error occurs, true is returned (indicating that + ** data is available) and the error code returned when xColumn or + ** some other method is next invoked on the save virtual table cursor. + */ + rc = pModule->xNext(pCur->uc.pVCur); + sqlite3VtabImportErrmsg(p, pVtab); + if( rc ) goto abort_due_to_error; + res = pModule->xEof(pCur->uc.pVCur); + VdbeBranchTaken(!res,2); + if( !res ){ + /* If there is data, jump to P2 */ + goto jump_to_p2_and_check_for_interrupt; + } + goto check_for_interrupt; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VRename P1 * * P4 * +** +** P4 is a pointer to a virtual table object, an sqlite3_vtab structure. +** This opcode invokes the corresponding xRename method. The value +** in register P1 is passed as the zName argument to the xRename method. +*/ +case OP_VRename: { + sqlite3_vtab *pVtab; + Mem *pName; + int isLegacy; + + isLegacy = (db->flags & SQLITE_LegacyAlter); + db->flags |= SQLITE_LegacyAlter; + pVtab = pOp->p4.pVtab->pVtab; + pName = &aMem[pOp->p1]; + assert( pVtab->pModule->xRename ); + assert( memIsValid(pName) ); + assert( p->readOnly==0 ); + REGISTER_TRACE(pOp->p1, pName); + assert( pName->flags & MEM_Str ); + testcase( pName->enc==SQLITE_UTF8 ); + testcase( pName->enc==SQLITE_UTF16BE ); + testcase( pName->enc==SQLITE_UTF16LE ); + rc = sqlite3VdbeChangeEncoding(pName, SQLITE_UTF8); + if( rc ) goto abort_due_to_error; + rc = pVtab->pModule->xRename(pVtab, pName->z); + if( isLegacy==0 ) db->flags &= ~(u64)SQLITE_LegacyAlter; + sqlite3VtabImportErrmsg(p, pVtab); + p->expired = 0; + if( rc ) goto abort_due_to_error; + break; +} +#endif + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Opcode: VUpdate P1 P2 P3 P4 P5 +** Synopsis: data=r[P3@P2] +** +** P4 is a pointer to a virtual table object, an sqlite3_vtab structure. +** This opcode invokes the corresponding xUpdate method. P2 values +** are contiguous memory cells starting at P3 to pass to the xUpdate +** invocation. The value in register (P3+P2-1) corresponds to the +** p2th element of the argv array passed to xUpdate. +** +** The xUpdate method will do a DELETE or an INSERT or both. +** The argv[0] element (which corresponds to memory cell P3) +** is the rowid of a row to delete. If argv[0] is NULL then no +** deletion occurs. The argv[1] element is the rowid of the new +** row. This can be NULL to have the virtual table select the new +** rowid for itself. The subsequent elements in the array are +** the values of columns in the new row. +** +** If P2==1 then no insert is performed. argv[0] is the rowid of +** a row to delete. +** +** P1 is a boolean flag. If it is set to true and the xUpdate call +** is successful, then the value returned by sqlite3_last_insert_rowid() +** is set to the value of the rowid for the row just inserted. +** +** P5 is the error actions (OE_Replace, OE_Fail, OE_Ignore, etc) to +** apply in the case of a constraint failure on an insert or update. +*/ +case OP_VUpdate: { + sqlite3_vtab *pVtab; + const sqlite3_module *pModule; + int nArg; + int i; + sqlite_int64 rowid = 0; + Mem **apArg; + Mem *pX; + + assert( pOp->p2==1 || pOp->p5==OE_Fail || pOp->p5==OE_Rollback + || pOp->p5==OE_Abort || pOp->p5==OE_Ignore || pOp->p5==OE_Replace + ); + assert( p->readOnly==0 ); + if( db->mallocFailed ) goto no_mem; + sqlite3VdbeIncrWriteCounter(p, 0); + pVtab = pOp->p4.pVtab->pVtab; + if( pVtab==0 || NEVER(pVtab->pModule==0) ){ + rc = SQLITE_LOCKED; + goto abort_due_to_error; + } + pModule = pVtab->pModule; + nArg = pOp->p2; + assert( pOp->p4type==P4_VTAB ); + if( ALWAYS(pModule->xUpdate) ){ + u8 vtabOnConflict = db->vtabOnConflict; + apArg = p->apArg; + pX = &aMem[pOp->p3]; + for(i=0; ivtabOnConflict = pOp->p5; + rc = pModule->xUpdate(pVtab, nArg, apArg, &rowid); + db->vtabOnConflict = vtabOnConflict; + sqlite3VtabImportErrmsg(p, pVtab); + if( rc==SQLITE_OK && pOp->p1 ){ + assert( nArg>1 && apArg[0] && (apArg[0]->flags&MEM_Null) ); + db->lastRowid = rowid; + } + if( (rc&0xff)==SQLITE_CONSTRAINT && pOp->p4.pVtab->bConstraint ){ + if( pOp->p5==OE_Ignore ){ + rc = SQLITE_OK; + }else{ + p->errorAction = ((pOp->p5==OE_Replace) ? OE_Abort : pOp->p5); + } + }else{ + p->nChange++; + } + if( rc ) goto abort_due_to_error; + } + break; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +/* Opcode: Pagecount P1 P2 * * * +** +** Write the current number of pages in database P1 to memory cell P2. +*/ +case OP_Pagecount: { /* out2 */ + pOut = out2Prerelease(p, pOp); + pOut->u.i = sqlite3BtreeLastPage(db->aDb[pOp->p1].pBt); + break; +} +#endif + + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +/* Opcode: MaxPgcnt P1 P2 P3 * * +** +** Try to set the maximum page count for database P1 to the value in P3. +** Do not let the maximum page count fall below the current page count and +** do not change the maximum page count value if P3==0. +** +** Store the maximum page count after the change in register P2. +*/ +case OP_MaxPgcnt: { /* out2 */ + unsigned int newMax; + Btree *pBt; + + pOut = out2Prerelease(p, pOp); + pBt = db->aDb[pOp->p1].pBt; + newMax = 0; + if( pOp->p3 ){ + newMax = sqlite3BtreeLastPage(pBt); + if( newMax < (unsigned)pOp->p3 ) newMax = (unsigned)pOp->p3; + } + pOut->u.i = sqlite3BtreeMaxPageCount(pBt, newMax); + break; +} +#endif + +/* Opcode: Function P1 P2 P3 P4 * +** Synopsis: r[P3]=func(r[P2@NP]) +** +** Invoke a user function (P4 is a pointer to an sqlite3_context object that +** contains a pointer to the function to be run) with arguments taken +** from register P2 and successors. The number of arguments is in +** the sqlite3_context object that P4 points to. +** The result of the function is stored +** in register P3. Register P3 must not be one of the function inputs. +** +** P1 is a 32-bit bitmask indicating whether or not each argument to the +** function was determined to be constant at compile time. If the first +** argument was constant then bit 0 of P1 is set. This is used to determine +** whether meta data associated with a user function argument using the +** sqlite3_set_auxdata() API may be safely retained until the next +** invocation of this opcode. +** +** See also: AggStep, AggFinal, PureFunc +*/ +/* Opcode: PureFunc P1 P2 P3 P4 * +** Synopsis: r[P3]=func(r[P2@NP]) +** +** Invoke a user function (P4 is a pointer to an sqlite3_context object that +** contains a pointer to the function to be run) with arguments taken +** from register P2 and successors. The number of arguments is in +** the sqlite3_context object that P4 points to. +** The result of the function is stored +** in register P3. Register P3 must not be one of the function inputs. +** +** P1 is a 32-bit bitmask indicating whether or not each argument to the +** function was determined to be constant at compile time. If the first +** argument was constant then bit 0 of P1 is set. This is used to determine +** whether meta data associated with a user function argument using the +** sqlite3_set_auxdata() API may be safely retained until the next +** invocation of this opcode. +** +** This opcode works exactly like OP_Function. The only difference is in +** its name. This opcode is used in places where the function must be +** purely non-deterministic. Some built-in date/time functions can be +** either determinitic of non-deterministic, depending on their arguments. +** When those function are used in a non-deterministic way, they will check +** to see if they were called using OP_PureFunc instead of OP_Function, and +** if they were, they throw an error. +** +** See also: AggStep, AggFinal, Function +*/ +case OP_PureFunc: /* group */ +case OP_Function: { /* group */ + int i; + sqlite3_context *pCtx; + + assert( pOp->p4type==P4_FUNCCTX ); + pCtx = pOp->p4.pCtx; + + /* If this function is inside of a trigger, the register array in aMem[] + ** might change from one evaluation to the next. The next block of code + ** checks to see if the register array has changed, and if so it + ** reinitializes the relavant parts of the sqlite3_context object */ + pOut = &aMem[pOp->p3]; + if( pCtx->pOut != pOut ){ + pCtx->pVdbe = p; + pCtx->pOut = pOut; + pCtx->enc = encoding; + for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i]; + } + assert( pCtx->pVdbe==p ); + + memAboutToChange(p, pOut); +#ifdef SQLITE_DEBUG + for(i=0; iargc; i++){ + assert( memIsValid(pCtx->argv[i]) ); + REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]); + } +#endif + MemSetTypeFlag(pOut, MEM_Null); + assert( pCtx->isError==0 ); + (*pCtx->pFunc->xSFunc)(pCtx, pCtx->argc, pCtx->argv);/* IMP: R-24505-23230 */ + + /* If the function returned an error, throw an exception */ + if( pCtx->isError ){ + if( pCtx->isError>0 ){ + sqlite3VdbeError(p, "%s", sqlite3_value_text(pOut)); + rc = pCtx->isError; + } + sqlite3VdbeDeleteAuxData(db, &p->pAuxData, pCtx->iOp, pOp->p1); + pCtx->isError = 0; + if( rc ) goto abort_due_to_error; + } + + assert( (pOut->flags&MEM_Str)==0 + || pOut->enc==encoding + || db->mallocFailed ); + assert( !sqlite3VdbeMemTooBig(pOut) ); + + REGISTER_TRACE(pOp->p3, pOut); + UPDATE_MAX_BLOBSIZE(pOut); + break; +} + +/* Opcode: ClrSubtype P1 * * * * +** Synopsis: r[P1].subtype = 0 +** +** Clear the subtype from register P1. +*/ +case OP_ClrSubtype: { /* in1 */ + pIn1 = &aMem[pOp->p1]; + pIn1->flags &= ~MEM_Subtype; + break; +} + +/* Opcode: FilterAdd P1 * P3 P4 * +** Synopsis: filter(P1) += key(P3@P4) +** +** Compute a hash on the P4 registers starting with r[P3] and +** add that hash to the bloom filter contained in r[P1]. +*/ +case OP_FilterAdd: { + u64 h; + + assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) ); + pIn1 = &aMem[pOp->p1]; + assert( pIn1->flags & MEM_Blob ); + assert( pIn1->n>0 ); + h = filterHash(aMem, pOp); +#ifdef SQLITE_DEBUG + if( db->flags&SQLITE_VdbeTrace ){ + int ii; + for(ii=pOp->p3; iip3+pOp->p4.i; ii++){ + registerTrace(ii, &aMem[ii]); + } + printf("hash: %llu modulo %d -> %u\n", h, pIn1->n, (int)(h%pIn1->n)); + } +#endif + h %= pIn1->n; + pIn1->z[h/8] |= 1<<(h&7); + break; +} + +/* Opcode: Filter P1 P2 P3 P4 * +** Synopsis: if key(P3@P4) not in filter(P1) goto P2 +** +** Compute a hash on the key contained in the P4 registers starting +** with r[P3]. Check to see if that hash is found in the +** bloom filter hosted by register P1. If it is not present then +** maybe jump to P2. Otherwise fall through. +** +** False negatives are harmless. It is always safe to fall through, +** even if the value is in the bloom filter. A false negative causes +** more CPU cycles to be used, but it should still yield the correct +** answer. However, an incorrect answer may well arise from a +** false positive - if the jump is taken when it should fall through. +*/ +case OP_Filter: { /* jump */ + u64 h; + + assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) ); + pIn1 = &aMem[pOp->p1]; + assert( (pIn1->flags & MEM_Blob)!=0 ); + assert( pIn1->n >= 1 ); + h = filterHash(aMem, pOp); +#ifdef SQLITE_DEBUG + if( db->flags&SQLITE_VdbeTrace ){ + int ii; + for(ii=pOp->p3; iip3+pOp->p4.i; ii++){ + registerTrace(ii, &aMem[ii]); + } + printf("hash: %llu modulo %d -> %u\n", h, pIn1->n, (int)(h%pIn1->n)); + } +#endif + h %= pIn1->n; + if( (pIn1->z[h/8] & (1<<(h&7)))==0 ){ + VdbeBranchTaken(1, 2); + p->aCounter[SQLITE_STMTSTATUS_FILTER_HIT]++; + goto jump_to_p2; + }else{ + p->aCounter[SQLITE_STMTSTATUS_FILTER_MISS]++; + VdbeBranchTaken(0, 2); + } + break; +} + +/* Opcode: Trace P1 P2 * P4 * +** +** Write P4 on the statement trace output if statement tracing is +** enabled. +** +** Operand P1 must be 0x7fffffff and P2 must positive. +*/ +/* Opcode: Init P1 P2 P3 P4 * +** Synopsis: Start at P2 +** +** Programs contain a single instance of this opcode as the very first +** opcode. +** +** If tracing is enabled (by the sqlite3_trace()) interface, then +** the UTF-8 string contained in P4 is emitted on the trace callback. +** Or if P4 is blank, use the string returned by sqlite3_sql(). +** +** If P2 is not zero, jump to instruction P2. +** +** Increment the value of P1 so that OP_Once opcodes will jump the +** first time they are evaluated for this run. +** +** If P3 is not zero, then it is an address to jump to if an SQLITE_CORRUPT +** error is encountered. +*/ +case OP_Trace: +case OP_Init: { /* jump */ + int i; +#ifndef SQLITE_OMIT_TRACE + char *zTrace; +#endif + + /* If the P4 argument is not NULL, then it must be an SQL comment string. + ** The "--" string is broken up to prevent false-positives with srcck1.c. + ** + ** This assert() provides evidence for: + ** EVIDENCE-OF: R-50676-09860 The callback can compute the same text that + ** would have been returned by the legacy sqlite3_trace() interface by + ** using the X argument when X begins with "--" and invoking + ** sqlite3_expanded_sql(P) otherwise. + */ + assert( pOp->p4.z==0 || strncmp(pOp->p4.z, "-" "- ", 3)==0 ); + + /* OP_Init is always instruction 0 */ + assert( pOp==p->aOp || pOp->opcode==OP_Trace ); + +#ifndef SQLITE_OMIT_TRACE + if( (db->mTrace & (SQLITE_TRACE_STMT|SQLITE_TRACE_LEGACY))!=0 + && p->minWriteFileFormat!=254 /* tag-20220401a */ + && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0 + ){ +#ifndef SQLITE_OMIT_DEPRECATED + if( db->mTrace & SQLITE_TRACE_LEGACY ){ + char *z = sqlite3VdbeExpandSql(p, zTrace); + db->trace.xLegacy(db->pTraceArg, z); + sqlite3_free(z); + }else +#endif + if( db->nVdbeExec>1 ){ + char *z = sqlite3MPrintf(db, "-- %s", zTrace); + (void)db->trace.xV2(SQLITE_TRACE_STMT, db->pTraceArg, p, z); + sqlite3DbFree(db, z); + }else{ + (void)db->trace.xV2(SQLITE_TRACE_STMT, db->pTraceArg, p, zTrace); + } + } +#ifdef SQLITE_USE_FCNTL_TRACE + zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql); + if( zTrace ){ + int j; + for(j=0; jnDb; j++){ + if( DbMaskTest(p->btreeMask, j)==0 ) continue; + sqlite3_file_control(db, db->aDb[j].zDbSName, SQLITE_FCNTL_TRACE, zTrace); + } + } +#endif /* SQLITE_USE_FCNTL_TRACE */ +#ifdef SQLITE_DEBUG + if( (db->flags & SQLITE_SqlTrace)!=0 + && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0 + ){ + sqlite3DebugPrintf("SQL-trace: %s\n", zTrace); + } +#endif /* SQLITE_DEBUG */ +#endif /* SQLITE_OMIT_TRACE */ + assert( pOp->p2>0 ); + if( pOp->p1>=sqlite3GlobalConfig.iOnceResetThreshold ){ + if( pOp->opcode==OP_Trace ) break; + for(i=1; inOp; i++){ + if( p->aOp[i].opcode==OP_Once ) p->aOp[i].p1 = 0; + } + pOp->p1 = 0; + } + pOp->p1++; + p->aCounter[SQLITE_STMTSTATUS_RUN]++; + goto jump_to_p2; +} + +#ifdef SQLITE_ENABLE_CURSOR_HINTS +/* Opcode: CursorHint P1 * * P4 * +** +** Provide a hint to cursor P1 that it only needs to return rows that +** satisfy the Expr in P4. TK_REGISTER terms in the P4 expression refer +** to values currently held in registers. TK_COLUMN terms in the P4 +** expression refer to columns in the b-tree to which cursor P1 is pointing. +*/ +case OP_CursorHint: { + VdbeCursor *pC; + + assert( pOp->p1>=0 && pOp->p1nCursor ); + assert( pOp->p4type==P4_EXPR ); + pC = p->apCsr[pOp->p1]; + if( pC ){ + assert( pC->eCurType==CURTYPE_BTREE ); + sqlite3BtreeCursorHint(pC->uc.pCursor, BTREE_HINT_RANGE, + pOp->p4.pExpr, aMem); + } + break; +} +#endif /* SQLITE_ENABLE_CURSOR_HINTS */ + +#ifdef SQLITE_DEBUG +/* Opcode: Abortable * * * * * +** +** Verify that an Abort can happen. Assert if an Abort at this point +** might cause database corruption. This opcode only appears in debugging +** builds. +** +** An Abort is safe if either there have been no writes, or if there is +** an active statement journal. +*/ +case OP_Abortable: { + sqlite3VdbeAssertAbortable(p); + break; +} +#endif + +#ifdef SQLITE_DEBUG +/* Opcode: ReleaseReg P1 P2 P3 * P5 +** Synopsis: release r[P1@P2] mask P3 +** +** Release registers from service. Any content that was in the +** the registers is unreliable after this opcode completes. +** +** The registers released will be the P2 registers starting at P1, +** except if bit ii of P3 set, then do not release register P1+ii. +** In other words, P3 is a mask of registers to preserve. +** +** Releasing a register clears the Mem.pScopyFrom pointer. That means +** that if the content of the released register was set using OP_SCopy, +** a change to the value of the source register for the OP_SCopy will no longer +** generate an assertion fault in sqlite3VdbeMemAboutToChange(). +** +** If P5 is set, then all released registers have their type set +** to MEM_Undefined so that any subsequent attempt to read the released +** register (before it is reinitialized) will generate an assertion fault. +** +** P5 ought to be set on every call to this opcode. +** However, there are places in the code generator will release registers +** before their are used, under the (valid) assumption that the registers +** will not be reallocated for some other purpose before they are used and +** hence are safe to release. +** +** This opcode is only available in testing and debugging builds. It is +** not generated for release builds. The purpose of this opcode is to help +** validate the generated bytecode. This opcode does not actually contribute +** to computing an answer. +*/ +case OP_ReleaseReg: { + Mem *pMem; + int i; + u32 constMask; + assert( pOp->p1>0 ); + assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 ); + pMem = &aMem[pOp->p1]; + constMask = pOp->p3; + for(i=0; ip2; i++, pMem++){ + if( i>=32 || (constMask & MASKBIT32(i))==0 ){ + pMem->pScopyFrom = 0; + if( i<32 && pOp->p5 ) MemSetTypeFlag(pMem, MEM_Undefined); + } + } + break; +} +#endif + +/* Opcode: Noop * * * * * +** +** Do nothing. This instruction is often useful as a jump +** destination. +*/ +/* +** The magic Explain opcode are only inserted when explain==2 (which +** is to say when the EXPLAIN QUERY PLAN syntax is used.) +** This opcode records information from the optimizer. It is the +** the same as a no-op. This opcodesnever appears in a real VM program. +*/ +default: { /* This is really OP_Noop, OP_Explain */ + assert( pOp->opcode==OP_Noop || pOp->opcode==OP_Explain ); + + break; +} + +/***************************************************************************** +** The cases of the switch statement above this line should all be indented +** by 6 spaces. But the left-most 6 spaces have been removed to improve the +** readability. From this point on down, the normal indentation rules are +** restored. +*****************************************************************************/ + } + +#if defined(VDBE_PROFILE) + *pnCycle += sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime(); + pnCycle = 0; +#elif defined(SQLITE_ENABLE_STMT_SCANSTATUS) + if( pnCycle ){ + *pnCycle += sqlite3Hwtime(); + pnCycle = 0; + } +#endif + + /* The following code adds nothing to the actual functionality + ** of the program. It is only here for testing and debugging. + ** On the other hand, it does burn CPU cycles every time through + ** the evaluator loop. So we can leave it out when NDEBUG is defined. + */ +#ifndef NDEBUG + assert( pOp>=&aOp[-1] && pOp<&aOp[p->nOp-1] ); + +#ifdef SQLITE_DEBUG + if( db->flags & SQLITE_VdbeTrace ){ + u8 opProperty = sqlite3OpcodeProperty[pOrigOp->opcode]; + if( rc!=0 ) printf("rc=%d\n",rc); + if( opProperty & (OPFLG_OUT2) ){ + registerTrace(pOrigOp->p2, &aMem[pOrigOp->p2]); + } + if( opProperty & OPFLG_OUT3 ){ + registerTrace(pOrigOp->p3, &aMem[pOrigOp->p3]); + } + if( opProperty==0xff ){ + /* Never happens. This code exists to avoid a harmless linkage + ** warning aboud sqlite3VdbeRegisterDump() being defined but not + ** used. */ + sqlite3VdbeRegisterDump(p); + } + } +#endif /* SQLITE_DEBUG */ +#endif /* NDEBUG */ + } /* The end of the for(;;) loop the loops through opcodes */ + + /* If we reach this point, it means that execution is finished with + ** an error of some kind. + */ +abort_due_to_error: + if( db->mallocFailed ){ + rc = SQLITE_NOMEM_BKPT; + }else if( rc==SQLITE_IOERR_CORRUPTFS ){ + rc = SQLITE_CORRUPT_BKPT; + } + assert( rc ); +#ifdef SQLITE_DEBUG + if( db->flags & SQLITE_VdbeTrace ){ + const char *zTrace = p->zSql; + if( zTrace==0 ){ + if( aOp[0].opcode==OP_Trace ){ + zTrace = aOp[0].p4.z; + } + if( zTrace==0 ) zTrace = "???"; + } + printf("ABORT-due-to-error (rc=%d): %s\n", rc, zTrace); + } +#endif + if( p->zErrMsg==0 && rc!=SQLITE_IOERR_NOMEM ){ + sqlite3VdbeError(p, "%s", sqlite3ErrStr(rc)); + } + p->rc = rc; + sqlite3SystemError(db, rc); + testcase( sqlite3GlobalConfig.xLog!=0 ); + sqlite3_log(rc, "statement aborts at %d: [%s] %s", + (int)(pOp - aOp), p->zSql, p->zErrMsg); + if( p->eVdbeState==VDBE_RUN_STATE ) sqlite3VdbeHalt(p); + if( rc==SQLITE_IOERR_NOMEM ) sqlite3OomFault(db); + if( rc==SQLITE_CORRUPT && db->autoCommit==0 ){ + db->flags |= SQLITE_CorruptRdOnly; + } + rc = SQLITE_ERROR; + if( resetSchemaOnFault>0 ){ + sqlite3ResetOneSchema(db, resetSchemaOnFault-1); + } + + /* This is the only way out of this procedure. We have to + ** release the mutexes on btrees that were acquired at the + ** top. */ +vdbe_return: +#if defined(VDBE_PROFILE) + if( pnCycle ){ + *pnCycle += sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime(); + pnCycle = 0; + } +#elif defined(SQLITE_ENABLE_STMT_SCANSTATUS) + if( pnCycle ){ + *pnCycle += sqlite3Hwtime(); + pnCycle = 0; + } +#endif + +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + while( nVmStep>=nProgressLimit && db->xProgress!=0 ){ + nProgressLimit += db->nProgressOps; + if( db->xProgress(db->pProgressArg) ){ + nProgressLimit = LARGEST_UINT64; + rc = SQLITE_INTERRUPT; + goto abort_due_to_error; + } + } +#endif + p->aCounter[SQLITE_STMTSTATUS_VM_STEP] += (int)nVmStep; + if( DbMaskNonZero(p->lockMask) ){ + sqlite3VdbeLeave(p); + } + assert( rc!=SQLITE_OK || nExtraDelete==0 + || sqlite3_strlike("DELETE%",p->zSql,0)!=0 + ); + return rc; + + /* Jump to here if a string or blob larger than SQLITE_MAX_LENGTH + ** is encountered. + */ +too_big: + sqlite3VdbeError(p, "string or blob too big"); + rc = SQLITE_TOOBIG; + goto abort_due_to_error; + + /* Jump to here if a malloc() fails. + */ +no_mem: + sqlite3OomFault(db); + sqlite3VdbeError(p, "out of memory"); + rc = SQLITE_NOMEM_BKPT; + goto abort_due_to_error; + + /* Jump to here if the sqlite3_interrupt() API sets the interrupt + ** flag. + */ +abort_due_to_interrupt: + assert( AtomicLoad(&db->u1.isInterrupted) ); + rc = SQLITE_INTERRUPT; + goto abort_due_to_error; +} + + +/************** End of vdbe.c ************************************************/ +/************** Begin file vdbeblob.c ****************************************/ +/* +** 2007 May 1 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains code used to implement incremental BLOB I/O. +*/ + +/* #include "sqliteInt.h" */ +/* #include "vdbeInt.h" */ + +#ifndef SQLITE_OMIT_INCRBLOB + +/* +** Valid sqlite3_blob* handles point to Incrblob structures. +*/ +typedef struct Incrblob Incrblob; +struct Incrblob { + int nByte; /* Size of open blob, in bytes */ + int iOffset; /* Byte offset of blob in cursor data */ + u16 iCol; /* Table column this handle is open on */ + BtCursor *pCsr; /* Cursor pointing at blob row */ + sqlite3_stmt *pStmt; /* Statement holding cursor open */ + sqlite3 *db; /* The associated database */ + char *zDb; /* Database name */ + Table *pTab; /* Table object */ +}; + + +/* +** This function is used by both blob_open() and blob_reopen(). It seeks +** the b-tree cursor associated with blob handle p to point to row iRow. +** If successful, SQLITE_OK is returned and subsequent calls to +** sqlite3_blob_read() or sqlite3_blob_write() access the specified row. +** +** If an error occurs, or if the specified row does not exist or does not +** contain a value of type TEXT or BLOB in the column nominated when the +** blob handle was opened, then an error code is returned and *pzErr may +** be set to point to a buffer containing an error message. It is the +** responsibility of the caller to free the error message buffer using +** sqlite3DbFree(). +** +** If an error does occur, then the b-tree cursor is closed. All subsequent +** calls to sqlite3_blob_read(), blob_write() or blob_reopen() will +** immediately return SQLITE_ABORT. +*/ +static int blobSeekToRow(Incrblob *p, sqlite3_int64 iRow, char **pzErr){ + int rc; /* Error code */ + char *zErr = 0; /* Error message */ + Vdbe *v = (Vdbe *)p->pStmt; + + /* Set the value of register r[1] in the SQL statement to integer iRow. + ** This is done directly as a performance optimization + */ + v->aMem[1].flags = MEM_Int; + v->aMem[1].u.i = iRow; + + /* If the statement has been run before (and is paused at the OP_ResultRow) + ** then back it up to the point where it does the OP_NotExists. This could + ** have been down with an extra OP_Goto, but simply setting the program + ** counter is faster. */ + if( v->pc>4 ){ + v->pc = 4; + assert( v->aOp[v->pc].opcode==OP_NotExists ); + rc = sqlite3VdbeExec(v); + }else{ + rc = sqlite3_step(p->pStmt); + } + if( rc==SQLITE_ROW ){ + VdbeCursor *pC = v->apCsr[0]; + u32 type; + assert( pC!=0 ); + assert( pC->eCurType==CURTYPE_BTREE ); + type = pC->nHdrParsed>p->iCol ? pC->aType[p->iCol] : 0; + testcase( pC->nHdrParsed==p->iCol ); + testcase( pC->nHdrParsed==p->iCol+1 ); + if( type<12 ){ + zErr = sqlite3MPrintf(p->db, "cannot open value of type %s", + type==0?"null": type==7?"real": "integer" + ); + rc = SQLITE_ERROR; + sqlite3_finalize(p->pStmt); + p->pStmt = 0; + }else{ + p->iOffset = pC->aType[p->iCol + pC->nField]; + p->nByte = sqlite3VdbeSerialTypeLen(type); + p->pCsr = pC->uc.pCursor; + sqlite3BtreeIncrblobCursor(p->pCsr); + } + } + + if( rc==SQLITE_ROW ){ + rc = SQLITE_OK; + }else if( p->pStmt ){ + rc = sqlite3_finalize(p->pStmt); + p->pStmt = 0; + if( rc==SQLITE_OK ){ + zErr = sqlite3MPrintf(p->db, "no such rowid: %lld", iRow); + rc = SQLITE_ERROR; + }else{ + zErr = sqlite3MPrintf(p->db, "%s", sqlite3_errmsg(p->db)); + } + } + + assert( rc!=SQLITE_OK || zErr==0 ); + assert( rc!=SQLITE_ROW && rc!=SQLITE_DONE ); + + *pzErr = zErr; + return rc; +} + +/* +** Open a blob handle. +*/ +SQLITE_API int sqlite3_blob_open( + sqlite3* db, /* The database connection */ + const char *zDb, /* The attached database containing the blob */ + const char *zTable, /* The table containing the blob */ + const char *zColumn, /* The column containing the blob */ + sqlite_int64 iRow, /* The row containing the glob */ + int wrFlag, /* True -> read/write access, false -> read-only */ + sqlite3_blob **ppBlob /* Handle for accessing the blob returned here */ +){ + int nAttempt = 0; + int iCol; /* Index of zColumn in row-record */ + int rc = SQLITE_OK; + char *zErr = 0; + Table *pTab; + Incrblob *pBlob = 0; + Parse sParse; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( ppBlob==0 ){ + return SQLITE_MISUSE_BKPT; + } +#endif + *ppBlob = 0; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zTable==0 ){ + return SQLITE_MISUSE_BKPT; + } +#endif + wrFlag = !!wrFlag; /* wrFlag = (wrFlag ? 1 : 0); */ + + sqlite3_mutex_enter(db->mutex); + + pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob)); + while(1){ + sqlite3ParseObjectInit(&sParse,db); + if( !pBlob ) goto blob_open_out; + sqlite3DbFree(db, zErr); + zErr = 0; + + sqlite3BtreeEnterAll(db); + pTab = sqlite3LocateTable(&sParse, 0, zTable, zDb); + if( pTab && IsVirtual(pTab) ){ + pTab = 0; + sqlite3ErrorMsg(&sParse, "cannot open virtual table: %s", zTable); + } + if( pTab && !HasRowid(pTab) ){ + pTab = 0; + sqlite3ErrorMsg(&sParse, "cannot open table without rowid: %s", zTable); + } +#ifndef SQLITE_OMIT_VIEW + if( pTab && IsView(pTab) ){ + pTab = 0; + sqlite3ErrorMsg(&sParse, "cannot open view: %s", zTable); + } +#endif + if( !pTab ){ + if( sParse.zErrMsg ){ + sqlite3DbFree(db, zErr); + zErr = sParse.zErrMsg; + sParse.zErrMsg = 0; + } + rc = SQLITE_ERROR; + sqlite3BtreeLeaveAll(db); + goto blob_open_out; + } + pBlob->pTab = pTab; + pBlob->zDb = db->aDb[sqlite3SchemaToIndex(db, pTab->pSchema)].zDbSName; + + /* Now search pTab for the exact column. */ + for(iCol=0; iColnCol; iCol++) { + if( sqlite3StrICmp(pTab->aCol[iCol].zCnName, zColumn)==0 ){ + break; + } + } + if( iCol==pTab->nCol ){ + sqlite3DbFree(db, zErr); + zErr = sqlite3MPrintf(db, "no such column: \"%s\"", zColumn); + rc = SQLITE_ERROR; + sqlite3BtreeLeaveAll(db); + goto blob_open_out; + } + + /* If the value is being opened for writing, check that the + ** column is not indexed, and that it is not part of a foreign key. + */ + if( wrFlag ){ + const char *zFault = 0; + Index *pIdx; +#ifndef SQLITE_OMIT_FOREIGN_KEY + if( db->flags&SQLITE_ForeignKeys ){ + /* Check that the column is not part of an FK child key definition. It + ** is not necessary to check if it is part of a parent key, as parent + ** key columns must be indexed. The check below will pick up this + ** case. */ + FKey *pFKey; + assert( IsOrdinaryTable(pTab) ); + for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){ + int j; + for(j=0; jnCol; j++){ + if( pFKey->aCol[j].iFrom==iCol ){ + zFault = "foreign key"; + } + } + } + } +#endif + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + int j; + for(j=0; jnKeyCol; j++){ + /* FIXME: Be smarter about indexes that use expressions */ + if( pIdx->aiColumn[j]==iCol || pIdx->aiColumn[j]==XN_EXPR ){ + zFault = "indexed"; + } + } + } + if( zFault ){ + sqlite3DbFree(db, zErr); + zErr = sqlite3MPrintf(db, "cannot open %s column for writing", zFault); + rc = SQLITE_ERROR; + sqlite3BtreeLeaveAll(db); + goto blob_open_out; + } + } + + pBlob->pStmt = (sqlite3_stmt *)sqlite3VdbeCreate(&sParse); + assert( pBlob->pStmt || db->mallocFailed ); + if( pBlob->pStmt ){ + + /* This VDBE program seeks a btree cursor to the identified + ** db/table/row entry. The reason for using a vdbe program instead + ** of writing code to use the b-tree layer directly is that the + ** vdbe program will take advantage of the various transaction, + ** locking and error handling infrastructure built into the vdbe. + ** + ** After seeking the cursor, the vdbe executes an OP_ResultRow. + ** Code external to the Vdbe then "borrows" the b-tree cursor and + ** uses it to implement the blob_read(), blob_write() and + ** blob_bytes() functions. + ** + ** The sqlite3_blob_close() function finalizes the vdbe program, + ** which closes the b-tree cursor and (possibly) commits the + ** transaction. + */ + static const int iLn = VDBE_OFFSET_LINENO(2); + static const VdbeOpList openBlob[] = { + {OP_TableLock, 0, 0, 0}, /* 0: Acquire a read or write lock */ + {OP_OpenRead, 0, 0, 0}, /* 1: Open a cursor */ + /* blobSeekToRow() will initialize r[1] to the desired rowid */ + {OP_NotExists, 0, 5, 1}, /* 2: Seek the cursor to rowid=r[1] */ + {OP_Column, 0, 0, 1}, /* 3 */ + {OP_ResultRow, 1, 0, 0}, /* 4 */ + {OP_Halt, 0, 0, 0}, /* 5 */ + }; + Vdbe *v = (Vdbe *)pBlob->pStmt; + int iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + VdbeOp *aOp; + + sqlite3VdbeAddOp4Int(v, OP_Transaction, iDb, wrFlag, + pTab->pSchema->schema_cookie, + pTab->pSchema->iGeneration); + sqlite3VdbeChangeP5(v, 1); + assert( sqlite3VdbeCurrentAddr(v)==2 || db->mallocFailed ); + aOp = sqlite3VdbeAddOpList(v, ArraySize(openBlob), openBlob, iLn); + + /* Make sure a mutex is held on the table to be accessed */ + sqlite3VdbeUsesBtree(v, iDb); + + if( db->mallocFailed==0 ){ + assert( aOp!=0 ); + /* Configure the OP_TableLock instruction */ +#ifdef SQLITE_OMIT_SHARED_CACHE + aOp[0].opcode = OP_Noop; +#else + aOp[0].p1 = iDb; + aOp[0].p2 = pTab->tnum; + aOp[0].p3 = wrFlag; + sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT); + } + if( db->mallocFailed==0 ){ +#endif + + /* Remove either the OP_OpenWrite or OpenRead. Set the P2 + ** parameter of the other to pTab->tnum. */ + if( wrFlag ) aOp[1].opcode = OP_OpenWrite; + aOp[1].p2 = pTab->tnum; + aOp[1].p3 = iDb; + + /* Configure the number of columns. Configure the cursor to + ** think that the table has one more column than it really + ** does. An OP_Column to retrieve this imaginary column will + ** always return an SQL NULL. This is useful because it means + ** we can invoke OP_Column to fill in the vdbe cursors type + ** and offset cache without causing any IO. + */ + aOp[1].p4type = P4_INT32; + aOp[1].p4.i = pTab->nCol+1; + aOp[3].p2 = pTab->nCol; + + sParse.nVar = 0; + sParse.nMem = 1; + sParse.nTab = 1; + sqlite3VdbeMakeReady(v, &sParse); + } + } + + pBlob->iCol = iCol; + pBlob->db = db; + sqlite3BtreeLeaveAll(db); + if( db->mallocFailed ){ + goto blob_open_out; + } + rc = blobSeekToRow(pBlob, iRow, &zErr); + if( (++nAttempt)>=SQLITE_MAX_SCHEMA_RETRY || rc!=SQLITE_SCHEMA ) break; + sqlite3ParseObjectReset(&sParse); + } + +blob_open_out: + if( rc==SQLITE_OK && db->mallocFailed==0 ){ + *ppBlob = (sqlite3_blob *)pBlob; + }else{ + if( pBlob && pBlob->pStmt ) sqlite3VdbeFinalize((Vdbe *)pBlob->pStmt); + sqlite3DbFree(db, pBlob); + } + sqlite3ErrorWithMsg(db, rc, (zErr ? "%s" : (char*)0), zErr); + sqlite3DbFree(db, zErr); + sqlite3ParseObjectReset(&sParse); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Close a blob handle that was previously created using +** sqlite3_blob_open(). +*/ +SQLITE_API int sqlite3_blob_close(sqlite3_blob *pBlob){ + Incrblob *p = (Incrblob *)pBlob; + int rc; + sqlite3 *db; + + if( p ){ + sqlite3_stmt *pStmt = p->pStmt; + db = p->db; + sqlite3_mutex_enter(db->mutex); + sqlite3DbFree(db, p); + sqlite3_mutex_leave(db->mutex); + rc = sqlite3_finalize(pStmt); + }else{ + rc = SQLITE_OK; + } + return rc; +} + +/* +** Perform a read or write operation on a blob +*/ +static int blobReadWrite( + sqlite3_blob *pBlob, + void *z, + int n, + int iOffset, + int (*xCall)(BtCursor*, u32, u32, void*) +){ + int rc; + Incrblob *p = (Incrblob *)pBlob; + Vdbe *v; + sqlite3 *db; + + if( p==0 ) return SQLITE_MISUSE_BKPT; + db = p->db; + sqlite3_mutex_enter(db->mutex); + v = (Vdbe*)p->pStmt; + + if( n<0 || iOffset<0 || ((sqlite3_int64)iOffset+n)>p->nByte ){ + /* Request is out of range. Return a transient error. */ + rc = SQLITE_ERROR; + }else if( v==0 ){ + /* If there is no statement handle, then the blob-handle has + ** already been invalidated. Return SQLITE_ABORT in this case. + */ + rc = SQLITE_ABORT; + }else{ + /* Call either BtreeData() or BtreePutData(). If SQLITE_ABORT is + ** returned, clean-up the statement handle. + */ + assert( db == v->db ); + sqlite3BtreeEnterCursor(p->pCsr); + +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + if( xCall==sqlite3BtreePutData && db->xPreUpdateCallback ){ + /* If a pre-update hook is registered and this is a write cursor, + ** invoke it here. + ** + ** TODO: The preupdate-hook is passed SQLITE_DELETE, even though this + ** operation should really be an SQLITE_UPDATE. This is probably + ** incorrect, but is convenient because at this point the new.* values + ** are not easily obtainable. And for the sessions module, an + ** SQLITE_UPDATE where the PK columns do not change is handled in the + ** same way as an SQLITE_DELETE (the SQLITE_DELETE code is actually + ** slightly more efficient). Since you cannot write to a PK column + ** using the incremental-blob API, this works. For the sessions module + ** anyhow. + */ + sqlite3_int64 iKey; + iKey = sqlite3BtreeIntegerKey(p->pCsr); + assert( v->apCsr[0]!=0 ); + assert( v->apCsr[0]->eCurType==CURTYPE_BTREE ); + sqlite3VdbePreUpdateHook( + v, v->apCsr[0], SQLITE_DELETE, p->zDb, p->pTab, iKey, -1, p->iCol + ); + } +#endif + + rc = xCall(p->pCsr, iOffset+p->iOffset, n, z); + sqlite3BtreeLeaveCursor(p->pCsr); + if( rc==SQLITE_ABORT ){ + sqlite3VdbeFinalize(v); + p->pStmt = 0; + }else{ + v->rc = rc; + } + } + sqlite3Error(db, rc); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Read data from a blob handle. +*/ +SQLITE_API int sqlite3_blob_read(sqlite3_blob *pBlob, void *z, int n, int iOffset){ + return blobReadWrite(pBlob, z, n, iOffset, sqlite3BtreePayloadChecked); +} + +/* +** Write data to a blob handle. +*/ +SQLITE_API int sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int iOffset){ + return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlite3BtreePutData); +} + +/* +** Query a blob handle for the size of the data. +** +** The Incrblob.nByte field is fixed for the lifetime of the Incrblob +** so no mutex is required for access. +*/ +SQLITE_API int sqlite3_blob_bytes(sqlite3_blob *pBlob){ + Incrblob *p = (Incrblob *)pBlob; + return (p && p->pStmt) ? p->nByte : 0; +} + +/* +** Move an existing blob handle to point to a different row of the same +** database table. +** +** If an error occurs, or if the specified row does not exist or does not +** contain a blob or text value, then an error code is returned and the +** database handle error code and message set. If this happens, then all +** subsequent calls to sqlite3_blob_xxx() functions (except blob_close()) +** immediately return SQLITE_ABORT. +*/ +SQLITE_API int sqlite3_blob_reopen(sqlite3_blob *pBlob, sqlite3_int64 iRow){ + int rc; + Incrblob *p = (Incrblob *)pBlob; + sqlite3 *db; + + if( p==0 ) return SQLITE_MISUSE_BKPT; + db = p->db; + sqlite3_mutex_enter(db->mutex); + + if( p->pStmt==0 ){ + /* If there is no statement handle, then the blob-handle has + ** already been invalidated. Return SQLITE_ABORT in this case. + */ + rc = SQLITE_ABORT; + }else{ + char *zErr; + ((Vdbe*)p->pStmt)->rc = SQLITE_OK; + rc = blobSeekToRow(p, iRow, &zErr); + if( rc!=SQLITE_OK ){ + sqlite3ErrorWithMsg(db, rc, (zErr ? "%s" : (char*)0), zErr); + sqlite3DbFree(db, zErr); + } + assert( rc!=SQLITE_SCHEMA ); + } + + rc = sqlite3ApiExit(db, rc); + assert( rc==SQLITE_OK || p->pStmt==0 ); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +#endif /* #ifndef SQLITE_OMIT_INCRBLOB */ + +/************** End of vdbeblob.c ********************************************/ +/************** Begin file vdbesort.c ****************************************/ +/* +** 2011-07-09 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code for the VdbeSorter object, used in concert with +** a VdbeCursor to sort large numbers of keys for CREATE INDEX statements +** or by SELECT statements with ORDER BY clauses that cannot be satisfied +** using indexes and without LIMIT clauses. +** +** The VdbeSorter object implements a multi-threaded external merge sort +** algorithm that is efficient even if the number of elements being sorted +** exceeds the available memory. +** +** Here is the (internal, non-API) interface between this module and the +** rest of the SQLite system: +** +** sqlite3VdbeSorterInit() Create a new VdbeSorter object. +** +** sqlite3VdbeSorterWrite() Add a single new row to the VdbeSorter +** object. The row is a binary blob in the +** OP_MakeRecord format that contains both +** the ORDER BY key columns and result columns +** in the case of a SELECT w/ ORDER BY, or +** the complete record for an index entry +** in the case of a CREATE INDEX. +** +** sqlite3VdbeSorterRewind() Sort all content previously added. +** Position the read cursor on the +** first sorted element. +** +** sqlite3VdbeSorterNext() Advance the read cursor to the next sorted +** element. +** +** sqlite3VdbeSorterRowkey() Return the complete binary blob for the +** row currently under the read cursor. +** +** sqlite3VdbeSorterCompare() Compare the binary blob for the row +** currently under the read cursor against +** another binary blob X and report if +** X is strictly less than the read cursor. +** Used to enforce uniqueness in a +** CREATE UNIQUE INDEX statement. +** +** sqlite3VdbeSorterClose() Close the VdbeSorter object and reclaim +** all resources. +** +** sqlite3VdbeSorterReset() Refurbish the VdbeSorter for reuse. This +** is like Close() followed by Init() only +** much faster. +** +** The interfaces above must be called in a particular order. Write() can +** only occur in between Init()/Reset() and Rewind(). Next(), Rowkey(), and +** Compare() can only occur in between Rewind() and Close()/Reset(). i.e. +** +** Init() +** for each record: Write() +** Rewind() +** Rowkey()/Compare() +** Next() +** Close() +** +** Algorithm: +** +** Records passed to the sorter via calls to Write() are initially held +** unsorted in main memory. Assuming the amount of memory used never exceeds +** a threshold, when Rewind() is called the set of records is sorted using +** an in-memory merge sort. In this case, no temporary files are required +** and subsequent calls to Rowkey(), Next() and Compare() read records +** directly from main memory. +** +** If the amount of space used to store records in main memory exceeds the +** threshold, then the set of records currently in memory are sorted and +** written to a temporary file in "Packed Memory Array" (PMA) format. +** A PMA created at this point is known as a "level-0 PMA". Higher levels +** of PMAs may be created by merging existing PMAs together - for example +** merging two or more level-0 PMAs together creates a level-1 PMA. +** +** The threshold for the amount of main memory to use before flushing +** records to a PMA is roughly the same as the limit configured for the +** page-cache of the main database. Specifically, the threshold is set to +** the value returned by "PRAGMA main.page_size" multipled by +** that returned by "PRAGMA main.cache_size", in bytes. +** +** If the sorter is running in single-threaded mode, then all PMAs generated +** are appended to a single temporary file. Or, if the sorter is running in +** multi-threaded mode then up to (N+1) temporary files may be opened, where +** N is the configured number of worker threads. In this case, instead of +** sorting the records and writing the PMA to a temporary file itself, the +** calling thread usually launches a worker thread to do so. Except, if +** there are already N worker threads running, the main thread does the work +** itself. +** +** The sorter is running in multi-threaded mode if (a) the library was built +** with pre-processor symbol SQLITE_MAX_WORKER_THREADS set to a value greater +** than zero, and (b) worker threads have been enabled at runtime by calling +** "PRAGMA threads=N" with some value of N greater than 0. +** +** When Rewind() is called, any data remaining in memory is flushed to a +** final PMA. So at this point the data is stored in some number of sorted +** PMAs within temporary files on disk. +** +** If there are fewer than SORTER_MAX_MERGE_COUNT PMAs in total and the +** sorter is running in single-threaded mode, then these PMAs are merged +** incrementally as keys are retreived from the sorter by the VDBE. The +** MergeEngine object, described in further detail below, performs this +** merge. +** +** Or, if running in multi-threaded mode, then a background thread is +** launched to merge the existing PMAs. Once the background thread has +** merged T bytes of data into a single sorted PMA, the main thread +** begins reading keys from that PMA while the background thread proceeds +** with merging the next T bytes of data. And so on. +** +** Parameter T is set to half the value of the memory threshold used +** by Write() above to determine when to create a new PMA. +** +** If there are more than SORTER_MAX_MERGE_COUNT PMAs in total when +** Rewind() is called, then a hierarchy of incremental-merges is used. +** First, T bytes of data from the first SORTER_MAX_MERGE_COUNT PMAs on +** disk are merged together. Then T bytes of data from the second set, and +** so on, such that no operation ever merges more than SORTER_MAX_MERGE_COUNT +** PMAs at a time. This done is to improve locality. +** +** If running in multi-threaded mode and there are more than +** SORTER_MAX_MERGE_COUNT PMAs on disk when Rewind() is called, then more +** than one background thread may be created. Specifically, there may be +** one background thread for each temporary file on disk, and one background +** thread to merge the output of each of the others to a single PMA for +** the main thread to read from. +*/ +/* #include "sqliteInt.h" */ +/* #include "vdbeInt.h" */ + +/* +** If SQLITE_DEBUG_SORTER_THREADS is defined, this module outputs various +** messages to stderr that may be helpful in understanding the performance +** characteristics of the sorter in multi-threaded mode. +*/ +#if 0 +# define SQLITE_DEBUG_SORTER_THREADS 1 +#endif + +/* +** Hard-coded maximum amount of data to accumulate in memory before flushing +** to a level 0 PMA. The purpose of this limit is to prevent various integer +** overflows. 512MiB. +*/ +#define SQLITE_MAX_PMASZ (1<<29) + +/* +** Private objects used by the sorter +*/ +typedef struct MergeEngine MergeEngine; /* Merge PMAs together */ +typedef struct PmaReader PmaReader; /* Incrementally read one PMA */ +typedef struct PmaWriter PmaWriter; /* Incrementally write one PMA */ +typedef struct SorterRecord SorterRecord; /* A record being sorted */ +typedef struct SortSubtask SortSubtask; /* A sub-task in the sort process */ +typedef struct SorterFile SorterFile; /* Temporary file object wrapper */ +typedef struct SorterList SorterList; /* In-memory list of records */ +typedef struct IncrMerger IncrMerger; /* Read & merge multiple PMAs */ + +/* +** A container for a temp file handle and the current amount of data +** stored in the file. +*/ +struct SorterFile { + sqlite3_file *pFd; /* File handle */ + i64 iEof; /* Bytes of data stored in pFd */ +}; + +/* +** An in-memory list of objects to be sorted. +** +** If aMemory==0 then each object is allocated separately and the objects +** are connected using SorterRecord.u.pNext. If aMemory!=0 then all objects +** are stored in the aMemory[] bulk memory, one right after the other, and +** are connected using SorterRecord.u.iNext. +*/ +struct SorterList { + SorterRecord *pList; /* Linked list of records */ + u8 *aMemory; /* If non-NULL, bulk memory to hold pList */ + int szPMA; /* Size of pList as PMA in bytes */ +}; + +/* +** The MergeEngine object is used to combine two or more smaller PMAs into +** one big PMA using a merge operation. Separate PMAs all need to be +** combined into one big PMA in order to be able to step through the sorted +** records in order. +** +** The aReadr[] array contains a PmaReader object for each of the PMAs being +** merged. An aReadr[] object either points to a valid key or else is at EOF. +** ("EOF" means "End Of File". When aReadr[] is at EOF there is no more data.) +** For the purposes of the paragraphs below, we assume that the array is +** actually N elements in size, where N is the smallest power of 2 greater +** to or equal to the number of PMAs being merged. The extra aReadr[] elements +** are treated as if they are empty (always at EOF). +** +** The aTree[] array is also N elements in size. The value of N is stored in +** the MergeEngine.nTree variable. +** +** The final (N/2) elements of aTree[] contain the results of comparing +** pairs of PMA keys together. Element i contains the result of +** comparing aReadr[2*i-N] and aReadr[2*i-N+1]. Whichever key is smaller, the +** aTree element is set to the index of it. +** +** For the purposes of this comparison, EOF is considered greater than any +** other key value. If the keys are equal (only possible with two EOF +** values), it doesn't matter which index is stored. +** +** The (N/4) elements of aTree[] that precede the final (N/2) described +** above contains the index of the smallest of each block of 4 PmaReaders +** And so on. So that aTree[1] contains the index of the PmaReader that +** currently points to the smallest key value. aTree[0] is unused. +** +** Example: +** +** aReadr[0] -> Banana +** aReadr[1] -> Feijoa +** aReadr[2] -> Elderberry +** aReadr[3] -> Currant +** aReadr[4] -> Grapefruit +** aReadr[5] -> Apple +** aReadr[6] -> Durian +** aReadr[7] -> EOF +** +** aTree[] = { X, 5 0, 5 0, 3, 5, 6 } +** +** The current element is "Apple" (the value of the key indicated by +** PmaReader 5). When the Next() operation is invoked, PmaReader 5 will +** be advanced to the next key in its segment. Say the next key is +** "Eggplant": +** +** aReadr[5] -> Eggplant +** +** The contents of aTree[] are updated first by comparing the new PmaReader +** 5 key to the current key of PmaReader 4 (still "Grapefruit"). The PmaReader +** 5 value is still smaller, so aTree[6] is set to 5. And so on up the tree. +** The value of PmaReader 6 - "Durian" - is now smaller than that of PmaReader +** 5, so aTree[3] is set to 6. Key 0 is smaller than key 6 (Bananafile2. And instead of using a +** background thread to prepare data for the PmaReader, with a single +** threaded IncrMerger the allocate part of pTask->file2 is "refilled" with +** keys from pMerger by the calling thread whenever the PmaReader runs out +** of data. +*/ +struct IncrMerger { + SortSubtask *pTask; /* Task that owns this merger */ + MergeEngine *pMerger; /* Merge engine thread reads data from */ + i64 iStartOff; /* Offset to start writing file at */ + int mxSz; /* Maximum bytes of data to store */ + int bEof; /* Set to true when merge is finished */ + int bUseThread; /* True to use a bg thread for this object */ + SorterFile aFile[2]; /* aFile[0] for reading, [1] for writing */ +}; + +/* +** An instance of this object is used for writing a PMA. +** +** The PMA is written one record at a time. Each record is of an arbitrary +** size. But I/O is more efficient if it occurs in page-sized blocks where +** each block is aligned on a page boundary. This object caches writes to +** the PMA so that aligned, page-size blocks are written. +*/ +struct PmaWriter { + int eFWErr; /* Non-zero if in an error state */ + u8 *aBuffer; /* Pointer to write buffer */ + int nBuffer; /* Size of write buffer in bytes */ + int iBufStart; /* First byte of buffer to write */ + int iBufEnd; /* Last byte of buffer to write */ + i64 iWriteOff; /* Offset of start of buffer in file */ + sqlite3_file *pFd; /* File handle to write to */ +}; + +/* +** This object is the header on a single record while that record is being +** held in memory and prior to being written out as part of a PMA. +** +** How the linked list is connected depends on how memory is being managed +** by this module. If using a separate allocation for each in-memory record +** (VdbeSorter.list.aMemory==0), then the list is always connected using the +** SorterRecord.u.pNext pointers. +** +** Or, if using the single large allocation method (VdbeSorter.list.aMemory!=0), +** then while records are being accumulated the list is linked using the +** SorterRecord.u.iNext offset. This is because the aMemory[] array may +** be sqlite3Realloc()ed while records are being accumulated. Once the VM +** has finished passing records to the sorter, or when the in-memory buffer +** is full, the list is sorted. As part of the sorting process, it is +** converted to use the SorterRecord.u.pNext pointers. See function +** vdbeSorterSort() for details. +*/ +struct SorterRecord { + int nVal; /* Size of the record in bytes */ + union { + SorterRecord *pNext; /* Pointer to next record in list */ + int iNext; /* Offset within aMemory of next record */ + } u; + /* The data for the record immediately follows this header */ +}; + +/* Return a pointer to the buffer containing the record data for SorterRecord +** object p. Should be used as if: +** +** void *SRVAL(SorterRecord *p) { return (void*)&p[1]; } +*/ +#define SRVAL(p) ((void*)((SorterRecord*)(p) + 1)) + + +/* Maximum number of PMAs that a single MergeEngine can merge */ +#define SORTER_MAX_MERGE_COUNT 16 + +static int vdbeIncrSwap(IncrMerger*); +static void vdbeIncrFree(IncrMerger *); + +/* +** Free all memory belonging to the PmaReader object passed as the +** argument. All structure fields are set to zero before returning. +*/ +static void vdbePmaReaderClear(PmaReader *pReadr){ + sqlite3_free(pReadr->aAlloc); + sqlite3_free(pReadr->aBuffer); + if( pReadr->aMap ) sqlite3OsUnfetch(pReadr->pFd, 0, pReadr->aMap); + vdbeIncrFree(pReadr->pIncr); + memset(pReadr, 0, sizeof(PmaReader)); +} + +/* +** Read the next nByte bytes of data from the PMA p. +** If successful, set *ppOut to point to a buffer containing the data +** and return SQLITE_OK. Otherwise, if an error occurs, return an SQLite +** error code. +** +** The buffer returned in *ppOut is only valid until the +** next call to this function. +*/ +static int vdbePmaReadBlob( + PmaReader *p, /* PmaReader from which to take the blob */ + int nByte, /* Bytes of data to read */ + u8 **ppOut /* OUT: Pointer to buffer containing data */ +){ + int iBuf; /* Offset within buffer to read from */ + int nAvail; /* Bytes of data available in buffer */ + + if( p->aMap ){ + *ppOut = &p->aMap[p->iReadOff]; + p->iReadOff += nByte; + return SQLITE_OK; + } + + assert( p->aBuffer ); + + /* If there is no more data to be read from the buffer, read the next + ** p->nBuffer bytes of data from the file into it. Or, if there are less + ** than p->nBuffer bytes remaining in the PMA, read all remaining data. */ + iBuf = p->iReadOff % p->nBuffer; + if( iBuf==0 ){ + int nRead; /* Bytes to read from disk */ + int rc; /* sqlite3OsRead() return code */ + + /* Determine how many bytes of data to read. */ + if( (p->iEof - p->iReadOff) > (i64)p->nBuffer ){ + nRead = p->nBuffer; + }else{ + nRead = (int)(p->iEof - p->iReadOff); + } + assert( nRead>0 ); + + /* Readr data from the file. Return early if an error occurs. */ + rc = sqlite3OsRead(p->pFd, p->aBuffer, nRead, p->iReadOff); + assert( rc!=SQLITE_IOERR_SHORT_READ ); + if( rc!=SQLITE_OK ) return rc; + } + nAvail = p->nBuffer - iBuf; + + if( nByte<=nAvail ){ + /* The requested data is available in the in-memory buffer. In this + ** case there is no need to make a copy of the data, just return a + ** pointer into the buffer to the caller. */ + *ppOut = &p->aBuffer[iBuf]; + p->iReadOff += nByte; + }else{ + /* The requested data is not all available in the in-memory buffer. + ** In this case, allocate space at p->aAlloc[] to copy the requested + ** range into. Then return a copy of pointer p->aAlloc to the caller. */ + int nRem; /* Bytes remaining to copy */ + + /* Extend the p->aAlloc[] allocation if required. */ + if( p->nAllocnAlloc); + while( nByte>nNew ) nNew = nNew*2; + aNew = sqlite3Realloc(p->aAlloc, nNew); + if( !aNew ) return SQLITE_NOMEM_BKPT; + p->nAlloc = nNew; + p->aAlloc = aNew; + } + + /* Copy as much data as is available in the buffer into the start of + ** p->aAlloc[]. */ + memcpy(p->aAlloc, &p->aBuffer[iBuf], nAvail); + p->iReadOff += nAvail; + nRem = nByte - nAvail; + + /* The following loop copies up to p->nBuffer bytes per iteration into + ** the p->aAlloc[] buffer. */ + while( nRem>0 ){ + int rc; /* vdbePmaReadBlob() return code */ + int nCopy; /* Number of bytes to copy */ + u8 *aNext; /* Pointer to buffer to copy data from */ + + nCopy = nRem; + if( nRem>p->nBuffer ) nCopy = p->nBuffer; + rc = vdbePmaReadBlob(p, nCopy, &aNext); + if( rc!=SQLITE_OK ) return rc; + assert( aNext!=p->aAlloc ); + memcpy(&p->aAlloc[nByte - nRem], aNext, nCopy); + nRem -= nCopy; + } + + *ppOut = p->aAlloc; + } + + return SQLITE_OK; +} + +/* +** Read a varint from the stream of data accessed by p. Set *pnOut to +** the value read. +*/ +static int vdbePmaReadVarint(PmaReader *p, u64 *pnOut){ + int iBuf; + + if( p->aMap ){ + p->iReadOff += sqlite3GetVarint(&p->aMap[p->iReadOff], pnOut); + }else{ + iBuf = p->iReadOff % p->nBuffer; + if( iBuf && (p->nBuffer-iBuf)>=9 ){ + p->iReadOff += sqlite3GetVarint(&p->aBuffer[iBuf], pnOut); + }else{ + u8 aVarint[16], *a; + int i = 0, rc; + do{ + rc = vdbePmaReadBlob(p, 1, &a); + if( rc ) return rc; + aVarint[(i++)&0xf] = a[0]; + }while( (a[0]&0x80)!=0 ); + sqlite3GetVarint(aVarint, pnOut); + } + } + + return SQLITE_OK; +} + +/* +** Attempt to memory map file pFile. If successful, set *pp to point to the +** new mapping and return SQLITE_OK. If the mapping is not attempted +** (because the file is too large or the VFS layer is configured not to use +** mmap), return SQLITE_OK and set *pp to NULL. +** +** Or, if an error occurs, return an SQLite error code. The final value of +** *pp is undefined in this case. +*/ +static int vdbeSorterMapFile(SortSubtask *pTask, SorterFile *pFile, u8 **pp){ + int rc = SQLITE_OK; + if( pFile->iEof<=(i64)(pTask->pSorter->db->nMaxSorterMmap) ){ + sqlite3_file *pFd = pFile->pFd; + if( pFd->pMethods->iVersion>=3 ){ + rc = sqlite3OsFetch(pFd, 0, (int)pFile->iEof, (void**)pp); + testcase( rc!=SQLITE_OK ); + } + } + return rc; +} + +/* +** Attach PmaReader pReadr to file pFile (if it is not already attached to +** that file) and seek it to offset iOff within the file. Return SQLITE_OK +** if successful, or an SQLite error code if an error occurs. +*/ +static int vdbePmaReaderSeek( + SortSubtask *pTask, /* Task context */ + PmaReader *pReadr, /* Reader whose cursor is to be moved */ + SorterFile *pFile, /* Sorter file to read from */ + i64 iOff /* Offset in pFile */ +){ + int rc = SQLITE_OK; + + assert( pReadr->pIncr==0 || pReadr->pIncr->bEof==0 ); + + if( sqlite3FaultSim(201) ) return SQLITE_IOERR_READ; + if( pReadr->aMap ){ + sqlite3OsUnfetch(pReadr->pFd, 0, pReadr->aMap); + pReadr->aMap = 0; + } + pReadr->iReadOff = iOff; + pReadr->iEof = pFile->iEof; + pReadr->pFd = pFile->pFd; + + rc = vdbeSorterMapFile(pTask, pFile, &pReadr->aMap); + if( rc==SQLITE_OK && pReadr->aMap==0 ){ + int pgsz = pTask->pSorter->pgsz; + int iBuf = pReadr->iReadOff % pgsz; + if( pReadr->aBuffer==0 ){ + pReadr->aBuffer = (u8*)sqlite3Malloc(pgsz); + if( pReadr->aBuffer==0 ) rc = SQLITE_NOMEM_BKPT; + pReadr->nBuffer = pgsz; + } + if( rc==SQLITE_OK && iBuf ){ + int nRead = pgsz - iBuf; + if( (pReadr->iReadOff + nRead) > pReadr->iEof ){ + nRead = (int)(pReadr->iEof - pReadr->iReadOff); + } + rc = sqlite3OsRead( + pReadr->pFd, &pReadr->aBuffer[iBuf], nRead, pReadr->iReadOff + ); + testcase( rc!=SQLITE_OK ); + } + } + + return rc; +} + +/* +** Advance PmaReader pReadr to the next key in its PMA. Return SQLITE_OK if +** no error occurs, or an SQLite error code if one does. +*/ +static int vdbePmaReaderNext(PmaReader *pReadr){ + int rc = SQLITE_OK; /* Return Code */ + u64 nRec = 0; /* Size of record in bytes */ + + + if( pReadr->iReadOff>=pReadr->iEof ){ + IncrMerger *pIncr = pReadr->pIncr; + int bEof = 1; + if( pIncr ){ + rc = vdbeIncrSwap(pIncr); + if( rc==SQLITE_OK && pIncr->bEof==0 ){ + rc = vdbePmaReaderSeek( + pIncr->pTask, pReadr, &pIncr->aFile[0], pIncr->iStartOff + ); + bEof = 0; + } + } + + if( bEof ){ + /* This is an EOF condition */ + vdbePmaReaderClear(pReadr); + testcase( rc!=SQLITE_OK ); + return rc; + } + } + + if( rc==SQLITE_OK ){ + rc = vdbePmaReadVarint(pReadr, &nRec); + } + if( rc==SQLITE_OK ){ + pReadr->nKey = (int)nRec; + rc = vdbePmaReadBlob(pReadr, (int)nRec, &pReadr->aKey); + testcase( rc!=SQLITE_OK ); + } + + return rc; +} + +/* +** Initialize PmaReader pReadr to scan through the PMA stored in file pFile +** starting at offset iStart and ending at offset iEof-1. This function +** leaves the PmaReader pointing to the first key in the PMA (or EOF if the +** PMA is empty). +** +** If the pnByte parameter is NULL, then it is assumed that the file +** contains a single PMA, and that that PMA omits the initial length varint. +*/ +static int vdbePmaReaderInit( + SortSubtask *pTask, /* Task context */ + SorterFile *pFile, /* Sorter file to read from */ + i64 iStart, /* Start offset in pFile */ + PmaReader *pReadr, /* PmaReader to populate */ + i64 *pnByte /* IN/OUT: Increment this value by PMA size */ +){ + int rc; + + assert( pFile->iEof>iStart ); + assert( pReadr->aAlloc==0 && pReadr->nAlloc==0 ); + assert( pReadr->aBuffer==0 ); + assert( pReadr->aMap==0 ); + + rc = vdbePmaReaderSeek(pTask, pReadr, pFile, iStart); + if( rc==SQLITE_OK ){ + u64 nByte = 0; /* Size of PMA in bytes */ + rc = vdbePmaReadVarint(pReadr, &nByte); + pReadr->iEof = pReadr->iReadOff + nByte; + *pnByte += nByte; + } + + if( rc==SQLITE_OK ){ + rc = vdbePmaReaderNext(pReadr); + } + return rc; +} + +/* +** A version of vdbeSorterCompare() that assumes that it has already been +** determined that the first field of key1 is equal to the first field of +** key2. +*/ +static int vdbeSorterCompareTail( + SortSubtask *pTask, /* Subtask context (for pKeyInfo) */ + int *pbKey2Cached, /* True if pTask->pUnpacked is pKey2 */ + const void *pKey1, int nKey1, /* Left side of comparison */ + const void *pKey2, int nKey2 /* Right side of comparison */ +){ + UnpackedRecord *r2 = pTask->pUnpacked; + if( *pbKey2Cached==0 ){ + sqlite3VdbeRecordUnpack(pTask->pSorter->pKeyInfo, nKey2, pKey2, r2); + *pbKey2Cached = 1; + } + return sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, r2, 1); +} + +/* +** Compare key1 (buffer pKey1, size nKey1 bytes) with key2 (buffer pKey2, +** size nKey2 bytes). Use (pTask->pKeyInfo) for the collation sequences +** used by the comparison. Return the result of the comparison. +** +** If IN/OUT parameter *pbKey2Cached is true when this function is called, +** it is assumed that (pTask->pUnpacked) contains the unpacked version +** of key2. If it is false, (pTask->pUnpacked) is populated with the unpacked +** version of key2 and *pbKey2Cached set to true before returning. +** +** If an OOM error is encountered, (pTask->pUnpacked->error_rc) is set +** to SQLITE_NOMEM. +*/ +static int vdbeSorterCompare( + SortSubtask *pTask, /* Subtask context (for pKeyInfo) */ + int *pbKey2Cached, /* True if pTask->pUnpacked is pKey2 */ + const void *pKey1, int nKey1, /* Left side of comparison */ + const void *pKey2, int nKey2 /* Right side of comparison */ +){ + UnpackedRecord *r2 = pTask->pUnpacked; + if( !*pbKey2Cached ){ + sqlite3VdbeRecordUnpack(pTask->pSorter->pKeyInfo, nKey2, pKey2, r2); + *pbKey2Cached = 1; + } + return sqlite3VdbeRecordCompare(nKey1, pKey1, r2); +} + +/* +** A specially optimized version of vdbeSorterCompare() that assumes that +** the first field of each key is a TEXT value and that the collation +** sequence to compare them with is BINARY. +*/ +static int vdbeSorterCompareText( + SortSubtask *pTask, /* Subtask context (for pKeyInfo) */ + int *pbKey2Cached, /* True if pTask->pUnpacked is pKey2 */ + const void *pKey1, int nKey1, /* Left side of comparison */ + const void *pKey2, int nKey2 /* Right side of comparison */ +){ + const u8 * const p1 = (const u8 * const)pKey1; + const u8 * const p2 = (const u8 * const)pKey2; + const u8 * const v1 = &p1[ p1[0] ]; /* Pointer to value 1 */ + const u8 * const v2 = &p2[ p2[0] ]; /* Pointer to value 2 */ + + int n1; + int n2; + int res; + + getVarint32NR(&p1[1], n1); + getVarint32NR(&p2[1], n2); + res = memcmp(v1, v2, (MIN(n1, n2) - 13)/2); + if( res==0 ){ + res = n1 - n2; + } + + if( res==0 ){ + if( pTask->pSorter->pKeyInfo->nKeyField>1 ){ + res = vdbeSorterCompareTail( + pTask, pbKey2Cached, pKey1, nKey1, pKey2, nKey2 + ); + } + }else{ + assert( !(pTask->pSorter->pKeyInfo->aSortFlags[0]&KEYINFO_ORDER_BIGNULL) ); + if( pTask->pSorter->pKeyInfo->aSortFlags[0] ){ + res = res * -1; + } + } + + return res; +} + +/* +** A specially optimized version of vdbeSorterCompare() that assumes that +** the first field of each key is an INTEGER value. +*/ +static int vdbeSorterCompareInt( + SortSubtask *pTask, /* Subtask context (for pKeyInfo) */ + int *pbKey2Cached, /* True if pTask->pUnpacked is pKey2 */ + const void *pKey1, int nKey1, /* Left side of comparison */ + const void *pKey2, int nKey2 /* Right side of comparison */ +){ + const u8 * const p1 = (const u8 * const)pKey1; + const u8 * const p2 = (const u8 * const)pKey2; + const int s1 = p1[1]; /* Left hand serial type */ + const int s2 = p2[1]; /* Right hand serial type */ + const u8 * const v1 = &p1[ p1[0] ]; /* Pointer to value 1 */ + const u8 * const v2 = &p2[ p2[0] ]; /* Pointer to value 2 */ + int res; /* Return value */ + + assert( (s1>0 && s1<7) || s1==8 || s1==9 ); + assert( (s2>0 && s2<7) || s2==8 || s2==9 ); + + if( s1==s2 ){ + /* The two values have the same sign. Compare using memcmp(). */ + static const u8 aLen[] = {0, 1, 2, 3, 4, 6, 8, 0, 0, 0 }; + const u8 n = aLen[s1]; + int i; + res = 0; + for(i=0; i7 && s2>7 ){ + res = s1 - s2; + }else{ + if( s2>7 ){ + res = +1; + }else if( s1>7 ){ + res = -1; + }else{ + res = s1 - s2; + } + assert( res!=0 ); + + if( res>0 ){ + if( *v1 & 0x80 ) res = -1; + }else{ + if( *v2 & 0x80 ) res = +1; + } + } + + if( res==0 ){ + if( pTask->pSorter->pKeyInfo->nKeyField>1 ){ + res = vdbeSorterCompareTail( + pTask, pbKey2Cached, pKey1, nKey1, pKey2, nKey2 + ); + } + }else if( pTask->pSorter->pKeyInfo->aSortFlags[0] ){ + assert( !(pTask->pSorter->pKeyInfo->aSortFlags[0]&KEYINFO_ORDER_BIGNULL) ); + res = res * -1; + } + + return res; +} + +/* +** Initialize the temporary index cursor just opened as a sorter cursor. +** +** Usually, the sorter module uses the value of (pCsr->pKeyInfo->nKeyField) +** to determine the number of fields that should be compared from the +** records being sorted. However, if the value passed as argument nField +** is non-zero and the sorter is able to guarantee a stable sort, nField +** is used instead. This is used when sorting records for a CREATE INDEX +** statement. In this case, keys are always delivered to the sorter in +** order of the primary key, which happens to be make up the final part +** of the records being sorted. So if the sort is stable, there is never +** any reason to compare PK fields and they can be ignored for a small +** performance boost. +** +** The sorter can guarantee a stable sort when running in single-threaded +** mode, but not in multi-threaded mode. +** +** SQLITE_OK is returned if successful, or an SQLite error code otherwise. +*/ +SQLITE_PRIVATE int sqlite3VdbeSorterInit( + sqlite3 *db, /* Database connection (for malloc()) */ + int nField, /* Number of key fields in each record */ + VdbeCursor *pCsr /* Cursor that holds the new sorter */ +){ + int pgsz; /* Page size of main database */ + int i; /* Used to iterate through aTask[] */ + VdbeSorter *pSorter; /* The new sorter */ + KeyInfo *pKeyInfo; /* Copy of pCsr->pKeyInfo with db==0 */ + int szKeyInfo; /* Size of pCsr->pKeyInfo in bytes */ + int sz; /* Size of pSorter in bytes */ + int rc = SQLITE_OK; +#if SQLITE_MAX_WORKER_THREADS==0 +# define nWorker 0 +#else + int nWorker; +#endif + + /* Initialize the upper limit on the number of worker threads */ +#if SQLITE_MAX_WORKER_THREADS>0 + if( sqlite3TempInMemory(db) || sqlite3GlobalConfig.bCoreMutex==0 ){ + nWorker = 0; + }else{ + nWorker = db->aLimit[SQLITE_LIMIT_WORKER_THREADS]; + } +#endif + + /* Do not allow the total number of threads (main thread + all workers) + ** to exceed the maximum merge count */ +#if SQLITE_MAX_WORKER_THREADS>=SORTER_MAX_MERGE_COUNT + if( nWorker>=SORTER_MAX_MERGE_COUNT ){ + nWorker = SORTER_MAX_MERGE_COUNT-1; + } +#endif + + assert( pCsr->pKeyInfo ); + assert( !pCsr->isEphemeral ); + assert( pCsr->eCurType==CURTYPE_SORTER ); + szKeyInfo = sizeof(KeyInfo) + (pCsr->pKeyInfo->nKeyField-1)*sizeof(CollSeq*); + sz = sizeof(VdbeSorter) + nWorker * sizeof(SortSubtask); + + pSorter = (VdbeSorter*)sqlite3DbMallocZero(db, sz + szKeyInfo); + pCsr->uc.pSorter = pSorter; + if( pSorter==0 ){ + rc = SQLITE_NOMEM_BKPT; + }else{ + Btree *pBt = db->aDb[0].pBt; + pSorter->pKeyInfo = pKeyInfo = (KeyInfo*)((u8*)pSorter + sz); + memcpy(pKeyInfo, pCsr->pKeyInfo, szKeyInfo); + pKeyInfo->db = 0; + if( nField && nWorker==0 ){ + pKeyInfo->nKeyField = nField; + } + sqlite3BtreeEnter(pBt); + pSorter->pgsz = pgsz = sqlite3BtreeGetPageSize(pBt); + sqlite3BtreeLeave(pBt); + pSorter->nTask = nWorker + 1; + pSorter->iPrev = (u8)(nWorker - 1); + pSorter->bUseThreads = (pSorter->nTask>1); + pSorter->db = db; + for(i=0; inTask; i++){ + SortSubtask *pTask = &pSorter->aTask[i]; + pTask->pSorter = pSorter; + } + + if( !sqlite3TempInMemory(db) ){ + i64 mxCache; /* Cache size in bytes*/ + u32 szPma = sqlite3GlobalConfig.szPma; + pSorter->mnPmaSize = szPma * pgsz; + + mxCache = db->aDb[0].pSchema->cache_size; + if( mxCache<0 ){ + /* A negative cache-size value C indicates that the cache is abs(C) + ** KiB in size. */ + mxCache = mxCache * -1024; + }else{ + mxCache = mxCache * pgsz; + } + mxCache = MIN(mxCache, SQLITE_MAX_PMASZ); + pSorter->mxPmaSize = MAX(pSorter->mnPmaSize, (int)mxCache); + + /* Avoid large memory allocations if the application has requested + ** SQLITE_CONFIG_SMALL_MALLOC. */ + if( sqlite3GlobalConfig.bSmallMalloc==0 ){ + assert( pSorter->iMemory==0 ); + pSorter->nMemory = pgsz; + pSorter->list.aMemory = (u8*)sqlite3Malloc(pgsz); + if( !pSorter->list.aMemory ) rc = SQLITE_NOMEM_BKPT; + } + } + + if( pKeyInfo->nAllField<13 + && (pKeyInfo->aColl[0]==0 || pKeyInfo->aColl[0]==db->pDfltColl) + && (pKeyInfo->aSortFlags[0] & KEYINFO_ORDER_BIGNULL)==0 + ){ + pSorter->typeMask = SORTER_TYPE_INTEGER | SORTER_TYPE_TEXT; + } + } + + return rc; +} +#undef nWorker /* Defined at the top of this function */ + +/* +** Free the list of sorted records starting at pRecord. +*/ +static void vdbeSorterRecordFree(sqlite3 *db, SorterRecord *pRecord){ + SorterRecord *p; + SorterRecord *pNext; + for(p=pRecord; p; p=pNext){ + pNext = p->u.pNext; + sqlite3DbFree(db, p); + } +} + +/* +** Free all resources owned by the object indicated by argument pTask. All +** fields of *pTask are zeroed before returning. +*/ +static void vdbeSortSubtaskCleanup(sqlite3 *db, SortSubtask *pTask){ + sqlite3DbFree(db, pTask->pUnpacked); +#if SQLITE_MAX_WORKER_THREADS>0 + /* pTask->list.aMemory can only be non-zero if it was handed memory + ** from the main thread. That only occurs SQLITE_MAX_WORKER_THREADS>0 */ + if( pTask->list.aMemory ){ + sqlite3_free(pTask->list.aMemory); + }else +#endif + { + assert( pTask->list.aMemory==0 ); + vdbeSorterRecordFree(0, pTask->list.pList); + } + if( pTask->file.pFd ){ + sqlite3OsCloseFree(pTask->file.pFd); + } + if( pTask->file2.pFd ){ + sqlite3OsCloseFree(pTask->file2.pFd); + } + memset(pTask, 0, sizeof(SortSubtask)); +} + +#ifdef SQLITE_DEBUG_SORTER_THREADS +static void vdbeSorterWorkDebug(SortSubtask *pTask, const char *zEvent){ + i64 t; + int iTask = (pTask - pTask->pSorter->aTask); + sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t); + fprintf(stderr, "%lld:%d %s\n", t, iTask, zEvent); +} +static void vdbeSorterRewindDebug(const char *zEvent){ + i64 t = 0; + sqlite3_vfs *pVfs = sqlite3_vfs_find(0); + if( ALWAYS(pVfs) ) sqlite3OsCurrentTimeInt64(pVfs, &t); + fprintf(stderr, "%lld:X %s\n", t, zEvent); +} +static void vdbeSorterPopulateDebug( + SortSubtask *pTask, + const char *zEvent +){ + i64 t; + int iTask = (pTask - pTask->pSorter->aTask); + sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t); + fprintf(stderr, "%lld:bg%d %s\n", t, iTask, zEvent); +} +static void vdbeSorterBlockDebug( + SortSubtask *pTask, + int bBlocked, + const char *zEvent +){ + if( bBlocked ){ + i64 t; + sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t); + fprintf(stderr, "%lld:main %s\n", t, zEvent); + } +} +#else +# define vdbeSorterWorkDebug(x,y) +# define vdbeSorterRewindDebug(y) +# define vdbeSorterPopulateDebug(x,y) +# define vdbeSorterBlockDebug(x,y,z) +#endif + +#if SQLITE_MAX_WORKER_THREADS>0 +/* +** Join thread pTask->thread. +*/ +static int vdbeSorterJoinThread(SortSubtask *pTask){ + int rc = SQLITE_OK; + if( pTask->pThread ){ +#ifdef SQLITE_DEBUG_SORTER_THREADS + int bDone = pTask->bDone; +#endif + void *pRet = SQLITE_INT_TO_PTR(SQLITE_ERROR); + vdbeSorterBlockDebug(pTask, !bDone, "enter"); + (void)sqlite3ThreadJoin(pTask->pThread, &pRet); + vdbeSorterBlockDebug(pTask, !bDone, "exit"); + rc = SQLITE_PTR_TO_INT(pRet); + assert( pTask->bDone==1 ); + pTask->bDone = 0; + pTask->pThread = 0; + } + return rc; +} + +/* +** Launch a background thread to run xTask(pIn). +*/ +static int vdbeSorterCreateThread( + SortSubtask *pTask, /* Thread will use this task object */ + void *(*xTask)(void*), /* Routine to run in a separate thread */ + void *pIn /* Argument passed into xTask() */ +){ + assert( pTask->pThread==0 && pTask->bDone==0 ); + return sqlite3ThreadCreate(&pTask->pThread, xTask, pIn); +} + +/* +** Join all outstanding threads launched by SorterWrite() to create +** level-0 PMAs. +*/ +static int vdbeSorterJoinAll(VdbeSorter *pSorter, int rcin){ + int rc = rcin; + int i; + + /* This function is always called by the main user thread. + ** + ** If this function is being called after SorterRewind() has been called, + ** it is possible that thread pSorter->aTask[pSorter->nTask-1].pThread + ** is currently attempt to join one of the other threads. To avoid a race + ** condition where this thread also attempts to join the same object, join + ** thread pSorter->aTask[pSorter->nTask-1].pThread first. */ + for(i=pSorter->nTask-1; i>=0; i--){ + SortSubtask *pTask = &pSorter->aTask[i]; + int rc2 = vdbeSorterJoinThread(pTask); + if( rc==SQLITE_OK ) rc = rc2; + } + return rc; +} +#else +# define vdbeSorterJoinAll(x,rcin) (rcin) +# define vdbeSorterJoinThread(pTask) SQLITE_OK +#endif + +/* +** Allocate a new MergeEngine object capable of handling up to +** nReader PmaReader inputs. +** +** nReader is automatically rounded up to the next power of two. +** nReader may not exceed SORTER_MAX_MERGE_COUNT even after rounding up. +*/ +static MergeEngine *vdbeMergeEngineNew(int nReader){ + int N = 2; /* Smallest power of two >= nReader */ + int nByte; /* Total bytes of space to allocate */ + MergeEngine *pNew; /* Pointer to allocated object to return */ + + assert( nReader<=SORTER_MAX_MERGE_COUNT ); + + while( NnTree = N; + pNew->pTask = 0; + pNew->aReadr = (PmaReader*)&pNew[1]; + pNew->aTree = (int*)&pNew->aReadr[N]; + } + return pNew; +} + +/* +** Free the MergeEngine object passed as the only argument. +*/ +static void vdbeMergeEngineFree(MergeEngine *pMerger){ + int i; + if( pMerger ){ + for(i=0; inTree; i++){ + vdbePmaReaderClear(&pMerger->aReadr[i]); + } + } + sqlite3_free(pMerger); +} + +/* +** Free all resources associated with the IncrMerger object indicated by +** the first argument. +*/ +static void vdbeIncrFree(IncrMerger *pIncr){ + if( pIncr ){ +#if SQLITE_MAX_WORKER_THREADS>0 + if( pIncr->bUseThread ){ + vdbeSorterJoinThread(pIncr->pTask); + if( pIncr->aFile[0].pFd ) sqlite3OsCloseFree(pIncr->aFile[0].pFd); + if( pIncr->aFile[1].pFd ) sqlite3OsCloseFree(pIncr->aFile[1].pFd); + } +#endif + vdbeMergeEngineFree(pIncr->pMerger); + sqlite3_free(pIncr); + } +} + +/* +** Reset a sorting cursor back to its original empty state. +*/ +SQLITE_PRIVATE void sqlite3VdbeSorterReset(sqlite3 *db, VdbeSorter *pSorter){ + int i; + (void)vdbeSorterJoinAll(pSorter, SQLITE_OK); + assert( pSorter->bUseThreads || pSorter->pReader==0 ); +#if SQLITE_MAX_WORKER_THREADS>0 + if( pSorter->pReader ){ + vdbePmaReaderClear(pSorter->pReader); + sqlite3DbFree(db, pSorter->pReader); + pSorter->pReader = 0; + } +#endif + vdbeMergeEngineFree(pSorter->pMerger); + pSorter->pMerger = 0; + for(i=0; inTask; i++){ + SortSubtask *pTask = &pSorter->aTask[i]; + vdbeSortSubtaskCleanup(db, pTask); + pTask->pSorter = pSorter; + } + if( pSorter->list.aMemory==0 ){ + vdbeSorterRecordFree(0, pSorter->list.pList); + } + pSorter->list.pList = 0; + pSorter->list.szPMA = 0; + pSorter->bUsePMA = 0; + pSorter->iMemory = 0; + pSorter->mxKeysize = 0; + sqlite3DbFree(db, pSorter->pUnpacked); + pSorter->pUnpacked = 0; +} + +/* +** Free any cursor components allocated by sqlite3VdbeSorterXXX routines. +*/ +SQLITE_PRIVATE void sqlite3VdbeSorterClose(sqlite3 *db, VdbeCursor *pCsr){ + VdbeSorter *pSorter; + assert( pCsr->eCurType==CURTYPE_SORTER ); + pSorter = pCsr->uc.pSorter; + if( pSorter ){ + sqlite3VdbeSorterReset(db, pSorter); + sqlite3_free(pSorter->list.aMemory); + sqlite3DbFree(db, pSorter); + pCsr->uc.pSorter = 0; + } +} + +#if SQLITE_MAX_MMAP_SIZE>0 +/* +** The first argument is a file-handle open on a temporary file. The file +** is guaranteed to be nByte bytes or smaller in size. This function +** attempts to extend the file to nByte bytes in size and to ensure that +** the VFS has memory mapped it. +** +** Whether or not the file does end up memory mapped of course depends on +** the specific VFS implementation. +*/ +static void vdbeSorterExtendFile(sqlite3 *db, sqlite3_file *pFd, i64 nByte){ + if( nByte<=(i64)(db->nMaxSorterMmap) && pFd->pMethods->iVersion>=3 ){ + void *p = 0; + int chunksize = 4*1024; + sqlite3OsFileControlHint(pFd, SQLITE_FCNTL_CHUNK_SIZE, &chunksize); + sqlite3OsFileControlHint(pFd, SQLITE_FCNTL_SIZE_HINT, &nByte); + sqlite3OsFetch(pFd, 0, (int)nByte, &p); + if( p ) sqlite3OsUnfetch(pFd, 0, p); + } +} +#else +# define vdbeSorterExtendFile(x,y,z) +#endif + +/* +** Allocate space for a file-handle and open a temporary file. If successful, +** set *ppFd to point to the malloc'd file-handle and return SQLITE_OK. +** Otherwise, set *ppFd to 0 and return an SQLite error code. +*/ +static int vdbeSorterOpenTempFile( + sqlite3 *db, /* Database handle doing sort */ + i64 nExtend, /* Attempt to extend file to this size */ + sqlite3_file **ppFd +){ + int rc; + if( sqlite3FaultSim(202) ) return SQLITE_IOERR_ACCESS; + rc = sqlite3OsOpenMalloc(db->pVfs, 0, ppFd, + SQLITE_OPEN_TEMP_JOURNAL | + SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | + SQLITE_OPEN_EXCLUSIVE | SQLITE_OPEN_DELETEONCLOSE, &rc + ); + if( rc==SQLITE_OK ){ + i64 max = SQLITE_MAX_MMAP_SIZE; + sqlite3OsFileControlHint(*ppFd, SQLITE_FCNTL_MMAP_SIZE, (void*)&max); + if( nExtend>0 ){ + vdbeSorterExtendFile(db, *ppFd, nExtend); + } + } + return rc; +} + +/* +** If it has not already been allocated, allocate the UnpackedRecord +** structure at pTask->pUnpacked. Return SQLITE_OK if successful (or +** if no allocation was required), or SQLITE_NOMEM otherwise. +*/ +static int vdbeSortAllocUnpacked(SortSubtask *pTask){ + if( pTask->pUnpacked==0 ){ + pTask->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pTask->pSorter->pKeyInfo); + if( pTask->pUnpacked==0 ) return SQLITE_NOMEM_BKPT; + pTask->pUnpacked->nField = pTask->pSorter->pKeyInfo->nKeyField; + pTask->pUnpacked->errCode = 0; + } + return SQLITE_OK; +} + + +/* +** Merge the two sorted lists p1 and p2 into a single list. +*/ +static SorterRecord *vdbeSorterMerge( + SortSubtask *pTask, /* Calling thread context */ + SorterRecord *p1, /* First list to merge */ + SorterRecord *p2 /* Second list to merge */ +){ + SorterRecord *pFinal = 0; + SorterRecord **pp = &pFinal; + int bCached = 0; + + assert( p1!=0 && p2!=0 ); + for(;;){ + int res; + res = pTask->xCompare( + pTask, &bCached, SRVAL(p1), p1->nVal, SRVAL(p2), p2->nVal + ); + + if( res<=0 ){ + *pp = p1; + pp = &p1->u.pNext; + p1 = p1->u.pNext; + if( p1==0 ){ + *pp = p2; + break; + } + }else{ + *pp = p2; + pp = &p2->u.pNext; + p2 = p2->u.pNext; + bCached = 0; + if( p2==0 ){ + *pp = p1; + break; + } + } + } + return pFinal; +} + +/* +** Return the SorterCompare function to compare values collected by the +** sorter object passed as the only argument. +*/ +static SorterCompare vdbeSorterGetCompare(VdbeSorter *p){ + if( p->typeMask==SORTER_TYPE_INTEGER ){ + return vdbeSorterCompareInt; + }else if( p->typeMask==SORTER_TYPE_TEXT ){ + return vdbeSorterCompareText; + } + return vdbeSorterCompare; +} + +/* +** Sort the linked list of records headed at pTask->pList. Return +** SQLITE_OK if successful, or an SQLite error code (i.e. SQLITE_NOMEM) if +** an error occurs. +*/ +static int vdbeSorterSort(SortSubtask *pTask, SorterList *pList){ + int i; + SorterRecord *p; + int rc; + SorterRecord *aSlot[64]; + + rc = vdbeSortAllocUnpacked(pTask); + if( rc!=SQLITE_OK ) return rc; + + p = pList->pList; + pTask->xCompare = vdbeSorterGetCompare(pTask->pSorter); + memset(aSlot, 0, sizeof(aSlot)); + + while( p ){ + SorterRecord *pNext; + if( pList->aMemory ){ + if( (u8*)p==pList->aMemory ){ + pNext = 0; + }else{ + assert( p->u.iNextaMemory) ); + pNext = (SorterRecord*)&pList->aMemory[p->u.iNext]; + } + }else{ + pNext = p->u.pNext; + } + + p->u.pNext = 0; + for(i=0; aSlot[i]; i++){ + p = vdbeSorterMerge(pTask, p, aSlot[i]); + aSlot[i] = 0; + } + aSlot[i] = p; + p = pNext; + } + + p = 0; + for(i=0; ipList = p; + + assert( pTask->pUnpacked->errCode==SQLITE_OK + || pTask->pUnpacked->errCode==SQLITE_NOMEM + ); + return pTask->pUnpacked->errCode; +} + +/* +** Initialize a PMA-writer object. +*/ +static void vdbePmaWriterInit( + sqlite3_file *pFd, /* File handle to write to */ + PmaWriter *p, /* Object to populate */ + int nBuf, /* Buffer size */ + i64 iStart /* Offset of pFd to begin writing at */ +){ + memset(p, 0, sizeof(PmaWriter)); + p->aBuffer = (u8*)sqlite3Malloc(nBuf); + if( !p->aBuffer ){ + p->eFWErr = SQLITE_NOMEM_BKPT; + }else{ + p->iBufEnd = p->iBufStart = (iStart % nBuf); + p->iWriteOff = iStart - p->iBufStart; + p->nBuffer = nBuf; + p->pFd = pFd; + } +} + +/* +** Write nData bytes of data to the PMA. Return SQLITE_OK +** if successful, or an SQLite error code if an error occurs. +*/ +static void vdbePmaWriteBlob(PmaWriter *p, u8 *pData, int nData){ + int nRem = nData; + while( nRem>0 && p->eFWErr==0 ){ + int nCopy = nRem; + if( nCopy>(p->nBuffer - p->iBufEnd) ){ + nCopy = p->nBuffer - p->iBufEnd; + } + + memcpy(&p->aBuffer[p->iBufEnd], &pData[nData-nRem], nCopy); + p->iBufEnd += nCopy; + if( p->iBufEnd==p->nBuffer ){ + p->eFWErr = sqlite3OsWrite(p->pFd, + &p->aBuffer[p->iBufStart], p->iBufEnd - p->iBufStart, + p->iWriteOff + p->iBufStart + ); + p->iBufStart = p->iBufEnd = 0; + p->iWriteOff += p->nBuffer; + } + assert( p->iBufEndnBuffer ); + + nRem -= nCopy; + } +} + +/* +** Flush any buffered data to disk and clean up the PMA-writer object. +** The results of using the PMA-writer after this call are undefined. +** Return SQLITE_OK if flushing the buffered data succeeds or is not +** required. Otherwise, return an SQLite error code. +** +** Before returning, set *piEof to the offset immediately following the +** last byte written to the file. +*/ +static int vdbePmaWriterFinish(PmaWriter *p, i64 *piEof){ + int rc; + if( p->eFWErr==0 && ALWAYS(p->aBuffer) && p->iBufEnd>p->iBufStart ){ + p->eFWErr = sqlite3OsWrite(p->pFd, + &p->aBuffer[p->iBufStart], p->iBufEnd - p->iBufStart, + p->iWriteOff + p->iBufStart + ); + } + *piEof = (p->iWriteOff + p->iBufEnd); + sqlite3_free(p->aBuffer); + rc = p->eFWErr; + memset(p, 0, sizeof(PmaWriter)); + return rc; +} + +/* +** Write value iVal encoded as a varint to the PMA. Return +** SQLITE_OK if successful, or an SQLite error code if an error occurs. +*/ +static void vdbePmaWriteVarint(PmaWriter *p, u64 iVal){ + int nByte; + u8 aByte[10]; + nByte = sqlite3PutVarint(aByte, iVal); + vdbePmaWriteBlob(p, aByte, nByte); +} + +/* +** Write the current contents of in-memory linked-list pList to a level-0 +** PMA in the temp file belonging to sub-task pTask. Return SQLITE_OK if +** successful, or an SQLite error code otherwise. +** +** The format of a PMA is: +** +** * A varint. This varint contains the total number of bytes of content +** in the PMA (not including the varint itself). +** +** * One or more records packed end-to-end in order of ascending keys. +** Each record consists of a varint followed by a blob of data (the +** key). The varint is the number of bytes in the blob of data. +*/ +static int vdbeSorterListToPMA(SortSubtask *pTask, SorterList *pList){ + sqlite3 *db = pTask->pSorter->db; + int rc = SQLITE_OK; /* Return code */ + PmaWriter writer; /* Object used to write to the file */ + +#ifdef SQLITE_DEBUG + /* Set iSz to the expected size of file pTask->file after writing the PMA. + ** This is used by an assert() statement at the end of this function. */ + i64 iSz = pList->szPMA + sqlite3VarintLen(pList->szPMA) + pTask->file.iEof; +#endif + + vdbeSorterWorkDebug(pTask, "enter"); + memset(&writer, 0, sizeof(PmaWriter)); + assert( pList->szPMA>0 ); + + /* If the first temporary PMA file has not been opened, open it now. */ + if( pTask->file.pFd==0 ){ + rc = vdbeSorterOpenTempFile(db, 0, &pTask->file.pFd); + assert( rc!=SQLITE_OK || pTask->file.pFd ); + assert( pTask->file.iEof==0 ); + assert( pTask->nPMA==0 ); + } + + /* Try to get the file to memory map */ + if( rc==SQLITE_OK ){ + vdbeSorterExtendFile(db, pTask->file.pFd, pTask->file.iEof+pList->szPMA+9); + } + + /* Sort the list */ + if( rc==SQLITE_OK ){ + rc = vdbeSorterSort(pTask, pList); + } + + if( rc==SQLITE_OK ){ + SorterRecord *p; + SorterRecord *pNext = 0; + + vdbePmaWriterInit(pTask->file.pFd, &writer, pTask->pSorter->pgsz, + pTask->file.iEof); + pTask->nPMA++; + vdbePmaWriteVarint(&writer, pList->szPMA); + for(p=pList->pList; p; p=pNext){ + pNext = p->u.pNext; + vdbePmaWriteVarint(&writer, p->nVal); + vdbePmaWriteBlob(&writer, SRVAL(p), p->nVal); + if( pList->aMemory==0 ) sqlite3_free(p); + } + pList->pList = p; + rc = vdbePmaWriterFinish(&writer, &pTask->file.iEof); + } + + vdbeSorterWorkDebug(pTask, "exit"); + assert( rc!=SQLITE_OK || pList->pList==0 ); + assert( rc!=SQLITE_OK || pTask->file.iEof==iSz ); + return rc; +} + +/* +** Advance the MergeEngine to its next entry. +** Set *pbEof to true there is no next entry because +** the MergeEngine has reached the end of all its inputs. +** +** Return SQLITE_OK if successful or an error code if an error occurs. +*/ +static int vdbeMergeEngineStep( + MergeEngine *pMerger, /* The merge engine to advance to the next row */ + int *pbEof /* Set TRUE at EOF. Set false for more content */ +){ + int rc; + int iPrev = pMerger->aTree[1];/* Index of PmaReader to advance */ + SortSubtask *pTask = pMerger->pTask; + + /* Advance the current PmaReader */ + rc = vdbePmaReaderNext(&pMerger->aReadr[iPrev]); + + /* Update contents of aTree[] */ + if( rc==SQLITE_OK ){ + int i; /* Index of aTree[] to recalculate */ + PmaReader *pReadr1; /* First PmaReader to compare */ + PmaReader *pReadr2; /* Second PmaReader to compare */ + int bCached = 0; + + /* Find the first two PmaReaders to compare. The one that was just + ** advanced (iPrev) and the one next to it in the array. */ + pReadr1 = &pMerger->aReadr[(iPrev & 0xFFFE)]; + pReadr2 = &pMerger->aReadr[(iPrev | 0x0001)]; + + for(i=(pMerger->nTree+iPrev)/2; i>0; i=i/2){ + /* Compare pReadr1 and pReadr2. Store the result in variable iRes. */ + int iRes; + if( pReadr1->pFd==0 ){ + iRes = +1; + }else if( pReadr2->pFd==0 ){ + iRes = -1; + }else{ + iRes = pTask->xCompare(pTask, &bCached, + pReadr1->aKey, pReadr1->nKey, pReadr2->aKey, pReadr2->nKey + ); + } + + /* If pReadr1 contained the smaller value, set aTree[i] to its index. + ** Then set pReadr2 to the next PmaReader to compare to pReadr1. In this + ** case there is no cache of pReadr2 in pTask->pUnpacked, so set + ** pKey2 to point to the record belonging to pReadr2. + ** + ** Alternatively, if pReadr2 contains the smaller of the two values, + ** set aTree[i] to its index and update pReadr1. If vdbeSorterCompare() + ** was actually called above, then pTask->pUnpacked now contains + ** a value equivalent to pReadr2. So set pKey2 to NULL to prevent + ** vdbeSorterCompare() from decoding pReadr2 again. + ** + ** If the two values were equal, then the value from the oldest + ** PMA should be considered smaller. The VdbeSorter.aReadr[] array + ** is sorted from oldest to newest, so pReadr1 contains older values + ** than pReadr2 iff (pReadr1aTree[i] = (int)(pReadr1 - pMerger->aReadr); + pReadr2 = &pMerger->aReadr[ pMerger->aTree[i ^ 0x0001] ]; + bCached = 0; + }else{ + if( pReadr1->pFd ) bCached = 0; + pMerger->aTree[i] = (int)(pReadr2 - pMerger->aReadr); + pReadr1 = &pMerger->aReadr[ pMerger->aTree[i ^ 0x0001] ]; + } + } + *pbEof = (pMerger->aReadr[pMerger->aTree[1]].pFd==0); + } + + return (rc==SQLITE_OK ? pTask->pUnpacked->errCode : rc); +} + +#if SQLITE_MAX_WORKER_THREADS>0 +/* +** The main routine for background threads that write level-0 PMAs. +*/ +static void *vdbeSorterFlushThread(void *pCtx){ + SortSubtask *pTask = (SortSubtask*)pCtx; + int rc; /* Return code */ + assert( pTask->bDone==0 ); + rc = vdbeSorterListToPMA(pTask, &pTask->list); + pTask->bDone = 1; + return SQLITE_INT_TO_PTR(rc); +} +#endif /* SQLITE_MAX_WORKER_THREADS>0 */ + +/* +** Flush the current contents of VdbeSorter.list to a new PMA, possibly +** using a background thread. +*/ +static int vdbeSorterFlushPMA(VdbeSorter *pSorter){ +#if SQLITE_MAX_WORKER_THREADS==0 + pSorter->bUsePMA = 1; + return vdbeSorterListToPMA(&pSorter->aTask[0], &pSorter->list); +#else + int rc = SQLITE_OK; + int i; + SortSubtask *pTask = 0; /* Thread context used to create new PMA */ + int nWorker = (pSorter->nTask-1); + + /* Set the flag to indicate that at least one PMA has been written. + ** Or will be, anyhow. */ + pSorter->bUsePMA = 1; + + /* Select a sub-task to sort and flush the current list of in-memory + ** records to disk. If the sorter is running in multi-threaded mode, + ** round-robin between the first (pSorter->nTask-1) tasks. Except, if + ** the background thread from a sub-tasks previous turn is still running, + ** skip it. If the first (pSorter->nTask-1) sub-tasks are all still busy, + ** fall back to using the final sub-task. The first (pSorter->nTask-1) + ** sub-tasks are prefered as they use background threads - the final + ** sub-task uses the main thread. */ + for(i=0; iiPrev + i + 1) % nWorker; + pTask = &pSorter->aTask[iTest]; + if( pTask->bDone ){ + rc = vdbeSorterJoinThread(pTask); + } + if( rc!=SQLITE_OK || pTask->pThread==0 ) break; + } + + if( rc==SQLITE_OK ){ + if( i==nWorker ){ + /* Use the foreground thread for this operation */ + rc = vdbeSorterListToPMA(&pSorter->aTask[nWorker], &pSorter->list); + }else{ + /* Launch a background thread for this operation */ + u8 *aMem; + void *pCtx; + + assert( pTask!=0 ); + assert( pTask->pThread==0 && pTask->bDone==0 ); + assert( pTask->list.pList==0 ); + assert( pTask->list.aMemory==0 || pSorter->list.aMemory!=0 ); + + aMem = pTask->list.aMemory; + pCtx = (void*)pTask; + pSorter->iPrev = (u8)(pTask - pSorter->aTask); + pTask->list = pSorter->list; + pSorter->list.pList = 0; + pSorter->list.szPMA = 0; + if( aMem ){ + pSorter->list.aMemory = aMem; + pSorter->nMemory = sqlite3MallocSize(aMem); + }else if( pSorter->list.aMemory ){ + pSorter->list.aMemory = sqlite3Malloc(pSorter->nMemory); + if( !pSorter->list.aMemory ) return SQLITE_NOMEM_BKPT; + } + + rc = vdbeSorterCreateThread(pTask, vdbeSorterFlushThread, pCtx); + } + } + + return rc; +#endif /* SQLITE_MAX_WORKER_THREADS!=0 */ +} + +/* +** Add a record to the sorter. +*/ +SQLITE_PRIVATE int sqlite3VdbeSorterWrite( + const VdbeCursor *pCsr, /* Sorter cursor */ + Mem *pVal /* Memory cell containing record */ +){ + VdbeSorter *pSorter; + int rc = SQLITE_OK; /* Return Code */ + SorterRecord *pNew; /* New list element */ + int bFlush; /* True to flush contents of memory to PMA */ + int nReq; /* Bytes of memory required */ + int nPMA; /* Bytes of PMA space required */ + int t; /* serial type of first record field */ + + assert( pCsr->eCurType==CURTYPE_SORTER ); + pSorter = pCsr->uc.pSorter; + getVarint32NR((const u8*)&pVal->z[1], t); + if( t>0 && t<10 && t!=7 ){ + pSorter->typeMask &= SORTER_TYPE_INTEGER; + }else if( t>10 && (t & 0x01) ){ + pSorter->typeMask &= SORTER_TYPE_TEXT; + }else{ + pSorter->typeMask = 0; + } + + assert( pSorter ); + + /* Figure out whether or not the current contents of memory should be + ** flushed to a PMA before continuing. If so, do so. + ** + ** If using the single large allocation mode (pSorter->aMemory!=0), then + ** flush the contents of memory to a new PMA if (a) at least one value is + ** already in memory and (b) the new value will not fit in memory. + ** + ** Or, if using separate allocations for each record, flush the contents + ** of memory to a PMA if either of the following are true: + ** + ** * The total memory allocated for the in-memory list is greater + ** than (page-size * cache-size), or + ** + ** * The total memory allocated for the in-memory list is greater + ** than (page-size * 10) and sqlite3HeapNearlyFull() returns true. + */ + nReq = pVal->n + sizeof(SorterRecord); + nPMA = pVal->n + sqlite3VarintLen(pVal->n); + if( pSorter->mxPmaSize ){ + if( pSorter->list.aMemory ){ + bFlush = pSorter->iMemory && (pSorter->iMemory+nReq) > pSorter->mxPmaSize; + }else{ + bFlush = ( + (pSorter->list.szPMA > pSorter->mxPmaSize) + || (pSorter->list.szPMA > pSorter->mnPmaSize && sqlite3HeapNearlyFull()) + ); + } + if( bFlush ){ + rc = vdbeSorterFlushPMA(pSorter); + pSorter->list.szPMA = 0; + pSorter->iMemory = 0; + assert( rc!=SQLITE_OK || pSorter->list.pList==0 ); + } + } + + pSorter->list.szPMA += nPMA; + if( nPMA>pSorter->mxKeysize ){ + pSorter->mxKeysize = nPMA; + } + + if( pSorter->list.aMemory ){ + int nMin = pSorter->iMemory + nReq; + + if( nMin>pSorter->nMemory ){ + u8 *aNew; + sqlite3_int64 nNew = 2 * (sqlite3_int64)pSorter->nMemory; + int iListOff = -1; + if( pSorter->list.pList ){ + iListOff = (u8*)pSorter->list.pList - pSorter->list.aMemory; + } + while( nNew < nMin ) nNew = nNew*2; + if( nNew > pSorter->mxPmaSize ) nNew = pSorter->mxPmaSize; + if( nNew < nMin ) nNew = nMin; + aNew = sqlite3Realloc(pSorter->list.aMemory, nNew); + if( !aNew ) return SQLITE_NOMEM_BKPT; + if( iListOff>=0 ){ + pSorter->list.pList = (SorterRecord*)&aNew[iListOff]; + } + pSorter->list.aMemory = aNew; + pSorter->nMemory = nNew; + } + + pNew = (SorterRecord*)&pSorter->list.aMemory[pSorter->iMemory]; + pSorter->iMemory += ROUND8(nReq); + if( pSorter->list.pList ){ + pNew->u.iNext = (int)((u8*)(pSorter->list.pList) - pSorter->list.aMemory); + } + }else{ + pNew = (SorterRecord *)sqlite3Malloc(nReq); + if( pNew==0 ){ + return SQLITE_NOMEM_BKPT; + } + pNew->u.pNext = pSorter->list.pList; + } + + memcpy(SRVAL(pNew), pVal->z, pVal->n); + pNew->nVal = pVal->n; + pSorter->list.pList = pNew; + + return rc; +} + +/* +** Read keys from pIncr->pMerger and populate pIncr->aFile[1]. The format +** of the data stored in aFile[1] is the same as that used by regular PMAs, +** except that the number-of-bytes varint is omitted from the start. +*/ +static int vdbeIncrPopulate(IncrMerger *pIncr){ + int rc = SQLITE_OK; + int rc2; + i64 iStart = pIncr->iStartOff; + SorterFile *pOut = &pIncr->aFile[1]; + SortSubtask *pTask = pIncr->pTask; + MergeEngine *pMerger = pIncr->pMerger; + PmaWriter writer; + assert( pIncr->bEof==0 ); + + vdbeSorterPopulateDebug(pTask, "enter"); + + vdbePmaWriterInit(pOut->pFd, &writer, pTask->pSorter->pgsz, iStart); + while( rc==SQLITE_OK ){ + int dummy; + PmaReader *pReader = &pMerger->aReadr[ pMerger->aTree[1] ]; + int nKey = pReader->nKey; + i64 iEof = writer.iWriteOff + writer.iBufEnd; + + /* Check if the output file is full or if the input has been exhausted. + ** In either case exit the loop. */ + if( pReader->pFd==0 ) break; + if( (iEof + nKey + sqlite3VarintLen(nKey))>(iStart + pIncr->mxSz) ) break; + + /* Write the next key to the output. */ + vdbePmaWriteVarint(&writer, nKey); + vdbePmaWriteBlob(&writer, pReader->aKey, nKey); + assert( pIncr->pMerger->pTask==pTask ); + rc = vdbeMergeEngineStep(pIncr->pMerger, &dummy); + } + + rc2 = vdbePmaWriterFinish(&writer, &pOut->iEof); + if( rc==SQLITE_OK ) rc = rc2; + vdbeSorterPopulateDebug(pTask, "exit"); + return rc; +} + +#if SQLITE_MAX_WORKER_THREADS>0 +/* +** The main routine for background threads that populate aFile[1] of +** multi-threaded IncrMerger objects. +*/ +static void *vdbeIncrPopulateThread(void *pCtx){ + IncrMerger *pIncr = (IncrMerger*)pCtx; + void *pRet = SQLITE_INT_TO_PTR( vdbeIncrPopulate(pIncr) ); + pIncr->pTask->bDone = 1; + return pRet; +} + +/* +** Launch a background thread to populate aFile[1] of pIncr. +*/ +static int vdbeIncrBgPopulate(IncrMerger *pIncr){ + void *p = (void*)pIncr; + assert( pIncr->bUseThread ); + return vdbeSorterCreateThread(pIncr->pTask, vdbeIncrPopulateThread, p); +} +#endif + +/* +** This function is called when the PmaReader corresponding to pIncr has +** finished reading the contents of aFile[0]. Its purpose is to "refill" +** aFile[0] such that the PmaReader should start rereading it from the +** beginning. +** +** For single-threaded objects, this is accomplished by literally reading +** keys from pIncr->pMerger and repopulating aFile[0]. +** +** For multi-threaded objects, all that is required is to wait until the +** background thread is finished (if it is not already) and then swap +** aFile[0] and aFile[1] in place. If the contents of pMerger have not +** been exhausted, this function also launches a new background thread +** to populate the new aFile[1]. +** +** SQLITE_OK is returned on success, or an SQLite error code otherwise. +*/ +static int vdbeIncrSwap(IncrMerger *pIncr){ + int rc = SQLITE_OK; + +#if SQLITE_MAX_WORKER_THREADS>0 + if( pIncr->bUseThread ){ + rc = vdbeSorterJoinThread(pIncr->pTask); + + if( rc==SQLITE_OK ){ + SorterFile f0 = pIncr->aFile[0]; + pIncr->aFile[0] = pIncr->aFile[1]; + pIncr->aFile[1] = f0; + } + + if( rc==SQLITE_OK ){ + if( pIncr->aFile[0].iEof==pIncr->iStartOff ){ + pIncr->bEof = 1; + }else{ + rc = vdbeIncrBgPopulate(pIncr); + } + } + }else +#endif + { + rc = vdbeIncrPopulate(pIncr); + pIncr->aFile[0] = pIncr->aFile[1]; + if( pIncr->aFile[0].iEof==pIncr->iStartOff ){ + pIncr->bEof = 1; + } + } + + return rc; +} + +/* +** Allocate and return a new IncrMerger object to read data from pMerger. +** +** If an OOM condition is encountered, return NULL. In this case free the +** pMerger argument before returning. +*/ +static int vdbeIncrMergerNew( + SortSubtask *pTask, /* The thread that will be using the new IncrMerger */ + MergeEngine *pMerger, /* The MergeEngine that the IncrMerger will control */ + IncrMerger **ppOut /* Write the new IncrMerger here */ +){ + int rc = SQLITE_OK; + IncrMerger *pIncr = *ppOut = (IncrMerger*) + (sqlite3FaultSim(100) ? 0 : sqlite3MallocZero(sizeof(*pIncr))); + if( pIncr ){ + pIncr->pMerger = pMerger; + pIncr->pTask = pTask; + pIncr->mxSz = MAX(pTask->pSorter->mxKeysize+9,pTask->pSorter->mxPmaSize/2); + pTask->file2.iEof += pIncr->mxSz; + }else{ + vdbeMergeEngineFree(pMerger); + rc = SQLITE_NOMEM_BKPT; + } + assert( *ppOut!=0 || rc!=SQLITE_OK ); + return rc; +} + +#if SQLITE_MAX_WORKER_THREADS>0 +/* +** Set the "use-threads" flag on object pIncr. +*/ +static void vdbeIncrMergerSetThreads(IncrMerger *pIncr){ + pIncr->bUseThread = 1; + pIncr->pTask->file2.iEof -= pIncr->mxSz; +} +#endif /* SQLITE_MAX_WORKER_THREADS>0 */ + + + +/* +** Recompute pMerger->aTree[iOut] by comparing the next keys on the +** two PmaReaders that feed that entry. Neither of the PmaReaders +** are advanced. This routine merely does the comparison. +*/ +static void vdbeMergeEngineCompare( + MergeEngine *pMerger, /* Merge engine containing PmaReaders to compare */ + int iOut /* Store the result in pMerger->aTree[iOut] */ +){ + int i1; + int i2; + int iRes; + PmaReader *p1; + PmaReader *p2; + + assert( iOutnTree && iOut>0 ); + + if( iOut>=(pMerger->nTree/2) ){ + i1 = (iOut - pMerger->nTree/2) * 2; + i2 = i1 + 1; + }else{ + i1 = pMerger->aTree[iOut*2]; + i2 = pMerger->aTree[iOut*2+1]; + } + + p1 = &pMerger->aReadr[i1]; + p2 = &pMerger->aReadr[i2]; + + if( p1->pFd==0 ){ + iRes = i2; + }else if( p2->pFd==0 ){ + iRes = i1; + }else{ + SortSubtask *pTask = pMerger->pTask; + int bCached = 0; + int res; + assert( pTask->pUnpacked!=0 ); /* from vdbeSortSubtaskMain() */ + res = pTask->xCompare( + pTask, &bCached, p1->aKey, p1->nKey, p2->aKey, p2->nKey + ); + if( res<=0 ){ + iRes = i1; + }else{ + iRes = i2; + } + } + + pMerger->aTree[iOut] = iRes; +} + +/* +** Allowed values for the eMode parameter to vdbeMergeEngineInit() +** and vdbePmaReaderIncrMergeInit(). +** +** Only INCRINIT_NORMAL is valid in single-threaded builds (when +** SQLITE_MAX_WORKER_THREADS==0). The other values are only used +** when there exists one or more separate worker threads. +*/ +#define INCRINIT_NORMAL 0 +#define INCRINIT_TASK 1 +#define INCRINIT_ROOT 2 + +/* +** Forward reference required as the vdbeIncrMergeInit() and +** vdbePmaReaderIncrInit() routines are called mutually recursively when +** building a merge tree. +*/ +static int vdbePmaReaderIncrInit(PmaReader *pReadr, int eMode); + +/* +** Initialize the MergeEngine object passed as the second argument. Once this +** function returns, the first key of merged data may be read from the +** MergeEngine object in the usual fashion. +** +** If argument eMode is INCRINIT_ROOT, then it is assumed that any IncrMerge +** objects attached to the PmaReader objects that the merger reads from have +** already been populated, but that they have not yet populated aFile[0] and +** set the PmaReader objects up to read from it. In this case all that is +** required is to call vdbePmaReaderNext() on each PmaReader to point it at +** its first key. +** +** Otherwise, if eMode is any value other than INCRINIT_ROOT, then use +** vdbePmaReaderIncrMergeInit() to initialize each PmaReader that feeds data +** to pMerger. +** +** SQLITE_OK is returned if successful, or an SQLite error code otherwise. +*/ +static int vdbeMergeEngineInit( + SortSubtask *pTask, /* Thread that will run pMerger */ + MergeEngine *pMerger, /* MergeEngine to initialize */ + int eMode /* One of the INCRINIT_XXX constants */ +){ + int rc = SQLITE_OK; /* Return code */ + int i; /* For looping over PmaReader objects */ + int nTree; /* Number of subtrees to merge */ + + /* Failure to allocate the merge would have been detected prior to + ** invoking this routine */ + assert( pMerger!=0 ); + + /* eMode is always INCRINIT_NORMAL in single-threaded mode */ + assert( SQLITE_MAX_WORKER_THREADS>0 || eMode==INCRINIT_NORMAL ); + + /* Verify that the MergeEngine is assigned to a single thread */ + assert( pMerger->pTask==0 ); + pMerger->pTask = pTask; + + nTree = pMerger->nTree; + for(i=0; i0 && eMode==INCRINIT_ROOT ){ + /* PmaReaders should be normally initialized in order, as if they are + ** reading from the same temp file this makes for more linear file IO. + ** However, in the INCRINIT_ROOT case, if PmaReader aReadr[nTask-1] is + ** in use it will block the vdbePmaReaderNext() call while it uses + ** the main thread to fill its buffer. So calling PmaReaderNext() + ** on this PmaReader before any of the multi-threaded PmaReaders takes + ** better advantage of multi-processor hardware. */ + rc = vdbePmaReaderNext(&pMerger->aReadr[nTree-i-1]); + }else{ + rc = vdbePmaReaderIncrInit(&pMerger->aReadr[i], INCRINIT_NORMAL); + } + if( rc!=SQLITE_OK ) return rc; + } + + for(i=pMerger->nTree-1; i>0; i--){ + vdbeMergeEngineCompare(pMerger, i); + } + return pTask->pUnpacked->errCode; +} + +/* +** The PmaReader passed as the first argument is guaranteed to be an +** incremental-reader (pReadr->pIncr!=0). This function serves to open +** and/or initialize the temp file related fields of the IncrMerge +** object at (pReadr->pIncr). +** +** If argument eMode is set to INCRINIT_NORMAL, then all PmaReaders +** in the sub-tree headed by pReadr are also initialized. Data is then +** loaded into the buffers belonging to pReadr and it is set to point to +** the first key in its range. +** +** If argument eMode is set to INCRINIT_TASK, then pReadr is guaranteed +** to be a multi-threaded PmaReader and this function is being called in a +** background thread. In this case all PmaReaders in the sub-tree are +** initialized as for INCRINIT_NORMAL and the aFile[1] buffer belonging to +** pReadr is populated. However, pReadr itself is not set up to point +** to its first key. A call to vdbePmaReaderNext() is still required to do +** that. +** +** The reason this function does not call vdbePmaReaderNext() immediately +** in the INCRINIT_TASK case is that vdbePmaReaderNext() assumes that it has +** to block on thread (pTask->thread) before accessing aFile[1]. But, since +** this entire function is being run by thread (pTask->thread), that will +** lead to the current background thread attempting to join itself. +** +** Finally, if argument eMode is set to INCRINIT_ROOT, it may be assumed +** that pReadr->pIncr is a multi-threaded IncrMerge objects, and that all +** child-trees have already been initialized using IncrInit(INCRINIT_TASK). +** In this case vdbePmaReaderNext() is called on all child PmaReaders and +** the current PmaReader set to point to the first key in its range. +** +** SQLITE_OK is returned if successful, or an SQLite error code otherwise. +*/ +static int vdbePmaReaderIncrMergeInit(PmaReader *pReadr, int eMode){ + int rc = SQLITE_OK; + IncrMerger *pIncr = pReadr->pIncr; + SortSubtask *pTask = pIncr->pTask; + sqlite3 *db = pTask->pSorter->db; + + /* eMode is always INCRINIT_NORMAL in single-threaded mode */ + assert( SQLITE_MAX_WORKER_THREADS>0 || eMode==INCRINIT_NORMAL ); + + rc = vdbeMergeEngineInit(pTask, pIncr->pMerger, eMode); + + /* Set up the required files for pIncr. A multi-theaded IncrMerge object + ** requires two temp files to itself, whereas a single-threaded object + ** only requires a region of pTask->file2. */ + if( rc==SQLITE_OK ){ + int mxSz = pIncr->mxSz; +#if SQLITE_MAX_WORKER_THREADS>0 + if( pIncr->bUseThread ){ + rc = vdbeSorterOpenTempFile(db, mxSz, &pIncr->aFile[0].pFd); + if( rc==SQLITE_OK ){ + rc = vdbeSorterOpenTempFile(db, mxSz, &pIncr->aFile[1].pFd); + } + }else +#endif + /*if( !pIncr->bUseThread )*/{ + if( pTask->file2.pFd==0 ){ + assert( pTask->file2.iEof>0 ); + rc = vdbeSorterOpenTempFile(db, pTask->file2.iEof, &pTask->file2.pFd); + pTask->file2.iEof = 0; + } + if( rc==SQLITE_OK ){ + pIncr->aFile[1].pFd = pTask->file2.pFd; + pIncr->iStartOff = pTask->file2.iEof; + pTask->file2.iEof += mxSz; + } + } + } + +#if SQLITE_MAX_WORKER_THREADS>0 + if( rc==SQLITE_OK && pIncr->bUseThread ){ + /* Use the current thread to populate aFile[1], even though this + ** PmaReader is multi-threaded. If this is an INCRINIT_TASK object, + ** then this function is already running in background thread + ** pIncr->pTask->thread. + ** + ** If this is the INCRINIT_ROOT object, then it is running in the + ** main VDBE thread. But that is Ok, as that thread cannot return + ** control to the VDBE or proceed with anything useful until the + ** first results are ready from this merger object anyway. + */ + assert( eMode==INCRINIT_ROOT || eMode==INCRINIT_TASK ); + rc = vdbeIncrPopulate(pIncr); + } +#endif + + if( rc==SQLITE_OK && (SQLITE_MAX_WORKER_THREADS==0 || eMode!=INCRINIT_TASK) ){ + rc = vdbePmaReaderNext(pReadr); + } + + return rc; +} + +#if SQLITE_MAX_WORKER_THREADS>0 +/* +** The main routine for vdbePmaReaderIncrMergeInit() operations run in +** background threads. +*/ +static void *vdbePmaReaderBgIncrInit(void *pCtx){ + PmaReader *pReader = (PmaReader*)pCtx; + void *pRet = SQLITE_INT_TO_PTR( + vdbePmaReaderIncrMergeInit(pReader,INCRINIT_TASK) + ); + pReader->pIncr->pTask->bDone = 1; + return pRet; +} +#endif + +/* +** If the PmaReader passed as the first argument is not an incremental-reader +** (if pReadr->pIncr==0), then this function is a no-op. Otherwise, it invokes +** the vdbePmaReaderIncrMergeInit() function with the parameters passed to +** this routine to initialize the incremental merge. +** +** If the IncrMerger object is multi-threaded (IncrMerger.bUseThread==1), +** then a background thread is launched to call vdbePmaReaderIncrMergeInit(). +** Or, if the IncrMerger is single threaded, the same function is called +** using the current thread. +*/ +static int vdbePmaReaderIncrInit(PmaReader *pReadr, int eMode){ + IncrMerger *pIncr = pReadr->pIncr; /* Incremental merger */ + int rc = SQLITE_OK; /* Return code */ + if( pIncr ){ +#if SQLITE_MAX_WORKER_THREADS>0 + assert( pIncr->bUseThread==0 || eMode==INCRINIT_TASK ); + if( pIncr->bUseThread ){ + void *pCtx = (void*)pReadr; + rc = vdbeSorterCreateThread(pIncr->pTask, vdbePmaReaderBgIncrInit, pCtx); + }else +#endif + { + rc = vdbePmaReaderIncrMergeInit(pReadr, eMode); + } + } + return rc; +} + +/* +** Allocate a new MergeEngine object to merge the contents of nPMA level-0 +** PMAs from pTask->file. If no error occurs, set *ppOut to point to +** the new object and return SQLITE_OK. Or, if an error does occur, set *ppOut +** to NULL and return an SQLite error code. +** +** When this function is called, *piOffset is set to the offset of the +** first PMA to read from pTask->file. Assuming no error occurs, it is +** set to the offset immediately following the last byte of the last +** PMA before returning. If an error does occur, then the final value of +** *piOffset is undefined. +*/ +static int vdbeMergeEngineLevel0( + SortSubtask *pTask, /* Sorter task to read from */ + int nPMA, /* Number of PMAs to read */ + i64 *piOffset, /* IN/OUT: Readr offset in pTask->file */ + MergeEngine **ppOut /* OUT: New merge-engine */ +){ + MergeEngine *pNew; /* Merge engine to return */ + i64 iOff = *piOffset; + int i; + int rc = SQLITE_OK; + + *ppOut = pNew = vdbeMergeEngineNew(nPMA); + if( pNew==0 ) rc = SQLITE_NOMEM_BKPT; + + for(i=0; iaReadr[i]; + rc = vdbePmaReaderInit(pTask, &pTask->file, iOff, pReadr, &nDummy); + iOff = pReadr->iEof; + } + + if( rc!=SQLITE_OK ){ + vdbeMergeEngineFree(pNew); + *ppOut = 0; + } + *piOffset = iOff; + return rc; +} + +/* +** Return the depth of a tree comprising nPMA PMAs, assuming a fanout of +** SORTER_MAX_MERGE_COUNT. The returned value does not include leaf nodes. +** +** i.e. +** +** nPMA<=16 -> TreeDepth() == 0 +** nPMA<=256 -> TreeDepth() == 1 +** nPMA<=65536 -> TreeDepth() == 2 +*/ +static int vdbeSorterTreeDepth(int nPMA){ + int nDepth = 0; + i64 nDiv = SORTER_MAX_MERGE_COUNT; + while( nDiv < (i64)nPMA ){ + nDiv = nDiv * SORTER_MAX_MERGE_COUNT; + nDepth++; + } + return nDepth; +} + +/* +** pRoot is the root of an incremental merge-tree with depth nDepth (according +** to vdbeSorterTreeDepth()). pLeaf is the iSeq'th leaf to be added to the +** tree, counting from zero. This function adds pLeaf to the tree. +** +** If successful, SQLITE_OK is returned. If an error occurs, an SQLite error +** code is returned and pLeaf is freed. +*/ +static int vdbeSorterAddToTree( + SortSubtask *pTask, /* Task context */ + int nDepth, /* Depth of tree according to TreeDepth() */ + int iSeq, /* Sequence number of leaf within tree */ + MergeEngine *pRoot, /* Root of tree */ + MergeEngine *pLeaf /* Leaf to add to tree */ +){ + int rc = SQLITE_OK; + int nDiv = 1; + int i; + MergeEngine *p = pRoot; + IncrMerger *pIncr; + + rc = vdbeIncrMergerNew(pTask, pLeaf, &pIncr); + + for(i=1; iaReadr[iIter]; + + if( pReadr->pIncr==0 ){ + MergeEngine *pNew = vdbeMergeEngineNew(SORTER_MAX_MERGE_COUNT); + if( pNew==0 ){ + rc = SQLITE_NOMEM_BKPT; + }else{ + rc = vdbeIncrMergerNew(pTask, pNew, &pReadr->pIncr); + } + } + if( rc==SQLITE_OK ){ + p = pReadr->pIncr->pMerger; + nDiv = nDiv / SORTER_MAX_MERGE_COUNT; + } + } + + if( rc==SQLITE_OK ){ + p->aReadr[iSeq % SORTER_MAX_MERGE_COUNT].pIncr = pIncr; + }else{ + vdbeIncrFree(pIncr); + } + return rc; +} + +/* +** This function is called as part of a SorterRewind() operation on a sorter +** that has already written two or more level-0 PMAs to one or more temp +** files. It builds a tree of MergeEngine/IncrMerger/PmaReader objects that +** can be used to incrementally merge all PMAs on disk. +** +** If successful, SQLITE_OK is returned and *ppOut set to point to the +** MergeEngine object at the root of the tree before returning. Or, if an +** error occurs, an SQLite error code is returned and the final value +** of *ppOut is undefined. +*/ +static int vdbeSorterMergeTreeBuild( + VdbeSorter *pSorter, /* The VDBE cursor that implements the sort */ + MergeEngine **ppOut /* Write the MergeEngine here */ +){ + MergeEngine *pMain = 0; + int rc = SQLITE_OK; + int iTask; + +#if SQLITE_MAX_WORKER_THREADS>0 + /* If the sorter uses more than one task, then create the top-level + ** MergeEngine here. This MergeEngine will read data from exactly + ** one PmaReader per sub-task. */ + assert( pSorter->bUseThreads || pSorter->nTask==1 ); + if( pSorter->nTask>1 ){ + pMain = vdbeMergeEngineNew(pSorter->nTask); + if( pMain==0 ) rc = SQLITE_NOMEM_BKPT; + } +#endif + + for(iTask=0; rc==SQLITE_OK && iTasknTask; iTask++){ + SortSubtask *pTask = &pSorter->aTask[iTask]; + assert( pTask->nPMA>0 || SQLITE_MAX_WORKER_THREADS>0 ); + if( SQLITE_MAX_WORKER_THREADS==0 || pTask->nPMA ){ + MergeEngine *pRoot = 0; /* Root node of tree for this task */ + int nDepth = vdbeSorterTreeDepth(pTask->nPMA); + i64 iReadOff = 0; + + if( pTask->nPMA<=SORTER_MAX_MERGE_COUNT ){ + rc = vdbeMergeEngineLevel0(pTask, pTask->nPMA, &iReadOff, &pRoot); + }else{ + int i; + int iSeq = 0; + pRoot = vdbeMergeEngineNew(SORTER_MAX_MERGE_COUNT); + if( pRoot==0 ) rc = SQLITE_NOMEM_BKPT; + for(i=0; inPMA && rc==SQLITE_OK; i += SORTER_MAX_MERGE_COUNT){ + MergeEngine *pMerger = 0; /* New level-0 PMA merger */ + int nReader; /* Number of level-0 PMAs to merge */ + + nReader = MIN(pTask->nPMA - i, SORTER_MAX_MERGE_COUNT); + rc = vdbeMergeEngineLevel0(pTask, nReader, &iReadOff, &pMerger); + if( rc==SQLITE_OK ){ + rc = vdbeSorterAddToTree(pTask, nDepth, iSeq++, pRoot, pMerger); + } + } + } + + if( rc==SQLITE_OK ){ +#if SQLITE_MAX_WORKER_THREADS>0 + if( pMain!=0 ){ + rc = vdbeIncrMergerNew(pTask, pRoot, &pMain->aReadr[iTask].pIncr); + }else +#endif + { + assert( pMain==0 ); + pMain = pRoot; + } + }else{ + vdbeMergeEngineFree(pRoot); + } + } + } + + if( rc!=SQLITE_OK ){ + vdbeMergeEngineFree(pMain); + pMain = 0; + } + *ppOut = pMain; + return rc; +} + +/* +** This function is called as part of an sqlite3VdbeSorterRewind() operation +** on a sorter that has written two or more PMAs to temporary files. It sets +** up either VdbeSorter.pMerger (for single threaded sorters) or pReader +** (for multi-threaded sorters) so that it can be used to iterate through +** all records stored in the sorter. +** +** SQLITE_OK is returned if successful, or an SQLite error code otherwise. +*/ +static int vdbeSorterSetupMerge(VdbeSorter *pSorter){ + int rc; /* Return code */ + SortSubtask *pTask0 = &pSorter->aTask[0]; + MergeEngine *pMain = 0; +#if SQLITE_MAX_WORKER_THREADS + sqlite3 *db = pTask0->pSorter->db; + int i; + SorterCompare xCompare = vdbeSorterGetCompare(pSorter); + for(i=0; inTask; i++){ + pSorter->aTask[i].xCompare = xCompare; + } +#endif + + rc = vdbeSorterMergeTreeBuild(pSorter, &pMain); + if( rc==SQLITE_OK ){ +#if SQLITE_MAX_WORKER_THREADS + assert( pSorter->bUseThreads==0 || pSorter->nTask>1 ); + if( pSorter->bUseThreads ){ + int iTask; + PmaReader *pReadr = 0; + SortSubtask *pLast = &pSorter->aTask[pSorter->nTask-1]; + rc = vdbeSortAllocUnpacked(pLast); + if( rc==SQLITE_OK ){ + pReadr = (PmaReader*)sqlite3DbMallocZero(db, sizeof(PmaReader)); + pSorter->pReader = pReadr; + if( pReadr==0 ) rc = SQLITE_NOMEM_BKPT; + } + if( rc==SQLITE_OK ){ + rc = vdbeIncrMergerNew(pLast, pMain, &pReadr->pIncr); + if( rc==SQLITE_OK ){ + vdbeIncrMergerSetThreads(pReadr->pIncr); + for(iTask=0; iTask<(pSorter->nTask-1); iTask++){ + IncrMerger *pIncr; + if( (pIncr = pMain->aReadr[iTask].pIncr) ){ + vdbeIncrMergerSetThreads(pIncr); + assert( pIncr->pTask!=pLast ); + } + } + for(iTask=0; rc==SQLITE_OK && iTasknTask; iTask++){ + /* Check that: + ** + ** a) The incremental merge object is configured to use the + ** right task, and + ** b) If it is using task (nTask-1), it is configured to run + ** in single-threaded mode. This is important, as the + ** root merge (INCRINIT_ROOT) will be using the same task + ** object. + */ + PmaReader *p = &pMain->aReadr[iTask]; + assert( p->pIncr==0 || ( + (p->pIncr->pTask==&pSorter->aTask[iTask]) /* a */ + && (iTask!=pSorter->nTask-1 || p->pIncr->bUseThread==0) /* b */ + )); + rc = vdbePmaReaderIncrInit(p, INCRINIT_TASK); + } + } + pMain = 0; + } + if( rc==SQLITE_OK ){ + rc = vdbePmaReaderIncrMergeInit(pReadr, INCRINIT_ROOT); + } + }else +#endif + { + rc = vdbeMergeEngineInit(pTask0, pMain, INCRINIT_NORMAL); + pSorter->pMerger = pMain; + pMain = 0; + } + } + + if( rc!=SQLITE_OK ){ + vdbeMergeEngineFree(pMain); + } + return rc; +} + + +/* +** Once the sorter has been populated by calls to sqlite3VdbeSorterWrite, +** this function is called to prepare for iterating through the records +** in sorted order. +*/ +SQLITE_PRIVATE int sqlite3VdbeSorterRewind(const VdbeCursor *pCsr, int *pbEof){ + VdbeSorter *pSorter; + int rc = SQLITE_OK; /* Return code */ + + assert( pCsr->eCurType==CURTYPE_SORTER ); + pSorter = pCsr->uc.pSorter; + assert( pSorter ); + + /* If no data has been written to disk, then do not do so now. Instead, + ** sort the VdbeSorter.pRecord list. The vdbe layer will read data directly + ** from the in-memory list. */ + if( pSorter->bUsePMA==0 ){ + if( pSorter->list.pList ){ + *pbEof = 0; + rc = vdbeSorterSort(&pSorter->aTask[0], &pSorter->list); + }else{ + *pbEof = 1; + } + return rc; + } + + /* Write the current in-memory list to a PMA. When the VdbeSorterWrite() + ** function flushes the contents of memory to disk, it immediately always + ** creates a new list consisting of a single key immediately afterwards. + ** So the list is never empty at this point. */ + assert( pSorter->list.pList ); + rc = vdbeSorterFlushPMA(pSorter); + + /* Join all threads */ + rc = vdbeSorterJoinAll(pSorter, rc); + + vdbeSorterRewindDebug("rewind"); + + /* Assuming no errors have occurred, set up a merger structure to + ** incrementally read and merge all remaining PMAs. */ + assert( pSorter->pReader==0 ); + if( rc==SQLITE_OK ){ + rc = vdbeSorterSetupMerge(pSorter); + *pbEof = 0; + } + + vdbeSorterRewindDebug("rewinddone"); + return rc; +} + +/* +** Advance to the next element in the sorter. Return value: +** +** SQLITE_OK success +** SQLITE_DONE end of data +** otherwise some kind of error. +*/ +SQLITE_PRIVATE int sqlite3VdbeSorterNext(sqlite3 *db, const VdbeCursor *pCsr){ + VdbeSorter *pSorter; + int rc; /* Return code */ + + assert( pCsr->eCurType==CURTYPE_SORTER ); + pSorter = pCsr->uc.pSorter; + assert( pSorter->bUsePMA || (pSorter->pReader==0 && pSorter->pMerger==0) ); + if( pSorter->bUsePMA ){ + assert( pSorter->pReader==0 || pSorter->pMerger==0 ); + assert( pSorter->bUseThreads==0 || pSorter->pReader ); + assert( pSorter->bUseThreads==1 || pSorter->pMerger ); +#if SQLITE_MAX_WORKER_THREADS>0 + if( pSorter->bUseThreads ){ + rc = vdbePmaReaderNext(pSorter->pReader); + if( rc==SQLITE_OK && pSorter->pReader->pFd==0 ) rc = SQLITE_DONE; + }else +#endif + /*if( !pSorter->bUseThreads )*/ { + int res = 0; + assert( pSorter->pMerger!=0 ); + assert( pSorter->pMerger->pTask==(&pSorter->aTask[0]) ); + rc = vdbeMergeEngineStep(pSorter->pMerger, &res); + if( rc==SQLITE_OK && res ) rc = SQLITE_DONE; + } + }else{ + SorterRecord *pFree = pSorter->list.pList; + pSorter->list.pList = pFree->u.pNext; + pFree->u.pNext = 0; + if( pSorter->list.aMemory==0 ) vdbeSorterRecordFree(db, pFree); + rc = pSorter->list.pList ? SQLITE_OK : SQLITE_DONE; + } + return rc; +} + +/* +** Return a pointer to a buffer owned by the sorter that contains the +** current key. +*/ +static void *vdbeSorterRowkey( + const VdbeSorter *pSorter, /* Sorter object */ + int *pnKey /* OUT: Size of current key in bytes */ +){ + void *pKey; + if( pSorter->bUsePMA ){ + PmaReader *pReader; +#if SQLITE_MAX_WORKER_THREADS>0 + if( pSorter->bUseThreads ){ + pReader = pSorter->pReader; + }else +#endif + /*if( !pSorter->bUseThreads )*/{ + pReader = &pSorter->pMerger->aReadr[pSorter->pMerger->aTree[1]]; + } + *pnKey = pReader->nKey; + pKey = pReader->aKey; + }else{ + *pnKey = pSorter->list.pList->nVal; + pKey = SRVAL(pSorter->list.pList); + } + return pKey; +} + +/* +** Copy the current sorter key into the memory cell pOut. +*/ +SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(const VdbeCursor *pCsr, Mem *pOut){ + VdbeSorter *pSorter; + void *pKey; int nKey; /* Sorter key to copy into pOut */ + + assert( pCsr->eCurType==CURTYPE_SORTER ); + pSorter = pCsr->uc.pSorter; + pKey = vdbeSorterRowkey(pSorter, &nKey); + if( sqlite3VdbeMemClearAndResize(pOut, nKey) ){ + return SQLITE_NOMEM_BKPT; + } + pOut->n = nKey; + MemSetTypeFlag(pOut, MEM_Blob); + memcpy(pOut->z, pKey, nKey); + + return SQLITE_OK; +} + +/* +** Compare the key in memory cell pVal with the key that the sorter cursor +** passed as the first argument currently points to. For the purposes of +** the comparison, ignore the rowid field at the end of each record. +** +** If the sorter cursor key contains any NULL values, consider it to be +** less than pVal. Even if pVal also contains NULL values. +** +** If an error occurs, return an SQLite error code (i.e. SQLITE_NOMEM). +** Otherwise, set *pRes to a negative, zero or positive value if the +** key in pVal is smaller than, equal to or larger than the current sorter +** key. +** +** This routine forms the core of the OP_SorterCompare opcode, which in +** turn is used to verify uniqueness when constructing a UNIQUE INDEX. +*/ +SQLITE_PRIVATE int sqlite3VdbeSorterCompare( + const VdbeCursor *pCsr, /* Sorter cursor */ + Mem *pVal, /* Value to compare to current sorter key */ + int nKeyCol, /* Compare this many columns */ + int *pRes /* OUT: Result of comparison */ +){ + VdbeSorter *pSorter; + UnpackedRecord *r2; + KeyInfo *pKeyInfo; + int i; + void *pKey; int nKey; /* Sorter key to compare pVal with */ + + assert( pCsr->eCurType==CURTYPE_SORTER ); + pSorter = pCsr->uc.pSorter; + r2 = pSorter->pUnpacked; + pKeyInfo = pCsr->pKeyInfo; + if( r2==0 ){ + r2 = pSorter->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pKeyInfo); + if( r2==0 ) return SQLITE_NOMEM_BKPT; + r2->nField = nKeyCol; + } + assert( r2->nField==nKeyCol ); + + pKey = vdbeSorterRowkey(pSorter, &nKey); + sqlite3VdbeRecordUnpack(pKeyInfo, nKey, pKey, r2); + for(i=0; iaMem[i].flags & MEM_Null ){ + *pRes = -1; + return SQLITE_OK; + } + } + + *pRes = sqlite3VdbeRecordCompare(pVal->n, pVal->z, r2); + return SQLITE_OK; +} + +/************** End of vdbesort.c ********************************************/ +/************** Begin file vdbevtab.c ****************************************/ +/* +** 2020-03-23 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file implements virtual-tables for examining the bytecode content +** of a prepared statement. +*/ +/* #include "sqliteInt.h" */ +#if defined(SQLITE_ENABLE_BYTECODE_VTAB) && !defined(SQLITE_OMIT_VIRTUALTABLE) +/* #include "vdbeInt.h" */ + +/* An instance of the bytecode() table-valued function. +*/ +typedef struct bytecodevtab bytecodevtab; +struct bytecodevtab { + sqlite3_vtab base; /* Base class - must be first */ + sqlite3 *db; /* Database connection */ + int bTablesUsed; /* 2 for tables_used(). 0 for bytecode(). */ +}; + +/* A cursor for scanning through the bytecode +*/ +typedef struct bytecodevtab_cursor bytecodevtab_cursor; +struct bytecodevtab_cursor { + sqlite3_vtab_cursor base; /* Base class - must be first */ + sqlite3_stmt *pStmt; /* The statement whose bytecode is displayed */ + int iRowid; /* The rowid of the output table */ + int iAddr; /* Address */ + int needFinalize; /* Cursors owns pStmt and must finalize it */ + int showSubprograms; /* Provide a listing of subprograms */ + Op *aOp; /* Operand array */ + char *zP4; /* Rendered P4 value */ + const char *zType; /* tables_used.type */ + const char *zSchema; /* tables_used.schema */ + const char *zName; /* tables_used.name */ + Mem sub; /* Subprograms */ +}; + +/* +** Create a new bytecode() table-valued function. +*/ +static int bytecodevtabConnect( + sqlite3 *db, + void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVtab, + char **pzErr +){ + bytecodevtab *pNew; + int rc; + int isTabUsed = pAux!=0; + const char *azSchema[2] = { + /* bytecode() schema */ + "CREATE TABLE x(" + "addr INT," + "opcode TEXT," + "p1 INT," + "p2 INT," + "p3 INT," + "p4 TEXT," + "p5 INT," + "comment TEXT," + "subprog TEXT," + "stmt HIDDEN" + ");", + + /* Tables_used() schema */ + "CREATE TABLE x(" + "type TEXT," + "schema TEXT," + "name TEXT," + "wr INT," + "subprog TEXT," + "stmt HIDDEN" + ");" + }; + + (void)argc; + (void)argv; + (void)pzErr; + rc = sqlite3_declare_vtab(db, azSchema[isTabUsed]); + if( rc==SQLITE_OK ){ + pNew = sqlite3_malloc( sizeof(*pNew) ); + *ppVtab = (sqlite3_vtab*)pNew; + if( pNew==0 ) return SQLITE_NOMEM; + memset(pNew, 0, sizeof(*pNew)); + pNew->db = db; + pNew->bTablesUsed = isTabUsed*2; + } + return rc; +} + +/* +** This method is the destructor for bytecodevtab objects. +*/ +static int bytecodevtabDisconnect(sqlite3_vtab *pVtab){ + bytecodevtab *p = (bytecodevtab*)pVtab; + sqlite3_free(p); + return SQLITE_OK; +} + +/* +** Constructor for a new bytecodevtab_cursor object. +*/ +static int bytecodevtabOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){ + bytecodevtab *pVTab = (bytecodevtab*)p; + bytecodevtab_cursor *pCur; + pCur = sqlite3_malloc( sizeof(*pCur) ); + if( pCur==0 ) return SQLITE_NOMEM; + memset(pCur, 0, sizeof(*pCur)); + sqlite3VdbeMemInit(&pCur->sub, pVTab->db, 1); + *ppCursor = &pCur->base; + return SQLITE_OK; +} + +/* +** Clear all internal content from a bytecodevtab cursor. +*/ +static void bytecodevtabCursorClear(bytecodevtab_cursor *pCur){ + sqlite3_free(pCur->zP4); + pCur->zP4 = 0; + sqlite3VdbeMemRelease(&pCur->sub); + sqlite3VdbeMemSetNull(&pCur->sub); + if( pCur->needFinalize ){ + sqlite3_finalize(pCur->pStmt); + } + pCur->pStmt = 0; + pCur->needFinalize = 0; + pCur->zType = 0; + pCur->zSchema = 0; + pCur->zName = 0; +} + +/* +** Destructor for a bytecodevtab_cursor. +*/ +static int bytecodevtabClose(sqlite3_vtab_cursor *cur){ + bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur; + bytecodevtabCursorClear(pCur); + sqlite3_free(pCur); + return SQLITE_OK; +} + + +/* +** Advance a bytecodevtab_cursor to its next row of output. +*/ +static int bytecodevtabNext(sqlite3_vtab_cursor *cur){ + bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur; + bytecodevtab *pTab = (bytecodevtab*)cur->pVtab; + int rc; + if( pCur->zP4 ){ + sqlite3_free(pCur->zP4); + pCur->zP4 = 0; + } + if( pCur->zName ){ + pCur->zName = 0; + pCur->zType = 0; + pCur->zSchema = 0; + } + rc = sqlite3VdbeNextOpcode( + (Vdbe*)pCur->pStmt, + pCur->showSubprograms ? &pCur->sub : 0, + pTab->bTablesUsed, + &pCur->iRowid, + &pCur->iAddr, + &pCur->aOp); + if( rc!=SQLITE_OK ){ + sqlite3VdbeMemSetNull(&pCur->sub); + pCur->aOp = 0; + } + return SQLITE_OK; +} + +/* +** Return TRUE if the cursor has been moved off of the last +** row of output. +*/ +static int bytecodevtabEof(sqlite3_vtab_cursor *cur){ + bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur; + return pCur->aOp==0; +} + +/* +** Return values of columns for the row at which the bytecodevtab_cursor +** is currently pointing. +*/ +static int bytecodevtabColumn( + sqlite3_vtab_cursor *cur, /* The cursor */ + sqlite3_context *ctx, /* First argument to sqlite3_result_...() */ + int i /* Which column to return */ +){ + bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur; + bytecodevtab *pVTab = (bytecodevtab*)cur->pVtab; + Op *pOp = pCur->aOp + pCur->iAddr; + if( pVTab->bTablesUsed ){ + if( i==4 ){ + i = 8; + }else{ + if( i<=2 && pCur->zType==0 ){ + Schema *pSchema; + HashElem *k; + int iDb = pOp->p3; + Pgno iRoot = (Pgno)pOp->p2; + sqlite3 *db = pVTab->db; + pSchema = db->aDb[iDb].pSchema; + pCur->zSchema = db->aDb[iDb].zDbSName; + for(k=sqliteHashFirst(&pSchema->tblHash); k; k=sqliteHashNext(k)){ + Table *pTab = (Table*)sqliteHashData(k); + if( !IsVirtual(pTab) && pTab->tnum==iRoot ){ + pCur->zName = pTab->zName; + pCur->zType = "table"; + break; + } + } + if( pCur->zName==0 ){ + for(k=sqliteHashFirst(&pSchema->idxHash); k; k=sqliteHashNext(k)){ + Index *pIdx = (Index*)sqliteHashData(k); + if( pIdx->tnum==iRoot ){ + pCur->zName = pIdx->zName; + pCur->zType = "index"; + } + } + } + } + i += 10; + } + } + switch( i ){ + case 0: /* addr */ + sqlite3_result_int(ctx, pCur->iAddr); + break; + case 1: /* opcode */ + sqlite3_result_text(ctx, (char*)sqlite3OpcodeName(pOp->opcode), + -1, SQLITE_STATIC); + break; + case 2: /* p1 */ + sqlite3_result_int(ctx, pOp->p1); + break; + case 3: /* p2 */ + sqlite3_result_int(ctx, pOp->p2); + break; + case 4: /* p3 */ + sqlite3_result_int(ctx, pOp->p3); + break; + case 5: /* p4 */ + case 7: /* comment */ + if( pCur->zP4==0 ){ + pCur->zP4 = sqlite3VdbeDisplayP4(pVTab->db, pOp); + } + if( i==5 ){ + sqlite3_result_text(ctx, pCur->zP4, -1, SQLITE_STATIC); + }else{ +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + char *zCom = sqlite3VdbeDisplayComment(pVTab->db, pOp, pCur->zP4); + sqlite3_result_text(ctx, zCom, -1, sqlite3_free); +#endif + } + break; + case 6: /* p5 */ + sqlite3_result_int(ctx, pOp->p5); + break; + case 8: { /* subprog */ + Op *aOp = pCur->aOp; + assert( aOp[0].opcode==OP_Init ); + assert( aOp[0].p4.z==0 || strncmp(aOp[0].p4.z,"-" "- ",3)==0 ); + if( pCur->iRowid==pCur->iAddr+1 ){ + break; /* Result is NULL for the main program */ + }else if( aOp[0].p4.z!=0 ){ + sqlite3_result_text(ctx, aOp[0].p4.z+3, -1, SQLITE_STATIC); + }else{ + sqlite3_result_text(ctx, "(FK)", 4, SQLITE_STATIC); + } + break; + } + case 10: /* tables_used.type */ + sqlite3_result_text(ctx, pCur->zType, -1, SQLITE_STATIC); + break; + case 11: /* tables_used.schema */ + sqlite3_result_text(ctx, pCur->zSchema, -1, SQLITE_STATIC); + break; + case 12: /* tables_used.name */ + sqlite3_result_text(ctx, pCur->zName, -1, SQLITE_STATIC); + break; + case 13: /* tables_used.wr */ + sqlite3_result_int(ctx, pOp->opcode==OP_OpenWrite); + break; + } + return SQLITE_OK; +} + +/* +** Return the rowid for the current row. In this implementation, the +** rowid is the same as the output value. +*/ +static int bytecodevtabRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){ + bytecodevtab_cursor *pCur = (bytecodevtab_cursor*)cur; + *pRowid = pCur->iRowid; + return SQLITE_OK; +} + +/* +** Initialize a cursor. +** +** idxNum==0 means show all subprograms +** idxNum==1 means show only the main bytecode and omit subprograms. +*/ +static int bytecodevtabFilter( + sqlite3_vtab_cursor *pVtabCursor, + int idxNum, const char *idxStr, + int argc, sqlite3_value **argv +){ + bytecodevtab_cursor *pCur = (bytecodevtab_cursor *)pVtabCursor; + bytecodevtab *pVTab = (bytecodevtab *)pVtabCursor->pVtab; + int rc = SQLITE_OK; + (void)idxStr; + + bytecodevtabCursorClear(pCur); + pCur->iRowid = 0; + pCur->iAddr = 0; + pCur->showSubprograms = idxNum==0; + assert( argc==1 ); + if( sqlite3_value_type(argv[0])==SQLITE_TEXT ){ + const char *zSql = (const char*)sqlite3_value_text(argv[0]); + if( zSql==0 ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare_v2(pVTab->db, zSql, -1, &pCur->pStmt, 0); + pCur->needFinalize = 1; + } + }else{ + pCur->pStmt = (sqlite3_stmt*)sqlite3_value_pointer(argv[0],"stmt-pointer"); + } + if( pCur->pStmt==0 ){ + pVTab->base.zErrMsg = sqlite3_mprintf( + "argument to %s() is not a valid SQL statement", + pVTab->bTablesUsed ? "tables_used" : "bytecode" + ); + rc = SQLITE_ERROR; + }else{ + bytecodevtabNext(pVtabCursor); + } + return rc; +} + +/* +** We must have a single stmt=? constraint that will be passed through +** into the xFilter method. If there is no valid stmt=? constraint, +** then return an SQLITE_CONSTRAINT error. +*/ +static int bytecodevtabBestIndex( + sqlite3_vtab *tab, + sqlite3_index_info *pIdxInfo +){ + int i; + int rc = SQLITE_CONSTRAINT; + struct sqlite3_index_constraint *p; + bytecodevtab *pVTab = (bytecodevtab*)tab; + int iBaseCol = pVTab->bTablesUsed ? 4 : 8; + pIdxInfo->estimatedCost = (double)100; + pIdxInfo->estimatedRows = 100; + pIdxInfo->idxNum = 0; + for(i=0, p=pIdxInfo->aConstraint; inConstraint; i++, p++){ + if( p->usable==0 ) continue; + if( p->op==SQLITE_INDEX_CONSTRAINT_EQ && p->iColumn==iBaseCol+1 ){ + rc = SQLITE_OK; + pIdxInfo->aConstraintUsage[i].omit = 1; + pIdxInfo->aConstraintUsage[i].argvIndex = 1; + } + if( p->op==SQLITE_INDEX_CONSTRAINT_ISNULL && p->iColumn==iBaseCol ){ + pIdxInfo->aConstraintUsage[i].omit = 1; + pIdxInfo->idxNum = 1; + } + } + return rc; +} + +/* +** This following structure defines all the methods for the +** virtual table. +*/ +static sqlite3_module bytecodevtabModule = { + /* iVersion */ 0, + /* xCreate */ 0, + /* xConnect */ bytecodevtabConnect, + /* xBestIndex */ bytecodevtabBestIndex, + /* xDisconnect */ bytecodevtabDisconnect, + /* xDestroy */ 0, + /* xOpen */ bytecodevtabOpen, + /* xClose */ bytecodevtabClose, + /* xFilter */ bytecodevtabFilter, + /* xNext */ bytecodevtabNext, + /* xEof */ bytecodevtabEof, + /* xColumn */ bytecodevtabColumn, + /* xRowid */ bytecodevtabRowid, + /* xUpdate */ 0, + /* xBegin */ 0, + /* xSync */ 0, + /* xCommit */ 0, + /* xRollback */ 0, + /* xFindMethod */ 0, + /* xRename */ 0, + /* xSavepoint */ 0, + /* xRelease */ 0, + /* xRollbackTo */ 0, + /* xShadowName */ 0 +}; + + +SQLITE_PRIVATE int sqlite3VdbeBytecodeVtabInit(sqlite3 *db){ + int rc; + rc = sqlite3_create_module(db, "bytecode", &bytecodevtabModule, 0); + if( rc==SQLITE_OK ){ + rc = sqlite3_create_module(db, "tables_used", &bytecodevtabModule, &db); + } + return rc; +} +#elif defined(SQLITE_ENABLE_BYTECODE_VTAB) +SQLITE_PRIVATE int sqlite3VdbeBytecodeVtabInit(sqlite3 *db){ return SQLITE_OK; } +#endif /* SQLITE_ENABLE_BYTECODE_VTAB */ + +/************** End of vdbevtab.c ********************************************/ +/************** Begin file memjournal.c **************************************/ +/* +** 2008 October 7 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains code use to implement an in-memory rollback journal. +** The in-memory rollback journal is used to journal transactions for +** ":memory:" databases and when the journal_mode=MEMORY pragma is used. +** +** Update: The in-memory journal is also used to temporarily cache +** smaller journals that are not critical for power-loss recovery. +** For example, statement journals that are not too big will be held +** entirely in memory, thus reducing the number of file I/O calls, and +** more importantly, reducing temporary file creation events. If these +** journals become too large for memory, they are spilled to disk. But +** in the common case, they are usually small and no file I/O needs to +** occur. +*/ +/* #include "sqliteInt.h" */ + +/* Forward references to internal structures */ +typedef struct MemJournal MemJournal; +typedef struct FilePoint FilePoint; +typedef struct FileChunk FileChunk; + +/* +** The rollback journal is composed of a linked list of these structures. +** +** The zChunk array is always at least 8 bytes in size - usually much more. +** Its actual size is stored in the MemJournal.nChunkSize variable. +*/ +struct FileChunk { + FileChunk *pNext; /* Next chunk in the journal */ + u8 zChunk[8]; /* Content of this chunk */ +}; + +/* +** By default, allocate this many bytes of memory for each FileChunk object. +*/ +#define MEMJOURNAL_DFLT_FILECHUNKSIZE 1024 + +/* +** For chunk size nChunkSize, return the number of bytes that should +** be allocated for each FileChunk structure. +*/ +#define fileChunkSize(nChunkSize) (sizeof(FileChunk) + ((nChunkSize)-8)) + +/* +** An instance of this object serves as a cursor into the rollback journal. +** The cursor can be either for reading or writing. +*/ +struct FilePoint { + sqlite3_int64 iOffset; /* Offset from the beginning of the file */ + FileChunk *pChunk; /* Specific chunk into which cursor points */ +}; + +/* +** This structure is a subclass of sqlite3_file. Each open memory-journal +** is an instance of this class. +*/ +struct MemJournal { + const sqlite3_io_methods *pMethod; /* Parent class. MUST BE FIRST */ + int nChunkSize; /* In-memory chunk-size */ + + int nSpill; /* Bytes of data before flushing */ + FileChunk *pFirst; /* Head of in-memory chunk-list */ + FilePoint endpoint; /* Pointer to the end of the file */ + FilePoint readpoint; /* Pointer to the end of the last xRead() */ + + int flags; /* xOpen flags */ + sqlite3_vfs *pVfs; /* The "real" underlying VFS */ + const char *zJournal; /* Name of the journal file */ +}; + +/* +** Read data from the in-memory journal file. This is the implementation +** of the sqlite3_vfs.xRead method. +*/ +static int memjrnlRead( + sqlite3_file *pJfd, /* The journal file from which to read */ + void *zBuf, /* Put the results here */ + int iAmt, /* Number of bytes to read */ + sqlite_int64 iOfst /* Begin reading at this offset */ +){ + MemJournal *p = (MemJournal *)pJfd; + u8 *zOut = zBuf; + int nRead = iAmt; + int iChunkOffset; + FileChunk *pChunk; + + if( (iAmt+iOfst)>p->endpoint.iOffset ){ + return SQLITE_IOERR_SHORT_READ; + } + assert( p->readpoint.iOffset==0 || p->readpoint.pChunk!=0 ); + if( p->readpoint.iOffset!=iOfst || iOfst==0 ){ + sqlite3_int64 iOff = 0; + for(pChunk=p->pFirst; + ALWAYS(pChunk) && (iOff+p->nChunkSize)<=iOfst; + pChunk=pChunk->pNext + ){ + iOff += p->nChunkSize; + } + }else{ + pChunk = p->readpoint.pChunk; + assert( pChunk!=0 ); + } + + iChunkOffset = (int)(iOfst%p->nChunkSize); + do { + int iSpace = p->nChunkSize - iChunkOffset; + int nCopy = MIN(nRead, (p->nChunkSize - iChunkOffset)); + memcpy(zOut, (u8*)pChunk->zChunk + iChunkOffset, nCopy); + zOut += nCopy; + nRead -= iSpace; + iChunkOffset = 0; + } while( nRead>=0 && (pChunk=pChunk->pNext)!=0 && nRead>0 ); + p->readpoint.iOffset = pChunk ? iOfst+iAmt : 0; + p->readpoint.pChunk = pChunk; + + return SQLITE_OK; +} + +/* +** Free the list of FileChunk structures headed at MemJournal.pFirst. +*/ +static void memjrnlFreeChunks(FileChunk *pFirst){ + FileChunk *pIter; + FileChunk *pNext; + for(pIter=pFirst; pIter; pIter=pNext){ + pNext = pIter->pNext; + sqlite3_free(pIter); + } +} + +/* +** Flush the contents of memory to a real file on disk. +*/ +static int memjrnlCreateFile(MemJournal *p){ + int rc; + sqlite3_file *pReal = (sqlite3_file*)p; + MemJournal copy = *p; + + memset(p, 0, sizeof(MemJournal)); + rc = sqlite3OsOpen(copy.pVfs, copy.zJournal, pReal, copy.flags, 0); + if( rc==SQLITE_OK ){ + int nChunk = copy.nChunkSize; + i64 iOff = 0; + FileChunk *pIter; + for(pIter=copy.pFirst; pIter; pIter=pIter->pNext){ + if( iOff + nChunk > copy.endpoint.iOffset ){ + nChunk = copy.endpoint.iOffset - iOff; + } + rc = sqlite3OsWrite(pReal, (u8*)pIter->zChunk, nChunk, iOff); + if( rc ) break; + iOff += nChunk; + } + if( rc==SQLITE_OK ){ + /* No error has occurred. Free the in-memory buffers. */ + memjrnlFreeChunks(copy.pFirst); + } + } + if( rc!=SQLITE_OK ){ + /* If an error occurred while creating or writing to the file, restore + ** the original before returning. This way, SQLite uses the in-memory + ** journal data to roll back changes made to the internal page-cache + ** before this function was called. */ + sqlite3OsClose(pReal); + *p = copy; + } + return rc; +} + + +/* Forward reference */ +static int memjrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size); + +/* +** Write data to the file. +*/ +static int memjrnlWrite( + sqlite3_file *pJfd, /* The journal file into which to write */ + const void *zBuf, /* Take data to be written from here */ + int iAmt, /* Number of bytes to write */ + sqlite_int64 iOfst /* Begin writing at this offset into the file */ +){ + MemJournal *p = (MemJournal *)pJfd; + int nWrite = iAmt; + u8 *zWrite = (u8 *)zBuf; + + /* If the file should be created now, create it and write the new data + ** into the file on disk. */ + if( p->nSpill>0 && (iAmt+iOfst)>p->nSpill ){ + int rc = memjrnlCreateFile(p); + if( rc==SQLITE_OK ){ + rc = sqlite3OsWrite(pJfd, zBuf, iAmt, iOfst); + } + return rc; + } + + /* If the contents of this write should be stored in memory */ + else{ + /* An in-memory journal file should only ever be appended to. Random + ** access writes are not required. The only exception to this is when + ** the in-memory journal is being used by a connection using the + ** atomic-write optimization. In this case the first 28 bytes of the + ** journal file may be written as part of committing the transaction. */ + assert( iOfst<=p->endpoint.iOffset ); + if( iOfst>0 && iOfst!=p->endpoint.iOffset ){ + memjrnlTruncate(pJfd, iOfst); + } + if( iOfst==0 && p->pFirst ){ + assert( p->nChunkSize>iAmt ); + memcpy((u8*)p->pFirst->zChunk, zBuf, iAmt); + }else{ + while( nWrite>0 ){ + FileChunk *pChunk = p->endpoint.pChunk; + int iChunkOffset = (int)(p->endpoint.iOffset%p->nChunkSize); + int iSpace = MIN(nWrite, p->nChunkSize - iChunkOffset); + + assert( pChunk!=0 || iChunkOffset==0 ); + if( iChunkOffset==0 ){ + /* New chunk is required to extend the file. */ + FileChunk *pNew = sqlite3_malloc(fileChunkSize(p->nChunkSize)); + if( !pNew ){ + return SQLITE_IOERR_NOMEM_BKPT; + } + pNew->pNext = 0; + if( pChunk ){ + assert( p->pFirst ); + pChunk->pNext = pNew; + }else{ + assert( !p->pFirst ); + p->pFirst = pNew; + } + pChunk = p->endpoint.pChunk = pNew; + } + + assert( pChunk!=0 ); + memcpy((u8*)pChunk->zChunk + iChunkOffset, zWrite, iSpace); + zWrite += iSpace; + nWrite -= iSpace; + p->endpoint.iOffset += iSpace; + } + } + } + + return SQLITE_OK; +} + +/* +** Truncate the in-memory file. +*/ +static int memjrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){ + MemJournal *p = (MemJournal *)pJfd; + assert( p->endpoint.pChunk==0 || p->endpoint.pChunk->pNext==0 ); + if( sizeendpoint.iOffset ){ + FileChunk *pIter = 0; + if( size==0 ){ + memjrnlFreeChunks(p->pFirst); + p->pFirst = 0; + }else{ + i64 iOff = p->nChunkSize; + for(pIter=p->pFirst; ALWAYS(pIter) && iOffpNext){ + iOff += p->nChunkSize; + } + if( ALWAYS(pIter) ){ + memjrnlFreeChunks(pIter->pNext); + pIter->pNext = 0; + } + } + + p->endpoint.pChunk = pIter; + p->endpoint.iOffset = size; + p->readpoint.pChunk = 0; + p->readpoint.iOffset = 0; + } + return SQLITE_OK; +} + +/* +** Close the file. +*/ +static int memjrnlClose(sqlite3_file *pJfd){ + MemJournal *p = (MemJournal *)pJfd; + memjrnlFreeChunks(p->pFirst); + return SQLITE_OK; +} + +/* +** Sync the file. +** +** If the real file has been created, call its xSync method. Otherwise, +** syncing an in-memory journal is a no-op. +*/ +static int memjrnlSync(sqlite3_file *pJfd, int flags){ + UNUSED_PARAMETER2(pJfd, flags); + return SQLITE_OK; +} + +/* +** Query the size of the file in bytes. +*/ +static int memjrnlFileSize(sqlite3_file *pJfd, sqlite_int64 *pSize){ + MemJournal *p = (MemJournal *)pJfd; + *pSize = (sqlite_int64) p->endpoint.iOffset; + return SQLITE_OK; +} + +/* +** Table of methods for MemJournal sqlite3_file object. +*/ +static const struct sqlite3_io_methods MemJournalMethods = { + 1, /* iVersion */ + memjrnlClose, /* xClose */ + memjrnlRead, /* xRead */ + memjrnlWrite, /* xWrite */ + memjrnlTruncate, /* xTruncate */ + memjrnlSync, /* xSync */ + memjrnlFileSize, /* xFileSize */ + 0, /* xLock */ + 0, /* xUnlock */ + 0, /* xCheckReservedLock */ + 0, /* xFileControl */ + 0, /* xSectorSize */ + 0, /* xDeviceCharacteristics */ + 0, /* xShmMap */ + 0, /* xShmLock */ + 0, /* xShmBarrier */ + 0, /* xShmUnmap */ + 0, /* xFetch */ + 0 /* xUnfetch */ +}; + +/* +** Open a journal file. +** +** The behaviour of the journal file depends on the value of parameter +** nSpill. If nSpill is 0, then the journal file is always create and +** accessed using the underlying VFS. If nSpill is less than zero, then +** all content is always stored in main-memory. Finally, if nSpill is a +** positive value, then the journal file is initially created in-memory +** but may be flushed to disk later on. In this case the journal file is +** flushed to disk either when it grows larger than nSpill bytes in size, +** or when sqlite3JournalCreate() is called. +*/ +SQLITE_PRIVATE int sqlite3JournalOpen( + sqlite3_vfs *pVfs, /* The VFS to use for actual file I/O */ + const char *zName, /* Name of the journal file */ + sqlite3_file *pJfd, /* Preallocated, blank file handle */ + int flags, /* Opening flags */ + int nSpill /* Bytes buffered before opening the file */ +){ + MemJournal *p = (MemJournal*)pJfd; + + assert( zName || nSpill<0 || (flags & SQLITE_OPEN_EXCLUSIVE) ); + + /* Zero the file-handle object. If nSpill was passed zero, initialize + ** it using the sqlite3OsOpen() function of the underlying VFS. In this + ** case none of the code in this module is executed as a result of calls + ** made on the journal file-handle. */ + memset(p, 0, sizeof(MemJournal)); + if( nSpill==0 ){ + return sqlite3OsOpen(pVfs, zName, pJfd, flags, 0); + } + + if( nSpill>0 ){ + p->nChunkSize = nSpill; + }else{ + p->nChunkSize = 8 + MEMJOURNAL_DFLT_FILECHUNKSIZE - sizeof(FileChunk); + assert( MEMJOURNAL_DFLT_FILECHUNKSIZE==fileChunkSize(p->nChunkSize) ); + } + + pJfd->pMethods = (const sqlite3_io_methods*)&MemJournalMethods; + p->nSpill = nSpill; + p->flags = flags; + p->zJournal = zName; + p->pVfs = pVfs; + return SQLITE_OK; +} + +/* +** Open an in-memory journal file. +*/ +SQLITE_PRIVATE void sqlite3MemJournalOpen(sqlite3_file *pJfd){ + sqlite3JournalOpen(0, 0, pJfd, 0, -1); +} + +#if defined(SQLITE_ENABLE_ATOMIC_WRITE) \ + || defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE) +/* +** If the argument p points to a MemJournal structure that is not an +** in-memory-only journal file (i.e. is one that was opened with a +ve +** nSpill parameter or as SQLITE_OPEN_MAIN_JOURNAL), and the underlying +** file has not yet been created, create it now. +*/ +SQLITE_PRIVATE int sqlite3JournalCreate(sqlite3_file *pJfd){ + int rc = SQLITE_OK; + MemJournal *p = (MemJournal*)pJfd; + if( pJfd->pMethods==&MemJournalMethods && ( +#ifdef SQLITE_ENABLE_ATOMIC_WRITE + p->nSpill>0 +#else + /* While this appears to not be possible without ATOMIC_WRITE, the + ** paths are complex, so it seems prudent to leave the test in as + ** a NEVER(), in case our analysis is subtly flawed. */ + NEVER(p->nSpill>0) +#endif +#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE + || (p->flags & SQLITE_OPEN_MAIN_JOURNAL) +#endif + )){ + rc = memjrnlCreateFile(p); + } + return rc; +} +#endif + +/* +** The file-handle passed as the only argument is open on a journal file. +** Return true if this "journal file" is currently stored in heap memory, +** or false otherwise. +*/ +SQLITE_PRIVATE int sqlite3JournalIsInMemory(sqlite3_file *p){ + return p->pMethods==&MemJournalMethods; +} + +/* +** Return the number of bytes required to store a JournalFile that uses vfs +** pVfs to create the underlying on-disk files. +*/ +SQLITE_PRIVATE int sqlite3JournalSize(sqlite3_vfs *pVfs){ + return MAX(pVfs->szOsFile, (int)sizeof(MemJournal)); +} + +/************** End of memjournal.c ******************************************/ +/************** Begin file crypto.c ******************************************/ +/* +** SQLCipher +** http://sqlcipher.net +** +** Copyright (c) 2008 - 2013, ZETETIC LLC +** All rights reserved. +** +** Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in the +** documentation and/or other materials provided with the distribution. +** * Neither the name of the ZETETIC LLC nor the +** names of its contributors may be used to endorse or promote products +** derived from this software without specific prior written permission. +** +** THIS SOFTWARE IS PROVIDED BY ZETETIC LLC ''AS IS'' AND ANY +** EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +** DISCLAIMED. IN NO EVENT SHALL ZETETIC LLC BE LIABLE FOR ANY +** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +** +*/ +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC + +/* #include */ +/************** Include sqlcipher.h in the middle of crypto.c ****************/ +/************** Begin file sqlcipher.h ***************************************/ +/* +** SQLCipher +** sqlcipher.h developed by Stephen Lombardo (Zetetic LLC) +** sjlombardo at zetetic dot net +** http://zetetic.net +** +** Copyright (c) 2008, ZETETIC LLC +** All rights reserved. +** +** Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in the +** documentation and/or other materials provided with the distribution. +** * Neither the name of the ZETETIC LLC nor the +** names of its contributors may be used to endorse or promote products +** derived from this software without specific prior written permission. +** +** THIS SOFTWARE IS PROVIDED BY ZETETIC LLC ''AS IS'' AND ANY +** EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +** DISCLAIMED. IN NO EVENT SHALL ZETETIC LLC BE LIABLE FOR ANY +** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +** +*/ +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC +#ifndef SQLCIPHER_H +#define SQLCIPHER_H + +/* #include "sqlite3.h" */ + +#define SQLCIPHER_HMAC_SHA1 0 +#define SQLCIPHER_HMAC_SHA1_LABEL "HMAC_SHA1" +#define SQLCIPHER_HMAC_SHA256 1 +#define SQLCIPHER_HMAC_SHA256_LABEL "HMAC_SHA256" +#define SQLCIPHER_HMAC_SHA512 2 +#define SQLCIPHER_HMAC_SHA512_LABEL "HMAC_SHA512" + + +#define SQLCIPHER_PBKDF2_HMAC_SHA1 0 +#define SQLCIPHER_PBKDF2_HMAC_SHA1_LABEL "PBKDF2_HMAC_SHA1" +#define SQLCIPHER_PBKDF2_HMAC_SHA256 1 +#define SQLCIPHER_PBKDF2_HMAC_SHA256_LABEL "PBKDF2_HMAC_SHA256" +#define SQLCIPHER_PBKDF2_HMAC_SHA512 2 +#define SQLCIPHER_PBKDF2_HMAC_SHA512_LABEL "PBKDF2_HMAC_SHA512" + + +typedef struct { + int (*activate)(void *ctx); + int (*deactivate)(void *ctx); + const char* (*get_provider_name)(void *ctx); + int (*add_random)(void *ctx, void *buffer, int length); + int (*random)(void *ctx, void *buffer, int length); + int (*hmac)(void *ctx, int algorithm, unsigned char *hmac_key, int key_sz, unsigned char *in, int in_sz, unsigned char *in2, int in2_sz, unsigned char *out); + int (*kdf)(void *ctx, int algorithm, const unsigned char *pass, int pass_sz, unsigned char* salt, int salt_sz, int workfactor, int key_sz, unsigned char *key); + int (*cipher)(void *ctx, int mode, unsigned char *key, int key_sz, unsigned char *iv, unsigned char *in, int in_sz, unsigned char *out); + const char* (*get_cipher)(void *ctx); + int (*get_key_sz)(void *ctx); + int (*get_iv_sz)(void *ctx); + int (*get_block_sz)(void *ctx); + int (*get_hmac_sz)(void *ctx, int algorithm); + int (*ctx_init)(void **ctx); + int (*ctx_free)(void **ctx); + int (*fips_status)(void *ctx); + const char* (*get_provider_version)(void *ctx); +} sqlcipher_provider; + +/* utility functions */ +void* sqlcipher_malloc(sqlite_uint64); +void sqlcipher_mlock(void *, sqlite_uint64); +void sqlcipher_munlock(void *, sqlite_uint64); +void* sqlcipher_memset(void *, unsigned char, sqlite_uint64); +int sqlcipher_ismemset(const void *, unsigned char, sqlite_uint64); +int sqlcipher_memcmp(const void *, const void *, int); +void sqlcipher_free(void *, sqlite_uint64); +char* sqlcipher_version(); + +/* provider interfaces */ +int sqlcipher_register_provider(sqlcipher_provider *); +sqlcipher_provider* sqlcipher_get_provider(void); + +#define SQLCIPHER_MUTEX_PROVIDER 0 +#define SQLCIPHER_MUTEX_PROVIDER_ACTIVATE 1 +#define SQLCIPHER_MUTEX_PROVIDER_RAND 2 +#define SQLCIPHER_MUTEX_RESERVED1 3 +#define SQLCIPHER_MUTEX_RESERVED2 4 +#define SQLCIPHER_MUTEX_RESERVED3 5 +#define SQLCIPHER_MUTEX_COUNT 6 + +sqlite3_mutex* sqlcipher_mutex(int); + +#endif +#endif +/* END SQLCIPHER */ + + +/************** End of sqlcipher.h *******************************************/ +/************** Continuing where we left off in crypto.c *********************/ +/************** Include crypto.h in the middle of crypto.c *******************/ +/************** Begin file crypto.h ******************************************/ +/* +** SQLCipher +** crypto.h developed by Stephen Lombardo (Zetetic LLC) +** sjlombardo at zetetic dot net +** http://zetetic.net +** +** Copyright (c) 2008, ZETETIC LLC +** All rights reserved. +** +** Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in the +** documentation and/or other materials provided with the distribution. +** * Neither the name of the ZETETIC LLC nor the +** names of its contributors may be used to endorse or promote products +** derived from this software without specific prior written permission. +** +** THIS SOFTWARE IS PROVIDED BY ZETETIC LLC ''AS IS'' AND ANY +** EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +** DISCLAIMED. IN NO EVENT SHALL ZETETIC LLC BE LIABLE FOR ANY +** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +** +*/ +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC +#ifndef CRYPTO_H +#define CRYPTO_H + +/* #include "sqliteInt.h" */ +/* #include "btreeInt.h" */ +/* #include "pager.h" */ +/* #include "vdbeInt.h" */ + +#ifdef __ANDROID__ +#include +#endif + +/* #include */ + +#if defined(_WIN32) || defined(SQLITE_OS_WINRT) +/* #include ** amalgamator: dontcache ** */ +#else +/* #include ** amalgamator: dontcache ** */ +#endif + +#ifndef OMIT_MEMLOCK +#if defined(__unix__) || defined(__APPLE__) || defined(_AIX) +/* #include ** amalgamator: dontcache ** */ +/* #include ** amalgamator: dontcache ** */ +#include /* amalgamator: dontcache */ +/* #include ** amalgamator: dontcache ** */ +#endif +#endif + +/* #include "sqlcipher.h" */ + +/* extensions defined in pager.c */ +void *sqlcipherPagerGetCodec(Pager*); +void sqlcipherPagerSetCodec(Pager*, void *(*)(void*,void*,Pgno,int), void (*)(void*,int,int), void (*)(void*), void *); +SQLITE_API int sqlite3pager_is_sj_pgno(Pager*, Pgno); +SQLITE_API void sqlite3pager_error(Pager*, int); +SQLITE_API void sqlite3pager_reset(Pager *pPager); +/* end extensions defined in pager.c */ + +#if !defined (SQLCIPHER_CRYPTO_CC) \ + && !defined (SQLCIPHER_CRYPTO_LIBTOMCRYPT) \ + && !defined (SQLCIPHER_CRYPTO_NSS) \ + && !defined (SQLCIPHER_CRYPTO_OPENSSL) +#define SQLCIPHER_CRYPTO_OPENSSL +#endif + +#define FILE_HEADER_SZ 16 + +#define CIPHER_XSTR(s) CIPHER_STR(s) +#define CIPHER_STR(s) #s + +#ifndef CIPHER_VERSION_NUMBER +#define CIPHER_VERSION_NUMBER 4.5.5 +#endif + +#ifndef CIPHER_VERSION_BUILD +#define CIPHER_VERSION_BUILD community +#endif + +#define CIPHER_DECRYPT 0 +#define CIPHER_ENCRYPT 1 + +#define CIPHER_READ_CTX 0 +#define CIPHER_WRITE_CTX 1 +#define CIPHER_READWRITE_CTX 2 + +#ifndef PBKDF2_ITER +#define PBKDF2_ITER 256000 +#endif + +#define SQLCIPHER_FLAG_GET(FLAG,BIT) ((FLAG & BIT) != 0) +#define SQLCIPHER_FLAG_SET(FLAG,BIT) FLAG |= BIT +#define SQLCIPHER_FLAG_UNSET(FLAG,BIT) FLAG &= ~BIT + +/* possible flags for codec_ctx->flags */ +#define CIPHER_FLAG_HMAC (1 << 0) +#define CIPHER_FLAG_LE_PGNO (1 << 1) +#define CIPHER_FLAG_BE_PGNO (1 << 2) +#define CIPHER_FLAG_KEY_USED (1 << 3) +#define CIPHER_FLAG_HAS_KDF_SALT (1 << 4) + + +#ifndef DEFAULT_CIPHER_FLAGS +#define DEFAULT_CIPHER_FLAGS CIPHER_FLAG_HMAC | CIPHER_FLAG_LE_PGNO +#endif + + +/* by default, sqlcipher will use a reduced number of iterations to generate + the HMAC key / or transform a raw cipher key + */ +#ifndef FAST_PBKDF2_ITER +#define FAST_PBKDF2_ITER 2 +#endif + +/* this if a fixed random array that will be xor'd with the database salt to ensure that the + salt passed to the HMAC key derivation function is not the same as that used to derive + the encryption key. This can be overridden at compile time but it will make the resulting + binary incompatible with the default builds when using HMAC. A future version of SQLcipher + will likely allow this to be defined at runtime via pragma */ +#ifndef HMAC_SALT_MASK +#define HMAC_SALT_MASK 0x3a +#endif + +#ifndef CIPHER_MAX_IV_SZ +#define CIPHER_MAX_IV_SZ 16 +#endif + +#ifndef CIPHER_MAX_KEY_SZ +#define CIPHER_MAX_KEY_SZ 64 +#endif + + +/* +** Simple shared routines for converting hex char strings to binary data + */ +static int cipher_hex2int(char c) { + return (c>='0' && c<='9') ? (c)-'0' : + (c>='A' && c<='F') ? (c)-'A'+10 : + (c>='a' && c<='f') ? (c)-'a'+10 : 0; +} + +static void cipher_hex2bin(const unsigned char *hex, int sz, unsigned char *out){ + int i; + for(i = 0; i < sz; i += 2){ + out[i/2] = (cipher_hex2int(hex[i])<<4) | cipher_hex2int(hex[i+1]); + } +} + +static void cipher_bin2hex(const unsigned char* in, int sz, char *out) { + int i; + for(i=0; i < sz; i++) { + sqlite3_snprintf(3, out + (i*2), "%02x ", in[i]); + } +} + +static int cipher_isHex(const unsigned char *hex, int sz){ + int i; + for(i = 0; i < sz; i++) { + unsigned char c = hex[i]; + if ((c < '0' || c > '9') && + (c < 'A' || c > 'F') && + (c < 'a' || c > 'f')) { + return 0; + } + } + return 1; +} + +/* possible flags for simulating specific test conditions */ +#ifdef SQLCIPHER_TEST +#define TEST_FAIL_ENCRYPT 0x01 +#define TEST_FAIL_DECRYPT 0x02 +#define TEST_FAIL_MIGRATE 0x04 +unsigned int sqlcipher_get_test_flags(void); +void sqlcipher_set_test_flags(unsigned int); +int sqlcipher_get_test_rand(void); +void sqlcipher_set_test_rand(int); +int sqlcipher_get_test_fail(void); +#endif + +/* extensions defined in crypto_impl.c */ +/* the default implementation of SQLCipher uses a cipher_ctx + to keep track of read / write state separately. The following + struct and associated functions are defined here */ +typedef struct { + int derive_key; + int pass_sz; + unsigned char *key; + unsigned char *hmac_key; + unsigned char *pass; + char *keyspec; +} cipher_ctx; + + +typedef struct { + int store_pass; + int kdf_iter; + int fast_kdf_iter; + int kdf_salt_sz; + int key_sz; + int iv_sz; + int block_sz; + int page_sz; + int keyspec_sz; + int reserve_sz; + int hmac_sz; + int plaintext_header_sz; + int hmac_algorithm; + int kdf_algorithm; + unsigned int flags; + unsigned char *kdf_salt; + unsigned char *hmac_kdf_salt; + unsigned char *buffer; + Btree *pBt; + cipher_ctx *read_ctx; + cipher_ctx *write_ctx; + sqlcipher_provider *provider; + void *provider_ctx; +} codec_ctx ; + +/* crypto.c functions */ +int sqlcipher_codec_pragma(sqlite3*, int, Parse*, const char *, const char*); +int sqlcipherCodecAttach(sqlite3*, int, const void *, int); +void sqlcipherCodecGetKey(sqlite3*, int, void**, int*); +void sqlcipher_exportFunc(sqlite3_context *, int, sqlite3_value **); + +/* crypto_impl.c functions */ + +void sqlcipher_init_memmethods(void); + +/* activation and initialization */ +void sqlcipher_activate(void); +void sqlcipher_deactivate(void); + +int sqlcipher_codec_ctx_init(codec_ctx **, Db *, Pager *, const void *, int); +void sqlcipher_codec_ctx_free(codec_ctx **); +int sqlcipher_codec_key_derive(codec_ctx *); +int sqlcipher_codec_key_copy(codec_ctx *, int); + +/* page cipher implementation */ +int sqlcipher_page_cipher(codec_ctx *, int, Pgno, int, int, unsigned char *, unsigned char *); + +/* context setters & getters */ +void sqlcipher_codec_ctx_set_error(codec_ctx *, int); + +void sqlcipher_codec_get_pass(codec_ctx *, void **, int *); +int sqlcipher_codec_ctx_set_pass(codec_ctx *, const void *, int, int); +void sqlcipher_codec_get_keyspec(codec_ctx *, void **zKey, int *nKey); + +int sqlcipher_codec_ctx_set_pagesize(codec_ctx *, int); +int sqlcipher_codec_ctx_get_pagesize(codec_ctx *); +int sqlcipher_codec_ctx_get_reservesize(codec_ctx *); + +void sqlcipher_set_default_pagesize(int page_size); +int sqlcipher_get_default_pagesize(void); + +void sqlcipher_set_default_kdf_iter(int iter); +int sqlcipher_get_default_kdf_iter(void); +int sqlcipher_codec_ctx_set_kdf_iter(codec_ctx *, int); +int sqlcipher_codec_ctx_get_kdf_iter(codec_ctx *ctx); + +int sqlcipher_codec_ctx_set_kdf_salt(codec_ctx *ctx, unsigned char *salt, int sz); +int sqlcipher_codec_ctx_get_kdf_salt(codec_ctx *ctx, void **salt); + +int sqlcipher_codec_ctx_set_fast_kdf_iter(codec_ctx *, int); +int sqlcipher_codec_ctx_get_fast_kdf_iter(codec_ctx *); + +const char* sqlcipher_codec_ctx_get_cipher(codec_ctx *ctx); + +void* sqlcipher_codec_ctx_get_data(codec_ctx *); + +void sqlcipher_set_default_use_hmac(int use); +int sqlcipher_get_default_use_hmac(void); + +void sqlcipher_set_hmac_salt_mask(unsigned char mask); +unsigned char sqlcipher_get_hmac_salt_mask(void); + +int sqlcipher_codec_ctx_set_use_hmac(codec_ctx *ctx, int use); +int sqlcipher_codec_ctx_get_use_hmac(codec_ctx *ctx); + +const char* sqlcipher_codec_get_cipher_provider(codec_ctx *ctx); +int sqlcipher_codec_ctx_migrate(codec_ctx *ctx); +int sqlcipher_codec_add_random(codec_ctx *ctx, const char *data, int random_sz); +int sqlcipher_cipher_profile(sqlite3 *db, const char *destination); +int sqlcipher_codec_get_store_pass(codec_ctx *ctx); +void sqlcipher_codec_get_pass(codec_ctx *ctx, void **zKey, int *nKey); +void sqlcipher_codec_set_store_pass(codec_ctx *ctx, int value); +int sqlcipher_codec_fips_status(codec_ctx *ctx); +const char* sqlcipher_codec_get_provider_version(codec_ctx *ctx); + +int sqlcipher_set_default_plaintext_header_size(int size); +int sqlcipher_get_default_plaintext_header_size(void); +int sqlcipher_codec_ctx_set_plaintext_header_size(codec_ctx *ctx, int size); +int sqlcipher_codec_ctx_get_plaintext_header_size(codec_ctx *ctx); + +int sqlcipher_set_default_hmac_algorithm(int algorithm); +int sqlcipher_get_default_hmac_algorithm(void); +int sqlcipher_codec_ctx_set_hmac_algorithm(codec_ctx *ctx, int algorithm); +int sqlcipher_codec_ctx_get_hmac_algorithm(codec_ctx *ctx); + +int sqlcipher_set_default_kdf_algorithm(int algorithm); +int sqlcipher_get_default_kdf_algorithm(void); +int sqlcipher_codec_ctx_set_kdf_algorithm(codec_ctx *ctx, int algorithm); +int sqlcipher_codec_ctx_get_kdf_algorithm(codec_ctx *ctx); + +void sqlcipher_set_mem_security(int); +int sqlcipher_get_mem_security(void); + +int sqlcipher_find_db_index(sqlite3 *db, const char *zDb); + +int sqlcipher_codec_ctx_integrity_check(codec_ctx *, Parse *, char *); + +int sqlcipher_set_log(const char *destination); +void sqlcipher_set_log_level(unsigned int level); +void sqlcipher_log(unsigned int tag, const char *message, ...); + +#define SQLCIPHER_LOG_NONE 0x00 +#define SQLCIPHER_LOG_ERROR 0x01 +#define SQLCIPHER_LOG_WARN 0x02 +#define SQLCIPHER_LOG_INFO 0x04 +#define SQLCIPHER_LOG_DEBUG 0x08 +#define SQLCIPHER_LOG_TRACE 0x10 +#define SQLCIPHER_LOG_ALL 0xffffffff + +void sqlcipher_vdbe_return_string(Parse*, const char*, const char*, int); + +#ifdef CODEC_DEBUG_PAGEDATA +#define CODEC_HEXDUMP(DESC,BUFFER,LEN) \ + { \ + int __pctr; \ + printf(DESC); \ + for(__pctr=0; __pctr < LEN; __pctr++) { \ + if(__pctr % 16 == 0) printf("\n%05x: ",__pctr); \ + printf("%02x ",((unsigned char*) BUFFER)[__pctr]); \ + } \ + printf("\n"); \ + fflush(stdout); \ + } +#else +#define CODEC_HEXDUMP(DESC,BUFFER,LEN) +#endif + +#endif +#endif +/* END SQLCIPHER */ + + +/************** End of crypto.h **********************************************/ +/************** Continuing where we left off in crypto.c *********************/ + +#ifdef SQLCIPHER_EXT +#include "sqlcipher_ext.h" +#endif + +void sqlcipher_vdbe_return_string(Parse *pParse, const char *zLabel, const char *value, int value_type){ + Vdbe *v = sqlite3GetVdbe(pParse); + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLabel, SQLITE_STATIC); + sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, value, value_type); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1); +} + +static int codec_set_btree_to_codec_pagesize(sqlite3 *db, Db *pDb, codec_ctx *ctx) { + int rc, page_sz, reserve_sz; + + page_sz = sqlcipher_codec_ctx_get_pagesize(ctx); + reserve_sz = sqlcipher_codec_ctx_get_reservesize(ctx); + + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "codec_set_btree_to_codec_pagesize: sqlite3BtreeSetPageSize() size=%d reserve=%d", page_sz, reserve_sz); + + sqlcipher_log(SQLCIPHER_LOG_TRACE, "codec_set_btree_to_codec_pagesize: entering database mutex %p", db->mutex); + sqlite3_mutex_enter(db->mutex); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "codec_set_btree_to_codec_pagesize: entered database mutex %p", db->mutex); + db->nextPagesize = page_sz; + + /* before forcing the page size we need to unset the BTS_PAGESIZE_FIXED flag, else + sqliteBtreeSetPageSize will block the change */ + pDb->pBt->pBt->btsFlags &= ~BTS_PAGESIZE_FIXED; + rc = sqlite3BtreeSetPageSize(pDb->pBt, page_sz, reserve_sz, 0); + + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "codec_set_btree_to_codec_pagesize: sqlite3BtreeSetPageSize returned %d", rc); + + sqlcipher_log(SQLCIPHER_LOG_TRACE, "codec_set_btree_to_codec_pagesize: leaving database mutex %p", db->mutex); + sqlite3_mutex_leave(db->mutex); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "codec_set_btree_to_codec_pagesize: left database mutex %p", db->mutex); + + return rc; +} + +static int codec_set_pass_key(sqlite3* db, int nDb, const void *zKey, int nKey, int for_ctx) { + struct Db *pDb = &db->aDb[nDb]; + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "codec_set_pass_key: db=%p nDb=%d for_ctx=%d", db, nDb, for_ctx); + if(pDb->pBt) { + codec_ctx *ctx = (codec_ctx*) sqlcipherPagerGetCodec(pDb->pBt->pBt->pPager); + + if(ctx) { + return sqlcipher_codec_ctx_set_pass(ctx, zKey, nKey, for_ctx); + } else { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "codec_set_pass_key: error ocurred fetching codec from pager on db %d", nDb); + return SQLITE_ERROR; + } + } + sqlcipher_log(SQLCIPHER_LOG_ERROR, "codec_set_pass_key: no btree present on db %d", nDb); + return SQLITE_ERROR; +} + +int sqlcipher_codec_pragma(sqlite3* db, int iDb, Parse *pParse, const char *zLeft, const char *zRight) { + struct Db *pDb = &db->aDb[iDb]; + codec_ctx *ctx = NULL; + int rc; + + if(pDb->pBt) { + ctx = (codec_ctx*) sqlcipherPagerGetCodec(pDb->pBt->pBt->pPager); + } + + if(sqlite3_stricmp(zLeft, "key") !=0 && sqlite3_stricmp(zLeft, "rekey") != 0) { + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipher_codec_pragma: db=%p iDb=%d pParse=%p zLeft=%s zRight=%s ctx=%p", db, iDb, pParse, zLeft, zRight, ctx); + } + +#ifdef SQLCIPHER_EXT + if(sqlcipher_ext_pragma(db, iDb, pParse, zLeft, zRight)) { + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipher_codec_pragma: PRAGMA handled by sqlcipher_ext_pragma"); + } else +#endif +#ifdef SQLCIPHER_TEST + if( sqlite3_stricmp(zLeft,"cipher_test_on")==0 ){ + if( zRight ) { + unsigned int flags = sqlcipher_get_test_flags(); + if(sqlite3_stricmp(zRight, "fail_encrypt")==0) { + SQLCIPHER_FLAG_SET(flags,TEST_FAIL_ENCRYPT); + } else + if(sqlite3_stricmp(zRight, "fail_decrypt")==0) { + SQLCIPHER_FLAG_SET(flags,TEST_FAIL_DECRYPT); + } else + if(sqlite3_stricmp(zRight, "fail_migrate")==0) { + SQLCIPHER_FLAG_SET(flags,TEST_FAIL_MIGRATE); + } + sqlcipher_set_test_flags(flags); + } + } else + if( sqlite3_stricmp(zLeft,"cipher_test_off")==0 ){ + if( zRight ) { + unsigned int flags = sqlcipher_get_test_flags(); + if(sqlite3_stricmp(zRight, "fail_encrypt")==0) { + SQLCIPHER_FLAG_UNSET(flags,TEST_FAIL_ENCRYPT); + } else + if(sqlite3_stricmp(zRight, "fail_decrypt")==0) { + SQLCIPHER_FLAG_UNSET(flags,TEST_FAIL_DECRYPT); + } else + if(sqlite3_stricmp(zRight, "fail_migrate")==0) { + SQLCIPHER_FLAG_UNSET(flags,TEST_FAIL_MIGRATE); + } + sqlcipher_set_test_flags(flags); + } + } else + if( sqlite3_stricmp(zLeft,"cipher_test")==0 ){ + char *flags = sqlite3_mprintf("%u", sqlcipher_get_test_flags()); + sqlcipher_vdbe_return_string(pParse, "cipher_test", flags, P4_DYNAMIC); + }else + if( sqlite3_stricmp(zLeft,"cipher_test_rand")==0 ){ + if( zRight ) { + int rand = atoi(zRight); + sqlcipher_set_test_rand(rand); + } else { + char *rand = sqlite3_mprintf("%d", sqlcipher_get_test_rand()); + sqlcipher_vdbe_return_string(pParse, "cipher_test_rand", rand, P4_DYNAMIC); + } + } else +#endif + if( sqlite3_stricmp(zLeft, "cipher_fips_status")== 0 && !zRight ){ + if(ctx) { + char *fips_mode_status = sqlite3_mprintf("%d", sqlcipher_codec_fips_status(ctx)); + sqlcipher_vdbe_return_string(pParse, "cipher_fips_status", fips_mode_status, P4_DYNAMIC); + } + } else + if( sqlite3_stricmp(zLeft, "cipher_store_pass")==0 && zRight ) { + if(ctx) { + char *deprecation = "PRAGMA cipher_store_pass is deprecated, please remove from use"; + sqlcipher_codec_set_store_pass(ctx, sqlite3GetBoolean(zRight, 1)); + sqlcipher_vdbe_return_string(pParse, "cipher_store_pass", deprecation, P4_TRANSIENT); + sqlite3_log(SQLITE_WARNING, deprecation); + } + } else + if( sqlite3_stricmp(zLeft, "cipher_store_pass")==0 && !zRight ) { + if(ctx){ + char *store_pass_value = sqlite3_mprintf("%d", sqlcipher_codec_get_store_pass(ctx)); + sqlcipher_vdbe_return_string(pParse, "cipher_store_pass", store_pass_value, P4_DYNAMIC); + } + } + if( sqlite3_stricmp(zLeft, "cipher_profile")== 0 && zRight ){ + char *profile_status = sqlite3_mprintf("%d", sqlcipher_cipher_profile(db, zRight)); + sqlcipher_vdbe_return_string(pParse, "cipher_profile", profile_status, P4_DYNAMIC); + } else + if( sqlite3_stricmp(zLeft, "cipher_add_random")==0 && zRight ){ + if(ctx) { + char *add_random_status = sqlite3_mprintf("%d", sqlcipher_codec_add_random(ctx, zRight, sqlite3Strlen30(zRight))); + sqlcipher_vdbe_return_string(pParse, "cipher_add_random", add_random_status, P4_DYNAMIC); + } + } else + if( sqlite3_stricmp(zLeft, "cipher_migrate")==0 && !zRight ){ + if(ctx){ + int status = sqlcipher_codec_ctx_migrate(ctx); + char *migrate_status = sqlite3_mprintf("%d", status); + sqlcipher_vdbe_return_string(pParse, "cipher_migrate", migrate_status, P4_DYNAMIC); + if(status != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_pragma: error occurred during cipher_migrate: %d", status); + sqlcipher_codec_ctx_set_error(ctx, status); + } + } + } else + if( sqlite3_stricmp(zLeft, "cipher_provider")==0 && !zRight ){ + if(ctx) { sqlcipher_vdbe_return_string(pParse, "cipher_provider", + sqlcipher_codec_get_cipher_provider(ctx), P4_TRANSIENT); + } + } else + if( sqlite3_stricmp(zLeft, "cipher_provider_version")==0 && !zRight){ + if(ctx) { sqlcipher_vdbe_return_string(pParse, "cipher_provider_version", + sqlcipher_codec_get_provider_version(ctx), P4_TRANSIENT); + } + } else + if( sqlite3_stricmp(zLeft, "cipher_version")==0 && !zRight ){ + sqlcipher_vdbe_return_string(pParse, "cipher_version", sqlcipher_version(), P4_DYNAMIC); + }else + if( sqlite3_stricmp(zLeft, "cipher")==0 ){ + if(ctx) { + if( zRight ) { + const char* message = "PRAGMA cipher is no longer supported."; + sqlcipher_vdbe_return_string(pParse, "cipher", message, P4_TRANSIENT); + sqlite3_log(SQLITE_WARNING, message); + }else { + sqlcipher_vdbe_return_string(pParse, "cipher", sqlcipher_codec_ctx_get_cipher(ctx), P4_TRANSIENT); + } + } + }else + if( sqlite3_stricmp(zLeft, "rekey_cipher")==0 && zRight ){ + const char* message = "PRAGMA rekey_cipher is no longer supported."; + sqlcipher_vdbe_return_string(pParse, "rekey_cipher", message, P4_TRANSIENT); + sqlite3_log(SQLITE_WARNING, message); + }else + if( sqlite3_stricmp(zLeft,"cipher_default_kdf_iter")==0 ){ + if( zRight ) { + sqlcipher_set_default_kdf_iter(atoi(zRight)); /* change default KDF iterations */ + } else { + char *kdf_iter = sqlite3_mprintf("%d", sqlcipher_get_default_kdf_iter()); + sqlcipher_vdbe_return_string(pParse, "cipher_default_kdf_iter", kdf_iter, P4_DYNAMIC); + } + }else + if( sqlite3_stricmp(zLeft, "kdf_iter")==0 ){ + if(ctx) { + if( zRight ) { + sqlcipher_codec_ctx_set_kdf_iter(ctx, atoi(zRight)); /* change of RW PBKDF2 iteration */ + } else { + char *kdf_iter = sqlite3_mprintf("%d", sqlcipher_codec_ctx_get_kdf_iter(ctx)); + sqlcipher_vdbe_return_string(pParse, "kdf_iter", kdf_iter, P4_DYNAMIC); + } + } + }else + if( sqlite3_stricmp(zLeft, "fast_kdf_iter")==0){ + if(ctx) { + if( zRight ) { + char *deprecation = "PRAGMA fast_kdf_iter is deprecated, please remove from use"; + sqlcipher_codec_ctx_set_fast_kdf_iter(ctx, atoi(zRight)); /* change of RW PBKDF2 iteration */ + sqlcipher_vdbe_return_string(pParse, "fast_kdf_iter", deprecation, P4_TRANSIENT); + sqlite3_log(SQLITE_WARNING, deprecation); + } else { + char *fast_kdf_iter = sqlite3_mprintf("%d", sqlcipher_codec_ctx_get_fast_kdf_iter(ctx)); + sqlcipher_vdbe_return_string(pParse, "fast_kdf_iter", fast_kdf_iter, P4_DYNAMIC); + } + } + }else + if( sqlite3_stricmp(zLeft, "rekey_kdf_iter")==0 && zRight ){ + const char* message = "PRAGMA rekey_kdf_iter is no longer supported."; + sqlcipher_vdbe_return_string(pParse, "rekey_kdf_iter", message, P4_TRANSIENT); + sqlite3_log(SQLITE_WARNING, message); + }else + if( sqlite3_stricmp(zLeft,"cipher_page_size")==0 ){ + if(ctx) { + if( zRight ) { + int size = atoi(zRight); + rc = sqlcipher_codec_ctx_set_pagesize(ctx, size); + if(rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, rc); + rc = codec_set_btree_to_codec_pagesize(db, pDb, ctx); + if(rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, rc); + } else { + char * page_size = sqlite3_mprintf("%d", sqlcipher_codec_ctx_get_pagesize(ctx)); + sqlcipher_vdbe_return_string(pParse, "cipher_page_size", page_size, P4_DYNAMIC); + } + } + }else + if( sqlite3_stricmp(zLeft,"cipher_default_page_size")==0 ){ + if( zRight ) { + sqlcipher_set_default_pagesize(atoi(zRight)); + } else { + char *default_page_size = sqlite3_mprintf("%d", sqlcipher_get_default_pagesize()); + sqlcipher_vdbe_return_string(pParse, "cipher_default_page_size", default_page_size, P4_DYNAMIC); + } + }else + if( sqlite3_stricmp(zLeft,"cipher_default_use_hmac")==0 ){ + if( zRight ) { + sqlcipher_set_default_use_hmac(sqlite3GetBoolean(zRight,1)); + } else { + char *default_use_hmac = sqlite3_mprintf("%d", sqlcipher_get_default_use_hmac()); + sqlcipher_vdbe_return_string(pParse, "cipher_default_use_hmac", default_use_hmac, P4_DYNAMIC); + } + }else + if( sqlite3_stricmp(zLeft,"cipher_use_hmac")==0 ){ + if(ctx) { + if( zRight ) { + rc = sqlcipher_codec_ctx_set_use_hmac(ctx, sqlite3GetBoolean(zRight,1)); + if(rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, rc); + /* since the use of hmac has changed, the page size may also change */ + rc = codec_set_btree_to_codec_pagesize(db, pDb, ctx); + if(rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, rc); + } else { + char *hmac_flag = sqlite3_mprintf("%d", sqlcipher_codec_ctx_get_use_hmac(ctx)); + sqlcipher_vdbe_return_string(pParse, "cipher_use_hmac", hmac_flag, P4_DYNAMIC); + } + } + }else + if( sqlite3_stricmp(zLeft,"cipher_hmac_pgno")==0 ){ + if(ctx) { + if(zRight) { + char *deprecation = "PRAGMA cipher_hmac_pgno is deprecated, please remove from use"; + /* clear both pgno endian flags */ + if(sqlite3_stricmp(zRight, "le") == 0) { + SQLCIPHER_FLAG_UNSET(ctx->flags, CIPHER_FLAG_BE_PGNO); + SQLCIPHER_FLAG_SET(ctx->flags, CIPHER_FLAG_LE_PGNO); + } else if(sqlite3_stricmp(zRight, "be") == 0) { + SQLCIPHER_FLAG_UNSET(ctx->flags, CIPHER_FLAG_LE_PGNO); + SQLCIPHER_FLAG_SET(ctx->flags, CIPHER_FLAG_BE_PGNO); + } else if(sqlite3_stricmp(zRight, "native") == 0) { + SQLCIPHER_FLAG_UNSET(ctx->flags, CIPHER_FLAG_LE_PGNO); + SQLCIPHER_FLAG_UNSET(ctx->flags, CIPHER_FLAG_BE_PGNO); + } + sqlcipher_vdbe_return_string(pParse, "cipher_hmac_pgno", deprecation, P4_TRANSIENT); + sqlite3_log(SQLITE_WARNING, deprecation); + + } else { + if(SQLCIPHER_FLAG_GET(ctx->flags, CIPHER_FLAG_LE_PGNO)) { + sqlcipher_vdbe_return_string(pParse, "cipher_hmac_pgno", "le", P4_TRANSIENT); + } else if(SQLCIPHER_FLAG_GET(ctx->flags, CIPHER_FLAG_BE_PGNO)) { + sqlcipher_vdbe_return_string(pParse, "cipher_hmac_pgno", "be", P4_TRANSIENT); + } else { + sqlcipher_vdbe_return_string(pParse, "cipher_hmac_pgno", "native", P4_TRANSIENT); + } + } + } + }else + if( sqlite3_stricmp(zLeft,"cipher_hmac_salt_mask")==0 ){ + if(ctx) { + if(zRight) { + char *deprecation = "PRAGMA cipher_hmac_salt_mask is deprecated, please remove from use"; + if (sqlite3StrNICmp(zRight ,"x'", 2) == 0 && sqlite3Strlen30(zRight) == 5) { + unsigned char mask = 0; + const unsigned char *hex = (const unsigned char *)zRight+2; + cipher_hex2bin(hex,2,&mask); + sqlcipher_set_hmac_salt_mask(mask); + } + sqlcipher_vdbe_return_string(pParse, "cipher_hmac_salt_mask", deprecation, P4_TRANSIENT); + sqlite3_log(SQLITE_WARNING, deprecation); + } else { + char *hmac_salt_mask = sqlite3_mprintf("%02x", sqlcipher_get_hmac_salt_mask()); + sqlcipher_vdbe_return_string(pParse, "cipher_hmac_salt_mask", hmac_salt_mask, P4_DYNAMIC); + } + } + }else + if( sqlite3_stricmp(zLeft,"cipher_plaintext_header_size")==0 ){ + if(ctx) { + if( zRight ) { + int size = atoi(zRight); + /* deliberately ignore result code, if size is invalid it will be set to -1 + and trip the error later in the codec */ + sqlcipher_codec_ctx_set_plaintext_header_size(ctx, size); + } else { + char *size = sqlite3_mprintf("%d", sqlcipher_codec_ctx_get_plaintext_header_size(ctx)); + sqlcipher_vdbe_return_string(pParse, "cipher_plaintext_header_size", size, P4_DYNAMIC); + } + } + }else + if( sqlite3_stricmp(zLeft,"cipher_default_plaintext_header_size")==0 ){ + if( zRight ) { + sqlcipher_set_default_plaintext_header_size(atoi(zRight)); + } else { + char *size = sqlite3_mprintf("%d", sqlcipher_get_default_plaintext_header_size()); + sqlcipher_vdbe_return_string(pParse, "cipher_default_plaintext_header_size", size, P4_DYNAMIC); + } + }else + if( sqlite3_stricmp(zLeft,"cipher_salt")==0 ){ + if(ctx) { + if(zRight) { + if (sqlite3StrNICmp(zRight ,"x'", 2) == 0 && sqlite3Strlen30(zRight) == (FILE_HEADER_SZ*2)+3) { + unsigned char *salt = (unsigned char*) sqlite3_malloc(FILE_HEADER_SZ); + const unsigned char *hex = (const unsigned char *)zRight+2; + cipher_hex2bin(hex,FILE_HEADER_SZ*2,salt); + sqlcipher_codec_ctx_set_kdf_salt(ctx, salt, FILE_HEADER_SZ); + sqlite3_free(salt); + } + } else { + void *salt; + char *hexsalt = (char*) sqlite3_malloc((FILE_HEADER_SZ*2)+1); + if((rc = sqlcipher_codec_ctx_get_kdf_salt(ctx, &salt)) == SQLITE_OK) { + cipher_bin2hex(salt, FILE_HEADER_SZ, hexsalt); + sqlcipher_vdbe_return_string(pParse, "cipher_salt", hexsalt, P4_DYNAMIC); + } else { + sqlite3_free(hexsalt); + sqlcipher_codec_ctx_set_error(ctx, rc); + } + } + } + }else + if( sqlite3_stricmp(zLeft,"cipher_hmac_algorithm")==0 ){ + if(ctx) { + if(zRight) { + rc = SQLITE_ERROR; + if(sqlite3_stricmp(zRight, SQLCIPHER_HMAC_SHA1_LABEL) == 0) { + rc = sqlcipher_codec_ctx_set_hmac_algorithm(ctx, SQLCIPHER_HMAC_SHA1); + } else if(sqlite3_stricmp(zRight, SQLCIPHER_HMAC_SHA256_LABEL) == 0) { + rc = sqlcipher_codec_ctx_set_hmac_algorithm(ctx, SQLCIPHER_HMAC_SHA256); + } else if(sqlite3_stricmp(zRight, SQLCIPHER_HMAC_SHA512_LABEL) == 0) { + rc = sqlcipher_codec_ctx_set_hmac_algorithm(ctx, SQLCIPHER_HMAC_SHA512); + } + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + rc = codec_set_btree_to_codec_pagesize(db, pDb, ctx); + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + } else { + int algorithm = sqlcipher_codec_ctx_get_hmac_algorithm(ctx); + if(algorithm == SQLCIPHER_HMAC_SHA1) { + sqlcipher_vdbe_return_string(pParse, "cipher_hmac_algorithm", SQLCIPHER_HMAC_SHA1_LABEL, P4_TRANSIENT); + } else if(algorithm == SQLCIPHER_HMAC_SHA256) { + sqlcipher_vdbe_return_string(pParse, "cipher_hmac_algorithm", SQLCIPHER_HMAC_SHA256_LABEL, P4_TRANSIENT); + } else if(algorithm == SQLCIPHER_HMAC_SHA512) { + sqlcipher_vdbe_return_string(pParse, "cipher_hmac_algorithm", SQLCIPHER_HMAC_SHA512_LABEL, P4_TRANSIENT); + } + } + } + }else + if( sqlite3_stricmp(zLeft,"cipher_default_hmac_algorithm")==0 ){ + if(zRight) { + rc = SQLITE_ERROR; + if(sqlite3_stricmp(zRight, SQLCIPHER_HMAC_SHA1_LABEL) == 0) { + rc = sqlcipher_set_default_hmac_algorithm(SQLCIPHER_HMAC_SHA1); + } else if(sqlite3_stricmp(zRight, SQLCIPHER_HMAC_SHA256_LABEL) == 0) { + rc = sqlcipher_set_default_hmac_algorithm(SQLCIPHER_HMAC_SHA256); + } else if(sqlite3_stricmp(zRight, SQLCIPHER_HMAC_SHA512_LABEL) == 0) { + rc = sqlcipher_set_default_hmac_algorithm(SQLCIPHER_HMAC_SHA512); + } + } else { + int algorithm = sqlcipher_get_default_hmac_algorithm(); + if(algorithm == SQLCIPHER_HMAC_SHA1) { + sqlcipher_vdbe_return_string(pParse, "cipher_default_hmac_algorithm", SQLCIPHER_HMAC_SHA1_LABEL, P4_TRANSIENT); + } else if(algorithm == SQLCIPHER_HMAC_SHA256) { + sqlcipher_vdbe_return_string(pParse, "cipher_default_hmac_algorithm", SQLCIPHER_HMAC_SHA256_LABEL, P4_TRANSIENT); + } else if(algorithm == SQLCIPHER_HMAC_SHA512) { + sqlcipher_vdbe_return_string(pParse, "cipher_default_hmac_algorithm", SQLCIPHER_HMAC_SHA512_LABEL, P4_TRANSIENT); + } + } + }else + if( sqlite3_stricmp(zLeft,"cipher_kdf_algorithm")==0 ){ + if(ctx) { + if(zRight) { + rc = SQLITE_ERROR; + if(sqlite3_stricmp(zRight, SQLCIPHER_PBKDF2_HMAC_SHA1_LABEL) == 0) { + rc = sqlcipher_codec_ctx_set_kdf_algorithm(ctx, SQLCIPHER_PBKDF2_HMAC_SHA1); + } else if(sqlite3_stricmp(zRight, SQLCIPHER_PBKDF2_HMAC_SHA256_LABEL) == 0) { + rc = sqlcipher_codec_ctx_set_kdf_algorithm(ctx, SQLCIPHER_PBKDF2_HMAC_SHA256); + } else if(sqlite3_stricmp(zRight, SQLCIPHER_PBKDF2_HMAC_SHA512_LABEL) == 0) { + rc = sqlcipher_codec_ctx_set_kdf_algorithm(ctx, SQLCIPHER_PBKDF2_HMAC_SHA512); + } + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + } else { + int algorithm = sqlcipher_codec_ctx_get_kdf_algorithm(ctx); + if(algorithm == SQLCIPHER_PBKDF2_HMAC_SHA1) { + sqlcipher_vdbe_return_string(pParse, "cipher_kdf_algorithm", SQLCIPHER_PBKDF2_HMAC_SHA1_LABEL, P4_TRANSIENT); + } else if(algorithm == SQLCIPHER_PBKDF2_HMAC_SHA256) { + sqlcipher_vdbe_return_string(pParse, "cipher_kdf_algorithm", SQLCIPHER_PBKDF2_HMAC_SHA256_LABEL, P4_TRANSIENT); + } else if(algorithm == SQLCIPHER_PBKDF2_HMAC_SHA512) { + sqlcipher_vdbe_return_string(pParse, "cipher_kdf_algorithm", SQLCIPHER_PBKDF2_HMAC_SHA512_LABEL, P4_TRANSIENT); + } + } + } + }else + if( sqlite3_stricmp(zLeft,"cipher_default_kdf_algorithm")==0 ){ + if(zRight) { + rc = SQLITE_ERROR; + if(sqlite3_stricmp(zRight, SQLCIPHER_PBKDF2_HMAC_SHA1_LABEL) == 0) { + rc = sqlcipher_set_default_kdf_algorithm(SQLCIPHER_PBKDF2_HMAC_SHA1); + } else if(sqlite3_stricmp(zRight, SQLCIPHER_PBKDF2_HMAC_SHA256_LABEL) == 0) { + rc = sqlcipher_set_default_kdf_algorithm(SQLCIPHER_PBKDF2_HMAC_SHA256); + } else if(sqlite3_stricmp(zRight, SQLCIPHER_PBKDF2_HMAC_SHA512_LABEL) == 0) { + rc = sqlcipher_set_default_kdf_algorithm(SQLCIPHER_PBKDF2_HMAC_SHA512); + } + } else { + int algorithm = sqlcipher_get_default_kdf_algorithm(); + if(algorithm == SQLCIPHER_PBKDF2_HMAC_SHA1) { + sqlcipher_vdbe_return_string(pParse, "cipher_default_kdf_algorithm", SQLCIPHER_PBKDF2_HMAC_SHA1_LABEL, P4_TRANSIENT); + } else if(algorithm == SQLCIPHER_PBKDF2_HMAC_SHA256) { + sqlcipher_vdbe_return_string(pParse, "cipher_default_kdf_algorithm", SQLCIPHER_PBKDF2_HMAC_SHA256_LABEL, P4_TRANSIENT); + } else if(algorithm == SQLCIPHER_PBKDF2_HMAC_SHA512) { + sqlcipher_vdbe_return_string(pParse, "cipher_default_kdf_algorithm", SQLCIPHER_PBKDF2_HMAC_SHA512_LABEL, P4_TRANSIENT); + } + } + }else + if( sqlite3_stricmp(zLeft,"cipher_compatibility")==0 ){ + if(ctx) { + if(zRight) { + int version = atoi(zRight); + + switch(version) { + case 1: + rc = sqlcipher_codec_ctx_set_pagesize(ctx, 1024); + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + rc = sqlcipher_codec_ctx_set_hmac_algorithm(ctx, SQLCIPHER_HMAC_SHA1); + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + rc = sqlcipher_codec_ctx_set_kdf_algorithm(ctx, SQLCIPHER_PBKDF2_HMAC_SHA1); + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + rc = sqlcipher_codec_ctx_set_kdf_iter(ctx, 4000); + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + rc = sqlcipher_codec_ctx_set_use_hmac(ctx, 0); + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + break; + + case 2: + rc = sqlcipher_codec_ctx_set_pagesize(ctx, 1024); + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + rc = sqlcipher_codec_ctx_set_hmac_algorithm(ctx, SQLCIPHER_HMAC_SHA1); + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + rc = sqlcipher_codec_ctx_set_kdf_algorithm(ctx, SQLCIPHER_PBKDF2_HMAC_SHA1); + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + rc = sqlcipher_codec_ctx_set_kdf_iter(ctx, 4000); + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + rc = sqlcipher_codec_ctx_set_use_hmac(ctx, 1); + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + break; + + case 3: + rc = sqlcipher_codec_ctx_set_pagesize(ctx, 1024); + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + rc = sqlcipher_codec_ctx_set_hmac_algorithm(ctx, SQLCIPHER_HMAC_SHA1); + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + rc = sqlcipher_codec_ctx_set_kdf_algorithm(ctx, SQLCIPHER_PBKDF2_HMAC_SHA1); + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + rc = sqlcipher_codec_ctx_set_kdf_iter(ctx, 64000); + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + rc = sqlcipher_codec_ctx_set_use_hmac(ctx, 1); + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + break; + + default: + rc = sqlcipher_codec_ctx_set_pagesize(ctx, 4096); + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + rc = sqlcipher_codec_ctx_set_hmac_algorithm(ctx, SQLCIPHER_HMAC_SHA512); + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + rc = sqlcipher_codec_ctx_set_kdf_algorithm(ctx, SQLCIPHER_PBKDF2_HMAC_SHA512); + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + rc = sqlcipher_codec_ctx_set_kdf_iter(ctx, 256000); + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + rc = sqlcipher_codec_ctx_set_use_hmac(ctx, 1); + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + break; + } + + rc = codec_set_btree_to_codec_pagesize(db, pDb, ctx); + if (rc != SQLITE_OK) sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + } + } + }else + if( sqlite3_stricmp(zLeft,"cipher_default_compatibility")==0 ){ + if(zRight) { + int version = atoi(zRight); + switch(version) { + case 1: + sqlcipher_set_default_pagesize(1024); + sqlcipher_set_default_hmac_algorithm(SQLCIPHER_HMAC_SHA1); + sqlcipher_set_default_kdf_algorithm(SQLCIPHER_PBKDF2_HMAC_SHA1); + sqlcipher_set_default_kdf_iter(4000); + sqlcipher_set_default_use_hmac(0); + break; + + case 2: + sqlcipher_set_default_pagesize(1024); + sqlcipher_set_default_hmac_algorithm(SQLCIPHER_HMAC_SHA1); + sqlcipher_set_default_kdf_algorithm(SQLCIPHER_PBKDF2_HMAC_SHA1); + sqlcipher_set_default_kdf_iter(4000); + sqlcipher_set_default_use_hmac(1); + break; + + case 3: + sqlcipher_set_default_pagesize(1024); + sqlcipher_set_default_hmac_algorithm(SQLCIPHER_HMAC_SHA1); + sqlcipher_set_default_kdf_algorithm(SQLCIPHER_PBKDF2_HMAC_SHA1); + sqlcipher_set_default_kdf_iter(64000); + sqlcipher_set_default_use_hmac(1); + break; + + default: + sqlcipher_set_default_pagesize(4096); + sqlcipher_set_default_hmac_algorithm(SQLCIPHER_HMAC_SHA512); + sqlcipher_set_default_kdf_algorithm(SQLCIPHER_PBKDF2_HMAC_SHA512); + sqlcipher_set_default_kdf_iter(256000); + sqlcipher_set_default_use_hmac(1); + break; + } + } + }else + if( sqlite3_stricmp(zLeft,"cipher_memory_security")==0 ){ + if( zRight ) { + sqlcipher_set_mem_security(sqlite3GetBoolean(zRight,1)); + } else { + char *on = sqlite3_mprintf("%d", sqlcipher_get_mem_security()); + sqlcipher_vdbe_return_string(pParse, "cipher_memory_security", on, P4_DYNAMIC); + } + }else + if( sqlite3_stricmp(zLeft,"cipher_settings")==0 ){ + if(ctx) { + int algorithm; + char *pragma; + + pragma = sqlite3_mprintf("PRAGMA kdf_iter = %d;", sqlcipher_codec_ctx_get_kdf_iter(ctx)); + sqlcipher_vdbe_return_string(pParse, "pragma", pragma, P4_DYNAMIC); + + pragma = sqlite3_mprintf("PRAGMA cipher_page_size = %d;", sqlcipher_codec_ctx_get_pagesize(ctx)); + sqlcipher_vdbe_return_string(pParse, "pragma", pragma, P4_DYNAMIC); + + pragma = sqlite3_mprintf("PRAGMA cipher_use_hmac = %d;", sqlcipher_codec_ctx_get_use_hmac(ctx)); + sqlcipher_vdbe_return_string(pParse, "pragma", pragma, P4_DYNAMIC); + + pragma = sqlite3_mprintf("PRAGMA cipher_plaintext_header_size = %d;", sqlcipher_codec_ctx_get_plaintext_header_size(ctx)); + sqlcipher_vdbe_return_string(pParse, "pragma", pragma, P4_DYNAMIC); + + algorithm = sqlcipher_codec_ctx_get_hmac_algorithm(ctx); + pragma = NULL; + if(algorithm == SQLCIPHER_HMAC_SHA1) { + pragma = sqlite3_mprintf("PRAGMA cipher_hmac_algorithm = %s;", SQLCIPHER_HMAC_SHA1_LABEL); + } else if(algorithm == SQLCIPHER_HMAC_SHA256) { + pragma = sqlite3_mprintf("PRAGMA cipher_hmac_algorithm = %s;", SQLCIPHER_HMAC_SHA256_LABEL); + } else if(algorithm == SQLCIPHER_HMAC_SHA512) { + pragma = sqlite3_mprintf("PRAGMA cipher_hmac_algorithm = %s;", SQLCIPHER_HMAC_SHA512_LABEL); + } + sqlcipher_vdbe_return_string(pParse, "pragma", pragma, P4_DYNAMIC); + + algorithm = sqlcipher_codec_ctx_get_kdf_algorithm(ctx); + pragma = NULL; + if(algorithm == SQLCIPHER_PBKDF2_HMAC_SHA1) { + pragma = sqlite3_mprintf("PRAGMA cipher_kdf_algorithm = %s;", SQLCIPHER_PBKDF2_HMAC_SHA1_LABEL); + } else if(algorithm == SQLCIPHER_PBKDF2_HMAC_SHA256) { + pragma = sqlite3_mprintf("PRAGMA cipher_kdf_algorithm = %s;", SQLCIPHER_PBKDF2_HMAC_SHA256_LABEL); + } else if(algorithm == SQLCIPHER_PBKDF2_HMAC_SHA512) { + pragma = sqlite3_mprintf("PRAGMA cipher_kdf_algorithm = %s;", SQLCIPHER_PBKDF2_HMAC_SHA512_LABEL); + } + sqlcipher_vdbe_return_string(pParse, "pragma", pragma, P4_DYNAMIC); + + } + }else + if( sqlite3_stricmp(zLeft,"cipher_default_settings")==0 ){ + int algorithm; + char *pragma; + + pragma = sqlite3_mprintf("PRAGMA cipher_default_kdf_iter = %d;", sqlcipher_get_default_kdf_iter()); + sqlcipher_vdbe_return_string(pParse, "pragma", pragma, P4_DYNAMIC); + + pragma = sqlite3_mprintf("PRAGMA cipher_default_page_size = %d;", sqlcipher_get_default_pagesize()); + sqlcipher_vdbe_return_string(pParse, "pragma", pragma, P4_DYNAMIC); + + pragma = sqlite3_mprintf("PRAGMA cipher_default_use_hmac = %d;", sqlcipher_get_default_use_hmac()); + sqlcipher_vdbe_return_string(pParse, "pragma", pragma, P4_DYNAMIC); + + pragma = sqlite3_mprintf("PRAGMA cipher_default_plaintext_header_size = %d;", sqlcipher_get_default_plaintext_header_size()); + sqlcipher_vdbe_return_string(pParse, "pragma", pragma, P4_DYNAMIC); + + algorithm = sqlcipher_get_default_hmac_algorithm(); + pragma = NULL; + if(algorithm == SQLCIPHER_HMAC_SHA1) { + pragma = sqlite3_mprintf("PRAGMA cipher_default_hmac_algorithm = %s;", SQLCIPHER_HMAC_SHA1_LABEL); + } else if(algorithm == SQLCIPHER_HMAC_SHA256) { + pragma = sqlite3_mprintf("PRAGMA cipher_default_hmac_algorithm = %s;", SQLCIPHER_HMAC_SHA256_LABEL); + } else if(algorithm == SQLCIPHER_HMAC_SHA512) { + pragma = sqlite3_mprintf("PRAGMA cipher_default_hmac_algorithm = %s;", SQLCIPHER_HMAC_SHA512_LABEL); + } + sqlcipher_vdbe_return_string(pParse, "pragma", pragma, P4_DYNAMIC); + + algorithm = sqlcipher_get_default_kdf_algorithm(); + pragma = NULL; + if(algorithm == SQLCIPHER_PBKDF2_HMAC_SHA1) { + pragma = sqlite3_mprintf("PRAGMA cipher_default_kdf_algorithm = %s;", SQLCIPHER_PBKDF2_HMAC_SHA1_LABEL); + } else if(algorithm == SQLCIPHER_PBKDF2_HMAC_SHA256) { + pragma = sqlite3_mprintf("PRAGMA cipher_default_kdf_algorithm = %s;", SQLCIPHER_PBKDF2_HMAC_SHA256_LABEL); + } else if(algorithm == SQLCIPHER_PBKDF2_HMAC_SHA512) { + pragma = sqlite3_mprintf("PRAGMA cipher_default_kdf_algorithm = %s;", SQLCIPHER_PBKDF2_HMAC_SHA512_LABEL); + } + sqlcipher_vdbe_return_string(pParse, "pragma", pragma, P4_DYNAMIC); + }else + if( sqlite3_stricmp(zLeft,"cipher_integrity_check")==0 ){ + if(ctx) { + sqlcipher_codec_ctx_integrity_check(ctx, pParse, "cipher_integrity_check"); + } + } else + if( sqlite3_stricmp(zLeft, "cipher_log_level")==0 && zRight){ + unsigned int level = SQLCIPHER_LOG_NONE; + if(sqlite3_stricmp(zRight, "ERROR")==0) level = SQLCIPHER_LOG_ERROR; + else if(sqlite3_stricmp(zRight, "WARN" )==0) level = SQLCIPHER_LOG_WARN; + else if(sqlite3_stricmp(zRight, "INFO" )==0) level = SQLCIPHER_LOG_INFO; + else if(sqlite3_stricmp(zRight, "DEBUG")==0) level = SQLCIPHER_LOG_DEBUG; + else if(sqlite3_stricmp(zRight, "TRACE")==0) level = SQLCIPHER_LOG_TRACE; + sqlcipher_set_log_level(level); + sqlcipher_vdbe_return_string(pParse, "cipher_log_level", sqlite3_mprintf("%u", level), P4_DYNAMIC); + } else + if( sqlite3_stricmp(zLeft, "cipher_log")== 0 && zRight ){ + char *status = sqlite3_mprintf("%d", sqlcipher_set_log(zRight)); + sqlcipher_vdbe_return_string(pParse, "cipher_log", status, P4_DYNAMIC); + }else { + return 0; + } + return 1; +} + +/* these constants are used internally within SQLite's pager.c to differentiate between + operations on the main database or journal pages. This is important in the context + of a rekey operations, where the journal must be written using the original key + material (to allow a transactional rollback), while the new database pages are being + written with the new key material*/ +#define CODEC_READ_OP 3 +#define CODEC_WRITE_OP 6 +#define CODEC_JOURNAL_OP 7 + +/* + * sqlite3Codec can be called in multiple modes. + * encrypt mode - expected to return a pointer to the + * encrypted data without altering pData. + * decrypt mode - expected to return a pointer to pData, with + * the data decrypted in the input buffer + */ +static void* sqlite3Codec(void *iCtx, void *data, Pgno pgno, int mode) { + codec_ctx *ctx = (codec_ctx *) iCtx; + int offset = 0, rc = 0; + int page_sz = sqlcipher_codec_ctx_get_pagesize(ctx); + unsigned char *pData = (unsigned char *) data; + void *buffer = sqlcipher_codec_ctx_get_data(ctx); + int plaintext_header_sz = sqlcipher_codec_ctx_get_plaintext_header_size(ctx); + int cctx = CIPHER_READ_CTX; + + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlite3Codec: pgno=%d, mode=%d, page_sz=%d", pgno, mode, page_sz); + +#ifdef SQLCIPHER_EXT + if(sqlcipher_license_check(ctx) != SQLITE_OK) return NULL; +#endif + + /* call to derive keys if not present yet */ + if((rc = sqlcipher_codec_key_derive(ctx)) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlite3Codec: error occurred during key derivation: %d", rc); + sqlcipher_codec_ctx_set_error(ctx, rc); + return NULL; + } + + /* if the plaintext_header_size is negative that means an invalid size was set via + PRAGMA. We can't set the error state on the pager at that point because the pager + may not be open yet. However, this is a fatal error state, so abort the codec */ + if(plaintext_header_sz < 0) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlite3Codec: error invalid plaintext_header_sz: %d", plaintext_header_sz); + sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); + return NULL; + } + + if(pgno == 1) /* adjust starting pointers in data page for header offset on first page*/ + offset = plaintext_header_sz ? plaintext_header_sz : FILE_HEADER_SZ; + + + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlite3Codec: switch mode=%d offset=%d", mode, offset); + switch(mode) { + case CODEC_READ_OP: /* decrypt */ + if(pgno == 1) /* copy initial part of file header or SQLite magic to buffer */ + memcpy(buffer, plaintext_header_sz ? pData : (void *) SQLITE_FILE_HEADER, offset); + + rc = sqlcipher_page_cipher(ctx, cctx, pgno, CIPHER_DECRYPT, page_sz - offset, pData + offset, (unsigned char*)buffer + offset); +#ifdef SQLCIPHER_TEST + if((sqlcipher_get_test_flags() & TEST_FAIL_DECRYPT) > 0 && sqlcipher_get_test_fail()) { + rc = SQLITE_ERROR; + sqlcipher_log(SQLCIPHER_LOG_ERROR, "simulating decryption failure for pgno=%d, mode=%d, page_sz=%d\n", pgno, mode, page_sz); + } +#endif + if(rc != SQLITE_OK) { + /* failure to decrypt a page is considered a permanent error and will render the pager unusable + in order to prevent inconsistent data being loaded into page cache */ + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlite3Codec: error decrypting page %d data: %d", pgno, rc); + sqlcipher_memset((unsigned char*) buffer+offset, 0, page_sz-offset); + sqlcipher_codec_ctx_set_error(ctx, rc); + } else { + SQLCIPHER_FLAG_SET(ctx->flags, CIPHER_FLAG_KEY_USED); + } + memcpy(pData, buffer, page_sz); /* copy buffer data back to pData and return */ + return pData; + break; + + case CODEC_WRITE_OP: /* encrypt database page, operate on write context and fall through to case 7, so the write context is used*/ + cctx = CIPHER_WRITE_CTX; + + case CODEC_JOURNAL_OP: /* encrypt journal page, operate on read context use to get the original page data from the database */ + if(pgno == 1) { /* copy initial part of file header or salt to buffer */ + void *kdf_salt = NULL; + /* retrieve the kdf salt */ + if((rc = sqlcipher_codec_ctx_get_kdf_salt(ctx, &kdf_salt)) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlite3Codec: error retrieving salt: %d", rc); + sqlcipher_codec_ctx_set_error(ctx, rc); + return NULL; + } + memcpy(buffer, plaintext_header_sz ? pData : kdf_salt, offset); + } + rc = sqlcipher_page_cipher(ctx, cctx, pgno, CIPHER_ENCRYPT, page_sz - offset, pData + offset, (unsigned char*)buffer + offset); +#ifdef SQLCIPHER_TEST + if((sqlcipher_get_test_flags() & TEST_FAIL_ENCRYPT) > 0 && sqlcipher_get_test_fail()) { + rc = SQLITE_ERROR; + sqlcipher_log(SQLCIPHER_LOG_ERROR, "simulating encryption failure for pgno=%d, mode=%d, page_sz=%d\n", pgno, mode, page_sz); + } +#endif + if(rc != SQLITE_OK) { + /* failure to encrypt a page is considered a permanent error and will render the pager unusable + in order to prevent corrupted pages from being written to the main databased when using WAL */ + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlite3Codec: error encrypting page %d data: %d", pgno, rc); + sqlcipher_memset((unsigned char*)buffer+offset, 0, page_sz-offset); + sqlcipher_codec_ctx_set_error(ctx, rc); + return NULL; + } + SQLCIPHER_FLAG_SET(ctx->flags, CIPHER_FLAG_KEY_USED); + return buffer; /* return persistent buffer data, pData remains intact */ + break; + + default: + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlite3Codec: error unsupported codec mode %d", mode); + sqlcipher_codec_ctx_set_error(ctx, SQLITE_ERROR); /* unsupported mode, set error */ + return pData; + break; + } +} + +static void sqlite3FreeCodecArg(void *pCodecArg) { + codec_ctx *ctx = (codec_ctx *) pCodecArg; + if(pCodecArg == NULL) return; + sqlcipher_codec_ctx_free(&ctx); /* wipe and free allocated memory for the context */ + sqlcipher_deactivate(); /* cleanup related structures, OpenSSL etc, when codec is detatched */ +} + +int sqlcipherCodecAttach(sqlite3* db, int nDb, const void *zKey, int nKey) { + struct Db *pDb = &db->aDb[nDb]; + + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipherCodecAttach: db=%p, nDb=%d", db, nDb); + + if(nKey && zKey && pDb->pBt) { + int rc; + Pager *pPager = pDb->pBt->pBt->pPager; + sqlite3_file *fd; + codec_ctx *ctx; + + ctx = (codec_ctx*) sqlcipherPagerGetCodec(pDb->pBt->pBt->pPager); + + if(ctx != NULL && SQLCIPHER_FLAG_GET(ctx->flags, CIPHER_FLAG_KEY_USED)) { + /* there is already a codec attached to this database, so we should not proceed */ + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipherCodecAttach: no codec attached to db, exiting"); + return SQLITE_OK; + } + + /* check if the sqlite3_file is open, and if not force handle to NULL */ + if((fd = sqlite3PagerFile(pPager))->pMethods == 0) fd = NULL; + + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipherCodecAttach: calling sqlcipher_activate()"); + sqlcipher_activate(); /* perform internal initialization for sqlcipher */ + + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipherCodecAttach: entering database mutex %p", db->mutex); + sqlite3_mutex_enter(db->mutex); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipherCodecAttach: entered database mutex %p", db->mutex); + +#ifdef SQLCIPHER_EXT + if((rc = sqlite3_set_authorizer(db, sqlcipher_license_authorizer, db)) != SQLITE_OK) { + sqlite3_mutex_leave(db->mutex); + return rc; + } +#endif + + /* point the internal codec argument against the contet to be prepared */ + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipherCodecAttach: calling sqlcipher_codec_ctx_init()"); + rc = sqlcipher_codec_ctx_init(&ctx, pDb, pDb->pBt->pBt->pPager, zKey, nKey); + + if(rc != SQLITE_OK) { + /* initialization failed, do not attach potentially corrupted context */ + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipherCodecAttach: context initialization failed forcing error state with rc=%d", rc); + /* force an error at the pager level, such that even the upstream caller ignores the return code + the pager will be in an error state and will process no further operations */ + sqlite3pager_error(pPager, rc); + pDb->pBt->pBt->db->errCode = rc; + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipherCodecAttach: leaving database mutex %p (early return on rc=%d)", db->mutex, rc); + sqlite3_mutex_leave(db->mutex); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipherCodecAttach: left database mutex %p (early return on rc=%d)", db->mutex, rc); + return rc; + } + + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipherCodecAttach: calling sqlcipherPagerSetCodec()"); + sqlcipherPagerSetCodec(sqlite3BtreePager(pDb->pBt), sqlite3Codec, NULL, sqlite3FreeCodecArg, (void *) ctx); + + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipherCodecAttach: calling codec_set_btree_to_codec_pagesize()"); + codec_set_btree_to_codec_pagesize(db, pDb, ctx); + + /* force secure delete. This has the benefit of wiping internal data when deleted + and also ensures that all pages are written to disk (i.e. not skipped by + sqlite3PagerDontWrite optimizations) */ + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipherCodecAttach: calling sqlite3BtreeSecureDelete()"); + sqlite3BtreeSecureDelete(pDb->pBt, 1); + + /* if fd is null, then this is an in-memory database and + we dont' want to overwrite the AutoVacuum settings + if not null, then set to the default */ + if(fd != NULL) { + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipherCodecAttach: calling sqlite3BtreeSetAutoVacuum()"); + sqlite3BtreeSetAutoVacuum(pDb->pBt, SQLITE_DEFAULT_AUTOVACUUM); + } + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipherCodecAttach: leaving database mutex %p", db->mutex); + sqlite3_mutex_leave(db->mutex); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipherCodecAttach: left database mutex %p", db->mutex); + } + return SQLITE_OK; +} + +int sqlcipher_find_db_index(sqlite3 *db, const char *zDb) { + int db_index; + if(zDb == NULL){ + return 0; + } + for(db_index = 0; db_index < db->nDb; db_index++) { + struct Db *pDb = &db->aDb[db_index]; + if(strcmp(pDb->zDbSName, zDb) == 0) { + return db_index; + } + } + return 0; +} + +SQLITE_API void sqlite3_activate_see(const char* in) { + /* do nothing, security enhancements are always active */ +} + +SQLITE_API int sqlite3_key(sqlite3 *db, const void *pKey, int nKey) { + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlite3_key: db=%p", db); + return sqlite3_key_v2(db, "main", pKey, nKey); +} + +SQLITE_API int sqlite3_key_v2(sqlite3 *db, const char *zDb, const void *pKey, int nKey) { + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlite3_key_v2: db=%p zDb=%s", db, zDb); + /* attach key if db and pKey are not null and nKey is > 0 */ + if(db && pKey && nKey) { + int db_index = sqlcipher_find_db_index(db, zDb); + return sqlcipherCodecAttach(db, db_index, pKey, nKey); + } + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlite3_key_v2: no key provided"); + return SQLITE_ERROR; +} + +SQLITE_API int sqlite3_rekey(sqlite3 *db, const void *pKey, int nKey) { + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlite3_rekey: db=%p", db); + return sqlite3_rekey_v2(db, "main", pKey, nKey); +} + +/* sqlite3_rekey_v2 +** Given a database, this will reencrypt the database using a new key. +** There is only one possible modes of operation - to encrypt a database +** that is already encrpyted. If the database is not already encrypted +** this should do nothing +** The proposed logic for this function follows: +** 1. Determine if the database is already encryptped +** 2. If there is NOT already a key present do nothing +** 3. If there is a key present, re-encrypt the database with the new key +*/ +SQLITE_API int sqlite3_rekey_v2(sqlite3 *db, const char *zDb, const void *pKey, int nKey) { + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlite3_rekey_v2: db=%p zDb=%s", db, zDb); + if(db && pKey && nKey) { + int db_index = sqlcipher_find_db_index(db, zDb); + struct Db *pDb = &db->aDb[db_index]; + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlite3_rekey_v2: database zDb=%p db_index:%d", zDb, db_index); + if(pDb->pBt) { + codec_ctx *ctx; + int rc, page_count; + Pgno pgno; + PgHdr *page; + Pager *pPager = pDb->pBt->pBt->pPager; + + ctx = (codec_ctx*) sqlcipherPagerGetCodec(pDb->pBt->pBt->pPager); + + if(ctx == NULL) { + /* there was no codec attached to this database, so this should do nothing! */ + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlite3_rekey_v2: no codec attached to db, exiting"); + return SQLITE_MISUSE; + } + + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlite3_rekey_v2: entering database mutex %p", db->mutex); + sqlite3_mutex_enter(db->mutex); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlite3_rekey_v2: entered database mutex %p", db->mutex); + + codec_set_pass_key(db, db_index, pKey, nKey, CIPHER_WRITE_CTX); + + /* do stuff here to rewrite the database + ** 1. Create a transaction on the database + ** 2. Iterate through each page, reading it and then writing it. + ** 3. If that goes ok then commit and put ctx->rekey into ctx->key + ** note: don't deallocate rekey since it may be used in a subsequent iteration + */ + rc = sqlite3BtreeBeginTrans(pDb->pBt, 1, 0); /* begin write transaction */ + sqlite3PagerPagecount(pPager, &page_count); + for(pgno = 1; rc == SQLITE_OK && pgno <= (unsigned int)page_count; pgno++) { /* pgno's start at 1 see pager.c:pagerAcquire */ + if(!sqlite3pager_is_sj_pgno(pPager, pgno)) { /* skip this page (see pager.c:pagerAcquire for reasoning) */ + rc = sqlite3PagerGet(pPager, pgno, &page, 0); + if(rc == SQLITE_OK) { /* write page see pager_incr_changecounter for example */ + rc = sqlite3PagerWrite(page); + if(rc == SQLITE_OK) { + sqlite3PagerUnref(page); + } else { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlite3_rekey_v2: error %d occurred writing page %d", rc, pgno); + } + } else { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlite3_rekey_v2: error %d occurred getting page %d", rc, pgno); + } + } + } + + /* if commit was successful commit and copy the rekey data to current key, else rollback to release locks */ + if(rc == SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlite3_rekey_v2: committing"); + rc = sqlite3BtreeCommit(pDb->pBt); + sqlcipher_codec_key_copy(ctx, CIPHER_WRITE_CTX); + } else { + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlite3_rekey_v2: rollback"); + sqlite3BtreeRollback(pDb->pBt, SQLITE_ABORT_ROLLBACK, 0); + } + + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlite3_rekey_v2: leaving database mutex %p", db->mutex); + sqlite3_mutex_leave(db->mutex); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlite3_rekey_v2: left database mutex %p", db->mutex); + } + return SQLITE_OK; + } + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlite3_rekey_v2: no key provided"); + return SQLITE_ERROR; +} + +void sqlcipherCodecGetKey(sqlite3* db, int nDb, void **zKey, int *nKey) { + struct Db *pDb = &db->aDb[nDb]; + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipherCodecGetKey:db=%p, nDb=%d", db, nDb); + if( pDb->pBt ) { + codec_ctx *ctx = (codec_ctx*) sqlcipherPagerGetCodec(pDb->pBt->pBt->pPager); + + if(ctx) { + /* pass back the keyspec from the codec, unless PRAGMA cipher_store_pass + is set or keyspec has not yet been derived, in which case pass + back the password key material */ + sqlcipher_codec_get_keyspec(ctx, zKey, nKey); + if(sqlcipher_codec_get_store_pass(ctx) == 1 || *zKey == NULL) { + sqlcipher_codec_get_pass(ctx, zKey, nKey); + } + } else { + *zKey = NULL; + *nKey = 0; + } + } +} + +/* + * Implementation of an "export" function that allows a caller + * to duplicate the main database to an attached database. This is intended + * as a conveneince for users who need to: + * + * 1. migrate from an non-encrypted database to an encrypted database + * 2. move from an encrypted database to a non-encrypted database + * 3. convert beween the various flavors of encrypted databases. + * + * This implementation is based heavily on the procedure and code used + * in vacuum.c, but is exposed as a function that allows export to any + * named attached database. + */ + +/* +** Finalize a prepared statement. If there was an error, store the +** text of the error message in *pzErrMsg. Return the result code. +** +** Based on vacuumFinalize from vacuum.c +*/ +static int sqlcipher_finalize(sqlite3 *db, sqlite3_stmt *pStmt, char **pzErrMsg){ + int rc; + rc = sqlite3VdbeFinalize((Vdbe*)pStmt); + if( rc ){ + sqlite3SetString(pzErrMsg, db, sqlite3_errmsg(db)); + } + return rc; +} + +/* +** Execute zSql on database db. Return an error code. +** +** Based on execSql from vacuum.c +*/ +static int sqlcipher_execSql(sqlite3 *db, char **pzErrMsg, const char *zSql){ + sqlite3_stmt *pStmt; + VVA_ONLY( int rc; ) + if( !zSql ){ + return SQLITE_NOMEM; + } + if( SQLITE_OK!=sqlite3_prepare(db, zSql, -1, &pStmt, 0) ){ + sqlite3SetString(pzErrMsg, db, sqlite3_errmsg(db)); + return sqlite3_errcode(db); + } + VVA_ONLY( rc = ) sqlite3_step(pStmt); + assert( rc!=SQLITE_ROW ); + return sqlcipher_finalize(db, pStmt, pzErrMsg); +} + +/* +** Execute zSql on database db. The statement returns exactly +** one column. Execute this as SQL on the same database. +** +** Based on execExecSql from vacuum.c +*/ +static int sqlcipher_execExecSql(sqlite3 *db, char **pzErrMsg, const char *zSql){ + sqlite3_stmt *pStmt; + int rc; + + rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0); + if( rc!=SQLITE_OK ) return rc; + + while( SQLITE_ROW==sqlite3_step(pStmt) ){ + rc = sqlcipher_execSql(db, pzErrMsg, (char*)sqlite3_column_text(pStmt, 0)); + if( rc!=SQLITE_OK ){ + sqlcipher_finalize(db, pStmt, pzErrMsg); + return rc; + } + } + + return sqlcipher_finalize(db, pStmt, pzErrMsg); +} + +/* + * copy database and schema from the main database to an attached database + * + * Based on sqlite3RunVacuum from vacuum.c +*/ +void sqlcipher_exportFunc(sqlite3_context *context, int argc, sqlite3_value **argv) { + sqlite3 *db = sqlite3_context_db_handle(context); + const char* targetDb, *sourceDb; + int targetDb_idx = 0; + u64 saved_flags = db->flags; /* Saved value of the db->flags */ + u32 saved_mDbFlags = db->mDbFlags; /* Saved value of the db->mDbFlags */ + int saved_nChange = db->nChange; /* Saved value of db->nChange */ + int saved_nTotalChange = db->nTotalChange; /* Saved value of db->nTotalChange */ + u8 saved_mTrace = db->mTrace; /* Saved value of db->mTrace */ + int rc = SQLITE_OK; /* Return code from service routines */ + char *zSql = NULL; /* SQL statements */ + char *pzErrMsg = NULL; + + if(argc != 1 && argc != 2) { + rc = SQLITE_ERROR; + pzErrMsg = sqlite3_mprintf("invalid number of arguments (%d) passed to sqlcipher_export", argc); + goto end_of_export; + } + + if(sqlite3_value_type(argv[0]) == SQLITE_NULL) { + rc = SQLITE_ERROR; + pzErrMsg = sqlite3_mprintf("target database can't be NULL"); + goto end_of_export; + } + + targetDb = (const char*) sqlite3_value_text(argv[0]); + sourceDb = "main"; + + if(argc == 2) { + if(sqlite3_value_type(argv[1]) == SQLITE_NULL) { + rc = SQLITE_ERROR; + pzErrMsg = sqlite3_mprintf("target database can't be NULL"); + goto end_of_export; + } + sourceDb = (char *) sqlite3_value_text(argv[1]); + } + + + /* if the name of the target is not main, but the index returned is zero + there is a mismatch and we should not proceed */ + targetDb_idx = sqlcipher_find_db_index(db, targetDb); + if(targetDb_idx == 0 && targetDb != NULL && sqlite3_stricmp("main", targetDb) != 0) { + rc = SQLITE_ERROR; + pzErrMsg = sqlite3_mprintf("unknown database %s", targetDb); + goto end_of_export; + } + db->init.iDb = targetDb_idx; + + db->flags |= SQLITE_WriteSchema | SQLITE_IgnoreChecks; + db->mDbFlags |= DBFLAG_PreferBuiltin | DBFLAG_Vacuum; + db->flags &= ~(u64)(SQLITE_ForeignKeys | SQLITE_ReverseOrder | SQLITE_Defensive | SQLITE_CountRows); + db->mTrace = 0; + + /* Query the schema of the main database. Create a mirror schema + ** in the temporary database. + */ + zSql = sqlite3_mprintf( + "SELECT sql " + " FROM %s.sqlite_schema WHERE type='table' AND name!='sqlite_sequence'" + " AND rootpage>0" + , sourceDb); + rc = (zSql == NULL) ? SQLITE_NOMEM : sqlcipher_execExecSql(db, &pzErrMsg, zSql); + if( rc!=SQLITE_OK ) goto end_of_export; + sqlite3_free(zSql); + + zSql = sqlite3_mprintf( + "SELECT sql " + " FROM %s.sqlite_schema WHERE sql LIKE 'CREATE INDEX %%' " + , sourceDb); + rc = (zSql == NULL) ? SQLITE_NOMEM : sqlcipher_execExecSql(db, &pzErrMsg, zSql); + if( rc!=SQLITE_OK ) goto end_of_export; + sqlite3_free(zSql); + + zSql = sqlite3_mprintf( + "SELECT sql " + " FROM %s.sqlite_schema WHERE sql LIKE 'CREATE UNIQUE INDEX %%'" + , sourceDb); + rc = (zSql == NULL) ? SQLITE_NOMEM : sqlcipher_execExecSql(db, &pzErrMsg, zSql); + if( rc!=SQLITE_OK ) goto end_of_export; + sqlite3_free(zSql); + + /* Loop through the tables in the main database. For each, do + ** an "INSERT INTO rekey_db.xxx SELECT * FROM main.xxx;" to copy + ** the contents to the temporary database. + */ + zSql = sqlite3_mprintf( + "SELECT 'INSERT INTO %s.' || quote(name) " + "|| ' SELECT * FROM %s.' || quote(name) || ';'" + "FROM %s.sqlite_schema " + "WHERE type = 'table' AND name!='sqlite_sequence' " + " AND rootpage>0" + , targetDb, sourceDb, sourceDb); + rc = (zSql == NULL) ? SQLITE_NOMEM : sqlcipher_execExecSql(db, &pzErrMsg, zSql); + if( rc!=SQLITE_OK ) goto end_of_export; + sqlite3_free(zSql); + + /* Copy over the contents of the sequence table + */ + zSql = sqlite3_mprintf( + "SELECT 'INSERT INTO %s.' || quote(name) " + "|| ' SELECT * FROM %s.' || quote(name) || ';' " + "FROM %s.sqlite_schema WHERE name=='sqlite_sequence';" + , targetDb, sourceDb, targetDb); + rc = (zSql == NULL) ? SQLITE_NOMEM : sqlcipher_execExecSql(db, &pzErrMsg, zSql); + if( rc!=SQLITE_OK ) goto end_of_export; + sqlite3_free(zSql); + + /* Copy the triggers, views, and virtual tables from the main database + ** over to the temporary database. None of these objects has any + ** associated storage, so all we have to do is copy their entries + ** from the SQLITE_MASTER table. + */ + zSql = sqlite3_mprintf( + "INSERT INTO %s.sqlite_schema " + " SELECT type, name, tbl_name, rootpage, sql" + " FROM %s.sqlite_schema" + " WHERE type='view' OR type='trigger'" + " OR (type='table' AND rootpage=0)" + , targetDb, sourceDb); + rc = (zSql == NULL) ? SQLITE_NOMEM : sqlcipher_execSql(db, &pzErrMsg, zSql); + if( rc!=SQLITE_OK ) goto end_of_export; + sqlite3_free(zSql); + + zSql = NULL; +end_of_export: + db->init.iDb = 0; + db->flags = saved_flags; + db->mDbFlags = saved_mDbFlags; + db->nChange = saved_nChange; + db->nTotalChange = saved_nTotalChange; + db->mTrace = saved_mTrace; + + if(zSql) sqlite3_free(zSql); + + if(rc) { + if(pzErrMsg != NULL) { + sqlite3_result_error(context, pzErrMsg, -1); + sqlite3DbFree(db, pzErrMsg); + } else { + sqlite3_result_error(context, sqlite3ErrStr(rc), -1); + } + } +} +#endif +/* END SQLCIPHER */ + +/************** End of crypto.c **********************************************/ +/************** Begin file crypto_impl.c *************************************/ +/* +** SQLCipher +** http://sqlcipher.net +** +** Copyright (c) 2008 - 2013, ZETETIC LLC +** All rights reserved. +** +** Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in the +** documentation and/or other materials provided with the distribution. +** * Neither the name of the ZETETIC LLC nor the +** names of its contributors may be used to endorse or promote products +** derived from this software without specific prior written permission. +** +** THIS SOFTWARE IS PROVIDED BY ZETETIC LLC ''AS IS'' AND ANY +** EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +** DISCLAIMED. IN NO EVENT SHALL ZETETIC LLC BE LIABLE FOR ANY +** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +** +*/ +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC + +/* #include "sqlcipher.h" */ +/* #include "crypto.h" */ + +#ifdef SQLCIPHER_TEST +static volatile unsigned int cipher_test_flags = 0; +unsigned int sqlcipher_get_test_flags() { + return cipher_test_flags; +} +void sqlcipher_set_test_flags(unsigned int flags) { + cipher_test_flags = flags; +} + +static volatile int cipher_test_rand = 0; +int sqlcipher_get_test_rand() { + return cipher_test_rand; +} +void sqlcipher_set_test_rand(int rand) { + cipher_test_rand = rand; +} +int sqlcipher_get_test_fail() { + int x; + + /* if cipher_test_rand is not set to a non-zero value always fail (return true) */ + if (cipher_test_rand == 0) return 1; + + sqlite3_randomness(sizeof(x), &x); + return ((x % cipher_test_rand) == 0); +} +#endif + +/* Generate code to return a string value */ + +static volatile unsigned int default_flags = DEFAULT_CIPHER_FLAGS; +static volatile unsigned char hmac_salt_mask = HMAC_SALT_MASK; +static volatile int default_kdf_iter = PBKDF2_ITER; +static volatile int default_page_size = 4096; +static volatile int default_plaintext_header_sz = 0; +static volatile int default_hmac_algorithm = SQLCIPHER_HMAC_SHA512; +static volatile int default_kdf_algorithm = SQLCIPHER_PBKDF2_HMAC_SHA512; +static volatile int sqlcipher_mem_security_on = 0; +static volatile int sqlcipher_mem_executed = 0; +static volatile int sqlcipher_mem_initialized = 0; +static volatile unsigned int sqlcipher_activate_count = 0; +static volatile sqlite3_mem_methods default_mem_methods; +static sqlcipher_provider *default_provider = NULL; + +static sqlite3_mutex* sqlcipher_static_mutex[SQLCIPHER_MUTEX_COUNT]; +static FILE* sqlcipher_log_file = NULL; +static volatile int sqlcipher_log_logcat = 0; +static volatile unsigned int sqlcipher_log_level = SQLCIPHER_LOG_NONE; + +sqlite3_mutex* sqlcipher_mutex(int mutex) { + if(mutex < 0 || mutex >= SQLCIPHER_MUTEX_COUNT) return NULL; + return sqlcipher_static_mutex[mutex]; +} + +static int sqlcipher_mem_init(void *pAppData) { + return default_mem_methods.xInit(pAppData); +} +static void sqlcipher_mem_shutdown(void *pAppData) { + default_mem_methods.xShutdown(pAppData); +} +static void *sqlcipher_mem_malloc(int n) { + void *ptr = default_mem_methods.xMalloc(n); + if(!sqlcipher_mem_executed) sqlcipher_mem_executed = 1; + if(sqlcipher_mem_security_on) { + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_mem_malloc: calling sqlcipher_mlock(%p,%d)", ptr, n); + sqlcipher_mlock(ptr, n); + } + return ptr; +} +static int sqlcipher_mem_size(void *p) { + return default_mem_methods.xSize(p); +} +static void sqlcipher_mem_free(void *p) { + int sz; + if(!sqlcipher_mem_executed) sqlcipher_mem_executed = 1; + if(sqlcipher_mem_security_on) { + sz = sqlcipher_mem_size(p); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_mem_free: calling sqlcipher_memset(%p,0,%d) and sqlcipher_munlock(%p, %d)", p, sz, p, sz); + sqlcipher_memset(p, 0, sz); + sqlcipher_munlock(p, sz); + } + default_mem_methods.xFree(p); +} +static void *sqlcipher_mem_realloc(void *p, int n) { + void *new = NULL; + int orig_sz = 0; + if(sqlcipher_mem_security_on) { + orig_sz = sqlcipher_mem_size(p); + if (n==0) { + sqlcipher_mem_free(p); + return NULL; + } else if (!p) { + return sqlcipher_mem_malloc(n); + } else if(n <= orig_sz) { + return p; + } else { + new = sqlcipher_mem_malloc(n); + if(new) { + memcpy(new, p, orig_sz); + sqlcipher_mem_free(p); + } + return new; + } + } else { + return default_mem_methods.xRealloc(p, n); + } +} + +static int sqlcipher_mem_roundup(int n) { + return default_mem_methods.xRoundup(n); +} + +static sqlite3_mem_methods sqlcipher_mem_methods = { + sqlcipher_mem_malloc, + sqlcipher_mem_free, + sqlcipher_mem_realloc, + sqlcipher_mem_size, + sqlcipher_mem_roundup, + sqlcipher_mem_init, + sqlcipher_mem_shutdown, + 0 +}; + +void sqlcipher_init_memmethods() { + if(sqlcipher_mem_initialized) return; + if(sqlite3_config(SQLITE_CONFIG_GETMALLOC, &default_mem_methods) != SQLITE_OK || + sqlite3_config(SQLITE_CONFIG_MALLOC, &sqlcipher_mem_methods) != SQLITE_OK) { + sqlcipher_mem_security_on = sqlcipher_mem_executed = sqlcipher_mem_initialized = 0; + } else { + sqlcipher_mem_initialized = 1; + } +} + +int sqlcipher_register_provider(sqlcipher_provider *p) { + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_register_provider: entering SQLCIPHER_MUTEX_PROVIDER"); + sqlite3_mutex_enter(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_register_provider: entered SQLCIPHER_MUTEX_PROVIDER"); + + if(default_provider != NULL && default_provider != p) { + /* only free the current registerd provider if it has been initialized + and it isn't a pointer to the same provider passed to the function + (i.e. protect against a caller calling register twice for the same provider) */ + sqlcipher_free(default_provider, sizeof(sqlcipher_provider)); + } + default_provider = p; + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_register_provider: leaving SQLCIPHER_MUTEX_PROVIDER"); + sqlite3_mutex_leave(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_register_provider: left SQLCIPHER_MUTEX_PROVIDER"); + + return SQLITE_OK; +} + +/* return a pointer to the currently registered provider. This will + allow an application to fetch the current registered provider and + make minor changes to it */ +sqlcipher_provider* sqlcipher_get_provider() { + return default_provider; +} + +void sqlcipher_activate() { + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_activate: entering static master mutex"); + sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_activate: entered static master mutex"); + + /* allocate new mutexes */ + if(sqlcipher_activate_count == 0) { + int i; + for(i = 0; i < SQLCIPHER_MUTEX_COUNT; i++) { + sqlcipher_static_mutex[i] = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST); + } + } + + /* check to see if there is a provider registered at this point + if there no provider registered at this point, register the + default provider */ + if(sqlcipher_get_provider() == NULL) { + sqlcipher_provider *p = sqlcipher_malloc(sizeof(sqlcipher_provider)); +#if defined (SQLCIPHER_CRYPTO_CC) + extern int sqlcipher_cc_setup(sqlcipher_provider *p); + sqlcipher_cc_setup(p); +#elif defined (SQLCIPHER_CRYPTO_LIBTOMCRYPT) + extern int sqlcipher_ltc_setup(sqlcipher_provider *p); + sqlcipher_ltc_setup(p); +#elif defined (SQLCIPHER_CRYPTO_NSS) + extern int sqlcipher_nss_setup(sqlcipher_provider *p); + sqlcipher_nss_setup(p); +#elif defined (SQLCIPHER_CRYPTO_OPENSSL) + extern int sqlcipher_openssl_setup(sqlcipher_provider *p); + sqlcipher_openssl_setup(p); +#else +#error "NO DEFAULT SQLCIPHER CRYPTO PROVIDER DEFINED" +#endif + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipher_activate: calling sqlcipher_register_provider(%p)", p); +#ifdef SQLCIPHER_EXT + sqlcipher_ext_provider_setup(p); +#endif + sqlcipher_register_provider(p); + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipher_activate: called sqlcipher_register_provider(%p)",p); + } + + sqlcipher_activate_count++; /* increment activation count */ + + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_activate: leaving static master mutex"); + sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_activate: left static master mutex"); +} + +void sqlcipher_deactivate() { + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_deactivate: entering static master mutex"); + sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_deactivate: entered static master mutex"); + + sqlcipher_activate_count--; + /* if no connections are using sqlcipher, cleanup globals */ + if(sqlcipher_activate_count < 1) { + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_deactivate: entering SQLCIPHER_MUTEX_PROVIDER"); + sqlite3_mutex_enter(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_deactivate: entered SQLCIPHER_MUTEX_PROVIDER"); + + if(default_provider != NULL) { + sqlcipher_free(default_provider, sizeof(sqlcipher_provider)); + default_provider = NULL; + } + + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_deactivate: leaving SQLCIPHER_MUTEX_PROVIDER"); + sqlite3_mutex_leave(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_deactivate: left SQLCIPHER_MUTEX_PROVIDER"); + +#ifdef SQLCIPHER_EXT + sqlcipher_ext_provider_destroy(); +#endif + + /* last connection closed, free mutexes */ + if(sqlcipher_activate_count == 0) { + int i; + for(i = 0; i < SQLCIPHER_MUTEX_COUNT; i++) { + sqlite3_mutex_free(sqlcipher_static_mutex[i]); + } + } + sqlcipher_activate_count = 0; /* reset activation count */ + } + + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_deactivate: leaving static master mutex"); + sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_deactivate: left static master mutex"); +} + +/* constant time memset using volitile to avoid having the memset + optimized out by the compiler. + Note: As suggested by Joachim Schipper (joachim.schipper@fox-it.com) +*/ +void* sqlcipher_memset(void *v, unsigned char value, sqlite_uint64 len) { + volatile sqlite_uint64 i = 0; + volatile unsigned char *a = v; + + if (v == NULL) return v; + + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_memset: setting %p[0-%llu]=%d)", a, len, value); + for(i = 0; i < len; i++) { + a[i] = value; + } + + return v; +} + +/* constant time memory check tests every position of a memory segement + matches a single value (i.e. the memory is all zeros) + returns 0 if match, 1 of no match */ +int sqlcipher_ismemset(const void *v, unsigned char value, sqlite_uint64 len) { + const volatile unsigned char *a = v; + volatile sqlite_uint64 i = 0, result = 0; + + for(i = 0; i < len; i++) { + result |= a[i] ^ value; + } + + return (result != 0); +} + +/* constant time memory comparison routine. + returns 0 if match, 1 if no match */ +int sqlcipher_memcmp(const void *v0, const void *v1, int len) { + const volatile unsigned char *a0 = v0, *a1 = v1; + volatile int i = 0, result = 0; + + for(i = 0; i < len; i++) { + result |= a0[i] ^ a1[i]; + } + + return (result != 0); +} + +void sqlcipher_mlock(void *ptr, sqlite_uint64 sz) { +#ifndef OMIT_MEMLOCK +#if defined(__unix__) || defined(__APPLE__) + int rc; + unsigned long pagesize = sysconf(_SC_PAGESIZE); + unsigned long offset = (unsigned long) ptr % pagesize; + + if(ptr == NULL || sz == 0) return; + + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_mem_lock: calling mlock(%p,%lu); _SC_PAGESIZE=%lu", ptr - offset, sz + offset, pagesize); + rc = mlock(ptr - offset, sz + offset); + if(rc!=0) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_mem_lock: mlock(%p,%lu) returned %d errno=%d", ptr - offset, sz + offset, rc, errno); + } +#elif defined(_WIN32) +#if !(defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP || WINAPI_FAMILY == WINAPI_FAMILY_APP)) + int rc; + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_mem_lock: calling VirtualLock(%p,%d)", ptr, sz); + rc = VirtualLock(ptr, sz); + if(rc==0) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_mem_lock: VirtualLock(%p,%d) returned %d LastError=%d", ptr, sz, rc, GetLastError()); + } +#endif +#endif +#endif +} + +void sqlcipher_munlock(void *ptr, sqlite_uint64 sz) { +#ifndef OMIT_MEMLOCK +#if defined(__unix__) || defined(__APPLE__) + int rc; + unsigned long pagesize = sysconf(_SC_PAGESIZE); + unsigned long offset = (unsigned long) ptr % pagesize; + + if(ptr == NULL || sz == 0) return; + + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_mem_unlock: calling munlock(%p,%lu)", ptr - offset, sz + offset); + rc = munlock(ptr - offset, sz + offset); + if(rc!=0) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_mem_unlock: munlock(%p,%lu) returned %d errno=%d", ptr - offset, sz + offset, rc, errno); + } +#elif defined(_WIN32) +#if !(defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP || WINAPI_FAMILY == WINAPI_FAMILY_APP)) + int rc; + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_mem_lock: calling VirtualUnlock(%p,%d)", ptr, sz); + rc = VirtualUnlock(ptr, sz); + if(!rc) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_mem_unlock: VirtualUnlock(%p,%d) returned %d LastError=%d", ptr, sz, rc, GetLastError()); + } +#endif +#endif +#endif +} + +/** + * Free and wipe memory. Uses SQLites internal sqlite3_free so that memory + * can be countend and memory leak detection works in the test suite. + * If ptr is not null memory will be freed. + * If sz is greater than zero, the memory will be overwritten with zero before it is freed + * If sz is > 0, and not compiled with OMIT_MEMLOCK, system will attempt to unlock the + * memory segment so it can be paged + */ +void sqlcipher_free(void *ptr, sqlite_uint64 sz) { + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_free: calling sqlcipher_memset(%p,0,%llu)", ptr, sz); + sqlcipher_memset(ptr, 0, sz); + sqlcipher_munlock(ptr, sz); + sqlite3_free(ptr); +} + +/** + * allocate memory. Uses sqlite's internall malloc wrapper so memory can be + * reference counted and leak detection works. Unless compiled with OMIT_MEMLOCK + * attempts to lock the memory pages so sensitive information won't be swapped + */ +void* sqlcipher_malloc(sqlite_uint64 sz) { + void *ptr; + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_malloc: calling sqlite3Malloc(%llu)", sz); + ptr = sqlite3Malloc(sz); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_malloc: calling sqlcipher_memset(%p,0,%llu)", ptr, sz); + sqlcipher_memset(ptr, 0, sz); + sqlcipher_mlock(ptr, sz); + return ptr; +} + +char* sqlcipher_version() { +#ifdef CIPHER_VERSION_QUALIFIER + char *version = sqlite3_mprintf("%s %s %s", CIPHER_XSTR(CIPHER_VERSION_NUMBER), CIPHER_XSTR(CIPHER_VERSION_QUALIFIER), CIPHER_XSTR(CIPHER_VERSION_BUILD)); +#else + char *version = sqlite3_mprintf("%s %s", CIPHER_XSTR(CIPHER_VERSION_NUMBER), CIPHER_XSTR(CIPHER_VERSION_BUILD)); +#endif + return version; +} + +/** + * Initialize new cipher_ctx struct. This function will allocate memory + * for the cipher context and for the key + * + * returns SQLITE_OK if initialization was successful + * returns SQLITE_NOMEM if an error occured allocating memory + */ +static int sqlcipher_cipher_ctx_init(codec_ctx *ctx, cipher_ctx **iCtx) { + cipher_ctx *c_ctx; + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipher_cipher_ctx_init: allocating context"); + *iCtx = (cipher_ctx *) sqlcipher_malloc(sizeof(cipher_ctx)); + c_ctx = *iCtx; + if(c_ctx == NULL) return SQLITE_NOMEM; + + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipher_cipher_ctx_init: allocating key"); + c_ctx->key = (unsigned char *) sqlcipher_malloc(ctx->key_sz); + + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipher_cipher_ctx_init: allocating hmac_key"); + c_ctx->hmac_key = (unsigned char *) sqlcipher_malloc(ctx->key_sz); + + if(c_ctx->key == NULL) return SQLITE_NOMEM; + if(c_ctx->hmac_key == NULL) return SQLITE_NOMEM; + + return SQLITE_OK; +} + +/** + * Free and wipe memory associated with a cipher_ctx + */ +static void sqlcipher_cipher_ctx_free(codec_ctx* ctx, cipher_ctx **iCtx) { + cipher_ctx *c_ctx = *iCtx; + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "cipher_ctx_free: iCtx=%p", iCtx); + sqlcipher_free(c_ctx->key, ctx->key_sz); + sqlcipher_free(c_ctx->hmac_key, ctx->key_sz); + sqlcipher_free(c_ctx->pass, c_ctx->pass_sz); + sqlcipher_free(c_ctx->keyspec, ctx->keyspec_sz); + sqlcipher_free(c_ctx, sizeof(cipher_ctx)); +} + +static int sqlcipher_codec_ctx_reserve_setup(codec_ctx *ctx) { + int base_reserve = ctx->iv_sz; /* base reserve size will be IV only */ + int reserve = base_reserve; + + ctx->hmac_sz = ctx->provider->get_hmac_sz(ctx->provider_ctx, ctx->hmac_algorithm); + + if(sqlcipher_codec_ctx_get_use_hmac(ctx)) + reserve += ctx->hmac_sz; /* if reserve will include hmac, update that size */ + + /* calculate the amount of reserve needed in even increments of the cipher block size */ + if(ctx->block_sz > 0) { + reserve = ((reserve % ctx->block_sz) == 0) ? reserve : + ((reserve / ctx->block_sz) + 1) * ctx->block_sz; + } + + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipher_codec_ctx_reserve_setup: base_reserve=%d block_sz=%d md_size=%d reserve=%d", + base_reserve, ctx->block_sz, ctx->hmac_sz, reserve); + + ctx->reserve_sz = reserve; + + return SQLITE_OK; +} + +/** + * Compare one cipher_ctx to another. + * + * returns 0 if all the parameters (except the derived key data) are the same + * returns 1 otherwise + */ +static int sqlcipher_cipher_ctx_cmp(cipher_ctx *c1, cipher_ctx *c2) { + int are_equal = ( + c1->pass_sz == c2->pass_sz + && ( + c1->pass == c2->pass + || !sqlcipher_memcmp((const unsigned char*)c1->pass, + (const unsigned char*)c2->pass, + c1->pass_sz) + )); + + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipher_cipher_ctx_cmp: c1=%p c2=%p sqlcipher_memcmp(c1->pass, c2_pass)=%d are_equal=%d", + c1, c2, + (c1->pass == NULL || c2->pass == NULL) ? + -1 : + sqlcipher_memcmp( + (const unsigned char*)c1->pass, + (const unsigned char*)c2->pass, + c1->pass_sz + ), + are_equal + ); + + return !are_equal; /* return 0 if they are the same, 1 otherwise */ +} + +/** + * Copy one cipher_ctx to another. For instance, assuming that read_ctx is a + * fully initialized context, you could copy it to write_ctx and all yet data + * and pass information across + * + * returns SQLITE_OK if initialization was successful + * returns SQLITE_NOMEM if an error occured allocating memory + */ +static int sqlcipher_cipher_ctx_copy(codec_ctx *ctx, cipher_ctx *target, cipher_ctx *source) { + void *key = target->key; + void *hmac_key = target->hmac_key; + + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipher_cipher_ctx_copy: target=%p, source=%p", target, source); + sqlcipher_free(target->pass, target->pass_sz); + sqlcipher_free(target->keyspec, ctx->keyspec_sz); + memcpy(target, source, sizeof(cipher_ctx)); + + target->key = key; /* restore pointer to previously allocated key data */ + memcpy(target->key, source->key, ctx->key_sz); + + target->hmac_key = hmac_key; /* restore pointer to previously allocated hmac key data */ + memcpy(target->hmac_key, source->hmac_key, ctx->key_sz); + + if(source->pass && source->pass_sz) { + target->pass = sqlcipher_malloc(source->pass_sz); + if(target->pass == NULL) return SQLITE_NOMEM; + memcpy(target->pass, source->pass, source->pass_sz); + } + if(source->keyspec) { + target->keyspec = sqlcipher_malloc(ctx->keyspec_sz); + if(target->keyspec == NULL) return SQLITE_NOMEM; + memcpy(target->keyspec, source->keyspec, ctx->keyspec_sz); + } + return SQLITE_OK; +} + +/** + * Set the keyspec for the cipher_ctx + * + * returns SQLITE_OK if assignment was successfull + * returns SQLITE_NOMEM if an error occured allocating memory + */ +static int sqlcipher_cipher_ctx_set_keyspec(codec_ctx *ctx, cipher_ctx *c_ctx, const unsigned char *key) { + /* free, zero existing pointers and size */ + sqlcipher_free(c_ctx->keyspec, ctx->keyspec_sz); + c_ctx->keyspec = NULL; + + c_ctx->keyspec = sqlcipher_malloc(ctx->keyspec_sz); + if(c_ctx->keyspec == NULL) return SQLITE_NOMEM; + + c_ctx->keyspec[0] = 'x'; + c_ctx->keyspec[1] = '\''; + cipher_bin2hex(key, ctx->key_sz, c_ctx->keyspec + 2); + cipher_bin2hex(ctx->kdf_salt, ctx->kdf_salt_sz, c_ctx->keyspec + (ctx->key_sz * 2) + 2); + c_ctx->keyspec[ctx->keyspec_sz - 1] = '\''; + return SQLITE_OK; +} + +int sqlcipher_codec_get_store_pass(codec_ctx *ctx) { + return ctx->store_pass; +} + +void sqlcipher_codec_set_store_pass(codec_ctx *ctx, int value) { + ctx->store_pass = value; +} + +void sqlcipher_codec_get_pass(codec_ctx *ctx, void **zKey, int *nKey) { + *zKey = ctx->read_ctx->pass; + *nKey = ctx->read_ctx->pass_sz; +} + +static void sqlcipher_set_derive_key(codec_ctx *ctx, int derive) { + if(ctx->read_ctx != NULL) ctx->read_ctx->derive_key = derive; + if(ctx->write_ctx != NULL) ctx->write_ctx->derive_key = derive; +} + +/** + * Set the passphrase for the cipher_ctx + * + * returns SQLITE_OK if assignment was successfull + * returns SQLITE_NOMEM if an error occured allocating memory + */ +static int sqlcipher_cipher_ctx_set_pass(cipher_ctx *ctx, const void *zKey, int nKey) { + /* free, zero existing pointers and size */ + sqlcipher_free(ctx->pass, ctx->pass_sz); + ctx->pass = NULL; + ctx->pass_sz = 0; + + if(zKey && nKey) { /* if new password is provided, copy it */ + ctx->pass_sz = nKey; + ctx->pass = sqlcipher_malloc(nKey); + if(ctx->pass == NULL) return SQLITE_NOMEM; + memcpy(ctx->pass, zKey, nKey); + } + return SQLITE_OK; +} + +int sqlcipher_codec_ctx_set_pass(codec_ctx *ctx, const void *zKey, int nKey, int for_ctx) { + cipher_ctx *c_ctx = for_ctx ? ctx->write_ctx : ctx->read_ctx; + int rc; + + if((rc = sqlcipher_cipher_ctx_set_pass(c_ctx, zKey, nKey)) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_ctx_set_pass: error %d from sqlcipher_cipher_ctx_set_pass", rc); + return rc; + } + + c_ctx->derive_key = 1; + + if(for_ctx == 2) { + if((rc = sqlcipher_cipher_ctx_copy(ctx, for_ctx ? ctx->read_ctx : ctx->write_ctx, c_ctx)) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_ctx_set_pass: error %d from sqlcipher_cipher_ctx_copy", rc); + return rc; + } + } + + return SQLITE_OK; +} + +const char* sqlcipher_codec_ctx_get_cipher(codec_ctx *ctx) { + return ctx->provider->get_cipher(ctx->provider_ctx); +} + +/* set the global default KDF iteration */ +void sqlcipher_set_default_kdf_iter(int iter) { + default_kdf_iter = iter; +} + +int sqlcipher_get_default_kdf_iter() { + return default_kdf_iter; +} + +int sqlcipher_codec_ctx_set_kdf_iter(codec_ctx *ctx, int kdf_iter) { + ctx->kdf_iter = kdf_iter; + sqlcipher_set_derive_key(ctx, 1); + return SQLITE_OK; +} + +int sqlcipher_codec_ctx_get_kdf_iter(codec_ctx *ctx) { + return ctx->kdf_iter; +} + +int sqlcipher_codec_ctx_set_fast_kdf_iter(codec_ctx *ctx, int fast_kdf_iter) { + ctx->fast_kdf_iter = fast_kdf_iter; + sqlcipher_set_derive_key(ctx, 1); + return SQLITE_OK; +} + +int sqlcipher_codec_ctx_get_fast_kdf_iter(codec_ctx *ctx) { + return ctx->fast_kdf_iter; +} + +/* set the global default flag for HMAC */ +void sqlcipher_set_default_use_hmac(int use) { + if(use) SQLCIPHER_FLAG_SET(default_flags, CIPHER_FLAG_HMAC); + else SQLCIPHER_FLAG_UNSET(default_flags,CIPHER_FLAG_HMAC); +} + +int sqlcipher_get_default_use_hmac() { + return SQLCIPHER_FLAG_GET(default_flags, CIPHER_FLAG_HMAC); +} + +void sqlcipher_set_hmac_salt_mask(unsigned char mask) { + hmac_salt_mask = mask; +} + +unsigned char sqlcipher_get_hmac_salt_mask() { + return hmac_salt_mask; +} + +/* set the codec flag for whether this individual database should be using hmac */ +int sqlcipher_codec_ctx_set_use_hmac(codec_ctx *ctx, int use) { + if(use) { + SQLCIPHER_FLAG_SET(ctx->flags, CIPHER_FLAG_HMAC); + } else { + SQLCIPHER_FLAG_UNSET(ctx->flags, CIPHER_FLAG_HMAC); + } + + return sqlcipher_codec_ctx_reserve_setup(ctx); +} + +int sqlcipher_codec_ctx_get_use_hmac(codec_ctx *ctx) { + return SQLCIPHER_FLAG_GET(ctx->flags, CIPHER_FLAG_HMAC); +} + +/* the length of plaintext header size must be: + * 1. greater than or equal to zero + * 2. a multiple of the cipher block size + * 3. less than the usable size of the first database page + */ +int sqlcipher_set_default_plaintext_header_size(int size) { + default_plaintext_header_sz = size; + return SQLITE_OK; +} + +int sqlcipher_codec_ctx_set_plaintext_header_size(codec_ctx *ctx, int size) { + if(size >= 0 && ctx->block_sz > 0 && (size % ctx->block_sz) == 0 && size < (ctx->page_sz - ctx->reserve_sz)) { + ctx->plaintext_header_sz = size; + return SQLITE_OK; + } + ctx->plaintext_header_sz = -1; + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_ctx_set_plaintext_header_size: attempt to set invalid plantext_header_size %d", size); + return SQLITE_ERROR; +} + +int sqlcipher_get_default_plaintext_header_size() { + return default_plaintext_header_sz; +} + +int sqlcipher_codec_ctx_get_plaintext_header_size(codec_ctx *ctx) { + return ctx->plaintext_header_sz; +} + +/* manipulate HMAC algorithm */ +int sqlcipher_set_default_hmac_algorithm(int algorithm) { + default_hmac_algorithm = algorithm; + return SQLITE_OK; +} + +int sqlcipher_codec_ctx_set_hmac_algorithm(codec_ctx *ctx, int algorithm) { + ctx->hmac_algorithm = algorithm; + return sqlcipher_codec_ctx_reserve_setup(ctx); +} + +int sqlcipher_get_default_hmac_algorithm() { + return default_hmac_algorithm; +} + +int sqlcipher_codec_ctx_get_hmac_algorithm(codec_ctx *ctx) { + return ctx->hmac_algorithm; +} + +/* manipulate KDF algorithm */ +int sqlcipher_set_default_kdf_algorithm(int algorithm) { + default_kdf_algorithm = algorithm; + return SQLITE_OK; +} + +int sqlcipher_codec_ctx_set_kdf_algorithm(codec_ctx *ctx, int algorithm) { + ctx->kdf_algorithm = algorithm; + return SQLITE_OK; +} + +int sqlcipher_get_default_kdf_algorithm() { + return default_kdf_algorithm; +} + +int sqlcipher_codec_ctx_get_kdf_algorithm(codec_ctx *ctx) { + return ctx->kdf_algorithm; +} + +void sqlcipher_codec_ctx_set_error(codec_ctx *ctx, int error) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_ctx_set_error: ctx=%p, error=%d", ctx, error); + sqlite3pager_error(ctx->pBt->pBt->pPager, error); + ctx->pBt->pBt->db->errCode = error; +} + +int sqlcipher_codec_ctx_get_reservesize(codec_ctx *ctx) { + return ctx->reserve_sz; +} + +void* sqlcipher_codec_ctx_get_data(codec_ctx *ctx) { + return ctx->buffer; +} + +static int sqlcipher_codec_ctx_init_kdf_salt(codec_ctx *ctx) { + sqlite3_file *fd = sqlite3PagerFile(ctx->pBt->pBt->pPager); + + if(SQLCIPHER_FLAG_GET(ctx->flags, CIPHER_FLAG_HAS_KDF_SALT)) { + return SQLITE_OK; /* don't reload salt when not needed */ + } + + /* read salt from header, if present, otherwise generate a new random salt */ + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipher_codec_ctx_init_kdf_salt: obtaining salt"); + if(fd == NULL || fd->pMethods == 0 || sqlite3OsRead(fd, ctx->kdf_salt, ctx->kdf_salt_sz, 0) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipher_codec_ctx_init_kdf_salt: unable to read salt from file header, generating random"); + if(ctx->provider->random(ctx->provider_ctx, ctx->kdf_salt, ctx->kdf_salt_sz) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_ctx_init_kdf_salt: error retrieving random bytes from provider"); + return SQLITE_ERROR; + } + } + SQLCIPHER_FLAG_SET(ctx->flags, CIPHER_FLAG_HAS_KDF_SALT); + return SQLITE_OK; +} + +int sqlcipher_codec_ctx_set_kdf_salt(codec_ctx *ctx, unsigned char *salt, int size) { + if(size >= ctx->kdf_salt_sz) { + memcpy(ctx->kdf_salt, salt, ctx->kdf_salt_sz); + SQLCIPHER_FLAG_SET(ctx->flags, CIPHER_FLAG_HAS_KDF_SALT); + return SQLITE_OK; + } + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_ctx_set_kdf_salt: attempt to set salt of incorrect size %d", size); + return SQLITE_ERROR; +} + +int sqlcipher_codec_ctx_get_kdf_salt(codec_ctx *ctx, void** salt) { + int rc = SQLITE_OK; + if(!SQLCIPHER_FLAG_GET(ctx->flags, CIPHER_FLAG_HAS_KDF_SALT)) { + if((rc = sqlcipher_codec_ctx_init_kdf_salt(ctx)) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_ctx_get_kdf_salt: error %d from sqlcipher_codec_ctx_init_kdf_salt", rc); + } + } + *salt = ctx->kdf_salt; + + return rc; +} + +void sqlcipher_codec_get_keyspec(codec_ctx *ctx, void **zKey, int *nKey) { + *zKey = ctx->read_ctx->keyspec; + *nKey = ctx->keyspec_sz; +} + +int sqlcipher_codec_ctx_set_pagesize(codec_ctx *ctx, int size) { + if(!((size != 0) && ((size & (size - 1)) == 0)) || size < 512 || size > 65536) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "cipher_page_size not a power of 2 and between 512 and 65536 inclusive"); + return SQLITE_ERROR; + } + /* attempt to free the existing page buffer */ + sqlcipher_free(ctx->buffer,ctx->page_sz); + ctx->page_sz = size; + + /* pre-allocate a page buffer of PageSize bytes. This will + be used as a persistent buffer for encryption and decryption + operations to avoid overhead of multiple memory allocations*/ + ctx->buffer = sqlcipher_malloc(size); + if(ctx->buffer == NULL) return SQLITE_NOMEM; + + return SQLITE_OK; +} + +int sqlcipher_codec_ctx_get_pagesize(codec_ctx *ctx) { + return ctx->page_sz; +} + +void sqlcipher_set_default_pagesize(int page_size) { + default_page_size = page_size; +} + +int sqlcipher_get_default_pagesize() { + return default_page_size; +} + +void sqlcipher_set_mem_security(int on) { + /* memory security can only be enabled, not disabled */ + if(on) { + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipher_set_mem_security: on"); + sqlcipher_mem_security_on = on; + } +} + +int sqlcipher_get_mem_security() { + /* only report that memory security is enabled if pragma cipher_memory_security is ON and + SQLCipher's allocator/deallocator was run at least one timecurrently used */ + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipher_get_mem_security: sqlcipher_mem_security_on = %d, sqlcipher_mem_executed = %d", sqlcipher_mem_security_on, sqlcipher_mem_executed); + return sqlcipher_mem_security_on && sqlcipher_mem_executed; +} + + +int sqlcipher_codec_ctx_init(codec_ctx **iCtx, Db *pDb, Pager *pPager, const void *zKey, int nKey) { + int rc; + codec_ctx *ctx; + + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipher_codec_ctx_init: allocating context"); + + *iCtx = sqlcipher_malloc(sizeof(codec_ctx)); + ctx = *iCtx; + + if(ctx == NULL) return SQLITE_NOMEM; + + ctx->pBt = pDb->pBt; /* assign pointer to database btree structure */ + + /* allocate space for salt data. Then read the first 16 bytes + directly off the database file. This is the salt for the + key derivation function. If we get a short read allocate + a new random salt value */ + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipher_codec_ctx_init: allocating kdf_salt"); + ctx->kdf_salt_sz = FILE_HEADER_SZ; + ctx->kdf_salt = sqlcipher_malloc(ctx->kdf_salt_sz); + if(ctx->kdf_salt == NULL) return SQLITE_NOMEM; + + /* allocate space for separate hmac salt data. We want the + HMAC derivation salt to be different than the encryption + key derivation salt */ + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipher_codec_ctx_init: allocating hmac_kdf_salt"); + ctx->hmac_kdf_salt = sqlcipher_malloc(ctx->kdf_salt_sz); + if(ctx->hmac_kdf_salt == NULL) return SQLITE_NOMEM; + + /* setup default flags */ + ctx->flags = default_flags; + + /* setup the crypto provider */ + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipher_codec_ctx_init: allocating provider"); + ctx->provider = (sqlcipher_provider *) sqlcipher_malloc(sizeof(sqlcipher_provider)); + if(ctx->provider == NULL) return SQLITE_NOMEM; + + /* make a copy of the provider to be used for the duration of the context */ + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_codec_ctx_init: entering SQLCIPHER_MUTEX_PROVIDER"); + sqlite3_mutex_enter(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_codec_ctx_init: entered SQLCIPHER_MUTEX_PROVIDER"); + + memcpy(ctx->provider, default_provider, sizeof(sqlcipher_provider)); + + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_codec_ctx_init: leaving SQLCIPHER_MUTEX_PROVIDER"); + sqlite3_mutex_leave(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_codec_ctx_init: left SQLCIPHER_MUTEX_PROVIDER"); + + if((rc = ctx->provider->ctx_init(&ctx->provider_ctx)) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_ctx_init: error %d returned from ctx_init", rc); + return rc; + } + + ctx->key_sz = ctx->provider->get_key_sz(ctx->provider_ctx); + ctx->iv_sz = ctx->provider->get_iv_sz(ctx->provider_ctx); + ctx->block_sz = ctx->provider->get_block_sz(ctx->provider_ctx); + + /* establic the size for a hex-formated key specification, containing the + raw encryption key and the salt used to generate it format. will be x'hexkey...hexsalt' + so oversize by 3 bytes */ + ctx->keyspec_sz = ((ctx->key_sz + ctx->kdf_salt_sz) * 2) + 3; + + /* + Always overwrite page size and set to the default because the first page of the database + in encrypted and thus sqlite can't effectively determine the pagesize. this causes an issue in + cases where bytes 16 & 17 of the page header are a power of 2 as reported by John Lehman + */ + if((rc = sqlcipher_codec_ctx_set_pagesize(ctx, default_page_size)) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_ctx_init: error %d returned from sqlcipher_codec_ctx_set_pagesize with %d", rc, default_page_size); + return rc; + } + + /* establish settings for the KDF iterations and fast (HMAC) KDF iterations */ + if((rc = sqlcipher_codec_ctx_set_kdf_iter(ctx, default_kdf_iter)) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_ctx_init: error %d setting default_kdf_iter %d", rc, default_kdf_iter); + return rc; + } + + if((rc = sqlcipher_codec_ctx_set_fast_kdf_iter(ctx, FAST_PBKDF2_ITER)) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_ctx_init: error %d setting fast_kdf_iter to %d", rc, FAST_PBKDF2_ITER); + return rc; + } + + /* set the default HMAC and KDF algorithms which will determine the reserve size */ + if((rc = sqlcipher_codec_ctx_set_hmac_algorithm(ctx, default_hmac_algorithm)) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_ctx_init: error %d setting sqlcipher_codec_ctx_set_hmac_algorithm with %d", rc, default_hmac_algorithm); + return rc; + } + + /* Note that use_hmac is a special case that requires recalculation of page size + so we call set_use_hmac to perform setup */ + if((rc = sqlcipher_codec_ctx_set_use_hmac(ctx, SQLCIPHER_FLAG_GET(default_flags, CIPHER_FLAG_HMAC))) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_ctx_init: error %d setting use_hmac %d", rc, SQLCIPHER_FLAG_GET(default_flags, CIPHER_FLAG_HMAC)); + return rc; + } + + if((rc = sqlcipher_codec_ctx_set_kdf_algorithm(ctx, default_kdf_algorithm)) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_ctx_init: error %d setting sqlcipher_codec_ctx_set_kdf_algorithm with %d", rc, default_kdf_algorithm); + return rc; + } + + /* setup the default plaintext header size */ + if((rc = sqlcipher_codec_ctx_set_plaintext_header_size(ctx, default_plaintext_header_sz)) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_ctx_init: error %d setting sqlcipher_codec_ctx_set_plaintext_header_size with %d", rc, default_plaintext_header_sz); + return rc; + } + + /* initialize the read and write sub-contexts. this must happen after key_sz is established */ + if((rc = sqlcipher_cipher_ctx_init(ctx, &ctx->read_ctx)) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_ctx_init: error %d initializing read_ctx", rc); + return rc; + } + + if((rc = sqlcipher_cipher_ctx_init(ctx, &ctx->write_ctx)) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_ctx_init: error %d initializing write_ctx", rc); + return rc; + } + + /* set the key material on one of the sub cipher contexts and sync them up */ + if((rc = sqlcipher_codec_ctx_set_pass(ctx, zKey, nKey, 0)) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_ctx_init: error %d setting pass key", rc); + return rc; + } + + if((rc = sqlcipher_cipher_ctx_copy(ctx, ctx->write_ctx, ctx->read_ctx)) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_ctx_init: error %d copying write_ctx to read_ctx", rc); + return rc; + } + + return SQLITE_OK; +} + +/** + * Free and wipe memory associated with a cipher_ctx, including the allocated + * read_ctx and write_ctx. + */ +void sqlcipher_codec_ctx_free(codec_ctx **iCtx) { + codec_ctx *ctx = *iCtx; + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "codec_ctx_free: iCtx=%p", iCtx); + sqlcipher_free(ctx->kdf_salt, ctx->kdf_salt_sz); + sqlcipher_free(ctx->hmac_kdf_salt, ctx->kdf_salt_sz); + sqlcipher_free(ctx->buffer, ctx->page_sz); + + ctx->provider->ctx_free(&ctx->provider_ctx); + sqlcipher_free(ctx->provider, sizeof(sqlcipher_provider)); + + sqlcipher_cipher_ctx_free(ctx, &ctx->read_ctx); + sqlcipher_cipher_ctx_free(ctx, &ctx->write_ctx); + sqlcipher_free(ctx, sizeof(codec_ctx)); +} + +/** convert a 32bit unsigned integer to little endian byte ordering */ +static void sqlcipher_put4byte_le(unsigned char *p, u32 v) { + p[0] = (u8)v; + p[1] = (u8)(v>>8); + p[2] = (u8)(v>>16); + p[3] = (u8)(v>>24); +} + +static int sqlcipher_page_hmac(codec_ctx *ctx, cipher_ctx *c_ctx, Pgno pgno, unsigned char *in, int in_sz, unsigned char *out) { + unsigned char pgno_raw[sizeof(pgno)]; + /* we may convert page number to consistent representation before calculating MAC for + compatibility across big-endian and little-endian platforms. + + Note: The public release of sqlcipher 2.0.0 to 2.0.6 had a bug where the bytes of pgno + were used directly in the MAC. SQLCipher convert's to little endian by default to preserve + backwards compatibility on the most popular platforms, but can optionally be configured + to use either big endian or native byte ordering via pragma. */ + + if(SQLCIPHER_FLAG_GET(ctx->flags, CIPHER_FLAG_LE_PGNO)) { /* compute hmac using little endian pgno*/ + sqlcipher_put4byte_le(pgno_raw, pgno); + } else if(SQLCIPHER_FLAG_GET(ctx->flags, CIPHER_FLAG_BE_PGNO)) { /* compute hmac using big endian pgno */ + sqlite3Put4byte(pgno_raw, pgno); /* sqlite3Put4byte converts 32bit uint to big endian */ + } else { /* use native byte ordering */ + memcpy(pgno_raw, &pgno, sizeof(pgno)); + } + + /* include the encrypted page data, initialization vector, and page number in HMAC. This will + prevent both tampering with the ciphertext, manipulation of the IV, or resequencing otherwise + valid pages out of order in a database */ + return ctx->provider->hmac( + ctx->provider_ctx, ctx->hmac_algorithm, c_ctx->hmac_key, + ctx->key_sz, in, + in_sz, (unsigned char*) &pgno_raw, + sizeof(pgno), out); +} + +/* + * ctx - codec context + * pgno - page number in database + * size - size in bytes of input and output buffers + * mode - 1 to encrypt, 0 to decrypt + * in - pointer to input bytes + * out - pouter to output bytes + */ +int sqlcipher_page_cipher(codec_ctx *ctx, int for_ctx, Pgno pgno, int mode, int page_sz, unsigned char *in, unsigned char *out) { + cipher_ctx *c_ctx = for_ctx ? ctx->write_ctx : ctx->read_ctx; + unsigned char *iv_in, *iv_out, *hmac_in, *hmac_out, *out_start; + int size; + + /* calculate some required positions into various buffers */ + size = page_sz - ctx->reserve_sz; /* adjust size to useable size and memset reserve at end of page */ + iv_out = out + size; + iv_in = in + size; + + /* hmac will be written immediately after the initialization vector. the remainder of the page reserve will contain + random bytes. note, these pointers are only valid when using hmac */ + hmac_in = in + size + ctx->iv_sz; + hmac_out = out + size + ctx->iv_sz; + out_start = out; /* note the original position of the output buffer pointer, as out will be rewritten during encryption */ + + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipher_page_cipher: pgno=%d, mode=%d, size=%d", pgno, mode, size); + CODEC_HEXDUMP("sqlcipher_page_cipher: input page data", in, page_sz); + + /* the key size should never be zero. If it is, error out. */ + if(ctx->key_sz == 0) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_page_cipher: error possible context corruption, key_sz is zero for pgno=%d", pgno); + goto error; + } + + if(mode == CIPHER_ENCRYPT) { + /* start at front of the reserve block, write random data to the end */ + if(ctx->provider->random(ctx->provider_ctx, iv_out, ctx->reserve_sz) != SQLITE_OK) goto error; + } else { /* CIPHER_DECRYPT */ + memcpy(iv_out, iv_in, ctx->iv_sz); /* copy the iv from the input to output buffer */ + } + + if(SQLCIPHER_FLAG_GET(ctx->flags, CIPHER_FLAG_HMAC) && (mode == CIPHER_DECRYPT)) { + if(sqlcipher_page_hmac(ctx, c_ctx, pgno, in, size + ctx->iv_sz, hmac_out) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_page_cipher: hmac operation on decrypt failed for pgno=%d", pgno); + goto error; + } + + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipher_page_cipher: comparing hmac on in=%p out=%p hmac_sz=%d", hmac_in, hmac_out, ctx->hmac_sz); + if(sqlcipher_memcmp(hmac_in, hmac_out, ctx->hmac_sz) != 0) { /* the hmac check failed */ + if(sqlite3BtreeGetAutoVacuum(ctx->pBt) != BTREE_AUTOVACUUM_NONE && sqlcipher_ismemset(in, 0, page_sz) == 0) { + /* first check if the entire contents of the page is zeros. If so, this page + resulted from a short read (i.e. sqlite attempted to pull a page after the end of the file. these + short read failures must be ignored for autovaccum mode to work so wipe the output buffer + and return SQLITE_OK to skip the decryption step. */ + sqlcipher_log(SQLCIPHER_LOG_WARN, "sqlcipher_page_cipher: zeroed page (short read) for pgno %d, encryption but returning SQLITE_OK", pgno); + sqlcipher_memset(out, 0, page_sz); + return SQLITE_OK; + } else { + /* if the page memory is not all zeros, it means the there was data and a hmac on the page. + since the check failed, the page was either tampered with or corrupted. wipe the output buffer, + and return SQLITE_ERROR to the caller */ + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_page_cipher: hmac check failed for pgno=%d returning SQLITE_ERROR", pgno); + goto error; + } + } + } + + if(ctx->provider->cipher(ctx->provider_ctx, mode, c_ctx->key, ctx->key_sz, iv_out, in, size, out) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_page_cipher: cipher operation mode=%d failed for pgno=%d returning SQLITE_ERROR", mode, pgno); + goto error; + }; + + if(SQLCIPHER_FLAG_GET(ctx->flags, CIPHER_FLAG_HMAC) && (mode == CIPHER_ENCRYPT)) { + if(sqlcipher_page_hmac(ctx, c_ctx, pgno, out_start, size + ctx->iv_sz, hmac_out) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_page_cipher: hmac operation on encrypt failed for pgno=%d", pgno); + goto error; + }; + } + + CODEC_HEXDUMP("sqlcipher_page_cipher: output page data", out_start, page_sz); + + return SQLITE_OK; +error: + sqlcipher_memset(out, 0, page_sz); + return SQLITE_ERROR; +} + +/** + * Derive an encryption key for a cipher contex key based on the raw password. + * + * If the raw key data is formated as x'hex' and there are exactly enough hex chars to fill + * the key (i.e 64 hex chars for a 256 bit key) then the key data will be used directly. + + * Else, if the raw key data is formated as x'hex' and there are exactly enough hex chars to fill + * the key and the salt (i.e 92 hex chars for a 256 bit key and 16 byte salt) then it will be unpacked + * as the key followed by the salt. + * + * Otherwise, a key data will be derived using PBKDF2 + * + * returns SQLITE_OK if initialization was successful + * returns SQLITE_ERROR if the key could't be derived (for instance if pass is NULL or pass_sz is 0) + */ +static int sqlcipher_cipher_ctx_key_derive(codec_ctx *ctx, cipher_ctx *c_ctx) { + int rc; + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipher_cipher_ctx_key_derive: ctx->kdf_salt_sz=%d ctx->kdf_iter=%d ctx->fast_kdf_iter=%d ctx->key_sz=%d", + ctx->kdf_salt_sz, ctx->kdf_iter, ctx->fast_kdf_iter, ctx->key_sz); + + if(c_ctx->pass && c_ctx->pass_sz) { /* if key material is present on the context for derivation */ + + /* if necessary, initialize the salt from the header or random source */ + if(!SQLCIPHER_FLAG_GET(ctx->flags, CIPHER_FLAG_HAS_KDF_SALT)) { + if((rc = sqlcipher_codec_ctx_init_kdf_salt(ctx)) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_cipher_ctx_key_derive: error %d from sqlcipher_codec_ctx_init_kdf_salt", rc); + return rc; + } + } + + if (c_ctx->pass_sz == ((ctx->key_sz * 2) + 3) && sqlite3StrNICmp((const char *)c_ctx->pass ,"x'", 2) == 0 && cipher_isHex(c_ctx->pass + 2, ctx->key_sz * 2)) { + int n = c_ctx->pass_sz - 3; /* adjust for leading x' and tailing ' */ + const unsigned char *z = c_ctx->pass + 2; /* adjust lead offset of x' */ + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "cipher_ctx_key_derive: using raw key from hex"); + cipher_hex2bin(z, n, c_ctx->key); + } else if (c_ctx->pass_sz == (((ctx->key_sz + ctx->kdf_salt_sz) * 2) + 3) && sqlite3StrNICmp((const char *)c_ctx->pass ,"x'", 2) == 0 && cipher_isHex(c_ctx->pass + 2, (ctx->key_sz + ctx->kdf_salt_sz) * 2)) { + const unsigned char *z = c_ctx->pass + 2; /* adjust lead offset of x' */ + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "cipher_ctx_key_derive: using raw key from hex"); + cipher_hex2bin(z, (ctx->key_sz * 2), c_ctx->key); + cipher_hex2bin(z + (ctx->key_sz * 2), (ctx->kdf_salt_sz * 2), ctx->kdf_salt); + } else { + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "cipher_ctx_key_derive: deriving key using full PBKDF2 with %d iterations", ctx->kdf_iter); + if(ctx->provider->kdf(ctx->provider_ctx, ctx->kdf_algorithm, c_ctx->pass, c_ctx->pass_sz, + ctx->kdf_salt, ctx->kdf_salt_sz, ctx->kdf_iter, + ctx->key_sz, c_ctx->key) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "cipher_ctx_key_derive: error occurred from provider kdf generating encryption key"); + return SQLITE_ERROR; + } + } + + /* set the context "keyspec" containing the hex-formatted key and salt to be used when attaching databases */ + if((rc = sqlcipher_cipher_ctx_set_keyspec(ctx, c_ctx, c_ctx->key)) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_cipher_ctx_key_derive: error %d from sqlcipher_cipher_ctx_set_keyspec", rc); + return rc; + } + + /* if this context is setup to use hmac checks, generate a seperate and different + key for HMAC. In this case, we use the output of the previous KDF as the input to + this KDF run. This ensures a distinct but predictable HMAC key. */ + if(ctx->flags & CIPHER_FLAG_HMAC) { + int i; + + /* start by copying the kdf key into the hmac salt slot + then XOR it with the fixed hmac salt defined at compile time + this ensures that the salt passed in to derive the hmac key, while + easy to derive and publically known, is not the same as the salt used + to generate the encryption key */ + memcpy(ctx->hmac_kdf_salt, ctx->kdf_salt, ctx->kdf_salt_sz); + for(i = 0; i < ctx->kdf_salt_sz; i++) { + ctx->hmac_kdf_salt[i] ^= hmac_salt_mask; + } + + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "cipher_ctx_key_derive: deriving hmac key from encryption key using PBKDF2 with %d iterations", + ctx->fast_kdf_iter); + + + if(ctx->provider->kdf(ctx->provider_ctx, ctx->kdf_algorithm, c_ctx->key, ctx->key_sz, + ctx->hmac_kdf_salt, ctx->kdf_salt_sz, ctx->fast_kdf_iter, + ctx->key_sz, c_ctx->hmac_key) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "cipher_ctx_key_derive: error occurred from provider kdf generating HMAC key"); + return SQLITE_ERROR; + } + } + + c_ctx->derive_key = 0; + return SQLITE_OK; + } + sqlcipher_log(SQLCIPHER_LOG_ERROR, "cipher_ctx_key_derive: key material is not present on the context for key derivation"); + return SQLITE_ERROR; +} + +int sqlcipher_codec_key_derive(codec_ctx *ctx) { + /* derive key on first use if necessary */ + if(ctx->read_ctx->derive_key) { + if(sqlcipher_cipher_ctx_key_derive(ctx, ctx->read_ctx) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_key_derive: error occurred deriving read_ctx key"); + return SQLITE_ERROR; + } + } + + if(ctx->write_ctx->derive_key) { + if(sqlcipher_cipher_ctx_cmp(ctx->write_ctx, ctx->read_ctx) == 0) { + /* the relevant parameters are the same, just copy read key */ + if(sqlcipher_cipher_ctx_copy(ctx, ctx->write_ctx, ctx->read_ctx) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_key_derive: error occurred copying read_ctx to write_ctx"); + return SQLITE_ERROR; + } + } else { + if(sqlcipher_cipher_ctx_key_derive(ctx, ctx->write_ctx) != SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_key_derive: error occurred deriving write_ctx key"); + return SQLITE_ERROR; + } + } + } + + /* TODO: wipe and free passphrase after key derivation */ + if(ctx->store_pass != 1) { + sqlcipher_cipher_ctx_set_pass(ctx->read_ctx, NULL, 0); + sqlcipher_cipher_ctx_set_pass(ctx->write_ctx, NULL, 0); + } + + return SQLITE_OK; +} + +int sqlcipher_codec_key_copy(codec_ctx *ctx, int source) { + if(source == CIPHER_READ_CTX) { + return sqlcipher_cipher_ctx_copy(ctx, ctx->write_ctx, ctx->read_ctx); + } else { + return sqlcipher_cipher_ctx_copy(ctx, ctx->read_ctx, ctx->write_ctx); + } +} + +const char* sqlcipher_codec_get_cipher_provider(codec_ctx *ctx) { + return ctx->provider->get_provider_name(ctx->provider_ctx); +} + + +static int sqlcipher_check_connection(const char *filename, char *key, int key_sz, char *sql, int *user_version, char** journal_mode) { + int rc; + sqlite3 *db = NULL; + sqlite3_stmt *statement = NULL; + char *query_journal_mode = "PRAGMA journal_mode;"; + char *query_user_version = "PRAGMA user_version;"; + + rc = sqlite3_open(filename, &db); + if(rc != SQLITE_OK) goto cleanup; + + rc = sqlite3_key(db, key, key_sz); + if(rc != SQLITE_OK) goto cleanup; + + rc = sqlite3_exec(db, sql, NULL, NULL, NULL); + if(rc != SQLITE_OK) goto cleanup; + + /* start by querying the user version. + this will fail if the key is incorrect */ + rc = sqlite3_prepare(db, query_user_version, -1, &statement, NULL); + if(rc != SQLITE_OK) goto cleanup; + + rc = sqlite3_step(statement); + if(rc == SQLITE_ROW) { + *user_version = sqlite3_column_int(statement, 0); + } else { + goto cleanup; + } + sqlite3_finalize(statement); + + rc = sqlite3_prepare(db, query_journal_mode, -1, &statement, NULL); + if(rc != SQLITE_OK) goto cleanup; + + rc = sqlite3_step(statement); + if(rc == SQLITE_ROW) { + *journal_mode = sqlite3_mprintf("%s", sqlite3_column_text(statement, 0)); + } else { + goto cleanup; + } + rc = SQLITE_OK; + /* cleanup will finalize open statement */ + +cleanup: + if(statement) sqlite3_finalize(statement); + if(db) sqlite3_close(db); + return rc; +} + +int sqlcipher_codec_ctx_integrity_check(codec_ctx *ctx, Parse *pParse, char *column) { + Pgno page = 1; + int rc = 0; + char *result; + unsigned char *hmac_out = NULL; + sqlite3_file *fd = sqlite3PagerFile(ctx->pBt->pBt->pPager); + i64 file_sz; + + Vdbe *v = sqlite3GetVdbe(pParse); + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, column, SQLITE_STATIC); + + if(fd == NULL || fd->pMethods == 0) { + sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, "database file is undefined", P4_TRANSIENT); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1); + goto cleanup; + } + + if(!(ctx->flags & CIPHER_FLAG_HMAC)) { + sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, "HMAC is not enabled, unable to integrity check", P4_TRANSIENT); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1); + goto cleanup; + } + + if((rc = sqlcipher_codec_key_derive(ctx)) != SQLITE_OK) { + sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, "unable to derive keys", P4_TRANSIENT); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1); + goto cleanup; + } + + sqlite3OsFileSize(fd, &file_sz); + hmac_out = sqlcipher_malloc(ctx->hmac_sz); + + for(page = 1; page <= file_sz / ctx->page_sz; page++) { + i64 offset = (page - 1) * ctx->page_sz; + int payload_sz = ctx->page_sz - ctx->reserve_sz + ctx->iv_sz; + int read_sz = ctx->page_sz; + + /* skip integrity check on PAGER_SJ_PGNO since it will have no valid content */ + if(sqlite3pager_is_sj_pgno(ctx->pBt->pBt->pPager, page)) continue; + + if(page==1) { + int page1_offset = ctx->plaintext_header_sz ? ctx->plaintext_header_sz : FILE_HEADER_SZ; + read_sz = read_sz - page1_offset; + payload_sz = payload_sz - page1_offset; + offset += page1_offset; + } + + sqlcipher_memset(ctx->buffer, 0, ctx->page_sz); + sqlcipher_memset(hmac_out, 0, ctx->hmac_sz); + if(sqlite3OsRead(fd, ctx->buffer, read_sz, offset) != SQLITE_OK) { + result = sqlite3_mprintf("error reading %d bytes from file page %d at offset %d", read_sz, page, offset); + sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, result, P4_DYNAMIC); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1); + } else if(sqlcipher_page_hmac(ctx, ctx->read_ctx, page, ctx->buffer, payload_sz, hmac_out) != SQLITE_OK) { + result = sqlite3_mprintf("HMAC operation failed for page %d", page); + sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, result, P4_DYNAMIC); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1); + } else if(sqlcipher_memcmp(ctx->buffer + payload_sz, hmac_out, ctx->hmac_sz) != 0) { + result = sqlite3_mprintf("HMAC verification failed for page %d", page); + sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, result, P4_DYNAMIC); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1); + } + } + + if(file_sz % ctx->page_sz != 0) { + result = sqlite3_mprintf("page %d has an invalid size of %lld bytes", page, file_sz - ((file_sz / ctx->page_sz) * ctx->page_sz)); + sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, result, P4_DYNAMIC); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1); + } + +cleanup: + if(hmac_out != NULL) sqlcipher_free(hmac_out, ctx->hmac_sz); + return SQLITE_OK; +} + +int sqlcipher_codec_ctx_migrate(codec_ctx *ctx) { + int i, pass_sz, keyspec_sz, nRes, user_version, rc, oflags; + Db *pDb = 0; + sqlite3 *db = ctx->pBt->db; + const char *db_filename = sqlite3_db_filename(db, "main"); + char *set_user_version = NULL, *pass = NULL, *attach_command = NULL, *migrated_db_filename = NULL, *keyspec = NULL, *temp = NULL, *journal_mode = NULL, *set_journal_mode = NULL, *pragma_compat = NULL; + Btree *pDest = NULL, *pSrc = NULL; + sqlite3_file *srcfile, *destfile; +#if defined(_WIN32) || defined(SQLITE_OS_WINRT) + LPWSTR w_db_filename = NULL, w_migrated_db_filename = NULL; + int w_db_filename_sz = 0, w_migrated_db_filename_sz = 0; +#endif + pass_sz = keyspec_sz = rc = user_version = 0; + + if(!db_filename || sqlite3Strlen30(db_filename) < 1) + goto cleanup; /* exit immediately if this is an in memory database */ + + /* pull the provided password / key material off the current codec context */ + pass_sz = ctx->read_ctx->pass_sz; + pass = sqlcipher_malloc(pass_sz+1); + memset(pass, 0, pass_sz+1); + memcpy(pass, ctx->read_ctx->pass, pass_sz); + + /* Version 4 - current, no upgrade required, so exit immediately */ + rc = sqlcipher_check_connection(db_filename, pass, pass_sz, "", &user_version, &journal_mode); + if(rc == SQLITE_OK){ + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "No upgrade required - exiting"); + goto cleanup; + } + + for(i = 3; i > 0; i--) { + pragma_compat = sqlite3_mprintf("PRAGMA cipher_compatibility = %d;", i); + rc = sqlcipher_check_connection(db_filename, pass, pass_sz, pragma_compat, &user_version, &journal_mode); + if(rc == SQLITE_OK) { + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "Version %d format found", i); + goto migrate; + } + if(pragma_compat) sqlcipher_free(pragma_compat, sqlite3Strlen30(pragma_compat)); + pragma_compat = NULL; + } + + /* if we exit the loop normally we failed to determine the version, this is an error */ + sqlcipher_log(SQLCIPHER_LOG_ERROR, "Upgrade format not determined"); + goto handle_error; + +migrate: + + temp = sqlite3_mprintf("%s-migrated", db_filename); + /* overallocate migrated_db_filename, because sqlite3OsOpen will read past the null terminator + * to determine whether the filename was URI formatted */ + migrated_db_filename = sqlcipher_malloc(sqlite3Strlen30(temp)+2); + memcpy(migrated_db_filename, temp, sqlite3Strlen30(temp)); + sqlcipher_free(temp, sqlite3Strlen30(temp)); + + attach_command = sqlite3_mprintf("ATTACH DATABASE '%s' as migrate;", migrated_db_filename, pass); + set_user_version = sqlite3_mprintf("PRAGMA migrate.user_version = %d;", user_version); + + rc = sqlite3_exec(db, pragma_compat, NULL, NULL, NULL); + if(rc != SQLITE_OK){ + sqlcipher_log(SQLCIPHER_LOG_ERROR, "set compatibility mode failed, error code %d", rc); + goto handle_error; + } + + /* force journal mode to DELETE, we will set it back later if different */ + rc = sqlite3_exec(db, "PRAGMA journal_mode = delete;", NULL, NULL, NULL); + if(rc != SQLITE_OK){ + sqlcipher_log(SQLCIPHER_LOG_ERROR, "force journal mode DELETE failed, error code %d", rc); + goto handle_error; + } + + rc = sqlite3_exec(db, attach_command, NULL, NULL, NULL); + if(rc != SQLITE_OK){ + sqlcipher_log(SQLCIPHER_LOG_ERROR, "attach failed, error code %d", rc); + goto handle_error; + } + + rc = sqlite3_key_v2(db, "migrate", pass, pass_sz); + if(rc != SQLITE_OK){ + sqlcipher_log(SQLCIPHER_LOG_ERROR, "keying attached database failed, error code %d", rc); + goto handle_error; + } + + rc = sqlite3_exec(db, "SELECT sqlcipher_export('migrate');", NULL, NULL, NULL); + if(rc != SQLITE_OK){ + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_export failed, error code %d", rc); + goto handle_error; + } + +#ifdef SQLCIPHER_TEST + if((sqlcipher_get_test_flags() & TEST_FAIL_MIGRATE) > 0) { + rc = SQLITE_ERROR; + sqlcipher_log(SQLCIPHER_LOG_ERROR, "simulated migrate failure, error code %d", rc); + goto handle_error; + } +#endif + + rc = sqlite3_exec(db, set_user_version, NULL, NULL, NULL); + if(rc != SQLITE_OK){ + sqlcipher_log(SQLCIPHER_LOG_ERROR, "set user version failed, error code %d", rc); + goto handle_error; + } + + if( !db->autoCommit ){ + sqlcipher_log(SQLCIPHER_LOG_ERROR, "cannot migrate from within a transaction"); + goto handle_error; + } + if( db->nVdbeActive>1 ){ + sqlcipher_log(SQLCIPHER_LOG_ERROR, "cannot migrate - SQL statements in progress"); + goto handle_error; + } + + pDest = db->aDb[0].pBt; + pDb = &(db->aDb[db->nDb-1]); + pSrc = pDb->pBt; + + nRes = sqlite3BtreeGetRequestedReserve(pSrc); + /* unset the BTS_PAGESIZE_FIXED flag to avoid SQLITE_READONLY */ + pDest->pBt->btsFlags &= ~BTS_PAGESIZE_FIXED; + rc = sqlite3BtreeSetPageSize(pDest, default_page_size, nRes, 0); + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "set btree page size to %d res %d rc %d", default_page_size, nRes, rc); + if( rc!=SQLITE_OK ) goto handle_error; + + sqlcipherCodecGetKey(db, db->nDb - 1, (void**)&keyspec, &keyspec_sz); + SQLCIPHER_FLAG_UNSET(ctx->flags, CIPHER_FLAG_KEY_USED); + sqlcipherCodecAttach(db, 0, keyspec, keyspec_sz); + + srcfile = sqlite3PagerFile(pSrc->pBt->pPager); + destfile = sqlite3PagerFile(pDest->pBt->pPager); + + sqlite3OsClose(srcfile); + sqlite3OsClose(destfile); + +#if defined(_WIN32) || defined(SQLITE_OS_WINRT) + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "performing windows MoveFileExA"); + + w_db_filename_sz = MultiByteToWideChar(CP_UTF8, 0, (LPCCH) db_filename, -1, NULL, 0); + w_db_filename = sqlcipher_malloc(w_db_filename_sz * sizeof(wchar_t)); + w_db_filename_sz = MultiByteToWideChar(CP_UTF8, 0, (LPCCH) db_filename, -1, (const LPWSTR) w_db_filename, w_db_filename_sz); + + w_migrated_db_filename_sz = MultiByteToWideChar(CP_UTF8, 0, (LPCCH) migrated_db_filename, -1, NULL, 0); + w_migrated_db_filename = sqlcipher_malloc(w_migrated_db_filename_sz * sizeof(wchar_t)); + w_migrated_db_filename_sz = MultiByteToWideChar(CP_UTF8, 0, (LPCCH) migrated_db_filename, -1, (const LPWSTR) w_migrated_db_filename, w_migrated_db_filename_sz); + + if(!MoveFileExW(w_migrated_db_filename, w_db_filename, MOVEFILE_REPLACE_EXISTING)) { + rc = SQLITE_ERROR; + sqlcipher_log(SQLCIPHER_LOG_ERROR, "error occurred while renaming %d", rc); + goto handle_error; + } +#else + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "performing POSIX rename"); + if ((rc = rename(migrated_db_filename, db_filename)) != 0) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "error occurred while renaming %d", rc); + goto handle_error; + } +#endif + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "renamed migration database %s to main database %s: %d", migrated_db_filename, db_filename, rc); + + rc = sqlite3OsOpen(db->pVfs, migrated_db_filename, srcfile, SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_MAIN_DB, &oflags); + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "reopened migration database: %d", rc); + if( rc!=SQLITE_OK ) goto handle_error; + + rc = sqlite3OsOpen(db->pVfs, db_filename, destfile, SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_MAIN_DB, &oflags); + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "reopened main database: %d", rc); + if( rc!=SQLITE_OK ) goto handle_error; + + sqlite3pager_reset(pDest->pBt->pPager); + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "reset pager"); + + rc = sqlite3_exec(db, "DETACH DATABASE migrate;", NULL, NULL, NULL); + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "DETACH DATABASE called %d", rc); + if(rc != SQLITE_OK) goto cleanup; + + sqlite3ResetAllSchemasOfConnection(db); + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "reset all schemas"); + + set_journal_mode = sqlite3_mprintf("PRAGMA journal_mode = %s;", journal_mode); + rc = sqlite3_exec(db, set_journal_mode, NULL, NULL, NULL); + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "%s: %d", set_journal_mode, rc); + if( rc!=SQLITE_OK ) goto handle_error; + + goto cleanup; + +handle_error: + sqlcipher_log(SQLCIPHER_LOG_ERROR, "An error occurred attempting to migrate the database - last error %d", rc); + +cleanup: + if(migrated_db_filename) { + int del_rc = sqlite3OsDelete(db->pVfs, migrated_db_filename, 0); + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "deleted migration database: %d", del_rc); + } + + if(pass) sqlcipher_free(pass, pass_sz); + if(attach_command) sqlcipher_free(attach_command, sqlite3Strlen30(attach_command)); + if(migrated_db_filename) sqlcipher_free(migrated_db_filename, sqlite3Strlen30(migrated_db_filename)); + if(set_user_version) sqlcipher_free(set_user_version, sqlite3Strlen30(set_user_version)); + if(set_journal_mode) sqlcipher_free(set_journal_mode, sqlite3Strlen30(set_journal_mode)); + if(journal_mode) sqlcipher_free(journal_mode, sqlite3Strlen30(journal_mode)); + if(pragma_compat) sqlcipher_free(pragma_compat, sqlite3Strlen30(pragma_compat)); +#if defined(_WIN32) || defined(SQLITE_OS_WINRT) + if(w_db_filename) sqlcipher_free(w_db_filename, w_db_filename_sz); + if(w_migrated_db_filename) sqlcipher_free(w_migrated_db_filename, w_migrated_db_filename_sz); +#endif + return rc; +} + +int sqlcipher_codec_add_random(codec_ctx *ctx, const char *zRight, int random_sz){ + const char *suffix = &zRight[random_sz-1]; + int n = random_sz - 3; /* adjust for leading x' and tailing ' */ + if (n > 0 && + sqlite3StrNICmp((const char *)zRight ,"x'", 2) == 0 && + sqlite3StrNICmp(suffix, "'", 1) == 0 && + n % 2 == 0) { + int rc = 0; + int buffer_sz = n / 2; + unsigned char *random; + const unsigned char *z = (const unsigned char *)zRight + 2; /* adjust lead offset of x' */ + sqlcipher_log(SQLCIPHER_LOG_DEBUG, "sqlcipher_codec_add_random: using raw random blob from hex"); + random = sqlcipher_malloc(buffer_sz); + memset(random, 0, buffer_sz); + cipher_hex2bin(z, n, random); + rc = ctx->provider->add_random(ctx->provider_ctx, random, buffer_sz); + sqlcipher_free(random, buffer_sz); + return rc; + } + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_codec_add_random: attemt to add random with invalid format"); + return SQLITE_ERROR; +} + +#if !defined(SQLITE_OMIT_TRACE) +static int sqlcipher_profile_callback(unsigned int trace, void *file, void *stmt, void *run_time){ + FILE *f = (FILE*) file; + char *fmt = "Elapsed time:%.3f ms - %s\n"; + double elapsed = (*((sqlite3_uint64*)run_time))/1000000.0; +#ifdef __ANDROID__ + if(f == NULL) { + __android_log_print(ANDROID_LOG_DEBUG, "sqlcipher", fmt, elapsed, sqlite3_sql((sqlite3_stmt*)stmt)); + } +#endif + if(f) fprintf(f, fmt, elapsed, sqlite3_sql((sqlite3_stmt*)stmt)); + return SQLITE_OK; +} +#endif + +int sqlcipher_cipher_profile(sqlite3 *db, const char *destination){ +#if defined(SQLITE_OMIT_TRACE) + return SQLITE_ERROR; +#else + FILE *f = NULL; + if(sqlite3_stricmp(destination, "off") == 0){ + sqlite3_trace_v2(db, 0, NULL, NULL); /* disable tracing */ + } else { + if(sqlite3_stricmp(destination, "stdout") == 0){ + f = stdout; + }else if(sqlite3_stricmp(destination, "stderr") == 0){ + f = stderr; + }else if(sqlite3_stricmp(destination, "logcat") == 0){ + f = NULL; /* file pointer will be NULL indicating logcat on android */ + }else{ +#if !defined(SQLCIPHER_PROFILE_USE_FOPEN) && (defined(_WIN32) && (__STDC_VERSION__ > 199901L) || defined(SQLITE_OS_WINRT)) + if(fopen_s(&f, destination, "a") != 0) return SQLITE_ERROR; +#else + if((f = fopen(destination, "a")) == 0) return SQLITE_ERROR; +#endif + } + sqlite3_trace_v2(db, SQLITE_TRACE_PROFILE, sqlcipher_profile_callback, f); + } + return SQLITE_OK; +#endif +} + +int sqlcipher_codec_fips_status(codec_ctx *ctx) { + return ctx->provider->fips_status(ctx->provider_ctx); +} + +const char* sqlcipher_codec_get_provider_version(codec_ctx *ctx) { + return ctx->provider->get_provider_version(ctx->provider_ctx); +} + +#ifndef SQLCIPHER_OMIT_LOG +/* constants from https://github.com/Alexpux/mingw-w64/blob/master/mingw-w64-crt/misc/gettimeofday.c */ +#define FILETIME_1970 116444736000000000ull /* seconds between 1/1/1601 and 1/1/1970 */ +#define HECTONANOSEC_PER_SEC 10000000ull +void sqlcipher_log(unsigned int level, const char *message, ...) { + va_list params; + va_start(params, message); + +#ifdef CODEC_DEBUG +#ifdef __ANDROID__ + __android_log_vprint(ANDROID_LOG_DEBUG, "sqlcipher", message, params); +#else + vfprintf(stderr, message, params); + fprintf(stderr, "\n"); +#endif +#endif + + if(level > sqlcipher_log_level || (sqlcipher_log_logcat == 0 && sqlcipher_log_file == NULL)) { + /* no log target or tag not in included filters */ + goto end; + } + if(sqlcipher_log_file != NULL){ + char buffer[24]; + struct tm tt; + int ms; + time_t sec; +#ifdef _WIN32 + SYSTEMTIME st; + FILETIME ft; + GetSystemTime(&st); + SystemTimeToFileTime(&st, &ft); + sec = (time_t) ((*((sqlite_int64*)&ft) - FILETIME_1970) / HECTONANOSEC_PER_SEC); + ms = st.wMilliseconds; + localtime_s(&tt, &sec); +#else + struct timeval tv; + gettimeofday(&tv, NULL); + sec = tv.tv_sec; + ms = tv.tv_usec/1000.0; + localtime_r(&sec, &tt); +#endif + if(strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &tt)) { + fprintf((FILE*)sqlcipher_log_file, "%s.%03d: ", buffer, ms); + vfprintf((FILE*)sqlcipher_log_file, message, params); + fprintf((FILE*)sqlcipher_log_file, "\n"); + } + } +#ifdef __ANDROID__ + if(sqlcipher_log_logcat) { + __android_log_vprint(ANDROID_LOG_DEBUG, "sqlcipher", message, params); + } +#endif +end: + va_end(params); +} +#endif + +void sqlcipher_set_log_level(unsigned int level) { + sqlcipher_log_level = level; +} + +int sqlcipher_set_log(const char *destination){ +#ifdef SQLCIPHER_OMIT_LOG + return SQLITE_ERROR; +#else + /* close open trace file if it is not stdout or stderr, then + reset trace settings */ + if(sqlcipher_log_file != NULL && sqlcipher_log_file != stdout && sqlcipher_log_file != stderr) { + fclose((FILE*)sqlcipher_log_file); + } + sqlcipher_log_file = NULL; + sqlcipher_log_logcat = 0; + + if(sqlite3_stricmp(destination, "logcat") == 0){ + sqlcipher_log_logcat = 1; + } else if(sqlite3_stricmp(destination, "stdout") == 0){ + sqlcipher_log_file = stdout; + }else if(sqlite3_stricmp(destination, "stderr") == 0){ + sqlcipher_log_file = stderr; + }else if(sqlite3_stricmp(destination, "off") != 0){ +#if !defined(SQLCIPHER_PROFILE_USE_FOPEN) && (defined(_WIN32) && (__STDC_VERSION__ > 199901L) || defined(SQLITE_OS_WINRT)) + if(fopen_s(&sqlcipher_log_file, destination, "a") != 0) return SQLITE_ERROR; +#else + if((sqlcipher_log_file = fopen(destination, "a")) == 0) return SQLITE_ERROR; +#endif + } + sqlcipher_log(SQLCIPHER_LOG_INFO, "sqlcipher_set_log: set log to %s", destination); + return SQLITE_OK; +#endif +} + +#endif +/* END SQLCIPHER */ + +/************** End of crypto_impl.c *****************************************/ +/************** Begin file crypto_libtomcrypt.c ******************************/ +/* +** SQLCipher +** http://sqlcipher.net +** +** Copyright (c) 2008 - 2013, ZETETIC LLC +** All rights reserved. +** +** Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in the +** documentation and/or other materials provided with the distribution. +** * Neither the name of the ZETETIC LLC nor the +** names of its contributors may be used to endorse or promote products +** derived from this software without specific prior written permission. +** +** THIS SOFTWARE IS PROVIDED BY ZETETIC LLC ''AS IS'' AND ANY +** EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +** DISCLAIMED. IN NO EVENT SHALL ZETETIC LLC BE LIABLE FOR ANY +** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +** +*/ +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC +#ifdef SQLCIPHER_CRYPTO_LIBTOMCRYPT +/* #include "sqliteInt.h" */ +/* #include "sqlcipher.h" */ +#include + +#define FORTUNA_MAX_SZ 32 +static prng_state prng; +static volatile unsigned int ltc_init = 0; +static volatile unsigned int ltc_ref_count = 0; + +#define LTC_CIPHER "rijndael" + +static int sqlcipher_ltc_add_random(void *ctx, void *buffer, int length) { + int rc = 0; + int data_to_read = length; + int block_sz = data_to_read < FORTUNA_MAX_SZ ? data_to_read : FORTUNA_MAX_SZ; + const unsigned char * data = (const unsigned char *)buffer; + + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_ltc_add_random: entering SQLCIPHER_MUTEX_PROVIDER_RAND"); + sqlite3_mutex_enter(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_RAND)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_ltc_add_random: entered SQLCIPHER_MUTEX_PROVIDER_RAND"); + + while(data_to_read > 0){ + rc = fortuna_add_entropy(data, block_sz, &prng); + rc = rc != CRYPT_OK ? SQLITE_ERROR : SQLITE_OK; + if(rc != SQLITE_OK){ + break; + } + data_to_read -= block_sz; + data += block_sz; + block_sz = data_to_read < FORTUNA_MAX_SZ ? data_to_read : FORTUNA_MAX_SZ; + } + fortuna_ready(&prng); + + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_ltc_add_random: leaving SQLCIPHER_MUTEX_PROVIDER_RAND"); + sqlite3_mutex_leave(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_RAND)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_ltc_add_random: left SQLCIPHER_MUTEX_PROVIDER_RAND"); + + return rc; +} + +static int sqlcipher_ltc_activate(void *ctx) { + unsigned char random_buffer[FORTUNA_MAX_SZ]; + + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_ltc_activate: entering SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + sqlite3_mutex_enter(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_ACTIVATE)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_ltc_activate: entered SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + + sqlcipher_memset(random_buffer, 0, FORTUNA_MAX_SZ); + if(ltc_init == 0) { + if(register_prng(&fortuna_desc) < 0) return SQLITE_ERROR; + if(register_cipher(&rijndael_desc) < 0) return SQLITE_ERROR; + if(register_hash(&sha512_desc) < 0) return SQLITE_ERROR; + if(register_hash(&sha256_desc) < 0) return SQLITE_ERROR; + if(register_hash(&sha1_desc) < 0) return SQLITE_ERROR; + if(fortuna_start(&prng) != CRYPT_OK) { + return SQLITE_ERROR; + } + + ltc_init = 1; + } + ltc_ref_count++; + +#ifndef SQLCIPHER_TEST + sqlite3_randomness(FORTUNA_MAX_SZ, random_buffer); +#endif + + if(sqlcipher_ltc_add_random(ctx, random_buffer, FORTUNA_MAX_SZ) != SQLITE_OK) { + return SQLITE_ERROR; + } + sqlcipher_memset(random_buffer, 0, FORTUNA_MAX_SZ); + + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_ltc_activate: leaving SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + sqlite3_mutex_leave(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_ACTIVATE)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_ltc_activate: left SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + + return SQLITE_OK; +} + +static int sqlcipher_ltc_deactivate(void *ctx) { + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_ltc_deactivate: entering SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + sqlite3_mutex_enter(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_ACTIVATE)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_ltc_deactivate: entered SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + + ltc_ref_count--; + if(ltc_ref_count == 0){ + fortuna_done(&prng); + sqlcipher_memset((void *)&prng, 0, sizeof(prng)); + } + + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_ltc_deactivate: leaving SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + sqlite3_mutex_leave(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_ACTIVATE)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_ltc_deactivate: left SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + + return SQLITE_OK; +} + +static const char* sqlcipher_ltc_get_provider_name(void *ctx) { + return "libtomcrypt"; +} + +static const char* sqlcipher_ltc_get_provider_version(void *ctx) { + return SCRYPT; +} + +static int sqlcipher_ltc_random(void *ctx, void *buffer, int length) { + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_ltc_random: entering SQLCIPHER_MUTEX_PROVIDER_RAND"); + sqlite3_mutex_enter(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_RAND)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_ltc_random: entered SQLCIPHER_MUTEX_PROVIDER_RAND"); + + fortuna_read(buffer, length, &prng); + + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_ltc_random: leaving SQLCIPHER_MUTEX_PROVIDER_RAND"); + sqlite3_mutex_leave(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_RAND)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_ltc_random: left SQLCIPHER_MUTEX_PROVIDER_RAND"); + + return SQLITE_OK; +} + +static int sqlcipher_ltc_hmac(void *ctx, int algorithm, unsigned char *hmac_key, int key_sz, unsigned char *in, int in_sz, unsigned char *in2, int in2_sz, unsigned char *out) { + int rc, hash_idx; + hmac_state hmac; + unsigned long outlen; + switch(algorithm) { + case SQLCIPHER_HMAC_SHA1: + hash_idx = find_hash("sha1"); + break; + case SQLCIPHER_HMAC_SHA256: + hash_idx = find_hash("sha256"); + break; + case SQLCIPHER_HMAC_SHA512: + hash_idx = find_hash("sha512"); + break; + default: + return SQLITE_ERROR; + } + + if(hash_idx < 0) return SQLITE_ERROR; + outlen = hash_descriptor[hash_idx].hashsize; + + if(in == NULL) return SQLITE_ERROR; + if((rc = hmac_init(&hmac, hash_idx, hmac_key, key_sz)) != CRYPT_OK) return SQLITE_ERROR; + if((rc = hmac_process(&hmac, in, in_sz)) != CRYPT_OK) return SQLITE_ERROR; + if(in2 != NULL && (rc = hmac_process(&hmac, in2, in2_sz)) != CRYPT_OK) return SQLITE_ERROR; + if((rc = hmac_done(&hmac, out, &outlen)) != CRYPT_OK) return SQLITE_ERROR; + return SQLITE_OK; +} + +static int sqlcipher_ltc_kdf(void *ctx, int algorithm, const unsigned char *pass, int pass_sz, unsigned char* salt, int salt_sz, int workfactor, int key_sz, unsigned char *key) { + int rc, hash_idx; + unsigned long outlen = key_sz; + + switch(algorithm) { + case SQLCIPHER_HMAC_SHA1: + hash_idx = find_hash("sha1"); + break; + case SQLCIPHER_HMAC_SHA256: + hash_idx = find_hash("sha256"); + break; + case SQLCIPHER_HMAC_SHA512: + hash_idx = find_hash("sha512"); + break; + default: + return SQLITE_ERROR; + } + if(hash_idx < 0) return SQLITE_ERROR; + + if((rc = pkcs_5_alg2(pass, pass_sz, salt, salt_sz, + workfactor, hash_idx, key, &outlen)) != CRYPT_OK) { + return SQLITE_ERROR; + } + return SQLITE_OK; +} + +static const char* sqlcipher_ltc_get_cipher(void *ctx) { + return "aes-256-cbc"; +} + +static int sqlcipher_ltc_cipher(void *ctx, int mode, unsigned char *key, int key_sz, unsigned char *iv, unsigned char *in, int in_sz, unsigned char *out) { + int rc, cipher_idx; + symmetric_CBC cbc; + + if((cipher_idx = find_cipher(LTC_CIPHER)) == -1) return SQLITE_ERROR; + if((rc = cbc_start(cipher_idx, iv, key, key_sz, 0, &cbc)) != CRYPT_OK) return SQLITE_ERROR; + rc = mode == 1 ? cbc_encrypt(in, out, in_sz, &cbc) : cbc_decrypt(in, out, in_sz, &cbc); + if(rc != CRYPT_OK) return SQLITE_ERROR; + cbc_done(&cbc); + return SQLITE_OK; +} + +static int sqlcipher_ltc_get_key_sz(void *ctx) { + int cipher_idx = find_cipher(LTC_CIPHER); + return cipher_descriptor[cipher_idx].max_key_length; +} + +static int sqlcipher_ltc_get_iv_sz(void *ctx) { + int cipher_idx = find_cipher(LTC_CIPHER); + return cipher_descriptor[cipher_idx].block_length; +} + +static int sqlcipher_ltc_get_block_sz(void *ctx) { + int cipher_idx = find_cipher(LTC_CIPHER); + return cipher_descriptor[cipher_idx].block_length; +} + +static int sqlcipher_ltc_get_hmac_sz(void *ctx, int algorithm) { + int hash_idx; + switch(algorithm) { + case SQLCIPHER_HMAC_SHA1: + hash_idx = find_hash("sha1"); + break; + case SQLCIPHER_HMAC_SHA256: + hash_idx = find_hash("sha256"); + break; + case SQLCIPHER_HMAC_SHA512: + hash_idx = find_hash("sha512"); + break; + default: + return 0; + } + + if(hash_idx < 0) return 0; + + return hash_descriptor[hash_idx].hashsize; +} + +static int sqlcipher_ltc_ctx_init(void **ctx) { + sqlcipher_ltc_activate(NULL); + return SQLITE_OK; +} + +static int sqlcipher_ltc_ctx_free(void **ctx) { + sqlcipher_ltc_deactivate(&ctx); + return SQLITE_OK; +} + +static int sqlcipher_ltc_fips_status(void *ctx) { + return 0; +} + +int sqlcipher_ltc_setup(sqlcipher_provider *p) { + p->activate = sqlcipher_ltc_activate; + p->deactivate = sqlcipher_ltc_deactivate; + p->get_provider_name = sqlcipher_ltc_get_provider_name; + p->random = sqlcipher_ltc_random; + p->hmac = sqlcipher_ltc_hmac; + p->kdf = sqlcipher_ltc_kdf; + p->cipher = sqlcipher_ltc_cipher; + p->get_cipher = sqlcipher_ltc_get_cipher; + p->get_key_sz = sqlcipher_ltc_get_key_sz; + p->get_iv_sz = sqlcipher_ltc_get_iv_sz; + p->get_block_sz = sqlcipher_ltc_get_block_sz; + p->get_hmac_sz = sqlcipher_ltc_get_hmac_sz; + p->ctx_init = sqlcipher_ltc_ctx_init; + p->ctx_free = sqlcipher_ltc_ctx_free; + p->add_random = sqlcipher_ltc_add_random; + p->fips_status = sqlcipher_ltc_fips_status; + p->get_provider_version = sqlcipher_ltc_get_provider_version; + return SQLITE_OK; +} + +#endif +#endif +/* END SQLCIPHER */ + +/************** End of crypto_libtomcrypt.c **********************************/ +/************** Begin file crypto_nss.c **************************************/ +/* +** SQLCipher +** http://sqlcipher.net +** +** Copyright (c) 2008 - 2013, ZETETIC LLC +** All rights reserved. +** +** Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in the +** documentation and/or other materials provided with the distribution. +** * Neither the name of the ZETETIC LLC nor the +** names of its contributors may be used to endorse or promote products +** derived from this software without specific prior written permission. +** +** THIS SOFTWARE IS PROVIDED BY ZETETIC LLC ''AS IS'' AND ANY +** EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +** DISCLAIMED. IN NO EVENT SHALL ZETETIC LLC BE LIABLE FOR ANY +** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +** +*/ +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC +#ifdef SQLCIPHER_CRYPTO_NSS +/* #include "crypto.h" */ +/* #include "sqlcipher.h" */ +#include +#include +#include + +static NSSInitContext* nss_init_context = NULL; +static unsigned int nss_init_count = 0; + +int sqlcipher_nss_setup(sqlcipher_provider *p); + +static int sqlcipher_nss_activate(void *ctx) { + + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_nss_activate: entering SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + sqlite3_mutex_enter(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_ACTIVATE)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_nss_activate: entered SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + if (nss_init_context == NULL) { + nss_init_context = NSS_InitContext("", "", "", "", NULL, + NSS_INIT_READONLY | NSS_INIT_NOCERTDB | NSS_INIT_NOMODDB | + NSS_INIT_FORCEOPEN | NSS_INIT_OPTIMIZESPACE | NSS_INIT_NOROOTINIT); + } + nss_init_count++; + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_nss_activate: leaving SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + sqlite3_mutex_leave(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_ACTIVATE)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_nss_activate: left SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + return SQLITE_OK; +} + +static int sqlcipher_nss_deactivate(void *ctx) { + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_nss_activate: entering SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + sqlite3_mutex_enter(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_ACTIVATE)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_nss_activate: entered SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + + nss_init_count--; + if (nss_init_count == 0 && nss_init_context != NULL) { + NSS_ShutdownContext(nss_init_context); + nss_init_context = NULL; + } + + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_nss_activate: leaving SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + sqlite3_mutex_leave(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_ACTIVATE)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_nss_activate: left SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + return SQLITE_OK; +} + +static int sqlcipher_nss_add_random(void *ctx, void *buffer, int length) { + return SQLITE_OK; +} + +/* generate a defined number of random bytes */ +static int sqlcipher_nss_random (void *ctx, void *buffer, int length) { + // PK11_GenerateRandom should be thread-safe. + return (PK11_GenerateRandom((unsigned char *)buffer, length) == SECSuccess) ? SQLITE_OK : SQLITE_ERROR; +} + +static const char* sqlcipher_nss_get_provider_name(void *ctx) { + return "nss"; +} + +static const char* sqlcipher_nss_get_provider_version(void *ctx) { + return NSS_GetVersion(); +} + +static const char* sqlcipher_nss_get_cipher(void *ctx) { + return "aes-256-cbc"; +} + +static int sqlcipher_nss_get_key_sz(void *ctx) { + return AES_256_KEY_LENGTH; +} + +static int sqlcipher_nss_get_iv_sz(void *ctx) { + return AES_BLOCK_SIZE; +} + +static int sqlcipher_nss_get_block_sz(void *ctx) { + return AES_BLOCK_SIZE; +} + +static int sqlcipher_nss_get_hmac_sz(void *ctx, int algorithm) { + switch(algorithm) { + case SQLCIPHER_HMAC_SHA1: + return SHA1_LENGTH; + break; + case SQLCIPHER_HMAC_SHA256: + return SHA256_LENGTH; + break; + case SQLCIPHER_HMAC_SHA512: + return SHA512_LENGTH; + break; + default: + return 0; + } +} + +static int sqlcipher_nss_hmac(void *ctx, int algorithm, unsigned char *hmac_key, int key_sz, unsigned char *in, int in_sz, unsigned char *in2, int in2_sz, unsigned char *out) { + int rc = SQLITE_OK; + unsigned int length; + unsigned int outLen; + PK11Context* context = NULL; + PK11SlotInfo * slot = NULL; + PK11SymKey* symKey = NULL; + if(in == NULL) goto error; + CK_MECHANISM_TYPE mech; + switch(algorithm) { + case SQLCIPHER_HMAC_SHA1: + mech = CKM_SHA_1_HMAC; + break; + case SQLCIPHER_HMAC_SHA256: + mech = CKM_SHA256_HMAC; + break; + case SQLCIPHER_HMAC_SHA512: + mech = CKM_SHA512_HMAC; + break; + default: + goto error; + } + length = sqlcipher_nss_get_hmac_sz(ctx, algorithm); + slot = PK11_GetInternalSlot(); + if (slot == NULL) goto error; + SECItem keyItem; + keyItem.data = hmac_key; + keyItem.len = key_sz; + symKey = PK11_ImportSymKey(slot, mech, PK11_OriginUnwrap, + CKA_SIGN, &keyItem, NULL); + if (symKey == NULL) goto error; + SECItem noParams; + noParams.data = 0; + noParams.len = 0; + context = PK11_CreateContextBySymKey(mech, CKA_SIGN, symKey, &noParams); + if (context == NULL) goto error; + if (PK11_DigestBegin(context) != SECSuccess) goto error; + if (PK11_DigestOp(context, in, in_sz) != SECSuccess) goto error; + if (in2 != NULL) { + if (PK11_DigestOp(context, in2, in2_sz) != SECSuccess) goto error; + } + if (PK11_DigestFinal(context, out, &outLen, length) != SECSuccess) goto error; + + goto cleanup; + error: + rc = SQLITE_ERROR; + cleanup: + if (context) PK11_DestroyContext(context, PR_TRUE); + if (symKey) PK11_FreeSymKey(symKey); + if (slot) PK11_FreeSlot(slot); + return rc; +} + +static int sqlcipher_nss_kdf(void *ctx, int algorithm, const unsigned char *pass, int pass_sz, unsigned char* salt, int salt_sz, int workfactor, int key_sz, unsigned char *key) { + int rc = SQLITE_OK; + PK11SlotInfo * slot = NULL; + SECAlgorithmID * algid = NULL; + PK11SymKey* symKey = NULL; + SECOidTag oidtag; + switch(algorithm) { + case SQLCIPHER_HMAC_SHA1: + oidtag = SEC_OID_HMAC_SHA1; + break; + case SQLCIPHER_HMAC_SHA256: + oidtag = SEC_OID_HMAC_SHA256; + break; + case SQLCIPHER_HMAC_SHA512: + oidtag = SEC_OID_HMAC_SHA512; + break; + default: + goto error; + } + SECItem secSalt; + secSalt.data = salt; + secSalt.len = salt_sz; + // Always pass SEC_OID_HMAC_SHA1 (i.e. PBMAC1) as this parameter + // is unused for key generation. It is currently only used + // for PBKDF2 authentication or key (un)wrapping when specifying an + // encryption algorithm (PBES2). + algid = PK11_CreatePBEV2AlgorithmID(SEC_OID_PKCS5_PBKDF2, SEC_OID_HMAC_SHA1, + oidtag, key_sz, workfactor, &secSalt); + if (algid == NULL) goto error; + slot = PK11_GetInternalSlot(); + if (slot == NULL) goto error; + SECItem pwItem; + pwItem.data = (unsigned char *) pass; // PK11_PBEKeyGen doesn't modify the key. + pwItem.len = pass_sz; + symKey = PK11_PBEKeyGen(slot, algid, &pwItem, PR_FALSE, NULL); + if (symKey == NULL) goto error; + if (PK11_ExtractKeyValue(symKey) != SECSuccess) goto error; + // No need to free keyData as it is a buffer managed by symKey. + SECItem* keyData = PK11_GetKeyData(symKey); + if (keyData == NULL) goto error; + memcpy(key, keyData->data, key_sz); + + goto cleanup; + error: + rc = SQLITE_ERROR; + cleanup: + if (slot) PK11_FreeSlot(slot); + if (algid) SECOID_DestroyAlgorithmID(algid, PR_TRUE); + if (symKey) PK11_FreeSymKey(symKey); + return rc; +} + +static int sqlcipher_nss_cipher(void *ctx, int mode, unsigned char *key, int key_sz, unsigned char *iv, unsigned char *in, int in_sz, unsigned char *out) { + int rc = SQLITE_OK; + PK11SlotInfo * slot = NULL; + PK11SymKey* symKey = NULL; + unsigned int outLen; + SECItem params; + params.data = iv; + params.len = sqlcipher_nss_get_iv_sz(ctx); + slot = PK11_GetInternalSlot(); + if (slot == NULL) goto error; + SECItem keyItem; + keyItem.data = key; + keyItem.len = key_sz; + symKey = PK11_ImportSymKey(slot, CKM_AES_CBC, PK11_OriginUnwrap, + CKA_ENCRYPT, &keyItem, NULL); + if (symKey == NULL) goto error; + SECStatus rv; + if (mode == CIPHER_ENCRYPT) { + rv = PK11_Encrypt(symKey, CKM_AES_CBC, ¶ms, out, &outLen, + in_sz + 16, in, in_sz); + } else { + rv = PK11_Decrypt(symKey, CKM_AES_CBC, ¶ms, out, &outLen, + in_sz + 16, in, in_sz); + } + if (rv != SECSuccess) goto error; + + goto cleanup; + error: + rc = SQLITE_ERROR; + cleanup: + if (slot) PK11_FreeSlot(slot); + if (symKey) PK11_FreeSymKey(symKey); + return rc; +} + +static int sqlcipher_nss_ctx_init(void **ctx) { + sqlcipher_nss_activate(NULL); + return SQLITE_OK; +} + +static int sqlcipher_nss_ctx_free(void **ctx) { + sqlcipher_nss_deactivate(NULL); + return SQLITE_OK; +} + +static int sqlcipher_nss_fips_status(void *ctx) { + return 0; +} + +int sqlcipher_nss_setup(sqlcipher_provider *p) { + p->activate = sqlcipher_nss_activate; + p->deactivate = sqlcipher_nss_deactivate; + p->random = sqlcipher_nss_random; + p->get_provider_name = sqlcipher_nss_get_provider_name; + p->hmac = sqlcipher_nss_hmac; + p->kdf = sqlcipher_nss_kdf; + p->cipher = sqlcipher_nss_cipher; + p->get_cipher = sqlcipher_nss_get_cipher; + p->get_key_sz = sqlcipher_nss_get_key_sz; + p->get_iv_sz = sqlcipher_nss_get_iv_sz; + p->get_block_sz = sqlcipher_nss_get_block_sz; + p->get_hmac_sz = sqlcipher_nss_get_hmac_sz; + p->ctx_init = sqlcipher_nss_ctx_init; + p->ctx_free = sqlcipher_nss_ctx_free; + p->add_random = sqlcipher_nss_add_random; + p->fips_status = sqlcipher_nss_fips_status; + p->get_provider_version = sqlcipher_nss_get_provider_version; + return SQLITE_OK; +} + +#endif +#endif +/* END SQLCIPHER */ + +/************** End of crypto_nss.c ******************************************/ +/************** Begin file crypto_openssl.c **********************************/ +/* +** SQLCipher +** http://sqlcipher.net +** +** Copyright (c) 2008 - 2013, ZETETIC LLC +** All rights reserved. +** +** Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in the +** documentation and/or other materials provided with the distribution. +** * Neither the name of the ZETETIC LLC nor the +** names of its contributors may be used to endorse or promote products +** derived from this software without specific prior written permission. +** +** THIS SOFTWARE IS PROVIDED BY ZETETIC LLC ''AS IS'' AND ANY +** EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +** DISCLAIMED. IN NO EVENT SHALL ZETETIC LLC BE LIABLE FOR ANY +** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +** +*/ +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC +#ifdef SQLCIPHER_CRYPTO_OPENSSL +/* #include "sqliteInt.h" */ +/* #include "crypto.h" */ +/* #include "sqlcipher.h" */ +#include +#include +#include +#include +#include +#include + +static unsigned int openssl_init_count = 0; + +static void sqlcipher_openssl_log_errors() { + unsigned long err = 0; + while((err = ERR_get_error()) != 0) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_log_errors: ERR_get_error() returned %lx: %s", err, ERR_error_string(err, NULL)); + } +} + +#if (defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER < 0x10100000L) || (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x20700000L) +static HMAC_CTX *HMAC_CTX_new(void) +{ + HMAC_CTX *ctx = OPENSSL_malloc(sizeof(*ctx)); + if (ctx != NULL) { + HMAC_CTX_init(ctx); + } + return ctx; +} + +/* Per 1.1.0 (https://wiki.openssl.org/index.php/1.1_API_Changes) + HMAC_CTX_free should call HMAC_CTX_cleanup, then EVP_MD_CTX_Cleanup. + HMAC_CTX_cleanup internally calls EVP_MD_CTX_cleanup so these + calls are not needed. */ +static void HMAC_CTX_free(HMAC_CTX *ctx) +{ + if (ctx != NULL) { + HMAC_CTX_cleanup(ctx); + OPENSSL_free(ctx); + } +} +#endif + +static int sqlcipher_openssl_add_random(void *ctx, void *buffer, int length) { +#ifndef SQLCIPHER_OPENSSL_NO_MUTEX_RAND + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_openssl_add_random: entering SQLCIPHER_MUTEX_PROVIDER_RAND"); + sqlite3_mutex_enter(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_RAND)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_openssl_add_random: entered SQLCIPHER_MUTEX_PROVIDER_RAND"); +#endif + RAND_add(buffer, length, 0); +#ifndef SQLCIPHER_OPENSSL_NO_MUTEX_RAND + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_openssl_add_random: leaving SQLCIPHER_MUTEX_PROVIDER_RAND"); + sqlite3_mutex_leave(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_RAND)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_openssl_add_random: left SQLCIPHER_MUTEX_PROVIDER_RAND"); +#endif + return SQLITE_OK; +} + +#define OPENSSL_CIPHER EVP_aes_256_cbc() + +/* activate and initialize sqlcipher. Most importantly, this will automatically + intialize OpenSSL's EVP system if it hasn't already be externally. Note that + this function may be called multiple times as new codecs are intiialized. + Thus it performs some basic counting to ensure that only the last and final + sqlcipher_openssl_deactivate() will free the EVP structures. +*/ +static int sqlcipher_openssl_activate(void *ctx) { + /* initialize openssl and increment the internal init counter + but only if it hasn't been initalized outside of SQLCipher by this program + e.g. on startup */ + int rc = 0; + + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_openssl_activate: entering SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + sqlite3_mutex_enter(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_ACTIVATE)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_openssl_activate: entered SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + +#if (defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER < 0x10100000L) + ERR_load_crypto_strings(); +#endif + +#ifdef SQLCIPHER_FIPS + if(!FIPS_mode()){ + if(!(rc = FIPS_mode_set(1))){ + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_activate: FIPS_mode_set() returned %d", rc); + sqlcipher_openssl_log_errors(); + } + } +#endif + + openssl_init_count++; + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_openssl_activate: leaving SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + sqlite3_mutex_leave(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_ACTIVATE)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_openssl_activate: left SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + return SQLITE_OK; +} + +/* deactivate SQLCipher, most imporantly decremeting the activation count and + freeing the EVP structures on the final deactivation to ensure that + OpenSSL memory is cleaned up */ +static int sqlcipher_openssl_deactivate(void *ctx) { + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_openssl_deactivate: entering SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + sqlite3_mutex_enter(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_ACTIVATE)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_openssl_deactivate: entered SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + + openssl_init_count--; + + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_openssl_deactivate: leaving SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + sqlite3_mutex_leave(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_ACTIVATE)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_openssl_deactivate: left SQLCIPHER_MUTEX_PROVIDER_ACTIVATE"); + return SQLITE_OK; +} + +static const char* sqlcipher_openssl_get_provider_name(void *ctx) { + return "openssl"; +} + +static const char* sqlcipher_openssl_get_provider_version(void *ctx) { +#if (defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER < 0x10100000L) + return OPENSSL_VERSION_TEXT; +#else + return OpenSSL_version(OPENSSL_VERSION); +#endif +} + +/* generate a defined number of random bytes */ +static int sqlcipher_openssl_random (void *ctx, void *buffer, int length) { + int rc = 0; + /* concurrent calls to RAND_bytes can cause a crash under some openssl versions when a + naive application doesn't use CRYPTO_set_locking_callback and + CRYPTO_THREADID_set_callback to ensure openssl thread safety. + This is simple workaround to prevent this common crash + but a more proper solution is that applications setup platform-appropriate + thread saftey in openssl externally */ +#ifndef SQLCIPHER_OPENSSL_NO_MUTEX_RAND + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_openssl_random: entering SQLCIPHER_MUTEX_PROVIDER_RAND"); + sqlite3_mutex_enter(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_RAND)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_openssl_random: entered SQLCIPHER_MUTEX_PROVIDER_RAND"); +#endif + rc = RAND_bytes((unsigned char *)buffer, length); +#ifndef SQLCIPHER_OPENSSL_NO_MUTEX_RAND + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_openssl_random: leaving SQLCIPHER_MUTEX_PROVIDER_RAND"); + sqlite3_mutex_leave(sqlcipher_mutex(SQLCIPHER_MUTEX_PROVIDER_RAND)); + sqlcipher_log(SQLCIPHER_LOG_TRACE, "sqlcipher_openssl_random: left SQLCIPHER_MUTEX_PROVIDER_RAND"); +#endif + if(!rc) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_random: RAND_bytes() returned %d", rc); + sqlcipher_openssl_log_errors(); + return SQLITE_ERROR; + } + return SQLITE_OK; +} + +static int sqlcipher_openssl_hmac(void *ctx, int algorithm, unsigned char *hmac_key, int key_sz, unsigned char *in, int in_sz, unsigned char *in2, int in2_sz, unsigned char *out) { + int rc = 0; + +#if (defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER < 0x30000000L) + unsigned int outlen; + HMAC_CTX* hctx = NULL; + + if(in == NULL) goto error; + + hctx = HMAC_CTX_new(); + if(hctx == NULL) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_hmac: HMAC_CTX_new() failed"); + sqlcipher_openssl_log_errors(); + goto error; + } + + switch(algorithm) { + case SQLCIPHER_HMAC_SHA1: + if(!(rc = HMAC_Init_ex(hctx, hmac_key, key_sz, EVP_sha1(), NULL))) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_hmac: HMAC_Init_ex() with key size %d and EVP_sha1() returned %d", key_sz, rc); + sqlcipher_openssl_log_errors(); + goto error; + } + break; + case SQLCIPHER_HMAC_SHA256: + if(!(rc = HMAC_Init_ex(hctx, hmac_key, key_sz, EVP_sha256(), NULL))) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_hmac: HMAC_Init_ex() with key size %d and EVP_sha256() returned %d", key_sz, rc); + sqlcipher_openssl_log_errors(); + goto error; + } + break; + case SQLCIPHER_HMAC_SHA512: + if(!(rc = HMAC_Init_ex(hctx, hmac_key, key_sz, EVP_sha512(), NULL))) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_hmac: HMAC_Init_ex() with key size %d and EVP_sha512() returned %d", key_sz, rc); + sqlcipher_openssl_log_errors(); + goto error; + } + break; + default: + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_hmac: invalid algorithm %d", algorithm); + goto error; + } + + if(!(rc = HMAC_Update(hctx, in, in_sz))) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_hmac: HMAC_Update() on 1st input buffer of %d bytes using algorithm %d returned %d", in_sz, algorithm, rc); + sqlcipher_openssl_log_errors(); + goto error; + } + + if(in2 != NULL) { + if(!(rc = HMAC_Update(hctx, in2, in2_sz))) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_hmac: HMAC_Update() on 2nd input buffer of %d bytes using algorithm %d returned %d", in2_sz, algorithm, rc); + sqlcipher_openssl_log_errors(); + goto error; + } + } + + if(!(rc = HMAC_Final(hctx, out, &outlen))) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_hmac: HMAC_Final() using algorithm %d returned %d", algorithm, rc); + sqlcipher_openssl_log_errors(); + goto error; + } + + rc = SQLITE_OK; + goto cleanup; + +error: + rc = SQLITE_ERROR; + +cleanup: + if(hctx) HMAC_CTX_free(hctx); + +#else + size_t outlen; + EVP_MAC *mac = NULL; + EVP_MAC_CTX *hctx = NULL; + OSSL_PARAM sha1[] = { { "digest", OSSL_PARAM_UTF8_STRING, "sha1", 4, 0 }, OSSL_PARAM_END }; + OSSL_PARAM sha256[] = { { "digest", OSSL_PARAM_UTF8_STRING, "sha256", 6, 0 }, OSSL_PARAM_END }; + OSSL_PARAM sha512[] = { { "digest", OSSL_PARAM_UTF8_STRING, "sha512", 6, 0 }, OSSL_PARAM_END }; + + if(in == NULL) goto error; + + mac = EVP_MAC_fetch(NULL, "HMAC", NULL); + if(mac == NULL) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_hmac: EVP_MAC_fetch for HMAC failed"); + sqlcipher_openssl_log_errors(); + goto error; + } + + hctx = EVP_MAC_CTX_new(mac); + if(hctx == NULL) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_hmac: EVP_MAC_CTX_new() failed"); + sqlcipher_openssl_log_errors(); + goto error; + } + + switch(algorithm) { + case SQLCIPHER_HMAC_SHA1: + if(!(rc = EVP_MAC_init(hctx, hmac_key, key_sz, sha1))) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_hmac: EVP_MAC_init() with key size %d and sha1 returned %d", key_sz, rc); + sqlcipher_openssl_log_errors(); + goto error; + } + break; + case SQLCIPHER_HMAC_SHA256: + if(!(rc = EVP_MAC_init(hctx, hmac_key, key_sz, sha256))) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_hmac: EVP_MAC_init() with key size %d and sha256 returned %d", key_sz, rc); + sqlcipher_openssl_log_errors(); + goto error; + } + break; + case SQLCIPHER_HMAC_SHA512: + if(!(rc = EVP_MAC_init(hctx, hmac_key, key_sz, sha512))) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_hmac: EVP_MAC_init() with key size %d and sha512 returned %d", key_sz, rc); + sqlcipher_openssl_log_errors(); + goto error; + } + break; + default: + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_hmac: invalid algorithm %d", algorithm); + goto error; + } + + if(!(rc = EVP_MAC_update(hctx, in, in_sz))) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_hmac: EVP_MAC_update() on 1st input buffer of %d bytes using algorithm %d returned %d", in_sz, algorithm, rc); + sqlcipher_openssl_log_errors(); + goto error; + } + + if(in2 != NULL) { + if(!(rc = EVP_MAC_update(hctx, in2, in2_sz))) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_hmac: EVP_MAC_update() on 2nd input buffer of %d bytes using algorithm %d returned %d", in_sz, algorithm, rc); + sqlcipher_openssl_log_errors(); + goto error; + } + } + + if(!(rc = EVP_MAC_final(hctx, NULL, &outlen, 0))) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_hmac: 1st EVP_MAC_final() for output length calculation using algorithm %d returned %d", algorithm, rc); + sqlcipher_openssl_log_errors(); + goto error; + } + + if(!(rc = EVP_MAC_final(hctx, out, &outlen, outlen))) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_hmac: 2nd EVP_MAC_final() using algorithm %d returned %d", algorithm, rc); + sqlcipher_openssl_log_errors(); + goto error; + } + + rc = SQLITE_OK; + goto cleanup; + +error: + rc = SQLITE_ERROR; + +cleanup: + if(hctx) EVP_MAC_CTX_free(hctx); + if(mac) EVP_MAC_free(mac); + +#endif + + return rc; +} + +static int sqlcipher_openssl_kdf(void *ctx, int algorithm, const unsigned char *pass, int pass_sz, unsigned char* salt, int salt_sz, int workfactor, int key_sz, unsigned char *key) { + int rc = 0; + + switch(algorithm) { + case SQLCIPHER_HMAC_SHA1: + if(!(rc = PKCS5_PBKDF2_HMAC((const char *)pass, pass_sz, salt, salt_sz, workfactor, EVP_sha1(), key_sz, key))) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_kdf: PKCS5_PBKDF2_HMAC() for EVP_sha1() workfactor %d and key size %d returned %d", workfactor, key_sz, rc); + sqlcipher_openssl_log_errors(); + goto error; + } + break; + case SQLCIPHER_HMAC_SHA256: + if(!(rc = PKCS5_PBKDF2_HMAC((const char *)pass, pass_sz, salt, salt_sz, workfactor, EVP_sha256(), key_sz, key))) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_kdf: PKCS5_PBKDF2_HMAC() for EVP_sha256() workfactor %d and key size %d returned %d", workfactor, key_sz, rc); + sqlcipher_openssl_log_errors(); + goto error; + } + break; + case SQLCIPHER_HMAC_SHA512: + if(!(rc = PKCS5_PBKDF2_HMAC((const char *)pass, pass_sz, salt, salt_sz, workfactor, EVP_sha512(), key_sz, key))) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_kdf: PKCS5_PBKDF2_HMAC() for EVP_sha512() workfactor %d and key size %d returned %d", workfactor, key_sz, rc); + sqlcipher_openssl_log_errors(); + goto error; + } + break; + default: + return SQLITE_ERROR; + } + + rc = SQLITE_OK; + goto cleanup; +error: + rc = SQLITE_ERROR; +cleanup: + return rc; +} + +static int sqlcipher_openssl_cipher(void *ctx, int mode, unsigned char *key, int key_sz, unsigned char *iv, unsigned char *in, int in_sz, unsigned char *out) { + int tmp_csz, csz, rc = 0; + EVP_CIPHER_CTX* ectx = EVP_CIPHER_CTX_new(); + if(ectx == NULL) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_cipher: EVP_CIPHER_CTX_new failed"); + sqlcipher_openssl_log_errors(); + goto error; + } + + if(!(rc = EVP_CipherInit_ex(ectx, OPENSSL_CIPHER, NULL, NULL, NULL, mode))) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_cipher: EVP_CipherInit_ex for mode %d returned %d", mode, rc); + sqlcipher_openssl_log_errors(); + goto error; + } + + if(!(rc = EVP_CIPHER_CTX_set_padding(ectx, 0))) { /* no padding */ + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_cipher: EVP_CIPHER_CTX_set_padding 0 returned %d", rc); + sqlcipher_openssl_log_errors(); + goto error; + } + + if(!(rc = EVP_CipherInit_ex(ectx, NULL, NULL, key, iv, mode))) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_cipher: EVP_CipherInit_ex for mode %d returned %d", mode, rc); + sqlcipher_openssl_log_errors(); + goto error; + } + + if(!(rc = EVP_CipherUpdate(ectx, out, &tmp_csz, in, in_sz))) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_cipher: EVP_CipherUpdate returned %d", rc); + sqlcipher_openssl_log_errors(); + goto error; + } + + csz = tmp_csz; + out += tmp_csz; + if(!(rc = EVP_CipherFinal_ex(ectx, out, &tmp_csz))) { + sqlcipher_log(SQLCIPHER_LOG_ERROR, "sqlcipher_openssl_cipher: EVP_CipherFinal_ex returned %d", rc); + sqlcipher_openssl_log_errors(); + goto error; + } + + csz += tmp_csz; + assert(in_sz == csz); + + rc = SQLITE_OK; + goto cleanup; +error: + rc = SQLITE_ERROR; +cleanup: + if(ectx) EVP_CIPHER_CTX_free(ectx); + return rc; +} + +static const char* sqlcipher_openssl_get_cipher(void *ctx) { + return OBJ_nid2sn(EVP_CIPHER_nid(OPENSSL_CIPHER)); +} + +static int sqlcipher_openssl_get_key_sz(void *ctx) { + return EVP_CIPHER_key_length(OPENSSL_CIPHER); +} + +static int sqlcipher_openssl_get_iv_sz(void *ctx) { + return EVP_CIPHER_iv_length(OPENSSL_CIPHER); +} + +static int sqlcipher_openssl_get_block_sz(void *ctx) { + return EVP_CIPHER_block_size(OPENSSL_CIPHER); +} + +static int sqlcipher_openssl_get_hmac_sz(void *ctx, int algorithm) { + switch(algorithm) { + case SQLCIPHER_HMAC_SHA1: + return EVP_MD_size(EVP_sha1()); + break; + case SQLCIPHER_HMAC_SHA256: + return EVP_MD_size(EVP_sha256()); + break; + case SQLCIPHER_HMAC_SHA512: + return EVP_MD_size(EVP_sha512()); + break; + default: + return 0; + } +} + +static int sqlcipher_openssl_ctx_init(void **ctx) { + return sqlcipher_openssl_activate(*ctx); +} + +static int sqlcipher_openssl_ctx_free(void **ctx) { + return sqlcipher_openssl_deactivate(NULL); +} + +static int sqlcipher_openssl_fips_status(void *ctx) { +#ifdef SQLCIPHER_FIPS + return FIPS_mode(); +#else + return 0; +#endif +} + +int sqlcipher_openssl_setup(sqlcipher_provider *p) { + p->activate = sqlcipher_openssl_activate; + p->deactivate = sqlcipher_openssl_deactivate; + p->get_provider_name = sqlcipher_openssl_get_provider_name; + p->random = sqlcipher_openssl_random; + p->hmac = sqlcipher_openssl_hmac; + p->kdf = sqlcipher_openssl_kdf; + p->cipher = sqlcipher_openssl_cipher; + p->get_cipher = sqlcipher_openssl_get_cipher; + p->get_key_sz = sqlcipher_openssl_get_key_sz; + p->get_iv_sz = sqlcipher_openssl_get_iv_sz; + p->get_block_sz = sqlcipher_openssl_get_block_sz; + p->get_hmac_sz = sqlcipher_openssl_get_hmac_sz; + p->ctx_init = sqlcipher_openssl_ctx_init; + p->ctx_free = sqlcipher_openssl_ctx_free; + p->add_random = sqlcipher_openssl_add_random; + p->fips_status = sqlcipher_openssl_fips_status; + p->get_provider_version = sqlcipher_openssl_get_provider_version; + return SQLITE_OK; +} + +#endif +#endif +/* END SQLCIPHER */ + +/************** End of crypto_openssl.c **************************************/ +/************** Begin file crypto_cc.c ***************************************/ +/* +** SQLCipher +** http://sqlcipher.net +** +** Copyright (c) 2008 - 2013, ZETETIC LLC +** All rights reserved. +** +** Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in the +** documentation and/or other materials provided with the distribution. +** * Neither the name of the ZETETIC LLC nor the +** names of its contributors may be used to endorse or promote products +** derived from this software without specific prior written permission. +** +** THIS SOFTWARE IS PROVIDED BY ZETETIC LLC ''AS IS'' AND ANY +** EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +** DISCLAIMED. IN NO EVENT SHALL ZETETIC LLC BE LIABLE FOR ANY +** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +** +*/ +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC +#ifdef SQLCIPHER_CRYPTO_CC +/* #include "crypto.h" */ +/* #include "sqlcipher.h" */ +#include +#include +#include + +int sqlcipher_cc_setup(sqlcipher_provider *p); + +static int sqlcipher_cc_add_random(void *ctx, void *buffer, int length) { + return SQLITE_OK; +} + +/* generate a defined number of random bytes */ +static int sqlcipher_cc_random (void *ctx, void *buffer, int length) { + return (SecRandomCopyBytes(kSecRandomDefault, length, (uint8_t *)buffer) == kCCSuccess) ? SQLITE_OK : SQLITE_ERROR; +} + +static const char* sqlcipher_cc_get_provider_name(void *ctx) { + return "commoncrypto"; +} + +static const char* sqlcipher_cc_get_provider_version(void *ctx) { +#if TARGET_OS_MAC + CFTypeRef version; + CFBundleRef bundle = CFBundleGetBundleWithIdentifier(CFSTR("com.apple.security")); + if(bundle == NULL) { + return "unknown"; + } + version = CFBundleGetValueForInfoDictionaryKey(bundle, CFSTR("CFBundleShortVersionString")); + return CFStringGetCStringPtr(version, kCFStringEncodingUTF8); +#else + return "unknown"; +#endif +} + +static int sqlcipher_cc_hmac(void *ctx, int algorithm, unsigned char *hmac_key, int key_sz, unsigned char *in, int in_sz, unsigned char *in2, int in2_sz, unsigned char *out) { + CCHmacContext hmac_context; + if(in == NULL) return SQLITE_ERROR; + switch(algorithm) { + case SQLCIPHER_HMAC_SHA1: + CCHmacInit(&hmac_context, kCCHmacAlgSHA1, hmac_key, key_sz); + break; + case SQLCIPHER_HMAC_SHA256: + CCHmacInit(&hmac_context, kCCHmacAlgSHA256, hmac_key, key_sz); + break; + case SQLCIPHER_HMAC_SHA512: + CCHmacInit(&hmac_context, kCCHmacAlgSHA512, hmac_key, key_sz); + break; + default: + return SQLITE_ERROR; + } + CCHmacUpdate(&hmac_context, in, in_sz); + if(in2 != NULL) CCHmacUpdate(&hmac_context, in2, in2_sz); + CCHmacFinal(&hmac_context, out); + return SQLITE_OK; +} + +static int sqlcipher_cc_kdf(void *ctx, int algorithm, const unsigned char *pass, int pass_sz, unsigned char* salt, int salt_sz, int workfactor, int key_sz, unsigned char *key) { + switch(algorithm) { + case SQLCIPHER_HMAC_SHA1: + if(CCKeyDerivationPBKDF(kCCPBKDF2, (const char *)pass, pass_sz, salt, salt_sz, kCCPRFHmacAlgSHA1, workfactor, key, key_sz) != kCCSuccess) return SQLITE_ERROR; + break; + case SQLCIPHER_HMAC_SHA256: + if(CCKeyDerivationPBKDF(kCCPBKDF2, (const char *)pass, pass_sz, salt, salt_sz, kCCPRFHmacAlgSHA256, workfactor, key, key_sz) != kCCSuccess) return SQLITE_ERROR; + break; + case SQLCIPHER_HMAC_SHA512: + if(CCKeyDerivationPBKDF(kCCPBKDF2, (const char *)pass, pass_sz, salt, salt_sz, kCCPRFHmacAlgSHA512, workfactor, key, key_sz) != kCCSuccess) return SQLITE_ERROR; + break; + default: + return SQLITE_ERROR; + } + return SQLITE_OK; +} + +static int sqlcipher_cc_cipher(void *ctx, int mode, unsigned char *key, int key_sz, unsigned char *iv, unsigned char *in, int in_sz, unsigned char *out) { + CCCryptorRef cryptor; + size_t tmp_csz, csz; + CCOperation op = mode == CIPHER_ENCRYPT ? kCCEncrypt : kCCDecrypt; + + if(CCCryptorCreate(op, kCCAlgorithmAES128, 0, key, kCCKeySizeAES256, iv, &cryptor) != kCCSuccess) return SQLITE_ERROR; + if(CCCryptorUpdate(cryptor, in, in_sz, out, in_sz, &tmp_csz) != kCCSuccess) return SQLITE_ERROR; + csz = tmp_csz; + out += tmp_csz; + if(CCCryptorFinal(cryptor, out, in_sz - csz, &tmp_csz) != kCCSuccess) return SQLITE_ERROR; + csz += tmp_csz; + if(CCCryptorRelease(cryptor) != kCCSuccess) return SQLITE_ERROR; + assert(in_sz == csz); + + return SQLITE_OK; +} + +static const char* sqlcipher_cc_get_cipher(void *ctx) { + return "aes-256-cbc"; +} + +static int sqlcipher_cc_get_key_sz(void *ctx) { + return kCCKeySizeAES256; +} + +static int sqlcipher_cc_get_iv_sz(void *ctx) { + return kCCBlockSizeAES128; +} + +static int sqlcipher_cc_get_block_sz(void *ctx) { + return kCCBlockSizeAES128; +} + +static int sqlcipher_cc_get_hmac_sz(void *ctx, int algorithm) { + switch(algorithm) { + case SQLCIPHER_HMAC_SHA1: + return CC_SHA1_DIGEST_LENGTH; + break; + case SQLCIPHER_HMAC_SHA256: + return CC_SHA256_DIGEST_LENGTH; + break; + case SQLCIPHER_HMAC_SHA512: + return CC_SHA512_DIGEST_LENGTH; + break; + default: + return 0; + } +} + +static int sqlcipher_cc_ctx_init(void **ctx) { + return SQLITE_OK; +} + +static int sqlcipher_cc_ctx_free(void **ctx) { + return SQLITE_OK; +} + +static int sqlcipher_cc_fips_status(void *ctx) { + return 0; +} + +int sqlcipher_cc_setup(sqlcipher_provider *p) { + p->random = sqlcipher_cc_random; + p->get_provider_name = sqlcipher_cc_get_provider_name; + p->hmac = sqlcipher_cc_hmac; + p->kdf = sqlcipher_cc_kdf; + p->cipher = sqlcipher_cc_cipher; + p->get_cipher = sqlcipher_cc_get_cipher; + p->get_key_sz = sqlcipher_cc_get_key_sz; + p->get_iv_sz = sqlcipher_cc_get_iv_sz; + p->get_block_sz = sqlcipher_cc_get_block_sz; + p->get_hmac_sz = sqlcipher_cc_get_hmac_sz; + p->ctx_init = sqlcipher_cc_ctx_init; + p->ctx_free = sqlcipher_cc_ctx_free; + p->add_random = sqlcipher_cc_add_random; + p->fips_status = sqlcipher_cc_fips_status; + p->get_provider_version = sqlcipher_cc_get_provider_version; + return SQLITE_OK; +} + +#endif +#endif +/* END SQLCIPHER */ + +/************** End of crypto_cc.c *******************************************/ +/************** Begin file walker.c ******************************************/ +/* +** 2008 August 16 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains routines used for walking the parser tree for +** an SQL statement. +*/ +/* #include "sqliteInt.h" */ +/* #include */ +/* #include */ + + +#if !defined(SQLITE_OMIT_WINDOWFUNC) +/* +** Walk all expressions linked into the list of Window objects passed +** as the second argument. +*/ +static int walkWindowList(Walker *pWalker, Window *pList, int bOneOnly){ + Window *pWin; + for(pWin=pList; pWin; pWin=pWin->pNextWin){ + int rc; + rc = sqlite3WalkExprList(pWalker, pWin->pOrderBy); + if( rc ) return WRC_Abort; + rc = sqlite3WalkExprList(pWalker, pWin->pPartition); + if( rc ) return WRC_Abort; + rc = sqlite3WalkExpr(pWalker, pWin->pFilter); + if( rc ) return WRC_Abort; + rc = sqlite3WalkExpr(pWalker, pWin->pStart); + if( rc ) return WRC_Abort; + rc = sqlite3WalkExpr(pWalker, pWin->pEnd); + if( rc ) return WRC_Abort; + if( bOneOnly ) break; + } + return WRC_Continue; +} +#endif + +/* +** Walk an expression tree. Invoke the callback once for each node +** of the expression, while descending. (In other words, the callback +** is invoked before visiting children.) +** +** The return value from the callback should be one of the WRC_* +** constants to specify how to proceed with the walk. +** +** WRC_Continue Continue descending down the tree. +** +** WRC_Prune Do not descend into child nodes, but allow +** the walk to continue with sibling nodes. +** +** WRC_Abort Do no more callbacks. Unwind the stack and +** return from the top-level walk call. +** +** The return value from this routine is WRC_Abort to abandon the tree walk +** and WRC_Continue to continue. +*/ +static SQLITE_NOINLINE int walkExpr(Walker *pWalker, Expr *pExpr){ + int rc; + testcase( ExprHasProperty(pExpr, EP_TokenOnly) ); + testcase( ExprHasProperty(pExpr, EP_Reduced) ); + while(1){ + rc = pWalker->xExprCallback(pWalker, pExpr); + if( rc ) return rc & WRC_Abort; + if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){ + assert( pExpr->x.pList==0 || pExpr->pRight==0 ); + if( pExpr->pLeft && walkExpr(pWalker, pExpr->pLeft) ) return WRC_Abort; + if( pExpr->pRight ){ + assert( !ExprHasProperty(pExpr, EP_WinFunc) ); + pExpr = pExpr->pRight; + continue; + }else if( ExprUseXSelect(pExpr) ){ + assert( !ExprHasProperty(pExpr, EP_WinFunc) ); + if( sqlite3WalkSelect(pWalker, pExpr->x.pSelect) ) return WRC_Abort; + }else{ + if( pExpr->x.pList ){ + if( sqlite3WalkExprList(pWalker, pExpr->x.pList) ) return WRC_Abort; + } +#ifndef SQLITE_OMIT_WINDOWFUNC + if( ExprHasProperty(pExpr, EP_WinFunc) ){ + if( walkWindowList(pWalker, pExpr->y.pWin, 1) ) return WRC_Abort; + } +#endif + } + } + break; + } + return WRC_Continue; +} +SQLITE_PRIVATE int sqlite3WalkExpr(Walker *pWalker, Expr *pExpr){ + return pExpr ? walkExpr(pWalker,pExpr) : WRC_Continue; +} + +/* +** Call sqlite3WalkExpr() for every expression in list p or until +** an abort request is seen. +*/ +SQLITE_PRIVATE int sqlite3WalkExprList(Walker *pWalker, ExprList *p){ + int i; + struct ExprList_item *pItem; + if( p ){ + for(i=p->nExpr, pItem=p->a; i>0; i--, pItem++){ + if( sqlite3WalkExpr(pWalker, pItem->pExpr) ) return WRC_Abort; + } + } + return WRC_Continue; +} + +/* +** This is a no-op callback for Walker->xSelectCallback2. If this +** callback is set, then the Select->pWinDefn list is traversed. +*/ +SQLITE_PRIVATE void sqlite3WalkWinDefnDummyCallback(Walker *pWalker, Select *p){ + UNUSED_PARAMETER(pWalker); + UNUSED_PARAMETER(p); + /* No-op */ +} + +/* +** Walk all expressions associated with SELECT statement p. Do +** not invoke the SELECT callback on p, but do (of course) invoke +** any expr callbacks and SELECT callbacks that come from subqueries. +** Return WRC_Abort or WRC_Continue. +*/ +SQLITE_PRIVATE int sqlite3WalkSelectExpr(Walker *pWalker, Select *p){ + if( sqlite3WalkExprList(pWalker, p->pEList) ) return WRC_Abort; + if( sqlite3WalkExpr(pWalker, p->pWhere) ) return WRC_Abort; + if( sqlite3WalkExprList(pWalker, p->pGroupBy) ) return WRC_Abort; + if( sqlite3WalkExpr(pWalker, p->pHaving) ) return WRC_Abort; + if( sqlite3WalkExprList(pWalker, p->pOrderBy) ) return WRC_Abort; + if( sqlite3WalkExpr(pWalker, p->pLimit) ) return WRC_Abort; +#if !defined(SQLITE_OMIT_WINDOWFUNC) + if( p->pWinDefn ){ + Parse *pParse; + if( pWalker->xSelectCallback2==sqlite3WalkWinDefnDummyCallback + || ((pParse = pWalker->pParse)!=0 && IN_RENAME_OBJECT) +#ifndef SQLITE_OMIT_CTE + || pWalker->xSelectCallback2==sqlite3SelectPopWith +#endif + ){ + /* The following may return WRC_Abort if there are unresolvable + ** symbols (e.g. a table that does not exist) in a window definition. */ + int rc = walkWindowList(pWalker, p->pWinDefn, 0); + return rc; + } + } +#endif + return WRC_Continue; +} + +/* +** Walk the parse trees associated with all subqueries in the +** FROM clause of SELECT statement p. Do not invoke the select +** callback on p, but do invoke it on each FROM clause subquery +** and on any subqueries further down in the tree. Return +** WRC_Abort or WRC_Continue; +*/ +SQLITE_PRIVATE int sqlite3WalkSelectFrom(Walker *pWalker, Select *p){ + SrcList *pSrc; + int i; + SrcItem *pItem; + + pSrc = p->pSrc; + if( ALWAYS(pSrc) ){ + for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){ + if( pItem->pSelect && sqlite3WalkSelect(pWalker, pItem->pSelect) ){ + return WRC_Abort; + } + if( pItem->fg.isTabFunc + && sqlite3WalkExprList(pWalker, pItem->u1.pFuncArg) + ){ + return WRC_Abort; + } + } + } + return WRC_Continue; +} + +/* +** Call sqlite3WalkExpr() for every expression in Select statement p. +** Invoke sqlite3WalkSelect() for subqueries in the FROM clause and +** on the compound select chain, p->pPrior. +** +** If it is not NULL, the xSelectCallback() callback is invoked before +** the walk of the expressions and FROM clause. The xSelectCallback2() +** method is invoked following the walk of the expressions and FROM clause, +** but only if both xSelectCallback and xSelectCallback2 are both non-NULL +** and if the expressions and FROM clause both return WRC_Continue; +** +** Return WRC_Continue under normal conditions. Return WRC_Abort if +** there is an abort request. +** +** If the Walker does not have an xSelectCallback() then this routine +** is a no-op returning WRC_Continue. +*/ +SQLITE_PRIVATE int sqlite3WalkSelect(Walker *pWalker, Select *p){ + int rc; + if( p==0 ) return WRC_Continue; + if( pWalker->xSelectCallback==0 ) return WRC_Continue; + do{ + rc = pWalker->xSelectCallback(pWalker, p); + if( rc ) return rc & WRC_Abort; + if( sqlite3WalkSelectExpr(pWalker, p) + || sqlite3WalkSelectFrom(pWalker, p) + ){ + return WRC_Abort; + } + if( pWalker->xSelectCallback2 ){ + pWalker->xSelectCallback2(pWalker, p); + } + p = p->pPrior; + }while( p!=0 ); + return WRC_Continue; +} + +/* Increase the walkerDepth when entering a subquery, and +** descrease when leaving the subquery. +*/ +SQLITE_PRIVATE int sqlite3WalkerDepthIncrease(Walker *pWalker, Select *pSelect){ + UNUSED_PARAMETER(pSelect); + pWalker->walkerDepth++; + return WRC_Continue; +} +SQLITE_PRIVATE void sqlite3WalkerDepthDecrease(Walker *pWalker, Select *pSelect){ + UNUSED_PARAMETER(pSelect); + pWalker->walkerDepth--; +} + + +/* +** No-op routine for the parse-tree walker. +** +** When this routine is the Walker.xExprCallback then expression trees +** are walked without any actions being taken at each node. Presumably, +** when this routine is used for Walker.xExprCallback then +** Walker.xSelectCallback is set to do something useful for every +** subquery in the parser tree. +*/ +SQLITE_PRIVATE int sqlite3ExprWalkNoop(Walker *NotUsed, Expr *NotUsed2){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + return WRC_Continue; +} + +/* +** No-op routine for the parse-tree walker for SELECT statements. +** subquery in the parser tree. +*/ +SQLITE_PRIVATE int sqlite3SelectWalkNoop(Walker *NotUsed, Select *NotUsed2){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + return WRC_Continue; +} + +/************** End of walker.c **********************************************/ +/************** Begin file resolve.c *****************************************/ +/* +** 2008 August 18 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains routines used for walking the parser tree and +** resolve all identifiers by associating them with a particular +** table and column. +*/ +/* #include "sqliteInt.h" */ + +/* +** Magic table number to mean the EXCLUDED table in an UPSERT statement. +*/ +#define EXCLUDED_TABLE_NUMBER 2 + +/* +** Walk the expression tree pExpr and increase the aggregate function +** depth (the Expr.op2 field) by N on every TK_AGG_FUNCTION node. +** This needs to occur when copying a TK_AGG_FUNCTION node from an +** outer query into an inner subquery. +** +** incrAggFunctionDepth(pExpr,n) is the main routine. incrAggDepth(..) +** is a helper function - a callback for the tree walker. +** +** See also the sqlite3WindowExtraAggFuncDepth() routine in window.c +*/ +static int incrAggDepth(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_AGG_FUNCTION ) pExpr->op2 += pWalker->u.n; + return WRC_Continue; +} +static void incrAggFunctionDepth(Expr *pExpr, int N){ + if( N>0 ){ + Walker w; + memset(&w, 0, sizeof(w)); + w.xExprCallback = incrAggDepth; + w.u.n = N; + sqlite3WalkExpr(&w, pExpr); + } +} + +/* +** Turn the pExpr expression into an alias for the iCol-th column of the +** result set in pEList. +** +** If the reference is followed by a COLLATE operator, then make sure +** the COLLATE operator is preserved. For example: +** +** SELECT a+b, c+d FROM t1 ORDER BY 1 COLLATE nocase; +** +** Should be transformed into: +** +** SELECT a+b, c+d FROM t1 ORDER BY (a+b) COLLATE nocase; +** +** The nSubquery parameter specifies how many levels of subquery the +** alias is removed from the original expression. The usual value is +** zero but it might be more if the alias is contained within a subquery +** of the original expression. The Expr.op2 field of TK_AGG_FUNCTION +** structures must be increased by the nSubquery amount. +*/ +static void resolveAlias( + Parse *pParse, /* Parsing context */ + ExprList *pEList, /* A result set */ + int iCol, /* A column in the result set. 0..pEList->nExpr-1 */ + Expr *pExpr, /* Transform this into an alias to the result set */ + int nSubquery /* Number of subqueries that the label is moving */ +){ + Expr *pOrig; /* The iCol-th column of the result set */ + Expr *pDup; /* Copy of pOrig */ + sqlite3 *db; /* The database connection */ + + assert( iCol>=0 && iColnExpr ); + pOrig = pEList->a[iCol].pExpr; + assert( pOrig!=0 ); + db = pParse->db; + pDup = sqlite3ExprDup(db, pOrig, 0); + if( db->mallocFailed ){ + sqlite3ExprDelete(db, pDup); + pDup = 0; + }else{ + Expr temp; + incrAggFunctionDepth(pDup, nSubquery); + if( pExpr->op==TK_COLLATE ){ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken); + } + memcpy(&temp, pDup, sizeof(Expr)); + memcpy(pDup, pExpr, sizeof(Expr)); + memcpy(pExpr, &temp, sizeof(Expr)); + if( ExprHasProperty(pExpr, EP_WinFunc) ){ + if( ALWAYS(pExpr->y.pWin!=0) ){ + pExpr->y.pWin->pOwner = pExpr; + } + } + sqlite3ExprDeferredDelete(pParse, pDup); + } +} + +/* +** Subqueries stores the original database, table and column names for their +** result sets in ExprList.a[].zSpan, in the form "DATABASE.TABLE.COLUMN". +** Check to see if the zSpan given to this routine matches the zDb, zTab, +** and zCol. If any of zDb, zTab, and zCol are NULL then those fields will +** match anything. +*/ +SQLITE_PRIVATE int sqlite3MatchEName( + const struct ExprList_item *pItem, + const char *zCol, + const char *zTab, + const char *zDb +){ + int n; + const char *zSpan; + if( pItem->fg.eEName!=ENAME_TAB ) return 0; + zSpan = pItem->zEName; + for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){} + if( zDb && (sqlite3StrNICmp(zSpan, zDb, n)!=0 || zDb[n]!=0) ){ + return 0; + } + zSpan += n+1; + for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){} + if( zTab && (sqlite3StrNICmp(zSpan, zTab, n)!=0 || zTab[n]!=0) ){ + return 0; + } + zSpan += n+1; + if( zCol && sqlite3StrICmp(zSpan, zCol)!=0 ){ + return 0; + } + return 1; +} + +/* +** Return TRUE if the double-quoted string mis-feature should be supported. +*/ +static int areDoubleQuotedStringsEnabled(sqlite3 *db, NameContext *pTopNC){ + if( db->init.busy ) return 1; /* Always support for legacy schemas */ + if( pTopNC->ncFlags & NC_IsDDL ){ + /* Currently parsing a DDL statement */ + if( sqlite3WritableSchema(db) && (db->flags & SQLITE_DqsDML)!=0 ){ + return 1; + } + return (db->flags & SQLITE_DqsDDL)!=0; + }else{ + /* Currently parsing a DML statement */ + return (db->flags & SQLITE_DqsDML)!=0; + } +} + +/* +** The argument is guaranteed to be a non-NULL Expr node of type TK_COLUMN. +** return the appropriate colUsed mask. +*/ +SQLITE_PRIVATE Bitmask sqlite3ExprColUsed(Expr *pExpr){ + int n; + Table *pExTab; + + n = pExpr->iColumn; + assert( ExprUseYTab(pExpr) ); + pExTab = pExpr->y.pTab; + assert( pExTab!=0 ); + if( (pExTab->tabFlags & TF_HasGenerated)!=0 + && (pExTab->aCol[n].colFlags & COLFLAG_GENERATED)!=0 + ){ + testcase( pExTab->nCol==BMS-1 ); + testcase( pExTab->nCol==BMS ); + return pExTab->nCol>=BMS ? ALLBITS : MASKBIT(pExTab->nCol)-1; + }else{ + testcase( n==BMS-1 ); + testcase( n==BMS ); + if( n>=BMS ) n = BMS-1; + return ((Bitmask)1)<db, TK_COLUMN, 0, 0); + if( pNew ){ + pNew->iTable = pMatch->iCursor; + pNew->iColumn = iColumn; + pNew->y.pTab = pMatch->pTab; + assert( (pMatch->fg.jointype & (JT_LEFT|JT_LTORJ))!=0 ); + ExprSetProperty(pNew, EP_CanBeNull); + *ppList = sqlite3ExprListAppend(pParse, *ppList, pNew); + } +} + +/* +** Return TRUE (non-zero) if zTab is a valid name for the schema table pTab. +*/ +static SQLITE_NOINLINE int isValidSchemaTableName( + const char *zTab, /* Name as it appears in the SQL */ + Table *pTab, /* The schema table we are trying to match */ + Schema *pSchema /* non-NULL if a database qualifier is present */ +){ + const char *zLegacy; + assert( pTab!=0 ); + assert( pTab->tnum==1 ); + if( sqlite3StrNICmp(zTab, "sqlite_", 7)!=0 ) return 0; + zLegacy = pTab->zName; + if( strcmp(zLegacy+7, &LEGACY_TEMP_SCHEMA_TABLE[7])==0 ){ + if( sqlite3StrICmp(zTab+7, &PREFERRED_TEMP_SCHEMA_TABLE[7])==0 ){ + return 1; + } + if( pSchema==0 ) return 0; + if( sqlite3StrICmp(zTab+7, &LEGACY_SCHEMA_TABLE[7])==0 ) return 1; + if( sqlite3StrICmp(zTab+7, &PREFERRED_SCHEMA_TABLE[7])==0 ) return 1; + }else{ + if( sqlite3StrICmp(zTab+7, &PREFERRED_SCHEMA_TABLE[7])==0 ) return 1; + } + return 0; +} + +/* +** Given the name of a column of the form X.Y.Z or Y.Z or just Z, look up +** that name in the set of source tables in pSrcList and make the pExpr +** expression node refer back to that source column. The following changes +** are made to pExpr: +** +** pExpr->iDb Set the index in db->aDb[] of the database X +** (even if X is implied). +** pExpr->iTable Set to the cursor number for the table obtained +** from pSrcList. +** pExpr->y.pTab Points to the Table structure of X.Y (even if +** X and/or Y are implied.) +** pExpr->iColumn Set to the column number within the table. +** pExpr->op Set to TK_COLUMN. +** pExpr->pLeft Any expression this points to is deleted +** pExpr->pRight Any expression this points to is deleted. +** +** The zDb variable is the name of the database (the "X"). This value may be +** NULL meaning that name is of the form Y.Z or Z. Any available database +** can be used. The zTable variable is the name of the table (the "Y"). This +** value can be NULL if zDb is also NULL. If zTable is NULL it +** means that the form of the name is Z and that columns from any table +** can be used. +** +** If the name cannot be resolved unambiguously, leave an error message +** in pParse and return WRC_Abort. Return WRC_Prune on success. +*/ +static int lookupName( + Parse *pParse, /* The parsing context */ + const char *zDb, /* Name of the database containing table, or NULL */ + const char *zTab, /* Name of table containing column, or NULL */ + const char *zCol, /* Name of the column. */ + NameContext *pNC, /* The name context used to resolve the name */ + Expr *pExpr /* Make this EXPR node point to the selected column */ +){ + int i, j; /* Loop counters */ + int cnt = 0; /* Number of matching column names */ + int cntTab = 0; /* Number of matching table names */ + int nSubquery = 0; /* How many levels of subquery */ + sqlite3 *db = pParse->db; /* The database connection */ + SrcItem *pItem; /* Use for looping over pSrcList items */ + SrcItem *pMatch = 0; /* The matching pSrcList item */ + NameContext *pTopNC = pNC; /* First namecontext in the list */ + Schema *pSchema = 0; /* Schema of the expression */ + int eNewExprOp = TK_COLUMN; /* New value for pExpr->op on success */ + Table *pTab = 0; /* Table holding the row */ + Column *pCol; /* A column of pTab */ + ExprList *pFJMatch = 0; /* Matches for FULL JOIN .. USING */ + + assert( pNC ); /* the name context cannot be NULL. */ + assert( zCol ); /* The Z in X.Y.Z cannot be NULL */ + assert( zDb==0 || zTab!=0 ); + assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) ); + + /* Initialize the node to no-match */ + pExpr->iTable = -1; + ExprSetVVAProperty(pExpr, EP_NoReduce); + + /* Translate the schema name in zDb into a pointer to the corresponding + ** schema. If not found, pSchema will remain NULL and nothing will match + ** resulting in an appropriate error message toward the end of this routine + */ + if( zDb ){ + testcase( pNC->ncFlags & NC_PartIdx ); + testcase( pNC->ncFlags & NC_IsCheck ); + if( (pNC->ncFlags & (NC_PartIdx|NC_IsCheck))!=0 ){ + /* Silently ignore database qualifiers inside CHECK constraints and + ** partial indices. Do not raise errors because that might break + ** legacy and because it does not hurt anything to just ignore the + ** database name. */ + zDb = 0; + }else{ + for(i=0; inDb; i++){ + assert( db->aDb[i].zDbSName ); + if( sqlite3StrICmp(db->aDb[i].zDbSName,zDb)==0 ){ + pSchema = db->aDb[i].pSchema; + break; + } + } + if( i==db->nDb && sqlite3StrICmp("main", zDb)==0 ){ + /* This branch is taken when the main database has been renamed + ** using SQLITE_DBCONFIG_MAINDBNAME. */ + pSchema = db->aDb[0].pSchema; + zDb = db->aDb[0].zDbSName; + } + } + } + + /* Start at the inner-most context and move outward until a match is found */ + assert( pNC && cnt==0 ); + do{ + ExprList *pEList; + SrcList *pSrcList = pNC->pSrcList; + + if( pSrcList ){ + for(i=0, pItem=pSrcList->a; inSrc; i++, pItem++){ + u8 hCol; + pTab = pItem->pTab; + assert( pTab!=0 && pTab->zName!=0 ); + assert( pTab->nCol>0 || pParse->nErr ); + assert( (int)pItem->fg.isNestedFrom == IsNestedFrom(pItem->pSelect) ); + if( pItem->fg.isNestedFrom ){ + /* In this case, pItem is a subquery that has been formed from a + ** parenthesized subset of the FROM clause terms. Example: + ** .... FROM t1 LEFT JOIN (t2 RIGHT JOIN t3 USING(x)) USING(y) ... + ** \_________________________/ + ** This pItem -------------^ + */ + int hit = 0; + assert( pItem->pSelect!=0 ); + pEList = pItem->pSelect->pEList; + assert( pEList!=0 ); + assert( pEList->nExpr==pTab->nCol ); + for(j=0; jnExpr; j++){ + if( !sqlite3MatchEName(&pEList->a[j], zCol, zTab, zDb) ){ + continue; + } + if( cnt>0 ){ + if( pItem->fg.isUsing==0 + || sqlite3IdListIndex(pItem->u3.pUsing, zCol)<0 + ){ + /* Two or more tables have the same column name which is + ** not joined by USING. This is an error. Signal as much + ** by clearing pFJMatch and letting cnt go above 1. */ + sqlite3ExprListDelete(db, pFJMatch); + pFJMatch = 0; + }else + if( (pItem->fg.jointype & JT_RIGHT)==0 ){ + /* An INNER or LEFT JOIN. Use the left-most table */ + continue; + }else + if( (pItem->fg.jointype & JT_LEFT)==0 ){ + /* A RIGHT JOIN. Use the right-most table */ + cnt = 0; + sqlite3ExprListDelete(db, pFJMatch); + pFJMatch = 0; + }else{ + /* For a FULL JOIN, we must construct a coalesce() func */ + extendFJMatch(pParse, &pFJMatch, pMatch, pExpr->iColumn); + } + } + cnt++; + cntTab = 2; + pMatch = pItem; + pExpr->iColumn = j; + pEList->a[j].fg.bUsed = 1; + hit = 1; + if( pEList->a[j].fg.bUsingTerm ) break; + } + if( hit || zTab==0 ) continue; + } + assert( zDb==0 || zTab!=0 ); + if( zTab ){ + if( zDb ){ + if( pTab->pSchema!=pSchema ) continue; + if( pSchema==0 && strcmp(zDb,"*")!=0 ) continue; + } + if( pItem->zAlias!=0 ){ + if( sqlite3StrICmp(zTab, pItem->zAlias)!=0 ){ + continue; + } + }else if( sqlite3StrICmp(zTab, pTab->zName)!=0 ){ + if( pTab->tnum!=1 ) continue; + if( !isValidSchemaTableName(zTab, pTab, pSchema) ) continue; + } + assert( ExprUseYTab(pExpr) ); + if( IN_RENAME_OBJECT && pItem->zAlias ){ + sqlite3RenameTokenRemap(pParse, 0, (void*)&pExpr->y.pTab); + } + } + hCol = sqlite3StrIHash(zCol); + for(j=0, pCol=pTab->aCol; jnCol; j++, pCol++){ + if( pCol->hName==hCol + && sqlite3StrICmp(pCol->zCnName, zCol)==0 + ){ + if( cnt>0 ){ + if( pItem->fg.isUsing==0 + || sqlite3IdListIndex(pItem->u3.pUsing, zCol)<0 + ){ + /* Two or more tables have the same column name which is + ** not joined by USING. This is an error. Signal as much + ** by clearing pFJMatch and letting cnt go above 1. */ + sqlite3ExprListDelete(db, pFJMatch); + pFJMatch = 0; + }else + if( (pItem->fg.jointype & JT_RIGHT)==0 ){ + /* An INNER or LEFT JOIN. Use the left-most table */ + continue; + }else + if( (pItem->fg.jointype & JT_LEFT)==0 ){ + /* A RIGHT JOIN. Use the right-most table */ + cnt = 0; + sqlite3ExprListDelete(db, pFJMatch); + pFJMatch = 0; + }else{ + /* For a FULL JOIN, we must construct a coalesce() func */ + extendFJMatch(pParse, &pFJMatch, pMatch, pExpr->iColumn); + } + } + cnt++; + pMatch = pItem; + /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */ + pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j; + if( pItem->fg.isNestedFrom ){ + sqlite3SrcItemColumnUsed(pItem, j); + } + break; + } + } + if( 0==cnt && VisibleRowid(pTab) ){ + cntTab++; + pMatch = pItem; + } + } + if( pMatch ){ + pExpr->iTable = pMatch->iCursor; + assert( ExprUseYTab(pExpr) ); + pExpr->y.pTab = pMatch->pTab; + if( (pMatch->fg.jointype & (JT_LEFT|JT_LTORJ))!=0 ){ + ExprSetProperty(pExpr, EP_CanBeNull); + } + pSchema = pExpr->y.pTab->pSchema; + } + } /* if( pSrcList ) */ + +#if !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT) + /* If we have not already resolved the name, then maybe + ** it is a new.* or old.* trigger argument reference. Or + ** maybe it is an excluded.* from an upsert. Or maybe it is + ** a reference in the RETURNING clause to a table being modified. + */ + if( cnt==0 && zDb==0 ){ + pTab = 0; +#ifndef SQLITE_OMIT_TRIGGER + if( pParse->pTriggerTab!=0 ){ + int op = pParse->eTriggerOp; + assert( op==TK_DELETE || op==TK_UPDATE || op==TK_INSERT ); + if( pParse->bReturning ){ + if( (pNC->ncFlags & NC_UBaseReg)!=0 + && ALWAYS(zTab==0 + || sqlite3StrICmp(zTab,pParse->pTriggerTab->zName)==0) + ){ + pExpr->iTable = op!=TK_DELETE; + pTab = pParse->pTriggerTab; + } + }else if( op!=TK_DELETE && zTab && sqlite3StrICmp("new",zTab) == 0 ){ + pExpr->iTable = 1; + pTab = pParse->pTriggerTab; + }else if( op!=TK_INSERT && zTab && sqlite3StrICmp("old",zTab)==0 ){ + pExpr->iTable = 0; + pTab = pParse->pTriggerTab; + } + } +#endif /* SQLITE_OMIT_TRIGGER */ +#ifndef SQLITE_OMIT_UPSERT + if( (pNC->ncFlags & NC_UUpsert)!=0 && zTab!=0 ){ + Upsert *pUpsert = pNC->uNC.pUpsert; + if( pUpsert && sqlite3StrICmp("excluded",zTab)==0 ){ + pTab = pUpsert->pUpsertSrc->a[0].pTab; + pExpr->iTable = EXCLUDED_TABLE_NUMBER; + } + } +#endif /* SQLITE_OMIT_UPSERT */ + + if( pTab ){ + int iCol; + u8 hCol = sqlite3StrIHash(zCol); + pSchema = pTab->pSchema; + cntTab++; + for(iCol=0, pCol=pTab->aCol; iColnCol; iCol++, pCol++){ + if( pCol->hName==hCol + && sqlite3StrICmp(pCol->zCnName, zCol)==0 + ){ + if( iCol==pTab->iPKey ){ + iCol = -1; + } + break; + } + } + if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && VisibleRowid(pTab) ){ + /* IMP: R-51414-32910 */ + iCol = -1; + } + if( iColnCol ){ + cnt++; + pMatch = 0; +#ifndef SQLITE_OMIT_UPSERT + if( pExpr->iTable==EXCLUDED_TABLE_NUMBER ){ + testcase( iCol==(-1) ); + assert( ExprUseYTab(pExpr) ); + if( IN_RENAME_OBJECT ){ + pExpr->iColumn = iCol; + pExpr->y.pTab = pTab; + eNewExprOp = TK_COLUMN; + }else{ + pExpr->iTable = pNC->uNC.pUpsert->regData + + sqlite3TableColumnToStorage(pTab, iCol); + eNewExprOp = TK_REGISTER; + } + }else +#endif /* SQLITE_OMIT_UPSERT */ + { + assert( ExprUseYTab(pExpr) ); + pExpr->y.pTab = pTab; + if( pParse->bReturning ){ + eNewExprOp = TK_REGISTER; + pExpr->op2 = TK_COLUMN; + pExpr->iColumn = iCol; + pExpr->iTable = pNC->uNC.iBaseReg + (pTab->nCol+1)*pExpr->iTable + + sqlite3TableColumnToStorage(pTab, iCol) + 1; + }else{ + pExpr->iColumn = (i16)iCol; + eNewExprOp = TK_TRIGGER; +#ifndef SQLITE_OMIT_TRIGGER + if( iCol<0 ){ + pExpr->affExpr = SQLITE_AFF_INTEGER; + }else if( pExpr->iTable==0 ){ + testcase( iCol==31 ); + testcase( iCol==32 ); + pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<ncFlags & (NC_IdxExpr|NC_GenCol))==0 + && sqlite3IsRowid(zCol) + && ALWAYS(VisibleRowid(pMatch->pTab)) + ){ + cnt = 1; + pExpr->iColumn = -1; + pExpr->affExpr = SQLITE_AFF_INTEGER; + } + + /* + ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z + ** might refer to an result-set alias. This happens, for example, when + ** we are resolving names in the WHERE clause of the following command: + ** + ** SELECT a+b AS x FROM table WHERE x<10; + ** + ** In cases like this, replace pExpr with a copy of the expression that + ** forms the result set entry ("a+b" in the example) and return immediately. + ** Note that the expression in the result set should have already been + ** resolved by the time the WHERE clause is resolved. + ** + ** The ability to use an output result-set column in the WHERE, GROUP BY, + ** or HAVING clauses, or as part of a larger expression in the ORDER BY + ** clause is not standard SQL. This is a (goofy) SQLite extension, that + ** is supported for backwards compatibility only. Hence, we issue a warning + ** on sqlite3_log() whenever the capability is used. + */ + if( cnt==0 + && (pNC->ncFlags & NC_UEList)!=0 + && zTab==0 + ){ + pEList = pNC->uNC.pEList; + assert( pEList!=0 ); + for(j=0; jnExpr; j++){ + char *zAs = pEList->a[j].zEName; + if( pEList->a[j].fg.eEName==ENAME_NAME + && sqlite3_stricmp(zAs, zCol)==0 + ){ + Expr *pOrig; + assert( pExpr->pLeft==0 && pExpr->pRight==0 ); + assert( ExprUseXList(pExpr)==0 || pExpr->x.pList==0 ); + assert( ExprUseXSelect(pExpr)==0 || pExpr->x.pSelect==0 ); + pOrig = pEList->a[j].pExpr; + if( (pNC->ncFlags&NC_AllowAgg)==0 && ExprHasProperty(pOrig, EP_Agg) ){ + sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs); + return WRC_Abort; + } + if( ExprHasProperty(pOrig, EP_Win) + && ((pNC->ncFlags&NC_AllowWin)==0 || pNC!=pTopNC ) + ){ + sqlite3ErrorMsg(pParse, "misuse of aliased window function %s",zAs); + return WRC_Abort; + } + if( sqlite3ExprVectorSize(pOrig)!=1 ){ + sqlite3ErrorMsg(pParse, "row value misused"); + return WRC_Abort; + } + resolveAlias(pParse, pEList, j, pExpr, nSubquery); + cnt = 1; + pMatch = 0; + assert( zTab==0 && zDb==0 ); + if( IN_RENAME_OBJECT ){ + sqlite3RenameTokenRemap(pParse, 0, (void*)pExpr); + } + goto lookupname_end; + } + } + } + + /* Advance to the next name context. The loop will exit when either + ** we have a match (cnt>0) or when we run out of name contexts. + */ + if( cnt ) break; + pNC = pNC->pNext; + nSubquery++; + }while( pNC ); + + + /* + ** If X and Y are NULL (in other words if only the column name Z is + ** supplied) and the value of Z is enclosed in double-quotes, then + ** Z is a string literal if it doesn't match any column names. In that + ** case, we need to return right away and not make any changes to + ** pExpr. + ** + ** Because no reference was made to outer contexts, the pNC->nRef + ** fields are not changed in any context. + */ + if( cnt==0 && zTab==0 ){ + assert( pExpr->op==TK_ID ); + if( ExprHasProperty(pExpr,EP_DblQuoted) + && areDoubleQuotedStringsEnabled(db, pTopNC) + ){ + /* If a double-quoted identifier does not match any known column name, + ** then treat it as a string. + ** + ** This hack was added in the early days of SQLite in a misguided attempt + ** to be compatible with MySQL 3.x, which used double-quotes for strings. + ** I now sorely regret putting in this hack. The effect of this hack is + ** that misspelled identifier names are silently converted into strings + ** rather than causing an error, to the frustration of countless + ** programmers. To all those frustrated programmers, my apologies. + ** + ** Someday, I hope to get rid of this hack. Unfortunately there is + ** a huge amount of legacy SQL that uses it. So for now, we just + ** issue a warning. + */ + sqlite3_log(SQLITE_WARNING, + "double-quoted string literal: \"%w\"", zCol); +#ifdef SQLITE_ENABLE_NORMALIZE + sqlite3VdbeAddDblquoteStr(db, pParse->pVdbe, zCol); +#endif + pExpr->op = TK_STRING; + memset(&pExpr->y, 0, sizeof(pExpr->y)); + return WRC_Prune; + } + if( sqlite3ExprIdToTrueFalse(pExpr) ){ + return WRC_Prune; + } + } + + /* + ** cnt==0 means there was not match. + ** cnt>1 means there were two or more matches. + ** + ** cnt==0 is always an error. cnt>1 is often an error, but might + ** be multiple matches for a NATURAL LEFT JOIN or a LEFT JOIN USING. + */ + assert( pFJMatch==0 || cnt>0 ); + assert( !ExprHasProperty(pExpr, EP_xIsSelect|EP_IntValue) ); + if( cnt!=1 ){ + const char *zErr; + if( pFJMatch ){ + if( pFJMatch->nExpr==cnt-1 ){ + if( ExprHasProperty(pExpr,EP_Leaf) ){ + ExprClearProperty(pExpr,EP_Leaf); + }else{ + sqlite3ExprDelete(db, pExpr->pLeft); + pExpr->pLeft = 0; + sqlite3ExprDelete(db, pExpr->pRight); + pExpr->pRight = 0; + } + extendFJMatch(pParse, &pFJMatch, pMatch, pExpr->iColumn); + pExpr->op = TK_FUNCTION; + pExpr->u.zToken = "coalesce"; + pExpr->x.pList = pFJMatch; + cnt = 1; + goto lookupname_end; + }else{ + sqlite3ExprListDelete(db, pFJMatch); + pFJMatch = 0; + } + } + zErr = cnt==0 ? "no such column" : "ambiguous column name"; + if( zDb ){ + sqlite3ErrorMsg(pParse, "%s: %s.%s.%s", zErr, zDb, zTab, zCol); + }else if( zTab ){ + sqlite3ErrorMsg(pParse, "%s: %s.%s", zErr, zTab, zCol); + }else{ + sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol); + } + sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr); + pParse->checkSchema = 1; + pTopNC->nNcErr++; + } + assert( pFJMatch==0 ); + + /* Remove all substructure from pExpr */ + if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){ + sqlite3ExprDelete(db, pExpr->pLeft); + pExpr->pLeft = 0; + sqlite3ExprDelete(db, pExpr->pRight); + pExpr->pRight = 0; + ExprSetProperty(pExpr, EP_Leaf); + } + + /* If a column from a table in pSrcList is referenced, then record + ** this fact in the pSrcList.a[].colUsed bitmask. Column 0 causes + ** bit 0 to be set. Column 1 sets bit 1. And so forth. Bit 63 is + ** set if the 63rd or any subsequent column is used. + ** + ** The colUsed mask is an optimization used to help determine if an + ** index is a covering index. The correct answer is still obtained + ** if the mask contains extra set bits. However, it is important to + ** avoid setting bits beyond the maximum column number of the table. + ** (See ticket [b92e5e8ec2cdbaa1]). + ** + ** If a generated column is referenced, set bits for every column + ** of the table. + */ + if( pExpr->iColumn>=0 && pMatch!=0 ){ + pMatch->colUsed |= sqlite3ExprColUsed(pExpr); + } + + pExpr->op = eNewExprOp; +lookupname_end: + if( cnt==1 ){ + assert( pNC!=0 ); +#ifndef SQLITE_OMIT_AUTHORIZATION + if( pParse->db->xAuth + && (pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER) + ){ + sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList); + } +#endif + /* Increment the nRef value on all name contexts from TopNC up to + ** the point where the name matched. */ + for(;;){ + assert( pTopNC!=0 ); + pTopNC->nRef++; + if( pTopNC==pNC ) break; + pTopNC = pTopNC->pNext; + } + return WRC_Prune; + } else { + return WRC_Abort; + } +} + +/* +** Allocate and return a pointer to an expression to load the column iCol +** from datasource iSrc in SrcList pSrc. +*/ +SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSrc, int iCol){ + Expr *p = sqlite3ExprAlloc(db, TK_COLUMN, 0, 0); + if( p ){ + SrcItem *pItem = &pSrc->a[iSrc]; + Table *pTab; + assert( ExprUseYTab(p) ); + pTab = p->y.pTab = pItem->pTab; + p->iTable = pItem->iCursor; + if( p->y.pTab->iPKey==iCol ){ + p->iColumn = -1; + }else{ + p->iColumn = (ynVar)iCol; + if( (pTab->tabFlags & TF_HasGenerated)!=0 + && (pTab->aCol[iCol].colFlags & COLFLAG_GENERATED)!=0 + ){ + testcase( pTab->nCol==63 ); + testcase( pTab->nCol==64 ); + pItem->colUsed = pTab->nCol>=64 ? ALLBITS : MASKBIT(pTab->nCol)-1; + }else{ + testcase( iCol==BMS ); + testcase( iCol==BMS-1 ); + pItem->colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol); + } + } + } + return p; +} + +/* +** Report an error that an expression is not valid for some set of +** pNC->ncFlags values determined by validMask. +** +** static void notValid( +** Parse *pParse, // Leave error message here +** NameContext *pNC, // The name context +** const char *zMsg, // Type of error +** int validMask, // Set of contexts for which prohibited +** Expr *pExpr // Invalidate this expression on error +** ){...} +** +** As an optimization, since the conditional is almost always false +** (because errors are rare), the conditional is moved outside of the +** function call using a macro. +*/ +static void notValidImpl( + Parse *pParse, /* Leave error message here */ + NameContext *pNC, /* The name context */ + const char *zMsg, /* Type of error */ + Expr *pExpr, /* Invalidate this expression on error */ + Expr *pError /* Associate error with this expression */ +){ + const char *zIn = "partial index WHERE clauses"; + if( pNC->ncFlags & NC_IdxExpr ) zIn = "index expressions"; +#ifndef SQLITE_OMIT_CHECK + else if( pNC->ncFlags & NC_IsCheck ) zIn = "CHECK constraints"; +#endif +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + else if( pNC->ncFlags & NC_GenCol ) zIn = "generated columns"; +#endif + sqlite3ErrorMsg(pParse, "%s prohibited in %s", zMsg, zIn); + if( pExpr ) pExpr->op = TK_NULL; + sqlite3RecordErrorOffsetOfExpr(pParse->db, pError); +} +#define sqlite3ResolveNotValid(P,N,M,X,E,R) \ + assert( ((X)&~(NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol))==0 ); \ + if( ((N)->ncFlags & (X))!=0 ) notValidImpl(P,N,M,E,R); + +/* +** Expression p should encode a floating point value between 1.0 and 0.0. +** Return 1024 times this value. Or return -1 if p is not a floating point +** value between 1.0 and 0.0. +*/ +static int exprProbability(Expr *p){ + double r = -1.0; + if( p->op!=TK_FLOAT ) return -1; + assert( !ExprHasProperty(p, EP_IntValue) ); + sqlite3AtoF(p->u.zToken, &r, sqlite3Strlen30(p->u.zToken), SQLITE_UTF8); + assert( r>=0.0 ); + if( r>1.0 ) return -1; + return (int)(r*134217728.0); +} + +/* +** This routine is callback for sqlite3WalkExpr(). +** +** Resolve symbolic names into TK_COLUMN operators for the current +** node in the expression tree. Return 0 to continue the search down +** the tree or 2 to abort the tree walk. +** +** This routine also does error checking and name resolution for +** function names. The operator for aggregate functions is changed +** to TK_AGG_FUNCTION. +*/ +static int resolveExprStep(Walker *pWalker, Expr *pExpr){ + NameContext *pNC; + Parse *pParse; + + pNC = pWalker->u.pNC; + assert( pNC!=0 ); + pParse = pNC->pParse; + assert( pParse==pWalker->pParse ); + +#ifndef NDEBUG + if( pNC->pSrcList && pNC->pSrcList->nAlloc>0 ){ + SrcList *pSrcList = pNC->pSrcList; + int i; + for(i=0; ipSrcList->nSrc; i++){ + assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursornTab); + } + } +#endif + switch( pExpr->op ){ + + /* The special operator TK_ROW means use the rowid for the first + ** column in the FROM clause. This is used by the LIMIT and ORDER BY + ** clause processing on UPDATE and DELETE statements, and by + ** UPDATE ... FROM statement processing. + */ + case TK_ROW: { + SrcList *pSrcList = pNC->pSrcList; + SrcItem *pItem; + assert( pSrcList && pSrcList->nSrc>=1 ); + pItem = pSrcList->a; + pExpr->op = TK_COLUMN; + assert( ExprUseYTab(pExpr) ); + pExpr->y.pTab = pItem->pTab; + pExpr->iTable = pItem->iCursor; + pExpr->iColumn--; + pExpr->affExpr = SQLITE_AFF_INTEGER; + break; + } + + /* An optimization: Attempt to convert + ** + ** "expr IS NOT NULL" --> "TRUE" + ** "expr IS NULL" --> "FALSE" + ** + ** if we can prove that "expr" is never NULL. Call this the + ** "NOT NULL strength reduction optimization". + ** + ** If this optimization occurs, also restore the NameContext ref-counts + ** to the state they where in before the "column" LHS expression was + ** resolved. This prevents "column" from being counted as having been + ** referenced, which might prevent a SELECT from being erroneously + ** marked as correlated. + */ + case TK_NOTNULL: + case TK_ISNULL: { + int anRef[8]; + NameContext *p; + int i; + for(i=0, p=pNC; p && ipNext, i++){ + anRef[i] = p->nRef; + } + sqlite3WalkExpr(pWalker, pExpr->pLeft); + if( 0==sqlite3ExprCanBeNull(pExpr->pLeft) && !IN_RENAME_OBJECT ){ + testcase( ExprHasProperty(pExpr, EP_OuterON) ); + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + pExpr->u.iValue = (pExpr->op==TK_NOTNULL); + pExpr->flags |= EP_IntValue; + pExpr->op = TK_INTEGER; + + for(i=0, p=pNC; p && ipNext, i++){ + p->nRef = anRef[i]; + } + sqlite3ExprDelete(pParse->db, pExpr->pLeft); + pExpr->pLeft = 0; + } + return WRC_Prune; + } + + /* A column name: ID + ** Or table name and column name: ID.ID + ** Or a database, table and column: ID.ID.ID + ** + ** The TK_ID and TK_OUT cases are combined so that there will only + ** be one call to lookupName(). Then the compiler will in-line + ** lookupName() for a size reduction and performance increase. + */ + case TK_ID: + case TK_DOT: { + const char *zColumn; + const char *zTable; + const char *zDb; + Expr *pRight; + + if( pExpr->op==TK_ID ){ + zDb = 0; + zTable = 0; + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + zColumn = pExpr->u.zToken; + }else{ + Expr *pLeft = pExpr->pLeft; + testcase( pNC->ncFlags & NC_IdxExpr ); + testcase( pNC->ncFlags & NC_GenCol ); + sqlite3ResolveNotValid(pParse, pNC, "the \".\" operator", + NC_IdxExpr|NC_GenCol, 0, pExpr); + pRight = pExpr->pRight; + if( pRight->op==TK_ID ){ + zDb = 0; + }else{ + assert( pRight->op==TK_DOT ); + assert( !ExprHasProperty(pRight, EP_IntValue) ); + zDb = pLeft->u.zToken; + pLeft = pRight->pLeft; + pRight = pRight->pRight; + } + assert( ExprUseUToken(pLeft) && ExprUseUToken(pRight) ); + zTable = pLeft->u.zToken; + zColumn = pRight->u.zToken; + assert( ExprUseYTab(pExpr) ); + if( IN_RENAME_OBJECT ){ + sqlite3RenameTokenRemap(pParse, (void*)pExpr, (void*)pRight); + sqlite3RenameTokenRemap(pParse, (void*)&pExpr->y.pTab, (void*)pLeft); + } + } + return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr); + } + + /* Resolve function names + */ + case TK_FUNCTION: { + ExprList *pList = pExpr->x.pList; /* The argument list */ + int n = pList ? pList->nExpr : 0; /* Number of arguments */ + int no_such_func = 0; /* True if no such function exists */ + int wrong_num_args = 0; /* True if wrong number of arguments */ + int is_agg = 0; /* True if is an aggregate function */ + const char *zId; /* The function name. */ + FuncDef *pDef; /* Information about the function */ + u8 enc = ENC(pParse->db); /* The database encoding */ + int savedAllowFlags = (pNC->ncFlags & (NC_AllowAgg | NC_AllowWin)); +#ifndef SQLITE_OMIT_WINDOWFUNC + Window *pWin = (IsWindowFunc(pExpr) ? pExpr->y.pWin : 0); +#endif + assert( !ExprHasProperty(pExpr, EP_xIsSelect|EP_IntValue) ); + zId = pExpr->u.zToken; + pDef = sqlite3FindFunction(pParse->db, zId, n, enc, 0); + if( pDef==0 ){ + pDef = sqlite3FindFunction(pParse->db, zId, -2, enc, 0); + if( pDef==0 ){ + no_such_func = 1; + }else{ + wrong_num_args = 1; + } + }else{ + is_agg = pDef->xFinalize!=0; + if( pDef->funcFlags & SQLITE_FUNC_UNLIKELY ){ + ExprSetProperty(pExpr, EP_Unlikely); + if( n==2 ){ + pExpr->iTable = exprProbability(pList->a[1].pExpr); + if( pExpr->iTable<0 ){ + sqlite3ErrorMsg(pParse, + "second argument to %#T() must be a " + "constant between 0.0 and 1.0", pExpr); + pNC->nNcErr++; + } + }else{ + /* EVIDENCE-OF: R-61304-29449 The unlikely(X) function is + ** equivalent to likelihood(X, 0.0625). + ** EVIDENCE-OF: R-01283-11636 The unlikely(X) function is + ** short-hand for likelihood(X,0.0625). + ** EVIDENCE-OF: R-36850-34127 The likely(X) function is short-hand + ** for likelihood(X,0.9375). + ** EVIDENCE-OF: R-53436-40973 The likely(X) function is equivalent + ** to likelihood(X,0.9375). */ + /* TUNING: unlikely() probability is 0.0625. likely() is 0.9375 */ + pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120; + } + } +#ifndef SQLITE_OMIT_AUTHORIZATION + { + int auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0,pDef->zName,0); + if( auth!=SQLITE_OK ){ + if( auth==SQLITE_DENY ){ + sqlite3ErrorMsg(pParse, "not authorized to use function: %#T", + pExpr); + pNC->nNcErr++; + } + pExpr->op = TK_NULL; + return WRC_Prune; + } + } +#endif + if( pDef->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG) ){ + /* For the purposes of the EP_ConstFunc flag, date and time + ** functions and other functions that change slowly are considered + ** constant because they are constant for the duration of one query. + ** This allows them to be factored out of inner loops. */ + ExprSetProperty(pExpr,EP_ConstFunc); + } + if( (pDef->funcFlags & SQLITE_FUNC_CONSTANT)==0 ){ + /* Clearly non-deterministic functions like random(), but also + ** date/time functions that use 'now', and other functions like + ** sqlite_version() that might change over time cannot be used + ** in an index or generated column. Curiously, they can be used + ** in a CHECK constraint. SQLServer, MySQL, and PostgreSQL all + ** all this. */ + sqlite3ResolveNotValid(pParse, pNC, "non-deterministic functions", + NC_IdxExpr|NC_PartIdx|NC_GenCol, 0, pExpr); + }else{ + assert( (NC_SelfRef & 0xff)==NC_SelfRef ); /* Must fit in 8 bits */ + pExpr->op2 = pNC->ncFlags & NC_SelfRef; + if( pNC->ncFlags & NC_FromDDL ) ExprSetProperty(pExpr, EP_FromDDL); + } + if( (pDef->funcFlags & SQLITE_FUNC_INTERNAL)!=0 + && pParse->nested==0 + && (pParse->db->mDbFlags & DBFLAG_InternalFunc)==0 + ){ + /* Internal-use-only functions are disallowed unless the + ** SQL is being compiled using sqlite3NestedParse() or + ** the SQLITE_TESTCTRL_INTERNAL_FUNCTIONS test-control has be + ** used to activate internal functions for testing purposes */ + no_such_func = 1; + pDef = 0; + }else + if( (pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE))!=0 + && !IN_RENAME_OBJECT + ){ + sqlite3ExprFunctionUsable(pParse, pExpr, pDef); + } + } + + if( 0==IN_RENAME_OBJECT ){ +#ifndef SQLITE_OMIT_WINDOWFUNC + assert( is_agg==0 || (pDef->funcFlags & SQLITE_FUNC_MINMAX) + || (pDef->xValue==0 && pDef->xInverse==0) + || (pDef->xValue && pDef->xInverse && pDef->xSFunc && pDef->xFinalize) + ); + if( pDef && pDef->xValue==0 && pWin ){ + sqlite3ErrorMsg(pParse, + "%#T() may not be used as a window function", pExpr + ); + pNC->nNcErr++; + }else if( + (is_agg && (pNC->ncFlags & NC_AllowAgg)==0) + || (is_agg && (pDef->funcFlags&SQLITE_FUNC_WINDOW) && !pWin) + || (is_agg && pWin && (pNC->ncFlags & NC_AllowWin)==0) + ){ + const char *zType; + if( (pDef->funcFlags & SQLITE_FUNC_WINDOW) || pWin ){ + zType = "window"; + }else{ + zType = "aggregate"; + } + sqlite3ErrorMsg(pParse, "misuse of %s function %#T()",zType,pExpr); + pNC->nNcErr++; + is_agg = 0; + } +#else + if( (is_agg && (pNC->ncFlags & NC_AllowAgg)==0) ){ + sqlite3ErrorMsg(pParse,"misuse of aggregate function %#T()",pExpr); + pNC->nNcErr++; + is_agg = 0; + } +#endif + else if( no_such_func && pParse->db->init.busy==0 +#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION + && pParse->explain==0 +#endif + ){ + sqlite3ErrorMsg(pParse, "no such function: %#T", pExpr); + pNC->nNcErr++; + }else if( wrong_num_args ){ + sqlite3ErrorMsg(pParse,"wrong number of arguments to function %#T()", + pExpr); + pNC->nNcErr++; + } +#ifndef SQLITE_OMIT_WINDOWFUNC + else if( is_agg==0 && ExprHasProperty(pExpr, EP_WinFunc) ){ + sqlite3ErrorMsg(pParse, + "FILTER may not be used with non-aggregate %#T()", + pExpr + ); + pNC->nNcErr++; + } +#endif + if( is_agg ){ + /* Window functions may not be arguments of aggregate functions. + ** Or arguments of other window functions. But aggregate functions + ** may be arguments for window functions. */ +#ifndef SQLITE_OMIT_WINDOWFUNC + pNC->ncFlags &= ~(NC_AllowWin | (!pWin ? NC_AllowAgg : 0)); +#else + pNC->ncFlags &= ~NC_AllowAgg; +#endif + } + } +#ifndef SQLITE_OMIT_WINDOWFUNC + else if( ExprHasProperty(pExpr, EP_WinFunc) ){ + is_agg = 1; + } +#endif + sqlite3WalkExprList(pWalker, pList); + if( is_agg ){ +#ifndef SQLITE_OMIT_WINDOWFUNC + if( pWin ){ + Select *pSel = pNC->pWinSelect; + assert( pWin==0 || (ExprUseYWin(pExpr) && pWin==pExpr->y.pWin) ); + if( IN_RENAME_OBJECT==0 ){ + sqlite3WindowUpdate(pParse, pSel ? pSel->pWinDefn : 0, pWin, pDef); + if( pParse->db->mallocFailed ) break; + } + sqlite3WalkExprList(pWalker, pWin->pPartition); + sqlite3WalkExprList(pWalker, pWin->pOrderBy); + sqlite3WalkExpr(pWalker, pWin->pFilter); + sqlite3WindowLink(pSel, pWin); + pNC->ncFlags |= NC_HasWin; + }else +#endif /* SQLITE_OMIT_WINDOWFUNC */ + { + NameContext *pNC2; /* For looping up thru outer contexts */ + pExpr->op = TK_AGG_FUNCTION; + pExpr->op2 = 0; +#ifndef SQLITE_OMIT_WINDOWFUNC + if( ExprHasProperty(pExpr, EP_WinFunc) ){ + sqlite3WalkExpr(pWalker, pExpr->y.pWin->pFilter); + } +#endif + pNC2 = pNC; + while( pNC2 + && sqlite3ReferencesSrcList(pParse, pExpr, pNC2->pSrcList)==0 + ){ + pExpr->op2++; + pNC2 = pNC2->pNext; + } + assert( pDef!=0 || IN_RENAME_OBJECT ); + if( pNC2 && pDef ){ + assert( SQLITE_FUNC_MINMAX==NC_MinMaxAgg ); + assert( SQLITE_FUNC_ANYORDER==NC_OrderAgg ); + testcase( (pDef->funcFlags & SQLITE_FUNC_MINMAX)!=0 ); + testcase( (pDef->funcFlags & SQLITE_FUNC_ANYORDER)!=0 ); + pNC2->ncFlags |= NC_HasAgg + | ((pDef->funcFlags^SQLITE_FUNC_ANYORDER) + & (SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER)); + } + } + pNC->ncFlags |= savedAllowFlags; + } + /* FIX ME: Compute pExpr->affinity based on the expected return + ** type of the function + */ + return WRC_Prune; + } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_SELECT: + case TK_EXISTS: testcase( pExpr->op==TK_EXISTS ); +#endif + case TK_IN: { + testcase( pExpr->op==TK_IN ); + if( ExprUseXSelect(pExpr) ){ + int nRef = pNC->nRef; + testcase( pNC->ncFlags & NC_IsCheck ); + testcase( pNC->ncFlags & NC_PartIdx ); + testcase( pNC->ncFlags & NC_IdxExpr ); + testcase( pNC->ncFlags & NC_GenCol ); + if( pNC->ncFlags & NC_SelfRef ){ + notValidImpl(pParse, pNC, "subqueries", pExpr, pExpr); + }else{ + sqlite3WalkSelect(pWalker, pExpr->x.pSelect); + } + assert( pNC->nRef>=nRef ); + if( nRef!=pNC->nRef ){ + ExprSetProperty(pExpr, EP_VarSelect); + } + pNC->ncFlags |= NC_Subquery; + } + break; + } + case TK_VARIABLE: { + testcase( pNC->ncFlags & NC_IsCheck ); + testcase( pNC->ncFlags & NC_PartIdx ); + testcase( pNC->ncFlags & NC_IdxExpr ); + testcase( pNC->ncFlags & NC_GenCol ); + sqlite3ResolveNotValid(pParse, pNC, "parameters", + NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol, pExpr, pExpr); + break; + } + case TK_IS: + case TK_ISNOT: { + Expr *pRight = sqlite3ExprSkipCollateAndLikely(pExpr->pRight); + assert( !ExprHasProperty(pExpr, EP_Reduced) ); + /* Handle special cases of "x IS TRUE", "x IS FALSE", "x IS NOT TRUE", + ** and "x IS NOT FALSE". */ + if( ALWAYS(pRight) && (pRight->op==TK_ID || pRight->op==TK_TRUEFALSE) ){ + int rc = resolveExprStep(pWalker, pRight); + if( rc==WRC_Abort ) return WRC_Abort; + if( pRight->op==TK_TRUEFALSE ){ + pExpr->op2 = pExpr->op; + pExpr->op = TK_TRUTH; + return WRC_Continue; + } + } + /* no break */ deliberate_fall_through + } + case TK_BETWEEN: + case TK_EQ: + case TK_NE: + case TK_LT: + case TK_LE: + case TK_GT: + case TK_GE: { + int nLeft, nRight; + if( pParse->db->mallocFailed ) break; + assert( pExpr->pLeft!=0 ); + nLeft = sqlite3ExprVectorSize(pExpr->pLeft); + if( pExpr->op==TK_BETWEEN ){ + assert( ExprUseXList(pExpr) ); + nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[0].pExpr); + if( nRight==nLeft ){ + nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[1].pExpr); + } + }else{ + assert( pExpr->pRight!=0 ); + nRight = sqlite3ExprVectorSize(pExpr->pRight); + } + if( nLeft!=nRight ){ + testcase( pExpr->op==TK_EQ ); + testcase( pExpr->op==TK_NE ); + testcase( pExpr->op==TK_LT ); + testcase( pExpr->op==TK_LE ); + testcase( pExpr->op==TK_GT ); + testcase( pExpr->op==TK_GE ); + testcase( pExpr->op==TK_IS ); + testcase( pExpr->op==TK_ISNOT ); + testcase( pExpr->op==TK_BETWEEN ); + sqlite3ErrorMsg(pParse, "row value misused"); + sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr); + } + break; + } + } + assert( pParse->db->mallocFailed==0 || pParse->nErr!=0 ); + return pParse->nErr ? WRC_Abort : WRC_Continue; +} + +/* +** pEList is a list of expressions which are really the result set of the +** a SELECT statement. pE is a term in an ORDER BY or GROUP BY clause. +** This routine checks to see if pE is a simple identifier which corresponds +** to the AS-name of one of the terms of the expression list. If it is, +** this routine return an integer between 1 and N where N is the number of +** elements in pEList, corresponding to the matching entry. If there is +** no match, or if pE is not a simple identifier, then this routine +** return 0. +** +** pEList has been resolved. pE has not. +*/ +static int resolveAsName( + Parse *pParse, /* Parsing context for error messages */ + ExprList *pEList, /* List of expressions to scan */ + Expr *pE /* Expression we are trying to match */ +){ + int i; /* Loop counter */ + + UNUSED_PARAMETER(pParse); + + if( pE->op==TK_ID ){ + const char *zCol; + assert( !ExprHasProperty(pE, EP_IntValue) ); + zCol = pE->u.zToken; + for(i=0; inExpr; i++){ + if( pEList->a[i].fg.eEName==ENAME_NAME + && sqlite3_stricmp(pEList->a[i].zEName, zCol)==0 + ){ + return i+1; + } + } + } + return 0; +} + +/* +** pE is a pointer to an expression which is a single term in the +** ORDER BY of a compound SELECT. The expression has not been +** name resolved. +** +** At the point this routine is called, we already know that the +** ORDER BY term is not an integer index into the result set. That +** case is handled by the calling routine. +** +** Attempt to match pE against result set columns in the left-most +** SELECT statement. Return the index i of the matching column, +** as an indication to the caller that it should sort by the i-th column. +** The left-most column is 1. In other words, the value returned is the +** same integer value that would be used in the SQL statement to indicate +** the column. +** +** If there is no match, return 0. Return -1 if an error occurs. +*/ +static int resolveOrderByTermToExprList( + Parse *pParse, /* Parsing context for error messages */ + Select *pSelect, /* The SELECT statement with the ORDER BY clause */ + Expr *pE /* The specific ORDER BY term */ +){ + int i; /* Loop counter */ + ExprList *pEList; /* The columns of the result set */ + NameContext nc; /* Name context for resolving pE */ + sqlite3 *db; /* Database connection */ + int rc; /* Return code from subprocedures */ + u8 savedSuppErr; /* Saved value of db->suppressErr */ + + assert( sqlite3ExprIsInteger(pE, &i)==0 ); + pEList = pSelect->pEList; + + /* Resolve all names in the ORDER BY term expression + */ + memset(&nc, 0, sizeof(nc)); + nc.pParse = pParse; + nc.pSrcList = pSelect->pSrc; + nc.uNC.pEList = pEList; + nc.ncFlags = NC_AllowAgg|NC_UEList|NC_NoSelect; + nc.nNcErr = 0; + db = pParse->db; + savedSuppErr = db->suppressErr; + db->suppressErr = 1; + rc = sqlite3ResolveExprNames(&nc, pE); + db->suppressErr = savedSuppErr; + if( rc ) return 0; + + /* Try to match the ORDER BY expression against an expression + ** in the result set. Return an 1-based index of the matching + ** result-set entry. + */ + for(i=0; inExpr; i++){ + if( sqlite3ExprCompare(0, pEList->a[i].pExpr, pE, -1)<2 ){ + return i+1; + } + } + + /* If no match, return 0. */ + return 0; +} + +/* +** Generate an ORDER BY or GROUP BY term out-of-range error. +*/ +static void resolveOutOfRangeError( + Parse *pParse, /* The error context into which to write the error */ + const char *zType, /* "ORDER" or "GROUP" */ + int i, /* The index (1-based) of the term out of range */ + int mx, /* Largest permissible value of i */ + Expr *pError /* Associate the error with the expression */ +){ + sqlite3ErrorMsg(pParse, + "%r %s BY term out of range - should be " + "between 1 and %d", i, zType, mx); + sqlite3RecordErrorOffsetOfExpr(pParse->db, pError); +} + +/* +** Analyze the ORDER BY clause in a compound SELECT statement. Modify +** each term of the ORDER BY clause is a constant integer between 1 +** and N where N is the number of columns in the compound SELECT. +** +** ORDER BY terms that are already an integer between 1 and N are +** unmodified. ORDER BY terms that are integers outside the range of +** 1 through N generate an error. ORDER BY terms that are expressions +** are matched against result set expressions of compound SELECT +** beginning with the left-most SELECT and working toward the right. +** At the first match, the ORDER BY expression is transformed into +** the integer column number. +** +** Return the number of errors seen. +*/ +static int resolveCompoundOrderBy( + Parse *pParse, /* Parsing context. Leave error messages here */ + Select *pSelect /* The SELECT statement containing the ORDER BY */ +){ + int i; + ExprList *pOrderBy; + ExprList *pEList; + sqlite3 *db; + int moreToDo = 1; + + pOrderBy = pSelect->pOrderBy; + if( pOrderBy==0 ) return 0; + db = pParse->db; + if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){ + sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause"); + return 1; + } + for(i=0; inExpr; i++){ + pOrderBy->a[i].fg.done = 0; + } + pSelect->pNext = 0; + while( pSelect->pPrior ){ + pSelect->pPrior->pNext = pSelect; + pSelect = pSelect->pPrior; + } + while( pSelect && moreToDo ){ + struct ExprList_item *pItem; + moreToDo = 0; + pEList = pSelect->pEList; + assert( pEList!=0 ); + for(i=0, pItem=pOrderBy->a; inExpr; i++, pItem++){ + int iCol = -1; + Expr *pE, *pDup; + if( pItem->fg.done ) continue; + pE = sqlite3ExprSkipCollateAndLikely(pItem->pExpr); + if( NEVER(pE==0) ) continue; + if( sqlite3ExprIsInteger(pE, &iCol) ){ + if( iCol<=0 || iCol>pEList->nExpr ){ + resolveOutOfRangeError(pParse, "ORDER", i+1, pEList->nExpr, pE); + return 1; + } + }else{ + iCol = resolveAsName(pParse, pEList, pE); + if( iCol==0 ){ + /* Now test if expression pE matches one of the values returned + ** by pSelect. In the usual case this is done by duplicating the + ** expression, resolving any symbols in it, and then comparing + ** it against each expression returned by the SELECT statement. + ** Once the comparisons are finished, the duplicate expression + ** is deleted. + ** + ** If this is running as part of an ALTER TABLE operation and + ** the symbols resolve successfully, also resolve the symbols in the + ** actual expression. This allows the code in alter.c to modify + ** column references within the ORDER BY expression as required. */ + pDup = sqlite3ExprDup(db, pE, 0); + if( !db->mallocFailed ){ + assert(pDup); + iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup); + if( IN_RENAME_OBJECT && iCol>0 ){ + resolveOrderByTermToExprList(pParse, pSelect, pE); + } + } + sqlite3ExprDelete(db, pDup); + } + } + if( iCol>0 ){ + /* Convert the ORDER BY term into an integer column number iCol, + ** taking care to preserve the COLLATE clause if it exists. */ + if( !IN_RENAME_OBJECT ){ + Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0); + if( pNew==0 ) return 1; + pNew->flags |= EP_IntValue; + pNew->u.iValue = iCol; + if( pItem->pExpr==pE ){ + pItem->pExpr = pNew; + }else{ + Expr *pParent = pItem->pExpr; + assert( pParent->op==TK_COLLATE ); + while( pParent->pLeft->op==TK_COLLATE ) pParent = pParent->pLeft; + assert( pParent->pLeft==pE ); + pParent->pLeft = pNew; + } + sqlite3ExprDelete(db, pE); + pItem->u.x.iOrderByCol = (u16)iCol; + } + pItem->fg.done = 1; + }else{ + moreToDo = 1; + } + } + pSelect = pSelect->pNext; + } + for(i=0; inExpr; i++){ + if( pOrderBy->a[i].fg.done==0 ){ + sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any " + "column in the result set", i+1); + return 1; + } + } + return 0; +} + +/* +** Check every term in the ORDER BY or GROUP BY clause pOrderBy of +** the SELECT statement pSelect. If any term is reference to a +** result set expression (as determined by the ExprList.a.u.x.iOrderByCol +** field) then convert that term into a copy of the corresponding result set +** column. +** +** If any errors are detected, add an error message to pParse and +** return non-zero. Return zero if no errors are seen. +*/ +SQLITE_PRIVATE int sqlite3ResolveOrderGroupBy( + Parse *pParse, /* Parsing context. Leave error messages here */ + Select *pSelect, /* The SELECT statement containing the clause */ + ExprList *pOrderBy, /* The ORDER BY or GROUP BY clause to be processed */ + const char *zType /* "ORDER" or "GROUP" */ +){ + int i; + sqlite3 *db = pParse->db; + ExprList *pEList; + struct ExprList_item *pItem; + + if( pOrderBy==0 || pParse->db->mallocFailed || IN_RENAME_OBJECT ) return 0; + if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){ + sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType); + return 1; + } + pEList = pSelect->pEList; + assert( pEList!=0 ); /* sqlite3SelectNew() guarantees this */ + for(i=0, pItem=pOrderBy->a; inExpr; i++, pItem++){ + if( pItem->u.x.iOrderByCol ){ + if( pItem->u.x.iOrderByCol>pEList->nExpr ){ + resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr, 0); + return 1; + } + resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr,0); + } + } + return 0; +} + +#ifndef SQLITE_OMIT_WINDOWFUNC +/* +** Walker callback for windowRemoveExprFromSelect(). +*/ +static int resolveRemoveWindowsCb(Walker *pWalker, Expr *pExpr){ + UNUSED_PARAMETER(pWalker); + if( ExprHasProperty(pExpr, EP_WinFunc) ){ + Window *pWin = pExpr->y.pWin; + sqlite3WindowUnlinkFromSelect(pWin); + } + return WRC_Continue; +} + +/* +** Remove any Window objects owned by the expression pExpr from the +** Select.pWin list of Select object pSelect. +*/ +static void windowRemoveExprFromSelect(Select *pSelect, Expr *pExpr){ + if( pSelect->pWin ){ + Walker sWalker; + memset(&sWalker, 0, sizeof(Walker)); + sWalker.xExprCallback = resolveRemoveWindowsCb; + sWalker.u.pSelect = pSelect; + sqlite3WalkExpr(&sWalker, pExpr); + } +} +#else +# define windowRemoveExprFromSelect(a, b) +#endif /* SQLITE_OMIT_WINDOWFUNC */ + +/* +** pOrderBy is an ORDER BY or GROUP BY clause in SELECT statement pSelect. +** The Name context of the SELECT statement is pNC. zType is either +** "ORDER" or "GROUP" depending on which type of clause pOrderBy is. +** +** This routine resolves each term of the clause into an expression. +** If the order-by term is an integer I between 1 and N (where N is the +** number of columns in the result set of the SELECT) then the expression +** in the resolution is a copy of the I-th result-set expression. If +** the order-by term is an identifier that corresponds to the AS-name of +** a result-set expression, then the term resolves to a copy of the +** result-set expression. Otherwise, the expression is resolved in +** the usual way - using sqlite3ResolveExprNames(). +** +** This routine returns the number of errors. If errors occur, then +** an appropriate error message might be left in pParse. (OOM errors +** excepted.) +*/ +static int resolveOrderGroupBy( + NameContext *pNC, /* The name context of the SELECT statement */ + Select *pSelect, /* The SELECT statement holding pOrderBy */ + ExprList *pOrderBy, /* An ORDER BY or GROUP BY clause to resolve */ + const char *zType /* Either "ORDER" or "GROUP", as appropriate */ +){ + int i, j; /* Loop counters */ + int iCol; /* Column number */ + struct ExprList_item *pItem; /* A term of the ORDER BY clause */ + Parse *pParse; /* Parsing context */ + int nResult; /* Number of terms in the result set */ + + assert( pOrderBy!=0 ); + nResult = pSelect->pEList->nExpr; + pParse = pNC->pParse; + for(i=0, pItem=pOrderBy->a; inExpr; i++, pItem++){ + Expr *pE = pItem->pExpr; + Expr *pE2 = sqlite3ExprSkipCollateAndLikely(pE); + if( NEVER(pE2==0) ) continue; + if( zType[0]!='G' ){ + iCol = resolveAsName(pParse, pSelect->pEList, pE2); + if( iCol>0 ){ + /* If an AS-name match is found, mark this ORDER BY column as being + ** a copy of the iCol-th result-set column. The subsequent call to + ** sqlite3ResolveOrderGroupBy() will convert the expression to a + ** copy of the iCol-th result-set expression. */ + pItem->u.x.iOrderByCol = (u16)iCol; + continue; + } + } + if( sqlite3ExprIsInteger(pE2, &iCol) ){ + /* The ORDER BY term is an integer constant. Again, set the column + ** number so that sqlite3ResolveOrderGroupBy() will convert the + ** order-by term to a copy of the result-set expression */ + if( iCol<1 || iCol>0xffff ){ + resolveOutOfRangeError(pParse, zType, i+1, nResult, pE2); + return 1; + } + pItem->u.x.iOrderByCol = (u16)iCol; + continue; + } + + /* Otherwise, treat the ORDER BY term as an ordinary expression */ + pItem->u.x.iOrderByCol = 0; + if( sqlite3ResolveExprNames(pNC, pE) ){ + return 1; + } + for(j=0; jpEList->nExpr; j++){ + if( sqlite3ExprCompare(0, pE, pSelect->pEList->a[j].pExpr, -1)==0 ){ + /* Since this expresion is being changed into a reference + ** to an identical expression in the result set, remove all Window + ** objects belonging to the expression from the Select.pWin list. */ + windowRemoveExprFromSelect(pSelect, pE); + pItem->u.x.iOrderByCol = j+1; + } + } + } + return sqlite3ResolveOrderGroupBy(pParse, pSelect, pOrderBy, zType); +} + +/* +** Resolve names in the SELECT statement p and all of its descendants. +*/ +static int resolveSelectStep(Walker *pWalker, Select *p){ + NameContext *pOuterNC; /* Context that contains this SELECT */ + NameContext sNC; /* Name context of this SELECT */ + int isCompound; /* True if p is a compound select */ + int nCompound; /* Number of compound terms processed so far */ + Parse *pParse; /* Parsing context */ + int i; /* Loop counter */ + ExprList *pGroupBy; /* The GROUP BY clause */ + Select *pLeftmost; /* Left-most of SELECT of a compound */ + sqlite3 *db; /* Database connection */ + + + assert( p!=0 ); + if( p->selFlags & SF_Resolved ){ + return WRC_Prune; + } + pOuterNC = pWalker->u.pNC; + pParse = pWalker->pParse; + db = pParse->db; + + /* Normally sqlite3SelectExpand() will be called first and will have + ** already expanded this SELECT. However, if this is a subquery within + ** an expression, sqlite3ResolveExprNames() will be called without a + ** prior call to sqlite3SelectExpand(). When that happens, let + ** sqlite3SelectPrep() do all of the processing for this SELECT. + ** sqlite3SelectPrep() will invoke both sqlite3SelectExpand() and + ** this routine in the correct order. + */ + if( (p->selFlags & SF_Expanded)==0 ){ + sqlite3SelectPrep(pParse, p, pOuterNC); + return pParse->nErr ? WRC_Abort : WRC_Prune; + } + + isCompound = p->pPrior!=0; + nCompound = 0; + pLeftmost = p; + while( p ){ + assert( (p->selFlags & SF_Expanded)!=0 ); + assert( (p->selFlags & SF_Resolved)==0 ); + assert( db->suppressErr==0 ); /* SF_Resolved not set if errors suppressed */ + p->selFlags |= SF_Resolved; + + + /* Resolve the expressions in the LIMIT and OFFSET clauses. These + ** are not allowed to refer to any names, so pass an empty NameContext. + */ + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + sNC.pWinSelect = p; + if( sqlite3ResolveExprNames(&sNC, p->pLimit) ){ + return WRC_Abort; + } + + /* If the SF_Converted flags is set, then this Select object was + ** was created by the convertCompoundSelectToSubquery() function. + ** In this case the ORDER BY clause (p->pOrderBy) should be resolved + ** as if it were part of the sub-query, not the parent. This block + ** moves the pOrderBy down to the sub-query. It will be moved back + ** after the names have been resolved. */ + if( p->selFlags & SF_Converted ){ + Select *pSub = p->pSrc->a[0].pSelect; + assert( p->pSrc->nSrc==1 && p->pOrderBy ); + assert( pSub->pPrior && pSub->pOrderBy==0 ); + pSub->pOrderBy = p->pOrderBy; + p->pOrderBy = 0; + } + + /* Recursively resolve names in all subqueries in the FROM clause + */ + for(i=0; ipSrc->nSrc; i++){ + SrcItem *pItem = &p->pSrc->a[i]; + if( pItem->pSelect && (pItem->pSelect->selFlags & SF_Resolved)==0 ){ + int nRef = pOuterNC ? pOuterNC->nRef : 0; + const char *zSavedContext = pParse->zAuthContext; + + if( pItem->zName ) pParse->zAuthContext = pItem->zName; + sqlite3ResolveSelectNames(pParse, pItem->pSelect, pOuterNC); + pParse->zAuthContext = zSavedContext; + if( pParse->nErr ) return WRC_Abort; + assert( db->mallocFailed==0 ); + + /* If the number of references to the outer context changed when + ** expressions in the sub-select were resolved, the sub-select + ** is correlated. It is not required to check the refcount on any + ** but the innermost outer context object, as lookupName() increments + ** the refcount on all contexts between the current one and the + ** context containing the column when it resolves a name. */ + if( pOuterNC ){ + assert( pItem->fg.isCorrelated==0 && pOuterNC->nRef>=nRef ); + pItem->fg.isCorrelated = (pOuterNC->nRef>nRef); + } + } + } + + /* Set up the local name-context to pass to sqlite3ResolveExprNames() to + ** resolve the result-set expression list. + */ + sNC.ncFlags = NC_AllowAgg|NC_AllowWin; + sNC.pSrcList = p->pSrc; + sNC.pNext = pOuterNC; + + /* Resolve names in the result set. */ + if( sqlite3ResolveExprListNames(&sNC, p->pEList) ) return WRC_Abort; + sNC.ncFlags &= ~NC_AllowWin; + + /* If there are no aggregate functions in the result-set, and no GROUP BY + ** expression, do not allow aggregates in any of the other expressions. + */ + assert( (p->selFlags & SF_Aggregate)==0 ); + pGroupBy = p->pGroupBy; + if( pGroupBy || (sNC.ncFlags & NC_HasAgg)!=0 ){ + assert( NC_MinMaxAgg==SF_MinMaxAgg ); + assert( NC_OrderAgg==SF_OrderByReqd ); + p->selFlags |= SF_Aggregate | (sNC.ncFlags&(NC_MinMaxAgg|NC_OrderAgg)); + }else{ + sNC.ncFlags &= ~NC_AllowAgg; + } + + /* Add the output column list to the name-context before parsing the + ** other expressions in the SELECT statement. This is so that + ** expressions in the WHERE clause (etc.) can refer to expressions by + ** aliases in the result set. + ** + ** Minor point: If this is the case, then the expression will be + ** re-evaluated for each reference to it. + */ + assert( (sNC.ncFlags & (NC_UAggInfo|NC_UUpsert|NC_UBaseReg))==0 ); + sNC.uNC.pEList = p->pEList; + sNC.ncFlags |= NC_UEList; + if( p->pHaving ){ + if( (p->selFlags & SF_Aggregate)==0 ){ + sqlite3ErrorMsg(pParse, "HAVING clause on a non-aggregate query"); + return WRC_Abort; + } + if( sqlite3ResolveExprNames(&sNC, p->pHaving) ) return WRC_Abort; + } + if( sqlite3ResolveExprNames(&sNC, p->pWhere) ) return WRC_Abort; + + /* Resolve names in table-valued-function arguments */ + for(i=0; ipSrc->nSrc; i++){ + SrcItem *pItem = &p->pSrc->a[i]; + if( pItem->fg.isTabFunc + && sqlite3ResolveExprListNames(&sNC, pItem->u1.pFuncArg) + ){ + return WRC_Abort; + } + } + +#ifndef SQLITE_OMIT_WINDOWFUNC + if( IN_RENAME_OBJECT ){ + Window *pWin; + for(pWin=p->pWinDefn; pWin; pWin=pWin->pNextWin){ + if( sqlite3ResolveExprListNames(&sNC, pWin->pOrderBy) + || sqlite3ResolveExprListNames(&sNC, pWin->pPartition) + ){ + return WRC_Abort; + } + } + } +#endif + + /* The ORDER BY and GROUP BY clauses may not refer to terms in + ** outer queries + */ + sNC.pNext = 0; + sNC.ncFlags |= NC_AllowAgg|NC_AllowWin; + + /* If this is a converted compound query, move the ORDER BY clause from + ** the sub-query back to the parent query. At this point each term + ** within the ORDER BY clause has been transformed to an integer value. + ** These integers will be replaced by copies of the corresponding result + ** set expressions by the call to resolveOrderGroupBy() below. */ + if( p->selFlags & SF_Converted ){ + Select *pSub = p->pSrc->a[0].pSelect; + p->pOrderBy = pSub->pOrderBy; + pSub->pOrderBy = 0; + } + + /* Process the ORDER BY clause for singleton SELECT statements. + ** The ORDER BY clause for compounds SELECT statements is handled + ** below, after all of the result-sets for all of the elements of + ** the compound have been resolved. + ** + ** If there is an ORDER BY clause on a term of a compound-select other + ** than the right-most term, then that is a syntax error. But the error + ** is not detected until much later, and so we need to go ahead and + ** resolve those symbols on the incorrect ORDER BY for consistency. + */ + if( p->pOrderBy!=0 + && isCompound<=nCompound /* Defer right-most ORDER BY of a compound */ + && resolveOrderGroupBy(&sNC, p, p->pOrderBy, "ORDER") + ){ + return WRC_Abort; + } + if( db->mallocFailed ){ + return WRC_Abort; + } + sNC.ncFlags &= ~NC_AllowWin; + + /* Resolve the GROUP BY clause. At the same time, make sure + ** the GROUP BY clause does not contain aggregate functions. + */ + if( pGroupBy ){ + struct ExprList_item *pItem; + + if( resolveOrderGroupBy(&sNC, p, pGroupBy, "GROUP") || db->mallocFailed ){ + return WRC_Abort; + } + for(i=0, pItem=pGroupBy->a; inExpr; i++, pItem++){ + if( ExprHasProperty(pItem->pExpr, EP_Agg) ){ + sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in " + "the GROUP BY clause"); + return WRC_Abort; + } + } + } + + /* If this is part of a compound SELECT, check that it has the right + ** number of expressions in the select list. */ + if( p->pNext && p->pEList->nExpr!=p->pNext->pEList->nExpr ){ + sqlite3SelectWrongNumTermsError(pParse, p->pNext); + return WRC_Abort; + } + + /* Advance to the next term of the compound + */ + p = p->pPrior; + nCompound++; + } + + /* Resolve the ORDER BY on a compound SELECT after all terms of + ** the compound have been resolved. + */ + if( isCompound && resolveCompoundOrderBy(pParse, pLeftmost) ){ + return WRC_Abort; + } + + return WRC_Prune; +} + +/* +** This routine walks an expression tree and resolves references to +** table columns and result-set columns. At the same time, do error +** checking on function usage and set a flag if any aggregate functions +** are seen. +** +** To resolve table columns references we look for nodes (or subtrees) of the +** form X.Y.Z or Y.Z or just Z where +** +** X: The name of a database. Ex: "main" or "temp" or +** the symbolic name assigned to an ATTACH-ed database. +** +** Y: The name of a table in a FROM clause. Or in a trigger +** one of the special names "old" or "new". +** +** Z: The name of a column in table Y. +** +** The node at the root of the subtree is modified as follows: +** +** Expr.op Changed to TK_COLUMN +** Expr.pTab Points to the Table object for X.Y +** Expr.iColumn The column index in X.Y. -1 for the rowid. +** Expr.iTable The VDBE cursor number for X.Y +** +** +** To resolve result-set references, look for expression nodes of the +** form Z (with no X and Y prefix) where the Z matches the right-hand +** size of an AS clause in the result-set of a SELECT. The Z expression +** is replaced by a copy of the left-hand side of the result-set expression. +** Table-name and function resolution occurs on the substituted expression +** tree. For example, in: +** +** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY x; +** +** The "x" term of the order by is replaced by "a+b" to render: +** +** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY a+b; +** +** Function calls are checked to make sure that the function is +** defined and that the correct number of arguments are specified. +** If the function is an aggregate function, then the NC_HasAgg flag is +** set and the opcode is changed from TK_FUNCTION to TK_AGG_FUNCTION. +** If an expression contains aggregate functions then the EP_Agg +** property on the expression is set. +** +** An error message is left in pParse if anything is amiss. The number +** if errors is returned. +*/ +SQLITE_PRIVATE int sqlite3ResolveExprNames( + NameContext *pNC, /* Namespace to resolve expressions in. */ + Expr *pExpr /* The expression to be analyzed. */ +){ + int savedHasAgg; + Walker w; + + if( pExpr==0 ) return SQLITE_OK; + savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg); + pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg); + w.pParse = pNC->pParse; + w.xExprCallback = resolveExprStep; + w.xSelectCallback = (pNC->ncFlags & NC_NoSelect) ? 0 : resolveSelectStep; + w.xSelectCallback2 = 0; + w.u.pNC = pNC; +#if SQLITE_MAX_EXPR_DEPTH>0 + w.pParse->nHeight += pExpr->nHeight; + if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){ + return SQLITE_ERROR; + } +#endif + sqlite3WalkExpr(&w, pExpr); +#if SQLITE_MAX_EXPR_DEPTH>0 + w.pParse->nHeight -= pExpr->nHeight; +#endif + assert( EP_Agg==NC_HasAgg ); + assert( EP_Win==NC_HasWin ); + testcase( pNC->ncFlags & NC_HasAgg ); + testcase( pNC->ncFlags & NC_HasWin ); + ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) ); + pNC->ncFlags |= savedHasAgg; + return pNC->nNcErr>0 || w.pParse->nErr>0; +} + +/* +** Resolve all names for all expression in an expression list. This is +** just like sqlite3ResolveExprNames() except that it works for an expression +** list rather than a single expression. +*/ +SQLITE_PRIVATE int sqlite3ResolveExprListNames( + NameContext *pNC, /* Namespace to resolve expressions in. */ + ExprList *pList /* The expression list to be analyzed. */ +){ + int i; + int savedHasAgg = 0; + Walker w; + if( pList==0 ) return WRC_Continue; + w.pParse = pNC->pParse; + w.xExprCallback = resolveExprStep; + w.xSelectCallback = resolveSelectStep; + w.xSelectCallback2 = 0; + w.u.pNC = pNC; + savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg); + pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg); + for(i=0; inExpr; i++){ + Expr *pExpr = pList->a[i].pExpr; + if( pExpr==0 ) continue; +#if SQLITE_MAX_EXPR_DEPTH>0 + w.pParse->nHeight += pExpr->nHeight; + if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){ + return WRC_Abort; + } +#endif + sqlite3WalkExpr(&w, pExpr); +#if SQLITE_MAX_EXPR_DEPTH>0 + w.pParse->nHeight -= pExpr->nHeight; +#endif + assert( EP_Agg==NC_HasAgg ); + assert( EP_Win==NC_HasWin ); + testcase( pNC->ncFlags & NC_HasAgg ); + testcase( pNC->ncFlags & NC_HasWin ); + if( pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg) ){ + ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) ); + savedHasAgg |= pNC->ncFlags & + (NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg); + pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin|NC_OrderAgg); + } + if( w.pParse->nErr>0 ) return WRC_Abort; + } + pNC->ncFlags |= savedHasAgg; + return WRC_Continue; +} + +/* +** Resolve all names in all expressions of a SELECT and in all +** decendents of the SELECT, including compounds off of p->pPrior, +** subqueries in expressions, and subqueries used as FROM clause +** terms. +** +** See sqlite3ResolveExprNames() for a description of the kinds of +** transformations that occur. +** +** All SELECT statements should have been expanded using +** sqlite3SelectExpand() prior to invoking this routine. +*/ +SQLITE_PRIVATE void sqlite3ResolveSelectNames( + Parse *pParse, /* The parser context */ + Select *p, /* The SELECT statement being coded. */ + NameContext *pOuterNC /* Name context for parent SELECT statement */ +){ + Walker w; + + assert( p!=0 ); + w.xExprCallback = resolveExprStep; + w.xSelectCallback = resolveSelectStep; + w.xSelectCallback2 = 0; + w.pParse = pParse; + w.u.pNC = pOuterNC; + sqlite3WalkSelect(&w, p); +} + +/* +** Resolve names in expressions that can only reference a single table +** or which cannot reference any tables at all. Examples: +** +** "type" flag +** ------------ +** (1) CHECK constraints NC_IsCheck +** (2) WHERE clauses on partial indices NC_PartIdx +** (3) Expressions in indexes on expressions NC_IdxExpr +** (4) Expression arguments to VACUUM INTO. 0 +** (5) GENERATED ALWAYS as expressions NC_GenCol +** +** In all cases except (4), the Expr.iTable value for Expr.op==TK_COLUMN +** nodes of the expression is set to -1 and the Expr.iColumn value is +** set to the column number. In case (4), TK_COLUMN nodes cause an error. +** +** Any errors cause an error message to be set in pParse. +*/ +SQLITE_PRIVATE int sqlite3ResolveSelfReference( + Parse *pParse, /* Parsing context */ + Table *pTab, /* The table being referenced, or NULL */ + int type, /* NC_IsCheck, NC_PartIdx, NC_IdxExpr, NC_GenCol, or 0 */ + Expr *pExpr, /* Expression to resolve. May be NULL. */ + ExprList *pList /* Expression list to resolve. May be NULL. */ +){ + SrcList sSrc; /* Fake SrcList for pParse->pNewTable */ + NameContext sNC; /* Name context for pParse->pNewTable */ + int rc; + + assert( type==0 || pTab!=0 ); + assert( type==NC_IsCheck || type==NC_PartIdx || type==NC_IdxExpr + || type==NC_GenCol || pTab==0 ); + memset(&sNC, 0, sizeof(sNC)); + memset(&sSrc, 0, sizeof(sSrc)); + if( pTab ){ + sSrc.nSrc = 1; + sSrc.a[0].zName = pTab->zName; + sSrc.a[0].pTab = pTab; + sSrc.a[0].iCursor = -1; + if( pTab->pSchema!=pParse->db->aDb[1].pSchema ){ + /* Cause EP_FromDDL to be set on TK_FUNCTION nodes of non-TEMP + ** schema elements */ + type |= NC_FromDDL; + } + } + sNC.pParse = pParse; + sNC.pSrcList = &sSrc; + sNC.ncFlags = type | NC_IsDDL; + if( (rc = sqlite3ResolveExprNames(&sNC, pExpr))!=SQLITE_OK ) return rc; + if( pList ) rc = sqlite3ResolveExprListNames(&sNC, pList); + return rc; +} + +/************** End of resolve.c *********************************************/ +/************** Begin file expr.c ********************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains routines used for analyzing expressions and +** for generating VDBE code that evaluates expressions in SQLite. +*/ +/* #include "sqliteInt.h" */ + +/* Forward declarations */ +static void exprCodeBetween(Parse*,Expr*,int,void(*)(Parse*,Expr*,int,int),int); +static int exprCodeVector(Parse *pParse, Expr *p, int *piToFree); + +/* +** Return the affinity character for a single column of a table. +*/ +SQLITE_PRIVATE char sqlite3TableColumnAffinity(const Table *pTab, int iCol){ + if( iCol<0 || NEVER(iCol>=pTab->nCol) ) return SQLITE_AFF_INTEGER; + return pTab->aCol[iCol].affinity; +} + +/* +** Return the 'affinity' of the expression pExpr if any. +** +** If pExpr is a column, a reference to a column via an 'AS' alias, +** or a sub-select with a column as the return value, then the +** affinity of that column is returned. Otherwise, 0x00 is returned, +** indicating no affinity for the expression. +** +** i.e. the WHERE clause expressions in the following statements all +** have an affinity: +** +** CREATE TABLE t1(a); +** SELECT * FROM t1 WHERE a; +** SELECT a AS b FROM t1 WHERE b; +** SELECT * FROM t1 WHERE (select a from t1); +*/ +SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr){ + int op; + op = pExpr->op; + while( 1 /* exit-by-break */ ){ + if( op==TK_COLUMN || (op==TK_AGG_COLUMN && pExpr->y.pTab!=0) ){ + assert( ExprUseYTab(pExpr) ); + assert( pExpr->y.pTab!=0 ); + return sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn); + } + if( op==TK_SELECT ){ + assert( ExprUseXSelect(pExpr) ); + assert( pExpr->x.pSelect!=0 ); + assert( pExpr->x.pSelect->pEList!=0 ); + assert( pExpr->x.pSelect->pEList->a[0].pExpr!=0 ); + return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr); + } +#ifndef SQLITE_OMIT_CAST + if( op==TK_CAST ){ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + return sqlite3AffinityType(pExpr->u.zToken, 0); + } +#endif + if( op==TK_SELECT_COLUMN ){ + assert( pExpr->pLeft!=0 && ExprUseXSelect(pExpr->pLeft) ); + assert( pExpr->iColumn < pExpr->iTable ); + assert( pExpr->iTable==pExpr->pLeft->x.pSelect->pEList->nExpr ); + return sqlite3ExprAffinity( + pExpr->pLeft->x.pSelect->pEList->a[pExpr->iColumn].pExpr + ); + } + if( op==TK_VECTOR ){ + assert( ExprUseXList(pExpr) ); + return sqlite3ExprAffinity(pExpr->x.pList->a[0].pExpr); + } + if( ExprHasProperty(pExpr, EP_Skip|EP_IfNullRow) ){ + assert( pExpr->op==TK_COLLATE + || pExpr->op==TK_IF_NULL_ROW + || (pExpr->op==TK_REGISTER && pExpr->op2==TK_IF_NULL_ROW) ); + pExpr = pExpr->pLeft; + op = pExpr->op; + continue; + } + if( op!=TK_REGISTER || (op = pExpr->op2)==TK_REGISTER ) break; + } + return pExpr->affExpr; +} + +/* +** Make a guess at all the possible datatypes of the result that could +** be returned by an expression. Return a bitmask indicating the answer: +** +** 0x01 Numeric +** 0x02 Text +** 0x04 Blob +** +** If the expression must return NULL, then 0x00 is returned. +*/ +SQLITE_PRIVATE int sqlite3ExprDataType(const Expr *pExpr){ + while( pExpr ){ + switch( pExpr->op ){ + case TK_COLLATE: + case TK_IF_NULL_ROW: + case TK_UPLUS: { + pExpr = pExpr->pLeft; + break; + } + case TK_NULL: { + pExpr = 0; + break; + } + case TK_STRING: { + return 0x02; + } + case TK_BLOB: { + return 0x04; + } + case TK_CONCAT: { + return 0x06; + } + case TK_VARIABLE: + case TK_AGG_FUNCTION: + case TK_FUNCTION: { + return 0x07; + } + case TK_COLUMN: + case TK_AGG_COLUMN: + case TK_SELECT: + case TK_CAST: + case TK_SELECT_COLUMN: + case TK_VECTOR: { + int aff = sqlite3ExprAffinity(pExpr); + if( aff>=SQLITE_AFF_NUMERIC ) return 0x05; + if( aff==SQLITE_AFF_TEXT ) return 0x06; + return 0x07; + } + case TK_CASE: { + int res = 0; + int ii; + ExprList *pList = pExpr->x.pList; + assert( ExprUseXList(pExpr) && pList!=0 ); + assert( pList->nExpr > 0); + for(ii=1; iinExpr; ii+=2){ + res |= sqlite3ExprDataType(pList->a[ii].pExpr); + } + if( pList->nExpr % 2 ){ + res |= sqlite3ExprDataType(pList->a[pList->nExpr-1].pExpr); + } + return res; + } + default: { + return 0x01; + } + } /* End of switch(op) */ + } /* End of while(pExpr) */ + return 0x00; +} + +/* +** Set the collating sequence for expression pExpr to be the collating +** sequence named by pToken. Return a pointer to a new Expr node that +** implements the COLLATE operator. +** +** If a memory allocation error occurs, that fact is recorded in pParse->db +** and the pExpr parameter is returned unchanged. +*/ +SQLITE_PRIVATE Expr *sqlite3ExprAddCollateToken( + const Parse *pParse, /* Parsing context */ + Expr *pExpr, /* Add the "COLLATE" clause to this expression */ + const Token *pCollName, /* Name of collating sequence */ + int dequote /* True to dequote pCollName */ +){ + if( pCollName->n>0 ){ + Expr *pNew = sqlite3ExprAlloc(pParse->db, TK_COLLATE, pCollName, dequote); + if( pNew ){ + pNew->pLeft = pExpr; + pNew->flags |= EP_Collate|EP_Skip; + pExpr = pNew; + } + } + return pExpr; +} +SQLITE_PRIVATE Expr *sqlite3ExprAddCollateString( + const Parse *pParse, /* Parsing context */ + Expr *pExpr, /* Add the "COLLATE" clause to this expression */ + const char *zC /* The collating sequence name */ +){ + Token s; + assert( zC!=0 ); + sqlite3TokenInit(&s, (char*)zC); + return sqlite3ExprAddCollateToken(pParse, pExpr, &s, 0); +} + +/* +** Skip over any TK_COLLATE operators. +*/ +SQLITE_PRIVATE Expr *sqlite3ExprSkipCollate(Expr *pExpr){ + while( pExpr && ExprHasProperty(pExpr, EP_Skip) ){ + assert( pExpr->op==TK_COLLATE ); + pExpr = pExpr->pLeft; + } + return pExpr; +} + +/* +** Skip over any TK_COLLATE operators and/or any unlikely() +** or likelihood() or likely() functions at the root of an +** expression. +*/ +SQLITE_PRIVATE Expr *sqlite3ExprSkipCollateAndLikely(Expr *pExpr){ + while( pExpr && ExprHasProperty(pExpr, EP_Skip|EP_Unlikely) ){ + if( ExprHasProperty(pExpr, EP_Unlikely) ){ + assert( ExprUseXList(pExpr) ); + assert( pExpr->x.pList->nExpr>0 ); + assert( pExpr->op==TK_FUNCTION ); + pExpr = pExpr->x.pList->a[0].pExpr; + }else{ + assert( pExpr->op==TK_COLLATE ); + pExpr = pExpr->pLeft; + } + } + return pExpr; +} + +/* +** Return the collation sequence for the expression pExpr. If +** there is no defined collating sequence, return NULL. +** +** See also: sqlite3ExprNNCollSeq() +** +** The sqlite3ExprNNCollSeq() works the same exact that it returns the +** default collation if pExpr has no defined collation. +** +** The collating sequence might be determined by a COLLATE operator +** or by the presence of a column with a defined collating sequence. +** COLLATE operators take first precedence. Left operands take +** precedence over right operands. +*/ +SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr){ + sqlite3 *db = pParse->db; + CollSeq *pColl = 0; + const Expr *p = pExpr; + while( p ){ + int op = p->op; + if( op==TK_REGISTER ) op = p->op2; + if( (op==TK_AGG_COLUMN && p->y.pTab!=0) + || op==TK_COLUMN || op==TK_TRIGGER + ){ + int j; + assert( ExprUseYTab(p) ); + assert( p->y.pTab!=0 ); + if( (j = p->iColumn)>=0 ){ + const char *zColl = sqlite3ColumnColl(&p->y.pTab->aCol[j]); + pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0); + } + break; + } + if( op==TK_CAST || op==TK_UPLUS ){ + p = p->pLeft; + continue; + } + if( op==TK_VECTOR ){ + assert( ExprUseXList(p) ); + p = p->x.pList->a[0].pExpr; + continue; + } + if( op==TK_COLLATE ){ + assert( !ExprHasProperty(p, EP_IntValue) ); + pColl = sqlite3GetCollSeq(pParse, ENC(db), 0, p->u.zToken); + break; + } + if( p->flags & EP_Collate ){ + if( p->pLeft && (p->pLeft->flags & EP_Collate)!=0 ){ + p = p->pLeft; + }else{ + Expr *pNext = p->pRight; + /* The Expr.x union is never used at the same time as Expr.pRight */ + assert( !ExprUseXList(p) || p->x.pList==0 || p->pRight==0 ); + if( ExprUseXList(p) && p->x.pList!=0 && !db->mallocFailed ){ + int i; + for(i=0; ix.pList->nExpr; i++){ + if( ExprHasProperty(p->x.pList->a[i].pExpr, EP_Collate) ){ + pNext = p->x.pList->a[i].pExpr; + break; + } + } + } + p = pNext; + } + }else{ + break; + } + } + if( sqlite3CheckCollSeq(pParse, pColl) ){ + pColl = 0; + } + return pColl; +} + +/* +** Return the collation sequence for the expression pExpr. If +** there is no defined collating sequence, return a pointer to the +** defautl collation sequence. +** +** See also: sqlite3ExprCollSeq() +** +** The sqlite3ExprCollSeq() routine works the same except that it +** returns NULL if there is no defined collation. +*/ +SQLITE_PRIVATE CollSeq *sqlite3ExprNNCollSeq(Parse *pParse, const Expr *pExpr){ + CollSeq *p = sqlite3ExprCollSeq(pParse, pExpr); + if( p==0 ) p = pParse->db->pDfltColl; + assert( p!=0 ); + return p; +} + +/* +** Return TRUE if the two expressions have equivalent collating sequences. +*/ +SQLITE_PRIVATE int sqlite3ExprCollSeqMatch(Parse *pParse, const Expr *pE1, const Expr *pE2){ + CollSeq *pColl1 = sqlite3ExprNNCollSeq(pParse, pE1); + CollSeq *pColl2 = sqlite3ExprNNCollSeq(pParse, pE2); + return sqlite3StrICmp(pColl1->zName, pColl2->zName)==0; +} + +/* +** pExpr is an operand of a comparison operator. aff2 is the +** type affinity of the other operand. This routine returns the +** type affinity that should be used for the comparison operator. +*/ +SQLITE_PRIVATE char sqlite3CompareAffinity(const Expr *pExpr, char aff2){ + char aff1 = sqlite3ExprAffinity(pExpr); + if( aff1>SQLITE_AFF_NONE && aff2>SQLITE_AFF_NONE ){ + /* Both sides of the comparison are columns. If one has numeric + ** affinity, use that. Otherwise use no affinity. + */ + if( sqlite3IsNumericAffinity(aff1) || sqlite3IsNumericAffinity(aff2) ){ + return SQLITE_AFF_NUMERIC; + }else{ + return SQLITE_AFF_BLOB; + } + }else{ + /* One side is a column, the other is not. Use the columns affinity. */ + assert( aff1<=SQLITE_AFF_NONE || aff2<=SQLITE_AFF_NONE ); + return (aff1<=SQLITE_AFF_NONE ? aff2 : aff1) | SQLITE_AFF_NONE; + } +} + +/* +** pExpr is a comparison operator. Return the type affinity that should +** be applied to both operands prior to doing the comparison. +*/ +static char comparisonAffinity(const Expr *pExpr){ + char aff; + assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT || + pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE || + pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT ); + assert( pExpr->pLeft ); + aff = sqlite3ExprAffinity(pExpr->pLeft); + if( pExpr->pRight ){ + aff = sqlite3CompareAffinity(pExpr->pRight, aff); + }else if( ExprUseXSelect(pExpr) ){ + aff = sqlite3CompareAffinity(pExpr->x.pSelect->pEList->a[0].pExpr, aff); + }else if( aff==0 ){ + aff = SQLITE_AFF_BLOB; + } + return aff; +} + +/* +** pExpr is a comparison expression, eg. '=', '<', IN(...) etc. +** idx_affinity is the affinity of an indexed column. Return true +** if the index with affinity idx_affinity may be used to implement +** the comparison in pExpr. +*/ +SQLITE_PRIVATE int sqlite3IndexAffinityOk(const Expr *pExpr, char idx_affinity){ + char aff = comparisonAffinity(pExpr); + if( affflags & EP_Collate ){ + pColl = sqlite3ExprCollSeq(pParse, pLeft); + }else if( pRight && (pRight->flags & EP_Collate)!=0 ){ + pColl = sqlite3ExprCollSeq(pParse, pRight); + }else{ + pColl = sqlite3ExprCollSeq(pParse, pLeft); + if( !pColl ){ + pColl = sqlite3ExprCollSeq(pParse, pRight); + } + } + return pColl; +} + +/* Expresssion p is a comparison operator. Return a collation sequence +** appropriate for the comparison operator. +** +** This is normally just a wrapper around sqlite3BinaryCompareCollSeq(). +** However, if the OP_Commuted flag is set, then the order of the operands +** is reversed in the sqlite3BinaryCompareCollSeq() call so that the +** correct collating sequence is found. +*/ +SQLITE_PRIVATE CollSeq *sqlite3ExprCompareCollSeq(Parse *pParse, const Expr *p){ + if( ExprHasProperty(p, EP_Commuted) ){ + return sqlite3BinaryCompareCollSeq(pParse, p->pRight, p->pLeft); + }else{ + return sqlite3BinaryCompareCollSeq(pParse, p->pLeft, p->pRight); + } +} + +/* +** Generate code for a comparison operator. +*/ +static int codeCompare( + Parse *pParse, /* The parsing (and code generating) context */ + Expr *pLeft, /* The left operand */ + Expr *pRight, /* The right operand */ + int opcode, /* The comparison opcode */ + int in1, int in2, /* Register holding operands */ + int dest, /* Jump here if true. */ + int jumpIfNull, /* If true, jump if either operand is NULL */ + int isCommuted /* The comparison has been commuted */ +){ + int p5; + int addr; + CollSeq *p4; + + if( pParse->nErr ) return 0; + if( isCommuted ){ + p4 = sqlite3BinaryCompareCollSeq(pParse, pRight, pLeft); + }else{ + p4 = sqlite3BinaryCompareCollSeq(pParse, pLeft, pRight); + } + p5 = binaryCompareP5(pLeft, pRight, jumpIfNull); + addr = sqlite3VdbeAddOp4(pParse->pVdbe, opcode, in2, dest, in1, + (void*)p4, P4_COLLSEQ); + sqlite3VdbeChangeP5(pParse->pVdbe, (u8)p5); + return addr; +} + +/* +** Return true if expression pExpr is a vector, or false otherwise. +** +** A vector is defined as any expression that results in two or more +** columns of result. Every TK_VECTOR node is an vector because the +** parser will not generate a TK_VECTOR with fewer than two entries. +** But a TK_SELECT might be either a vector or a scalar. It is only +** considered a vector if it has two or more result columns. +*/ +SQLITE_PRIVATE int sqlite3ExprIsVector(const Expr *pExpr){ + return sqlite3ExprVectorSize(pExpr)>1; +} + +/* +** If the expression passed as the only argument is of type TK_VECTOR +** return the number of expressions in the vector. Or, if the expression +** is a sub-select, return the number of columns in the sub-select. For +** any other type of expression, return 1. +*/ +SQLITE_PRIVATE int sqlite3ExprVectorSize(const Expr *pExpr){ + u8 op = pExpr->op; + if( op==TK_REGISTER ) op = pExpr->op2; + if( op==TK_VECTOR ){ + assert( ExprUseXList(pExpr) ); + return pExpr->x.pList->nExpr; + }else if( op==TK_SELECT ){ + assert( ExprUseXSelect(pExpr) ); + return pExpr->x.pSelect->pEList->nExpr; + }else{ + return 1; + } +} + +/* +** Return a pointer to a subexpression of pVector that is the i-th +** column of the vector (numbered starting with 0). The caller must +** ensure that i is within range. +** +** If pVector is really a scalar (and "scalar" here includes subqueries +** that return a single column!) then return pVector unmodified. +** +** pVector retains ownership of the returned subexpression. +** +** If the vector is a (SELECT ...) then the expression returned is +** just the expression for the i-th term of the result set, and may +** not be ready for evaluation because the table cursor has not yet +** been positioned. +*/ +SQLITE_PRIVATE Expr *sqlite3VectorFieldSubexpr(Expr *pVector, int i){ + assert( iop==TK_ERROR ); + if( sqlite3ExprIsVector(pVector) ){ + assert( pVector->op2==0 || pVector->op==TK_REGISTER ); + if( pVector->op==TK_SELECT || pVector->op2==TK_SELECT ){ + assert( ExprUseXSelect(pVector) ); + return pVector->x.pSelect->pEList->a[i].pExpr; + }else{ + assert( ExprUseXList(pVector) ); + return pVector->x.pList->a[i].pExpr; + } + } + return pVector; +} + +/* +** Compute and return a new Expr object which when passed to +** sqlite3ExprCode() will generate all necessary code to compute +** the iField-th column of the vector expression pVector. +** +** It is ok for pVector to be a scalar (as long as iField==0). +** In that case, this routine works like sqlite3ExprDup(). +** +** The caller owns the returned Expr object and is responsible for +** ensuring that the returned value eventually gets freed. +** +** The caller retains ownership of pVector. If pVector is a TK_SELECT, +** then the returned object will reference pVector and so pVector must remain +** valid for the life of the returned object. If pVector is a TK_VECTOR +** or a scalar expression, then it can be deleted as soon as this routine +** returns. +** +** A trick to cause a TK_SELECT pVector to be deleted together with +** the returned Expr object is to attach the pVector to the pRight field +** of the returned TK_SELECT_COLUMN Expr object. +*/ +SQLITE_PRIVATE Expr *sqlite3ExprForVectorField( + Parse *pParse, /* Parsing context */ + Expr *pVector, /* The vector. List of expressions or a sub-SELECT */ + int iField, /* Which column of the vector to return */ + int nField /* Total number of columns in the vector */ +){ + Expr *pRet; + if( pVector->op==TK_SELECT ){ + assert( ExprUseXSelect(pVector) ); + /* The TK_SELECT_COLUMN Expr node: + ** + ** pLeft: pVector containing TK_SELECT. Not deleted. + ** pRight: not used. But recursively deleted. + ** iColumn: Index of a column in pVector + ** iTable: 0 or the number of columns on the LHS of an assignment + ** pLeft->iTable: First in an array of register holding result, or 0 + ** if the result is not yet computed. + ** + ** sqlite3ExprDelete() specifically skips the recursive delete of + ** pLeft on TK_SELECT_COLUMN nodes. But pRight is followed, so pVector + ** can be attached to pRight to cause this node to take ownership of + ** pVector. Typically there will be multiple TK_SELECT_COLUMN nodes + ** with the same pLeft pointer to the pVector, but only one of them + ** will own the pVector. + */ + pRet = sqlite3PExpr(pParse, TK_SELECT_COLUMN, 0, 0); + if( pRet ){ + pRet->iTable = nField; + pRet->iColumn = iField; + pRet->pLeft = pVector; + } + }else{ + if( pVector->op==TK_VECTOR ){ + Expr **ppVector; + assert( ExprUseXList(pVector) ); + ppVector = &pVector->x.pList->a[iField].pExpr; + pVector = *ppVector; + if( IN_RENAME_OBJECT ){ + /* This must be a vector UPDATE inside a trigger */ + *ppVector = 0; + return pVector; + } + } + pRet = sqlite3ExprDup(pParse->db, pVector, 0); + } + return pRet; +} + +/* +** If expression pExpr is of type TK_SELECT, generate code to evaluate +** it. Return the register in which the result is stored (or, if the +** sub-select returns more than one column, the first in an array +** of registers in which the result is stored). +** +** If pExpr is not a TK_SELECT expression, return 0. +*/ +static int exprCodeSubselect(Parse *pParse, Expr *pExpr){ + int reg = 0; +#ifndef SQLITE_OMIT_SUBQUERY + if( pExpr->op==TK_SELECT ){ + reg = sqlite3CodeSubselect(pParse, pExpr); + } +#endif + return reg; +} + +/* +** Argument pVector points to a vector expression - either a TK_VECTOR +** or TK_SELECT that returns more than one column. This function returns +** the register number of a register that contains the value of +** element iField of the vector. +** +** If pVector is a TK_SELECT expression, then code for it must have +** already been generated using the exprCodeSubselect() routine. In this +** case parameter regSelect should be the first in an array of registers +** containing the results of the sub-select. +** +** If pVector is of type TK_VECTOR, then code for the requested field +** is generated. In this case (*pRegFree) may be set to the number of +** a temporary register to be freed by the caller before returning. +** +** Before returning, output parameter (*ppExpr) is set to point to the +** Expr object corresponding to element iElem of the vector. +*/ +static int exprVectorRegister( + Parse *pParse, /* Parse context */ + Expr *pVector, /* Vector to extract element from */ + int iField, /* Field to extract from pVector */ + int regSelect, /* First in array of registers */ + Expr **ppExpr, /* OUT: Expression element */ + int *pRegFree /* OUT: Temp register to free */ +){ + u8 op = pVector->op; + assert( op==TK_VECTOR || op==TK_REGISTER || op==TK_SELECT || op==TK_ERROR ); + if( op==TK_REGISTER ){ + *ppExpr = sqlite3VectorFieldSubexpr(pVector, iField); + return pVector->iTable+iField; + } + if( op==TK_SELECT ){ + assert( ExprUseXSelect(pVector) ); + *ppExpr = pVector->x.pSelect->pEList->a[iField].pExpr; + return regSelect+iField; + } + if( op==TK_VECTOR ){ + assert( ExprUseXList(pVector) ); + *ppExpr = pVector->x.pList->a[iField].pExpr; + return sqlite3ExprCodeTemp(pParse, *ppExpr, pRegFree); + } + return 0; +} + +/* +** Expression pExpr is a comparison between two vector values. Compute +** the result of the comparison (1, 0, or NULL) and write that +** result into register dest. +** +** The caller must satisfy the following preconditions: +** +** if pExpr->op==TK_IS: op==TK_EQ and p5==SQLITE_NULLEQ +** if pExpr->op==TK_ISNOT: op==TK_NE and p5==SQLITE_NULLEQ +** otherwise: op==pExpr->op and p5==0 +*/ +static void codeVectorCompare( + Parse *pParse, /* Code generator context */ + Expr *pExpr, /* The comparison operation */ + int dest, /* Write results into this register */ + u8 op, /* Comparison operator */ + u8 p5 /* SQLITE_NULLEQ or zero */ +){ + Vdbe *v = pParse->pVdbe; + Expr *pLeft = pExpr->pLeft; + Expr *pRight = pExpr->pRight; + int nLeft = sqlite3ExprVectorSize(pLeft); + int i; + int regLeft = 0; + int regRight = 0; + u8 opx = op; + int addrCmp = 0; + int addrDone = sqlite3VdbeMakeLabel(pParse); + int isCommuted = ExprHasProperty(pExpr,EP_Commuted); + + assert( !ExprHasVVAProperty(pExpr,EP_Immutable) ); + if( pParse->nErr ) return; + if( nLeft!=sqlite3ExprVectorSize(pRight) ){ + sqlite3ErrorMsg(pParse, "row value misused"); + return; + } + assert( pExpr->op==TK_EQ || pExpr->op==TK_NE + || pExpr->op==TK_IS || pExpr->op==TK_ISNOT + || pExpr->op==TK_LT || pExpr->op==TK_GT + || pExpr->op==TK_LE || pExpr->op==TK_GE + ); + assert( pExpr->op==op || (pExpr->op==TK_IS && op==TK_EQ) + || (pExpr->op==TK_ISNOT && op==TK_NE) ); + assert( p5==0 || pExpr->op!=op ); + assert( p5==SQLITE_NULLEQ || pExpr->op==op ); + + if( op==TK_LE ) opx = TK_LT; + if( op==TK_GE ) opx = TK_GT; + if( op==TK_NE ) opx = TK_EQ; + + regLeft = exprCodeSubselect(pParse, pLeft); + regRight = exprCodeSubselect(pParse, pRight); + + sqlite3VdbeAddOp2(v, OP_Integer, 1, dest); + for(i=0; 1 /*Loop exits by "break"*/; i++){ + int regFree1 = 0, regFree2 = 0; + Expr *pL = 0, *pR = 0; + int r1, r2; + assert( i>=0 && i0 +/* +** Check that argument nHeight is less than or equal to the maximum +** expression depth allowed. If it is not, leave an error message in +** pParse. +*/ +SQLITE_PRIVATE int sqlite3ExprCheckHeight(Parse *pParse, int nHeight){ + int rc = SQLITE_OK; + int mxHeight = pParse->db->aLimit[SQLITE_LIMIT_EXPR_DEPTH]; + if( nHeight>mxHeight ){ + sqlite3ErrorMsg(pParse, + "Expression tree is too large (maximum depth %d)", mxHeight + ); + rc = SQLITE_ERROR; + } + return rc; +} + +/* The following three functions, heightOfExpr(), heightOfExprList() +** and heightOfSelect(), are used to determine the maximum height +** of any expression tree referenced by the structure passed as the +** first argument. +** +** If this maximum height is greater than the current value pointed +** to by pnHeight, the second parameter, then set *pnHeight to that +** value. +*/ +static void heightOfExpr(const Expr *p, int *pnHeight){ + if( p ){ + if( p->nHeight>*pnHeight ){ + *pnHeight = p->nHeight; + } + } +} +static void heightOfExprList(const ExprList *p, int *pnHeight){ + if( p ){ + int i; + for(i=0; inExpr; i++){ + heightOfExpr(p->a[i].pExpr, pnHeight); + } + } +} +static void heightOfSelect(const Select *pSelect, int *pnHeight){ + const Select *p; + for(p=pSelect; p; p=p->pPrior){ + heightOfExpr(p->pWhere, pnHeight); + heightOfExpr(p->pHaving, pnHeight); + heightOfExpr(p->pLimit, pnHeight); + heightOfExprList(p->pEList, pnHeight); + heightOfExprList(p->pGroupBy, pnHeight); + heightOfExprList(p->pOrderBy, pnHeight); + } +} + +/* +** Set the Expr.nHeight variable in the structure passed as an +** argument. An expression with no children, Expr.pList or +** Expr.pSelect member has a height of 1. Any other expression +** has a height equal to the maximum height of any other +** referenced Expr plus one. +** +** Also propagate EP_Propagate flags up from Expr.x.pList to Expr.flags, +** if appropriate. +*/ +static void exprSetHeight(Expr *p){ + int nHeight = p->pLeft ? p->pLeft->nHeight : 0; + if( NEVER(p->pRight) && p->pRight->nHeight>nHeight ){ + nHeight = p->pRight->nHeight; + } + if( ExprUseXSelect(p) ){ + heightOfSelect(p->x.pSelect, &nHeight); + }else if( p->x.pList ){ + heightOfExprList(p->x.pList, &nHeight); + p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList); + } + p->nHeight = nHeight + 1; +} + +/* +** Set the Expr.nHeight variable using the exprSetHeight() function. If +** the height is greater than the maximum allowed expression depth, +** leave an error in pParse. +** +** Also propagate all EP_Propagate flags from the Expr.x.pList into +** Expr.flags. +*/ +SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p){ + if( pParse->nErr ) return; + exprSetHeight(p); + sqlite3ExprCheckHeight(pParse, p->nHeight); +} + +/* +** Return the maximum height of any expression tree referenced +** by the select statement passed as an argument. +*/ +SQLITE_PRIVATE int sqlite3SelectExprHeight(const Select *p){ + int nHeight = 0; + heightOfSelect(p, &nHeight); + return nHeight; +} +#else /* ABOVE: Height enforcement enabled. BELOW: Height enforcement off */ +/* +** Propagate all EP_Propagate flags from the Expr.x.pList into +** Expr.flags. +*/ +SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p){ + if( pParse->nErr ) return; + if( p && ExprUseXList(p) && p->x.pList ){ + p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList); + } +} +#define exprSetHeight(y) +#endif /* SQLITE_MAX_EXPR_DEPTH>0 */ + +/* +** This routine is the core allocator for Expr nodes. +** +** Construct a new expression node and return a pointer to it. Memory +** for this node and for the pToken argument is a single allocation +** obtained from sqlite3DbMalloc(). The calling function +** is responsible for making sure the node eventually gets freed. +** +** If dequote is true, then the token (if it exists) is dequoted. +** If dequote is false, no dequoting is performed. The deQuote +** parameter is ignored if pToken is NULL or if the token does not +** appear to be quoted. If the quotes were of the form "..." (double-quotes) +** then the EP_DblQuoted flag is set on the expression node. +** +** Special case: If op==TK_INTEGER and pToken points to a string that +** can be translated into a 32-bit integer, then the token is not +** stored in u.zToken. Instead, the integer values is written +** into u.iValue and the EP_IntValue flag is set. No extra storage +** is allocated to hold the integer text and the dequote flag is ignored. +*/ +SQLITE_PRIVATE Expr *sqlite3ExprAlloc( + sqlite3 *db, /* Handle for sqlite3DbMallocRawNN() */ + int op, /* Expression opcode */ + const Token *pToken, /* Token argument. Might be NULL */ + int dequote /* True to dequote */ +){ + Expr *pNew; + int nExtra = 0; + int iValue = 0; + + assert( db!=0 ); + if( pToken ){ + if( op!=TK_INTEGER || pToken->z==0 + || sqlite3GetInt32(pToken->z, &iValue)==0 ){ + nExtra = pToken->n+1; + assert( iValue>=0 ); + } + } + pNew = sqlite3DbMallocRawNN(db, sizeof(Expr)+nExtra); + if( pNew ){ + memset(pNew, 0, sizeof(Expr)); + pNew->op = (u8)op; + pNew->iAgg = -1; + if( pToken ){ + if( nExtra==0 ){ + pNew->flags |= EP_IntValue|EP_Leaf|(iValue?EP_IsTrue:EP_IsFalse); + pNew->u.iValue = iValue; + }else{ + pNew->u.zToken = (char*)&pNew[1]; + assert( pToken->z!=0 || pToken->n==0 ); + if( pToken->n ) memcpy(pNew->u.zToken, pToken->z, pToken->n); + pNew->u.zToken[pToken->n] = 0; + if( dequote && sqlite3Isquote(pNew->u.zToken[0]) ){ + sqlite3DequoteExpr(pNew); + } + } + } +#if SQLITE_MAX_EXPR_DEPTH>0 + pNew->nHeight = 1; +#endif + } + return pNew; +} + +/* +** Allocate a new expression node from a zero-terminated token that has +** already been dequoted. +*/ +SQLITE_PRIVATE Expr *sqlite3Expr( + sqlite3 *db, /* Handle for sqlite3DbMallocZero() (may be null) */ + int op, /* Expression opcode */ + const char *zToken /* Token argument. Might be NULL */ +){ + Token x; + x.z = zToken; + x.n = sqlite3Strlen30(zToken); + return sqlite3ExprAlloc(db, op, &x, 0); +} + +/* +** Attach subtrees pLeft and pRight to the Expr node pRoot. +** +** If pRoot==NULL that means that a memory allocation error has occurred. +** In that case, delete the subtrees pLeft and pRight. +*/ +SQLITE_PRIVATE void sqlite3ExprAttachSubtrees( + sqlite3 *db, + Expr *pRoot, + Expr *pLeft, + Expr *pRight +){ + if( pRoot==0 ){ + assert( db->mallocFailed ); + sqlite3ExprDelete(db, pLeft); + sqlite3ExprDelete(db, pRight); + }else{ + assert( ExprUseXList(pRoot) ); + assert( pRoot->x.pSelect==0 ); + if( pRight ){ + pRoot->pRight = pRight; + pRoot->flags |= EP_Propagate & pRight->flags; +#if SQLITE_MAX_EXPR_DEPTH>0 + pRoot->nHeight = pRight->nHeight+1; + }else{ + pRoot->nHeight = 1; +#endif + } + if( pLeft ){ + pRoot->pLeft = pLeft; + pRoot->flags |= EP_Propagate & pLeft->flags; +#if SQLITE_MAX_EXPR_DEPTH>0 + if( pLeft->nHeight>=pRoot->nHeight ){ + pRoot->nHeight = pLeft->nHeight+1; + } +#endif + } + } +} + +/* +** Allocate an Expr node which joins as many as two subtrees. +** +** One or both of the subtrees can be NULL. Return a pointer to the new +** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed, +** free the subtrees and return NULL. +*/ +SQLITE_PRIVATE Expr *sqlite3PExpr( + Parse *pParse, /* Parsing context */ + int op, /* Expression opcode */ + Expr *pLeft, /* Left operand */ + Expr *pRight /* Right operand */ +){ + Expr *p; + p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr)); + if( p ){ + memset(p, 0, sizeof(Expr)); + p->op = op & 0xff; + p->iAgg = -1; + sqlite3ExprAttachSubtrees(pParse->db, p, pLeft, pRight); + sqlite3ExprCheckHeight(pParse, p->nHeight); + }else{ + sqlite3ExprDelete(pParse->db, pLeft); + sqlite3ExprDelete(pParse->db, pRight); + } + return p; +} + +/* +** Add pSelect to the Expr.x.pSelect field. Or, if pExpr is NULL (due +** do a memory allocation failure) then delete the pSelect object. +*/ +SQLITE_PRIVATE void sqlite3PExprAddSelect(Parse *pParse, Expr *pExpr, Select *pSelect){ + if( pExpr ){ + pExpr->x.pSelect = pSelect; + ExprSetProperty(pExpr, EP_xIsSelect|EP_Subquery); + sqlite3ExprSetHeightAndFlags(pParse, pExpr); + }else{ + assert( pParse->db->mallocFailed ); + sqlite3SelectDelete(pParse->db, pSelect); + } +} + +/* +** Expression list pEList is a list of vector values. This function +** converts the contents of pEList to a VALUES(...) Select statement +** returning 1 row for each element of the list. For example, the +** expression list: +** +** ( (1,2), (3,4) (5,6) ) +** +** is translated to the equivalent of: +** +** VALUES(1,2), (3,4), (5,6) +** +** Each of the vector values in pEList must contain exactly nElem terms. +** If a list element that is not a vector or does not contain nElem terms, +** an error message is left in pParse. +** +** This is used as part of processing IN(...) expressions with a list +** of vectors on the RHS. e.g. "... IN ((1,2), (3,4), (5,6))". +*/ +SQLITE_PRIVATE Select *sqlite3ExprListToValues(Parse *pParse, int nElem, ExprList *pEList){ + int ii; + Select *pRet = 0; + assert( nElem>1 ); + for(ii=0; iinExpr; ii++){ + Select *pSel; + Expr *pExpr = pEList->a[ii].pExpr; + int nExprElem; + if( pExpr->op==TK_VECTOR ){ + assert( ExprUseXList(pExpr) ); + nExprElem = pExpr->x.pList->nExpr; + }else{ + nExprElem = 1; + } + if( nExprElem!=nElem ){ + sqlite3ErrorMsg(pParse, "IN(...) element has %d term%s - expected %d", + nExprElem, nExprElem>1?"s":"", nElem + ); + break; + } + assert( ExprUseXList(pExpr) ); + pSel = sqlite3SelectNew(pParse, pExpr->x.pList, 0, 0, 0, 0, 0, SF_Values,0); + pExpr->x.pList = 0; + if( pSel ){ + if( pRet ){ + pSel->op = TK_ALL; + pSel->pPrior = pRet; + } + pRet = pSel; + } + } + + if( pRet && pRet->pPrior ){ + pRet->selFlags |= SF_MultiValue; + } + sqlite3ExprListDelete(pParse->db, pEList); + return pRet; +} + +/* +** Join two expressions using an AND operator. If either expression is +** NULL, then just return the other expression. +** +** If one side or the other of the AND is known to be false, and neither side +** is part of an ON clause, then instead of returning an AND expression, +** just return a constant expression with a value of false. +*/ +SQLITE_PRIVATE Expr *sqlite3ExprAnd(Parse *pParse, Expr *pLeft, Expr *pRight){ + sqlite3 *db = pParse->db; + if( pLeft==0 ){ + return pRight; + }else if( pRight==0 ){ + return pLeft; + }else{ + u32 f = pLeft->flags | pRight->flags; + if( (f&(EP_OuterON|EP_InnerON|EP_IsFalse))==EP_IsFalse + && !IN_RENAME_OBJECT + ){ + sqlite3ExprDeferredDelete(pParse, pLeft); + sqlite3ExprDeferredDelete(pParse, pRight); + return sqlite3Expr(db, TK_INTEGER, "0"); + }else{ + return sqlite3PExpr(pParse, TK_AND, pLeft, pRight); + } + } +} + +/* +** Construct a new expression node for a function with multiple +** arguments. +*/ +SQLITE_PRIVATE Expr *sqlite3ExprFunction( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* Argument list */ + const Token *pToken, /* Name of the function */ + int eDistinct /* SF_Distinct or SF_ALL or 0 */ +){ + Expr *pNew; + sqlite3 *db = pParse->db; + assert( pToken ); + pNew = sqlite3ExprAlloc(db, TK_FUNCTION, pToken, 1); + if( pNew==0 ){ + sqlite3ExprListDelete(db, pList); /* Avoid memory leak when malloc fails */ + return 0; + } + assert( !ExprHasProperty(pNew, EP_InnerON|EP_OuterON) ); + pNew->w.iOfst = (int)(pToken->z - pParse->zTail); + if( pList + && pList->nExpr > pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] + && !pParse->nested + ){ + sqlite3ErrorMsg(pParse, "too many arguments on function %T", pToken); + } + pNew->x.pList = pList; + ExprSetProperty(pNew, EP_HasFunc); + assert( ExprUseXList(pNew) ); + sqlite3ExprSetHeightAndFlags(pParse, pNew); + if( eDistinct==SF_Distinct ) ExprSetProperty(pNew, EP_Distinct); + return pNew; +} + +/* +** Check to see if a function is usable according to current access +** rules: +** +** SQLITE_FUNC_DIRECT - Only usable from top-level SQL +** +** SQLITE_FUNC_UNSAFE - Usable if TRUSTED_SCHEMA or from +** top-level SQL +** +** If the function is not usable, create an error. +*/ +SQLITE_PRIVATE void sqlite3ExprFunctionUsable( + Parse *pParse, /* Parsing and code generating context */ + const Expr *pExpr, /* The function invocation */ + const FuncDef *pDef /* The function being invoked */ +){ + assert( !IN_RENAME_OBJECT ); + assert( (pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE))!=0 ); + if( ExprHasProperty(pExpr, EP_FromDDL) ){ + if( (pDef->funcFlags & SQLITE_FUNC_DIRECT)!=0 + || (pParse->db->flags & SQLITE_TrustedSchema)==0 + ){ + /* Functions prohibited in triggers and views if: + ** (1) tagged with SQLITE_DIRECTONLY + ** (2) not tagged with SQLITE_INNOCUOUS (which means it + ** is tagged with SQLITE_FUNC_UNSAFE) and + ** SQLITE_DBCONFIG_TRUSTED_SCHEMA is off (meaning + ** that the schema is possibly tainted). + */ + sqlite3ErrorMsg(pParse, "unsafe use of %#T()", pExpr); + } + } +} + +/* +** Assign a variable number to an expression that encodes a wildcard +** in the original SQL statement. +** +** Wildcards consisting of a single "?" are assigned the next sequential +** variable number. +** +** Wildcards of the form "?nnn" are assigned the number "nnn". We make +** sure "nnn" is not too big to avoid a denial of service attack when +** the SQL statement comes from an external source. +** +** Wildcards of the form ":aaa", "@aaa", or "$aaa" are assigned the same number +** as the previous instance of the same wildcard. Or if this is the first +** instance of the wildcard, the next sequential variable number is +** assigned. +*/ +SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr, u32 n){ + sqlite3 *db = pParse->db; + const char *z; + ynVar x; + + if( pExpr==0 ) return; + assert( !ExprHasProperty(pExpr, EP_IntValue|EP_Reduced|EP_TokenOnly) ); + z = pExpr->u.zToken; + assert( z!=0 ); + assert( z[0]!=0 ); + assert( n==(u32)sqlite3Strlen30(z) ); + if( z[1]==0 ){ + /* Wildcard of the form "?". Assign the next variable number */ + assert( z[0]=='?' ); + x = (ynVar)(++pParse->nVar); + }else{ + int doAdd = 0; + if( z[0]=='?' ){ + /* Wildcard of the form "?nnn". Convert "nnn" to an integer and + ** use it as the variable number */ + i64 i; + int bOk; + if( n==2 ){ /*OPTIMIZATION-IF-TRUE*/ + i = z[1]-'0'; /* The common case of ?N for a single digit N */ + bOk = 1; + }else{ + bOk = 0==sqlite3Atoi64(&z[1], &i, n-1, SQLITE_UTF8); + } + testcase( i==0 ); + testcase( i==1 ); + testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]-1 ); + testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ); + if( bOk==0 || i<1 || i>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){ + sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d", + db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]); + sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr); + return; + } + x = (ynVar)i; + if( x>pParse->nVar ){ + pParse->nVar = (int)x; + doAdd = 1; + }else if( sqlite3VListNumToName(pParse->pVList, x)==0 ){ + doAdd = 1; + } + }else{ + /* Wildcards like ":aaa", "$aaa" or "@aaa". Reuse the same variable + ** number as the prior appearance of the same name, or if the name + ** has never appeared before, reuse the same variable number + */ + x = (ynVar)sqlite3VListNameToNum(pParse->pVList, z, n); + if( x==0 ){ + x = (ynVar)(++pParse->nVar); + doAdd = 1; + } + } + if( doAdd ){ + pParse->pVList = sqlite3VListAdd(db, pParse->pVList, z, n, x); + } + } + pExpr->iColumn = x; + if( x>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){ + sqlite3ErrorMsg(pParse, "too many SQL variables"); + sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr); + } +} + +/* +** Recursively delete an expression tree. +*/ +static SQLITE_NOINLINE void sqlite3ExprDeleteNN(sqlite3 *db, Expr *p){ + assert( p!=0 ); + assert( db!=0 ); + assert( !ExprUseUValue(p) || p->u.iValue>=0 ); + assert( !ExprUseYWin(p) || !ExprUseYSub(p) ); + assert( !ExprUseYWin(p) || p->y.pWin!=0 || db->mallocFailed ); + assert( p->op!=TK_FUNCTION || !ExprUseYSub(p) ); +#ifdef SQLITE_DEBUG + if( ExprHasProperty(p, EP_Leaf) && !ExprHasProperty(p, EP_TokenOnly) ){ + assert( p->pLeft==0 ); + assert( p->pRight==0 ); + assert( !ExprUseXSelect(p) || p->x.pSelect==0 ); + assert( !ExprUseXList(p) || p->x.pList==0 ); + } +#endif + if( !ExprHasProperty(p, (EP_TokenOnly|EP_Leaf)) ){ + /* The Expr.x union is never used at the same time as Expr.pRight */ + assert( (ExprUseXList(p) && p->x.pList==0) || p->pRight==0 ); + if( p->pLeft && p->op!=TK_SELECT_COLUMN ) sqlite3ExprDeleteNN(db, p->pLeft); + if( p->pRight ){ + assert( !ExprHasProperty(p, EP_WinFunc) ); + sqlite3ExprDeleteNN(db, p->pRight); + }else if( ExprUseXSelect(p) ){ + assert( !ExprHasProperty(p, EP_WinFunc) ); + sqlite3SelectDelete(db, p->x.pSelect); + }else{ + sqlite3ExprListDelete(db, p->x.pList); +#ifndef SQLITE_OMIT_WINDOWFUNC + if( ExprHasProperty(p, EP_WinFunc) ){ + sqlite3WindowDelete(db, p->y.pWin); + } +#endif + } + } + if( !ExprHasProperty(p, EP_Static) ){ + sqlite3DbNNFreeNN(db, p); + } +} +SQLITE_PRIVATE void sqlite3ExprDelete(sqlite3 *db, Expr *p){ + if( p ) sqlite3ExprDeleteNN(db, p); +} + +/* +** Clear both elements of an OnOrUsing object +*/ +SQLITE_PRIVATE void sqlite3ClearOnOrUsing(sqlite3 *db, OnOrUsing *p){ + if( p==0 ){ + /* Nothing to clear */ + }else if( p->pOn ){ + sqlite3ExprDeleteNN(db, p->pOn); + }else if( p->pUsing ){ + sqlite3IdListDelete(db, p->pUsing); + } +} + +/* +** Arrange to cause pExpr to be deleted when the pParse is deleted. +** This is similar to sqlite3ExprDelete() except that the delete is +** deferred untilthe pParse is deleted. +** +** The pExpr might be deleted immediately on an OOM error. +** +** The deferred delete is (currently) implemented by adding the +** pExpr to the pParse->pConstExpr list with a register number of 0. +*/ +SQLITE_PRIVATE void sqlite3ExprDeferredDelete(Parse *pParse, Expr *pExpr){ + sqlite3ParserAddCleanup(pParse, + (void(*)(sqlite3*,void*))sqlite3ExprDelete, + pExpr); +} + +/* Invoke sqlite3RenameExprUnmap() and sqlite3ExprDelete() on the +** expression. +*/ +SQLITE_PRIVATE void sqlite3ExprUnmapAndDelete(Parse *pParse, Expr *p){ + if( p ){ + if( IN_RENAME_OBJECT ){ + sqlite3RenameExprUnmap(pParse, p); + } + sqlite3ExprDeleteNN(pParse->db, p); + } +} + +/* +** Return the number of bytes allocated for the expression structure +** passed as the first argument. This is always one of EXPR_FULLSIZE, +** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE. +*/ +static int exprStructSize(const Expr *p){ + if( ExprHasProperty(p, EP_TokenOnly) ) return EXPR_TOKENONLYSIZE; + if( ExprHasProperty(p, EP_Reduced) ) return EXPR_REDUCEDSIZE; + return EXPR_FULLSIZE; +} + +/* +** The dupedExpr*Size() routines each return the number of bytes required +** to store a copy of an expression or expression tree. They differ in +** how much of the tree is measured. +** +** dupedExprStructSize() Size of only the Expr structure +** dupedExprNodeSize() Size of Expr + space for token +** dupedExprSize() Expr + token + subtree components +** +*************************************************************************** +** +** The dupedExprStructSize() function returns two values OR-ed together: +** (1) the space required for a copy of the Expr structure only and +** (2) the EP_xxx flags that indicate what the structure size should be. +** The return values is always one of: +** +** EXPR_FULLSIZE +** EXPR_REDUCEDSIZE | EP_Reduced +** EXPR_TOKENONLYSIZE | EP_TokenOnly +** +** The size of the structure can be found by masking the return value +** of this routine with 0xfff. The flags can be found by masking the +** return value with EP_Reduced|EP_TokenOnly. +** +** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size +** (unreduced) Expr objects as they or originally constructed by the parser. +** During expression analysis, extra information is computed and moved into +** later parts of the Expr object and that extra information might get chopped +** off if the expression is reduced. Note also that it does not work to +** make an EXPRDUP_REDUCE copy of a reduced expression. It is only legal +** to reduce a pristine expression tree from the parser. The implementation +** of dupedExprStructSize() contain multiple assert() statements that attempt +** to enforce this constraint. +*/ +static int dupedExprStructSize(const Expr *p, int flags){ + int nSize; + assert( flags==EXPRDUP_REDUCE || flags==0 ); /* Only one flag value allowed */ + assert( EXPR_FULLSIZE<=0xfff ); + assert( (0xfff & (EP_Reduced|EP_TokenOnly))==0 ); + if( 0==flags || p->op==TK_SELECT_COLUMN +#ifndef SQLITE_OMIT_WINDOWFUNC + || ExprHasProperty(p, EP_WinFunc) +#endif + ){ + nSize = EXPR_FULLSIZE; + }else{ + assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) ); + assert( !ExprHasProperty(p, EP_OuterON) ); + assert( !ExprHasVVAProperty(p, EP_NoReduce) ); + if( p->pLeft || p->x.pList ){ + nSize = EXPR_REDUCEDSIZE | EP_Reduced; + }else{ + assert( p->pRight==0 ); + nSize = EXPR_TOKENONLYSIZE | EP_TokenOnly; + } + } + return nSize; +} + +/* +** This function returns the space in bytes required to store the copy +** of the Expr structure and a copy of the Expr.u.zToken string (if that +** string is defined.) +*/ +static int dupedExprNodeSize(const Expr *p, int flags){ + int nByte = dupedExprStructSize(p, flags) & 0xfff; + if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){ + nByte += sqlite3Strlen30NN(p->u.zToken)+1; + } + return ROUND8(nByte); +} + +/* +** Return the number of bytes required to create a duplicate of the +** expression passed as the first argument. The second argument is a +** mask containing EXPRDUP_XXX flags. +** +** The value returned includes space to create a copy of the Expr struct +** itself and the buffer referred to by Expr.u.zToken, if any. +** +** If the EXPRDUP_REDUCE flag is set, then the return value includes +** space to duplicate all Expr nodes in the tree formed by Expr.pLeft +** and Expr.pRight variables (but not for any structures pointed to or +** descended from the Expr.x.pList or Expr.x.pSelect variables). +*/ +static int dupedExprSize(const Expr *p, int flags){ + int nByte = 0; + if( p ){ + nByte = dupedExprNodeSize(p, flags); + if( flags&EXPRDUP_REDUCE ){ + nByte += dupedExprSize(p->pLeft, flags) + dupedExprSize(p->pRight, flags); + } + } + return nByte; +} + +/* +** This function is similar to sqlite3ExprDup(), except that if pzBuffer +** is not NULL then *pzBuffer is assumed to point to a buffer large enough +** to store the copy of expression p, the copies of p->u.zToken +** (if applicable), and the copies of the p->pLeft and p->pRight expressions, +** if any. Before returning, *pzBuffer is set to the first byte past the +** portion of the buffer copied into by this function. +*/ +static Expr *exprDup(sqlite3 *db, const Expr *p, int dupFlags, u8 **pzBuffer){ + Expr *pNew; /* Value to return */ + u8 *zAlloc; /* Memory space from which to build Expr object */ + u32 staticFlag; /* EP_Static if space not obtained from malloc */ + + assert( db!=0 ); + assert( p ); + assert( dupFlags==0 || dupFlags==EXPRDUP_REDUCE ); + assert( pzBuffer==0 || dupFlags==EXPRDUP_REDUCE ); + + /* Figure out where to write the new Expr structure. */ + if( pzBuffer ){ + zAlloc = *pzBuffer; + staticFlag = EP_Static; + assert( zAlloc!=0 ); + }else{ + zAlloc = sqlite3DbMallocRawNN(db, dupedExprSize(p, dupFlags)); + staticFlag = 0; + } + pNew = (Expr *)zAlloc; + + if( pNew ){ + /* Set nNewSize to the size allocated for the structure pointed to + ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or + ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed + ** by the copy of the p->u.zToken string (if any). + */ + const unsigned nStructSize = dupedExprStructSize(p, dupFlags); + const int nNewSize = nStructSize & 0xfff; + int nToken; + if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){ + nToken = sqlite3Strlen30(p->u.zToken) + 1; + }else{ + nToken = 0; + } + if( dupFlags ){ + assert( ExprHasProperty(p, EP_Reduced)==0 ); + memcpy(zAlloc, p, nNewSize); + }else{ + u32 nSize = (u32)exprStructSize(p); + memcpy(zAlloc, p, nSize); + if( nSizeflags &= ~(EP_Reduced|EP_TokenOnly|EP_Static); + pNew->flags |= nStructSize & (EP_Reduced|EP_TokenOnly); + pNew->flags |= staticFlag; + ExprClearVVAProperties(pNew); + if( dupFlags ){ + ExprSetVVAProperty(pNew, EP_Immutable); + } + + /* Copy the p->u.zToken string, if any. */ + if( nToken ){ + char *zToken = pNew->u.zToken = (char*)&zAlloc[nNewSize]; + memcpy(zToken, p->u.zToken, nToken); + } + + if( 0==((p->flags|pNew->flags) & (EP_TokenOnly|EP_Leaf)) ){ + /* Fill in the pNew->x.pSelect or pNew->x.pList member. */ + if( ExprUseXSelect(p) ){ + pNew->x.pSelect = sqlite3SelectDup(db, p->x.pSelect, dupFlags); + }else{ + pNew->x.pList = sqlite3ExprListDup(db, p->x.pList, dupFlags); + } + } + + /* Fill in pNew->pLeft and pNew->pRight. */ + if( ExprHasProperty(pNew, EP_Reduced|EP_TokenOnly|EP_WinFunc) ){ + zAlloc += dupedExprNodeSize(p, dupFlags); + if( !ExprHasProperty(pNew, EP_TokenOnly|EP_Leaf) ){ + pNew->pLeft = p->pLeft ? + exprDup(db, p->pLeft, EXPRDUP_REDUCE, &zAlloc) : 0; + pNew->pRight = p->pRight ? + exprDup(db, p->pRight, EXPRDUP_REDUCE, &zAlloc) : 0; + } +#ifndef SQLITE_OMIT_WINDOWFUNC + if( ExprHasProperty(p, EP_WinFunc) ){ + pNew->y.pWin = sqlite3WindowDup(db, pNew, p->y.pWin); + assert( ExprHasProperty(pNew, EP_WinFunc) ); + } +#endif /* SQLITE_OMIT_WINDOWFUNC */ + if( pzBuffer ){ + *pzBuffer = zAlloc; + } + }else{ + if( !ExprHasProperty(p, EP_TokenOnly|EP_Leaf) ){ + if( pNew->op==TK_SELECT_COLUMN ){ + pNew->pLeft = p->pLeft; + assert( p->pRight==0 || p->pRight==p->pLeft + || ExprHasProperty(p->pLeft, EP_Subquery) ); + }else{ + pNew->pLeft = sqlite3ExprDup(db, p->pLeft, 0); + } + pNew->pRight = sqlite3ExprDup(db, p->pRight, 0); + } + } + } + return pNew; +} + +/* +** Create and return a deep copy of the object passed as the second +** argument. If an OOM condition is encountered, NULL is returned +** and the db->mallocFailed flag set. +*/ +#ifndef SQLITE_OMIT_CTE +SQLITE_PRIVATE With *sqlite3WithDup(sqlite3 *db, With *p){ + With *pRet = 0; + if( p ){ + sqlite3_int64 nByte = sizeof(*p) + sizeof(p->a[0]) * (p->nCte-1); + pRet = sqlite3DbMallocZero(db, nByte); + if( pRet ){ + int i; + pRet->nCte = p->nCte; + for(i=0; inCte; i++){ + pRet->a[i].pSelect = sqlite3SelectDup(db, p->a[i].pSelect, 0); + pRet->a[i].pCols = sqlite3ExprListDup(db, p->a[i].pCols, 0); + pRet->a[i].zName = sqlite3DbStrDup(db, p->a[i].zName); + pRet->a[i].eM10d = p->a[i].eM10d; + } + } + } + return pRet; +} +#else +# define sqlite3WithDup(x,y) 0 +#endif + +#ifndef SQLITE_OMIT_WINDOWFUNC +/* +** The gatherSelectWindows() procedure and its helper routine +** gatherSelectWindowsCallback() are used to scan all the expressions +** an a newly duplicated SELECT statement and gather all of the Window +** objects found there, assembling them onto the linked list at Select->pWin. +*/ +static int gatherSelectWindowsCallback(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_FUNCTION && ExprHasProperty(pExpr, EP_WinFunc) ){ + Select *pSelect = pWalker->u.pSelect; + Window *pWin = pExpr->y.pWin; + assert( pWin ); + assert( IsWindowFunc(pExpr) ); + assert( pWin->ppThis==0 ); + sqlite3WindowLink(pSelect, pWin); + } + return WRC_Continue; +} +static int gatherSelectWindowsSelectCallback(Walker *pWalker, Select *p){ + return p==pWalker->u.pSelect ? WRC_Continue : WRC_Prune; +} +static void gatherSelectWindows(Select *p){ + Walker w; + w.xExprCallback = gatherSelectWindowsCallback; + w.xSelectCallback = gatherSelectWindowsSelectCallback; + w.xSelectCallback2 = 0; + w.pParse = 0; + w.u.pSelect = p; + sqlite3WalkSelect(&w, p); +} +#endif + + +/* +** The following group of routines make deep copies of expressions, +** expression lists, ID lists, and select statements. The copies can +** be deleted (by being passed to their respective ...Delete() routines) +** without effecting the originals. +** +** The expression list, ID, and source lists return by sqlite3ExprListDup(), +** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded +** by subsequent calls to sqlite*ListAppend() routines. +** +** Any tables that the SrcList might point to are not duplicated. +** +** The flags parameter contains a combination of the EXPRDUP_XXX flags. +** If the EXPRDUP_REDUCE flag is set, then the structure returned is a +** truncated version of the usual Expr structure that will be stored as +** part of the in-memory representation of the database schema. +*/ +SQLITE_PRIVATE Expr *sqlite3ExprDup(sqlite3 *db, const Expr *p, int flags){ + assert( flags==0 || flags==EXPRDUP_REDUCE ); + return p ? exprDup(db, p, flags, 0) : 0; +} +SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3 *db, const ExprList *p, int flags){ + ExprList *pNew; + struct ExprList_item *pItem; + const struct ExprList_item *pOldItem; + int i; + Expr *pPriorSelectColOld = 0; + Expr *pPriorSelectColNew = 0; + assert( db!=0 ); + if( p==0 ) return 0; + pNew = sqlite3DbMallocRawNN(db, sqlite3DbMallocSize(db, p)); + if( pNew==0 ) return 0; + pNew->nExpr = p->nExpr; + pNew->nAlloc = p->nAlloc; + pItem = pNew->a; + pOldItem = p->a; + for(i=0; inExpr; i++, pItem++, pOldItem++){ + Expr *pOldExpr = pOldItem->pExpr; + Expr *pNewExpr; + pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags); + if( pOldExpr + && pOldExpr->op==TK_SELECT_COLUMN + && (pNewExpr = pItem->pExpr)!=0 + ){ + if( pNewExpr->pRight ){ + pPriorSelectColOld = pOldExpr->pRight; + pPriorSelectColNew = pNewExpr->pRight; + pNewExpr->pLeft = pNewExpr->pRight; + }else{ + if( pOldExpr->pLeft!=pPriorSelectColOld ){ + pPriorSelectColOld = pOldExpr->pLeft; + pPriorSelectColNew = sqlite3ExprDup(db, pPriorSelectColOld, flags); + pNewExpr->pRight = pPriorSelectColNew; + } + pNewExpr->pLeft = pPriorSelectColNew; + } + } + pItem->zEName = sqlite3DbStrDup(db, pOldItem->zEName); + pItem->fg = pOldItem->fg; + pItem->fg.done = 0; + pItem->u = pOldItem->u; + } + return pNew; +} + +/* +** If cursors, triggers, views and subqueries are all omitted from +** the build, then none of the following routines, except for +** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes +** called with a NULL argument. +*/ +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \ + || !defined(SQLITE_OMIT_SUBQUERY) +SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3 *db, const SrcList *p, int flags){ + SrcList *pNew; + int i; + int nByte; + assert( db!=0 ); + if( p==0 ) return 0; + nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0); + pNew = sqlite3DbMallocRawNN(db, nByte ); + if( pNew==0 ) return 0; + pNew->nSrc = pNew->nAlloc = p->nSrc; + for(i=0; inSrc; i++){ + SrcItem *pNewItem = &pNew->a[i]; + const SrcItem *pOldItem = &p->a[i]; + Table *pTab; + pNewItem->pSchema = pOldItem->pSchema; + pNewItem->zDatabase = sqlite3DbStrDup(db, pOldItem->zDatabase); + pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName); + pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias); + pNewItem->fg = pOldItem->fg; + pNewItem->iCursor = pOldItem->iCursor; + pNewItem->addrFillSub = pOldItem->addrFillSub; + pNewItem->regReturn = pOldItem->regReturn; + if( pNewItem->fg.isIndexedBy ){ + pNewItem->u1.zIndexedBy = sqlite3DbStrDup(db, pOldItem->u1.zIndexedBy); + } + pNewItem->u2 = pOldItem->u2; + if( pNewItem->fg.isCte ){ + pNewItem->u2.pCteUse->nUse++; + } + if( pNewItem->fg.isTabFunc ){ + pNewItem->u1.pFuncArg = + sqlite3ExprListDup(db, pOldItem->u1.pFuncArg, flags); + } + pTab = pNewItem->pTab = pOldItem->pTab; + if( pTab ){ + pTab->nTabRef++; + } + pNewItem->pSelect = sqlite3SelectDup(db, pOldItem->pSelect, flags); + if( pOldItem->fg.isUsing ){ + assert( pNewItem->fg.isUsing ); + pNewItem->u3.pUsing = sqlite3IdListDup(db, pOldItem->u3.pUsing); + }else{ + pNewItem->u3.pOn = sqlite3ExprDup(db, pOldItem->u3.pOn, flags); + } + pNewItem->colUsed = pOldItem->colUsed; + } + return pNew; +} +SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3 *db, const IdList *p){ + IdList *pNew; + int i; + assert( db!=0 ); + if( p==0 ) return 0; + assert( p->eU4!=EU4_EXPR ); + pNew = sqlite3DbMallocRawNN(db, sizeof(*pNew)+(p->nId-1)*sizeof(p->a[0]) ); + if( pNew==0 ) return 0; + pNew->nId = p->nId; + pNew->eU4 = p->eU4; + for(i=0; inId; i++){ + struct IdList_item *pNewItem = &pNew->a[i]; + const struct IdList_item *pOldItem = &p->a[i]; + pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName); + pNewItem->u4 = pOldItem->u4; + } + return pNew; +} +SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, const Select *pDup, int flags){ + Select *pRet = 0; + Select *pNext = 0; + Select **pp = &pRet; + const Select *p; + + assert( db!=0 ); + for(p=pDup; p; p=p->pPrior){ + Select *pNew = sqlite3DbMallocRawNN(db, sizeof(*p) ); + if( pNew==0 ) break; + pNew->pEList = sqlite3ExprListDup(db, p->pEList, flags); + pNew->pSrc = sqlite3SrcListDup(db, p->pSrc, flags); + pNew->pWhere = sqlite3ExprDup(db, p->pWhere, flags); + pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy, flags); + pNew->pHaving = sqlite3ExprDup(db, p->pHaving, flags); + pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, flags); + pNew->op = p->op; + pNew->pNext = pNext; + pNew->pPrior = 0; + pNew->pLimit = sqlite3ExprDup(db, p->pLimit, flags); + pNew->iLimit = 0; + pNew->iOffset = 0; + pNew->selFlags = p->selFlags & ~SF_UsesEphemeral; + pNew->addrOpenEphm[0] = -1; + pNew->addrOpenEphm[1] = -1; + pNew->nSelectRow = p->nSelectRow; + pNew->pWith = sqlite3WithDup(db, p->pWith); +#ifndef SQLITE_OMIT_WINDOWFUNC + pNew->pWin = 0; + pNew->pWinDefn = sqlite3WindowListDup(db, p->pWinDefn); + if( p->pWin && db->mallocFailed==0 ) gatherSelectWindows(pNew); +#endif + pNew->selId = p->selId; + if( db->mallocFailed ){ + /* Any prior OOM might have left the Select object incomplete. + ** Delete the whole thing rather than allow an incomplete Select + ** to be used by the code generator. */ + pNew->pNext = 0; + sqlite3SelectDelete(db, pNew); + break; + } + *pp = pNew; + pp = &pNew->pPrior; + pNext = pNew; + } + + return pRet; +} +#else +SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, const Select *p, int flags){ + assert( p==0 ); + return 0; +} +#endif + + +/* +** Add a new element to the end of an expression list. If pList is +** initially NULL, then create a new expression list. +** +** The pList argument must be either NULL or a pointer to an ExprList +** obtained from a prior call to sqlite3ExprListAppend(). This routine +** may not be used with an ExprList obtained from sqlite3ExprListDup(). +** Reason: This routine assumes that the number of slots in pList->a[] +** is a power of two. That is true for sqlite3ExprListAppend() returns +** but is not necessarily true from the return value of sqlite3ExprListDup(). +** +** If a memory allocation error occurs, the entire list is freed and +** NULL is returned. If non-NULL is returned, then it is guaranteed +** that the new entry was successfully appended. +*/ +static const struct ExprList_item zeroItem = {0}; +SQLITE_PRIVATE SQLITE_NOINLINE ExprList *sqlite3ExprListAppendNew( + sqlite3 *db, /* Database handle. Used for memory allocation */ + Expr *pExpr /* Expression to be appended. Might be NULL */ +){ + struct ExprList_item *pItem; + ExprList *pList; + + pList = sqlite3DbMallocRawNN(db, sizeof(ExprList)+sizeof(pList->a[0])*4 ); + if( pList==0 ){ + sqlite3ExprDelete(db, pExpr); + return 0; + } + pList->nAlloc = 4; + pList->nExpr = 1; + pItem = &pList->a[0]; + *pItem = zeroItem; + pItem->pExpr = pExpr; + return pList; +} +SQLITE_PRIVATE SQLITE_NOINLINE ExprList *sqlite3ExprListAppendGrow( + sqlite3 *db, /* Database handle. Used for memory allocation */ + ExprList *pList, /* List to which to append. Might be NULL */ + Expr *pExpr /* Expression to be appended. Might be NULL */ +){ + struct ExprList_item *pItem; + ExprList *pNew; + pList->nAlloc *= 2; + pNew = sqlite3DbRealloc(db, pList, + sizeof(*pList)+(pList->nAlloc-1)*sizeof(pList->a[0])); + if( pNew==0 ){ + sqlite3ExprListDelete(db, pList); + sqlite3ExprDelete(db, pExpr); + return 0; + }else{ + pList = pNew; + } + pItem = &pList->a[pList->nExpr++]; + *pItem = zeroItem; + pItem->pExpr = pExpr; + return pList; +} +SQLITE_PRIVATE ExprList *sqlite3ExprListAppend( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* List to which to append. Might be NULL */ + Expr *pExpr /* Expression to be appended. Might be NULL */ +){ + struct ExprList_item *pItem; + if( pList==0 ){ + return sqlite3ExprListAppendNew(pParse->db,pExpr); + } + if( pList->nAllocnExpr+1 ){ + return sqlite3ExprListAppendGrow(pParse->db,pList,pExpr); + } + pItem = &pList->a[pList->nExpr++]; + *pItem = zeroItem; + pItem->pExpr = pExpr; + return pList; +} + +/* +** pColumns and pExpr form a vector assignment which is part of the SET +** clause of an UPDATE statement. Like this: +** +** (a,b,c) = (expr1,expr2,expr3) +** Or: (a,b,c) = (SELECT x,y,z FROM ....) +** +** For each term of the vector assignment, append new entries to the +** expression list pList. In the case of a subquery on the RHS, append +** TK_SELECT_COLUMN expressions. +*/ +SQLITE_PRIVATE ExprList *sqlite3ExprListAppendVector( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* List to which to append. Might be NULL */ + IdList *pColumns, /* List of names of LHS of the assignment */ + Expr *pExpr /* Vector expression to be appended. Might be NULL */ +){ + sqlite3 *db = pParse->db; + int n; + int i; + int iFirst = pList ? pList->nExpr : 0; + /* pColumns can only be NULL due to an OOM but an OOM will cause an + ** exit prior to this routine being invoked */ + if( NEVER(pColumns==0) ) goto vector_append_error; + if( pExpr==0 ) goto vector_append_error; + + /* If the RHS is a vector, then we can immediately check to see that + ** the size of the RHS and LHS match. But if the RHS is a SELECT, + ** wildcards ("*") in the result set of the SELECT must be expanded before + ** we can do the size check, so defer the size check until code generation. + */ + if( pExpr->op!=TK_SELECT && pColumns->nId!=(n=sqlite3ExprVectorSize(pExpr)) ){ + sqlite3ErrorMsg(pParse, "%d columns assigned %d values", + pColumns->nId, n); + goto vector_append_error; + } + + for(i=0; inId; i++){ + Expr *pSubExpr = sqlite3ExprForVectorField(pParse, pExpr, i, pColumns->nId); + assert( pSubExpr!=0 || db->mallocFailed ); + if( pSubExpr==0 ) continue; + pList = sqlite3ExprListAppend(pParse, pList, pSubExpr); + if( pList ){ + assert( pList->nExpr==iFirst+i+1 ); + pList->a[pList->nExpr-1].zEName = pColumns->a[i].zName; + pColumns->a[i].zName = 0; + } + } + + if( !db->mallocFailed && pExpr->op==TK_SELECT && ALWAYS(pList!=0) ){ + Expr *pFirst = pList->a[iFirst].pExpr; + assert( pFirst!=0 ); + assert( pFirst->op==TK_SELECT_COLUMN ); + + /* Store the SELECT statement in pRight so it will be deleted when + ** sqlite3ExprListDelete() is called */ + pFirst->pRight = pExpr; + pExpr = 0; + + /* Remember the size of the LHS in iTable so that we can check that + ** the RHS and LHS sizes match during code generation. */ + pFirst->iTable = pColumns->nId; + } + +vector_append_error: + sqlite3ExprUnmapAndDelete(pParse, pExpr); + sqlite3IdListDelete(db, pColumns); + return pList; +} + +/* +** Set the sort order for the last element on the given ExprList. +*/ +SQLITE_PRIVATE void sqlite3ExprListSetSortOrder(ExprList *p, int iSortOrder, int eNulls){ + struct ExprList_item *pItem; + if( p==0 ) return; + assert( p->nExpr>0 ); + + assert( SQLITE_SO_UNDEFINED<0 && SQLITE_SO_ASC==0 && SQLITE_SO_DESC>0 ); + assert( iSortOrder==SQLITE_SO_UNDEFINED + || iSortOrder==SQLITE_SO_ASC + || iSortOrder==SQLITE_SO_DESC + ); + assert( eNulls==SQLITE_SO_UNDEFINED + || eNulls==SQLITE_SO_ASC + || eNulls==SQLITE_SO_DESC + ); + + pItem = &p->a[p->nExpr-1]; + assert( pItem->fg.bNulls==0 ); + if( iSortOrder==SQLITE_SO_UNDEFINED ){ + iSortOrder = SQLITE_SO_ASC; + } + pItem->fg.sortFlags = (u8)iSortOrder; + + if( eNulls!=SQLITE_SO_UNDEFINED ){ + pItem->fg.bNulls = 1; + if( iSortOrder!=eNulls ){ + pItem->fg.sortFlags |= KEYINFO_ORDER_BIGNULL; + } + } +} + +/* +** Set the ExprList.a[].zEName element of the most recently added item +** on the expression list. +** +** pList might be NULL following an OOM error. But pName should never be +** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag +** is set. +*/ +SQLITE_PRIVATE void sqlite3ExprListSetName( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* List to which to add the span. */ + const Token *pName, /* Name to be added */ + int dequote /* True to cause the name to be dequoted */ +){ + assert( pList!=0 || pParse->db->mallocFailed!=0 ); + assert( pParse->eParseMode!=PARSE_MODE_UNMAP || dequote==0 ); + if( pList ){ + struct ExprList_item *pItem; + assert( pList->nExpr>0 ); + pItem = &pList->a[pList->nExpr-1]; + assert( pItem->zEName==0 ); + assert( pItem->fg.eEName==ENAME_NAME ); + pItem->zEName = sqlite3DbStrNDup(pParse->db, pName->z, pName->n); + if( dequote ){ + /* If dequote==0, then pName->z does not point to part of a DDL + ** statement handled by the parser. And so no token need be added + ** to the token-map. */ + sqlite3Dequote(pItem->zEName); + if( IN_RENAME_OBJECT ){ + sqlite3RenameTokenMap(pParse, (const void*)pItem->zEName, pName); + } + } + } +} + +/* +** Set the ExprList.a[].zSpan element of the most recently added item +** on the expression list. +** +** pList might be NULL following an OOM error. But pSpan should never be +** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag +** is set. +*/ +SQLITE_PRIVATE void sqlite3ExprListSetSpan( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* List to which to add the span. */ + const char *zStart, /* Start of the span */ + const char *zEnd /* End of the span */ +){ + sqlite3 *db = pParse->db; + assert( pList!=0 || db->mallocFailed!=0 ); + if( pList ){ + struct ExprList_item *pItem = &pList->a[pList->nExpr-1]; + assert( pList->nExpr>0 ); + if( pItem->zEName==0 ){ + pItem->zEName = sqlite3DbSpanDup(db, zStart, zEnd); + pItem->fg.eEName = ENAME_SPAN; + } + } +} + +/* +** If the expression list pEList contains more than iLimit elements, +** leave an error message in pParse. +*/ +SQLITE_PRIVATE void sqlite3ExprListCheckLength( + Parse *pParse, + ExprList *pEList, + const char *zObject +){ + int mx = pParse->db->aLimit[SQLITE_LIMIT_COLUMN]; + testcase( pEList && pEList->nExpr==mx ); + testcase( pEList && pEList->nExpr==mx+1 ); + if( pEList && pEList->nExpr>mx ){ + sqlite3ErrorMsg(pParse, "too many columns in %s", zObject); + } +} + +/* +** Delete an entire expression list. +*/ +static SQLITE_NOINLINE void exprListDeleteNN(sqlite3 *db, ExprList *pList){ + int i = pList->nExpr; + struct ExprList_item *pItem = pList->a; + assert( pList->nExpr>0 ); + assert( db!=0 ); + do{ + sqlite3ExprDelete(db, pItem->pExpr); + if( pItem->zEName ) sqlite3DbNNFreeNN(db, pItem->zEName); + pItem++; + }while( --i>0 ); + sqlite3DbNNFreeNN(db, pList); +} +SQLITE_PRIVATE void sqlite3ExprListDelete(sqlite3 *db, ExprList *pList){ + if( pList ) exprListDeleteNN(db, pList); +} + +/* +** Return the bitwise-OR of all Expr.flags fields in the given +** ExprList. +*/ +SQLITE_PRIVATE u32 sqlite3ExprListFlags(const ExprList *pList){ + int i; + u32 m = 0; + assert( pList!=0 ); + for(i=0; inExpr; i++){ + Expr *pExpr = pList->a[i].pExpr; + assert( pExpr!=0 ); + m |= pExpr->flags; + } + return m; +} + +/* +** This is a SELECT-node callback for the expression walker that +** always "fails". By "fail" in this case, we mean set +** pWalker->eCode to zero and abort. +** +** This callback is used by multiple expression walkers. +*/ +SQLITE_PRIVATE int sqlite3SelectWalkFail(Walker *pWalker, Select *NotUsed){ + UNUSED_PARAMETER(NotUsed); + pWalker->eCode = 0; + return WRC_Abort; +} + +/* +** Check the input string to see if it is "true" or "false" (in any case). +** +** If the string is.... Return +** "true" EP_IsTrue +** "false" EP_IsFalse +** anything else 0 +*/ +SQLITE_PRIVATE u32 sqlite3IsTrueOrFalse(const char *zIn){ + if( sqlite3StrICmp(zIn, "true")==0 ) return EP_IsTrue; + if( sqlite3StrICmp(zIn, "false")==0 ) return EP_IsFalse; + return 0; +} + + +/* +** If the input expression is an ID with the name "true" or "false" +** then convert it into an TK_TRUEFALSE term. Return non-zero if +** the conversion happened, and zero if the expression is unaltered. +*/ +SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr *pExpr){ + u32 v; + assert( pExpr->op==TK_ID || pExpr->op==TK_STRING ); + if( !ExprHasProperty(pExpr, EP_Quoted|EP_IntValue) + && (v = sqlite3IsTrueOrFalse(pExpr->u.zToken))!=0 + ){ + pExpr->op = TK_TRUEFALSE; + ExprSetProperty(pExpr, v); + return 1; + } + return 0; +} + +/* +** The argument must be a TK_TRUEFALSE Expr node. Return 1 if it is TRUE +** and 0 if it is FALSE. +*/ +SQLITE_PRIVATE int sqlite3ExprTruthValue(const Expr *pExpr){ + pExpr = sqlite3ExprSkipCollate((Expr*)pExpr); + assert( pExpr->op==TK_TRUEFALSE ); + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + assert( sqlite3StrICmp(pExpr->u.zToken,"true")==0 + || sqlite3StrICmp(pExpr->u.zToken,"false")==0 ); + return pExpr->u.zToken[4]==0; +} + +/* +** If pExpr is an AND or OR expression, try to simplify it by eliminating +** terms that are always true or false. Return the simplified expression. +** Or return the original expression if no simplification is possible. +** +** Examples: +** +** (x<10) AND true => (x<10) +** (x<10) AND false => false +** (x<10) AND (y=22 OR false) => (x<10) AND (y=22) +** (x<10) AND (y=22 OR true) => (x<10) +** (y=22) OR true => true +*/ +SQLITE_PRIVATE Expr *sqlite3ExprSimplifiedAndOr(Expr *pExpr){ + assert( pExpr!=0 ); + if( pExpr->op==TK_AND || pExpr->op==TK_OR ){ + Expr *pRight = sqlite3ExprSimplifiedAndOr(pExpr->pRight); + Expr *pLeft = sqlite3ExprSimplifiedAndOr(pExpr->pLeft); + if( ExprAlwaysTrue(pLeft) || ExprAlwaysFalse(pRight) ){ + pExpr = pExpr->op==TK_AND ? pRight : pLeft; + }else if( ExprAlwaysTrue(pRight) || ExprAlwaysFalse(pLeft) ){ + pExpr = pExpr->op==TK_AND ? pLeft : pRight; + } + } + return pExpr; +} + + +/* +** These routines are Walker callbacks used to check expressions to +** see if they are "constant" for some definition of constant. The +** Walker.eCode value determines the type of "constant" we are looking +** for. +** +** These callback routines are used to implement the following: +** +** sqlite3ExprIsConstant() pWalker->eCode==1 +** sqlite3ExprIsConstantNotJoin() pWalker->eCode==2 +** sqlite3ExprIsTableConstant() pWalker->eCode==3 +** sqlite3ExprIsConstantOrFunction() pWalker->eCode==4 or 5 +** +** In all cases, the callbacks set Walker.eCode=0 and abort if the expression +** is found to not be a constant. +** +** The sqlite3ExprIsConstantOrFunction() is used for evaluating DEFAULT +** expressions in a CREATE TABLE statement. The Walker.eCode value is 5 +** when parsing an existing schema out of the sqlite_schema table and 4 +** when processing a new CREATE TABLE statement. A bound parameter raises +** an error for new statements, but is silently converted +** to NULL for existing schemas. This allows sqlite_schema tables that +** contain a bound parameter because they were generated by older versions +** of SQLite to be parsed by newer versions of SQLite without raising a +** malformed schema error. +*/ +static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){ + + /* If pWalker->eCode is 2 then any term of the expression that comes from + ** the ON or USING clauses of an outer join disqualifies the expression + ** from being considered constant. */ + if( pWalker->eCode==2 && ExprHasProperty(pExpr, EP_OuterON) ){ + pWalker->eCode = 0; + return WRC_Abort; + } + + switch( pExpr->op ){ + /* Consider functions to be constant if all their arguments are constant + ** and either pWalker->eCode==4 or 5 or the function has the + ** SQLITE_FUNC_CONST flag. */ + case TK_FUNCTION: + if( (pWalker->eCode>=4 || ExprHasProperty(pExpr,EP_ConstFunc)) + && !ExprHasProperty(pExpr, EP_WinFunc) + ){ + if( pWalker->eCode==5 ) ExprSetProperty(pExpr, EP_FromDDL); + return WRC_Continue; + }else{ + pWalker->eCode = 0; + return WRC_Abort; + } + case TK_ID: + /* Convert "true" or "false" in a DEFAULT clause into the + ** appropriate TK_TRUEFALSE operator */ + if( sqlite3ExprIdToTrueFalse(pExpr) ){ + return WRC_Prune; + } + /* no break */ deliberate_fall_through + case TK_COLUMN: + case TK_AGG_FUNCTION: + case TK_AGG_COLUMN: + testcase( pExpr->op==TK_ID ); + testcase( pExpr->op==TK_COLUMN ); + testcase( pExpr->op==TK_AGG_FUNCTION ); + testcase( pExpr->op==TK_AGG_COLUMN ); + if( ExprHasProperty(pExpr, EP_FixedCol) && pWalker->eCode!=2 ){ + return WRC_Continue; + } + if( pWalker->eCode==3 && pExpr->iTable==pWalker->u.iCur ){ + return WRC_Continue; + } + /* no break */ deliberate_fall_through + case TK_IF_NULL_ROW: + case TK_REGISTER: + case TK_DOT: + testcase( pExpr->op==TK_REGISTER ); + testcase( pExpr->op==TK_IF_NULL_ROW ); + testcase( pExpr->op==TK_DOT ); + pWalker->eCode = 0; + return WRC_Abort; + case TK_VARIABLE: + if( pWalker->eCode==5 ){ + /* Silently convert bound parameters that appear inside of CREATE + ** statements into a NULL when parsing the CREATE statement text out + ** of the sqlite_schema table */ + pExpr->op = TK_NULL; + }else if( pWalker->eCode==4 ){ + /* A bound parameter in a CREATE statement that originates from + ** sqlite3_prepare() causes an error */ + pWalker->eCode = 0; + return WRC_Abort; + } + /* no break */ deliberate_fall_through + default: + testcase( pExpr->op==TK_SELECT ); /* sqlite3SelectWalkFail() disallows */ + testcase( pExpr->op==TK_EXISTS ); /* sqlite3SelectWalkFail() disallows */ + return WRC_Continue; + } +} +static int exprIsConst(Expr *p, int initFlag, int iCur){ + Walker w; + w.eCode = initFlag; + w.xExprCallback = exprNodeIsConstant; + w.xSelectCallback = sqlite3SelectWalkFail; +#ifdef SQLITE_DEBUG + w.xSelectCallback2 = sqlite3SelectWalkAssert2; +#endif + w.u.iCur = iCur; + sqlite3WalkExpr(&w, p); + return w.eCode; +} + +/* +** Walk an expression tree. Return non-zero if the expression is constant +** and 0 if it involves variables or function calls. +** +** For the purposes of this function, a double-quoted string (ex: "abc") +** is considered a variable but a single-quoted string (ex: 'abc') is +** a constant. +*/ +SQLITE_PRIVATE int sqlite3ExprIsConstant(Expr *p){ + return exprIsConst(p, 1, 0); +} + +/* +** Walk an expression tree. Return non-zero if +** +** (1) the expression is constant, and +** (2) the expression does originate in the ON or USING clause +** of a LEFT JOIN, and +** (3) the expression does not contain any EP_FixedCol TK_COLUMN +** operands created by the constant propagation optimization. +** +** When this routine returns true, it indicates that the expression +** can be added to the pParse->pConstExpr list and evaluated once when +** the prepared statement starts up. See sqlite3ExprCodeRunJustOnce(). +*/ +SQLITE_PRIVATE int sqlite3ExprIsConstantNotJoin(Expr *p){ + return exprIsConst(p, 2, 0); +} + +/* +** Walk an expression tree. Return non-zero if the expression is constant +** for any single row of the table with cursor iCur. In other words, the +** expression must not refer to any non-deterministic function nor any +** table other than iCur. +*/ +SQLITE_PRIVATE int sqlite3ExprIsTableConstant(Expr *p, int iCur){ + return exprIsConst(p, 3, iCur); +} + +/* +** Check pExpr to see if it is an constraint on the single data source +** pSrc = &pSrcList->a[iSrc]. In other words, check to see if pExpr +** constrains pSrc but does not depend on any other tables or data +** sources anywhere else in the query. Return true (non-zero) if pExpr +** is a constraint on pSrc only. +** +** This is an optimization. False negatives will perhaps cause slower +** queries, but false positives will yield incorrect answers. So when in +** doubt, return 0. +** +** To be an single-source constraint, the following must be true: +** +** (1) pExpr cannot refer to any table other than pSrc->iCursor. +** +** (2) pExpr cannot use subqueries or non-deterministic functions. +** +** (3) pSrc cannot be part of the left operand for a RIGHT JOIN. +** (Is there some way to relax this constraint?) +** +** (4) If pSrc is the right operand of a LEFT JOIN, then... +** (4a) pExpr must come from an ON clause.. +** (4b) and specifically the ON clause associated with the LEFT JOIN. +** +** (5) If pSrc is not the right operand of a LEFT JOIN or the left +** operand of a RIGHT JOIN, then pExpr must be from the WHERE +** clause, not an ON clause. +** +** (6) Either: +** +** (6a) pExpr does not originate in an ON or USING clause, or +** +** (6b) The ON or USING clause from which pExpr is derived is +** not to the left of a RIGHT JOIN (or FULL JOIN). +** +** Without this restriction, accepting pExpr as a single-table +** constraint might move the the ON/USING filter expression +** from the left side of a RIGHT JOIN over to the right side, +** which leads to incorrect answers. See also restriction (9) +** on push-down. +*/ +SQLITE_PRIVATE int sqlite3ExprIsSingleTableConstraint( + Expr *pExpr, /* The constraint */ + const SrcList *pSrcList, /* Complete FROM clause */ + int iSrc /* Which element of pSrcList to use */ +){ + const SrcItem *pSrc = &pSrcList->a[iSrc]; + if( pSrc->fg.jointype & JT_LTORJ ){ + return 0; /* rule (3) */ + } + if( pSrc->fg.jointype & JT_LEFT ){ + if( !ExprHasProperty(pExpr, EP_OuterON) ) return 0; /* rule (4a) */ + if( pExpr->w.iJoin!=pSrc->iCursor ) return 0; /* rule (4b) */ + }else{ + if( ExprHasProperty(pExpr, EP_OuterON) ) return 0; /* rule (5) */ + } + if( ExprHasProperty(pExpr, EP_OuterON|EP_InnerON) /* (6a) */ + && (pSrcList->a[0].fg.jointype & JT_LTORJ)!=0 /* Fast pre-test of (6b) */ + ){ + int jj; + for(jj=0; jjw.iJoin==pSrcList->a[jj].iCursor ){ + if( (pSrcList->a[jj].fg.jointype & JT_LTORJ)!=0 ){ + return 0; /* restriction (6) */ + } + break; + } + } + } + return sqlite3ExprIsTableConstant(pExpr, pSrc->iCursor); /* rules (1), (2) */ +} + + +/* +** sqlite3WalkExpr() callback used by sqlite3ExprIsConstantOrGroupBy(). +*/ +static int exprNodeIsConstantOrGroupBy(Walker *pWalker, Expr *pExpr){ + ExprList *pGroupBy = pWalker->u.pGroupBy; + int i; + + /* Check if pExpr is identical to any GROUP BY term. If so, consider + ** it constant. */ + for(i=0; inExpr; i++){ + Expr *p = pGroupBy->a[i].pExpr; + if( sqlite3ExprCompare(0, pExpr, p, -1)<2 ){ + CollSeq *pColl = sqlite3ExprNNCollSeq(pWalker->pParse, p); + if( sqlite3IsBinary(pColl) ){ + return WRC_Prune; + } + } + } + + /* Check if pExpr is a sub-select. If so, consider it variable. */ + if( ExprUseXSelect(pExpr) ){ + pWalker->eCode = 0; + return WRC_Abort; + } + + return exprNodeIsConstant(pWalker, pExpr); +} + +/* +** Walk the expression tree passed as the first argument. Return non-zero +** if the expression consists entirely of constants or copies of terms +** in pGroupBy that sort with the BINARY collation sequence. +** +** This routine is used to determine if a term of the HAVING clause can +** be promoted into the WHERE clause. In order for such a promotion to work, +** the value of the HAVING clause term must be the same for all members of +** a "group". The requirement that the GROUP BY term must be BINARY +** assumes that no other collating sequence will have a finer-grained +** grouping than binary. In other words (A=B COLLATE binary) implies +** A=B in every other collating sequence. The requirement that the +** GROUP BY be BINARY is stricter than necessary. It would also work +** to promote HAVING clauses that use the same alternative collating +** sequence as the GROUP BY term, but that is much harder to check, +** alternative collating sequences are uncommon, and this is only an +** optimization, so we take the easy way out and simply require the +** GROUP BY to use the BINARY collating sequence. +*/ +SQLITE_PRIVATE int sqlite3ExprIsConstantOrGroupBy(Parse *pParse, Expr *p, ExprList *pGroupBy){ + Walker w; + w.eCode = 1; + w.xExprCallback = exprNodeIsConstantOrGroupBy; + w.xSelectCallback = 0; + w.u.pGroupBy = pGroupBy; + w.pParse = pParse; + sqlite3WalkExpr(&w, p); + return w.eCode; +} + +/* +** Walk an expression tree for the DEFAULT field of a column definition +** in a CREATE TABLE statement. Return non-zero if the expression is +** acceptable for use as a DEFAULT. That is to say, return non-zero if +** the expression is constant or a function call with constant arguments. +** Return and 0 if there are any variables. +** +** isInit is true when parsing from sqlite_schema. isInit is false when +** processing a new CREATE TABLE statement. When isInit is true, parameters +** (such as ? or $abc) in the expression are converted into NULL. When +** isInit is false, parameters raise an error. Parameters should not be +** allowed in a CREATE TABLE statement, but some legacy versions of SQLite +** allowed it, so we need to support it when reading sqlite_schema for +** backwards compatibility. +** +** If isInit is true, set EP_FromDDL on every TK_FUNCTION node. +** +** For the purposes of this function, a double-quoted string (ex: "abc") +** is considered a variable but a single-quoted string (ex: 'abc') is +** a constant. +*/ +SQLITE_PRIVATE int sqlite3ExprIsConstantOrFunction(Expr *p, u8 isInit){ + assert( isInit==0 || isInit==1 ); + return exprIsConst(p, 4+isInit, 0); +} + +#ifdef SQLITE_ENABLE_CURSOR_HINTS +/* +** Walk an expression tree. Return 1 if the expression contains a +** subquery of some kind. Return 0 if there are no subqueries. +*/ +SQLITE_PRIVATE int sqlite3ExprContainsSubquery(Expr *p){ + Walker w; + w.eCode = 1; + w.xExprCallback = sqlite3ExprWalkNoop; + w.xSelectCallback = sqlite3SelectWalkFail; +#ifdef SQLITE_DEBUG + w.xSelectCallback2 = sqlite3SelectWalkAssert2; +#endif + sqlite3WalkExpr(&w, p); + return w.eCode==0; +} +#endif + +/* +** If the expression p codes a constant integer that is small enough +** to fit in a 32-bit integer, return 1 and put the value of the integer +** in *pValue. If the expression is not an integer or if it is too big +** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged. +*/ +SQLITE_PRIVATE int sqlite3ExprIsInteger(const Expr *p, int *pValue){ + int rc = 0; + if( NEVER(p==0) ) return 0; /* Used to only happen following on OOM */ + + /* If an expression is an integer literal that fits in a signed 32-bit + ** integer, then the EP_IntValue flag will have already been set */ + assert( p->op!=TK_INTEGER || (p->flags & EP_IntValue)!=0 + || sqlite3GetInt32(p->u.zToken, &rc)==0 ); + + if( p->flags & EP_IntValue ){ + *pValue = p->u.iValue; + return 1; + } + switch( p->op ){ + case TK_UPLUS: { + rc = sqlite3ExprIsInteger(p->pLeft, pValue); + break; + } + case TK_UMINUS: { + int v = 0; + if( sqlite3ExprIsInteger(p->pLeft, &v) ){ + assert( ((unsigned int)v)!=0x80000000 ); + *pValue = -v; + rc = 1; + } + break; + } + default: break; + } + return rc; +} + +/* +** Return FALSE if there is no chance that the expression can be NULL. +** +** If the expression might be NULL or if the expression is too complex +** to tell return TRUE. +** +** This routine is used as an optimization, to skip OP_IsNull opcodes +** when we know that a value cannot be NULL. Hence, a false positive +** (returning TRUE when in fact the expression can never be NULL) might +** be a small performance hit but is otherwise harmless. On the other +** hand, a false negative (returning FALSE when the result could be NULL) +** will likely result in an incorrect answer. So when in doubt, return +** TRUE. +*/ +SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr *p){ + u8 op; + assert( p!=0 ); + while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ + p = p->pLeft; + assert( p!=0 ); + } + op = p->op; + if( op==TK_REGISTER ) op = p->op2; + switch( op ){ + case TK_INTEGER: + case TK_STRING: + case TK_FLOAT: + case TK_BLOB: + return 0; + case TK_COLUMN: + assert( ExprUseYTab(p) ); + return ExprHasProperty(p, EP_CanBeNull) || + p->y.pTab==0 || /* Reference to column of index on expression */ + (p->iColumn>=0 + && p->y.pTab->aCol!=0 /* Possible due to prior error */ + && p->y.pTab->aCol[p->iColumn].notNull==0); + default: + return 1; + } +} + +/* +** Return TRUE if the given expression is a constant which would be +** unchanged by OP_Affinity with the affinity given in the second +** argument. +** +** This routine is used to determine if the OP_Affinity operation +** can be omitted. When in doubt return FALSE. A false negative +** is harmless. A false positive, however, can result in the wrong +** answer. +*/ +SQLITE_PRIVATE int sqlite3ExprNeedsNoAffinityChange(const Expr *p, char aff){ + u8 op; + int unaryMinus = 0; + if( aff==SQLITE_AFF_BLOB ) return 1; + while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ + if( p->op==TK_UMINUS ) unaryMinus = 1; + p = p->pLeft; + } + op = p->op; + if( op==TK_REGISTER ) op = p->op2; + switch( op ){ + case TK_INTEGER: { + return aff>=SQLITE_AFF_NUMERIC; + } + case TK_FLOAT: { + return aff>=SQLITE_AFF_NUMERIC; + } + case TK_STRING: { + return !unaryMinus && aff==SQLITE_AFF_TEXT; + } + case TK_BLOB: { + return !unaryMinus; + } + case TK_COLUMN: { + assert( p->iTable>=0 ); /* p cannot be part of a CHECK constraint */ + return aff>=SQLITE_AFF_NUMERIC && p->iColumn<0; + } + default: { + return 0; + } + } +} + +/* +** Return TRUE if the given string is a row-id column name. +*/ +SQLITE_PRIVATE int sqlite3IsRowid(const char *z){ + if( sqlite3StrICmp(z, "_ROWID_")==0 ) return 1; + if( sqlite3StrICmp(z, "ROWID")==0 ) return 1; + if( sqlite3StrICmp(z, "OID")==0 ) return 1; + return 0; +} + +/* +** pX is the RHS of an IN operator. If pX is a SELECT statement +** that can be simplified to a direct table access, then return +** a pointer to the SELECT statement. If pX is not a SELECT statement, +** or if the SELECT statement needs to be materialized into a transient +** table, then return NULL. +*/ +#ifndef SQLITE_OMIT_SUBQUERY +static Select *isCandidateForInOpt(const Expr *pX){ + Select *p; + SrcList *pSrc; + ExprList *pEList; + Table *pTab; + int i; + if( !ExprUseXSelect(pX) ) return 0; /* Not a subquery */ + if( ExprHasProperty(pX, EP_VarSelect) ) return 0; /* Correlated subq */ + p = pX->x.pSelect; + if( p->pPrior ) return 0; /* Not a compound SELECT */ + if( p->selFlags & (SF_Distinct|SF_Aggregate) ){ + testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct ); + testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate ); + return 0; /* No DISTINCT keyword and no aggregate functions */ + } + assert( p->pGroupBy==0 ); /* Has no GROUP BY clause */ + if( p->pLimit ) return 0; /* Has no LIMIT clause */ + if( p->pWhere ) return 0; /* Has no WHERE clause */ + pSrc = p->pSrc; + assert( pSrc!=0 ); + if( pSrc->nSrc!=1 ) return 0; /* Single term in FROM clause */ + if( pSrc->a[0].pSelect ) return 0; /* FROM is not a subquery or view */ + pTab = pSrc->a[0].pTab; + assert( pTab!=0 ); + assert( !IsView(pTab) ); /* FROM clause is not a view */ + if( IsVirtual(pTab) ) return 0; /* FROM clause not a virtual table */ + pEList = p->pEList; + assert( pEList!=0 ); + /* All SELECT results must be columns. */ + for(i=0; inExpr; i++){ + Expr *pRes = pEList->a[i].pExpr; + if( pRes->op!=TK_COLUMN ) return 0; + assert( pRes->iTable==pSrc->a[0].iCursor ); /* Not a correlated subquery */ + } + return p; +} +#endif /* SQLITE_OMIT_SUBQUERY */ + +#ifndef SQLITE_OMIT_SUBQUERY +/* +** Generate code that checks the left-most column of index table iCur to see if +** it contains any NULL entries. Cause the register at regHasNull to be set +** to a non-NULL value if iCur contains no NULLs. Cause register regHasNull +** to be set to NULL if iCur contains one or more NULL values. +*/ +static void sqlite3SetHasNullFlag(Vdbe *v, int iCur, int regHasNull){ + int addr1; + sqlite3VdbeAddOp2(v, OP_Integer, 0, regHasNull); + addr1 = sqlite3VdbeAddOp1(v, OP_Rewind, iCur); VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_Column, iCur, 0, regHasNull); + sqlite3VdbeChangeP5(v, OPFLAG_TYPEOFARG); + VdbeComment((v, "first_entry_in(%d)", iCur)); + sqlite3VdbeJumpHere(v, addr1); +} +#endif + + +#ifndef SQLITE_OMIT_SUBQUERY +/* +** The argument is an IN operator with a list (not a subquery) on the +** right-hand side. Return TRUE if that list is constant. +*/ +static int sqlite3InRhsIsConstant(Expr *pIn){ + Expr *pLHS; + int res; + assert( !ExprHasProperty(pIn, EP_xIsSelect) ); + pLHS = pIn->pLeft; + pIn->pLeft = 0; + res = sqlite3ExprIsConstant(pIn); + pIn->pLeft = pLHS; + return res; +} +#endif + +/* +** This function is used by the implementation of the IN (...) operator. +** The pX parameter is the expression on the RHS of the IN operator, which +** might be either a list of expressions or a subquery. +** +** The job of this routine is to find or create a b-tree object that can +** be used either to test for membership in the RHS set or to iterate through +** all members of the RHS set, skipping duplicates. +** +** A cursor is opened on the b-tree object that is the RHS of the IN operator +** and the *piTab parameter is set to the index of that cursor. +** +** The returned value of this function indicates the b-tree type, as follows: +** +** IN_INDEX_ROWID - The cursor was opened on a database table. +** IN_INDEX_INDEX_ASC - The cursor was opened on an ascending index. +** IN_INDEX_INDEX_DESC - The cursor was opened on a descending index. +** IN_INDEX_EPH - The cursor was opened on a specially created and +** populated epheremal table. +** IN_INDEX_NOOP - No cursor was allocated. The IN operator must be +** implemented as a sequence of comparisons. +** +** An existing b-tree might be used if the RHS expression pX is a simple +** subquery such as: +** +** SELECT , ... FROM +** +** If the RHS of the IN operator is a list or a more complex subquery, then +** an ephemeral table might need to be generated from the RHS and then +** pX->iTable made to point to the ephemeral table instead of an +** existing table. In this case, the creation and initialization of the +** ephmeral table might be put inside of a subroutine, the EP_Subrtn flag +** will be set on pX and the pX->y.sub fields will be set to show where +** the subroutine is coded. +** +** The inFlags parameter must contain, at a minimum, one of the bits +** IN_INDEX_MEMBERSHIP or IN_INDEX_LOOP but not both. If inFlags contains +** IN_INDEX_MEMBERSHIP, then the generated table will be used for a fast +** membership test. When the IN_INDEX_LOOP bit is set, the IN index will +** be used to loop over all values of the RHS of the IN operator. +** +** When IN_INDEX_LOOP is used (and the b-tree will be used to iterate +** through the set members) then the b-tree must not contain duplicates. +** An epheremal table will be created unless the selected columns are guaranteed +** to be unique - either because it is an INTEGER PRIMARY KEY or due to +** a UNIQUE constraint or index. +** +** When IN_INDEX_MEMBERSHIP is used (and the b-tree will be used +** for fast set membership tests) then an epheremal table must +** be used unless is a single INTEGER PRIMARY KEY column or an +** index can be found with the specified as its left-most. +** +** If the IN_INDEX_NOOP_OK and IN_INDEX_MEMBERSHIP are both set and +** if the RHS of the IN operator is a list (not a subquery) then this +** routine might decide that creating an ephemeral b-tree for membership +** testing is too expensive and return IN_INDEX_NOOP. In that case, the +** calling routine should implement the IN operator using a sequence +** of Eq or Ne comparison operations. +** +** When the b-tree is being used for membership tests, the calling function +** might need to know whether or not the RHS side of the IN operator +** contains a NULL. If prRhsHasNull is not a NULL pointer and +** if there is any chance that the (...) might contain a NULL value at +** runtime, then a register is allocated and the register number written +** to *prRhsHasNull. If there is no chance that the (...) contains a +** NULL value, then *prRhsHasNull is left unchanged. +** +** If a register is allocated and its location stored in *prRhsHasNull, then +** the value in that register will be NULL if the b-tree contains one or more +** NULL values, and it will be some non-NULL value if the b-tree contains no +** NULL values. +** +** If the aiMap parameter is not NULL, it must point to an array containing +** one element for each column returned by the SELECT statement on the RHS +** of the IN(...) operator. The i'th entry of the array is populated with the +** offset of the index column that matches the i'th column returned by the +** SELECT. For example, if the expression and selected index are: +** +** (?,?,?) IN (SELECT a, b, c FROM t1) +** CREATE INDEX i1 ON t1(b, c, a); +** +** then aiMap[] is populated with {2, 0, 1}. +*/ +#ifndef SQLITE_OMIT_SUBQUERY +SQLITE_PRIVATE int sqlite3FindInIndex( + Parse *pParse, /* Parsing context */ + Expr *pX, /* The IN expression */ + u32 inFlags, /* IN_INDEX_LOOP, _MEMBERSHIP, and/or _NOOP_OK */ + int *prRhsHasNull, /* Register holding NULL status. See notes */ + int *aiMap, /* Mapping from Index fields to RHS fields */ + int *piTab /* OUT: index to use */ +){ + Select *p; /* SELECT to the right of IN operator */ + int eType = 0; /* Type of RHS table. IN_INDEX_* */ + int iTab; /* Cursor of the RHS table */ + int mustBeUnique; /* True if RHS must be unique */ + Vdbe *v = sqlite3GetVdbe(pParse); /* Virtual machine being coded */ + + assert( pX->op==TK_IN ); + mustBeUnique = (inFlags & IN_INDEX_LOOP)!=0; + iTab = pParse->nTab++; + + /* If the RHS of this IN(...) operator is a SELECT, and if it matters + ** whether or not the SELECT result contains NULL values, check whether + ** or not NULL is actually possible (it may not be, for example, due + ** to NOT NULL constraints in the schema). If no NULL values are possible, + ** set prRhsHasNull to 0 before continuing. */ + if( prRhsHasNull && ExprUseXSelect(pX) ){ + int i; + ExprList *pEList = pX->x.pSelect->pEList; + for(i=0; inExpr; i++){ + if( sqlite3ExprCanBeNull(pEList->a[i].pExpr) ) break; + } + if( i==pEList->nExpr ){ + prRhsHasNull = 0; + } + } + + /* Check to see if an existing table or index can be used to + ** satisfy the query. This is preferable to generating a new + ** ephemeral table. */ + if( pParse->nErr==0 && (p = isCandidateForInOpt(pX))!=0 ){ + sqlite3 *db = pParse->db; /* Database connection */ + Table *pTab; /* Table
. */ + int iDb; /* Database idx for pTab */ + ExprList *pEList = p->pEList; + int nExpr = pEList->nExpr; + + assert( p->pEList!=0 ); /* Because of isCandidateForInOpt(p) */ + assert( p->pEList->a[0].pExpr!=0 ); /* Because of isCandidateForInOpt(p) */ + assert( p->pSrc!=0 ); /* Because of isCandidateForInOpt(p) */ + pTab = p->pSrc->a[0].pTab; + + /* Code an OP_Transaction and OP_TableLock for
. */ + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( iDb>=0 && iDbtnum, 0, pTab->zName); + + assert(v); /* sqlite3GetVdbe() has always been previously called */ + if( nExpr==1 && pEList->a[0].pExpr->iColumn<0 ){ + /* The "x IN (SELECT rowid FROM table)" case */ + int iAddr = sqlite3VdbeAddOp0(v, OP_Once); + VdbeCoverage(v); + + sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead); + eType = IN_INDEX_ROWID; + ExplainQueryPlan((pParse, 0, + "USING ROWID SEARCH ON TABLE %s FOR IN-OPERATOR",pTab->zName)); + sqlite3VdbeJumpHere(v, iAddr); + }else{ + Index *pIdx; /* Iterator variable */ + int affinity_ok = 1; + int i; + + /* Check that the affinity that will be used to perform each + ** comparison is the same as the affinity of each column in table + ** on the RHS of the IN operator. If it not, it is not possible to + ** use any index of the RHS table. */ + for(i=0; ipLeft, i); + int iCol = pEList->a[i].pExpr->iColumn; + char idxaff = sqlite3TableColumnAffinity(pTab,iCol); /* RHS table */ + char cmpaff = sqlite3CompareAffinity(pLhs, idxaff); + testcase( cmpaff==SQLITE_AFF_BLOB ); + testcase( cmpaff==SQLITE_AFF_TEXT ); + switch( cmpaff ){ + case SQLITE_AFF_BLOB: + break; + case SQLITE_AFF_TEXT: + /* sqlite3CompareAffinity() only returns TEXT if one side or the + ** other has no affinity and the other side is TEXT. Hence, + ** the only way for cmpaff to be TEXT is for idxaff to be TEXT + ** and for the term on the LHS of the IN to have no affinity. */ + assert( idxaff==SQLITE_AFF_TEXT ); + break; + default: + affinity_ok = sqlite3IsNumericAffinity(idxaff); + } + } + + if( affinity_ok ){ + /* Search for an existing index that will work for this IN operator */ + for(pIdx=pTab->pIndex; pIdx && eType==0; pIdx=pIdx->pNext){ + Bitmask colUsed; /* Columns of the index used */ + Bitmask mCol; /* Mask for the current column */ + if( pIdx->nColumnpPartIdxWhere!=0 ) continue; + /* Maximum nColumn is BMS-2, not BMS-1, so that we can compute + ** BITMASK(nExpr) without overflowing */ + testcase( pIdx->nColumn==BMS-2 ); + testcase( pIdx->nColumn==BMS-1 ); + if( pIdx->nColumn>=BMS-1 ) continue; + if( mustBeUnique ){ + if( pIdx->nKeyCol>nExpr + ||(pIdx->nColumn>nExpr && !IsUniqueIndex(pIdx)) + ){ + continue; /* This index is not unique over the IN RHS columns */ + } + } + + colUsed = 0; /* Columns of index used so far */ + for(i=0; ipLeft, i); + Expr *pRhs = pEList->a[i].pExpr; + CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pLhs, pRhs); + int j; + + for(j=0; jaiColumn[j]!=pRhs->iColumn ) continue; + assert( pIdx->azColl[j] ); + if( pReq!=0 && sqlite3StrICmp(pReq->zName, pIdx->azColl[j])!=0 ){ + continue; + } + break; + } + if( j==nExpr ) break; + mCol = MASKBIT(j); + if( mCol & colUsed ) break; /* Each column used only once */ + colUsed |= mCol; + if( aiMap ) aiMap[i] = j; + } + + assert( i==nExpr || colUsed!=(MASKBIT(nExpr)-1) ); + if( colUsed==(MASKBIT(nExpr)-1) ){ + /* If we reach this point, that means the index pIdx is usable */ + int iAddr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); + ExplainQueryPlan((pParse, 0, + "USING INDEX %s FOR IN-OPERATOR",pIdx->zName)); + sqlite3VdbeAddOp3(v, OP_OpenRead, iTab, pIdx->tnum, iDb); + sqlite3VdbeSetP4KeyInfo(pParse, pIdx); + VdbeComment((v, "%s", pIdx->zName)); + assert( IN_INDEX_INDEX_DESC == IN_INDEX_INDEX_ASC+1 ); + eType = IN_INDEX_INDEX_ASC + pIdx->aSortOrder[0]; + + if( prRhsHasNull ){ +#ifdef SQLITE_ENABLE_COLUMN_USED_MASK + i64 mask = (1<nMem; + if( nExpr==1 ){ + sqlite3SetHasNullFlag(v, iTab, *prRhsHasNull); + } + } + sqlite3VdbeJumpHere(v, iAddr); + } + } /* End loop over indexes */ + } /* End if( affinity_ok ) */ + } /* End if not an rowid index */ + } /* End attempt to optimize using an index */ + + /* If no preexisting index is available for the IN clause + ** and IN_INDEX_NOOP is an allowed reply + ** and the RHS of the IN operator is a list, not a subquery + ** and the RHS is not constant or has two or fewer terms, + ** then it is not worth creating an ephemeral table to evaluate + ** the IN operator so return IN_INDEX_NOOP. + */ + if( eType==0 + && (inFlags & IN_INDEX_NOOP_OK) + && ExprUseXList(pX) + && (!sqlite3InRhsIsConstant(pX) || pX->x.pList->nExpr<=2) + ){ + pParse->nTab--; /* Back out the allocation of the unused cursor */ + iTab = -1; /* Cursor is not allocated */ + eType = IN_INDEX_NOOP; + } + + if( eType==0 ){ + /* Could not find an existing table or index to use as the RHS b-tree. + ** We will have to generate an ephemeral table to do the job. + */ + u32 savedNQueryLoop = pParse->nQueryLoop; + int rMayHaveNull = 0; + eType = IN_INDEX_EPH; + if( inFlags & IN_INDEX_LOOP ){ + pParse->nQueryLoop = 0; + }else if( prRhsHasNull ){ + *prRhsHasNull = rMayHaveNull = ++pParse->nMem; + } + assert( pX->op==TK_IN ); + sqlite3CodeRhsOfIN(pParse, pX, iTab); + if( rMayHaveNull ){ + sqlite3SetHasNullFlag(v, iTab, rMayHaveNull); + } + pParse->nQueryLoop = savedNQueryLoop; + } + + if( aiMap && eType!=IN_INDEX_INDEX_ASC && eType!=IN_INDEX_INDEX_DESC ){ + int i, n; + n = sqlite3ExprVectorSize(pX->pLeft); + for(i=0; ipLeft; + int nVal = sqlite3ExprVectorSize(pLeft); + Select *pSelect = ExprUseXSelect(pExpr) ? pExpr->x.pSelect : 0; + char *zRet; + + assert( pExpr->op==TK_IN ); + zRet = sqlite3DbMallocRaw(pParse->db, nVal+1); + if( zRet ){ + int i; + for(i=0; ipEList->a[i].pExpr, a); + }else{ + zRet[i] = a; + } + } + zRet[nVal] = '\0'; + } + return zRet; +} +#endif + +#ifndef SQLITE_OMIT_SUBQUERY +/* +** Load the Parse object passed as the first argument with an error +** message of the form: +** +** "sub-select returns N columns - expected M" +*/ +SQLITE_PRIVATE void sqlite3SubselectError(Parse *pParse, int nActual, int nExpect){ + if( pParse->nErr==0 ){ + const char *zFmt = "sub-select returns %d columns - expected %d"; + sqlite3ErrorMsg(pParse, zFmt, nActual, nExpect); + } +} +#endif + +/* +** Expression pExpr is a vector that has been used in a context where +** it is not permitted. If pExpr is a sub-select vector, this routine +** loads the Parse object with a message of the form: +** +** "sub-select returns N columns - expected 1" +** +** Or, if it is a regular scalar vector: +** +** "row value misused" +*/ +SQLITE_PRIVATE void sqlite3VectorErrorMsg(Parse *pParse, Expr *pExpr){ +#ifndef SQLITE_OMIT_SUBQUERY + if( ExprUseXSelect(pExpr) ){ + sqlite3SubselectError(pParse, pExpr->x.pSelect->pEList->nExpr, 1); + }else +#endif + { + sqlite3ErrorMsg(pParse, "row value misused"); + } +} + +#ifndef SQLITE_OMIT_SUBQUERY +/* +** Generate code that will construct an ephemeral table containing all terms +** in the RHS of an IN operator. The IN operator can be in either of two +** forms: +** +** x IN (4,5,11) -- IN operator with list on right-hand side +** x IN (SELECT a FROM b) -- IN operator with subquery on the right +** +** The pExpr parameter is the IN operator. The cursor number for the +** constructed ephermeral table is returned. The first time the ephemeral +** table is computed, the cursor number is also stored in pExpr->iTable, +** however the cursor number returned might not be the same, as it might +** have been duplicated using OP_OpenDup. +** +** If the LHS expression ("x" in the examples) is a column value, or +** the SELECT statement returns a column value, then the affinity of that +** column is used to build the index keys. If both 'x' and the +** SELECT... statement are columns, then numeric affinity is used +** if either column has NUMERIC or INTEGER affinity. If neither +** 'x' nor the SELECT... statement are columns, then numeric affinity +** is used. +*/ +SQLITE_PRIVATE void sqlite3CodeRhsOfIN( + Parse *pParse, /* Parsing context */ + Expr *pExpr, /* The IN operator */ + int iTab /* Use this cursor number */ +){ + int addrOnce = 0; /* Address of the OP_Once instruction at top */ + int addr; /* Address of OP_OpenEphemeral instruction */ + Expr *pLeft; /* the LHS of the IN operator */ + KeyInfo *pKeyInfo = 0; /* Key information */ + int nVal; /* Size of vector pLeft */ + Vdbe *v; /* The prepared statement under construction */ + + v = pParse->pVdbe; + assert( v!=0 ); + + /* The evaluation of the IN must be repeated every time it + ** is encountered if any of the following is true: + ** + ** * The right-hand side is a correlated subquery + ** * The right-hand side is an expression list containing variables + ** * We are inside a trigger + ** + ** If all of the above are false, then we can compute the RHS just once + ** and reuse it many names. + */ + if( !ExprHasProperty(pExpr, EP_VarSelect) && pParse->iSelfTab==0 ){ + /* Reuse of the RHS is allowed */ + /* If this routine has already been coded, but the previous code + ** might not have been invoked yet, so invoke it now as a subroutine. + */ + if( ExprHasProperty(pExpr, EP_Subrtn) ){ + addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); + if( ExprUseXSelect(pExpr) ){ + ExplainQueryPlan((pParse, 0, "REUSE LIST SUBQUERY %d", + pExpr->x.pSelect->selId)); + } + assert( ExprUseYSub(pExpr) ); + sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn, + pExpr->y.sub.iAddr); + assert( iTab!=pExpr->iTable ); + sqlite3VdbeAddOp2(v, OP_OpenDup, iTab, pExpr->iTable); + sqlite3VdbeJumpHere(v, addrOnce); + return; + } + + /* Begin coding the subroutine */ + assert( !ExprUseYWin(pExpr) ); + ExprSetProperty(pExpr, EP_Subrtn); + assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) ); + pExpr->y.sub.regReturn = ++pParse->nMem; + pExpr->y.sub.iAddr = + sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pExpr->y.sub.regReturn) + 1; + + addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); + } + + /* Check to see if this is a vector IN operator */ + pLeft = pExpr->pLeft; + nVal = sqlite3ExprVectorSize(pLeft); + + /* Construct the ephemeral table that will contain the content of + ** RHS of the IN operator. + */ + pExpr->iTable = iTab; + addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, nVal); +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + if( ExprUseXSelect(pExpr) ){ + VdbeComment((v, "Result of SELECT %u", pExpr->x.pSelect->selId)); + }else{ + VdbeComment((v, "RHS of IN operator")); + } +#endif + pKeyInfo = sqlite3KeyInfoAlloc(pParse->db, nVal, 1); + + if( ExprUseXSelect(pExpr) ){ + /* Case 1: expr IN (SELECT ...) + ** + ** Generate code to write the results of the select into the temporary + ** table allocated and opened above. + */ + Select *pSelect = pExpr->x.pSelect; + ExprList *pEList = pSelect->pEList; + + ExplainQueryPlan((pParse, 1, "%sLIST SUBQUERY %d", + addrOnce?"":"CORRELATED ", pSelect->selId + )); + /* If the LHS and RHS of the IN operator do not match, that + ** error will have been caught long before we reach this point. */ + if( ALWAYS(pEList->nExpr==nVal) ){ + Select *pCopy; + SelectDest dest; + int i; + int rc; + sqlite3SelectDestInit(&dest, SRT_Set, iTab); + dest.zAffSdst = exprINAffinity(pParse, pExpr); + pSelect->iLimit = 0; + testcase( pSelect->selFlags & SF_Distinct ); + testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */ + pCopy = sqlite3SelectDup(pParse->db, pSelect, 0); + rc = pParse->db->mallocFailed ? 1 :sqlite3Select(pParse, pCopy, &dest); + sqlite3SelectDelete(pParse->db, pCopy); + sqlite3DbFree(pParse->db, dest.zAffSdst); + if( rc ){ + sqlite3KeyInfoUnref(pKeyInfo); + return; + } + assert( pKeyInfo!=0 ); /* OOM will cause exit after sqlite3Select() */ + assert( pEList!=0 ); + assert( pEList->nExpr>0 ); + assert( sqlite3KeyInfoIsWriteable(pKeyInfo) ); + for(i=0; iaColl[i] = sqlite3BinaryCompareCollSeq( + pParse, p, pEList->a[i].pExpr + ); + } + } + }else if( ALWAYS(pExpr->x.pList!=0) ){ + /* Case 2: expr IN (exprlist) + ** + ** For each expression, build an index key from the evaluation and + ** store it in the temporary table. If is a column, then use + ** that columns affinity when building index keys. If is not + ** a column, use numeric affinity. + */ + char affinity; /* Affinity of the LHS of the IN */ + int i; + ExprList *pList = pExpr->x.pList; + struct ExprList_item *pItem; + int r1, r2; + affinity = sqlite3ExprAffinity(pLeft); + if( affinity<=SQLITE_AFF_NONE ){ + affinity = SQLITE_AFF_BLOB; + }else if( affinity==SQLITE_AFF_REAL ){ + affinity = SQLITE_AFF_NUMERIC; + } + if( pKeyInfo ){ + assert( sqlite3KeyInfoIsWriteable(pKeyInfo) ); + pKeyInfo->aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft); + } + + /* Loop through each expression in . */ + r1 = sqlite3GetTempReg(pParse); + r2 = sqlite3GetTempReg(pParse); + for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){ + Expr *pE2 = pItem->pExpr; + + /* If the expression is not constant then we will need to + ** disable the test that was generated above that makes sure + ** this code only executes once. Because for a non-constant + ** expression we need to rerun this code each time. + */ + if( addrOnce && !sqlite3ExprIsConstant(pE2) ){ + sqlite3VdbeChangeToNoop(v, addrOnce-1); + sqlite3VdbeChangeToNoop(v, addrOnce); + ExprClearProperty(pExpr, EP_Subrtn); + addrOnce = 0; + } + + /* Evaluate the expression and insert it into the temp table */ + sqlite3ExprCode(pParse, pE2, r1); + sqlite3VdbeAddOp4(v, OP_MakeRecord, r1, 1, r2, &affinity, 1); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iTab, r2, r1, 1); + } + sqlite3ReleaseTempReg(pParse, r1); + sqlite3ReleaseTempReg(pParse, r2); + } + if( pKeyInfo ){ + sqlite3VdbeChangeP4(v, addr, (void *)pKeyInfo, P4_KEYINFO); + } + if( addrOnce ){ + sqlite3VdbeAddOp1(v, OP_NullRow, iTab); + sqlite3VdbeJumpHere(v, addrOnce); + /* Subroutine return */ + assert( ExprUseYSub(pExpr) ); + assert( sqlite3VdbeGetOp(v,pExpr->y.sub.iAddr-1)->opcode==OP_BeginSubrtn + || pParse->nErr ); + sqlite3VdbeAddOp3(v, OP_Return, pExpr->y.sub.regReturn, + pExpr->y.sub.iAddr, 1); + VdbeCoverage(v); + sqlite3ClearTempRegCache(pParse); + } +} +#endif /* SQLITE_OMIT_SUBQUERY */ + +/* +** Generate code for scalar subqueries used as a subquery expression +** or EXISTS operator: +** +** (SELECT a FROM b) -- subquery +** EXISTS (SELECT a FROM b) -- EXISTS subquery +** +** The pExpr parameter is the SELECT or EXISTS operator to be coded. +** +** Return the register that holds the result. For a multi-column SELECT, +** the result is stored in a contiguous array of registers and the +** return value is the register of the left-most result column. +** Return 0 if an error occurs. +*/ +#ifndef SQLITE_OMIT_SUBQUERY +SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){ + int addrOnce = 0; /* Address of OP_Once at top of subroutine */ + int rReg = 0; /* Register storing resulting */ + Select *pSel; /* SELECT statement to encode */ + SelectDest dest; /* How to deal with SELECT result */ + int nReg; /* Registers to allocate */ + Expr *pLimit; /* New limit expression */ +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + int addrExplain; /* Address of OP_Explain instruction */ +#endif + + Vdbe *v = pParse->pVdbe; + assert( v!=0 ); + if( pParse->nErr ) return 0; + testcase( pExpr->op==TK_EXISTS ); + testcase( pExpr->op==TK_SELECT ); + assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT ); + assert( ExprUseXSelect(pExpr) ); + pSel = pExpr->x.pSelect; + + /* If this routine has already been coded, then invoke it as a + ** subroutine. */ + if( ExprHasProperty(pExpr, EP_Subrtn) ){ + ExplainQueryPlan((pParse, 0, "REUSE SUBQUERY %d", pSel->selId)); + assert( ExprUseYSub(pExpr) ); + sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn, + pExpr->y.sub.iAddr); + return pExpr->iTable; + } + + /* Begin coding the subroutine */ + assert( !ExprUseYWin(pExpr) ); + assert( !ExprHasProperty(pExpr, EP_Reduced|EP_TokenOnly) ); + ExprSetProperty(pExpr, EP_Subrtn); + pExpr->y.sub.regReturn = ++pParse->nMem; + pExpr->y.sub.iAddr = + sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pExpr->y.sub.regReturn) + 1; + + /* The evaluation of the EXISTS/SELECT must be repeated every time it + ** is encountered if any of the following is true: + ** + ** * The right-hand side is a correlated subquery + ** * The right-hand side is an expression list containing variables + ** * We are inside a trigger + ** + ** If all of the above are false, then we can run this code just once + ** save the results, and reuse the same result on subsequent invocations. + */ + if( !ExprHasProperty(pExpr, EP_VarSelect) ){ + addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); + } + + /* For a SELECT, generate code to put the values for all columns of + ** the first row into an array of registers and return the index of + ** the first register. + ** + ** If this is an EXISTS, write an integer 0 (not exists) or 1 (exists) + ** into a register and return that register number. + ** + ** In both cases, the query is augmented with "LIMIT 1". Any + ** preexisting limit is discarded in place of the new LIMIT 1. + */ + ExplainQueryPlan2(addrExplain, (pParse, 1, "%sSCALAR SUBQUERY %d", + addrOnce?"":"CORRELATED ", pSel->selId)); + sqlite3VdbeScanStatusCounters(v, addrExplain, addrExplain, -1); + nReg = pExpr->op==TK_SELECT ? pSel->pEList->nExpr : 1; + sqlite3SelectDestInit(&dest, 0, pParse->nMem+1); + pParse->nMem += nReg; + if( pExpr->op==TK_SELECT ){ + dest.eDest = SRT_Mem; + dest.iSdst = dest.iSDParm; + dest.nSdst = nReg; + sqlite3VdbeAddOp3(v, OP_Null, 0, dest.iSDParm, dest.iSDParm+nReg-1); + VdbeComment((v, "Init subquery result")); + }else{ + dest.eDest = SRT_Exists; + sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iSDParm); + VdbeComment((v, "Init EXISTS result")); + } + if( pSel->pLimit ){ + /* The subquery already has a limit. If the pre-existing limit is X + ** then make the new limit X<>0 so that the new limit is either 1 or 0 */ + sqlite3 *db = pParse->db; + pLimit = sqlite3Expr(db, TK_INTEGER, "0"); + if( pLimit ){ + pLimit->affExpr = SQLITE_AFF_NUMERIC; + pLimit = sqlite3PExpr(pParse, TK_NE, + sqlite3ExprDup(db, pSel->pLimit->pLeft, 0), pLimit); + } + sqlite3ExprDeferredDelete(pParse, pSel->pLimit->pLeft); + pSel->pLimit->pLeft = pLimit; + }else{ + /* If there is no pre-existing limit add a limit of 1 */ + pLimit = sqlite3Expr(pParse->db, TK_INTEGER, "1"); + pSel->pLimit = sqlite3PExpr(pParse, TK_LIMIT, pLimit, 0); + } + pSel->iLimit = 0; + if( sqlite3Select(pParse, pSel, &dest) ){ + pExpr->op2 = pExpr->op; + pExpr->op = TK_ERROR; + return 0; + } + pExpr->iTable = rReg = dest.iSDParm; + ExprSetVVAProperty(pExpr, EP_NoReduce); + if( addrOnce ){ + sqlite3VdbeJumpHere(v, addrOnce); + } + sqlite3VdbeScanStatusRange(v, addrExplain, addrExplain, -1); + + /* Subroutine return */ + assert( ExprUseYSub(pExpr) ); + assert( sqlite3VdbeGetOp(v,pExpr->y.sub.iAddr-1)->opcode==OP_BeginSubrtn + || pParse->nErr ); + sqlite3VdbeAddOp3(v, OP_Return, pExpr->y.sub.regReturn, + pExpr->y.sub.iAddr, 1); + VdbeCoverage(v); + sqlite3ClearTempRegCache(pParse); + return rReg; +} +#endif /* SQLITE_OMIT_SUBQUERY */ + +#ifndef SQLITE_OMIT_SUBQUERY +/* +** Expr pIn is an IN(...) expression. This function checks that the +** sub-select on the RHS of the IN() operator has the same number of +** columns as the vector on the LHS. Or, if the RHS of the IN() is not +** a sub-query, that the LHS is a vector of size 1. +*/ +SQLITE_PRIVATE int sqlite3ExprCheckIN(Parse *pParse, Expr *pIn){ + int nVector = sqlite3ExprVectorSize(pIn->pLeft); + if( ExprUseXSelect(pIn) && !pParse->db->mallocFailed ){ + if( nVector!=pIn->x.pSelect->pEList->nExpr ){ + sqlite3SubselectError(pParse, pIn->x.pSelect->pEList->nExpr, nVector); + return 1; + } + }else if( nVector!=1 ){ + sqlite3VectorErrorMsg(pParse, pIn->pLeft); + return 1; + } + return 0; +} +#endif + +#ifndef SQLITE_OMIT_SUBQUERY +/* +** Generate code for an IN expression. +** +** x IN (SELECT ...) +** x IN (value, value, ...) +** +** The left-hand side (LHS) is a scalar or vector expression. The +** right-hand side (RHS) is an array of zero or more scalar values, or a +** subquery. If the RHS is a subquery, the number of result columns must +** match the number of columns in the vector on the LHS. If the RHS is +** a list of values, the LHS must be a scalar. +** +** The IN operator is true if the LHS value is contained within the RHS. +** The result is false if the LHS is definitely not in the RHS. The +** result is NULL if the presence of the LHS in the RHS cannot be +** determined due to NULLs. +** +** This routine generates code that jumps to destIfFalse if the LHS is not +** contained within the RHS. If due to NULLs we cannot determine if the LHS +** is contained in the RHS then jump to destIfNull. If the LHS is contained +** within the RHS then fall through. +** +** See the separate in-operator.md documentation file in the canonical +** SQLite source tree for additional information. +*/ +static void sqlite3ExprCodeIN( + Parse *pParse, /* Parsing and code generating context */ + Expr *pExpr, /* The IN expression */ + int destIfFalse, /* Jump here if LHS is not contained in the RHS */ + int destIfNull /* Jump here if the results are unknown due to NULLs */ +){ + int rRhsHasNull = 0; /* Register that is true if RHS contains NULL values */ + int eType; /* Type of the RHS */ + int rLhs; /* Register(s) holding the LHS values */ + int rLhsOrig; /* LHS values prior to reordering by aiMap[] */ + Vdbe *v; /* Statement under construction */ + int *aiMap = 0; /* Map from vector field to index column */ + char *zAff = 0; /* Affinity string for comparisons */ + int nVector; /* Size of vectors for this IN operator */ + int iDummy; /* Dummy parameter to exprCodeVector() */ + Expr *pLeft; /* The LHS of the IN operator */ + int i; /* loop counter */ + int destStep2; /* Where to jump when NULLs seen in step 2 */ + int destStep6 = 0; /* Start of code for Step 6 */ + int addrTruthOp; /* Address of opcode that determines the IN is true */ + int destNotNull; /* Jump here if a comparison is not true in step 6 */ + int addrTop; /* Top of the step-6 loop */ + int iTab = 0; /* Index to use */ + u8 okConstFactor = pParse->okConstFactor; + + assert( !ExprHasVVAProperty(pExpr,EP_Immutable) ); + pLeft = pExpr->pLeft; + if( sqlite3ExprCheckIN(pParse, pExpr) ) return; + zAff = exprINAffinity(pParse, pExpr); + nVector = sqlite3ExprVectorSize(pExpr->pLeft); + aiMap = (int*)sqlite3DbMallocZero( + pParse->db, nVector*(sizeof(int) + sizeof(char)) + 1 + ); + if( pParse->db->mallocFailed ) goto sqlite3ExprCodeIN_oom_error; + + /* Attempt to compute the RHS. After this step, if anything other than + ** IN_INDEX_NOOP is returned, the table opened with cursor iTab + ** contains the values that make up the RHS. If IN_INDEX_NOOP is returned, + ** the RHS has not yet been coded. */ + v = pParse->pVdbe; + assert( v!=0 ); /* OOM detected prior to this routine */ + VdbeNoopComment((v, "begin IN expr")); + eType = sqlite3FindInIndex(pParse, pExpr, + IN_INDEX_MEMBERSHIP | IN_INDEX_NOOP_OK, + destIfFalse==destIfNull ? 0 : &rRhsHasNull, + aiMap, &iTab); + + assert( pParse->nErr || nVector==1 || eType==IN_INDEX_EPH + || eType==IN_INDEX_INDEX_ASC || eType==IN_INDEX_INDEX_DESC + ); +#ifdef SQLITE_DEBUG + /* Confirm that aiMap[] contains nVector integer values between 0 and + ** nVector-1. */ + for(i=0; i from " IN (...)". If the LHS is a + ** vector, then it is stored in an array of nVector registers starting + ** at r1. + ** + ** sqlite3FindInIndex() might have reordered the fields of the LHS vector + ** so that the fields are in the same order as an existing index. The + ** aiMap[] array contains a mapping from the original LHS field order to + ** the field order that matches the RHS index. + ** + ** Avoid factoring the LHS of the IN(...) expression out of the loop, + ** even if it is constant, as OP_Affinity may be used on the register + ** by code generated below. */ + assert( pParse->okConstFactor==okConstFactor ); + pParse->okConstFactor = 0; + rLhsOrig = exprCodeVector(pParse, pLeft, &iDummy); + pParse->okConstFactor = okConstFactor; + for(i=0; ix.pList; + pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft); + if( destIfNull!=destIfFalse ){ + regCkNull = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_BitAnd, rLhs, rLhs, regCkNull); + } + for(ii=0; iinExpr; ii++){ + r2 = sqlite3ExprCodeTemp(pParse, pList->a[ii].pExpr, ®ToFree); + if( regCkNull && sqlite3ExprCanBeNull(pList->a[ii].pExpr) ){ + sqlite3VdbeAddOp3(v, OP_BitAnd, regCkNull, r2, regCkNull); + } + sqlite3ReleaseTempReg(pParse, regToFree); + if( iinExpr-1 || destIfNull!=destIfFalse ){ + int op = rLhs!=r2 ? OP_Eq : OP_NotNull; + sqlite3VdbeAddOp4(v, op, rLhs, labelOk, r2, + (void*)pColl, P4_COLLSEQ); + VdbeCoverageIf(v, iinExpr-1 && op==OP_Eq); + VdbeCoverageIf(v, ii==pList->nExpr-1 && op==OP_Eq); + VdbeCoverageIf(v, iinExpr-1 && op==OP_NotNull); + VdbeCoverageIf(v, ii==pList->nExpr-1 && op==OP_NotNull); + sqlite3VdbeChangeP5(v, zAff[0]); + }else{ + int op = rLhs!=r2 ? OP_Ne : OP_IsNull; + assert( destIfNull==destIfFalse ); + sqlite3VdbeAddOp4(v, op, rLhs, destIfFalse, r2, + (void*)pColl, P4_COLLSEQ); + VdbeCoverageIf(v, op==OP_Ne); + VdbeCoverageIf(v, op==OP_IsNull); + sqlite3VdbeChangeP5(v, zAff[0] | SQLITE_JUMPIFNULL); + } + } + if( regCkNull ){ + sqlite3VdbeAddOp2(v, OP_IsNull, regCkNull, destIfNull); VdbeCoverage(v); + sqlite3VdbeGoto(v, destIfFalse); + } + sqlite3VdbeResolveLabel(v, labelOk); + sqlite3ReleaseTempReg(pParse, regCkNull); + goto sqlite3ExprCodeIN_finished; + } + + /* Step 2: Check to see if the LHS contains any NULL columns. If the + ** LHS does contain NULLs then the result must be either FALSE or NULL. + ** We will then skip the binary search of the RHS. + */ + if( destIfNull==destIfFalse ){ + destStep2 = destIfFalse; + }else{ + destStep2 = destStep6 = sqlite3VdbeMakeLabel(pParse); + } + for(i=0; ipLeft, i); + if( pParse->nErr ) goto sqlite3ExprCodeIN_oom_error; + if( sqlite3ExprCanBeNull(p) ){ + sqlite3VdbeAddOp2(v, OP_IsNull, rLhs+i, destStep2); + VdbeCoverage(v); + } + } + + /* Step 3. The LHS is now known to be non-NULL. Do the binary search + ** of the RHS using the LHS as a probe. If found, the result is + ** true. + */ + if( eType==IN_INDEX_ROWID ){ + /* In this case, the RHS is the ROWID of table b-tree and so we also + ** know that the RHS is non-NULL. Hence, we combine steps 3 and 4 + ** into a single opcode. */ + sqlite3VdbeAddOp3(v, OP_SeekRowid, iTab, destIfFalse, rLhs); + VdbeCoverage(v); + addrTruthOp = sqlite3VdbeAddOp0(v, OP_Goto); /* Return True */ + }else{ + sqlite3VdbeAddOp4(v, OP_Affinity, rLhs, nVector, 0, zAff, nVector); + if( destIfFalse==destIfNull ){ + /* Combine Step 3 and Step 5 into a single opcode */ + sqlite3VdbeAddOp4Int(v, OP_NotFound, iTab, destIfFalse, + rLhs, nVector); VdbeCoverage(v); + goto sqlite3ExprCodeIN_finished; + } + /* Ordinary Step 3, for the case where FALSE and NULL are distinct */ + addrTruthOp = sqlite3VdbeAddOp4Int(v, OP_Found, iTab, 0, + rLhs, nVector); VdbeCoverage(v); + } + + /* Step 4. If the RHS is known to be non-NULL and we did not find + ** an match on the search above, then the result must be FALSE. + */ + if( rRhsHasNull && nVector==1 ){ + sqlite3VdbeAddOp2(v, OP_NotNull, rRhsHasNull, destIfFalse); + VdbeCoverage(v); + } + + /* Step 5. If we do not care about the difference between NULL and + ** FALSE, then just return false. + */ + if( destIfFalse==destIfNull ) sqlite3VdbeGoto(v, destIfFalse); + + /* Step 6: Loop through rows of the RHS. Compare each row to the LHS. + ** If any comparison is NULL, then the result is NULL. If all + ** comparisons are FALSE then the final result is FALSE. + ** + ** For a scalar LHS, it is sufficient to check just the first row + ** of the RHS. + */ + if( destStep6 ) sqlite3VdbeResolveLabel(v, destStep6); + addrTop = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, destIfFalse); + VdbeCoverage(v); + if( nVector>1 ){ + destNotNull = sqlite3VdbeMakeLabel(pParse); + }else{ + /* For nVector==1, combine steps 6 and 7 by immediately returning + ** FALSE if the first comparison is not NULL */ + destNotNull = destIfFalse; + } + for(i=0; i1 ){ + sqlite3VdbeResolveLabel(v, destNotNull); + sqlite3VdbeAddOp2(v, OP_Next, iTab, addrTop+1); + VdbeCoverage(v); + + /* Step 7: If we reach this point, we know that the result must + ** be false. */ + sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfFalse); + } + + /* Jumps here in order to return true. */ + sqlite3VdbeJumpHere(v, addrTruthOp); + +sqlite3ExprCodeIN_finished: + if( rLhs!=rLhsOrig ) sqlite3ReleaseTempReg(pParse, rLhs); + VdbeComment((v, "end IN expr")); +sqlite3ExprCodeIN_oom_error: + sqlite3DbFree(pParse->db, aiMap); + sqlite3DbFree(pParse->db, zAff); +} +#endif /* SQLITE_OMIT_SUBQUERY */ + +#ifndef SQLITE_OMIT_FLOATING_POINT +/* +** Generate an instruction that will put the floating point +** value described by z[0..n-1] into register iMem. +** +** The z[] string will probably not be zero-terminated. But the +** z[n] character is guaranteed to be something that does not look +** like the continuation of the number. +*/ +static void codeReal(Vdbe *v, const char *z, int negateFlag, int iMem){ + if( ALWAYS(z!=0) ){ + double value; + sqlite3AtoF(z, &value, sqlite3Strlen30(z), SQLITE_UTF8); + assert( !sqlite3IsNaN(value) ); /* The new AtoF never returns NaN */ + if( negateFlag ) value = -value; + sqlite3VdbeAddOp4Dup8(v, OP_Real, 0, iMem, 0, (u8*)&value, P4_REAL); + } +} +#endif + + +/* +** Generate an instruction that will put the integer describe by +** text z[0..n-1] into register iMem. +** +** Expr.u.zToken is always UTF8 and zero-terminated. +*/ +static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){ + Vdbe *v = pParse->pVdbe; + if( pExpr->flags & EP_IntValue ){ + int i = pExpr->u.iValue; + assert( i>=0 ); + if( negFlag ) i = -i; + sqlite3VdbeAddOp2(v, OP_Integer, i, iMem); + }else{ + int c; + i64 value; + const char *z = pExpr->u.zToken; + assert( z!=0 ); + c = sqlite3DecOrHexToI64(z, &value); + if( (c==3 && !negFlag) || (c==2) || (negFlag && value==SMALLEST_INT64)){ +#ifdef SQLITE_OMIT_FLOATING_POINT + sqlite3ErrorMsg(pParse, "oversized integer: %s%#T", negFlag?"-":"",pExpr); +#else +#ifndef SQLITE_OMIT_HEX_INTEGER + if( sqlite3_strnicmp(z,"0x",2)==0 ){ + sqlite3ErrorMsg(pParse, "hex literal too big: %s%#T", + negFlag?"-":"",pExpr); + }else +#endif + { + codeReal(v, z, negFlag, iMem); + } +#endif + }else{ + if( negFlag ){ value = c==3 ? SMALLEST_INT64 : -value; } + sqlite3VdbeAddOp4Dup8(v, OP_Int64, 0, iMem, 0, (u8*)&value, P4_INT64); + } + } +} + + +/* Generate code that will load into register regOut a value that is +** appropriate for the iIdxCol-th column of index pIdx. +*/ +SQLITE_PRIVATE void sqlite3ExprCodeLoadIndexColumn( + Parse *pParse, /* The parsing context */ + Index *pIdx, /* The index whose column is to be loaded */ + int iTabCur, /* Cursor pointing to a table row */ + int iIdxCol, /* The column of the index to be loaded */ + int regOut /* Store the index column value in this register */ +){ + i16 iTabCol = pIdx->aiColumn[iIdxCol]; + if( iTabCol==XN_EXPR ){ + assert( pIdx->aColExpr ); + assert( pIdx->aColExpr->nExpr>iIdxCol ); + pParse->iSelfTab = iTabCur + 1; + sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[iIdxCol].pExpr, regOut); + pParse->iSelfTab = 0; + }else{ + sqlite3ExprCodeGetColumnOfTable(pParse->pVdbe, pIdx->pTable, iTabCur, + iTabCol, regOut); + } +} + +#ifndef SQLITE_OMIT_GENERATED_COLUMNS +/* +** Generate code that will compute the value of generated column pCol +** and store the result in register regOut +*/ +SQLITE_PRIVATE void sqlite3ExprCodeGeneratedColumn( + Parse *pParse, /* Parsing context */ + Table *pTab, /* Table containing the generated column */ + Column *pCol, /* The generated column */ + int regOut /* Put the result in this register */ +){ + int iAddr; + Vdbe *v = pParse->pVdbe; + int nErr = pParse->nErr; + assert( v!=0 ); + assert( pParse->iSelfTab!=0 ); + if( pParse->iSelfTab>0 ){ + iAddr = sqlite3VdbeAddOp3(v, OP_IfNullRow, pParse->iSelfTab-1, 0, regOut); + }else{ + iAddr = 0; + } + sqlite3ExprCodeCopy(pParse, sqlite3ColumnExpr(pTab,pCol), regOut); + if( pCol->affinity>=SQLITE_AFF_TEXT ){ + sqlite3VdbeAddOp4(v, OP_Affinity, regOut, 1, 0, &pCol->affinity, 1); + } + if( iAddr ) sqlite3VdbeJumpHere(v, iAddr); + if( pParse->nErr>nErr ) pParse->db->errByteOffset = -1; +} +#endif /* SQLITE_OMIT_GENERATED_COLUMNS */ + +/* +** Generate code to extract the value of the iCol-th column of a table. +*/ +SQLITE_PRIVATE void sqlite3ExprCodeGetColumnOfTable( + Vdbe *v, /* Parsing context */ + Table *pTab, /* The table containing the value */ + int iTabCur, /* The table cursor. Or the PK cursor for WITHOUT ROWID */ + int iCol, /* Index of the column to extract */ + int regOut /* Extract the value into this register */ +){ + Column *pCol; + assert( v!=0 ); + assert( pTab!=0 ); + assert( iCol!=XN_EXPR ); + if( iCol<0 || iCol==pTab->iPKey ){ + sqlite3VdbeAddOp2(v, OP_Rowid, iTabCur, regOut); + VdbeComment((v, "%s.rowid", pTab->zName)); + }else{ + int op; + int x; + if( IsVirtual(pTab) ){ + op = OP_VColumn; + x = iCol; +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + }else if( (pCol = &pTab->aCol[iCol])->colFlags & COLFLAG_VIRTUAL ){ + Parse *pParse = sqlite3VdbeParser(v); + if( pCol->colFlags & COLFLAG_BUSY ){ + sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", + pCol->zCnName); + }else{ + int savedSelfTab = pParse->iSelfTab; + pCol->colFlags |= COLFLAG_BUSY; + pParse->iSelfTab = iTabCur+1; + sqlite3ExprCodeGeneratedColumn(pParse, pTab, pCol, regOut); + pParse->iSelfTab = savedSelfTab; + pCol->colFlags &= ~COLFLAG_BUSY; + } + return; +#endif + }else if( !HasRowid(pTab) ){ + testcase( iCol!=sqlite3TableColumnToStorage(pTab, iCol) ); + x = sqlite3TableColumnToIndex(sqlite3PrimaryKeyIndex(pTab), iCol); + op = OP_Column; + }else{ + x = sqlite3TableColumnToStorage(pTab,iCol); + testcase( x!=iCol ); + op = OP_Column; + } + sqlite3VdbeAddOp3(v, op, iTabCur, x, regOut); + sqlite3ColumnDefault(v, pTab, iCol, regOut); + } +} + +/* +** Generate code that will extract the iColumn-th column from +** table pTab and store the column value in register iReg. +** +** There must be an open cursor to pTab in iTable when this routine +** is called. If iColumn<0 then code is generated that extracts the rowid. +*/ +SQLITE_PRIVATE int sqlite3ExprCodeGetColumn( + Parse *pParse, /* Parsing and code generating context */ + Table *pTab, /* Description of the table we are reading from */ + int iColumn, /* Index of the table column */ + int iTable, /* The cursor pointing to the table */ + int iReg, /* Store results here */ + u8 p5 /* P5 value for OP_Column + FLAGS */ +){ + assert( pParse->pVdbe!=0 ); + sqlite3ExprCodeGetColumnOfTable(pParse->pVdbe, pTab, iTable, iColumn, iReg); + if( p5 ){ + VdbeOp *pOp = sqlite3VdbeGetLastOp(pParse->pVdbe); + if( pOp->opcode==OP_Column ) pOp->p5 = p5; + } + return iReg; +} + +/* +** Generate code to move content from registers iFrom...iFrom+nReg-1 +** over to iTo..iTo+nReg-1. +*/ +SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse *pParse, int iFrom, int iTo, int nReg){ + sqlite3VdbeAddOp3(pParse->pVdbe, OP_Move, iFrom, iTo, nReg); +} + +/* +** Convert a scalar expression node to a TK_REGISTER referencing +** register iReg. The caller must ensure that iReg already contains +** the correct value for the expression. +*/ +static void exprToRegister(Expr *pExpr, int iReg){ + Expr *p = sqlite3ExprSkipCollateAndLikely(pExpr); + if( NEVER(p==0) ) return; + p->op2 = p->op; + p->op = TK_REGISTER; + p->iTable = iReg; + ExprClearProperty(p, EP_Skip); +} + +/* +** Evaluate an expression (either a vector or a scalar expression) and store +** the result in continguous temporary registers. Return the index of +** the first register used to store the result. +** +** If the returned result register is a temporary scalar, then also write +** that register number into *piFreeable. If the returned result register +** is not a temporary or if the expression is a vector set *piFreeable +** to 0. +*/ +static int exprCodeVector(Parse *pParse, Expr *p, int *piFreeable){ + int iResult; + int nResult = sqlite3ExprVectorSize(p); + if( nResult==1 ){ + iResult = sqlite3ExprCodeTemp(pParse, p, piFreeable); + }else{ + *piFreeable = 0; + if( p->op==TK_SELECT ){ +#if SQLITE_OMIT_SUBQUERY + iResult = 0; +#else + iResult = sqlite3CodeSubselect(pParse, p); +#endif + }else{ + int i; + iResult = pParse->nMem+1; + pParse->nMem += nResult; + assert( ExprUseXList(p) ); + for(i=0; ix.pList->a[i].pExpr, i+iResult); + } + } + } + return iResult; +} + +/* +** If the last opcode is a OP_Copy, then set the do-not-merge flag (p5) +** so that a subsequent copy will not be merged into this one. +*/ +static void setDoNotMergeFlagOnCopy(Vdbe *v){ + if( sqlite3VdbeGetLastOp(v)->opcode==OP_Copy ){ + sqlite3VdbeChangeP5(v, 1); /* Tag trailing OP_Copy as not mergable */ + } +} + +/* +** Generate code to implement special SQL functions that are implemented +** in-line rather than by using the usual callbacks. +*/ +static int exprCodeInlineFunction( + Parse *pParse, /* Parsing context */ + ExprList *pFarg, /* List of function arguments */ + int iFuncId, /* Function ID. One of the INTFUNC_... values */ + int target /* Store function result in this register */ +){ + int nFarg; + Vdbe *v = pParse->pVdbe; + assert( v!=0 ); + assert( pFarg!=0 ); + nFarg = pFarg->nExpr; + assert( nFarg>0 ); /* All in-line functions have at least one argument */ + switch( iFuncId ){ + case INLINEFUNC_coalesce: { + /* Attempt a direct implementation of the built-in COALESCE() and + ** IFNULL() functions. This avoids unnecessary evaluation of + ** arguments past the first non-NULL argument. + */ + int endCoalesce = sqlite3VdbeMakeLabel(pParse); + int i; + assert( nFarg>=2 ); + sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target); + for(i=1; ia[i].pExpr, target); + } + setDoNotMergeFlagOnCopy(v); + sqlite3VdbeResolveLabel(v, endCoalesce); + break; + } + case INLINEFUNC_iif: { + Expr caseExpr; + memset(&caseExpr, 0, sizeof(caseExpr)); + caseExpr.op = TK_CASE; + caseExpr.x.pList = pFarg; + return sqlite3ExprCodeTarget(pParse, &caseExpr, target); + } +#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC + case INLINEFUNC_sqlite_offset: { + Expr *pArg = pFarg->a[0].pExpr; + if( pArg->op==TK_COLUMN && pArg->iTable>=0 ){ + sqlite3VdbeAddOp3(v, OP_Offset, pArg->iTable, pArg->iColumn, target); + }else{ + sqlite3VdbeAddOp2(v, OP_Null, 0, target); + } + break; + } +#endif + default: { + /* The UNLIKELY() function is a no-op. The result is the value + ** of the first argument. + */ + assert( nFarg==1 || nFarg==2 ); + target = sqlite3ExprCodeTarget(pParse, pFarg->a[0].pExpr, target); + break; + } + + /*********************************************************************** + ** Test-only SQL functions that are only usable if enabled + ** via SQLITE_TESTCTRL_INTERNAL_FUNCTIONS + */ +#if !defined(SQLITE_UNTESTABLE) + case INLINEFUNC_expr_compare: { + /* Compare two expressions using sqlite3ExprCompare() */ + assert( nFarg==2 ); + sqlite3VdbeAddOp2(v, OP_Integer, + sqlite3ExprCompare(0,pFarg->a[0].pExpr, pFarg->a[1].pExpr,-1), + target); + break; + } + + case INLINEFUNC_expr_implies_expr: { + /* Compare two expressions using sqlite3ExprImpliesExpr() */ + assert( nFarg==2 ); + sqlite3VdbeAddOp2(v, OP_Integer, + sqlite3ExprImpliesExpr(pParse,pFarg->a[0].pExpr, pFarg->a[1].pExpr,-1), + target); + break; + } + + case INLINEFUNC_implies_nonnull_row: { + /* REsult of sqlite3ExprImpliesNonNullRow() */ + Expr *pA1; + assert( nFarg==2 ); + pA1 = pFarg->a[1].pExpr; + if( pA1->op==TK_COLUMN ){ + sqlite3VdbeAddOp2(v, OP_Integer, + sqlite3ExprImpliesNonNullRow(pFarg->a[0].pExpr,pA1->iTable), + target); + }else{ + sqlite3VdbeAddOp2(v, OP_Null, 0, target); + } + break; + } + + case INLINEFUNC_affinity: { + /* The AFFINITY() function evaluates to a string that describes + ** the type affinity of the argument. This is used for testing of + ** the SQLite type logic. + */ + const char *azAff[] = { "blob", "text", "numeric", "integer", + "real", "flexnum" }; + char aff; + assert( nFarg==1 ); + aff = sqlite3ExprAffinity(pFarg->a[0].pExpr); + assert( aff<=SQLITE_AFF_NONE + || (aff>=SQLITE_AFF_BLOB && aff<=SQLITE_AFF_FLEXNUM) ); + sqlite3VdbeLoadString(v, target, + (aff<=SQLITE_AFF_NONE) ? "none" : azAff[aff-SQLITE_AFF_BLOB]); + break; + } +#endif /* !defined(SQLITE_UNTESTABLE) */ + } + return target; +} + +/* +** Check to see if pExpr is one of the indexed expressions on pParse->pIdxEpr. +** If it is, then resolve the expression by reading from the index and +** return the register into which the value has been read. If pExpr is +** not an indexed expression, then return negative. +*/ +static SQLITE_NOINLINE int sqlite3IndexedExprLookup( + Parse *pParse, /* The parsing context */ + Expr *pExpr, /* The expression to potentially bypass */ + int target /* Where to store the result of the expression */ +){ + IndexedExpr *p; + Vdbe *v; + for(p=pParse->pIdxEpr; p; p=p->pIENext){ + u8 exprAff; + int iDataCur = p->iDataCur; + if( iDataCur<0 ) continue; + if( pParse->iSelfTab ){ + if( p->iDataCur!=pParse->iSelfTab-1 ) continue; + iDataCur = -1; + } + if( sqlite3ExprCompare(0, pExpr, p->pExpr, iDataCur)!=0 ) continue; + assert( p->aff>=SQLITE_AFF_BLOB && p->aff<=SQLITE_AFF_NUMERIC ); + exprAff = sqlite3ExprAffinity(pExpr); + if( (exprAff<=SQLITE_AFF_BLOB && p->aff!=SQLITE_AFF_BLOB) + || (exprAff==SQLITE_AFF_TEXT && p->aff!=SQLITE_AFF_TEXT) + || (exprAff>=SQLITE_AFF_NUMERIC && p->aff!=SQLITE_AFF_NUMERIC) + ){ + /* Affinity mismatch on a generated column */ + continue; + } + + v = pParse->pVdbe; + assert( v!=0 ); + if( p->bMaybeNullRow ){ + /* If the index is on a NULL row due to an outer join, then we + ** cannot extract the value from the index. The value must be + ** computed using the original expression. */ + int addr = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp3(v, OP_IfNullRow, p->iIdxCur, addr+3, target); + VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_Column, p->iIdxCur, p->iIdxCol, target); + VdbeComment((v, "%s expr-column %d", p->zIdxName, p->iIdxCol)); + sqlite3VdbeGoto(v, 0); + p = pParse->pIdxEpr; + pParse->pIdxEpr = 0; + sqlite3ExprCode(pParse, pExpr, target); + pParse->pIdxEpr = p; + sqlite3VdbeJumpHere(v, addr+2); + }else{ + sqlite3VdbeAddOp3(v, OP_Column, p->iIdxCur, p->iIdxCol, target); + VdbeComment((v, "%s expr-column %d", p->zIdxName, p->iIdxCol)); + } + return target; + } + return -1; /* Not found */ +} + + +/* +** Generate code into the current Vdbe to evaluate the given +** expression. Attempt to store the results in register "target". +** Return the register where results are stored. +** +** With this routine, there is no guarantee that results will +** be stored in target. The result might be stored in some other +** register if it is convenient to do so. The calling function +** must check the return code and move the results to the desired +** register. +*/ +SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){ + Vdbe *v = pParse->pVdbe; /* The VM under construction */ + int op; /* The opcode being coded */ + int inReg = target; /* Results stored in register inReg */ + int regFree1 = 0; /* If non-zero free this temporary register */ + int regFree2 = 0; /* If non-zero free this temporary register */ + int r1, r2; /* Various register numbers */ + Expr tempX; /* Temporary expression node */ + int p5 = 0; + + assert( target>0 && target<=pParse->nMem ); + assert( v!=0 ); + +expr_code_doover: + if( pExpr==0 ){ + op = TK_NULL; + }else if( pParse->pIdxEpr!=0 + && !ExprHasProperty(pExpr, EP_Leaf) + && (r1 = sqlite3IndexedExprLookup(pParse, pExpr, target))>=0 + ){ + return r1; + }else{ + assert( !ExprHasVVAProperty(pExpr,EP_Immutable) ); + op = pExpr->op; + } + switch( op ){ + case TK_AGG_COLUMN: { + AggInfo *pAggInfo = pExpr->pAggInfo; + struct AggInfo_col *pCol; + assert( pAggInfo!=0 ); + assert( pExpr->iAgg>=0 ); + if( pExpr->iAgg>=pAggInfo->nColumn ){ + /* Happens when the left table of a RIGHT JOIN is null and + ** is using an expression index */ + sqlite3VdbeAddOp2(v, OP_Null, 0, target); +#ifdef SQLITE_VDBE_COVERAGE + /* Verify that the OP_Null above is exercised by tests + ** tag-20230325-2 */ + sqlite3VdbeAddOp2(v, OP_NotNull, target, 1); + VdbeCoverageNeverTaken(v); +#endif + break; + } + pCol = &pAggInfo->aCol[pExpr->iAgg]; + if( !pAggInfo->directMode ){ + return AggInfoColumnReg(pAggInfo, pExpr->iAgg); + }else if( pAggInfo->useSortingIdx ){ + Table *pTab = pCol->pTab; + sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdxPTab, + pCol->iSorterColumn, target); + if( pTab==0 ){ + /* No comment added */ + }else if( pCol->iColumn<0 ){ + VdbeComment((v,"%s.rowid",pTab->zName)); + }else{ + VdbeComment((v,"%s.%s", + pTab->zName, pTab->aCol[pCol->iColumn].zCnName)); + if( pTab->aCol[pCol->iColumn].affinity==SQLITE_AFF_REAL ){ + sqlite3VdbeAddOp1(v, OP_RealAffinity, target); + } + } + return target; + }else if( pExpr->y.pTab==0 ){ + /* This case happens when the argument to an aggregate function + ** is rewritten by aggregateConvertIndexedExprRefToColumn() */ + sqlite3VdbeAddOp3(v, OP_Column, pExpr->iTable, pExpr->iColumn, target); + return target; + } + /* Otherwise, fall thru into the TK_COLUMN case */ + /* no break */ deliberate_fall_through + } + case TK_COLUMN: { + int iTab = pExpr->iTable; + int iReg; + if( ExprHasProperty(pExpr, EP_FixedCol) ){ + /* This COLUMN expression is really a constant due to WHERE clause + ** constraints, and that constant is coded by the pExpr->pLeft + ** expresssion. However, make sure the constant has the correct + ** datatype by applying the Affinity of the table column to the + ** constant. + */ + int aff; + iReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft,target); + assert( ExprUseYTab(pExpr) ); + assert( pExpr->y.pTab!=0 ); + aff = sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn); + if( aff>SQLITE_AFF_BLOB ){ + static const char zAff[] = "B\000C\000D\000E\000F"; + assert( SQLITE_AFF_BLOB=='A' ); + assert( SQLITE_AFF_TEXT=='B' ); + sqlite3VdbeAddOp4(v, OP_Affinity, iReg, 1, 0, + &zAff[(aff-'B')*2], P4_STATIC); + } + return iReg; + } + if( iTab<0 ){ + if( pParse->iSelfTab<0 ){ + /* Other columns in the same row for CHECK constraints or + ** generated columns or for inserting into partial index. + ** The row is unpacked into registers beginning at + ** 0-(pParse->iSelfTab). The rowid (if any) is in a register + ** immediately prior to the first column. + */ + Column *pCol; + Table *pTab; + int iSrc; + int iCol = pExpr->iColumn; + assert( ExprUseYTab(pExpr) ); + pTab = pExpr->y.pTab; + assert( pTab!=0 ); + assert( iCol>=XN_ROWID ); + assert( iColnCol ); + if( iCol<0 ){ + return -1-pParse->iSelfTab; + } + pCol = pTab->aCol + iCol; + testcase( iCol!=sqlite3TableColumnToStorage(pTab,iCol) ); + iSrc = sqlite3TableColumnToStorage(pTab, iCol) - pParse->iSelfTab; +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + if( pCol->colFlags & COLFLAG_GENERATED ){ + if( pCol->colFlags & COLFLAG_BUSY ){ + sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", + pCol->zCnName); + return 0; + } + pCol->colFlags |= COLFLAG_BUSY; + if( pCol->colFlags & COLFLAG_NOTAVAIL ){ + sqlite3ExprCodeGeneratedColumn(pParse, pTab, pCol, iSrc); + } + pCol->colFlags &= ~(COLFLAG_BUSY|COLFLAG_NOTAVAIL); + return iSrc; + }else +#endif /* SQLITE_OMIT_GENERATED_COLUMNS */ + if( pCol->affinity==SQLITE_AFF_REAL ){ + sqlite3VdbeAddOp2(v, OP_SCopy, iSrc, target); + sqlite3VdbeAddOp1(v, OP_RealAffinity, target); + return target; + }else{ + return iSrc; + } + }else{ + /* Coding an expression that is part of an index where column names + ** in the index refer to the table to which the index belongs */ + iTab = pParse->iSelfTab - 1; + } + } + assert( ExprUseYTab(pExpr) ); + assert( pExpr->y.pTab!=0 ); + iReg = sqlite3ExprCodeGetColumn(pParse, pExpr->y.pTab, + pExpr->iColumn, iTab, target, + pExpr->op2); + return iReg; + } + case TK_INTEGER: { + codeInteger(pParse, pExpr, 0, target); + return target; + } + case TK_TRUEFALSE: { + sqlite3VdbeAddOp2(v, OP_Integer, sqlite3ExprTruthValue(pExpr), target); + return target; + } +#ifndef SQLITE_OMIT_FLOATING_POINT + case TK_FLOAT: { + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + codeReal(v, pExpr->u.zToken, 0, target); + return target; + } +#endif + case TK_STRING: { + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + sqlite3VdbeLoadString(v, target, pExpr->u.zToken); + return target; + } + default: { + /* Make NULL the default case so that if a bug causes an illegal + ** Expr node to be passed into this function, it will be handled + ** sanely and not crash. But keep the assert() to bring the problem + ** to the attention of the developers. */ + assert( op==TK_NULL || op==TK_ERROR || pParse->db->mallocFailed ); + sqlite3VdbeAddOp2(v, OP_Null, 0, target); + return target; + } +#ifndef SQLITE_OMIT_BLOB_LITERAL + case TK_BLOB: { + int n; + const char *z; + char *zBlob; + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' ); + assert( pExpr->u.zToken[1]=='\'' ); + z = &pExpr->u.zToken[2]; + n = sqlite3Strlen30(z) - 1; + assert( z[n]=='\'' ); + zBlob = sqlite3HexToBlob(sqlite3VdbeDb(v), z, n); + sqlite3VdbeAddOp4(v, OP_Blob, n/2, target, 0, zBlob, P4_DYNAMIC); + return target; + } +#endif + case TK_VARIABLE: { + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + assert( pExpr->u.zToken!=0 ); + assert( pExpr->u.zToken[0]!=0 ); + sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iColumn, target); + if( pExpr->u.zToken[1]!=0 ){ + const char *z = sqlite3VListNumToName(pParse->pVList, pExpr->iColumn); + assert( pExpr->u.zToken[0]=='?' || (z && !strcmp(pExpr->u.zToken, z)) ); + pParse->pVList[0] = 0; /* Indicate VList may no longer be enlarged */ + sqlite3VdbeAppendP4(v, (char*)z, P4_STATIC); + } + return target; + } + case TK_REGISTER: { + return pExpr->iTable; + } +#ifndef SQLITE_OMIT_CAST + case TK_CAST: { + /* Expressions of the form: CAST(pLeft AS token) */ + sqlite3ExprCode(pParse, pExpr->pLeft, target); + assert( inReg==target ); + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + sqlite3VdbeAddOp2(v, OP_Cast, target, + sqlite3AffinityType(pExpr->u.zToken, 0)); + return inReg; + } +#endif /* SQLITE_OMIT_CAST */ + case TK_IS: + case TK_ISNOT: + op = (op==TK_IS) ? TK_EQ : TK_NE; + p5 = SQLITE_NULLEQ; + /* fall-through */ + case TK_LT: + case TK_LE: + case TK_GT: + case TK_GE: + case TK_NE: + case TK_EQ: { + Expr *pLeft = pExpr->pLeft; + if( sqlite3ExprIsVector(pLeft) ){ + codeVectorCompare(pParse, pExpr, target, op, p5); + }else{ + r1 = sqlite3ExprCodeTemp(pParse, pLeft, ®Free1); + r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2); + sqlite3VdbeAddOp2(v, OP_Integer, 1, inReg); + codeCompare(pParse, pLeft, pExpr->pRight, op, r1, r2, + sqlite3VdbeCurrentAddr(v)+2, p5, + ExprHasProperty(pExpr,EP_Commuted)); + assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt); + assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le); + assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt); + assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge); + assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq); + assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne); + if( p5==SQLITE_NULLEQ ){ + sqlite3VdbeAddOp2(v, OP_Integer, 0, inReg); + }else{ + sqlite3VdbeAddOp3(v, OP_ZeroOrNull, r1, inReg, r2); + } + testcase( regFree1==0 ); + testcase( regFree2==0 ); + } + break; + } + case TK_AND: + case TK_OR: + case TK_PLUS: + case TK_STAR: + case TK_MINUS: + case TK_REM: + case TK_BITAND: + case TK_BITOR: + case TK_SLASH: + case TK_LSHIFT: + case TK_RSHIFT: + case TK_CONCAT: { + assert( TK_AND==OP_And ); testcase( op==TK_AND ); + assert( TK_OR==OP_Or ); testcase( op==TK_OR ); + assert( TK_PLUS==OP_Add ); testcase( op==TK_PLUS ); + assert( TK_MINUS==OP_Subtract ); testcase( op==TK_MINUS ); + assert( TK_REM==OP_Remainder ); testcase( op==TK_REM ); + assert( TK_BITAND==OP_BitAnd ); testcase( op==TK_BITAND ); + assert( TK_BITOR==OP_BitOr ); testcase( op==TK_BITOR ); + assert( TK_SLASH==OP_Divide ); testcase( op==TK_SLASH ); + assert( TK_LSHIFT==OP_ShiftLeft ); testcase( op==TK_LSHIFT ); + assert( TK_RSHIFT==OP_ShiftRight ); testcase( op==TK_RSHIFT ); + assert( TK_CONCAT==OP_Concat ); testcase( op==TK_CONCAT ); + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2); + sqlite3VdbeAddOp3(v, op, r2, r1, target); + testcase( regFree1==0 ); + testcase( regFree2==0 ); + break; + } + case TK_UMINUS: { + Expr *pLeft = pExpr->pLeft; + assert( pLeft ); + if( pLeft->op==TK_INTEGER ){ + codeInteger(pParse, pLeft, 1, target); + return target; +#ifndef SQLITE_OMIT_FLOATING_POINT + }else if( pLeft->op==TK_FLOAT ){ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + codeReal(v, pLeft->u.zToken, 1, target); + return target; +#endif + }else{ + tempX.op = TK_INTEGER; + tempX.flags = EP_IntValue|EP_TokenOnly; + tempX.u.iValue = 0; + ExprClearVVAProperties(&tempX); + r1 = sqlite3ExprCodeTemp(pParse, &tempX, ®Free1); + r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free2); + sqlite3VdbeAddOp3(v, OP_Subtract, r2, r1, target); + testcase( regFree2==0 ); + } + break; + } + case TK_BITNOT: + case TK_NOT: { + assert( TK_BITNOT==OP_BitNot ); testcase( op==TK_BITNOT ); + assert( TK_NOT==OP_Not ); testcase( op==TK_NOT ); + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + testcase( regFree1==0 ); + sqlite3VdbeAddOp2(v, op, r1, inReg); + break; + } + case TK_TRUTH: { + int isTrue; /* IS TRUE or IS NOT TRUE */ + int bNormal; /* IS TRUE or IS FALSE */ + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + testcase( regFree1==0 ); + isTrue = sqlite3ExprTruthValue(pExpr->pRight); + bNormal = pExpr->op2==TK_IS; + testcase( isTrue && bNormal); + testcase( !isTrue && bNormal); + sqlite3VdbeAddOp4Int(v, OP_IsTrue, r1, inReg, !isTrue, isTrue ^ bNormal); + break; + } + case TK_ISNULL: + case TK_NOTNULL: { + int addr; + assert( TK_ISNULL==OP_IsNull ); testcase( op==TK_ISNULL ); + assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL ); + sqlite3VdbeAddOp2(v, OP_Integer, 1, target); + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + testcase( regFree1==0 ); + addr = sqlite3VdbeAddOp1(v, op, r1); + VdbeCoverageIf(v, op==TK_ISNULL); + VdbeCoverageIf(v, op==TK_NOTNULL); + sqlite3VdbeAddOp2(v, OP_Integer, 0, target); + sqlite3VdbeJumpHere(v, addr); + break; + } + case TK_AGG_FUNCTION: { + AggInfo *pInfo = pExpr->pAggInfo; + if( pInfo==0 + || NEVER(pExpr->iAgg<0) + || NEVER(pExpr->iAgg>=pInfo->nFunc) + ){ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + sqlite3ErrorMsg(pParse, "misuse of aggregate: %#T()", pExpr); + }else{ + return AggInfoFuncReg(pInfo, pExpr->iAgg); + } + break; + } + case TK_FUNCTION: { + ExprList *pFarg; /* List of function arguments */ + int nFarg; /* Number of function arguments */ + FuncDef *pDef; /* The function definition object */ + const char *zId; /* The function name */ + u32 constMask = 0; /* Mask of function arguments that are constant */ + int i; /* Loop counter */ + sqlite3 *db = pParse->db; /* The database connection */ + u8 enc = ENC(db); /* The text encoding used by this database */ + CollSeq *pColl = 0; /* A collating sequence */ + +#ifndef SQLITE_OMIT_WINDOWFUNC + if( ExprHasProperty(pExpr, EP_WinFunc) ){ + return pExpr->y.pWin->regResult; + } +#endif + + if( ConstFactorOk(pParse) && sqlite3ExprIsConstantNotJoin(pExpr) ){ + /* SQL functions can be expensive. So try to avoid running them + ** multiple times if we know they always give the same result */ + return sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1); + } + assert( !ExprHasProperty(pExpr, EP_TokenOnly) ); + assert( ExprUseXList(pExpr) ); + pFarg = pExpr->x.pList; + nFarg = pFarg ? pFarg->nExpr : 0; + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + zId = pExpr->u.zToken; + pDef = sqlite3FindFunction(db, zId, nFarg, enc, 0); +#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION + if( pDef==0 && pParse->explain ){ + pDef = sqlite3FindFunction(db, "unknown", nFarg, enc, 0); + } +#endif + if( pDef==0 || pDef->xFinalize!=0 ){ + sqlite3ErrorMsg(pParse, "unknown function: %#T()", pExpr); + break; + } + if( pDef->funcFlags & SQLITE_FUNC_INLINE ){ + assert( (pDef->funcFlags & SQLITE_FUNC_UNSAFE)==0 ); + assert( (pDef->funcFlags & SQLITE_FUNC_DIRECT)==0 ); + return exprCodeInlineFunction(pParse, pFarg, + SQLITE_PTR_TO_INT(pDef->pUserData), target); + }else if( pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE) ){ + sqlite3ExprFunctionUsable(pParse, pExpr, pDef); + } + + for(i=0; ia[i].pExpr) ){ + testcase( i==31 ); + constMask |= MASKBIT32(i); + } + if( (pDef->funcFlags & SQLITE_FUNC_NEEDCOLL)!=0 && !pColl ){ + pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr); + } + } + if( pFarg ){ + if( constMask ){ + r1 = pParse->nMem+1; + pParse->nMem += nFarg; + }else{ + r1 = sqlite3GetTempRange(pParse, nFarg); + } + + /* For length() and typeof() functions with a column argument, + ** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG + ** or OPFLAG_TYPEOFARG respectively, to avoid unnecessary data + ** loading. + */ + if( (pDef->funcFlags & (SQLITE_FUNC_LENGTH|SQLITE_FUNC_TYPEOF))!=0 ){ + u8 exprOp; + assert( nFarg==1 ); + assert( pFarg->a[0].pExpr!=0 ); + exprOp = pFarg->a[0].pExpr->op; + if( exprOp==TK_COLUMN || exprOp==TK_AGG_COLUMN ){ + assert( SQLITE_FUNC_LENGTH==OPFLAG_LENGTHARG ); + assert( SQLITE_FUNC_TYPEOF==OPFLAG_TYPEOFARG ); + testcase( pDef->funcFlags & OPFLAG_LENGTHARG ); + pFarg->a[0].pExpr->op2 = + pDef->funcFlags & (OPFLAG_LENGTHARG|OPFLAG_TYPEOFARG); + } + } + + sqlite3ExprCodeExprList(pParse, pFarg, r1, 0, + SQLITE_ECEL_DUP|SQLITE_ECEL_FACTOR); + }else{ + r1 = 0; + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + /* Possibly overload the function if the first argument is + ** a virtual table column. + ** + ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the + ** second argument, not the first, as the argument to test to + ** see if it is a column in a virtual table. This is done because + ** the left operand of infix functions (the operand we want to + ** control overloading) ends up as the second argument to the + ** function. The expression "A glob B" is equivalent to + ** "glob(B,A). We want to use the A in "A glob B" to test + ** for function overloading. But we use the B term in "glob(B,A)". + */ + if( nFarg>=2 && ExprHasProperty(pExpr, EP_InfixFunc) ){ + pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr); + }else if( nFarg>0 ){ + pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr); + } +#endif + if( pDef->funcFlags & SQLITE_FUNC_NEEDCOLL ){ + if( !pColl ) pColl = db->pDfltColl; + sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ); + } + sqlite3VdbeAddFunctionCall(pParse, constMask, r1, target, nFarg, + pDef, pExpr->op2); + if( nFarg ){ + if( constMask==0 ){ + sqlite3ReleaseTempRange(pParse, r1, nFarg); + }else{ + sqlite3VdbeReleaseRegisters(pParse, r1, nFarg, constMask, 1); + } + } + return target; + } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_EXISTS: + case TK_SELECT: { + int nCol; + testcase( op==TK_EXISTS ); + testcase( op==TK_SELECT ); + if( pParse->db->mallocFailed ){ + return 0; + }else if( op==TK_SELECT + && ALWAYS( ExprUseXSelect(pExpr) ) + && (nCol = pExpr->x.pSelect->pEList->nExpr)!=1 + ){ + sqlite3SubselectError(pParse, nCol, 1); + }else{ + return sqlite3CodeSubselect(pParse, pExpr); + } + break; + } + case TK_SELECT_COLUMN: { + int n; + Expr *pLeft = pExpr->pLeft; + if( pLeft->iTable==0 || pParse->withinRJSubrtn > pLeft->op2 ){ + pLeft->iTable = sqlite3CodeSubselect(pParse, pLeft); + pLeft->op2 = pParse->withinRJSubrtn; + } + assert( pLeft->op==TK_SELECT || pLeft->op==TK_ERROR ); + n = sqlite3ExprVectorSize(pLeft); + if( pExpr->iTable!=n ){ + sqlite3ErrorMsg(pParse, "%d columns assigned %d values", + pExpr->iTable, n); + } + return pLeft->iTable + pExpr->iColumn; + } + case TK_IN: { + int destIfFalse = sqlite3VdbeMakeLabel(pParse); + int destIfNull = sqlite3VdbeMakeLabel(pParse); + sqlite3VdbeAddOp2(v, OP_Null, 0, target); + sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull); + sqlite3VdbeAddOp2(v, OP_Integer, 1, target); + sqlite3VdbeResolveLabel(v, destIfFalse); + sqlite3VdbeAddOp2(v, OP_AddImm, target, 0); + sqlite3VdbeResolveLabel(v, destIfNull); + return target; + } +#endif /* SQLITE_OMIT_SUBQUERY */ + + + /* + ** x BETWEEN y AND z + ** + ** This is equivalent to + ** + ** x>=y AND x<=z + ** + ** X is stored in pExpr->pLeft. + ** Y is stored in pExpr->pList->a[0].pExpr. + ** Z is stored in pExpr->pList->a[1].pExpr. + */ + case TK_BETWEEN: { + exprCodeBetween(pParse, pExpr, target, 0, 0); + return target; + } + case TK_COLLATE: { + if( !ExprHasProperty(pExpr, EP_Collate) ){ + /* A TK_COLLATE Expr node without the EP_Collate tag is a so-called + ** "SOFT-COLLATE" that is added to constraints that are pushed down + ** from outer queries into sub-queries by the push-down optimization. + ** Clear subtypes as subtypes may not cross a subquery boundary. + */ + assert( pExpr->pLeft ); + sqlite3ExprCode(pParse, pExpr->pLeft, target); + sqlite3VdbeAddOp1(v, OP_ClrSubtype, target); + return target; + }else{ + pExpr = pExpr->pLeft; + goto expr_code_doover; /* 2018-04-28: Prevent deep recursion. */ + } + } + case TK_SPAN: + case TK_UPLUS: { + pExpr = pExpr->pLeft; + goto expr_code_doover; /* 2018-04-28: Prevent deep recursion. OSSFuzz. */ + } + + case TK_TRIGGER: { + /* If the opcode is TK_TRIGGER, then the expression is a reference + ** to a column in the new.* or old.* pseudo-tables available to + ** trigger programs. In this case Expr.iTable is set to 1 for the + ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn + ** is set to the column of the pseudo-table to read, or to -1 to + ** read the rowid field. + ** + ** The expression is implemented using an OP_Param opcode. The p1 + ** parameter is set to 0 for an old.rowid reference, or to (i+1) + ** to reference another column of the old.* pseudo-table, where + ** i is the index of the column. For a new.rowid reference, p1 is + ** set to (n+1), where n is the number of columns in each pseudo-table. + ** For a reference to any other column in the new.* pseudo-table, p1 + ** is set to (n+2+i), where n and i are as defined previously. For + ** example, if the table on which triggers are being fired is + ** declared as: + ** + ** CREATE TABLE t1(a, b); + ** + ** Then p1 is interpreted as follows: + ** + ** p1==0 -> old.rowid p1==3 -> new.rowid + ** p1==1 -> old.a p1==4 -> new.a + ** p1==2 -> old.b p1==5 -> new.b + */ + Table *pTab; + int iCol; + int p1; + + assert( ExprUseYTab(pExpr) ); + pTab = pExpr->y.pTab; + iCol = pExpr->iColumn; + p1 = pExpr->iTable * (pTab->nCol+1) + 1 + + sqlite3TableColumnToStorage(pTab, iCol); + + assert( pExpr->iTable==0 || pExpr->iTable==1 ); + assert( iCol>=-1 && iColnCol ); + assert( pTab->iPKey<0 || iCol!=pTab->iPKey ); + assert( p1>=0 && p1<(pTab->nCol*2+2) ); + + sqlite3VdbeAddOp2(v, OP_Param, p1, target); + VdbeComment((v, "r[%d]=%s.%s", target, + (pExpr->iTable ? "new" : "old"), + (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zCnName) + )); + +#ifndef SQLITE_OMIT_FLOATING_POINT + /* If the column has REAL affinity, it may currently be stored as an + ** integer. Use OP_RealAffinity to make sure it is really real. + ** + ** EVIDENCE-OF: R-60985-57662 SQLite will convert the value back to + ** floating point when extracting it from the record. */ + if( iCol>=0 && pTab->aCol[iCol].affinity==SQLITE_AFF_REAL ){ + sqlite3VdbeAddOp1(v, OP_RealAffinity, target); + } +#endif + break; + } + + case TK_VECTOR: { + sqlite3ErrorMsg(pParse, "row value misused"); + break; + } + + /* TK_IF_NULL_ROW Expr nodes are inserted ahead of expressions + ** that derive from the right-hand table of a LEFT JOIN. The + ** Expr.iTable value is the table number for the right-hand table. + ** The expression is only evaluated if that table is not currently + ** on a LEFT JOIN NULL row. + */ + case TK_IF_NULL_ROW: { + int addrINR; + u8 okConstFactor = pParse->okConstFactor; + AggInfo *pAggInfo = pExpr->pAggInfo; + if( pAggInfo ){ + assert( pExpr->iAgg>=0 && pExpr->iAggnColumn ); + if( !pAggInfo->directMode ){ + inReg = AggInfoColumnReg(pAggInfo, pExpr->iAgg); + break; + } + if( pExpr->pAggInfo->useSortingIdx ){ + sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdxPTab, + pAggInfo->aCol[pExpr->iAgg].iSorterColumn, + target); + inReg = target; + break; + } + } + addrINR = sqlite3VdbeAddOp3(v, OP_IfNullRow, pExpr->iTable, 0, target); + /* The OP_IfNullRow opcode above can overwrite the result register with + ** NULL. So we have to ensure that the result register is not a value + ** that is suppose to be a constant. Two defenses are needed: + ** (1) Temporarily disable factoring of constant expressions + ** (2) Make sure the computed value really is stored in register + ** "target" and not someplace else. + */ + pParse->okConstFactor = 0; /* note (1) above */ + sqlite3ExprCode(pParse, pExpr->pLeft, target); + assert( target==inReg ); + pParse->okConstFactor = okConstFactor; + sqlite3VdbeJumpHere(v, addrINR); + break; + } + + /* + ** Form A: + ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END + ** + ** Form B: + ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END + ** + ** Form A is can be transformed into the equivalent form B as follows: + ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ... + ** WHEN x=eN THEN rN ELSE y END + ** + ** X (if it exists) is in pExpr->pLeft. + ** Y is in the last element of pExpr->x.pList if pExpr->x.pList->nExpr is + ** odd. The Y is also optional. If the number of elements in x.pList + ** is even, then Y is omitted and the "otherwise" result is NULL. + ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1]. + ** + ** The result of the expression is the Ri for the first matching Ei, + ** or if there is no matching Ei, the ELSE term Y, or if there is + ** no ELSE term, NULL. + */ + case TK_CASE: { + int endLabel; /* GOTO label for end of CASE stmt */ + int nextCase; /* GOTO label for next WHEN clause */ + int nExpr; /* 2x number of WHEN terms */ + int i; /* Loop counter */ + ExprList *pEList; /* List of WHEN terms */ + struct ExprList_item *aListelem; /* Array of WHEN terms */ + Expr opCompare; /* The X==Ei expression */ + Expr *pX; /* The X expression */ + Expr *pTest = 0; /* X==Ei (form A) or just Ei (form B) */ + Expr *pDel = 0; + sqlite3 *db = pParse->db; + + assert( ExprUseXList(pExpr) && pExpr->x.pList!=0 ); + assert(pExpr->x.pList->nExpr > 0); + pEList = pExpr->x.pList; + aListelem = pEList->a; + nExpr = pEList->nExpr; + endLabel = sqlite3VdbeMakeLabel(pParse); + if( (pX = pExpr->pLeft)!=0 ){ + pDel = sqlite3ExprDup(db, pX, 0); + if( db->mallocFailed ){ + sqlite3ExprDelete(db, pDel); + break; + } + testcase( pX->op==TK_COLUMN ); + exprToRegister(pDel, exprCodeVector(pParse, pDel, ®Free1)); + testcase( regFree1==0 ); + memset(&opCompare, 0, sizeof(opCompare)); + opCompare.op = TK_EQ; + opCompare.pLeft = pDel; + pTest = &opCompare; + /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001: + ** The value in regFree1 might get SCopy-ed into the file result. + ** So make sure that the regFree1 register is not reused for other + ** purposes and possibly overwritten. */ + regFree1 = 0; + } + for(i=0; iop==TK_COLUMN ); + sqlite3ExprIfFalse(pParse, pTest, nextCase, SQLITE_JUMPIFNULL); + testcase( aListelem[i+1].pExpr->op==TK_COLUMN ); + sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target); + sqlite3VdbeGoto(v, endLabel); + sqlite3VdbeResolveLabel(v, nextCase); + } + if( (nExpr&1)!=0 ){ + sqlite3ExprCode(pParse, pEList->a[nExpr-1].pExpr, target); + }else{ + sqlite3VdbeAddOp2(v, OP_Null, 0, target); + } + sqlite3ExprDelete(db, pDel); + setDoNotMergeFlagOnCopy(v); + sqlite3VdbeResolveLabel(v, endLabel); + break; + } +#ifndef SQLITE_OMIT_TRIGGER + case TK_RAISE: { + assert( pExpr->affExpr==OE_Rollback + || pExpr->affExpr==OE_Abort + || pExpr->affExpr==OE_Fail + || pExpr->affExpr==OE_Ignore + ); + if( !pParse->pTriggerTab && !pParse->nested ){ + sqlite3ErrorMsg(pParse, + "RAISE() may only be used within a trigger-program"); + return 0; + } + if( pExpr->affExpr==OE_Abort ){ + sqlite3MayAbort(pParse); + } + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + if( pExpr->affExpr==OE_Ignore ){ + sqlite3VdbeAddOp4( + v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0); + VdbeCoverage(v); + }else{ + sqlite3HaltConstraint(pParse, + pParse->pTriggerTab ? SQLITE_CONSTRAINT_TRIGGER : SQLITE_ERROR, + pExpr->affExpr, pExpr->u.zToken, 0, 0); + } + + break; + } +#endif + } + sqlite3ReleaseTempReg(pParse, regFree1); + sqlite3ReleaseTempReg(pParse, regFree2); + return inReg; +} + +/* +** Generate code that will evaluate expression pExpr just one time +** per prepared statement execution. +** +** If the expression uses functions (that might throw an exception) then +** guard them with an OP_Once opcode to ensure that the code is only executed +** once. If no functions are involved, then factor the code out and put it at +** the end of the prepared statement in the initialization section. +** +** If regDest>=0 then the result is always stored in that register and the +** result is not reusable. If regDest<0 then this routine is free to +** store the value whereever it wants. The register where the expression +** is stored is returned. When regDest<0, two identical expressions might +** code to the same register, if they do not contain function calls and hence +** are factored out into the initialization section at the end of the +** prepared statement. +*/ +SQLITE_PRIVATE int sqlite3ExprCodeRunJustOnce( + Parse *pParse, /* Parsing context */ + Expr *pExpr, /* The expression to code when the VDBE initializes */ + int regDest /* Store the value in this register */ +){ + ExprList *p; + assert( ConstFactorOk(pParse) ); + p = pParse->pConstExpr; + if( regDest<0 && p ){ + struct ExprList_item *pItem; + int i; + for(pItem=p->a, i=p->nExpr; i>0; pItem++, i--){ + if( pItem->fg.reusable + && sqlite3ExprCompare(0,pItem->pExpr,pExpr,-1)==0 + ){ + return pItem->u.iConstExprReg; + } + } + } + pExpr = sqlite3ExprDup(pParse->db, pExpr, 0); + if( pExpr!=0 && ExprHasProperty(pExpr, EP_HasFunc) ){ + Vdbe *v = pParse->pVdbe; + int addr; + assert( v ); + addr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); + pParse->okConstFactor = 0; + if( !pParse->db->mallocFailed ){ + if( regDest<0 ) regDest = ++pParse->nMem; + sqlite3ExprCode(pParse, pExpr, regDest); + } + pParse->okConstFactor = 1; + sqlite3ExprDelete(pParse->db, pExpr); + sqlite3VdbeJumpHere(v, addr); + }else{ + p = sqlite3ExprListAppend(pParse, p, pExpr); + if( p ){ + struct ExprList_item *pItem = &p->a[p->nExpr-1]; + pItem->fg.reusable = regDest<0; + if( regDest<0 ) regDest = ++pParse->nMem; + pItem->u.iConstExprReg = regDest; + } + pParse->pConstExpr = p; + } + return regDest; +} + +/* +** Generate code to evaluate an expression and store the results +** into a register. Return the register number where the results +** are stored. +** +** If the register is a temporary register that can be deallocated, +** then write its number into *pReg. If the result register is not +** a temporary, then set *pReg to zero. +** +** If pExpr is a constant, then this routine might generate this +** code to fill the register in the initialization section of the +** VDBE program, in order to factor it out of the evaluation loop. +*/ +SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){ + int r2; + pExpr = sqlite3ExprSkipCollateAndLikely(pExpr); + if( ConstFactorOk(pParse) + && ALWAYS(pExpr!=0) + && pExpr->op!=TK_REGISTER + && sqlite3ExprIsConstantNotJoin(pExpr) + ){ + *pReg = 0; + r2 = sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1); + }else{ + int r1 = sqlite3GetTempReg(pParse); + r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1); + if( r2==r1 ){ + *pReg = r1; + }else{ + sqlite3ReleaseTempReg(pParse, r1); + *pReg = 0; + } + } + return r2; +} + +/* +** Generate code that will evaluate expression pExpr and store the +** results in register target. The results are guaranteed to appear +** in register target. +*/ +SQLITE_PRIVATE void sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){ + int inReg; + + assert( pExpr==0 || !ExprHasVVAProperty(pExpr,EP_Immutable) ); + assert( target>0 && target<=pParse->nMem ); + assert( pParse->pVdbe!=0 || pParse->db->mallocFailed ); + if( pParse->pVdbe==0 ) return; + inReg = sqlite3ExprCodeTarget(pParse, pExpr, target); + if( inReg!=target ){ + u8 op; + if( ALWAYS(pExpr) + && (ExprHasProperty(pExpr,EP_Subquery) || pExpr->op==TK_REGISTER) + ){ + op = OP_Copy; + }else{ + op = OP_SCopy; + } + sqlite3VdbeAddOp2(pParse->pVdbe, op, inReg, target); + } +} + +/* +** Make a transient copy of expression pExpr and then code it using +** sqlite3ExprCode(). This routine works just like sqlite3ExprCode() +** except that the input expression is guaranteed to be unchanged. +*/ +SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse *pParse, Expr *pExpr, int target){ + sqlite3 *db = pParse->db; + pExpr = sqlite3ExprDup(db, pExpr, 0); + if( !db->mallocFailed ) sqlite3ExprCode(pParse, pExpr, target); + sqlite3ExprDelete(db, pExpr); +} + +/* +** Generate code that will evaluate expression pExpr and store the +** results in register target. The results are guaranteed to appear +** in register target. If the expression is constant, then this routine +** might choose to code the expression at initialization time. +*/ +SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse *pParse, Expr *pExpr, int target){ + if( pParse->okConstFactor && sqlite3ExprIsConstantNotJoin(pExpr) ){ + sqlite3ExprCodeRunJustOnce(pParse, pExpr, target); + }else{ + sqlite3ExprCodeCopy(pParse, pExpr, target); + } +} + +/* +** Generate code that pushes the value of every element of the given +** expression list into a sequence of registers beginning at target. +** +** Return the number of elements evaluated. The number returned will +** usually be pList->nExpr but might be reduced if SQLITE_ECEL_OMITREF +** is defined. +** +** The SQLITE_ECEL_DUP flag prevents the arguments from being +** filled using OP_SCopy. OP_Copy must be used instead. +** +** The SQLITE_ECEL_FACTOR argument allows constant arguments to be +** factored out into initialization code. +** +** The SQLITE_ECEL_REF flag means that expressions in the list with +** ExprList.a[].u.x.iOrderByCol>0 have already been evaluated and stored +** in registers at srcReg, and so the value can be copied from there. +** If SQLITE_ECEL_OMITREF is also set, then the values with u.x.iOrderByCol>0 +** are simply omitted rather than being copied from srcReg. +*/ +SQLITE_PRIVATE int sqlite3ExprCodeExprList( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* The expression list to be coded */ + int target, /* Where to write results */ + int srcReg, /* Source registers if SQLITE_ECEL_REF */ + u8 flags /* SQLITE_ECEL_* flags */ +){ + struct ExprList_item *pItem; + int i, j, n; + u8 copyOp = (flags & SQLITE_ECEL_DUP) ? OP_Copy : OP_SCopy; + Vdbe *v = pParse->pVdbe; + assert( pList!=0 ); + assert( target>0 ); + assert( pParse->pVdbe!=0 ); /* Never gets this far otherwise */ + n = pList->nExpr; + if( !ConstFactorOk(pParse) ) flags &= ~SQLITE_ECEL_FACTOR; + for(pItem=pList->a, i=0; ipExpr; +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + if( pItem->fg.bSorterRef ){ + i--; + n--; + }else +#endif + if( (flags & SQLITE_ECEL_REF)!=0 && (j = pItem->u.x.iOrderByCol)>0 ){ + if( flags & SQLITE_ECEL_OMITREF ){ + i--; + n--; + }else{ + sqlite3VdbeAddOp2(v, copyOp, j+srcReg-1, target+i); + } + }else if( (flags & SQLITE_ECEL_FACTOR)!=0 + && sqlite3ExprIsConstantNotJoin(pExpr) + ){ + sqlite3ExprCodeRunJustOnce(pParse, pExpr, target+i); + }else{ + int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i); + if( inReg!=target+i ){ + VdbeOp *pOp; + if( copyOp==OP_Copy + && (pOp=sqlite3VdbeGetLastOp(v))->opcode==OP_Copy + && pOp->p1+pOp->p3+1==inReg + && pOp->p2+pOp->p3+1==target+i + && pOp->p5==0 /* The do-not-merge flag must be clear */ + ){ + pOp->p3++; + }else{ + sqlite3VdbeAddOp2(v, copyOp, inReg, target+i); + } + } + } + } + return n; +} + +/* +** Generate code for a BETWEEN operator. +** +** x BETWEEN y AND z +** +** The above is equivalent to +** +** x>=y AND x<=z +** +** Code it as such, taking care to do the common subexpression +** elimination of x. +** +** The xJumpIf parameter determines details: +** +** NULL: Store the boolean result in reg[dest] +** sqlite3ExprIfTrue: Jump to dest if true +** sqlite3ExprIfFalse: Jump to dest if false +** +** The jumpIfNull parameter is ignored if xJumpIf is NULL. +*/ +static void exprCodeBetween( + Parse *pParse, /* Parsing and code generating context */ + Expr *pExpr, /* The BETWEEN expression */ + int dest, /* Jump destination or storage location */ + void (*xJump)(Parse*,Expr*,int,int), /* Action to take */ + int jumpIfNull /* Take the jump if the BETWEEN is NULL */ +){ + Expr exprAnd; /* The AND operator in x>=y AND x<=z */ + Expr compLeft; /* The x>=y term */ + Expr compRight; /* The x<=z term */ + int regFree1 = 0; /* Temporary use register */ + Expr *pDel = 0; + sqlite3 *db = pParse->db; + + memset(&compLeft, 0, sizeof(Expr)); + memset(&compRight, 0, sizeof(Expr)); + memset(&exprAnd, 0, sizeof(Expr)); + + assert( ExprUseXList(pExpr) ); + pDel = sqlite3ExprDup(db, pExpr->pLeft, 0); + if( db->mallocFailed==0 ){ + exprAnd.op = TK_AND; + exprAnd.pLeft = &compLeft; + exprAnd.pRight = &compRight; + compLeft.op = TK_GE; + compLeft.pLeft = pDel; + compLeft.pRight = pExpr->x.pList->a[0].pExpr; + compRight.op = TK_LE; + compRight.pLeft = pDel; + compRight.pRight = pExpr->x.pList->a[1].pExpr; + exprToRegister(pDel, exprCodeVector(pParse, pDel, ®Free1)); + if( xJump ){ + xJump(pParse, &exprAnd, dest, jumpIfNull); + }else{ + /* Mark the expression is being from the ON or USING clause of a join + ** so that the sqlite3ExprCodeTarget() routine will not attempt to move + ** it into the Parse.pConstExpr list. We should use a new bit for this, + ** for clarity, but we are out of bits in the Expr.flags field so we + ** have to reuse the EP_OuterON bit. Bummer. */ + pDel->flags |= EP_OuterON; + sqlite3ExprCodeTarget(pParse, &exprAnd, dest); + } + sqlite3ReleaseTempReg(pParse, regFree1); + } + sqlite3ExprDelete(db, pDel); + + /* Ensure adequate test coverage */ + testcase( xJump==sqlite3ExprIfTrue && jumpIfNull==0 && regFree1==0 ); + testcase( xJump==sqlite3ExprIfTrue && jumpIfNull==0 && regFree1!=0 ); + testcase( xJump==sqlite3ExprIfTrue && jumpIfNull!=0 && regFree1==0 ); + testcase( xJump==sqlite3ExprIfTrue && jumpIfNull!=0 && regFree1!=0 ); + testcase( xJump==sqlite3ExprIfFalse && jumpIfNull==0 && regFree1==0 ); + testcase( xJump==sqlite3ExprIfFalse && jumpIfNull==0 && regFree1!=0 ); + testcase( xJump==sqlite3ExprIfFalse && jumpIfNull!=0 && regFree1==0 ); + testcase( xJump==sqlite3ExprIfFalse && jumpIfNull!=0 && regFree1!=0 ); + testcase( xJump==0 ); +} + +/* +** Generate code for a boolean expression such that a jump is made +** to the label "dest" if the expression is true but execution +** continues straight thru if the expression is false. +** +** If the expression evaluates to NULL (neither true nor false), then +** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL. +** +** This code depends on the fact that certain token values (ex: TK_EQ) +** are the same as opcode values (ex: OP_Eq) that implement the corresponding +** operation. Special comments in vdbe.c and the mkopcodeh.awk script in +** the make process cause these values to align. Assert()s in the code +** below verify that the numbers are aligned correctly. +*/ +SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ + Vdbe *v = pParse->pVdbe; + int op = 0; + int regFree1 = 0; + int regFree2 = 0; + int r1, r2; + + assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 ); + if( NEVER(v==0) ) return; /* Existence of VDBE checked by caller */ + if( NEVER(pExpr==0) ) return; /* No way this can happen */ + assert( !ExprHasVVAProperty(pExpr, EP_Immutable) ); + op = pExpr->op; + switch( op ){ + case TK_AND: + case TK_OR: { + Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr); + if( pAlt!=pExpr ){ + sqlite3ExprIfTrue(pParse, pAlt, dest, jumpIfNull); + }else if( op==TK_AND ){ + int d2 = sqlite3VdbeMakeLabel(pParse); + testcase( jumpIfNull==0 ); + sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2, + jumpIfNull^SQLITE_JUMPIFNULL); + sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull); + sqlite3VdbeResolveLabel(v, d2); + }else{ + testcase( jumpIfNull==0 ); + sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull); + sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull); + } + break; + } + case TK_NOT: { + testcase( jumpIfNull==0 ); + sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull); + break; + } + case TK_TRUTH: { + int isNot; /* IS NOT TRUE or IS NOT FALSE */ + int isTrue; /* IS TRUE or IS NOT TRUE */ + testcase( jumpIfNull==0 ); + isNot = pExpr->op2==TK_ISNOT; + isTrue = sqlite3ExprTruthValue(pExpr->pRight); + testcase( isTrue && isNot ); + testcase( !isTrue && isNot ); + if( isTrue ^ isNot ){ + sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, + isNot ? SQLITE_JUMPIFNULL : 0); + }else{ + sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, + isNot ? SQLITE_JUMPIFNULL : 0); + } + break; + } + case TK_IS: + case TK_ISNOT: + testcase( op==TK_IS ); + testcase( op==TK_ISNOT ); + op = (op==TK_IS) ? TK_EQ : TK_NE; + jumpIfNull = SQLITE_NULLEQ; + /* no break */ deliberate_fall_through + case TK_LT: + case TK_LE: + case TK_GT: + case TK_GE: + case TK_NE: + case TK_EQ: { + if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr; + testcase( jumpIfNull==0 ); + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2); + codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, + r1, r2, dest, jumpIfNull, ExprHasProperty(pExpr,EP_Commuted)); + assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt); + assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le); + assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt); + assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge); + assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); + VdbeCoverageIf(v, op==OP_Eq && jumpIfNull==SQLITE_NULLEQ); + VdbeCoverageIf(v, op==OP_Eq && jumpIfNull!=SQLITE_NULLEQ); + assert(TK_NE==OP_Ne); testcase(op==OP_Ne); + VdbeCoverageIf(v, op==OP_Ne && jumpIfNull==SQLITE_NULLEQ); + VdbeCoverageIf(v, op==OP_Ne && jumpIfNull!=SQLITE_NULLEQ); + testcase( regFree1==0 ); + testcase( regFree2==0 ); + break; + } + case TK_ISNULL: + case TK_NOTNULL: { + assert( TK_ISNULL==OP_IsNull ); testcase( op==TK_ISNULL ); + assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL ); + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + sqlite3VdbeTypeofColumn(v, r1); + sqlite3VdbeAddOp2(v, op, r1, dest); + VdbeCoverageIf(v, op==TK_ISNULL); + VdbeCoverageIf(v, op==TK_NOTNULL); + testcase( regFree1==0 ); + break; + } + case TK_BETWEEN: { + testcase( jumpIfNull==0 ); + exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfTrue, jumpIfNull); + break; + } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_IN: { + int destIfFalse = sqlite3VdbeMakeLabel(pParse); + int destIfNull = jumpIfNull ? dest : destIfFalse; + sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull); + sqlite3VdbeGoto(v, dest); + sqlite3VdbeResolveLabel(v, destIfFalse); + break; + } +#endif + default: { + default_expr: + if( ExprAlwaysTrue(pExpr) ){ + sqlite3VdbeGoto(v, dest); + }else if( ExprAlwaysFalse(pExpr) ){ + /* No-op */ + }else{ + r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1); + sqlite3VdbeAddOp3(v, OP_If, r1, dest, jumpIfNull!=0); + VdbeCoverage(v); + testcase( regFree1==0 ); + testcase( jumpIfNull==0 ); + } + break; + } + } + sqlite3ReleaseTempReg(pParse, regFree1); + sqlite3ReleaseTempReg(pParse, regFree2); +} + +/* +** Generate code for a boolean expression such that a jump is made +** to the label "dest" if the expression is false but execution +** continues straight thru if the expression is true. +** +** If the expression evaluates to NULL (neither true nor false) then +** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull +** is 0. +*/ +SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ + Vdbe *v = pParse->pVdbe; + int op = 0; + int regFree1 = 0; + int regFree2 = 0; + int r1, r2; + + assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 ); + if( NEVER(v==0) ) return; /* Existence of VDBE checked by caller */ + if( pExpr==0 ) return; + assert( !ExprHasVVAProperty(pExpr,EP_Immutable) ); + + /* The value of pExpr->op and op are related as follows: + ** + ** pExpr->op op + ** --------- ---------- + ** TK_ISNULL OP_NotNull + ** TK_NOTNULL OP_IsNull + ** TK_NE OP_Eq + ** TK_EQ OP_Ne + ** TK_GT OP_Le + ** TK_LE OP_Gt + ** TK_GE OP_Lt + ** TK_LT OP_Ge + ** + ** For other values of pExpr->op, op is undefined and unused. + ** The value of TK_ and OP_ constants are arranged such that we + ** can compute the mapping above using the following expression. + ** Assert()s verify that the computation is correct. + */ + op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1); + + /* Verify correct alignment of TK_ and OP_ constants + */ + assert( pExpr->op!=TK_ISNULL || op==OP_NotNull ); + assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull ); + assert( pExpr->op!=TK_NE || op==OP_Eq ); + assert( pExpr->op!=TK_EQ || op==OP_Ne ); + assert( pExpr->op!=TK_LT || op==OP_Ge ); + assert( pExpr->op!=TK_LE || op==OP_Gt ); + assert( pExpr->op!=TK_GT || op==OP_Le ); + assert( pExpr->op!=TK_GE || op==OP_Lt ); + + switch( pExpr->op ){ + case TK_AND: + case TK_OR: { + Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr); + if( pAlt!=pExpr ){ + sqlite3ExprIfFalse(pParse, pAlt, dest, jumpIfNull); + }else if( pExpr->op==TK_AND ){ + testcase( jumpIfNull==0 ); + sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull); + sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull); + }else{ + int d2 = sqlite3VdbeMakeLabel(pParse); + testcase( jumpIfNull==0 ); + sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, + jumpIfNull^SQLITE_JUMPIFNULL); + sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull); + sqlite3VdbeResolveLabel(v, d2); + } + break; + } + case TK_NOT: { + testcase( jumpIfNull==0 ); + sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull); + break; + } + case TK_TRUTH: { + int isNot; /* IS NOT TRUE or IS NOT FALSE */ + int isTrue; /* IS TRUE or IS NOT TRUE */ + testcase( jumpIfNull==0 ); + isNot = pExpr->op2==TK_ISNOT; + isTrue = sqlite3ExprTruthValue(pExpr->pRight); + testcase( isTrue && isNot ); + testcase( !isTrue && isNot ); + if( isTrue ^ isNot ){ + /* IS TRUE and IS NOT FALSE */ + sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, + isNot ? 0 : SQLITE_JUMPIFNULL); + + }else{ + /* IS FALSE and IS NOT TRUE */ + sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, + isNot ? 0 : SQLITE_JUMPIFNULL); + } + break; + } + case TK_IS: + case TK_ISNOT: + testcase( pExpr->op==TK_IS ); + testcase( pExpr->op==TK_ISNOT ); + op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ; + jumpIfNull = SQLITE_NULLEQ; + /* no break */ deliberate_fall_through + case TK_LT: + case TK_LE: + case TK_GT: + case TK_GE: + case TK_NE: + case TK_EQ: { + if( sqlite3ExprIsVector(pExpr->pLeft) ) goto default_expr; + testcase( jumpIfNull==0 ); + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2); + codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, + r1, r2, dest, jumpIfNull,ExprHasProperty(pExpr,EP_Commuted)); + assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt); + assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le); + assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt); + assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge); + assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); + VdbeCoverageIf(v, op==OP_Eq && jumpIfNull!=SQLITE_NULLEQ); + VdbeCoverageIf(v, op==OP_Eq && jumpIfNull==SQLITE_NULLEQ); + assert(TK_NE==OP_Ne); testcase(op==OP_Ne); + VdbeCoverageIf(v, op==OP_Ne && jumpIfNull!=SQLITE_NULLEQ); + VdbeCoverageIf(v, op==OP_Ne && jumpIfNull==SQLITE_NULLEQ); + testcase( regFree1==0 ); + testcase( regFree2==0 ); + break; + } + case TK_ISNULL: + case TK_NOTNULL: { + r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1); + sqlite3VdbeTypeofColumn(v, r1); + sqlite3VdbeAddOp2(v, op, r1, dest); + testcase( op==TK_ISNULL ); VdbeCoverageIf(v, op==TK_ISNULL); + testcase( op==TK_NOTNULL ); VdbeCoverageIf(v, op==TK_NOTNULL); + testcase( regFree1==0 ); + break; + } + case TK_BETWEEN: { + testcase( jumpIfNull==0 ); + exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfFalse, jumpIfNull); + break; + } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_IN: { + if( jumpIfNull ){ + sqlite3ExprCodeIN(pParse, pExpr, dest, dest); + }else{ + int destIfNull = sqlite3VdbeMakeLabel(pParse); + sqlite3ExprCodeIN(pParse, pExpr, dest, destIfNull); + sqlite3VdbeResolveLabel(v, destIfNull); + } + break; + } +#endif + default: { + default_expr: + if( ExprAlwaysFalse(pExpr) ){ + sqlite3VdbeGoto(v, dest); + }else if( ExprAlwaysTrue(pExpr) ){ + /* no-op */ + }else{ + r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1); + sqlite3VdbeAddOp3(v, OP_IfNot, r1, dest, jumpIfNull!=0); + VdbeCoverage(v); + testcase( regFree1==0 ); + testcase( jumpIfNull==0 ); + } + break; + } + } + sqlite3ReleaseTempReg(pParse, regFree1); + sqlite3ReleaseTempReg(pParse, regFree2); +} + +/* +** Like sqlite3ExprIfFalse() except that a copy is made of pExpr before +** code generation, and that copy is deleted after code generation. This +** ensures that the original pExpr is unchanged. +*/ +SQLITE_PRIVATE void sqlite3ExprIfFalseDup(Parse *pParse, Expr *pExpr, int dest,int jumpIfNull){ + sqlite3 *db = pParse->db; + Expr *pCopy = sqlite3ExprDup(db, pExpr, 0); + if( db->mallocFailed==0 ){ + sqlite3ExprIfFalse(pParse, pCopy, dest, jumpIfNull); + } + sqlite3ExprDelete(db, pCopy); +} + +/* +** Expression pVar is guaranteed to be an SQL variable. pExpr may be any +** type of expression. +** +** If pExpr is a simple SQL value - an integer, real, string, blob +** or NULL value - then the VDBE currently being prepared is configured +** to re-prepare each time a new value is bound to variable pVar. +** +** Additionally, if pExpr is a simple SQL value and the value is the +** same as that currently bound to variable pVar, non-zero is returned. +** Otherwise, if the values are not the same or if pExpr is not a simple +** SQL value, zero is returned. +*/ +static int exprCompareVariable( + const Parse *pParse, + const Expr *pVar, + const Expr *pExpr +){ + int res = 0; + int iVar; + sqlite3_value *pL, *pR = 0; + + sqlite3ValueFromExpr(pParse->db, pExpr, SQLITE_UTF8, SQLITE_AFF_BLOB, &pR); + if( pR ){ + iVar = pVar->iColumn; + sqlite3VdbeSetVarmask(pParse->pVdbe, iVar); + pL = sqlite3VdbeGetBoundValue(pParse->pReprepare, iVar, SQLITE_AFF_BLOB); + if( pL ){ + if( sqlite3_value_type(pL)==SQLITE_TEXT ){ + sqlite3_value_text(pL); /* Make sure the encoding is UTF-8 */ + } + res = 0==sqlite3MemCompare(pL, pR, 0); + } + sqlite3ValueFree(pR); + sqlite3ValueFree(pL); + } + + return res; +} + +/* +** Do a deep comparison of two expression trees. Return 0 if the two +** expressions are completely identical. Return 1 if they differ only +** by a COLLATE operator at the top level. Return 2 if there are differences +** other than the top-level COLLATE operator. +** +** If any subelement of pB has Expr.iTable==(-1) then it is allowed +** to compare equal to an equivalent element in pA with Expr.iTable==iTab. +** +** The pA side might be using TK_REGISTER. If that is the case and pB is +** not using TK_REGISTER but is otherwise equivalent, then still return 0. +** +** Sometimes this routine will return 2 even if the two expressions +** really are equivalent. If we cannot prove that the expressions are +** identical, we return 2 just to be safe. So if this routine +** returns 2, then you do not really know for certain if the two +** expressions are the same. But if you get a 0 or 1 return, then you +** can be sure the expressions are the same. In the places where +** this routine is used, it does not hurt to get an extra 2 - that +** just might result in some slightly slower code. But returning +** an incorrect 0 or 1 could lead to a malfunction. +** +** If pParse is not NULL then TK_VARIABLE terms in pA with bindings in +** pParse->pReprepare can be matched against literals in pB. The +** pParse->pVdbe->expmask bitmask is updated for each variable referenced. +** If pParse is NULL (the normal case) then any TK_VARIABLE term in +** Argument pParse should normally be NULL. If it is not NULL and pA or +** pB causes a return value of 2. +*/ +SQLITE_PRIVATE int sqlite3ExprCompare( + const Parse *pParse, + const Expr *pA, + const Expr *pB, + int iTab +){ + u32 combinedFlags; + if( pA==0 || pB==0 ){ + return pB==pA ? 0 : 2; + } + if( pParse && pA->op==TK_VARIABLE && exprCompareVariable(pParse, pA, pB) ){ + return 0; + } + combinedFlags = pA->flags | pB->flags; + if( combinedFlags & EP_IntValue ){ + if( (pA->flags&pB->flags&EP_IntValue)!=0 && pA->u.iValue==pB->u.iValue ){ + return 0; + } + return 2; + } + if( pA->op!=pB->op || pA->op==TK_RAISE ){ + if( pA->op==TK_COLLATE && sqlite3ExprCompare(pParse, pA->pLeft,pB,iTab)<2 ){ + return 1; + } + if( pB->op==TK_COLLATE && sqlite3ExprCompare(pParse, pA,pB->pLeft,iTab)<2 ){ + return 1; + } + if( pA->op==TK_AGG_COLUMN && pB->op==TK_COLUMN + && pB->iTable<0 && pA->iTable==iTab + ){ + /* fall through */ + }else{ + return 2; + } + } + assert( !ExprHasProperty(pA, EP_IntValue) ); + assert( !ExprHasProperty(pB, EP_IntValue) ); + if( pA->u.zToken ){ + if( pA->op==TK_FUNCTION || pA->op==TK_AGG_FUNCTION ){ + if( sqlite3StrICmp(pA->u.zToken,pB->u.zToken)!=0 ) return 2; +#ifndef SQLITE_OMIT_WINDOWFUNC + assert( pA->op==pB->op ); + if( ExprHasProperty(pA,EP_WinFunc)!=ExprHasProperty(pB,EP_WinFunc) ){ + return 2; + } + if( ExprHasProperty(pA,EP_WinFunc) ){ + if( sqlite3WindowCompare(pParse, pA->y.pWin, pB->y.pWin, 1)!=0 ){ + return 2; + } + } +#endif + }else if( pA->op==TK_NULL ){ + return 0; + }else if( pA->op==TK_COLLATE ){ + if( sqlite3_stricmp(pA->u.zToken,pB->u.zToken)!=0 ) return 2; + }else + if( pB->u.zToken!=0 + && pA->op!=TK_COLUMN + && pA->op!=TK_AGG_COLUMN + && strcmp(pA->u.zToken,pB->u.zToken)!=0 + ){ + return 2; + } + } + if( (pA->flags & (EP_Distinct|EP_Commuted)) + != (pB->flags & (EP_Distinct|EP_Commuted)) ) return 2; + if( ALWAYS((combinedFlags & EP_TokenOnly)==0) ){ + if( combinedFlags & EP_xIsSelect ) return 2; + if( (combinedFlags & EP_FixedCol)==0 + && sqlite3ExprCompare(pParse, pA->pLeft, pB->pLeft, iTab) ) return 2; + if( sqlite3ExprCompare(pParse, pA->pRight, pB->pRight, iTab) ) return 2; + if( sqlite3ExprListCompare(pA->x.pList, pB->x.pList, iTab) ) return 2; + if( pA->op!=TK_STRING + && pA->op!=TK_TRUEFALSE + && ALWAYS((combinedFlags & EP_Reduced)==0) + ){ + if( pA->iColumn!=pB->iColumn ) return 2; + if( pA->op2!=pB->op2 && pA->op==TK_TRUTH ) return 2; + if( pA->op!=TK_IN && pA->iTable!=pB->iTable && pA->iTable!=iTab ){ + return 2; + } + } + } + return 0; +} + +/* +** Compare two ExprList objects. Return 0 if they are identical, 1 +** if they are certainly different, or 2 if it is not possible to +** determine if they are identical or not. +** +** If any subelement of pB has Expr.iTable==(-1) then it is allowed +** to compare equal to an equivalent element in pA with Expr.iTable==iTab. +** +** This routine might return non-zero for equivalent ExprLists. The +** only consequence will be disabled optimizations. But this routine +** must never return 0 if the two ExprList objects are different, or +** a malfunction will result. +** +** Two NULL pointers are considered to be the same. But a NULL pointer +** always differs from a non-NULL pointer. +*/ +SQLITE_PRIVATE int sqlite3ExprListCompare(const ExprList *pA, const ExprList *pB, int iTab){ + int i; + if( pA==0 && pB==0 ) return 0; + if( pA==0 || pB==0 ) return 1; + if( pA->nExpr!=pB->nExpr ) return 1; + for(i=0; inExpr; i++){ + int res; + Expr *pExprA = pA->a[i].pExpr; + Expr *pExprB = pB->a[i].pExpr; + if( pA->a[i].fg.sortFlags!=pB->a[i].fg.sortFlags ) return 1; + if( (res = sqlite3ExprCompare(0, pExprA, pExprB, iTab)) ) return res; + } + return 0; +} + +/* +** Like sqlite3ExprCompare() except COLLATE operators at the top-level +** are ignored. +*/ +SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr *pA,Expr *pB, int iTab){ + return sqlite3ExprCompare(0, + sqlite3ExprSkipCollateAndLikely(pA), + sqlite3ExprSkipCollateAndLikely(pB), + iTab); +} + +/* +** Return non-zero if Expr p can only be true if pNN is not NULL. +** +** Or if seenNot is true, return non-zero if Expr p can only be +** non-NULL if pNN is not NULL +*/ +static int exprImpliesNotNull( + const Parse *pParse,/* Parsing context */ + const Expr *p, /* The expression to be checked */ + const Expr *pNN, /* The expression that is NOT NULL */ + int iTab, /* Table being evaluated */ + int seenNot /* Return true only if p can be any non-NULL value */ +){ + assert( p ); + assert( pNN ); + if( sqlite3ExprCompare(pParse, p, pNN, iTab)==0 ){ + return pNN->op!=TK_NULL; + } + switch( p->op ){ + case TK_IN: { + if( seenNot && ExprHasProperty(p, EP_xIsSelect) ) return 0; + assert( ExprUseXSelect(p) || (p->x.pList!=0 && p->x.pList->nExpr>0) ); + return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1); + } + case TK_BETWEEN: { + ExprList *pList; + assert( ExprUseXList(p) ); + pList = p->x.pList; + assert( pList!=0 ); + assert( pList->nExpr==2 ); + if( seenNot ) return 0; + if( exprImpliesNotNull(pParse, pList->a[0].pExpr, pNN, iTab, 1) + || exprImpliesNotNull(pParse, pList->a[1].pExpr, pNN, iTab, 1) + ){ + return 1; + } + return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1); + } + case TK_EQ: + case TK_NE: + case TK_LT: + case TK_LE: + case TK_GT: + case TK_GE: + case TK_PLUS: + case TK_MINUS: + case TK_BITOR: + case TK_LSHIFT: + case TK_RSHIFT: + case TK_CONCAT: + seenNot = 1; + /* no break */ deliberate_fall_through + case TK_STAR: + case TK_REM: + case TK_BITAND: + case TK_SLASH: { + if( exprImpliesNotNull(pParse, p->pRight, pNN, iTab, seenNot) ) return 1; + /* no break */ deliberate_fall_through + } + case TK_SPAN: + case TK_COLLATE: + case TK_UPLUS: + case TK_UMINUS: { + return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, seenNot); + } + case TK_TRUTH: { + if( seenNot ) return 0; + if( p->op2!=TK_IS ) return 0; + return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1); + } + case TK_BITNOT: + case TK_NOT: { + return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1); + } + } + return 0; +} + +/* +** Return true if we can prove the pE2 will always be true if pE1 is +** true. Return false if we cannot complete the proof or if pE2 might +** be false. Examples: +** +** pE1: x==5 pE2: x==5 Result: true +** pE1: x>0 pE2: x==5 Result: false +** pE1: x=21 pE2: x=21 OR y=43 Result: true +** pE1: x!=123 pE2: x IS NOT NULL Result: true +** pE1: x!=?1 pE2: x IS NOT NULL Result: true +** pE1: x IS NULL pE2: x IS NOT NULL Result: false +** pE1: x IS ?2 pE2: x IS NOT NULL Reuslt: false +** +** When comparing TK_COLUMN nodes between pE1 and pE2, if pE2 has +** Expr.iTable<0 then assume a table number given by iTab. +** +** If pParse is not NULL, then the values of bound variables in pE1 are +** compared against literal values in pE2 and pParse->pVdbe->expmask is +** modified to record which bound variables are referenced. If pParse +** is NULL, then false will be returned if pE1 contains any bound variables. +** +** When in doubt, return false. Returning true might give a performance +** improvement. Returning false might cause a performance reduction, but +** it will always give the correct answer and is hence always safe. +*/ +SQLITE_PRIVATE int sqlite3ExprImpliesExpr( + const Parse *pParse, + const Expr *pE1, + const Expr *pE2, + int iTab +){ + if( sqlite3ExprCompare(pParse, pE1, pE2, iTab)==0 ){ + return 1; + } + if( pE2->op==TK_OR + && (sqlite3ExprImpliesExpr(pParse, pE1, pE2->pLeft, iTab) + || sqlite3ExprImpliesExpr(pParse, pE1, pE2->pRight, iTab) ) + ){ + return 1; + } + if( pE2->op==TK_NOTNULL + && exprImpliesNotNull(pParse, pE1, pE2->pLeft, iTab, 0) + ){ + return 1; + } + return 0; +} + +/* +** This is the Expr node callback for sqlite3ExprImpliesNonNullRow(). +** If the expression node requires that the table at pWalker->iCur +** have one or more non-NULL column, then set pWalker->eCode to 1 and abort. +** +** This routine controls an optimization. False positives (setting +** pWalker->eCode to 1 when it should not be) are deadly, but false-negatives +** (never setting pWalker->eCode) is a harmless missed optimization. +*/ +static int impliesNotNullRow(Walker *pWalker, Expr *pExpr){ + testcase( pExpr->op==TK_AGG_COLUMN ); + testcase( pExpr->op==TK_AGG_FUNCTION ); + if( ExprHasProperty(pExpr, EP_OuterON) ) return WRC_Prune; + switch( pExpr->op ){ + case TK_ISNOT: + case TK_ISNULL: + case TK_NOTNULL: + case TK_IS: + case TK_OR: + case TK_VECTOR: + case TK_CASE: + case TK_IN: + case TK_FUNCTION: + case TK_TRUTH: + testcase( pExpr->op==TK_ISNOT ); + testcase( pExpr->op==TK_ISNULL ); + testcase( pExpr->op==TK_NOTNULL ); + testcase( pExpr->op==TK_IS ); + testcase( pExpr->op==TK_OR ); + testcase( pExpr->op==TK_VECTOR ); + testcase( pExpr->op==TK_CASE ); + testcase( pExpr->op==TK_IN ); + testcase( pExpr->op==TK_FUNCTION ); + testcase( pExpr->op==TK_TRUTH ); + return WRC_Prune; + case TK_COLUMN: + if( pWalker->u.iCur==pExpr->iTable ){ + pWalker->eCode = 1; + return WRC_Abort; + } + return WRC_Prune; + + case TK_AND: + if( pWalker->eCode==0 ){ + sqlite3WalkExpr(pWalker, pExpr->pLeft); + if( pWalker->eCode ){ + pWalker->eCode = 0; + sqlite3WalkExpr(pWalker, pExpr->pRight); + } + } + return WRC_Prune; + + case TK_BETWEEN: + if( sqlite3WalkExpr(pWalker, pExpr->pLeft)==WRC_Abort ){ + assert( pWalker->eCode ); + return WRC_Abort; + } + return WRC_Prune; + + /* Virtual tables are allowed to use constraints like x=NULL. So + ** a term of the form x=y does not prove that y is not null if x + ** is the column of a virtual table */ + case TK_EQ: + case TK_NE: + case TK_LT: + case TK_LE: + case TK_GT: + case TK_GE: { + Expr *pLeft = pExpr->pLeft; + Expr *pRight = pExpr->pRight; + testcase( pExpr->op==TK_EQ ); + testcase( pExpr->op==TK_NE ); + testcase( pExpr->op==TK_LT ); + testcase( pExpr->op==TK_LE ); + testcase( pExpr->op==TK_GT ); + testcase( pExpr->op==TK_GE ); + /* The y.pTab=0 assignment in wherecode.c always happens after the + ** impliesNotNullRow() test */ + assert( pLeft->op!=TK_COLUMN || ExprUseYTab(pLeft) ); + assert( pRight->op!=TK_COLUMN || ExprUseYTab(pRight) ); + if( (pLeft->op==TK_COLUMN + && ALWAYS(pLeft->y.pTab!=0) + && IsVirtual(pLeft->y.pTab)) + || (pRight->op==TK_COLUMN + && ALWAYS(pRight->y.pTab!=0) + && IsVirtual(pRight->y.pTab)) + ){ + return WRC_Prune; + } + /* no break */ deliberate_fall_through + } + default: + return WRC_Continue; + } +} + +/* +** Return true (non-zero) if expression p can only be true if at least +** one column of table iTab is non-null. In other words, return true +** if expression p will always be NULL or false if every column of iTab +** is NULL. +** +** False negatives are acceptable. In other words, it is ok to return +** zero even if expression p will never be true of every column of iTab +** is NULL. A false negative is merely a missed optimization opportunity. +** +** False positives are not allowed, however. A false positive may result +** in an incorrect answer. +** +** Terms of p that are marked with EP_OuterON (and hence that come from +** the ON or USING clauses of OUTER JOINS) are excluded from the analysis. +** +** This routine is used to check if a LEFT JOIN can be converted into +** an ordinary JOIN. The p argument is the WHERE clause. If the WHERE +** clause requires that some column of the right table of the LEFT JOIN +** be non-NULL, then the LEFT JOIN can be safely converted into an +** ordinary join. +*/ +SQLITE_PRIVATE int sqlite3ExprImpliesNonNullRow(Expr *p, int iTab){ + Walker w; + p = sqlite3ExprSkipCollateAndLikely(p); + if( p==0 ) return 0; + if( p->op==TK_NOTNULL ){ + p = p->pLeft; + }else{ + while( p->op==TK_AND ){ + if( sqlite3ExprImpliesNonNullRow(p->pLeft, iTab) ) return 1; + p = p->pRight; + } + } + w.xExprCallback = impliesNotNullRow; + w.xSelectCallback = 0; + w.xSelectCallback2 = 0; + w.eCode = 0; + w.u.iCur = iTab; + sqlite3WalkExpr(&w, p); + return w.eCode; +} + +/* +** An instance of the following structure is used by the tree walker +** to determine if an expression can be evaluated by reference to the +** index only, without having to do a search for the corresponding +** table entry. The IdxCover.pIdx field is the index. IdxCover.iCur +** is the cursor for the table. +*/ +struct IdxCover { + Index *pIdx; /* The index to be tested for coverage */ + int iCur; /* Cursor number for the table corresponding to the index */ +}; + +/* +** Check to see if there are references to columns in table +** pWalker->u.pIdxCover->iCur can be satisfied using the index +** pWalker->u.pIdxCover->pIdx. +*/ +static int exprIdxCover(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_COLUMN + && pExpr->iTable==pWalker->u.pIdxCover->iCur + && sqlite3TableColumnToIndex(pWalker->u.pIdxCover->pIdx, pExpr->iColumn)<0 + ){ + pWalker->eCode = 1; + return WRC_Abort; + } + return WRC_Continue; +} + +/* +** Determine if an index pIdx on table with cursor iCur contains will +** the expression pExpr. Return true if the index does cover the +** expression and false if the pExpr expression references table columns +** that are not found in the index pIdx. +** +** An index covering an expression means that the expression can be +** evaluated using only the index and without having to lookup the +** corresponding table entry. +*/ +SQLITE_PRIVATE int sqlite3ExprCoveredByIndex( + Expr *pExpr, /* The index to be tested */ + int iCur, /* The cursor number for the corresponding table */ + Index *pIdx /* The index that might be used for coverage */ +){ + Walker w; + struct IdxCover xcov; + memset(&w, 0, sizeof(w)); + xcov.iCur = iCur; + xcov.pIdx = pIdx; + w.xExprCallback = exprIdxCover; + w.u.pIdxCover = &xcov; + sqlite3WalkExpr(&w, pExpr); + return !w.eCode; +} + + +/* Structure used to pass information throught the Walker in order to +** implement sqlite3ReferencesSrcList(). +*/ +struct RefSrcList { + sqlite3 *db; /* Database connection used for sqlite3DbRealloc() */ + SrcList *pRef; /* Looking for references to these tables */ + i64 nExclude; /* Number of tables to exclude from the search */ + int *aiExclude; /* Cursor IDs for tables to exclude from the search */ +}; + +/* +** Walker SELECT callbacks for sqlite3ReferencesSrcList(). +** +** When entering a new subquery on the pExpr argument, add all FROM clause +** entries for that subquery to the exclude list. +** +** When leaving the subquery, remove those entries from the exclude list. +*/ +static int selectRefEnter(Walker *pWalker, Select *pSelect){ + struct RefSrcList *p = pWalker->u.pRefSrcList; + SrcList *pSrc = pSelect->pSrc; + i64 i, j; + int *piNew; + if( pSrc->nSrc==0 ) return WRC_Continue; + j = p->nExclude; + p->nExclude += pSrc->nSrc; + piNew = sqlite3DbRealloc(p->db, p->aiExclude, p->nExclude*sizeof(int)); + if( piNew==0 ){ + p->nExclude = 0; + return WRC_Abort; + }else{ + p->aiExclude = piNew; + } + for(i=0; inSrc; i++, j++){ + p->aiExclude[j] = pSrc->a[i].iCursor; + } + return WRC_Continue; +} +static void selectRefLeave(Walker *pWalker, Select *pSelect){ + struct RefSrcList *p = pWalker->u.pRefSrcList; + SrcList *pSrc = pSelect->pSrc; + if( p->nExclude ){ + assert( p->nExclude>=pSrc->nSrc ); + p->nExclude -= pSrc->nSrc; + } +} + +/* This is the Walker EXPR callback for sqlite3ReferencesSrcList(). +** +** Set the 0x01 bit of pWalker->eCode if there is a reference to any +** of the tables shown in RefSrcList.pRef. +** +** Set the 0x02 bit of pWalker->eCode if there is a reference to a +** table is in neither RefSrcList.pRef nor RefSrcList.aiExclude. +*/ +static int exprRefToSrcList(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_COLUMN + || pExpr->op==TK_AGG_COLUMN + ){ + int i; + struct RefSrcList *p = pWalker->u.pRefSrcList; + SrcList *pSrc = p->pRef; + int nSrc = pSrc ? pSrc->nSrc : 0; + for(i=0; iiTable==pSrc->a[i].iCursor ){ + pWalker->eCode |= 1; + return WRC_Continue; + } + } + for(i=0; inExclude && p->aiExclude[i]!=pExpr->iTable; i++){} + if( i>=p->nExclude ){ + pWalker->eCode |= 2; + } + } + return WRC_Continue; +} + +/* +** Check to see if pExpr references any tables in pSrcList. +** Possible return values: +** +** 1 pExpr does references a table in pSrcList. +** +** 0 pExpr references some table that is not defined in either +** pSrcList or in subqueries of pExpr itself. +** +** -1 pExpr only references no tables at all, or it only +** references tables defined in subqueries of pExpr itself. +** +** As currently used, pExpr is always an aggregate function call. That +** fact is exploited for efficiency. +*/ +SQLITE_PRIVATE int sqlite3ReferencesSrcList(Parse *pParse, Expr *pExpr, SrcList *pSrcList){ + Walker w; + struct RefSrcList x; + assert( pParse->db!=0 ); + memset(&w, 0, sizeof(w)); + memset(&x, 0, sizeof(x)); + w.xExprCallback = exprRefToSrcList; + w.xSelectCallback = selectRefEnter; + w.xSelectCallback2 = selectRefLeave; + w.u.pRefSrcList = &x; + x.db = pParse->db; + x.pRef = pSrcList; + assert( pExpr->op==TK_AGG_FUNCTION ); + assert( ExprUseXList(pExpr) ); + sqlite3WalkExprList(&w, pExpr->x.pList); +#ifndef SQLITE_OMIT_WINDOWFUNC + if( ExprHasProperty(pExpr, EP_WinFunc) ){ + sqlite3WalkExpr(&w, pExpr->y.pWin->pFilter); + } +#endif + if( x.aiExclude ) sqlite3DbNNFreeNN(pParse->db, x.aiExclude); + if( w.eCode & 0x01 ){ + return 1; + }else if( w.eCode ){ + return 0; + }else{ + return -1; + } +} + +/* +** This is a Walker expression node callback. +** +** For Expr nodes that contain pAggInfo pointers, make sure the AggInfo +** object that is referenced does not refer directly to the Expr. If +** it does, make a copy. This is done because the pExpr argument is +** subject to change. +** +** The copy is scheduled for deletion using the sqlite3ExprDeferredDelete() +** which builds on the sqlite3ParserAddCleanup() mechanism. +*/ +static int agginfoPersistExprCb(Walker *pWalker, Expr *pExpr){ + if( ALWAYS(!ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced)) + && pExpr->pAggInfo!=0 + ){ + AggInfo *pAggInfo = pExpr->pAggInfo; + int iAgg = pExpr->iAgg; + Parse *pParse = pWalker->pParse; + sqlite3 *db = pParse->db; + assert( iAgg>=0 ); + if( pExpr->op!=TK_AGG_FUNCTION ){ + if( iAggnColumn + && pAggInfo->aCol[iAgg].pCExpr==pExpr + ){ + pExpr = sqlite3ExprDup(db, pExpr, 0); + if( pExpr ){ + pAggInfo->aCol[iAgg].pCExpr = pExpr; + sqlite3ExprDeferredDelete(pParse, pExpr); + } + } + }else{ + assert( pExpr->op==TK_AGG_FUNCTION ); + if( ALWAYS(iAggnFunc) + && pAggInfo->aFunc[iAgg].pFExpr==pExpr + ){ + pExpr = sqlite3ExprDup(db, pExpr, 0); + if( pExpr ){ + pAggInfo->aFunc[iAgg].pFExpr = pExpr; + sqlite3ExprDeferredDelete(pParse, pExpr); + } + } + } + } + return WRC_Continue; +} + +/* +** Initialize a Walker object so that will persist AggInfo entries referenced +** by the tree that is walked. +*/ +SQLITE_PRIVATE void sqlite3AggInfoPersistWalkerInit(Walker *pWalker, Parse *pParse){ + memset(pWalker, 0, sizeof(*pWalker)); + pWalker->pParse = pParse; + pWalker->xExprCallback = agginfoPersistExprCb; + pWalker->xSelectCallback = sqlite3SelectWalkNoop; +} + +/* +** Add a new element to the pAggInfo->aCol[] array. Return the index of +** the new element. Return a negative number if malloc fails. +*/ +static int addAggInfoColumn(sqlite3 *db, AggInfo *pInfo){ + int i; + pInfo->aCol = sqlite3ArrayAllocate( + db, + pInfo->aCol, + sizeof(pInfo->aCol[0]), + &pInfo->nColumn, + &i + ); + return i; +} + +/* +** Add a new element to the pAggInfo->aFunc[] array. Return the index of +** the new element. Return a negative number if malloc fails. +*/ +static int addAggInfoFunc(sqlite3 *db, AggInfo *pInfo){ + int i; + pInfo->aFunc = sqlite3ArrayAllocate( + db, + pInfo->aFunc, + sizeof(pInfo->aFunc[0]), + &pInfo->nFunc, + &i + ); + return i; +} + +/* +** Search the AggInfo object for an aCol[] entry that has iTable and iColumn. +** Return the index in aCol[] of the entry that describes that column. +** +** If no prior entry is found, create a new one and return -1. The +** new column will have an idex of pAggInfo->nColumn-1. +*/ +static void findOrCreateAggInfoColumn( + Parse *pParse, /* Parsing context */ + AggInfo *pAggInfo, /* The AggInfo object to search and/or modify */ + Expr *pExpr /* Expr describing the column to find or insert */ +){ + struct AggInfo_col *pCol; + int k; + + assert( pAggInfo->iFirstReg==0 ); + pCol = pAggInfo->aCol; + for(k=0; knColumn; k++, pCol++){ + if( pCol->iTable==pExpr->iTable + && pCol->iColumn==pExpr->iColumn + && pExpr->op!=TK_IF_NULL_ROW + ){ + goto fix_up_expr; + } + } + k = addAggInfoColumn(pParse->db, pAggInfo); + if( k<0 ){ + /* OOM on resize */ + assert( pParse->db->mallocFailed ); + return; + } + pCol = &pAggInfo->aCol[k]; + assert( ExprUseYTab(pExpr) ); + pCol->pTab = pExpr->y.pTab; + pCol->iTable = pExpr->iTable; + pCol->iColumn = pExpr->iColumn; + pCol->iSorterColumn = -1; + pCol->pCExpr = pExpr; + if( pAggInfo->pGroupBy && pExpr->op!=TK_IF_NULL_ROW ){ + int j, n; + ExprList *pGB = pAggInfo->pGroupBy; + struct ExprList_item *pTerm = pGB->a; + n = pGB->nExpr; + for(j=0; jpExpr; + if( pE->op==TK_COLUMN + && pE->iTable==pExpr->iTable + && pE->iColumn==pExpr->iColumn + ){ + pCol->iSorterColumn = j; + break; + } + } + } + if( pCol->iSorterColumn<0 ){ + pCol->iSorterColumn = pAggInfo->nSortingColumn++; + } +fix_up_expr: + ExprSetVVAProperty(pExpr, EP_NoReduce); + assert( pExpr->pAggInfo==0 || pExpr->pAggInfo==pAggInfo ); + pExpr->pAggInfo = pAggInfo; + if( pExpr->op==TK_COLUMN ){ + pExpr->op = TK_AGG_COLUMN; + } + pExpr->iAgg = (i16)k; +} + +/* +** This is the xExprCallback for a tree walker. It is used to +** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates +** for additional information. +*/ +static int analyzeAggregate(Walker *pWalker, Expr *pExpr){ + int i; + NameContext *pNC = pWalker->u.pNC; + Parse *pParse = pNC->pParse; + SrcList *pSrcList = pNC->pSrcList; + AggInfo *pAggInfo = pNC->uNC.pAggInfo; + + assert( pNC->ncFlags & NC_UAggInfo ); + assert( pAggInfo->iFirstReg==0 ); + switch( pExpr->op ){ + default: { + IndexedExpr *pIEpr; + Expr tmp; + assert( pParse->iSelfTab==0 ); + if( (pNC->ncFlags & NC_InAggFunc)==0 ) break; + if( pParse->pIdxEpr==0 ) break; + for(pIEpr=pParse->pIdxEpr; pIEpr; pIEpr=pIEpr->pIENext){ + int iDataCur = pIEpr->iDataCur; + if( iDataCur<0 ) continue; + if( sqlite3ExprCompare(0, pExpr, pIEpr->pExpr, iDataCur)==0 ) break; + } + if( pIEpr==0 ) break; + if( NEVER(!ExprUseYTab(pExpr)) ) break; + for(i=0; inSrc; i++){ + if( pSrcList->a[0].iCursor==pIEpr->iDataCur ) break; + } + if( i>=pSrcList->nSrc ) break; + if( NEVER(pExpr->pAggInfo!=0) ) break; /* Resolved by outer context */ + if( pParse->nErr ){ return WRC_Abort; } + + /* If we reach this point, it means that expression pExpr can be + ** translated into a reference to an index column as described by + ** pIEpr. + */ + memset(&tmp, 0, sizeof(tmp)); + tmp.op = TK_AGG_COLUMN; + tmp.iTable = pIEpr->iIdxCur; + tmp.iColumn = pIEpr->iIdxCol; + findOrCreateAggInfoColumn(pParse, pAggInfo, &tmp); + if( pParse->nErr ){ return WRC_Abort; } + assert( pAggInfo->aCol!=0 ); + assert( tmp.iAggnColumn ); + pAggInfo->aCol[tmp.iAgg].pCExpr = pExpr; + pExpr->pAggInfo = pAggInfo; + pExpr->iAgg = tmp.iAgg; + return WRC_Prune; + } + case TK_IF_NULL_ROW: + case TK_AGG_COLUMN: + case TK_COLUMN: { + testcase( pExpr->op==TK_AGG_COLUMN ); + testcase( pExpr->op==TK_COLUMN ); + testcase( pExpr->op==TK_IF_NULL_ROW ); + /* Check to see if the column is in one of the tables in the FROM + ** clause of the aggregate query */ + if( ALWAYS(pSrcList!=0) ){ + SrcItem *pItem = pSrcList->a; + for(i=0; inSrc; i++, pItem++){ + assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) ); + if( pExpr->iTable==pItem->iCursor ){ + findOrCreateAggInfoColumn(pParse, pAggInfo, pExpr); + break; + } /* endif pExpr->iTable==pItem->iCursor */ + } /* end loop over pSrcList */ + } + return WRC_Continue; + } + case TK_AGG_FUNCTION: { + if( (pNC->ncFlags & NC_InAggFunc)==0 + && pWalker->walkerDepth==pExpr->op2 + ){ + /* Check to see if pExpr is a duplicate of another aggregate + ** function that is already in the pAggInfo structure + */ + struct AggInfo_func *pItem = pAggInfo->aFunc; + for(i=0; inFunc; i++, pItem++){ + if( pItem->pFExpr==pExpr ) break; + if( sqlite3ExprCompare(0, pItem->pFExpr, pExpr, -1)==0 ){ + break; + } + } + if( i>=pAggInfo->nFunc ){ + /* pExpr is original. Make a new entry in pAggInfo->aFunc[] + */ + u8 enc = ENC(pParse->db); + i = addAggInfoFunc(pParse->db, pAggInfo); + if( i>=0 ){ + assert( !ExprHasProperty(pExpr, EP_xIsSelect) ); + pItem = &pAggInfo->aFunc[i]; + pItem->pFExpr = pExpr; + assert( ExprUseUToken(pExpr) ); + pItem->pFunc = sqlite3FindFunction(pParse->db, + pExpr->u.zToken, + pExpr->x.pList ? pExpr->x.pList->nExpr : 0, enc, 0); + if( pExpr->flags & EP_Distinct ){ + pItem->iDistinct = pParse->nTab++; + }else{ + pItem->iDistinct = -1; + } + } + } + /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry + */ + assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) ); + ExprSetVVAProperty(pExpr, EP_NoReduce); + pExpr->iAgg = (i16)i; + pExpr->pAggInfo = pAggInfo; + return WRC_Prune; + }else{ + return WRC_Continue; + } + } + } + return WRC_Continue; +} + +/* +** Analyze the pExpr expression looking for aggregate functions and +** for variables that need to be added to AggInfo object that pNC->pAggInfo +** points to. Additional entries are made on the AggInfo object as +** necessary. +** +** This routine should only be called after the expression has been +** analyzed by sqlite3ResolveExprNames(). +*/ +SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){ + Walker w; + w.xExprCallback = analyzeAggregate; + w.xSelectCallback = sqlite3WalkerDepthIncrease; + w.xSelectCallback2 = sqlite3WalkerDepthDecrease; + w.walkerDepth = 0; + w.u.pNC = pNC; + w.pParse = 0; + assert( pNC->pSrcList!=0 ); + sqlite3WalkExpr(&w, pExpr); +} + +/* +** Call sqlite3ExprAnalyzeAggregates() for every expression in an +** expression list. Return the number of errors. +** +** If an error is found, the analysis is cut short. +*/ +SQLITE_PRIVATE void sqlite3ExprAnalyzeAggList(NameContext *pNC, ExprList *pList){ + struct ExprList_item *pItem; + int i; + if( pList ){ + for(pItem=pList->a, i=0; inExpr; i++, pItem++){ + sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr); + } + } +} + +/* +** Allocate a single new register for use to hold some intermediate result. +*/ +SQLITE_PRIVATE int sqlite3GetTempReg(Parse *pParse){ + if( pParse->nTempReg==0 ){ + return ++pParse->nMem; + } + return pParse->aTempReg[--pParse->nTempReg]; +} + +/* +** Deallocate a register, making available for reuse for some other +** purpose. +*/ +SQLITE_PRIVATE void sqlite3ReleaseTempReg(Parse *pParse, int iReg){ + if( iReg ){ + sqlite3VdbeReleaseRegisters(pParse, iReg, 1, 0, 0); + if( pParse->nTempRegaTempReg) ){ + pParse->aTempReg[pParse->nTempReg++] = iReg; + } + } +} + +/* +** Allocate or deallocate a block of nReg consecutive registers. +*/ +SQLITE_PRIVATE int sqlite3GetTempRange(Parse *pParse, int nReg){ + int i, n; + if( nReg==1 ) return sqlite3GetTempReg(pParse); + i = pParse->iRangeReg; + n = pParse->nRangeReg; + if( nReg<=n ){ + pParse->iRangeReg += nReg; + pParse->nRangeReg -= nReg; + }else{ + i = pParse->nMem+1; + pParse->nMem += nReg; + } + return i; +} +SQLITE_PRIVATE void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg){ + if( nReg==1 ){ + sqlite3ReleaseTempReg(pParse, iReg); + return; + } + sqlite3VdbeReleaseRegisters(pParse, iReg, nReg, 0, 0); + if( nReg>pParse->nRangeReg ){ + pParse->nRangeReg = nReg; + pParse->iRangeReg = iReg; + } +} + +/* +** Mark all temporary registers as being unavailable for reuse. +** +** Always invoke this procedure after coding a subroutine or co-routine +** that might be invoked from other parts of the code, to ensure that +** the sub/co-routine does not use registers in common with the code that +** invokes the sub/co-routine. +*/ +SQLITE_PRIVATE void sqlite3ClearTempRegCache(Parse *pParse){ + pParse->nTempReg = 0; + pParse->nRangeReg = 0; +} + +/* +** Make sure sufficient registers have been allocated so that +** iReg is a valid register number. +*/ +SQLITE_PRIVATE void sqlite3TouchRegister(Parse *pParse, int iReg){ + if( pParse->nMemnMem = iReg; +} + +#if defined(SQLITE_ENABLE_STAT4) || defined(SQLITE_DEBUG) +/* +** Return the latest reusable register in the set of all registers. +** The value returned is no less than iMin. If any register iMin or +** greater is in permanent use, then return one more than that last +** permanent register. +*/ +SQLITE_PRIVATE int sqlite3FirstAvailableRegister(Parse *pParse, int iMin){ + const ExprList *pList = pParse->pConstExpr; + if( pList ){ + int i; + for(i=0; inExpr; i++){ + if( pList->a[i].u.iConstExprReg>=iMin ){ + iMin = pList->a[i].u.iConstExprReg + 1; + } + } + } + pParse->nTempReg = 0; + pParse->nRangeReg = 0; + return iMin; +} +#endif /* SQLITE_ENABLE_STAT4 || SQLITE_DEBUG */ + +/* +** Validate that no temporary register falls within the range of +** iFirst..iLast, inclusive. This routine is only call from within assert() +** statements. +*/ +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3NoTempsInRange(Parse *pParse, int iFirst, int iLast){ + int i; + if( pParse->nRangeReg>0 + && pParse->iRangeReg+pParse->nRangeReg > iFirst + && pParse->iRangeReg <= iLast + ){ + return 0; + } + for(i=0; inTempReg; i++){ + if( pParse->aTempReg[i]>=iFirst && pParse->aTempReg[i]<=iLast ){ + return 0; + } + } + if( pParse->pConstExpr ){ + ExprList *pList = pParse->pConstExpr; + for(i=0; inExpr; i++){ + int iReg = pList->a[i].u.iConstExprReg; + if( iReg==0 ) continue; + if( iReg>=iFirst && iReg<=iLast ) return 0; + } + } + return 1; +} +#endif /* SQLITE_DEBUG */ + +/************** End of expr.c ************************************************/ +/************** Begin file alter.c *******************************************/ +/* +** 2005 February 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that used to generate VDBE code +** that implements the ALTER TABLE command. +*/ +/* #include "sqliteInt.h" */ + +/* +** The code in this file only exists if we are not omitting the +** ALTER TABLE logic from the build. +*/ +#ifndef SQLITE_OMIT_ALTERTABLE + +/* +** Parameter zName is the name of a table that is about to be altered +** (either with ALTER TABLE ... RENAME TO or ALTER TABLE ... ADD COLUMN). +** If the table is a system table, this function leaves an error message +** in pParse->zErr (system tables may not be altered) and returns non-zero. +** +** Or, if zName is not a system table, zero is returned. +*/ +static int isAlterableTable(Parse *pParse, Table *pTab){ + if( 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7) +#ifndef SQLITE_OMIT_VIRTUALTABLE + || (pTab->tabFlags & TF_Eponymous)!=0 + || ( (pTab->tabFlags & TF_Shadow)!=0 + && sqlite3ReadOnlyShadowTables(pParse->db) + ) +#endif + ){ + sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName); + return 1; + } + return 0; +} + +/* +** Generate code to verify that the schemas of database zDb and, if +** bTemp is not true, database "temp", can still be parsed. This is +** called at the end of the generation of an ALTER TABLE ... RENAME ... +** statement to ensure that the operation has not rendered any schema +** objects unusable. +*/ +static void renameTestSchema( + Parse *pParse, /* Parse context */ + const char *zDb, /* Name of db to verify schema of */ + int bTemp, /* True if this is the temp db */ + const char *zWhen, /* "when" part of error message */ + int bNoDQS /* Do not allow DQS in the schema */ +){ + pParse->colNamesSet = 1; + sqlite3NestedParse(pParse, + "SELECT 1 " + "FROM \"%w\"." LEGACY_SCHEMA_TABLE " " + "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'" + " AND sql NOT LIKE 'create virtual%%'" + " AND sqlite_rename_test(%Q, sql, type, name, %d, %Q, %d)=NULL ", + zDb, + zDb, bTemp, zWhen, bNoDQS + ); + + if( bTemp==0 ){ + sqlite3NestedParse(pParse, + "SELECT 1 " + "FROM temp." LEGACY_SCHEMA_TABLE " " + "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'" + " AND sql NOT LIKE 'create virtual%%'" + " AND sqlite_rename_test(%Q, sql, type, name, 1, %Q, %d)=NULL ", + zDb, zWhen, bNoDQS + ); + } +} + +/* +** Generate VM code to replace any double-quoted strings (but not double-quoted +** identifiers) within the "sql" column of the sqlite_schema table in +** database zDb with their single-quoted equivalents. If argument bTemp is +** not true, similarly update all SQL statements in the sqlite_schema table +** of the temp db. +*/ +static void renameFixQuotes(Parse *pParse, const char *zDb, int bTemp){ + sqlite3NestedParse(pParse, + "UPDATE \"%w\"." LEGACY_SCHEMA_TABLE + " SET sql = sqlite_rename_quotefix(%Q, sql)" + "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'" + " AND sql NOT LIKE 'create virtual%%'" , zDb, zDb + ); + if( bTemp==0 ){ + sqlite3NestedParse(pParse, + "UPDATE temp." LEGACY_SCHEMA_TABLE + " SET sql = sqlite_rename_quotefix('temp', sql)" + "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'" + " AND sql NOT LIKE 'create virtual%%'" + ); + } +} + +/* +** Generate code to reload the schema for database iDb. And, if iDb!=1, for +** the temp database as well. +*/ +static void renameReloadSchema(Parse *pParse, int iDb, u16 p5){ + Vdbe *v = pParse->pVdbe; + if( v ){ + sqlite3ChangeCookie(pParse, iDb); + sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, iDb, 0, p5); + if( iDb!=1 ) sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, 1, 0, p5); + } +} + +/* +** Generate code to implement the "ALTER TABLE xxx RENAME TO yyy" +** command. +*/ +SQLITE_PRIVATE void sqlite3AlterRenameTable( + Parse *pParse, /* Parser context. */ + SrcList *pSrc, /* The table to rename. */ + Token *pName /* The new table name. */ +){ + int iDb; /* Database that contains the table */ + char *zDb; /* Name of database iDb */ + Table *pTab; /* Table being renamed */ + char *zName = 0; /* NULL-terminated version of pName */ + sqlite3 *db = pParse->db; /* Database connection */ + int nTabName; /* Number of UTF-8 characters in zTabName */ + const char *zTabName; /* Original name of the table */ + Vdbe *v; + VTable *pVTab = 0; /* Non-zero if this is a v-tab with an xRename() */ + + if( NEVER(db->mallocFailed) ) goto exit_rename_table; + assert( pSrc->nSrc==1 ); + assert( sqlite3BtreeHoldsAllMutexes(pParse->db) ); + + pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]); + if( !pTab ) goto exit_rename_table; + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + zDb = db->aDb[iDb].zDbSName; + + /* Get a NULL terminated version of the new table name. */ + zName = sqlite3NameFromToken(db, pName); + if( !zName ) goto exit_rename_table; + + /* Check that a table or index named 'zName' does not already exist + ** in database iDb. If so, this is an error. + */ + if( sqlite3FindTable(db, zName, zDb) + || sqlite3FindIndex(db, zName, zDb) + || sqlite3IsShadowTableOf(db, pTab, zName) + ){ + sqlite3ErrorMsg(pParse, + "there is already another table or index with this name: %s", zName); + goto exit_rename_table; + } + + /* Make sure it is not a system table being altered, or a reserved name + ** that the table is being renamed to. + */ + if( SQLITE_OK!=isAlterableTable(pParse, pTab) ){ + goto exit_rename_table; + } + if( SQLITE_OK!=sqlite3CheckObjectName(pParse,zName,"table",zName) ){ + goto exit_rename_table; + } + +#ifndef SQLITE_OMIT_VIEW + if( IsView(pTab) ){ + sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName); + goto exit_rename_table; + } +#endif + +#ifndef SQLITE_OMIT_AUTHORIZATION + /* Invoke the authorization callback. */ + if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){ + goto exit_rename_table; + } +#endif + +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( sqlite3ViewGetColumnNames(pParse, pTab) ){ + goto exit_rename_table; + } + if( IsVirtual(pTab) ){ + pVTab = sqlite3GetVTable(db, pTab); + if( pVTab->pVtab->pModule->xRename==0 ){ + pVTab = 0; + } + } +#endif + + /* Begin a transaction for database iDb. Then modify the schema cookie + ** (since the ALTER TABLE modifies the schema). Call sqlite3MayAbort(), + ** as the scalar functions (e.g. sqlite_rename_table()) invoked by the + ** nested SQL may raise an exception. */ + v = sqlite3GetVdbe(pParse); + if( v==0 ){ + goto exit_rename_table; + } + sqlite3MayAbort(pParse); + + /* figure out how many UTF-8 characters are in zName */ + zTabName = pTab->zName; + nTabName = sqlite3Utf8CharLen(zTabName, -1); + + /* Rewrite all CREATE TABLE, INDEX, TRIGGER or VIEW statements in + ** the schema to use the new table name. */ + sqlite3NestedParse(pParse, + "UPDATE \"%w\"." LEGACY_SCHEMA_TABLE " SET " + "sql = sqlite_rename_table(%Q, type, name, sql, %Q, %Q, %d) " + "WHERE (type!='index' OR tbl_name=%Q COLLATE nocase)" + "AND name NOT LIKE 'sqliteX_%%' ESCAPE 'X'" + , zDb, zDb, zTabName, zName, (iDb==1), zTabName + ); + + /* Update the tbl_name and name columns of the sqlite_schema table + ** as required. */ + sqlite3NestedParse(pParse, + "UPDATE %Q." LEGACY_SCHEMA_TABLE " SET " + "tbl_name = %Q, " + "name = CASE " + "WHEN type='table' THEN %Q " + "WHEN name LIKE 'sqliteX_autoindex%%' ESCAPE 'X' " + " AND type='index' THEN " + "'sqlite_autoindex_' || %Q || substr(name,%d+18) " + "ELSE name END " + "WHERE tbl_name=%Q COLLATE nocase AND " + "(type='table' OR type='index' OR type='trigger');", + zDb, + zName, zName, zName, + nTabName, zTabName + ); + +#ifndef SQLITE_OMIT_AUTOINCREMENT + /* If the sqlite_sequence table exists in this database, then update + ** it with the new table name. + */ + if( sqlite3FindTable(db, "sqlite_sequence", zDb) ){ + sqlite3NestedParse(pParse, + "UPDATE \"%w\".sqlite_sequence set name = %Q WHERE name = %Q", + zDb, zName, pTab->zName); + } +#endif + + /* If the table being renamed is not itself part of the temp database, + ** edit view and trigger definitions within the temp database + ** as required. */ + if( iDb!=1 ){ + sqlite3NestedParse(pParse, + "UPDATE sqlite_temp_schema SET " + "sql = sqlite_rename_table(%Q, type, name, sql, %Q, %Q, 1), " + "tbl_name = " + "CASE WHEN tbl_name=%Q COLLATE nocase AND " + " sqlite_rename_test(%Q, sql, type, name, 1, 'after rename', 0) " + "THEN %Q ELSE tbl_name END " + "WHERE type IN ('view', 'trigger')" + , zDb, zTabName, zName, zTabName, zDb, zName); + } + + /* If this is a virtual table, invoke the xRename() function if + ** one is defined. The xRename() callback will modify the names + ** of any resources used by the v-table implementation (including other + ** SQLite tables) that are identified by the name of the virtual table. + */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( pVTab ){ + int i = ++pParse->nMem; + sqlite3VdbeLoadString(v, i, zName); + sqlite3VdbeAddOp4(v, OP_VRename, i, 0, 0,(const char*)pVTab, P4_VTAB); + } +#endif + + renameReloadSchema(pParse, iDb, INITFLAG_AlterRename); + renameTestSchema(pParse, zDb, iDb==1, "after rename", 0); + +exit_rename_table: + sqlite3SrcListDelete(db, pSrc); + sqlite3DbFree(db, zName); +} + +/* +** Write code that will raise an error if the table described by +** zDb and zTab is not empty. +*/ +static void sqlite3ErrorIfNotEmpty( + Parse *pParse, /* Parsing context */ + const char *zDb, /* Schema holding the table */ + const char *zTab, /* Table to check for empty */ + const char *zErr /* Error message text */ +){ + sqlite3NestedParse(pParse, + "SELECT raise(ABORT,%Q) FROM \"%w\".\"%w\"", + zErr, zDb, zTab + ); +} + +/* +** This function is called after an "ALTER TABLE ... ADD" statement +** has been parsed. Argument pColDef contains the text of the new +** column definition. +** +** The Table structure pParse->pNewTable was extended to include +** the new column during parsing. +*/ +SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){ + Table *pNew; /* Copy of pParse->pNewTable */ + Table *pTab; /* Table being altered */ + int iDb; /* Database number */ + const char *zDb; /* Database name */ + const char *zTab; /* Table name */ + char *zCol; /* Null-terminated column definition */ + Column *pCol; /* The new column */ + Expr *pDflt; /* Default value for the new column */ + sqlite3 *db; /* The database connection; */ + Vdbe *v; /* The prepared statement under construction */ + int r1; /* Temporary registers */ + + db = pParse->db; + assert( db->pParse==pParse ); + if( pParse->nErr ) return; + assert( db->mallocFailed==0 ); + pNew = pParse->pNewTable; + assert( pNew ); + + assert( sqlite3BtreeHoldsAllMutexes(db) ); + iDb = sqlite3SchemaToIndex(db, pNew->pSchema); + zDb = db->aDb[iDb].zDbSName; + zTab = &pNew->zName[16]; /* Skip the "sqlite_altertab_" prefix on the name */ + pCol = &pNew->aCol[pNew->nCol-1]; + pDflt = sqlite3ColumnExpr(pNew, pCol); + pTab = sqlite3FindTable(db, zTab, zDb); + assert( pTab ); + +#ifndef SQLITE_OMIT_AUTHORIZATION + /* Invoke the authorization callback. */ + if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){ + return; + } +#endif + + + /* Check that the new column is not specified as PRIMARY KEY or UNIQUE. + ** If there is a NOT NULL constraint, then the default value for the + ** column must not be NULL. + */ + if( pCol->colFlags & COLFLAG_PRIMKEY ){ + sqlite3ErrorMsg(pParse, "Cannot add a PRIMARY KEY column"); + return; + } + if( pNew->pIndex ){ + sqlite3ErrorMsg(pParse, + "Cannot add a UNIQUE column"); + return; + } + if( (pCol->colFlags & COLFLAG_GENERATED)==0 ){ + /* If the default value for the new column was specified with a + ** literal NULL, then set pDflt to 0. This simplifies checking + ** for an SQL NULL default below. + */ + assert( pDflt==0 || pDflt->op==TK_SPAN ); + if( pDflt && pDflt->pLeft->op==TK_NULL ){ + pDflt = 0; + } + assert( IsOrdinaryTable(pNew) ); + if( (db->flags&SQLITE_ForeignKeys) && pNew->u.tab.pFKey && pDflt ){ + sqlite3ErrorIfNotEmpty(pParse, zDb, zTab, + "Cannot add a REFERENCES column with non-NULL default value"); + } + if( pCol->notNull && !pDflt ){ + sqlite3ErrorIfNotEmpty(pParse, zDb, zTab, + "Cannot add a NOT NULL column with default value NULL"); + } + + + /* Ensure the default expression is something that sqlite3ValueFromExpr() + ** can handle (i.e. not CURRENT_TIME etc.) + */ + if( pDflt ){ + sqlite3_value *pVal = 0; + int rc; + rc = sqlite3ValueFromExpr(db, pDflt, SQLITE_UTF8, SQLITE_AFF_BLOB, &pVal); + assert( rc==SQLITE_OK || rc==SQLITE_NOMEM ); + if( rc!=SQLITE_OK ){ + assert( db->mallocFailed == 1 ); + return; + } + if( !pVal ){ + sqlite3ErrorIfNotEmpty(pParse, zDb, zTab, + "Cannot add a column with non-constant default"); + } + sqlite3ValueFree(pVal); + } + }else if( pCol->colFlags & COLFLAG_STORED ){ + sqlite3ErrorIfNotEmpty(pParse, zDb, zTab, "cannot add a STORED column"); + } + + + /* Modify the CREATE TABLE statement. */ + zCol = sqlite3DbStrNDup(db, (char*)pColDef->z, pColDef->n); + if( zCol ){ + char *zEnd = &zCol[pColDef->n-1]; + while( zEnd>zCol && (*zEnd==';' || sqlite3Isspace(*zEnd)) ){ + *zEnd-- = '\0'; + } + /* substr() operations on characters, but addColOffset is in bytes. So we + ** have to use printf() to translate between these units: */ + assert( IsOrdinaryTable(pTab) ); + assert( IsOrdinaryTable(pNew) ); + sqlite3NestedParse(pParse, + "UPDATE \"%w\"." LEGACY_SCHEMA_TABLE " SET " + "sql = printf('%%.%ds, ',sql) || %Q" + " || substr(sql,1+length(printf('%%.%ds',sql))) " + "WHERE type = 'table' AND name = %Q", + zDb, pNew->u.tab.addColOffset, zCol, pNew->u.tab.addColOffset, + zTab + ); + sqlite3DbFree(db, zCol); + } + + v = sqlite3GetVdbe(pParse); + if( v ){ + /* Make sure the schema version is at least 3. But do not upgrade + ** from less than 3 to 4, as that will corrupt any preexisting DESC + ** index. + */ + r1 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, BTREE_FILE_FORMAT); + sqlite3VdbeUsesBtree(v, iDb); + sqlite3VdbeAddOp2(v, OP_AddImm, r1, -2); + sqlite3VdbeAddOp2(v, OP_IfPos, r1, sqlite3VdbeCurrentAddr(v)+2); + VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, 3); + sqlite3ReleaseTempReg(pParse, r1); + + /* Reload the table definition */ + renameReloadSchema(pParse, iDb, INITFLAG_AlterAdd); + + /* Verify that constraints are still satisfied */ + if( pNew->pCheck!=0 + || (pCol->notNull && (pCol->colFlags & COLFLAG_GENERATED)!=0) + ){ + sqlite3NestedParse(pParse, + "SELECT CASE WHEN quick_check GLOB 'CHECK*'" + " THEN raise(ABORT,'CHECK constraint failed')" + " ELSE raise(ABORT,'NOT NULL constraint failed')" + " END" + " FROM pragma_quick_check(%Q,%Q)" + " WHERE quick_check GLOB 'CHECK*' OR quick_check GLOB 'NULL*'", + zTab, zDb + ); + } + } +} + +/* +** This function is called by the parser after the table-name in +** an "ALTER TABLE ADD" statement is parsed. Argument +** pSrc is the full-name of the table being altered. +** +** This routine makes a (partial) copy of the Table structure +** for the table being altered and sets Parse.pNewTable to point +** to it. Routines called by the parser as the column definition +** is parsed (i.e. sqlite3AddColumn()) add the new Column data to +** the copy. The copy of the Table structure is deleted by tokenize.c +** after parsing is finished. +** +** Routine sqlite3AlterFinishAddColumn() will be called to complete +** coding the "ALTER TABLE ... ADD" statement. +*/ +SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){ + Table *pNew; + Table *pTab; + int iDb; + int i; + int nAlloc; + sqlite3 *db = pParse->db; + + /* Look up the table being altered. */ + assert( pParse->pNewTable==0 ); + assert( sqlite3BtreeHoldsAllMutexes(db) ); + if( db->mallocFailed ) goto exit_begin_add_column; + pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]); + if( !pTab ) goto exit_begin_add_column; + +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTab) ){ + sqlite3ErrorMsg(pParse, "virtual tables may not be altered"); + goto exit_begin_add_column; + } +#endif + + /* Make sure this is not an attempt to ALTER a view. */ + if( IsView(pTab) ){ + sqlite3ErrorMsg(pParse, "Cannot add a column to a view"); + goto exit_begin_add_column; + } + if( SQLITE_OK!=isAlterableTable(pParse, pTab) ){ + goto exit_begin_add_column; + } + + sqlite3MayAbort(pParse); + assert( IsOrdinaryTable(pTab) ); + assert( pTab->u.tab.addColOffset>0 ); + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + + /* Put a copy of the Table struct in Parse.pNewTable for the + ** sqlite3AddColumn() function and friends to modify. But modify + ** the name by adding an "sqlite_altertab_" prefix. By adding this + ** prefix, we insure that the name will not collide with an existing + ** table because user table are not allowed to have the "sqlite_" + ** prefix on their name. + */ + pNew = (Table*)sqlite3DbMallocZero(db, sizeof(Table)); + if( !pNew ) goto exit_begin_add_column; + pParse->pNewTable = pNew; + pNew->nTabRef = 1; + pNew->nCol = pTab->nCol; + assert( pNew->nCol>0 ); + nAlloc = (((pNew->nCol-1)/8)*8)+8; + assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 ); + pNew->aCol = (Column*)sqlite3DbMallocZero(db, sizeof(Column)*nAlloc); + pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName); + if( !pNew->aCol || !pNew->zName ){ + assert( db->mallocFailed ); + goto exit_begin_add_column; + } + memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol); + for(i=0; inCol; i++){ + Column *pCol = &pNew->aCol[i]; + pCol->zCnName = sqlite3DbStrDup(db, pCol->zCnName); + pCol->hName = sqlite3StrIHash(pCol->zCnName); + } + assert( IsOrdinaryTable(pNew) ); + pNew->u.tab.pDfltList = sqlite3ExprListDup(db, pTab->u.tab.pDfltList, 0); + pNew->pSchema = db->aDb[iDb].pSchema; + pNew->u.tab.addColOffset = pTab->u.tab.addColOffset; + pNew->nTabRef = 1; + +exit_begin_add_column: + sqlite3SrcListDelete(db, pSrc); + return; +} + +/* +** Parameter pTab is the subject of an ALTER TABLE ... RENAME COLUMN +** command. This function checks if the table is a view or virtual +** table (columns of views or virtual tables may not be renamed). If so, +** it loads an error message into pParse and returns non-zero. +** +** Or, if pTab is not a view or virtual table, zero is returned. +*/ +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) +static int isRealTable(Parse *pParse, Table *pTab, int bDrop){ + const char *zType = 0; +#ifndef SQLITE_OMIT_VIEW + if( IsView(pTab) ){ + zType = "view"; + } +#endif +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTab) ){ + zType = "virtual table"; + } +#endif + if( zType ){ + sqlite3ErrorMsg(pParse, "cannot %s %s \"%s\"", + (bDrop ? "drop column from" : "rename columns of"), + zType, pTab->zName + ); + return 1; + } + return 0; +} +#else /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */ +# define isRealTable(x,y,z) (0) +#endif + +/* +** Handles the following parser reduction: +** +** cmd ::= ALTER TABLE pSrc RENAME COLUMN pOld TO pNew +*/ +SQLITE_PRIVATE void sqlite3AlterRenameColumn( + Parse *pParse, /* Parsing context */ + SrcList *pSrc, /* Table being altered. pSrc->nSrc==1 */ + Token *pOld, /* Name of column being changed */ + Token *pNew /* New column name */ +){ + sqlite3 *db = pParse->db; /* Database connection */ + Table *pTab; /* Table being updated */ + int iCol; /* Index of column being renamed */ + char *zOld = 0; /* Old column name */ + char *zNew = 0; /* New column name */ + const char *zDb; /* Name of schema containing the table */ + int iSchema; /* Index of the schema */ + int bQuote; /* True to quote the new name */ + + /* Locate the table to be altered */ + pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]); + if( !pTab ) goto exit_rename_column; + + /* Cannot alter a system table */ + if( SQLITE_OK!=isAlterableTable(pParse, pTab) ) goto exit_rename_column; + if( SQLITE_OK!=isRealTable(pParse, pTab, 0) ) goto exit_rename_column; + + /* Which schema holds the table to be altered */ + iSchema = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( iSchema>=0 ); + zDb = db->aDb[iSchema].zDbSName; + +#ifndef SQLITE_OMIT_AUTHORIZATION + /* Invoke the authorization callback. */ + if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){ + goto exit_rename_column; + } +#endif + + /* Make sure the old name really is a column name in the table to be + ** altered. Set iCol to be the index of the column being renamed */ + zOld = sqlite3NameFromToken(db, pOld); + if( !zOld ) goto exit_rename_column; + for(iCol=0; iColnCol; iCol++){ + if( 0==sqlite3StrICmp(pTab->aCol[iCol].zCnName, zOld) ) break; + } + if( iCol==pTab->nCol ){ + sqlite3ErrorMsg(pParse, "no such column: \"%T\"", pOld); + goto exit_rename_column; + } + + /* Ensure the schema contains no double-quoted strings */ + renameTestSchema(pParse, zDb, iSchema==1, "", 0); + renameFixQuotes(pParse, zDb, iSchema==1); + + /* Do the rename operation using a recursive UPDATE statement that + ** uses the sqlite_rename_column() SQL function to compute the new + ** CREATE statement text for the sqlite_schema table. + */ + sqlite3MayAbort(pParse); + zNew = sqlite3NameFromToken(db, pNew); + if( !zNew ) goto exit_rename_column; + assert( pNew->n>0 ); + bQuote = sqlite3Isquote(pNew->z[0]); + sqlite3NestedParse(pParse, + "UPDATE \"%w\"." LEGACY_SCHEMA_TABLE " SET " + "sql = sqlite_rename_column(sql, type, name, %Q, %Q, %d, %Q, %d, %d) " + "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X' " + " AND (type != 'index' OR tbl_name = %Q)", + zDb, + zDb, pTab->zName, iCol, zNew, bQuote, iSchema==1, + pTab->zName + ); + + sqlite3NestedParse(pParse, + "UPDATE temp." LEGACY_SCHEMA_TABLE " SET " + "sql = sqlite_rename_column(sql, type, name, %Q, %Q, %d, %Q, %d, 1) " + "WHERE type IN ('trigger', 'view')", + zDb, pTab->zName, iCol, zNew, bQuote + ); + + /* Drop and reload the database schema. */ + renameReloadSchema(pParse, iSchema, INITFLAG_AlterRename); + renameTestSchema(pParse, zDb, iSchema==1, "after rename", 1); + + exit_rename_column: + sqlite3SrcListDelete(db, pSrc); + sqlite3DbFree(db, zOld); + sqlite3DbFree(db, zNew); + return; +} + +/* +** Each RenameToken object maps an element of the parse tree into +** the token that generated that element. The parse tree element +** might be one of: +** +** * A pointer to an Expr that represents an ID +** * The name of a table column in Column.zName +** +** A list of RenameToken objects can be constructed during parsing. +** Each new object is created by sqlite3RenameTokenMap(). +** As the parse tree is transformed, the sqlite3RenameTokenRemap() +** routine is used to keep the mapping current. +** +** After the parse finishes, renameTokenFind() routine can be used +** to look up the actual token value that created some element in +** the parse tree. +*/ +struct RenameToken { + const void *p; /* Parse tree element created by token t */ + Token t; /* The token that created parse tree element p */ + RenameToken *pNext; /* Next is a list of all RenameToken objects */ +}; + +/* +** The context of an ALTER TABLE RENAME COLUMN operation that gets passed +** down into the Walker. +*/ +typedef struct RenameCtx RenameCtx; +struct RenameCtx { + RenameToken *pList; /* List of tokens to overwrite */ + int nList; /* Number of tokens in pList */ + int iCol; /* Index of column being renamed */ + Table *pTab; /* Table being ALTERed */ + const char *zOld; /* Old column name */ +}; + +#ifdef SQLITE_DEBUG +/* +** This function is only for debugging. It performs two tasks: +** +** 1. Checks that pointer pPtr does not already appear in the +** rename-token list. +** +** 2. Dereferences each pointer in the rename-token list. +** +** The second is most effective when debugging under valgrind or +** address-sanitizer or similar. If any of these pointers no longer +** point to valid objects, an exception is raised by the memory-checking +** tool. +** +** The point of this is to prevent comparisons of invalid pointer values. +** Even though this always seems to work, it is undefined according to the +** C standard. Example of undefined comparison: +** +** sqlite3_free(x); +** if( x==y ) ... +** +** Technically, as x no longer points into a valid object or to the byte +** following a valid object, it may not be used in comparison operations. +*/ +static void renameTokenCheckAll(Parse *pParse, const void *pPtr){ + assert( pParse==pParse->db->pParse ); + assert( pParse->db->mallocFailed==0 || pParse->nErr!=0 ); + if( pParse->nErr==0 ){ + const RenameToken *p; + u32 i = 1; + for(p=pParse->pRename; p; p=p->pNext){ + if( p->p ){ + assert( p->p!=pPtr ); + i += *(u8*)(p->p) | 1; + } + } + assert( i>0 ); + } +} +#else +# define renameTokenCheckAll(x,y) +#endif + +/* +** Remember that the parser tree element pPtr was created using +** the token pToken. +** +** In other words, construct a new RenameToken object and add it +** to the list of RenameToken objects currently being built up +** in pParse->pRename. +** +** The pPtr argument is returned so that this routine can be used +** with tail recursion in tokenExpr() routine, for a small performance +** improvement. +*/ +SQLITE_PRIVATE const void *sqlite3RenameTokenMap( + Parse *pParse, + const void *pPtr, + const Token *pToken +){ + RenameToken *pNew; + assert( pPtr || pParse->db->mallocFailed ); + renameTokenCheckAll(pParse, pPtr); + if( ALWAYS(pParse->eParseMode!=PARSE_MODE_UNMAP) ){ + pNew = sqlite3DbMallocZero(pParse->db, sizeof(RenameToken)); + if( pNew ){ + pNew->p = pPtr; + pNew->t = *pToken; + pNew->pNext = pParse->pRename; + pParse->pRename = pNew; + } + } + + return pPtr; +} + +/* +** It is assumed that there is already a RenameToken object associated +** with parse tree element pFrom. This function remaps the associated token +** to parse tree element pTo. +*/ +SQLITE_PRIVATE void sqlite3RenameTokenRemap(Parse *pParse, const void *pTo, const void *pFrom){ + RenameToken *p; + renameTokenCheckAll(pParse, pTo); + for(p=pParse->pRename; p; p=p->pNext){ + if( p->p==pFrom ){ + p->p = pTo; + break; + } + } +} + +/* +** Walker callback used by sqlite3RenameExprUnmap(). +*/ +static int renameUnmapExprCb(Walker *pWalker, Expr *pExpr){ + Parse *pParse = pWalker->pParse; + sqlite3RenameTokenRemap(pParse, 0, (const void*)pExpr); + if( ExprUseYTab(pExpr) ){ + sqlite3RenameTokenRemap(pParse, 0, (const void*)&pExpr->y.pTab); + } + return WRC_Continue; +} + +/* +** Iterate through the Select objects that are part of WITH clauses attached +** to select statement pSelect. +*/ +static void renameWalkWith(Walker *pWalker, Select *pSelect){ + With *pWith = pSelect->pWith; + if( pWith ){ + Parse *pParse = pWalker->pParse; + int i; + With *pCopy = 0; + assert( pWith->nCte>0 ); + if( (pWith->a[0].pSelect->selFlags & SF_Expanded)==0 ){ + /* Push a copy of the With object onto the with-stack. We use a copy + ** here as the original will be expanded and resolved (flags SF_Expanded + ** and SF_Resolved) below. And the parser code that uses the with-stack + ** fails if the Select objects on it have already been expanded and + ** resolved. */ + pCopy = sqlite3WithDup(pParse->db, pWith); + pCopy = sqlite3WithPush(pParse, pCopy, 1); + } + for(i=0; inCte; i++){ + Select *p = pWith->a[i].pSelect; + NameContext sNC; + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + if( pCopy ) sqlite3SelectPrep(sNC.pParse, p, &sNC); + if( sNC.pParse->db->mallocFailed ) return; + sqlite3WalkSelect(pWalker, p); + sqlite3RenameExprlistUnmap(pParse, pWith->a[i].pCols); + } + if( pCopy && pParse->pWith==pCopy ){ + pParse->pWith = pCopy->pOuter; + } + } +} + +/* +** Unmap all tokens in the IdList object passed as the second argument. +*/ +static void unmapColumnIdlistNames( + Parse *pParse, + const IdList *pIdList +){ + int ii; + assert( pIdList!=0 ); + for(ii=0; iinId; ii++){ + sqlite3RenameTokenRemap(pParse, 0, (const void*)pIdList->a[ii].zName); + } +} + +/* +** Walker callback used by sqlite3RenameExprUnmap(). +*/ +static int renameUnmapSelectCb(Walker *pWalker, Select *p){ + Parse *pParse = pWalker->pParse; + int i; + if( pParse->nErr ) return WRC_Abort; + testcase( p->selFlags & SF_View ); + testcase( p->selFlags & SF_CopyCte ); + if( p->selFlags & (SF_View|SF_CopyCte) ){ + return WRC_Prune; + } + if( ALWAYS(p->pEList) ){ + ExprList *pList = p->pEList; + for(i=0; inExpr; i++){ + if( pList->a[i].zEName && pList->a[i].fg.eEName==ENAME_NAME ){ + sqlite3RenameTokenRemap(pParse, 0, (void*)pList->a[i].zEName); + } + } + } + if( ALWAYS(p->pSrc) ){ /* Every Select as a SrcList, even if it is empty */ + SrcList *pSrc = p->pSrc; + for(i=0; inSrc; i++){ + sqlite3RenameTokenRemap(pParse, 0, (void*)pSrc->a[i].zName); + if( pSrc->a[i].fg.isUsing==0 ){ + sqlite3WalkExpr(pWalker, pSrc->a[i].u3.pOn); + }else{ + unmapColumnIdlistNames(pParse, pSrc->a[i].u3.pUsing); + } + } + } + + renameWalkWith(pWalker, p); + return WRC_Continue; +} + +/* +** Remove all nodes that are part of expression pExpr from the rename list. +*/ +SQLITE_PRIVATE void sqlite3RenameExprUnmap(Parse *pParse, Expr *pExpr){ + u8 eMode = pParse->eParseMode; + Walker sWalker; + memset(&sWalker, 0, sizeof(Walker)); + sWalker.pParse = pParse; + sWalker.xExprCallback = renameUnmapExprCb; + sWalker.xSelectCallback = renameUnmapSelectCb; + pParse->eParseMode = PARSE_MODE_UNMAP; + sqlite3WalkExpr(&sWalker, pExpr); + pParse->eParseMode = eMode; +} + +/* +** Remove all nodes that are part of expression-list pEList from the +** rename list. +*/ +SQLITE_PRIVATE void sqlite3RenameExprlistUnmap(Parse *pParse, ExprList *pEList){ + if( pEList ){ + int i; + Walker sWalker; + memset(&sWalker, 0, sizeof(Walker)); + sWalker.pParse = pParse; + sWalker.xExprCallback = renameUnmapExprCb; + sqlite3WalkExprList(&sWalker, pEList); + for(i=0; inExpr; i++){ + if( ALWAYS(pEList->a[i].fg.eEName==ENAME_NAME) ){ + sqlite3RenameTokenRemap(pParse, 0, (void*)pEList->a[i].zEName); + } + } + } +} + +/* +** Free the list of RenameToken objects given in the second argument +*/ +static void renameTokenFree(sqlite3 *db, RenameToken *pToken){ + RenameToken *pNext; + RenameToken *p; + for(p=pToken; p; p=pNext){ + pNext = p->pNext; + sqlite3DbFree(db, p); + } +} + +/* +** Search the Parse object passed as the first argument for a RenameToken +** object associated with parse tree element pPtr. If found, return a pointer +** to it. Otherwise, return NULL. +** +** If the second argument passed to this function is not NULL and a matching +** RenameToken object is found, remove it from the Parse object and add it to +** the list maintained by the RenameCtx object. +*/ +static RenameToken *renameTokenFind( + Parse *pParse, + struct RenameCtx *pCtx, + const void *pPtr +){ + RenameToken **pp; + if( NEVER(pPtr==0) ){ + return 0; + } + for(pp=&pParse->pRename; (*pp); pp=&(*pp)->pNext){ + if( (*pp)->p==pPtr ){ + RenameToken *pToken = *pp; + if( pCtx ){ + *pp = pToken->pNext; + pToken->pNext = pCtx->pList; + pCtx->pList = pToken; + pCtx->nList++; + } + return pToken; + } + } + return 0; +} + +/* +** This is a Walker select callback. It does nothing. It is only required +** because without a dummy callback, sqlite3WalkExpr() and similar do not +** descend into sub-select statements. +*/ +static int renameColumnSelectCb(Walker *pWalker, Select *p){ + if( p->selFlags & (SF_View|SF_CopyCte) ){ + testcase( p->selFlags & SF_View ); + testcase( p->selFlags & SF_CopyCte ); + return WRC_Prune; + } + renameWalkWith(pWalker, p); + return WRC_Continue; +} + +/* +** This is a Walker expression callback. +** +** For every TK_COLUMN node in the expression tree, search to see +** if the column being references is the column being renamed by an +** ALTER TABLE statement. If it is, then attach its associated +** RenameToken object to the list of RenameToken objects being +** constructed in RenameCtx object at pWalker->u.pRename. +*/ +static int renameColumnExprCb(Walker *pWalker, Expr *pExpr){ + RenameCtx *p = pWalker->u.pRename; + if( pExpr->op==TK_TRIGGER + && pExpr->iColumn==p->iCol + && pWalker->pParse->pTriggerTab==p->pTab + ){ + renameTokenFind(pWalker->pParse, p, (void*)pExpr); + }else if( pExpr->op==TK_COLUMN + && pExpr->iColumn==p->iCol + && ALWAYS(ExprUseYTab(pExpr)) + && p->pTab==pExpr->y.pTab + ){ + renameTokenFind(pWalker->pParse, p, (void*)pExpr); + } + return WRC_Continue; +} + +/* +** The RenameCtx contains a list of tokens that reference a column that +** is being renamed by an ALTER TABLE statement. Return the "last" +** RenameToken in the RenameCtx and remove that RenameToken from the +** RenameContext. "Last" means the last RenameToken encountered when +** the input SQL is parsed from left to right. Repeated calls to this routine +** return all column name tokens in the order that they are encountered +** in the SQL statement. +*/ +static RenameToken *renameColumnTokenNext(RenameCtx *pCtx){ + RenameToken *pBest = pCtx->pList; + RenameToken *pToken; + RenameToken **pp; + + for(pToken=pBest->pNext; pToken; pToken=pToken->pNext){ + if( pToken->t.z>pBest->t.z ) pBest = pToken; + } + for(pp=&pCtx->pList; *pp!=pBest; pp=&(*pp)->pNext); + *pp = pBest->pNext; + + return pBest; +} + +/* +** An error occured while parsing or otherwise processing a database +** object (either pParse->pNewTable, pNewIndex or pNewTrigger) as part of an +** ALTER TABLE RENAME COLUMN program. The error message emitted by the +** sub-routine is currently stored in pParse->zErrMsg. This function +** adds context to the error message and then stores it in pCtx. +*/ +static void renameColumnParseError( + sqlite3_context *pCtx, + const char *zWhen, + sqlite3_value *pType, + sqlite3_value *pObject, + Parse *pParse +){ + const char *zT = (const char*)sqlite3_value_text(pType); + const char *zN = (const char*)sqlite3_value_text(pObject); + char *zErr; + + zErr = sqlite3MPrintf(pParse->db, "error in %s %s%s%s: %s", + zT, zN, (zWhen[0] ? " " : ""), zWhen, + pParse->zErrMsg + ); + sqlite3_result_error(pCtx, zErr, -1); + sqlite3DbFree(pParse->db, zErr); +} + +/* +** For each name in the the expression-list pEList (i.e. each +** pEList->a[i].zName) that matches the string in zOld, extract the +** corresponding rename-token from Parse object pParse and add it +** to the RenameCtx pCtx. +*/ +static void renameColumnElistNames( + Parse *pParse, + RenameCtx *pCtx, + const ExprList *pEList, + const char *zOld +){ + if( pEList ){ + int i; + for(i=0; inExpr; i++){ + const char *zName = pEList->a[i].zEName; + if( ALWAYS(pEList->a[i].fg.eEName==ENAME_NAME) + && ALWAYS(zName!=0) + && 0==sqlite3_stricmp(zName, zOld) + ){ + renameTokenFind(pParse, pCtx, (const void*)zName); + } + } + } +} + +/* +** For each name in the the id-list pIdList (i.e. each pIdList->a[i].zName) +** that matches the string in zOld, extract the corresponding rename-token +** from Parse object pParse and add it to the RenameCtx pCtx. +*/ +static void renameColumnIdlistNames( + Parse *pParse, + RenameCtx *pCtx, + const IdList *pIdList, + const char *zOld +){ + if( pIdList ){ + int i; + for(i=0; inId; i++){ + const char *zName = pIdList->a[i].zName; + if( 0==sqlite3_stricmp(zName, zOld) ){ + renameTokenFind(pParse, pCtx, (const void*)zName); + } + } + } +} + + +/* +** Parse the SQL statement zSql using Parse object (*p). The Parse object +** is initialized by this function before it is used. +*/ +static int renameParseSql( + Parse *p, /* Memory to use for Parse object */ + const char *zDb, /* Name of schema SQL belongs to */ + sqlite3 *db, /* Database handle */ + const char *zSql, /* SQL to parse */ + int bTemp /* True if SQL is from temp schema */ +){ + int rc; + + sqlite3ParseObjectInit(p, db); + if( zSql==0 ){ + return SQLITE_NOMEM; + } + if( sqlite3StrNICmp(zSql,"CREATE ",7)!=0 ){ + return SQLITE_CORRUPT_BKPT; + } + db->init.iDb = bTemp ? 1 : sqlite3FindDbName(db, zDb); + p->eParseMode = PARSE_MODE_RENAME; + p->db = db; + p->nQueryLoop = 1; + rc = sqlite3RunParser(p, zSql); + if( db->mallocFailed ) rc = SQLITE_NOMEM; + if( rc==SQLITE_OK + && NEVER(p->pNewTable==0 && p->pNewIndex==0 && p->pNewTrigger==0) + ){ + rc = SQLITE_CORRUPT_BKPT; + } + +#ifdef SQLITE_DEBUG + /* Ensure that all mappings in the Parse.pRename list really do map to + ** a part of the input string. */ + if( rc==SQLITE_OK ){ + int nSql = sqlite3Strlen30(zSql); + RenameToken *pToken; + for(pToken=p->pRename; pToken; pToken=pToken->pNext){ + assert( pToken->t.z>=zSql && &pToken->t.z[pToken->t.n]<=&zSql[nSql] ); + } + } +#endif + + db->init.iDb = 0; + return rc; +} + +/* +** This function edits SQL statement zSql, replacing each token identified +** by the linked list pRename with the text of zNew. If argument bQuote is +** true, then zNew is always quoted first. If no error occurs, the result +** is loaded into context object pCtx as the result. +** +** Or, if an error occurs (i.e. an OOM condition), an error is left in +** pCtx and an SQLite error code returned. +*/ +static int renameEditSql( + sqlite3_context *pCtx, /* Return result here */ + RenameCtx *pRename, /* Rename context */ + const char *zSql, /* SQL statement to edit */ + const char *zNew, /* New token text */ + int bQuote /* True to always quote token */ +){ + i64 nNew = sqlite3Strlen30(zNew); + i64 nSql = sqlite3Strlen30(zSql); + sqlite3 *db = sqlite3_context_db_handle(pCtx); + int rc = SQLITE_OK; + char *zQuot = 0; + char *zOut; + i64 nQuot = 0; + char *zBuf1 = 0; + char *zBuf2 = 0; + + if( zNew ){ + /* Set zQuot to point to a buffer containing a quoted copy of the + ** identifier zNew. If the corresponding identifier in the original + ** ALTER TABLE statement was quoted (bQuote==1), then set zNew to + ** point to zQuot so that all substitutions are made using the + ** quoted version of the new column name. */ + zQuot = sqlite3MPrintf(db, "\"%w\" ", zNew); + if( zQuot==0 ){ + return SQLITE_NOMEM; + }else{ + nQuot = sqlite3Strlen30(zQuot)-1; + } + + assert( nQuot>=nNew ); + zOut = sqlite3DbMallocZero(db, nSql + pRename->nList*nQuot + 1); + }else{ + zOut = (char*)sqlite3DbMallocZero(db, (nSql*2+1) * 3); + if( zOut ){ + zBuf1 = &zOut[nSql*2+1]; + zBuf2 = &zOut[nSql*4+2]; + } + } + + /* At this point pRename->pList contains a list of RenameToken objects + ** corresponding to all tokens in the input SQL that must be replaced + ** with the new column name, or with single-quoted versions of themselves. + ** All that remains is to construct and return the edited SQL string. */ + if( zOut ){ + int nOut = nSql; + memcpy(zOut, zSql, nSql); + while( pRename->pList ){ + int iOff; /* Offset of token to replace in zOut */ + u32 nReplace; + const char *zReplace; + RenameToken *pBest = renameColumnTokenNext(pRename); + + if( zNew ){ + if( bQuote==0 && sqlite3IsIdChar(*pBest->t.z) ){ + nReplace = nNew; + zReplace = zNew; + }else{ + nReplace = nQuot; + zReplace = zQuot; + if( pBest->t.z[pBest->t.n]=='"' ) nReplace++; + } + }else{ + /* Dequote the double-quoted token. Then requote it again, this time + ** using single quotes. If the character immediately following the + ** original token within the input SQL was a single quote ('), then + ** add another space after the new, single-quoted version of the + ** token. This is so that (SELECT "string"'alias') maps to + ** (SELECT 'string' 'alias'), and not (SELECT 'string''alias'). */ + memcpy(zBuf1, pBest->t.z, pBest->t.n); + zBuf1[pBest->t.n] = 0; + sqlite3Dequote(zBuf1); + sqlite3_snprintf(nSql*2, zBuf2, "%Q%s", zBuf1, + pBest->t.z[pBest->t.n]=='\'' ? " " : "" + ); + zReplace = zBuf2; + nReplace = sqlite3Strlen30(zReplace); + } + + iOff = pBest->t.z - zSql; + if( pBest->t.n!=nReplace ){ + memmove(&zOut[iOff + nReplace], &zOut[iOff + pBest->t.n], + nOut - (iOff + pBest->t.n) + ); + nOut += nReplace - pBest->t.n; + zOut[nOut] = '\0'; + } + memcpy(&zOut[iOff], zReplace, nReplace); + sqlite3DbFree(db, pBest); + } + + sqlite3_result_text(pCtx, zOut, -1, SQLITE_TRANSIENT); + sqlite3DbFree(db, zOut); + }else{ + rc = SQLITE_NOMEM; + } + + sqlite3_free(zQuot); + return rc; +} + +/* +** Set all pEList->a[].fg.eEName fields in the expression-list to val. +*/ +static void renameSetENames(ExprList *pEList, int val){ + if( pEList ){ + int i; + for(i=0; inExpr; i++){ + assert( val==ENAME_NAME || pEList->a[i].fg.eEName==ENAME_NAME ); + pEList->a[i].fg.eEName = val; + } + } +} + +/* +** Resolve all symbols in the trigger at pParse->pNewTrigger, assuming +** it was read from the schema of database zDb. Return SQLITE_OK if +** successful. Otherwise, return an SQLite error code and leave an error +** message in the Parse object. +*/ +static int renameResolveTrigger(Parse *pParse){ + sqlite3 *db = pParse->db; + Trigger *pNew = pParse->pNewTrigger; + TriggerStep *pStep; + NameContext sNC; + int rc = SQLITE_OK; + + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + assert( pNew->pTabSchema ); + pParse->pTriggerTab = sqlite3FindTable(db, pNew->table, + db->aDb[sqlite3SchemaToIndex(db, pNew->pTabSchema)].zDbSName + ); + pParse->eTriggerOp = pNew->op; + /* ALWAYS() because if the table of the trigger does not exist, the + ** error would have been hit before this point */ + if( ALWAYS(pParse->pTriggerTab) ){ + rc = sqlite3ViewGetColumnNames(pParse, pParse->pTriggerTab); + } + + /* Resolve symbols in WHEN clause */ + if( rc==SQLITE_OK && pNew->pWhen ){ + rc = sqlite3ResolveExprNames(&sNC, pNew->pWhen); + } + + for(pStep=pNew->step_list; rc==SQLITE_OK && pStep; pStep=pStep->pNext){ + if( pStep->pSelect ){ + sqlite3SelectPrep(pParse, pStep->pSelect, &sNC); + if( pParse->nErr ) rc = pParse->rc; + } + if( rc==SQLITE_OK && pStep->zTarget ){ + SrcList *pSrc = sqlite3TriggerStepSrc(pParse, pStep); + if( pSrc ){ + Select *pSel = sqlite3SelectNew( + pParse, pStep->pExprList, pSrc, 0, 0, 0, 0, 0, 0 + ); + if( pSel==0 ){ + pStep->pExprList = 0; + pSrc = 0; + rc = SQLITE_NOMEM; + }else{ + /* pStep->pExprList contains an expression-list used for an UPDATE + ** statement. So the a[].zEName values are the RHS of the + ** "= " clauses of the UPDATE statement. So, before + ** running SelectPrep(), change all the eEName values in + ** pStep->pExprList to ENAME_SPAN (from their current value of + ** ENAME_NAME). This is to prevent any ids in ON() clauses that are + ** part of pSrc from being incorrectly resolved against the + ** a[].zEName values as if they were column aliases. */ + renameSetENames(pStep->pExprList, ENAME_SPAN); + sqlite3SelectPrep(pParse, pSel, 0); + renameSetENames(pStep->pExprList, ENAME_NAME); + rc = pParse->nErr ? SQLITE_ERROR : SQLITE_OK; + assert( pStep->pExprList==0 || pStep->pExprList==pSel->pEList ); + assert( pSrc==pSel->pSrc ); + if( pStep->pExprList ) pSel->pEList = 0; + pSel->pSrc = 0; + sqlite3SelectDelete(db, pSel); + } + if( pStep->pFrom ){ + int i; + for(i=0; ipFrom->nSrc && rc==SQLITE_OK; i++){ + SrcItem *p = &pStep->pFrom->a[i]; + if( p->pSelect ){ + sqlite3SelectPrep(pParse, p->pSelect, 0); + } + } + } + + if( db->mallocFailed ){ + rc = SQLITE_NOMEM; + } + sNC.pSrcList = pSrc; + if( rc==SQLITE_OK && pStep->pWhere ){ + rc = sqlite3ResolveExprNames(&sNC, pStep->pWhere); + } + if( rc==SQLITE_OK ){ + rc = sqlite3ResolveExprListNames(&sNC, pStep->pExprList); + } + assert( !pStep->pUpsert || (!pStep->pWhere && !pStep->pExprList) ); + if( pStep->pUpsert && rc==SQLITE_OK ){ + Upsert *pUpsert = pStep->pUpsert; + pUpsert->pUpsertSrc = pSrc; + sNC.uNC.pUpsert = pUpsert; + sNC.ncFlags = NC_UUpsert; + rc = sqlite3ResolveExprListNames(&sNC, pUpsert->pUpsertTarget); + if( rc==SQLITE_OK ){ + ExprList *pUpsertSet = pUpsert->pUpsertSet; + rc = sqlite3ResolveExprListNames(&sNC, pUpsertSet); + } + if( rc==SQLITE_OK ){ + rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertWhere); + } + if( rc==SQLITE_OK ){ + rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertTargetWhere); + } + sNC.ncFlags = 0; + } + sNC.pSrcList = 0; + sqlite3SrcListDelete(db, pSrc); + }else{ + rc = SQLITE_NOMEM; + } + } + } + return rc; +} + +/* +** Invoke sqlite3WalkExpr() or sqlite3WalkSelect() on all Select or Expr +** objects that are part of the trigger passed as the second argument. +*/ +static void renameWalkTrigger(Walker *pWalker, Trigger *pTrigger){ + TriggerStep *pStep; + + /* Find tokens to edit in WHEN clause */ + sqlite3WalkExpr(pWalker, pTrigger->pWhen); + + /* Find tokens to edit in trigger steps */ + for(pStep=pTrigger->step_list; pStep; pStep=pStep->pNext){ + sqlite3WalkSelect(pWalker, pStep->pSelect); + sqlite3WalkExpr(pWalker, pStep->pWhere); + sqlite3WalkExprList(pWalker, pStep->pExprList); + if( pStep->pUpsert ){ + Upsert *pUpsert = pStep->pUpsert; + sqlite3WalkExprList(pWalker, pUpsert->pUpsertTarget); + sqlite3WalkExprList(pWalker, pUpsert->pUpsertSet); + sqlite3WalkExpr(pWalker, pUpsert->pUpsertWhere); + sqlite3WalkExpr(pWalker, pUpsert->pUpsertTargetWhere); + } + if( pStep->pFrom ){ + int i; + for(i=0; ipFrom->nSrc; i++){ + sqlite3WalkSelect(pWalker, pStep->pFrom->a[i].pSelect); + } + } + } +} + +/* +** Free the contents of Parse object (*pParse). Do not free the memory +** occupied by the Parse object itself. +*/ +static void renameParseCleanup(Parse *pParse){ + sqlite3 *db = pParse->db; + Index *pIdx; + if( pParse->pVdbe ){ + sqlite3VdbeFinalize(pParse->pVdbe); + } + sqlite3DeleteTable(db, pParse->pNewTable); + while( (pIdx = pParse->pNewIndex)!=0 ){ + pParse->pNewIndex = pIdx->pNext; + sqlite3FreeIndex(db, pIdx); + } + sqlite3DeleteTrigger(db, pParse->pNewTrigger); + sqlite3DbFree(db, pParse->zErrMsg); + renameTokenFree(db, pParse->pRename); + sqlite3ParseObjectReset(pParse); +} + +/* +** SQL function: +** +** sqlite_rename_column(SQL,TYPE,OBJ,DB,TABLE,COL,NEWNAME,QUOTE,TEMP) +** +** 0. zSql: SQL statement to rewrite +** 1. type: Type of object ("table", "view" etc.) +** 2. object: Name of object +** 3. Database: Database name (e.g. "main") +** 4. Table: Table name +** 5. iCol: Index of column to rename +** 6. zNew: New column name +** 7. bQuote: Non-zero if the new column name should be quoted. +** 8. bTemp: True if zSql comes from temp schema +** +** Do a column rename operation on the CREATE statement given in zSql. +** The iCol-th column (left-most is 0) of table zTable is renamed from zCol +** into zNew. The name should be quoted if bQuote is true. +** +** This function is used internally by the ALTER TABLE RENAME COLUMN command. +** It is only accessible to SQL created using sqlite3NestedParse(). It is +** not reachable from ordinary SQL passed into sqlite3_prepare() unless the +** SQLITE_TESTCTRL_INTERNAL_FUNCTIONS test setting is enabled. +*/ +static void renameColumnFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + sqlite3 *db = sqlite3_context_db_handle(context); + RenameCtx sCtx; + const char *zSql = (const char*)sqlite3_value_text(argv[0]); + const char *zDb = (const char*)sqlite3_value_text(argv[3]); + const char *zTable = (const char*)sqlite3_value_text(argv[4]); + int iCol = sqlite3_value_int(argv[5]); + const char *zNew = (const char*)sqlite3_value_text(argv[6]); + int bQuote = sqlite3_value_int(argv[7]); + int bTemp = sqlite3_value_int(argv[8]); + const char *zOld; + int rc; + Parse sParse; + Walker sWalker; + Index *pIdx; + int i; + Table *pTab; +#ifndef SQLITE_OMIT_AUTHORIZATION + sqlite3_xauth xAuth = db->xAuth; +#endif + + UNUSED_PARAMETER(NotUsed); + if( zSql==0 ) return; + if( zTable==0 ) return; + if( zNew==0 ) return; + if( iCol<0 ) return; + sqlite3BtreeEnterAll(db); + pTab = sqlite3FindTable(db, zTable, zDb); + if( pTab==0 || iCol>=pTab->nCol ){ + sqlite3BtreeLeaveAll(db); + return; + } + zOld = pTab->aCol[iCol].zCnName; + memset(&sCtx, 0, sizeof(sCtx)); + sCtx.iCol = ((iCol==pTab->iPKey) ? -1 : iCol); + +#ifndef SQLITE_OMIT_AUTHORIZATION + db->xAuth = 0; +#endif + rc = renameParseSql(&sParse, zDb, db, zSql, bTemp); + + /* Find tokens that need to be replaced. */ + memset(&sWalker, 0, sizeof(Walker)); + sWalker.pParse = &sParse; + sWalker.xExprCallback = renameColumnExprCb; + sWalker.xSelectCallback = renameColumnSelectCb; + sWalker.u.pRename = &sCtx; + + sCtx.pTab = pTab; + if( rc!=SQLITE_OK ) goto renameColumnFunc_done; + if( sParse.pNewTable ){ + if( IsView(sParse.pNewTable) ){ + Select *pSelect = sParse.pNewTable->u.view.pSelect; + pSelect->selFlags &= ~SF_View; + sParse.rc = SQLITE_OK; + sqlite3SelectPrep(&sParse, pSelect, 0); + rc = (db->mallocFailed ? SQLITE_NOMEM : sParse.rc); + if( rc==SQLITE_OK ){ + sqlite3WalkSelect(&sWalker, pSelect); + } + if( rc!=SQLITE_OK ) goto renameColumnFunc_done; + }else if( IsOrdinaryTable(sParse.pNewTable) ){ + /* A regular table */ + int bFKOnly = sqlite3_stricmp(zTable, sParse.pNewTable->zName); + FKey *pFKey; + sCtx.pTab = sParse.pNewTable; + if( bFKOnly==0 ){ + if( iColnCol ){ + renameTokenFind( + &sParse, &sCtx, (void*)sParse.pNewTable->aCol[iCol].zCnName + ); + } + if( sCtx.iCol<0 ){ + renameTokenFind(&sParse, &sCtx, (void*)&sParse.pNewTable->iPKey); + } + sqlite3WalkExprList(&sWalker, sParse.pNewTable->pCheck); + for(pIdx=sParse.pNewTable->pIndex; pIdx; pIdx=pIdx->pNext){ + sqlite3WalkExprList(&sWalker, pIdx->aColExpr); + } + for(pIdx=sParse.pNewIndex; pIdx; pIdx=pIdx->pNext){ + sqlite3WalkExprList(&sWalker, pIdx->aColExpr); + } +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + for(i=0; inCol; i++){ + Expr *pExpr = sqlite3ColumnExpr(sParse.pNewTable, + &sParse.pNewTable->aCol[i]); + sqlite3WalkExpr(&sWalker, pExpr); + } +#endif + } + + assert( IsOrdinaryTable(sParse.pNewTable) ); + for(pFKey=sParse.pNewTable->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){ + for(i=0; inCol; i++){ + if( bFKOnly==0 && pFKey->aCol[i].iFrom==iCol ){ + renameTokenFind(&sParse, &sCtx, (void*)&pFKey->aCol[i]); + } + if( 0==sqlite3_stricmp(pFKey->zTo, zTable) + && 0==sqlite3_stricmp(pFKey->aCol[i].zCol, zOld) + ){ + renameTokenFind(&sParse, &sCtx, (void*)pFKey->aCol[i].zCol); + } + } + } + } + }else if( sParse.pNewIndex ){ + sqlite3WalkExprList(&sWalker, sParse.pNewIndex->aColExpr); + sqlite3WalkExpr(&sWalker, sParse.pNewIndex->pPartIdxWhere); + }else{ + /* A trigger */ + TriggerStep *pStep; + rc = renameResolveTrigger(&sParse); + if( rc!=SQLITE_OK ) goto renameColumnFunc_done; + + for(pStep=sParse.pNewTrigger->step_list; pStep; pStep=pStep->pNext){ + if( pStep->zTarget ){ + Table *pTarget = sqlite3LocateTable(&sParse, 0, pStep->zTarget, zDb); + if( pTarget==pTab ){ + if( pStep->pUpsert ){ + ExprList *pUpsertSet = pStep->pUpsert->pUpsertSet; + renameColumnElistNames(&sParse, &sCtx, pUpsertSet, zOld); + } + renameColumnIdlistNames(&sParse, &sCtx, pStep->pIdList, zOld); + renameColumnElistNames(&sParse, &sCtx, pStep->pExprList, zOld); + } + } + } + + + /* Find tokens to edit in UPDATE OF clause */ + if( sParse.pTriggerTab==pTab ){ + renameColumnIdlistNames(&sParse, &sCtx,sParse.pNewTrigger->pColumns,zOld); + } + + /* Find tokens to edit in various expressions and selects */ + renameWalkTrigger(&sWalker, sParse.pNewTrigger); + } + + assert( rc==SQLITE_OK ); + rc = renameEditSql(context, &sCtx, zSql, zNew, bQuote); + +renameColumnFunc_done: + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_ERROR && sqlite3WritableSchema(db) ){ + sqlite3_result_value(context, argv[0]); + }else if( sParse.zErrMsg ){ + renameColumnParseError(context, "", argv[1], argv[2], &sParse); + }else{ + sqlite3_result_error_code(context, rc); + } + } + + renameParseCleanup(&sParse); + renameTokenFree(db, sCtx.pList); +#ifndef SQLITE_OMIT_AUTHORIZATION + db->xAuth = xAuth; +#endif + sqlite3BtreeLeaveAll(db); +} + +/* +** Walker expression callback used by "RENAME TABLE". +*/ +static int renameTableExprCb(Walker *pWalker, Expr *pExpr){ + RenameCtx *p = pWalker->u.pRename; + if( pExpr->op==TK_COLUMN + && ALWAYS(ExprUseYTab(pExpr)) + && p->pTab==pExpr->y.pTab + ){ + renameTokenFind(pWalker->pParse, p, (void*)&pExpr->y.pTab); + } + return WRC_Continue; +} + +/* +** Walker select callback used by "RENAME TABLE". +*/ +static int renameTableSelectCb(Walker *pWalker, Select *pSelect){ + int i; + RenameCtx *p = pWalker->u.pRename; + SrcList *pSrc = pSelect->pSrc; + if( pSelect->selFlags & (SF_View|SF_CopyCte) ){ + testcase( pSelect->selFlags & SF_View ); + testcase( pSelect->selFlags & SF_CopyCte ); + return WRC_Prune; + } + if( NEVER(pSrc==0) ){ + assert( pWalker->pParse->db->mallocFailed ); + return WRC_Abort; + } + for(i=0; inSrc; i++){ + SrcItem *pItem = &pSrc->a[i]; + if( pItem->pTab==p->pTab ){ + renameTokenFind(pWalker->pParse, p, pItem->zName); + } + } + renameWalkWith(pWalker, pSelect); + + return WRC_Continue; +} + + +/* +** This C function implements an SQL user function that is used by SQL code +** generated by the ALTER TABLE ... RENAME command to modify the definition +** of any foreign key constraints that use the table being renamed as the +** parent table. It is passed three arguments: +** +** 0: The database containing the table being renamed. +** 1. type: Type of object ("table", "view" etc.) +** 2. object: Name of object +** 3: The complete text of the schema statement being modified, +** 4: The old name of the table being renamed, and +** 5: The new name of the table being renamed. +** 6: True if the schema statement comes from the temp db. +** +** It returns the new schema statement. For example: +** +** sqlite_rename_table('main', 'CREATE TABLE t1(a REFERENCES t2)','t2','t3',0) +** -> 'CREATE TABLE t1(a REFERENCES t3)' +*/ +static void renameTableFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + sqlite3 *db = sqlite3_context_db_handle(context); + const char *zDb = (const char*)sqlite3_value_text(argv[0]); + const char *zInput = (const char*)sqlite3_value_text(argv[3]); + const char *zOld = (const char*)sqlite3_value_text(argv[4]); + const char *zNew = (const char*)sqlite3_value_text(argv[5]); + int bTemp = sqlite3_value_int(argv[6]); + UNUSED_PARAMETER(NotUsed); + + if( zInput && zOld && zNew ){ + Parse sParse; + int rc; + int bQuote = 1; + RenameCtx sCtx; + Walker sWalker; + +#ifndef SQLITE_OMIT_AUTHORIZATION + sqlite3_xauth xAuth = db->xAuth; + db->xAuth = 0; +#endif + + sqlite3BtreeEnterAll(db); + + memset(&sCtx, 0, sizeof(RenameCtx)); + sCtx.pTab = sqlite3FindTable(db, zOld, zDb); + memset(&sWalker, 0, sizeof(Walker)); + sWalker.pParse = &sParse; + sWalker.xExprCallback = renameTableExprCb; + sWalker.xSelectCallback = renameTableSelectCb; + sWalker.u.pRename = &sCtx; + + rc = renameParseSql(&sParse, zDb, db, zInput, bTemp); + + if( rc==SQLITE_OK ){ + int isLegacy = (db->flags & SQLITE_LegacyAlter); + if( sParse.pNewTable ){ + Table *pTab = sParse.pNewTable; + + if( IsView(pTab) ){ + if( isLegacy==0 ){ + Select *pSelect = pTab->u.view.pSelect; + NameContext sNC; + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = &sParse; + + assert( pSelect->selFlags & SF_View ); + pSelect->selFlags &= ~SF_View; + sqlite3SelectPrep(&sParse, pTab->u.view.pSelect, &sNC); + if( sParse.nErr ){ + rc = sParse.rc; + }else{ + sqlite3WalkSelect(&sWalker, pTab->u.view.pSelect); + } + } + }else{ + /* Modify any FK definitions to point to the new table. */ +#ifndef SQLITE_OMIT_FOREIGN_KEY + if( (isLegacy==0 || (db->flags & SQLITE_ForeignKeys)) + && !IsVirtual(pTab) + ){ + FKey *pFKey; + assert( IsOrdinaryTable(pTab) ); + for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){ + if( sqlite3_stricmp(pFKey->zTo, zOld)==0 ){ + renameTokenFind(&sParse, &sCtx, (void*)pFKey->zTo); + } + } + } +#endif + + /* If this is the table being altered, fix any table refs in CHECK + ** expressions. Also update the name that appears right after the + ** "CREATE [VIRTUAL] TABLE" bit. */ + if( sqlite3_stricmp(zOld, pTab->zName)==0 ){ + sCtx.pTab = pTab; + if( isLegacy==0 ){ + sqlite3WalkExprList(&sWalker, pTab->pCheck); + } + renameTokenFind(&sParse, &sCtx, pTab->zName); + } + } + } + + else if( sParse.pNewIndex ){ + renameTokenFind(&sParse, &sCtx, sParse.pNewIndex->zName); + if( isLegacy==0 ){ + sqlite3WalkExpr(&sWalker, sParse.pNewIndex->pPartIdxWhere); + } + } + +#ifndef SQLITE_OMIT_TRIGGER + else{ + Trigger *pTrigger = sParse.pNewTrigger; + TriggerStep *pStep; + if( 0==sqlite3_stricmp(sParse.pNewTrigger->table, zOld) + && sCtx.pTab->pSchema==pTrigger->pTabSchema + ){ + renameTokenFind(&sParse, &sCtx, sParse.pNewTrigger->table); + } + + if( isLegacy==0 ){ + rc = renameResolveTrigger(&sParse); + if( rc==SQLITE_OK ){ + renameWalkTrigger(&sWalker, pTrigger); + for(pStep=pTrigger->step_list; pStep; pStep=pStep->pNext){ + if( pStep->zTarget && 0==sqlite3_stricmp(pStep->zTarget, zOld) ){ + renameTokenFind(&sParse, &sCtx, pStep->zTarget); + } + if( pStep->pFrom ){ + int i; + for(i=0; ipFrom->nSrc; i++){ + SrcItem *pItem = &pStep->pFrom->a[i]; + if( 0==sqlite3_stricmp(pItem->zName, zOld) ){ + renameTokenFind(&sParse, &sCtx, pItem->zName); + } + } + } + } + } + } + } +#endif + } + + if( rc==SQLITE_OK ){ + rc = renameEditSql(context, &sCtx, zInput, zNew, bQuote); + } + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_ERROR && sqlite3WritableSchema(db) ){ + sqlite3_result_value(context, argv[3]); + }else if( sParse.zErrMsg ){ + renameColumnParseError(context, "", argv[1], argv[2], &sParse); + }else{ + sqlite3_result_error_code(context, rc); + } + } + + renameParseCleanup(&sParse); + renameTokenFree(db, sCtx.pList); + sqlite3BtreeLeaveAll(db); +#ifndef SQLITE_OMIT_AUTHORIZATION + db->xAuth = xAuth; +#endif + } + + return; +} + +static int renameQuotefixExprCb(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_STRING && (pExpr->flags & EP_DblQuoted) ){ + renameTokenFind(pWalker->pParse, pWalker->u.pRename, (const void*)pExpr); + } + return WRC_Continue; +} + +/* SQL function: sqlite_rename_quotefix(DB,SQL) +** +** Rewrite the DDL statement "SQL" so that any string literals that use +** double-quotes use single quotes instead. +** +** Two arguments must be passed: +** +** 0: Database name ("main", "temp" etc.). +** 1: SQL statement to edit. +** +** The returned value is the modified SQL statement. For example, given +** the database schema: +** +** CREATE TABLE t1(a, b, c); +** +** SELECT sqlite_rename_quotefix('main', +** 'CREATE VIEW v1 AS SELECT "a", "string" FROM t1' +** ); +** +** returns the string: +** +** CREATE VIEW v1 AS SELECT "a", 'string' FROM t1 +** +** If there is a error in the input SQL, then raise an error, except +** if PRAGMA writable_schema=ON, then just return the input string +** unmodified following an error. +*/ +static void renameQuotefixFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + sqlite3 *db = sqlite3_context_db_handle(context); + char const *zDb = (const char*)sqlite3_value_text(argv[0]); + char const *zInput = (const char*)sqlite3_value_text(argv[1]); + +#ifndef SQLITE_OMIT_AUTHORIZATION + sqlite3_xauth xAuth = db->xAuth; + db->xAuth = 0; +#endif + + sqlite3BtreeEnterAll(db); + + UNUSED_PARAMETER(NotUsed); + if( zDb && zInput ){ + int rc; + Parse sParse; + rc = renameParseSql(&sParse, zDb, db, zInput, 0); + + if( rc==SQLITE_OK ){ + RenameCtx sCtx; + Walker sWalker; + + /* Walker to find tokens that need to be replaced. */ + memset(&sCtx, 0, sizeof(RenameCtx)); + memset(&sWalker, 0, sizeof(Walker)); + sWalker.pParse = &sParse; + sWalker.xExprCallback = renameQuotefixExprCb; + sWalker.xSelectCallback = renameColumnSelectCb; + sWalker.u.pRename = &sCtx; + + if( sParse.pNewTable ){ + if( IsView(sParse.pNewTable) ){ + Select *pSelect = sParse.pNewTable->u.view.pSelect; + pSelect->selFlags &= ~SF_View; + sParse.rc = SQLITE_OK; + sqlite3SelectPrep(&sParse, pSelect, 0); + rc = (db->mallocFailed ? SQLITE_NOMEM : sParse.rc); + if( rc==SQLITE_OK ){ + sqlite3WalkSelect(&sWalker, pSelect); + } + }else{ + int i; + sqlite3WalkExprList(&sWalker, sParse.pNewTable->pCheck); +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + for(i=0; inCol; i++){ + sqlite3WalkExpr(&sWalker, + sqlite3ColumnExpr(sParse.pNewTable, + &sParse.pNewTable->aCol[i])); + } +#endif /* SQLITE_OMIT_GENERATED_COLUMNS */ + } + }else if( sParse.pNewIndex ){ + sqlite3WalkExprList(&sWalker, sParse.pNewIndex->aColExpr); + sqlite3WalkExpr(&sWalker, sParse.pNewIndex->pPartIdxWhere); + }else{ +#ifndef SQLITE_OMIT_TRIGGER + rc = renameResolveTrigger(&sParse); + if( rc==SQLITE_OK ){ + renameWalkTrigger(&sWalker, sParse.pNewTrigger); + } +#endif /* SQLITE_OMIT_TRIGGER */ + } + + if( rc==SQLITE_OK ){ + rc = renameEditSql(context, &sCtx, zInput, 0, 0); + } + renameTokenFree(db, sCtx.pList); + } + if( rc!=SQLITE_OK ){ + if( sqlite3WritableSchema(db) && rc==SQLITE_ERROR ){ + sqlite3_result_value(context, argv[1]); + }else{ + sqlite3_result_error_code(context, rc); + } + } + renameParseCleanup(&sParse); + } + +#ifndef SQLITE_OMIT_AUTHORIZATION + db->xAuth = xAuth; +#endif + + sqlite3BtreeLeaveAll(db); +} + +/* Function: sqlite_rename_test(DB,SQL,TYPE,NAME,ISTEMP,WHEN,DQS) +** +** An SQL user function that checks that there are no parse or symbol +** resolution problems in a CREATE TRIGGER|TABLE|VIEW|INDEX statement. +** After an ALTER TABLE .. RENAME operation is performed and the schema +** reloaded, this function is called on each SQL statement in the schema +** to ensure that it is still usable. +** +** 0: Database name ("main", "temp" etc.). +** 1: SQL statement. +** 2: Object type ("view", "table", "trigger" or "index"). +** 3: Object name. +** 4: True if object is from temp schema. +** 5: "when" part of error message. +** 6: True to disable the DQS quirk when parsing SQL. +** +** The return value is computed as follows: +** +** A. If an error is seen and not in PRAGMA writable_schema=ON mode, +** then raise the error. +** B. Else if a trigger is created and the the table that the trigger is +** attached to is in database zDb, then return 1. +** C. Otherwise return NULL. +*/ +static void renameTableTest( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + sqlite3 *db = sqlite3_context_db_handle(context); + char const *zDb = (const char*)sqlite3_value_text(argv[0]); + char const *zInput = (const char*)sqlite3_value_text(argv[1]); + int bTemp = sqlite3_value_int(argv[4]); + int isLegacy = (db->flags & SQLITE_LegacyAlter); + char const *zWhen = (const char*)sqlite3_value_text(argv[5]); + int bNoDQS = sqlite3_value_int(argv[6]); + +#ifndef SQLITE_OMIT_AUTHORIZATION + sqlite3_xauth xAuth = db->xAuth; + db->xAuth = 0; +#endif + + UNUSED_PARAMETER(NotUsed); + + if( zDb && zInput ){ + int rc; + Parse sParse; + int flags = db->flags; + if( bNoDQS ) db->flags &= ~(SQLITE_DqsDML|SQLITE_DqsDDL); + rc = renameParseSql(&sParse, zDb, db, zInput, bTemp); + db->flags |= (flags & (SQLITE_DqsDML|SQLITE_DqsDDL)); + if( rc==SQLITE_OK ){ + if( isLegacy==0 && sParse.pNewTable && IsView(sParse.pNewTable) ){ + NameContext sNC; + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = &sParse; + sqlite3SelectPrep(&sParse, sParse.pNewTable->u.view.pSelect, &sNC); + if( sParse.nErr ) rc = sParse.rc; + } + + else if( sParse.pNewTrigger ){ + if( isLegacy==0 ){ + rc = renameResolveTrigger(&sParse); + } + if( rc==SQLITE_OK ){ + int i1 = sqlite3SchemaToIndex(db, sParse.pNewTrigger->pTabSchema); + int i2 = sqlite3FindDbName(db, zDb); + if( i1==i2 ){ + /* Handle output case B */ + sqlite3_result_int(context, 1); + } + } + } + } + + if( rc!=SQLITE_OK && zWhen && !sqlite3WritableSchema(db) ){ + /* Output case A */ + renameColumnParseError(context, zWhen, argv[2], argv[3],&sParse); + } + renameParseCleanup(&sParse); + } + +#ifndef SQLITE_OMIT_AUTHORIZATION + db->xAuth = xAuth; +#endif +} + +/* +** The implementation of internal UDF sqlite_drop_column(). +** +** Arguments: +** +** argv[0]: An integer - the index of the schema containing the table +** argv[1]: CREATE TABLE statement to modify. +** argv[2]: An integer - the index of the column to remove. +** +** The value returned is a string containing the CREATE TABLE statement +** with column argv[2] removed. +*/ +static void dropColumnFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + sqlite3 *db = sqlite3_context_db_handle(context); + int iSchema = sqlite3_value_int(argv[0]); + const char *zSql = (const char*)sqlite3_value_text(argv[1]); + int iCol = sqlite3_value_int(argv[2]); + const char *zDb = db->aDb[iSchema].zDbSName; + int rc; + Parse sParse; + RenameToken *pCol; + Table *pTab; + const char *zEnd; + char *zNew = 0; + +#ifndef SQLITE_OMIT_AUTHORIZATION + sqlite3_xauth xAuth = db->xAuth; + db->xAuth = 0; +#endif + + UNUSED_PARAMETER(NotUsed); + rc = renameParseSql(&sParse, zDb, db, zSql, iSchema==1); + if( rc!=SQLITE_OK ) goto drop_column_done; + pTab = sParse.pNewTable; + if( pTab==0 || pTab->nCol==1 || iCol>=pTab->nCol ){ + /* This can happen if the sqlite_schema table is corrupt */ + rc = SQLITE_CORRUPT_BKPT; + goto drop_column_done; + } + + pCol = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol].zCnName); + if( iColnCol-1 ){ + RenameToken *pEnd; + pEnd = renameTokenFind(&sParse, 0, (void*)pTab->aCol[iCol+1].zCnName); + zEnd = (const char*)pEnd->t.z; + }else{ + assert( IsOrdinaryTable(pTab) ); + zEnd = (const char*)&zSql[pTab->u.tab.addColOffset]; + while( ALWAYS(pCol->t.z[0]!=0) && pCol->t.z[0]!=',' ) pCol->t.z--; + } + + zNew = sqlite3MPrintf(db, "%.*s%s", pCol->t.z-zSql, zSql, zEnd); + sqlite3_result_text(context, zNew, -1, SQLITE_TRANSIENT); + sqlite3_free(zNew); + +drop_column_done: + renameParseCleanup(&sParse); +#ifndef SQLITE_OMIT_AUTHORIZATION + db->xAuth = xAuth; +#endif + if( rc!=SQLITE_OK ){ + sqlite3_result_error_code(context, rc); + } +} + +/* +** This function is called by the parser upon parsing an +** +** ALTER TABLE pSrc DROP COLUMN pName +** +** statement. Argument pSrc contains the possibly qualified name of the +** table being edited, and token pName the name of the column to drop. +*/ +SQLITE_PRIVATE void sqlite3AlterDropColumn(Parse *pParse, SrcList *pSrc, const Token *pName){ + sqlite3 *db = pParse->db; /* Database handle */ + Table *pTab; /* Table to modify */ + int iDb; /* Index of db containing pTab in aDb[] */ + const char *zDb; /* Database containing pTab ("main" etc.) */ + char *zCol = 0; /* Name of column to drop */ + int iCol; /* Index of column zCol in pTab->aCol[] */ + + /* Look up the table being altered. */ + assert( pParse->pNewTable==0 ); + assert( sqlite3BtreeHoldsAllMutexes(db) ); + if( NEVER(db->mallocFailed) ) goto exit_drop_column; + pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]); + if( !pTab ) goto exit_drop_column; + + /* Make sure this is not an attempt to ALTER a view, virtual table or + ** system table. */ + if( SQLITE_OK!=isAlterableTable(pParse, pTab) ) goto exit_drop_column; + if( SQLITE_OK!=isRealTable(pParse, pTab, 1) ) goto exit_drop_column; + + /* Find the index of the column being dropped. */ + zCol = sqlite3NameFromToken(db, pName); + if( zCol==0 ){ + assert( db->mallocFailed ); + goto exit_drop_column; + } + iCol = sqlite3ColumnIndex(pTab, zCol); + if( iCol<0 ){ + sqlite3ErrorMsg(pParse, "no such column: \"%T\"", pName); + goto exit_drop_column; + } + + /* Do not allow the user to drop a PRIMARY KEY column or a column + ** constrained by a UNIQUE constraint. */ + if( pTab->aCol[iCol].colFlags & (COLFLAG_PRIMKEY|COLFLAG_UNIQUE) ){ + sqlite3ErrorMsg(pParse, "cannot drop %s column: \"%s\"", + (pTab->aCol[iCol].colFlags&COLFLAG_PRIMKEY) ? "PRIMARY KEY" : "UNIQUE", + zCol + ); + goto exit_drop_column; + } + + /* Do not allow the number of columns to go to zero */ + if( pTab->nCol<=1 ){ + sqlite3ErrorMsg(pParse, "cannot drop column \"%s\": no other columns exist",zCol); + goto exit_drop_column; + } + + /* Edit the sqlite_schema table */ + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( iDb>=0 ); + zDb = db->aDb[iDb].zDbSName; +#ifndef SQLITE_OMIT_AUTHORIZATION + /* Invoke the authorization callback. */ + if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, zCol) ){ + goto exit_drop_column; + } +#endif + renameTestSchema(pParse, zDb, iDb==1, "", 0); + renameFixQuotes(pParse, zDb, iDb==1); + sqlite3NestedParse(pParse, + "UPDATE \"%w\"." LEGACY_SCHEMA_TABLE " SET " + "sql = sqlite_drop_column(%d, sql, %d) " + "WHERE (type=='table' AND tbl_name=%Q COLLATE nocase)" + , zDb, iDb, iCol, pTab->zName + ); + + /* Drop and reload the database schema. */ + renameReloadSchema(pParse, iDb, INITFLAG_AlterDrop); + renameTestSchema(pParse, zDb, iDb==1, "after drop column", 1); + + /* Edit rows of table on disk */ + if( pParse->nErr==0 && (pTab->aCol[iCol].colFlags & COLFLAG_VIRTUAL)==0 ){ + int i; + int addr; + int reg; + int regRec; + Index *pPk = 0; + int nField = 0; /* Number of non-virtual columns after drop */ + int iCur; + Vdbe *v = sqlite3GetVdbe(pParse); + iCur = pParse->nTab++; + sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite); + addr = sqlite3VdbeAddOp1(v, OP_Rewind, iCur); VdbeCoverage(v); + reg = ++pParse->nMem; + if( HasRowid(pTab) ){ + sqlite3VdbeAddOp2(v, OP_Rowid, iCur, reg); + pParse->nMem += pTab->nCol; + }else{ + pPk = sqlite3PrimaryKeyIndex(pTab); + pParse->nMem += pPk->nColumn; + for(i=0; inKeyCol; i++){ + sqlite3VdbeAddOp3(v, OP_Column, iCur, i, reg+i+1); + } + nField = pPk->nKeyCol; + } + regRec = ++pParse->nMem; + for(i=0; inCol; i++){ + if( i!=iCol && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ){ + int regOut; + if( pPk ){ + int iPos = sqlite3TableColumnToIndex(pPk, i); + int iColPos = sqlite3TableColumnToIndex(pPk, iCol); + if( iPosnKeyCol ) continue; + regOut = reg+1+iPos-(iPos>iColPos); + }else{ + regOut = reg+1+nField; + } + if( i==pTab->iPKey ){ + sqlite3VdbeAddOp2(v, OP_Null, 0, regOut); + }else{ + sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, i, regOut); + } + nField++; + } + } + if( nField==0 ){ + /* dbsqlfuzz 5f09e7bcc78b4954d06bf9f2400d7715f48d1fef */ + pParse->nMem++; + sqlite3VdbeAddOp2(v, OP_Null, 0, reg+1); + nField = 1; + } + sqlite3VdbeAddOp3(v, OP_MakeRecord, reg+1, nField, regRec); + if( pPk ){ + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iCur, regRec, reg+1, pPk->nKeyCol); + }else{ + sqlite3VdbeAddOp3(v, OP_Insert, iCur, regRec, reg); + } + sqlite3VdbeChangeP5(v, OPFLAG_SAVEPOSITION); + + sqlite3VdbeAddOp2(v, OP_Next, iCur, addr+1); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addr); + } + +exit_drop_column: + sqlite3DbFree(db, zCol); + sqlite3SrcListDelete(db, pSrc); +} + +/* +** Register built-in functions used to help implement ALTER TABLE +*/ +SQLITE_PRIVATE void sqlite3AlterFunctions(void){ + static FuncDef aAlterTableFuncs[] = { + INTERNAL_FUNCTION(sqlite_rename_column, 9, renameColumnFunc), + INTERNAL_FUNCTION(sqlite_rename_table, 7, renameTableFunc), + INTERNAL_FUNCTION(sqlite_rename_test, 7, renameTableTest), + INTERNAL_FUNCTION(sqlite_drop_column, 3, dropColumnFunc), + INTERNAL_FUNCTION(sqlite_rename_quotefix,2, renameQuotefixFunc), + }; + sqlite3InsertBuiltinFuncs(aAlterTableFuncs, ArraySize(aAlterTableFuncs)); +} +#endif /* SQLITE_ALTER_TABLE */ + +/************** End of alter.c ***********************************************/ +/************** Begin file analyze.c *****************************************/ +/* +** 2005-07-08 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code associated with the ANALYZE command. +** +** The ANALYZE command gather statistics about the content of tables +** and indices. These statistics are made available to the query planner +** to help it make better decisions about how to perform queries. +** +** The following system tables are or have been supported: +** +** CREATE TABLE sqlite_stat1(tbl, idx, stat); +** CREATE TABLE sqlite_stat2(tbl, idx, sampleno, sample); +** CREATE TABLE sqlite_stat3(tbl, idx, nEq, nLt, nDLt, sample); +** CREATE TABLE sqlite_stat4(tbl, idx, nEq, nLt, nDLt, sample); +** +** Additional tables might be added in future releases of SQLite. +** The sqlite_stat2 table is not created or used unless the SQLite version +** is between 3.6.18 and 3.7.8, inclusive, and unless SQLite is compiled +** with SQLITE_ENABLE_STAT2. The sqlite_stat2 table is deprecated. +** The sqlite_stat2 table is superseded by sqlite_stat3, which is only +** created and used by SQLite versions 3.7.9 through 3.29.0 when +** SQLITE_ENABLE_STAT3 defined. The functionality of sqlite_stat3 +** is a superset of sqlite_stat2 and is also now deprecated. The +** sqlite_stat4 is an enhanced version of sqlite_stat3 and is only +** available when compiled with SQLITE_ENABLE_STAT4 and in SQLite +** versions 3.8.1 and later. STAT4 is the only variant that is still +** supported. +** +** For most applications, sqlite_stat1 provides all the statistics required +** for the query planner to make good choices. +** +** Format of sqlite_stat1: +** +** There is normally one row per index, with the index identified by the +** name in the idx column. The tbl column is the name of the table to +** which the index belongs. In each such row, the stat column will be +** a string consisting of a list of integers. The first integer in this +** list is the number of rows in the index. (This is the same as the +** number of rows in the table, except for partial indices.) The second +** integer is the average number of rows in the index that have the same +** value in the first column of the index. The third integer is the average +** number of rows in the index that have the same value for the first two +** columns. The N-th integer (for N>1) is the average number of rows in +** the index which have the same value for the first N-1 columns. For +** a K-column index, there will be K+1 integers in the stat column. If +** the index is unique, then the last integer will be 1. +** +** The list of integers in the stat column can optionally be followed +** by the keyword "unordered". The "unordered" keyword, if it is present, +** must be separated from the last integer by a single space. If the +** "unordered" keyword is present, then the query planner assumes that +** the index is unordered and will not use the index for a range query. +** +** If the sqlite_stat1.idx column is NULL, then the sqlite_stat1.stat +** column contains a single integer which is the (estimated) number of +** rows in the table identified by sqlite_stat1.tbl. +** +** Format of sqlite_stat2: +** +** The sqlite_stat2 is only created and is only used if SQLite is compiled +** with SQLITE_ENABLE_STAT2 and if the SQLite version number is between +** 3.6.18 and 3.7.8. The "stat2" table contains additional information +** about the distribution of keys within an index. The index is identified by +** the "idx" column and the "tbl" column is the name of the table to which +** the index belongs. There are usually 10 rows in the sqlite_stat2 +** table for each index. +** +** The sqlite_stat2 entries for an index that have sampleno between 0 and 9 +** inclusive are samples of the left-most key value in the index taken at +** evenly spaced points along the index. Let the number of samples be S +** (10 in the standard build) and let C be the number of rows in the index. +** Then the sampled rows are given by: +** +** rownumber = (i*C*2 + C)/(S*2) +** +** For i between 0 and S-1. Conceptually, the index space is divided into +** S uniform buckets and the samples are the middle row from each bucket. +** +** The format for sqlite_stat2 is recorded here for legacy reference. This +** version of SQLite does not support sqlite_stat2. It neither reads nor +** writes the sqlite_stat2 table. This version of SQLite only supports +** sqlite_stat3. +** +** Format for sqlite_stat3: +** +** The sqlite_stat3 format is a subset of sqlite_stat4. Hence, the +** sqlite_stat4 format will be described first. Further information +** about sqlite_stat3 follows the sqlite_stat4 description. +** +** Format for sqlite_stat4: +** +** As with sqlite_stat2, the sqlite_stat4 table contains histogram data +** to aid the query planner in choosing good indices based on the values +** that indexed columns are compared against in the WHERE clauses of +** queries. +** +** The sqlite_stat4 table contains multiple entries for each index. +** The idx column names the index and the tbl column is the table of the +** index. If the idx and tbl columns are the same, then the sample is +** of the INTEGER PRIMARY KEY. The sample column is a blob which is the +** binary encoding of a key from the index. The nEq column is a +** list of integers. The first integer is the approximate number +** of entries in the index whose left-most column exactly matches +** the left-most column of the sample. The second integer in nEq +** is the approximate number of entries in the index where the +** first two columns match the first two columns of the sample. +** And so forth. nLt is another list of integers that show the approximate +** number of entries that are strictly less than the sample. The first +** integer in nLt contains the number of entries in the index where the +** left-most column is less than the left-most column of the sample. +** The K-th integer in the nLt entry is the number of index entries +** where the first K columns are less than the first K columns of the +** sample. The nDLt column is like nLt except that it contains the +** number of distinct entries in the index that are less than the +** sample. +** +** There can be an arbitrary number of sqlite_stat4 entries per index. +** The ANALYZE command will typically generate sqlite_stat4 tables +** that contain between 10 and 40 samples which are distributed across +** the key space, though not uniformly, and which include samples with +** large nEq values. +** +** Format for sqlite_stat3 redux: +** +** The sqlite_stat3 table is like sqlite_stat4 except that it only +** looks at the left-most column of the index. The sqlite_stat3.sample +** column contains the actual value of the left-most column instead +** of a blob encoding of the complete index key as is found in +** sqlite_stat4.sample. The nEq, nLt, and nDLt entries of sqlite_stat3 +** all contain just a single integer which is the same as the first +** integer in the equivalent columns in sqlite_stat4. +*/ +#ifndef SQLITE_OMIT_ANALYZE +/* #include "sqliteInt.h" */ + +#if defined(SQLITE_ENABLE_STAT4) +# define IsStat4 1 +#else +# define IsStat4 0 +# undef SQLITE_STAT4_SAMPLES +# define SQLITE_STAT4_SAMPLES 1 +#endif + +/* +** This routine generates code that opens the sqlite_statN tables. +** The sqlite_stat1 table is always relevant. sqlite_stat2 is now +** obsolete. sqlite_stat3 and sqlite_stat4 are only opened when +** appropriate compile-time options are provided. +** +** If the sqlite_statN tables do not previously exist, it is created. +** +** Argument zWhere may be a pointer to a buffer containing a table name, +** or it may be a NULL pointer. If it is not NULL, then all entries in +** the sqlite_statN tables associated with the named table are deleted. +** If zWhere==0, then code is generated to delete all stat table entries. +*/ +static void openStatTable( + Parse *pParse, /* Parsing context */ + int iDb, /* The database we are looking in */ + int iStatCur, /* Open the sqlite_stat1 table on this cursor */ + const char *zWhere, /* Delete entries for this table or index */ + const char *zWhereType /* Either "tbl" or "idx" */ +){ + static const struct { + const char *zName; + const char *zCols; + } aTable[] = { + { "sqlite_stat1", "tbl,idx,stat" }, +#if defined(SQLITE_ENABLE_STAT4) + { "sqlite_stat4", "tbl,idx,neq,nlt,ndlt,sample" }, +#else + { "sqlite_stat4", 0 }, +#endif + { "sqlite_stat3", 0 }, + }; + int i; + sqlite3 *db = pParse->db; + Db *pDb; + Vdbe *v = sqlite3GetVdbe(pParse); + u32 aRoot[ArraySize(aTable)]; + u8 aCreateTbl[ArraySize(aTable)]; +#ifdef SQLITE_ENABLE_STAT4 + const int nToOpen = OptimizationEnabled(db,SQLITE_Stat4) ? 2 : 1; +#else + const int nToOpen = 1; +#endif + + if( v==0 ) return; + assert( sqlite3BtreeHoldsAllMutexes(db) ); + assert( sqlite3VdbeDb(v)==db ); + pDb = &db->aDb[iDb]; + + /* Create new statistic tables if they do not exist, or clear them + ** if they do already exist. + */ + for(i=0; izDbSName))==0 ){ + if( iregRoot. This is important + ** because the OpenWrite opcode below will be needing it. */ + sqlite3NestedParse(pParse, + "CREATE TABLE %Q.%s(%s)", pDb->zDbSName, zTab, aTable[i].zCols + ); + aRoot[i] = (u32)pParse->regRoot; + aCreateTbl[i] = OPFLAG_P2ISREG; + } + }else{ + /* The table already exists. If zWhere is not NULL, delete all entries + ** associated with the table zWhere. If zWhere is NULL, delete the + ** entire contents of the table. */ + aRoot[i] = pStat->tnum; + sqlite3TableLock(pParse, iDb, aRoot[i], 1, zTab); + if( zWhere ){ + sqlite3NestedParse(pParse, + "DELETE FROM %Q.%s WHERE %s=%Q", + pDb->zDbSName, zTab, zWhereType, zWhere + ); +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + }else if( db->xPreUpdateCallback ){ + sqlite3NestedParse(pParse, "DELETE FROM %Q.%s", pDb->zDbSName, zTab); +#endif + }else{ + /* The sqlite_stat[134] table already exists. Delete all rows. */ + sqlite3VdbeAddOp2(v, OP_Clear, (int)aRoot[i], iDb); + } + } + } + + /* Open the sqlite_stat[134] tables for writing. */ + for(i=0; inRowid ){ + sqlite3DbFree(db, p->u.aRowid); + p->nRowid = 0; + } +} +#endif + +/* Initialize the BLOB value of a ROWID +*/ +#ifdef SQLITE_ENABLE_STAT4 +static void sampleSetRowid(sqlite3 *db, StatSample *p, int n, const u8 *pData){ + assert( db!=0 ); + if( p->nRowid ) sqlite3DbFree(db, p->u.aRowid); + p->u.aRowid = sqlite3DbMallocRawNN(db, n); + if( p->u.aRowid ){ + p->nRowid = n; + memcpy(p->u.aRowid, pData, n); + }else{ + p->nRowid = 0; + } +} +#endif + +/* Initialize the INTEGER value of a ROWID. +*/ +#ifdef SQLITE_ENABLE_STAT4 +static void sampleSetRowidInt64(sqlite3 *db, StatSample *p, i64 iRowid){ + assert( db!=0 ); + if( p->nRowid ) sqlite3DbFree(db, p->u.aRowid); + p->nRowid = 0; + p->u.iRowid = iRowid; +} +#endif + + +/* +** Copy the contents of object (*pFrom) into (*pTo). +*/ +#ifdef SQLITE_ENABLE_STAT4 +static void sampleCopy(StatAccum *p, StatSample *pTo, StatSample *pFrom){ + pTo->isPSample = pFrom->isPSample; + pTo->iCol = pFrom->iCol; + pTo->iHash = pFrom->iHash; + memcpy(pTo->anEq, pFrom->anEq, sizeof(tRowcnt)*p->nCol); + memcpy(pTo->anLt, pFrom->anLt, sizeof(tRowcnt)*p->nCol); + memcpy(pTo->anDLt, pFrom->anDLt, sizeof(tRowcnt)*p->nCol); + if( pFrom->nRowid ){ + sampleSetRowid(p->db, pTo, pFrom->nRowid, pFrom->u.aRowid); + }else{ + sampleSetRowidInt64(p->db, pTo, pFrom->u.iRowid); + } +} +#endif + +/* +** Reclaim all memory of a StatAccum structure. +*/ +static void statAccumDestructor(void *pOld){ + StatAccum *p = (StatAccum*)pOld; +#ifdef SQLITE_ENABLE_STAT4 + if( p->mxSample ){ + int i; + for(i=0; inCol; i++) sampleClear(p->db, p->aBest+i); + for(i=0; imxSample; i++) sampleClear(p->db, p->a+i); + sampleClear(p->db, &p->current); + } +#endif + sqlite3DbFree(p->db, p); +} + +/* +** Implementation of the stat_init(N,K,C,L) SQL function. The four parameters +** are: +** N: The number of columns in the index including the rowid/pk (note 1) +** K: The number of columns in the index excluding the rowid/pk. +** C: Estimated number of rows in the index +** L: A limit on the number of rows to scan, or 0 for no-limit +** +** Note 1: In the special case of the covering index that implements a +** WITHOUT ROWID table, N is the number of PRIMARY KEY columns, not the +** total number of columns in the table. +** +** For indexes on ordinary rowid tables, N==K+1. But for indexes on +** WITHOUT ROWID tables, N=K+P where P is the number of columns in the +** PRIMARY KEY of the table. The covering index that implements the +** original WITHOUT ROWID table as N==K as a special case. +** +** This routine allocates the StatAccum object in heap memory. The return +** value is a pointer to the StatAccum object. The datatype of the +** return value is BLOB, but it is really just a pointer to the StatAccum +** object. +*/ +static void statInit( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + StatAccum *p; + int nCol; /* Number of columns in index being sampled */ + int nKeyCol; /* Number of key columns */ + int nColUp; /* nCol rounded up for alignment */ + int n; /* Bytes of space to allocate */ + sqlite3 *db = sqlite3_context_db_handle(context); /* Database connection */ +#ifdef SQLITE_ENABLE_STAT4 + /* Maximum number of samples. 0 if STAT4 data is not collected */ + int mxSample = OptimizationEnabled(db,SQLITE_Stat4) ?SQLITE_STAT4_SAMPLES :0; +#endif + + /* Decode the three function arguments */ + UNUSED_PARAMETER(argc); + nCol = sqlite3_value_int(argv[0]); + assert( nCol>0 ); + nColUp = sizeof(tRowcnt)<8 ? (nCol+1)&~1 : nCol; + nKeyCol = sqlite3_value_int(argv[1]); + assert( nKeyCol<=nCol ); + assert( nKeyCol>0 ); + + /* Allocate the space required for the StatAccum object */ + n = sizeof(*p) + + sizeof(tRowcnt)*nColUp /* StatAccum.anEq */ + + sizeof(tRowcnt)*nColUp; /* StatAccum.anDLt */ +#ifdef SQLITE_ENABLE_STAT4 + if( mxSample ){ + n += sizeof(tRowcnt)*nColUp /* StatAccum.anLt */ + + sizeof(StatSample)*(nCol+mxSample) /* StatAccum.aBest[], a[] */ + + sizeof(tRowcnt)*3*nColUp*(nCol+mxSample); + } +#endif + p = sqlite3DbMallocZero(db, n); + if( p==0 ){ + sqlite3_result_error_nomem(context); + return; + } + + p->db = db; + p->nEst = sqlite3_value_int64(argv[2]); + p->nRow = 0; + p->nLimit = sqlite3_value_int64(argv[3]); + p->nCol = nCol; + p->nKeyCol = nKeyCol; + p->nSkipAhead = 0; + p->current.anDLt = (tRowcnt*)&p[1]; + p->current.anEq = &p->current.anDLt[nColUp]; + +#ifdef SQLITE_ENABLE_STAT4 + p->mxSample = p->nLimit==0 ? mxSample : 0; + if( mxSample ){ + u8 *pSpace; /* Allocated space not yet assigned */ + int i; /* Used to iterate through p->aSample[] */ + + p->iGet = -1; + p->nPSample = (tRowcnt)(p->nEst/(mxSample/3+1) + 1); + p->current.anLt = &p->current.anEq[nColUp]; + p->iPrn = 0x689e962d*(u32)nCol ^ 0xd0944565*(u32)sqlite3_value_int(argv[2]); + + /* Set up the StatAccum.a[] and aBest[] arrays */ + p->a = (struct StatSample*)&p->current.anLt[nColUp]; + p->aBest = &p->a[mxSample]; + pSpace = (u8*)(&p->a[mxSample+nCol]); + for(i=0; i<(mxSample+nCol); i++){ + p->a[i].anEq = (tRowcnt *)pSpace; pSpace += (sizeof(tRowcnt) * nColUp); + p->a[i].anLt = (tRowcnt *)pSpace; pSpace += (sizeof(tRowcnt) * nColUp); + p->a[i].anDLt = (tRowcnt *)pSpace; pSpace += (sizeof(tRowcnt) * nColUp); + } + assert( (pSpace - (u8*)p)==n ); + + for(i=0; iaBest[i].iCol = i; + } + } +#endif + + /* Return a pointer to the allocated object to the caller. Note that + ** only the pointer (the 2nd parameter) matters. The size of the object + ** (given by the 3rd parameter) is never used and can be any positive + ** value. */ + sqlite3_result_blob(context, p, sizeof(*p), statAccumDestructor); +} +static const FuncDef statInitFuncdef = { + 4, /* nArg */ + SQLITE_UTF8, /* funcFlags */ + 0, /* pUserData */ + 0, /* pNext */ + statInit, /* xSFunc */ + 0, /* xFinalize */ + 0, 0, /* xValue, xInverse */ + "stat_init", /* zName */ + {0} +}; + +#ifdef SQLITE_ENABLE_STAT4 +/* +** pNew and pOld are both candidate non-periodic samples selected for +** the same column (pNew->iCol==pOld->iCol). Ignoring this column and +** considering only any trailing columns and the sample hash value, this +** function returns true if sample pNew is to be preferred over pOld. +** In other words, if we assume that the cardinalities of the selected +** column for pNew and pOld are equal, is pNew to be preferred over pOld. +** +** This function assumes that for each argument sample, the contents of +** the anEq[] array from pSample->anEq[pSample->iCol+1] onwards are valid. +*/ +static int sampleIsBetterPost( + StatAccum *pAccum, + StatSample *pNew, + StatSample *pOld +){ + int nCol = pAccum->nCol; + int i; + assert( pNew->iCol==pOld->iCol ); + for(i=pNew->iCol+1; ianEq[i]>pOld->anEq[i] ) return 1; + if( pNew->anEq[i]anEq[i] ) return 0; + } + if( pNew->iHash>pOld->iHash ) return 1; + return 0; +} +#endif + +#ifdef SQLITE_ENABLE_STAT4 +/* +** Return true if pNew is to be preferred over pOld. +** +** This function assumes that for each argument sample, the contents of +** the anEq[] array from pSample->anEq[pSample->iCol] onwards are valid. +*/ +static int sampleIsBetter( + StatAccum *pAccum, + StatSample *pNew, + StatSample *pOld +){ + tRowcnt nEqNew = pNew->anEq[pNew->iCol]; + tRowcnt nEqOld = pOld->anEq[pOld->iCol]; + + assert( pOld->isPSample==0 && pNew->isPSample==0 ); + assert( IsStat4 || (pNew->iCol==0 && pOld->iCol==0) ); + + if( (nEqNew>nEqOld) ) return 1; + if( nEqNew==nEqOld ){ + if( pNew->iColiCol ) return 1; + return (pNew->iCol==pOld->iCol && sampleIsBetterPost(pAccum, pNew, pOld)); + } + return 0; +} + +/* +** Copy the contents of sample *pNew into the p->a[] array. If necessary, +** remove the least desirable sample from p->a[] to make room. +*/ +static void sampleInsert(StatAccum *p, StatSample *pNew, int nEqZero){ + StatSample *pSample = 0; + int i; + + assert( IsStat4 || nEqZero==0 ); + + /* StatAccum.nMaxEqZero is set to the maximum number of leading 0 + ** values in the anEq[] array of any sample in StatAccum.a[]. In + ** other words, if nMaxEqZero is n, then it is guaranteed that there + ** are no samples with StatSample.anEq[m]==0 for (m>=n). */ + if( nEqZero>p->nMaxEqZero ){ + p->nMaxEqZero = nEqZero; + } + if( pNew->isPSample==0 ){ + StatSample *pUpgrade = 0; + assert( pNew->anEq[pNew->iCol]>0 ); + + /* This sample is being added because the prefix that ends in column + ** iCol occurs many times in the table. However, if we have already + ** added a sample that shares this prefix, there is no need to add + ** this one. Instead, upgrade the priority of the highest priority + ** existing sample that shares this prefix. */ + for(i=p->nSample-1; i>=0; i--){ + StatSample *pOld = &p->a[i]; + if( pOld->anEq[pNew->iCol]==0 ){ + if( pOld->isPSample ) return; + assert( pOld->iCol>pNew->iCol ); + assert( sampleIsBetter(p, pNew, pOld) ); + if( pUpgrade==0 || sampleIsBetter(p, pOld, pUpgrade) ){ + pUpgrade = pOld; + } + } + } + if( pUpgrade ){ + pUpgrade->iCol = pNew->iCol; + pUpgrade->anEq[pUpgrade->iCol] = pNew->anEq[pUpgrade->iCol]; + goto find_new_min; + } + } + + /* If necessary, remove sample iMin to make room for the new sample. */ + if( p->nSample>=p->mxSample ){ + StatSample *pMin = &p->a[p->iMin]; + tRowcnt *anEq = pMin->anEq; + tRowcnt *anLt = pMin->anLt; + tRowcnt *anDLt = pMin->anDLt; + sampleClear(p->db, pMin); + memmove(pMin, &pMin[1], sizeof(p->a[0])*(p->nSample-p->iMin-1)); + pSample = &p->a[p->nSample-1]; + pSample->nRowid = 0; + pSample->anEq = anEq; + pSample->anDLt = anDLt; + pSample->anLt = anLt; + p->nSample = p->mxSample-1; + } + + /* The "rows less-than" for the rowid column must be greater than that + ** for the last sample in the p->a[] array. Otherwise, the samples would + ** be out of order. */ + assert( p->nSample==0 + || pNew->anLt[p->nCol-1] > p->a[p->nSample-1].anLt[p->nCol-1] ); + + /* Insert the new sample */ + pSample = &p->a[p->nSample]; + sampleCopy(p, pSample, pNew); + p->nSample++; + + /* Zero the first nEqZero entries in the anEq[] array. */ + memset(pSample->anEq, 0, sizeof(tRowcnt)*nEqZero); + +find_new_min: + if( p->nSample>=p->mxSample ){ + int iMin = -1; + for(i=0; imxSample; i++){ + if( p->a[i].isPSample ) continue; + if( iMin<0 || sampleIsBetter(p, &p->a[iMin], &p->a[i]) ){ + iMin = i; + } + } + assert( iMin>=0 ); + p->iMin = iMin; + } +} +#endif /* SQLITE_ENABLE_STAT4 */ + +#ifdef SQLITE_ENABLE_STAT4 +/* +** Field iChng of the index being scanned has changed. So at this point +** p->current contains a sample that reflects the previous row of the +** index. The value of anEq[iChng] and subsequent anEq[] elements are +** correct at this point. +*/ +static void samplePushPrevious(StatAccum *p, int iChng){ + int i; + + /* Check if any samples from the aBest[] array should be pushed + ** into IndexSample.a[] at this point. */ + for(i=(p->nCol-2); i>=iChng; i--){ + StatSample *pBest = &p->aBest[i]; + pBest->anEq[i] = p->current.anEq[i]; + if( p->nSamplemxSample || sampleIsBetter(p, pBest, &p->a[p->iMin]) ){ + sampleInsert(p, pBest, i); + } + } + + /* Check that no sample contains an anEq[] entry with an index of + ** p->nMaxEqZero or greater set to zero. */ + for(i=p->nSample-1; i>=0; i--){ + int j; + for(j=p->nMaxEqZero; jnCol; j++) assert( p->a[i].anEq[j]>0 ); + } + + /* Update the anEq[] fields of any samples already collected. */ + if( iChngnMaxEqZero ){ + for(i=p->nSample-1; i>=0; i--){ + int j; + for(j=iChng; jnCol; j++){ + if( p->a[i].anEq[j]==0 ) p->a[i].anEq[j] = p->current.anEq[j]; + } + } + p->nMaxEqZero = iChng; + } +} +#endif /* SQLITE_ENABLE_STAT4 */ + +/* +** Implementation of the stat_push SQL function: stat_push(P,C,R) +** Arguments: +** +** P Pointer to the StatAccum object created by stat_init() +** C Index of left-most column to differ from previous row +** R Rowid for the current row. Might be a key record for +** WITHOUT ROWID tables. +** +** The purpose of this routine is to collect statistical data and/or +** samples from the index being analyzed into the StatAccum object. +** The stat_get() SQL function will be used afterwards to +** retrieve the information gathered. +** +** This SQL function usually returns NULL, but might return an integer +** if it wants the byte-code to do special processing. +** +** The R parameter is only used for STAT4 +*/ +static void statPush( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int i; + + /* The three function arguments */ + StatAccum *p = (StatAccum*)sqlite3_value_blob(argv[0]); + int iChng = sqlite3_value_int(argv[1]); + + UNUSED_PARAMETER( argc ); + UNUSED_PARAMETER( context ); + assert( p->nCol>0 ); + assert( iChngnCol ); + + if( p->nRow==0 ){ + /* This is the first call to this function. Do initialization. */ + for(i=0; inCol; i++) p->current.anEq[i] = 1; + }else{ + /* Second and subsequent calls get processed here */ +#ifdef SQLITE_ENABLE_STAT4 + if( p->mxSample ) samplePushPrevious(p, iChng); +#endif + + /* Update anDLt[], anLt[] and anEq[] to reflect the values that apply + ** to the current row of the index. */ + for(i=0; icurrent.anEq[i]++; + } + for(i=iChng; inCol; i++){ + p->current.anDLt[i]++; +#ifdef SQLITE_ENABLE_STAT4 + if( p->mxSample ) p->current.anLt[i] += p->current.anEq[i]; +#endif + p->current.anEq[i] = 1; + } + } + + p->nRow++; +#ifdef SQLITE_ENABLE_STAT4 + if( p->mxSample ){ + tRowcnt nLt; + if( sqlite3_value_type(argv[2])==SQLITE_INTEGER ){ + sampleSetRowidInt64(p->db, &p->current, sqlite3_value_int64(argv[2])); + }else{ + sampleSetRowid(p->db, &p->current, sqlite3_value_bytes(argv[2]), + sqlite3_value_blob(argv[2])); + } + p->current.iHash = p->iPrn = p->iPrn*1103515245 + 12345; + + nLt = p->current.anLt[p->nCol-1]; + /* Check if this is to be a periodic sample. If so, add it. */ + if( (nLt/p->nPSample)!=(nLt+1)/p->nPSample ){ + p->current.isPSample = 1; + p->current.iCol = 0; + sampleInsert(p, &p->current, p->nCol-1); + p->current.isPSample = 0; + } + + /* Update the aBest[] array. */ + for(i=0; i<(p->nCol-1); i++){ + p->current.iCol = i; + if( i>=iChng || sampleIsBetterPost(p, &p->current, &p->aBest[i]) ){ + sampleCopy(p, &p->aBest[i], &p->current); + } + } + }else +#endif + if( p->nLimit && p->nRow>(tRowcnt)p->nLimit*(p->nSkipAhead+1) ){ + p->nSkipAhead++; + sqlite3_result_int(context, p->current.anDLt[0]>0); + } +} + +static const FuncDef statPushFuncdef = { + 2+IsStat4, /* nArg */ + SQLITE_UTF8, /* funcFlags */ + 0, /* pUserData */ + 0, /* pNext */ + statPush, /* xSFunc */ + 0, /* xFinalize */ + 0, 0, /* xValue, xInverse */ + "stat_push", /* zName */ + {0} +}; + +#define STAT_GET_STAT1 0 /* "stat" column of stat1 table */ +#define STAT_GET_ROWID 1 /* "rowid" column of stat[34] entry */ +#define STAT_GET_NEQ 2 /* "neq" column of stat[34] entry */ +#define STAT_GET_NLT 3 /* "nlt" column of stat[34] entry */ +#define STAT_GET_NDLT 4 /* "ndlt" column of stat[34] entry */ + +/* +** Implementation of the stat_get(P,J) SQL function. This routine is +** used to query statistical information that has been gathered into +** the StatAccum object by prior calls to stat_push(). The P parameter +** has type BLOB but it is really just a pointer to the StatAccum object. +** The content to returned is determined by the parameter J +** which is one of the STAT_GET_xxxx values defined above. +** +** The stat_get(P,J) function is not available to generic SQL. It is +** inserted as part of a manually constructed bytecode program. (See +** the callStatGet() routine below.) It is guaranteed that the P +** parameter will always be a pointer to a StatAccum object, never a +** NULL. +** +** If STAT4 is not enabled, then J is always +** STAT_GET_STAT1 and is hence omitted and this routine becomes +** a one-parameter function, stat_get(P), that always returns the +** stat1 table entry information. +*/ +static void statGet( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + StatAccum *p = (StatAccum*)sqlite3_value_blob(argv[0]); +#ifdef SQLITE_ENABLE_STAT4 + /* STAT4 has a parameter on this routine. */ + int eCall = sqlite3_value_int(argv[1]); + assert( argc==2 ); + assert( eCall==STAT_GET_STAT1 || eCall==STAT_GET_NEQ + || eCall==STAT_GET_ROWID || eCall==STAT_GET_NLT + || eCall==STAT_GET_NDLT + ); + assert( eCall==STAT_GET_STAT1 || p->mxSample ); + if( eCall==STAT_GET_STAT1 ) +#else + assert( argc==1 ); +#endif + { + /* Return the value to store in the "stat" column of the sqlite_stat1 + ** table for this index. + ** + ** The value is a string composed of a list of integers describing + ** the index. The first integer in the list is the total number of + ** entries in the index. There is one additional integer in the list + ** for each indexed column. This additional integer is an estimate of + ** the number of rows matched by a equality query on the index using + ** a key with the corresponding number of fields. In other words, + ** if the index is on columns (a,b) and the sqlite_stat1 value is + ** "100 10 2", then SQLite estimates that: + ** + ** * the index contains 100 rows, + ** * "WHERE a=?" matches 10 rows, and + ** * "WHERE a=? AND b=?" matches 2 rows. + ** + ** If D is the count of distinct values and K is the total number of + ** rows, then each estimate is usually computed as: + ** + ** I = (K+D-1)/D + ** + ** In other words, I is K/D rounded up to the next whole integer. + ** However, if I is between 1.0 and 1.1 (in other words if I is + ** close to 1.0 but just a little larger) then do not round up but + ** instead keep the I value at 1.0. + */ + sqlite3_str sStat; /* Text of the constructed "stat" line */ + int i; /* Loop counter */ + + sqlite3StrAccumInit(&sStat, 0, 0, 0, (p->nKeyCol+1)*100); + sqlite3_str_appendf(&sStat, "%llu", + p->nSkipAhead ? (u64)p->nEst : (u64)p->nRow); + for(i=0; inKeyCol; i++){ + u64 nDistinct = p->current.anDLt[i] + 1; + u64 iVal = (p->nRow + nDistinct - 1) / nDistinct; + if( iVal==2 && p->nRow*10 <= nDistinct*11 ) iVal = 1; + sqlite3_str_appendf(&sStat, " %llu", iVal); + assert( p->current.anEq[i] ); + } + sqlite3ResultStrAccum(context, &sStat); + } +#ifdef SQLITE_ENABLE_STAT4 + else if( eCall==STAT_GET_ROWID ){ + if( p->iGet<0 ){ + samplePushPrevious(p, 0); + p->iGet = 0; + } + if( p->iGetnSample ){ + StatSample *pS = p->a + p->iGet; + if( pS->nRowid==0 ){ + sqlite3_result_int64(context, pS->u.iRowid); + }else{ + sqlite3_result_blob(context, pS->u.aRowid, pS->nRowid, + SQLITE_TRANSIENT); + } + } + }else{ + tRowcnt *aCnt = 0; + sqlite3_str sStat; + int i; + + assert( p->iGetnSample ); + switch( eCall ){ + case STAT_GET_NEQ: aCnt = p->a[p->iGet].anEq; break; + case STAT_GET_NLT: aCnt = p->a[p->iGet].anLt; break; + default: { + aCnt = p->a[p->iGet].anDLt; + p->iGet++; + break; + } + } + sqlite3StrAccumInit(&sStat, 0, 0, 0, p->nCol*100); + for(i=0; inCol; i++){ + sqlite3_str_appendf(&sStat, "%llu ", (u64)aCnt[i]); + } + if( sStat.nChar ) sStat.nChar--; + sqlite3ResultStrAccum(context, &sStat); + } +#endif /* SQLITE_ENABLE_STAT4 */ +#ifndef SQLITE_DEBUG + UNUSED_PARAMETER( argc ); +#endif +} +static const FuncDef statGetFuncdef = { + 1+IsStat4, /* nArg */ + SQLITE_UTF8, /* funcFlags */ + 0, /* pUserData */ + 0, /* pNext */ + statGet, /* xSFunc */ + 0, /* xFinalize */ + 0, 0, /* xValue, xInverse */ + "stat_get", /* zName */ + {0} +}; + +static void callStatGet(Parse *pParse, int regStat, int iParam, int regOut){ +#ifdef SQLITE_ENABLE_STAT4 + sqlite3VdbeAddOp2(pParse->pVdbe, OP_Integer, iParam, regStat+1); +#elif SQLITE_DEBUG + assert( iParam==STAT_GET_STAT1 ); +#else + UNUSED_PARAMETER( iParam ); +#endif + assert( regOut!=regStat && regOut!=regStat+1 ); + sqlite3VdbeAddFunctionCall(pParse, 0, regStat, regOut, 1+IsStat4, + &statGetFuncdef, 0); +} + +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS +/* Add a comment to the most recent VDBE opcode that is the name +** of the k-th column of the pIdx index. +*/ +static void analyzeVdbeCommentIndexWithColumnName( + Vdbe *v, /* Prepared statement under construction */ + Index *pIdx, /* Index whose column is being loaded */ + int k /* Which column index */ +){ + int i; /* Index of column in the table */ + assert( k>=0 && knColumn ); + i = pIdx->aiColumn[k]; + if( NEVER(i==XN_ROWID) ){ + VdbeComment((v,"%s.rowid",pIdx->zName)); + }else if( i==XN_EXPR ){ + assert( pIdx->bHasExpr ); + VdbeComment((v,"%s.expr(%d)",pIdx->zName, k)); + }else{ + VdbeComment((v,"%s.%s", pIdx->zName, pIdx->pTable->aCol[i].zCnName)); + } +} +#else +# define analyzeVdbeCommentIndexWithColumnName(a,b,c) +#endif /* SQLITE_DEBUG */ + +/* +** Generate code to do an analysis of all indices associated with +** a single table. +*/ +static void analyzeOneTable( + Parse *pParse, /* Parser context */ + Table *pTab, /* Table whose indices are to be analyzed */ + Index *pOnlyIdx, /* If not NULL, only analyze this one index */ + int iStatCur, /* Index of VdbeCursor that writes the sqlite_stat1 table */ + int iMem, /* Available memory locations begin here */ + int iTab /* Next available cursor */ +){ + sqlite3 *db = pParse->db; /* Database handle */ + Index *pIdx; /* An index to being analyzed */ + int iIdxCur; /* Cursor open on index being analyzed */ + int iTabCur; /* Table cursor */ + Vdbe *v; /* The virtual machine being built up */ + int i; /* Loop counter */ + int jZeroRows = -1; /* Jump from here if number of rows is zero */ + int iDb; /* Index of database containing pTab */ + u8 needTableCnt = 1; /* True to count the table */ + int regNewRowid = iMem++; /* Rowid for the inserted record */ + int regStat = iMem++; /* Register to hold StatAccum object */ + int regChng = iMem++; /* Index of changed index field */ + int regRowid = iMem++; /* Rowid argument passed to stat_push() */ + int regTemp = iMem++; /* Temporary use register */ + int regTemp2 = iMem++; /* Second temporary use register */ + int regTabname = iMem++; /* Register containing table name */ + int regIdxname = iMem++; /* Register containing index name */ + int regStat1 = iMem++; /* Value for the stat column of sqlite_stat1 */ + int regPrev = iMem; /* MUST BE LAST (see below) */ +#ifdef SQLITE_ENABLE_STAT4 + int doOnce = 1; /* Flag for a one-time computation */ +#endif +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + Table *pStat1 = 0; +#endif + + sqlite3TouchRegister(pParse, iMem); + assert( sqlite3NoTempsInRange(pParse, regNewRowid, iMem) ); + v = sqlite3GetVdbe(pParse); + if( v==0 || NEVER(pTab==0) ){ + return; + } + if( !IsOrdinaryTable(pTab) ){ + /* Do not gather statistics on views or virtual tables */ + return; + } + if( sqlite3_strlike("sqlite\\_%", pTab->zName, '\\')==0 ){ + /* Do not gather statistics on system tables */ + return; + } + assert( sqlite3BtreeHoldsAllMutexes(db) ); + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( iDb>=0 ); + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); +#ifndef SQLITE_OMIT_AUTHORIZATION + if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0, + db->aDb[iDb].zDbSName ) ){ + return; + } +#endif + +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + if( db->xPreUpdateCallback ){ + pStat1 = (Table*)sqlite3DbMallocZero(db, sizeof(Table) + 13); + if( pStat1==0 ) return; + pStat1->zName = (char*)&pStat1[1]; + memcpy(pStat1->zName, "sqlite_stat1", 13); + pStat1->nCol = 3; + pStat1->iPKey = -1; + sqlite3VdbeAddOp4(pParse->pVdbe, OP_Noop, 0, 0, 0,(char*)pStat1,P4_DYNAMIC); + } +#endif + + /* Establish a read-lock on the table at the shared-cache level. + ** Open a read-only cursor on the table. Also allocate a cursor number + ** to use for scanning indexes (iIdxCur). No index cursor is opened at + ** this time though. */ + sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName); + iTabCur = iTab++; + iIdxCur = iTab++; + pParse->nTab = MAX(pParse->nTab, iTab); + sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead); + sqlite3VdbeLoadString(v, regTabname, pTab->zName); + + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + int nCol; /* Number of columns in pIdx. "N" */ + int addrRewind; /* Address of "OP_Rewind iIdxCur" */ + int addrNextRow; /* Address of "next_row:" */ + const char *zIdxName; /* Name of the index */ + int nColTest; /* Number of columns to test for changes */ + + if( pOnlyIdx && pOnlyIdx!=pIdx ) continue; + if( pIdx->pPartIdxWhere==0 ) needTableCnt = 0; + if( !HasRowid(pTab) && IsPrimaryKeyIndex(pIdx) ){ + nCol = pIdx->nKeyCol; + zIdxName = pTab->zName; + nColTest = nCol - 1; + }else{ + nCol = pIdx->nColumn; + zIdxName = pIdx->zName; + nColTest = pIdx->uniqNotNull ? pIdx->nKeyCol-1 : nCol-1; + } + + /* Populate the register containing the index name. */ + sqlite3VdbeLoadString(v, regIdxname, zIdxName); + VdbeComment((v, "Analysis for %s.%s", pTab->zName, zIdxName)); + + /* + ** Pseudo-code for loop that calls stat_push(): + ** + ** Rewind csr + ** if eof(csr) goto end_of_scan; + ** regChng = 0 + ** goto chng_addr_0; + ** + ** next_row: + ** regChng = 0 + ** if( idx(0) != regPrev(0) ) goto chng_addr_0 + ** regChng = 1 + ** if( idx(1) != regPrev(1) ) goto chng_addr_1 + ** ... + ** regChng = N + ** goto chng_addr_N + ** + ** chng_addr_0: + ** regPrev(0) = idx(0) + ** chng_addr_1: + ** regPrev(1) = idx(1) + ** ... + ** + ** endDistinctTest: + ** regRowid = idx(rowid) + ** stat_push(P, regChng, regRowid) + ** Next csr + ** if !eof(csr) goto next_row; + ** + ** end_of_scan: + */ + + /* Make sure there are enough memory cells allocated to accommodate + ** the regPrev array and a trailing rowid (the rowid slot is required + ** when building a record to insert into the sample column of + ** the sqlite_stat4 table. */ + sqlite3TouchRegister(pParse, regPrev+nColTest); + + /* Open a read-only cursor on the index being analyzed. */ + assert( iDb==sqlite3SchemaToIndex(db, pIdx->pSchema) ); + sqlite3VdbeAddOp3(v, OP_OpenRead, iIdxCur, pIdx->tnum, iDb); + sqlite3VdbeSetP4KeyInfo(pParse, pIdx); + VdbeComment((v, "%s", pIdx->zName)); + + /* Invoke the stat_init() function. The arguments are: + ** + ** (1) the number of columns in the index including the rowid + ** (or for a WITHOUT ROWID table, the number of PK columns), + ** (2) the number of columns in the key without the rowid/pk + ** (3) estimated number of rows in the index, + */ + sqlite3VdbeAddOp2(v, OP_Integer, nCol, regStat+1); + assert( regRowid==regStat+2 ); + sqlite3VdbeAddOp2(v, OP_Integer, pIdx->nKeyCol, regRowid); +#ifdef SQLITE_ENABLE_STAT4 + if( OptimizationEnabled(db, SQLITE_Stat4) ){ + sqlite3VdbeAddOp2(v, OP_Count, iIdxCur, regTemp); + addrRewind = sqlite3VdbeAddOp1(v, OP_Rewind, iIdxCur); + VdbeCoverage(v); + }else +#endif + { + addrRewind = sqlite3VdbeAddOp1(v, OP_Rewind, iIdxCur); + VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_Count, iIdxCur, regTemp, 1); + } + assert( regTemp2==regStat+4 ); + sqlite3VdbeAddOp2(v, OP_Integer, db->nAnalysisLimit, regTemp2); + sqlite3VdbeAddFunctionCall(pParse, 0, regStat+1, regStat, 4, + &statInitFuncdef, 0); + + /* Implementation of the following: + ** + ** Rewind csr + ** if eof(csr) goto end_of_scan; + ** regChng = 0 + ** goto next_push_0; + ** + */ + sqlite3VdbeAddOp2(v, OP_Integer, 0, regChng); + addrNextRow = sqlite3VdbeCurrentAddr(v); + + if( nColTest>0 ){ + int endDistinctTest = sqlite3VdbeMakeLabel(pParse); + int *aGotoChng; /* Array of jump instruction addresses */ + aGotoChng = sqlite3DbMallocRawNN(db, sizeof(int)*nColTest); + if( aGotoChng==0 ) continue; + + /* + ** next_row: + ** regChng = 0 + ** if( idx(0) != regPrev(0) ) goto chng_addr_0 + ** regChng = 1 + ** if( idx(1) != regPrev(1) ) goto chng_addr_1 + ** ... + ** regChng = N + ** goto endDistinctTest + */ + sqlite3VdbeAddOp0(v, OP_Goto); + addrNextRow = sqlite3VdbeCurrentAddr(v); + if( nColTest==1 && pIdx->nKeyCol==1 && IsUniqueIndex(pIdx) ){ + /* For a single-column UNIQUE index, once we have found a non-NULL + ** row, we know that all the rest will be distinct, so skip + ** subsequent distinctness tests. */ + sqlite3VdbeAddOp2(v, OP_NotNull, regPrev, endDistinctTest); + VdbeCoverage(v); + } + for(i=0; iazColl[i]); + sqlite3VdbeAddOp2(v, OP_Integer, i, regChng); + sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, regTemp); + analyzeVdbeCommentIndexWithColumnName(v,pIdx,i); + aGotoChng[i] = + sqlite3VdbeAddOp4(v, OP_Ne, regTemp, 0, regPrev+i, pColl, P4_COLLSEQ); + sqlite3VdbeChangeP5(v, SQLITE_NULLEQ); + VdbeCoverage(v); + } + sqlite3VdbeAddOp2(v, OP_Integer, nColTest, regChng); + sqlite3VdbeGoto(v, endDistinctTest); + + + /* + ** chng_addr_0: + ** regPrev(0) = idx(0) + ** chng_addr_1: + ** regPrev(1) = idx(1) + ** ... + */ + sqlite3VdbeJumpHere(v, addrNextRow-1); + for(i=0; ipTable); + int j, k, regKey; + regKey = sqlite3GetTempRange(pParse, pPk->nKeyCol); + for(j=0; jnKeyCol; j++){ + k = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[j]); + assert( k>=0 && knColumn ); + sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, k, regKey+j); + analyzeVdbeCommentIndexWithColumnName(v,pIdx,k); + } + sqlite3VdbeAddOp3(v, OP_MakeRecord, regKey, pPk->nKeyCol, regRowid); + sqlite3ReleaseTempRange(pParse, regKey, pPk->nKeyCol); + } + } +#endif + assert( regChng==(regStat+1) ); + { + sqlite3VdbeAddFunctionCall(pParse, 1, regStat, regTemp, 2+IsStat4, + &statPushFuncdef, 0); + if( db->nAnalysisLimit ){ + int j1, j2, j3; + j1 = sqlite3VdbeAddOp1(v, OP_IsNull, regTemp); VdbeCoverage(v); + j2 = sqlite3VdbeAddOp1(v, OP_If, regTemp); VdbeCoverage(v); + j3 = sqlite3VdbeAddOp4Int(v, OP_SeekGT, iIdxCur, 0, regPrev, 1); + VdbeCoverage(v); + sqlite3VdbeJumpHere(v, j1); + sqlite3VdbeAddOp2(v, OP_Next, iIdxCur, addrNextRow); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, j2); + sqlite3VdbeJumpHere(v, j3); + }else{ + sqlite3VdbeAddOp2(v, OP_Next, iIdxCur, addrNextRow); VdbeCoverage(v); + } + } + + /* Add the entry to the stat1 table. */ + callStatGet(pParse, regStat, STAT_GET_STAT1, regStat1); + assert( "BBB"[0]==SQLITE_AFF_TEXT ); + sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regTemp, "BBB", 0); + sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur, regNewRowid); + sqlite3VdbeAddOp3(v, OP_Insert, iStatCur, regTemp, regNewRowid); +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + sqlite3VdbeChangeP4(v, -1, (char*)pStat1, P4_TABLE); +#endif + sqlite3VdbeChangeP5(v, OPFLAG_APPEND); + + /* Add the entries to the stat4 table. */ +#ifdef SQLITE_ENABLE_STAT4 + if( OptimizationEnabled(db, SQLITE_Stat4) && db->nAnalysisLimit==0 ){ + int regEq = regStat1; + int regLt = regStat1+1; + int regDLt = regStat1+2; + int regSample = regStat1+3; + int regCol = regStat1+4; + int regSampleRowid = regCol + nCol; + int addrNext; + int addrIsNull; + u8 seekOp = HasRowid(pTab) ? OP_NotExists : OP_NotFound; + + if( doOnce ){ + int mxCol = nCol; + Index *pX; + + /* Compute the maximum number of columns in any index */ + for(pX=pTab->pIndex; pX; pX=pX->pNext){ + int nColX; /* Number of columns in pX */ + if( !HasRowid(pTab) && IsPrimaryKeyIndex(pX) ){ + nColX = pX->nKeyCol; + }else{ + nColX = pX->nColumn; + } + if( nColX>mxCol ) mxCol = nColX; + } + + /* Allocate space to compute results for the largest index */ + sqlite3TouchRegister(pParse, regCol+mxCol); + doOnce = 0; +#ifdef SQLITE_DEBUG + /* Verify that the call to sqlite3ClearTempRegCache() below + ** really is needed. + ** https://sqlite.org/forum/forumpost/83cb4a95a0 (2023-03-25) + */ + testcase( !sqlite3NoTempsInRange(pParse, regEq, regCol+mxCol) ); +#endif + sqlite3ClearTempRegCache(pParse); /* tag-20230325-1 */ + assert( sqlite3NoTempsInRange(pParse, regEq, regCol+mxCol) ); + } + assert( sqlite3NoTempsInRange(pParse, regEq, regCol+nCol) ); + + addrNext = sqlite3VdbeCurrentAddr(v); + callStatGet(pParse, regStat, STAT_GET_ROWID, regSampleRowid); + addrIsNull = sqlite3VdbeAddOp1(v, OP_IsNull, regSampleRowid); + VdbeCoverage(v); + callStatGet(pParse, regStat, STAT_GET_NEQ, regEq); + callStatGet(pParse, regStat, STAT_GET_NLT, regLt); + callStatGet(pParse, regStat, STAT_GET_NDLT, regDLt); + sqlite3VdbeAddOp4Int(v, seekOp, iTabCur, addrNext, regSampleRowid, 0); + VdbeCoverage(v); + for(i=0; izName)); + sqlite3VdbeAddOp2(v, OP_Count, iTabCur, regStat1); + jZeroRows = sqlite3VdbeAddOp1(v, OP_IfNot, regStat1); VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_Null, 0, regIdxname); + assert( "BBB"[0]==SQLITE_AFF_TEXT ); + sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regTemp, "BBB", 0); + sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur, regNewRowid); + sqlite3VdbeAddOp3(v, OP_Insert, iStatCur, regTemp, regNewRowid); + sqlite3VdbeChangeP5(v, OPFLAG_APPEND); +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + sqlite3VdbeChangeP4(v, -1, (char*)pStat1, P4_TABLE); +#endif + sqlite3VdbeJumpHere(v, jZeroRows); + } +} + + +/* +** Generate code that will cause the most recent index analysis to +** be loaded into internal hash tables where is can be used. +*/ +static void loadAnalysis(Parse *pParse, int iDb){ + Vdbe *v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3VdbeAddOp1(v, OP_LoadAnalysis, iDb); + } +} + +/* +** Generate code that will do an analysis of an entire database +*/ +static void analyzeDatabase(Parse *pParse, int iDb){ + sqlite3 *db = pParse->db; + Schema *pSchema = db->aDb[iDb].pSchema; /* Schema of database iDb */ + HashElem *k; + int iStatCur; + int iMem; + int iTab; + + sqlite3BeginWriteOperation(pParse, 0, iDb); + iStatCur = pParse->nTab; + pParse->nTab += 3; + openStatTable(pParse, iDb, iStatCur, 0, 0); + iMem = pParse->nMem+1; + iTab = pParse->nTab; + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + for(k=sqliteHashFirst(&pSchema->tblHash); k; k=sqliteHashNext(k)){ + Table *pTab = (Table*)sqliteHashData(k); + analyzeOneTable(pParse, pTab, 0, iStatCur, iMem, iTab); +#ifdef SQLITE_ENABLE_STAT4 + iMem = sqlite3FirstAvailableRegister(pParse, iMem); +#else + assert( iMem==sqlite3FirstAvailableRegister(pParse,iMem) ); +#endif + } + loadAnalysis(pParse, iDb); +} + +/* +** Generate code that will do an analysis of a single table in +** a database. If pOnlyIdx is not NULL then it is a single index +** in pTab that should be analyzed. +*/ +static void analyzeTable(Parse *pParse, Table *pTab, Index *pOnlyIdx){ + int iDb; + int iStatCur; + + assert( pTab!=0 ); + assert( sqlite3BtreeHoldsAllMutexes(pParse->db) ); + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + sqlite3BeginWriteOperation(pParse, 0, iDb); + iStatCur = pParse->nTab; + pParse->nTab += 3; + if( pOnlyIdx ){ + openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx"); + }else{ + openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl"); + } + analyzeOneTable(pParse, pTab, pOnlyIdx, iStatCur,pParse->nMem+1,pParse->nTab); + loadAnalysis(pParse, iDb); +} + +/* +** Generate code for the ANALYZE command. The parser calls this routine +** when it recognizes an ANALYZE command. +** +** ANALYZE -- 1 +** ANALYZE -- 2 +** ANALYZE ?.? -- 3 +** +** Form 1 causes all indices in all attached databases to be analyzed. +** Form 2 analyzes all indices the single database named. +** Form 3 analyzes all indices associated with the named table. +*/ +SQLITE_PRIVATE void sqlite3Analyze(Parse *pParse, Token *pName1, Token *pName2){ + sqlite3 *db = pParse->db; + int iDb; + int i; + char *z, *zDb; + Table *pTab; + Index *pIdx; + Token *pTableName; + Vdbe *v; + + /* Read the database schema. If an error occurs, leave an error message + ** and code in pParse and return NULL. */ + assert( sqlite3BtreeHoldsAllMutexes(pParse->db) ); + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + return; + } + + assert( pName2!=0 || pName1==0 ); + if( pName1==0 ){ + /* Form 1: Analyze everything */ + for(i=0; inDb; i++){ + if( i==1 ) continue; /* Do not analyze the TEMP database */ + analyzeDatabase(pParse, i); + } + }else if( pName2->n==0 && (iDb = sqlite3FindDb(db, pName1))>=0 ){ + /* Analyze the schema named as the argument */ + analyzeDatabase(pParse, iDb); + }else{ + /* Form 3: Analyze the table or index named as an argument */ + iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName); + if( iDb>=0 ){ + zDb = pName2->n ? db->aDb[iDb].zDbSName : 0; + z = sqlite3NameFromToken(db, pTableName); + if( z ){ + if( (pIdx = sqlite3FindIndex(db, z, zDb))!=0 ){ + analyzeTable(pParse, pIdx->pTable, pIdx); + }else if( (pTab = sqlite3LocateTable(pParse, 0, z, zDb))!=0 ){ + analyzeTable(pParse, pTab, 0); + } + sqlite3DbFree(db, z); + } + } + } + if( db->nSqlExec==0 && (v = sqlite3GetVdbe(pParse))!=0 ){ + sqlite3VdbeAddOp0(v, OP_Expire); + } +} + +/* +** Used to pass information from the analyzer reader through to the +** callback routine. +*/ +typedef struct analysisInfo analysisInfo; +struct analysisInfo { + sqlite3 *db; + const char *zDatabase; +}; + +/* +** The first argument points to a nul-terminated string containing a +** list of space separated integers. Read the first nOut of these into +** the array aOut[]. +*/ +static void decodeIntArray( + char *zIntArray, /* String containing int array to decode */ + int nOut, /* Number of slots in aOut[] */ + tRowcnt *aOut, /* Store integers here */ + LogEst *aLog, /* Or, if aOut==0, here */ + Index *pIndex /* Handle extra flags for this index, if not NULL */ +){ + char *z = zIntArray; + int c; + int i; + tRowcnt v; + +#ifdef SQLITE_ENABLE_STAT4 + if( z==0 ) z = ""; +#else + assert( z!=0 ); +#endif + for(i=0; *z && i='0' && c<='9' ){ + v = v*10 + c - '0'; + z++; + } +#ifdef SQLITE_ENABLE_STAT4 + if( aOut ) aOut[i] = v; + if( aLog ) aLog[i] = sqlite3LogEst(v); +#else + assert( aOut==0 ); + UNUSED_PARAMETER(aOut); + assert( aLog!=0 ); + aLog[i] = sqlite3LogEst(v); +#endif + if( *z==' ' ) z++; + } +#ifndef SQLITE_ENABLE_STAT4 + assert( pIndex!=0 ); { +#else + if( pIndex ){ +#endif + pIndex->bUnordered = 0; + pIndex->noSkipScan = 0; + while( z[0] ){ + if( sqlite3_strglob("unordered*", z)==0 ){ + pIndex->bUnordered = 1; + }else if( sqlite3_strglob("sz=[0-9]*", z)==0 ){ + int sz = sqlite3Atoi(z+3); + if( sz<2 ) sz = 2; + pIndex->szIdxRow = sqlite3LogEst(sz); + }else if( sqlite3_strglob("noskipscan*", z)==0 ){ + pIndex->noSkipScan = 1; + } +#ifdef SQLITE_ENABLE_COSTMULT + else if( sqlite3_strglob("costmult=[0-9]*",z)==0 ){ + pIndex->pTable->costMult = sqlite3LogEst(sqlite3Atoi(z+9)); + } +#endif + while( z[0]!=0 && z[0]!=' ' ) z++; + while( z[0]==' ' ) z++; + } + } +} + +/* +** This callback is invoked once for each index when reading the +** sqlite_stat1 table. +** +** argv[0] = name of the table +** argv[1] = name of the index (might be NULL) +** argv[2] = results of analysis - on integer for each column +** +** Entries for which argv[1]==NULL simply record the number of rows in +** the table. +*/ +static int analysisLoader(void *pData, int argc, char **argv, char **NotUsed){ + analysisInfo *pInfo = (analysisInfo*)pData; + Index *pIndex; + Table *pTable; + const char *z; + + assert( argc==3 ); + UNUSED_PARAMETER2(NotUsed, argc); + + if( argv==0 || argv[0]==0 || argv[2]==0 ){ + return 0; + } + pTable = sqlite3FindTable(pInfo->db, argv[0], pInfo->zDatabase); + if( pTable==0 ){ + return 0; + } + if( argv[1]==0 ){ + pIndex = 0; + }else if( sqlite3_stricmp(argv[0],argv[1])==0 ){ + pIndex = sqlite3PrimaryKeyIndex(pTable); + }else{ + pIndex = sqlite3FindIndex(pInfo->db, argv[1], pInfo->zDatabase); + } + z = argv[2]; + + if( pIndex ){ + tRowcnt *aiRowEst = 0; + int nCol = pIndex->nKeyCol+1; +#ifdef SQLITE_ENABLE_STAT4 + /* Index.aiRowEst may already be set here if there are duplicate + ** sqlite_stat1 entries for this index. In that case just clobber + ** the old data with the new instead of allocating a new array. */ + if( pIndex->aiRowEst==0 ){ + pIndex->aiRowEst = (tRowcnt*)sqlite3MallocZero(sizeof(tRowcnt) * nCol); + if( pIndex->aiRowEst==0 ) sqlite3OomFault(pInfo->db); + } + aiRowEst = pIndex->aiRowEst; +#endif + pIndex->bUnordered = 0; + decodeIntArray((char*)z, nCol, aiRowEst, pIndex->aiRowLogEst, pIndex); + pIndex->hasStat1 = 1; + if( pIndex->pPartIdxWhere==0 ){ + pTable->nRowLogEst = pIndex->aiRowLogEst[0]; + pTable->tabFlags |= TF_HasStat1; + } + }else{ + Index fakeIdx; + fakeIdx.szIdxRow = pTable->szTabRow; +#ifdef SQLITE_ENABLE_COSTMULT + fakeIdx.pTable = pTable; +#endif + decodeIntArray((char*)z, 1, 0, &pTable->nRowLogEst, &fakeIdx); + pTable->szTabRow = fakeIdx.szIdxRow; + pTable->tabFlags |= TF_HasStat1; + } + + return 0; +} + +/* +** If the Index.aSample variable is not NULL, delete the aSample[] array +** and its contents. +*/ +SQLITE_PRIVATE void sqlite3DeleteIndexSamples(sqlite3 *db, Index *pIdx){ + assert( db!=0 ); + assert( pIdx!=0 ); +#ifdef SQLITE_ENABLE_STAT4 + if( pIdx->aSample ){ + int j; + for(j=0; jnSample; j++){ + IndexSample *p = &pIdx->aSample[j]; + sqlite3DbFree(db, p->p); + } + sqlite3DbFree(db, pIdx->aSample); + } + if( db->pnBytesFreed==0 ){ + pIdx->nSample = 0; + pIdx->aSample = 0; + } +#else + UNUSED_PARAMETER(db); + UNUSED_PARAMETER(pIdx); +#endif /* SQLITE_ENABLE_STAT4 */ +} + +#ifdef SQLITE_ENABLE_STAT4 +/* +** Populate the pIdx->aAvgEq[] array based on the samples currently +** stored in pIdx->aSample[]. +*/ +static void initAvgEq(Index *pIdx){ + if( pIdx ){ + IndexSample *aSample = pIdx->aSample; + IndexSample *pFinal = &aSample[pIdx->nSample-1]; + int iCol; + int nCol = 1; + if( pIdx->nSampleCol>1 ){ + /* If this is stat4 data, then calculate aAvgEq[] values for all + ** sample columns except the last. The last is always set to 1, as + ** once the trailing PK fields are considered all index keys are + ** unique. */ + nCol = pIdx->nSampleCol-1; + pIdx->aAvgEq[nCol] = 1; + } + for(iCol=0; iColnSample; + int i; /* Used to iterate through samples */ + tRowcnt sumEq = 0; /* Sum of the nEq values */ + tRowcnt avgEq = 0; + tRowcnt nRow; /* Number of rows in index */ + i64 nSum100 = 0; /* Number of terms contributing to sumEq */ + i64 nDist100; /* Number of distinct values in index */ + + if( !pIdx->aiRowEst || iCol>=pIdx->nKeyCol || pIdx->aiRowEst[iCol+1]==0 ){ + nRow = pFinal->anLt[iCol]; + nDist100 = (i64)100 * pFinal->anDLt[iCol]; + nSample--; + }else{ + nRow = pIdx->aiRowEst[0]; + nDist100 = ((i64)100 * pIdx->aiRowEst[0]) / pIdx->aiRowEst[iCol+1]; + } + pIdx->nRowEst0 = nRow; + + /* Set nSum to the number of distinct (iCol+1) field prefixes that + ** occur in the stat4 table for this index. Set sumEq to the sum of + ** the nEq values for column iCol for the same set (adding the value + ** only once where there exist duplicate prefixes). */ + for(i=0; inSample-1) + || aSample[i].anDLt[iCol]!=aSample[i+1].anDLt[iCol] + ){ + sumEq += aSample[i].anEq[iCol]; + nSum100 += 100; + } + } + + if( nDist100>nSum100 && sumEqaAvgEq[iCol] = avgEq; + } + } +} + +/* +** Look up an index by name. Or, if the name of a WITHOUT ROWID table +** is supplied instead, find the PRIMARY KEY index for that table. +*/ +static Index *findIndexOrPrimaryKey( + sqlite3 *db, + const char *zName, + const char *zDb +){ + Index *pIdx = sqlite3FindIndex(db, zName, zDb); + if( pIdx==0 ){ + Table *pTab = sqlite3FindTable(db, zName, zDb); + if( pTab && !HasRowid(pTab) ) pIdx = sqlite3PrimaryKeyIndex(pTab); + } + return pIdx; +} + +/* +** Load the content from either the sqlite_stat4 +** into the relevant Index.aSample[] arrays. +** +** Arguments zSql1 and zSql2 must point to SQL statements that return +** data equivalent to the following: +** +** zSql1: SELECT idx,count(*) FROM %Q.sqlite_stat4 GROUP BY idx +** zSql2: SELECT idx,neq,nlt,ndlt,sample FROM %Q.sqlite_stat4 +** +** where %Q is replaced with the database name before the SQL is executed. +*/ +static int loadStatTbl( + sqlite3 *db, /* Database handle */ + const char *zSql1, /* SQL statement 1 (see above) */ + const char *zSql2, /* SQL statement 2 (see above) */ + const char *zDb /* Database name (e.g. "main") */ +){ + int rc; /* Result codes from subroutines */ + sqlite3_stmt *pStmt = 0; /* An SQL statement being run */ + char *zSql; /* Text of the SQL statement */ + Index *pPrevIdx = 0; /* Previous index in the loop */ + IndexSample *pSample; /* A slot in pIdx->aSample[] */ + + assert( db->lookaside.bDisable ); + zSql = sqlite3MPrintf(db, zSql1, zDb); + if( !zSql ){ + return SQLITE_NOMEM_BKPT; + } + rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0); + sqlite3DbFree(db, zSql); + if( rc ) return rc; + + while( sqlite3_step(pStmt)==SQLITE_ROW ){ + int nIdxCol = 1; /* Number of columns in stat4 records */ + + char *zIndex; /* Index name */ + Index *pIdx; /* Pointer to the index object */ + int nSample; /* Number of samples */ + int nByte; /* Bytes of space required */ + int i; /* Bytes of space required */ + tRowcnt *pSpace; + + zIndex = (char *)sqlite3_column_text(pStmt, 0); + if( zIndex==0 ) continue; + nSample = sqlite3_column_int(pStmt, 1); + pIdx = findIndexOrPrimaryKey(db, zIndex, zDb); + assert( pIdx==0 || pIdx->nSample==0 ); + if( pIdx==0 ) continue; + if( pIdx->aSample!=0 ){ + /* The same index appears in sqlite_stat4 under multiple names */ + continue; + } + assert( !HasRowid(pIdx->pTable) || pIdx->nColumn==pIdx->nKeyCol+1 ); + if( !HasRowid(pIdx->pTable) && IsPrimaryKeyIndex(pIdx) ){ + nIdxCol = pIdx->nKeyCol; + }else{ + nIdxCol = pIdx->nColumn; + } + pIdx->nSampleCol = nIdxCol; + pIdx->mxSample = nSample; + nByte = sizeof(IndexSample) * nSample; + nByte += sizeof(tRowcnt) * nIdxCol * 3 * nSample; + nByte += nIdxCol * sizeof(tRowcnt); /* Space for Index.aAvgEq[] */ + + pIdx->aSample = sqlite3DbMallocZero(db, nByte); + if( pIdx->aSample==0 ){ + sqlite3_finalize(pStmt); + return SQLITE_NOMEM_BKPT; + } + pSpace = (tRowcnt*)&pIdx->aSample[nSample]; + pIdx->aAvgEq = pSpace; pSpace += nIdxCol; + pIdx->pTable->tabFlags |= TF_HasStat4; + for(i=0; iaSample[i].anEq = pSpace; pSpace += nIdxCol; + pIdx->aSample[i].anLt = pSpace; pSpace += nIdxCol; + pIdx->aSample[i].anDLt = pSpace; pSpace += nIdxCol; + } + assert( ((u8*)pSpace)-nByte==(u8*)(pIdx->aSample) ); + } + rc = sqlite3_finalize(pStmt); + if( rc ) return rc; + + zSql = sqlite3MPrintf(db, zSql2, zDb); + if( !zSql ){ + return SQLITE_NOMEM_BKPT; + } + rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0); + sqlite3DbFree(db, zSql); + if( rc ) return rc; + + while( sqlite3_step(pStmt)==SQLITE_ROW ){ + char *zIndex; /* Index name */ + Index *pIdx; /* Pointer to the index object */ + int nCol = 1; /* Number of columns in index */ + + zIndex = (char *)sqlite3_column_text(pStmt, 0); + if( zIndex==0 ) continue; + pIdx = findIndexOrPrimaryKey(db, zIndex, zDb); + if( pIdx==0 ) continue; + if( pIdx->nSample>=pIdx->mxSample ){ + /* Too many slots used because the same index appears in + ** sqlite_stat4 using multiple names */ + continue; + } + /* This next condition is true if data has already been loaded from + ** the sqlite_stat4 table. */ + nCol = pIdx->nSampleCol; + if( pIdx!=pPrevIdx ){ + initAvgEq(pPrevIdx); + pPrevIdx = pIdx; + } + pSample = &pIdx->aSample[pIdx->nSample]; + decodeIntArray((char*)sqlite3_column_text(pStmt,1),nCol,pSample->anEq,0,0); + decodeIntArray((char*)sqlite3_column_text(pStmt,2),nCol,pSample->anLt,0,0); + decodeIntArray((char*)sqlite3_column_text(pStmt,3),nCol,pSample->anDLt,0,0); + + /* Take a copy of the sample. Add two 0x00 bytes the end of the buffer. + ** This is in case the sample record is corrupted. In that case, the + ** sqlite3VdbeRecordCompare() may read up to two varints past the + ** end of the allocated buffer before it realizes it is dealing with + ** a corrupt record. Adding the two 0x00 bytes prevents this from causing + ** a buffer overread. */ + pSample->n = sqlite3_column_bytes(pStmt, 4); + pSample->p = sqlite3DbMallocZero(db, pSample->n + 2); + if( pSample->p==0 ){ + sqlite3_finalize(pStmt); + return SQLITE_NOMEM_BKPT; + } + if( pSample->n ){ + memcpy(pSample->p, sqlite3_column_blob(pStmt, 4), pSample->n); + } + pIdx->nSample++; + } + rc = sqlite3_finalize(pStmt); + if( rc==SQLITE_OK ) initAvgEq(pPrevIdx); + return rc; +} + +/* +** Load content from the sqlite_stat4 table into +** the Index.aSample[] arrays of all indices. +*/ +static int loadStat4(sqlite3 *db, const char *zDb){ + int rc = SQLITE_OK; /* Result codes from subroutines */ + const Table *pStat4; + + assert( db->lookaside.bDisable ); + if( OptimizationEnabled(db, SQLITE_Stat4) + && (pStat4 = sqlite3FindTable(db, "sqlite_stat4", zDb))!=0 + && IsOrdinaryTable(pStat4) + ){ + rc = loadStatTbl(db, + "SELECT idx,count(*) FROM %Q.sqlite_stat4 GROUP BY idx COLLATE nocase", + "SELECT idx,neq,nlt,ndlt,sample FROM %Q.sqlite_stat4", + zDb + ); + } + return rc; +} +#endif /* SQLITE_ENABLE_STAT4 */ + +/* +** Load the content of the sqlite_stat1 and sqlite_stat4 tables. The +** contents of sqlite_stat1 are used to populate the Index.aiRowEst[] +** arrays. The contents of sqlite_stat4 are used to populate the +** Index.aSample[] arrays. +** +** If the sqlite_stat1 table is not present in the database, SQLITE_ERROR +** is returned. In this case, even if SQLITE_ENABLE_STAT4 was defined +** during compilation and the sqlite_stat4 table is present, no data is +** read from it. +** +** If SQLITE_ENABLE_STAT4 was defined during compilation and the +** sqlite_stat4 table is not present in the database, SQLITE_ERROR is +** returned. However, in this case, data is read from the sqlite_stat1 +** table (if it is present) before returning. +** +** If an OOM error occurs, this function always sets db->mallocFailed. +** This means if the caller does not care about other errors, the return +** code may be ignored. +*/ +SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3 *db, int iDb){ + analysisInfo sInfo; + HashElem *i; + char *zSql; + int rc = SQLITE_OK; + Schema *pSchema = db->aDb[iDb].pSchema; + const Table *pStat1; + + assert( iDb>=0 && iDbnDb ); + assert( db->aDb[iDb].pBt!=0 ); + + /* Clear any prior statistics */ + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + for(i=sqliteHashFirst(&pSchema->tblHash); i; i=sqliteHashNext(i)){ + Table *pTab = sqliteHashData(i); + pTab->tabFlags &= ~TF_HasStat1; + } + for(i=sqliteHashFirst(&pSchema->idxHash); i; i=sqliteHashNext(i)){ + Index *pIdx = sqliteHashData(i); + pIdx->hasStat1 = 0; +#ifdef SQLITE_ENABLE_STAT4 + sqlite3DeleteIndexSamples(db, pIdx); + pIdx->aSample = 0; +#endif + } + + /* Load new statistics out of the sqlite_stat1 table */ + sInfo.db = db; + sInfo.zDatabase = db->aDb[iDb].zDbSName; + if( (pStat1 = sqlite3FindTable(db, "sqlite_stat1", sInfo.zDatabase)) + && IsOrdinaryTable(pStat1) + ){ + zSql = sqlite3MPrintf(db, + "SELECT tbl,idx,stat FROM %Q.sqlite_stat1", sInfo.zDatabase); + if( zSql==0 ){ + rc = SQLITE_NOMEM_BKPT; + }else{ + rc = sqlite3_exec(db, zSql, analysisLoader, &sInfo, 0); + sqlite3DbFree(db, zSql); + } + } + + /* Set appropriate defaults on all indexes not in the sqlite_stat1 table */ + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + for(i=sqliteHashFirst(&pSchema->idxHash); i; i=sqliteHashNext(i)){ + Index *pIdx = sqliteHashData(i); + if( !pIdx->hasStat1 ) sqlite3DefaultRowEst(pIdx); + } + + /* Load the statistics from the sqlite_stat4 table. */ +#ifdef SQLITE_ENABLE_STAT4 + if( rc==SQLITE_OK ){ + DisableLookaside; + rc = loadStat4(db, sInfo.zDatabase); + EnableLookaside; + } + for(i=sqliteHashFirst(&pSchema->idxHash); i; i=sqliteHashNext(i)){ + Index *pIdx = sqliteHashData(i); + sqlite3_free(pIdx->aiRowEst); + pIdx->aiRowEst = 0; + } +#endif + + if( rc==SQLITE_NOMEM ){ + sqlite3OomFault(db); + } + return rc; +} + + +#endif /* SQLITE_OMIT_ANALYZE */ + +/************** End of analyze.c *********************************************/ +/************** Begin file attach.c ******************************************/ +/* +** 2003 April 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to implement the ATTACH and DETACH commands. +*/ +/* #include "sqliteInt.h" */ + +#ifndef SQLITE_OMIT_ATTACH +/* +** Resolve an expression that was part of an ATTACH or DETACH statement. This +** is slightly different from resolving a normal SQL expression, because simple +** identifiers are treated as strings, not possible column names or aliases. +** +** i.e. if the parser sees: +** +** ATTACH DATABASE abc AS def +** +** it treats the two expressions as literal strings 'abc' and 'def' instead of +** looking for columns of the same name. +** +** This only applies to the root node of pExpr, so the statement: +** +** ATTACH DATABASE abc||def AS 'db2' +** +** will fail because neither abc or def can be resolved. +*/ +static int resolveAttachExpr(NameContext *pName, Expr *pExpr) +{ + int rc = SQLITE_OK; + if( pExpr ){ + if( pExpr->op!=TK_ID ){ + rc = sqlite3ResolveExprNames(pName, pExpr); + }else{ + pExpr->op = TK_STRING; + } + } + return rc; +} + +/* +** Return true if zName points to a name that may be used to refer to +** database iDb attached to handle db. +*/ +SQLITE_PRIVATE int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName){ + return ( + sqlite3StrICmp(db->aDb[iDb].zDbSName, zName)==0 + || (iDb==0 && sqlite3StrICmp("main", zName)==0) + ); +} + +/* +** An SQL user-function registered to do the work of an ATTACH statement. The +** three arguments to the function come directly from an attach statement: +** +** ATTACH DATABASE x AS y KEY z +** +** SELECT sqlite_attach(x, y, z) +** +** If the optional "KEY z" syntax is omitted, an SQL NULL is passed as the +** third argument. +** +** If the db->init.reopenMemdb flags is set, then instead of attaching a +** new database, close the database on db->init.iDb and reopen it as an +** empty MemDB. +*/ +static void attachFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + int i; + int rc = 0; + sqlite3 *db = sqlite3_context_db_handle(context); + const char *zName; + const char *zFile; + char *zPath = 0; + char *zErr = 0; + unsigned int flags; + Db *aNew; /* New array of Db pointers */ + Db *pNew = 0; /* Db object for the newly attached database */ + char *zErrDyn = 0; + sqlite3_vfs *pVfs; + + UNUSED_PARAMETER(NotUsed); + zFile = (const char *)sqlite3_value_text(argv[0]); + zName = (const char *)sqlite3_value_text(argv[1]); + if( zFile==0 ) zFile = ""; + if( zName==0 ) zName = ""; + +#ifndef SQLITE_OMIT_DESERIALIZE +# define REOPEN_AS_MEMDB(db) (db->init.reopenMemdb) +#else +# define REOPEN_AS_MEMDB(db) (0) +#endif + + if( REOPEN_AS_MEMDB(db) ){ + /* This is not a real ATTACH. Instead, this routine is being called + ** from sqlite3_deserialize() to close database db->init.iDb and + ** reopen it as a MemDB */ + Btree *pNewBt = 0; + pVfs = sqlite3_vfs_find("memdb"); + if( pVfs==0 ) return; + rc = sqlite3BtreeOpen(pVfs, "x\0", db, &pNewBt, 0, SQLITE_OPEN_MAIN_DB); + if( rc==SQLITE_OK ){ + Schema *pNewSchema = sqlite3SchemaGet(db, pNewBt); + if( pNewSchema ){ + /* Both the Btree and the new Schema were allocated successfully. + ** Close the old db and update the aDb[] slot with the new memdb + ** values. */ + pNew = &db->aDb[db->init.iDb]; + if( ALWAYS(pNew->pBt) ) sqlite3BtreeClose(pNew->pBt); + pNew->pBt = pNewBt; + pNew->pSchema = pNewSchema; + }else{ + sqlite3BtreeClose(pNewBt); + rc = SQLITE_NOMEM; + } + } + if( rc ) goto attach_error; + }else{ + /* This is a real ATTACH + ** + ** Check for the following errors: + ** + ** * Too many attached databases, + ** * Transaction currently open + ** * Specified database name already being used. + */ + if( db->nDb>=db->aLimit[SQLITE_LIMIT_ATTACHED]+2 ){ + zErrDyn = sqlite3MPrintf(db, "too many attached databases - max %d", + db->aLimit[SQLITE_LIMIT_ATTACHED] + ); + goto attach_error; + } + for(i=0; inDb; i++){ + assert( zName ); + if( sqlite3DbIsNamed(db, i, zName) ){ + zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName); + goto attach_error; + } + } + + /* Allocate the new entry in the db->aDb[] array and initialize the schema + ** hash tables. + */ + if( db->aDb==db->aDbStatic ){ + aNew = sqlite3DbMallocRawNN(db, sizeof(db->aDb[0])*3 ); + if( aNew==0 ) return; + memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2); + }else{ + aNew = sqlite3DbRealloc(db, db->aDb, sizeof(db->aDb[0])*(db->nDb+1) ); + if( aNew==0 ) return; + } + db->aDb = aNew; + pNew = &db->aDb[db->nDb]; + memset(pNew, 0, sizeof(*pNew)); + + /* Open the database file. If the btree is successfully opened, use + ** it to obtain the database schema. At this point the schema may + ** or may not be initialized. + */ + flags = db->openFlags; + rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_NOMEM ) sqlite3OomFault(db); + sqlite3_result_error(context, zErr, -1); + sqlite3_free(zErr); + return; + } + assert( pVfs ); + flags |= SQLITE_OPEN_MAIN_DB; + rc = sqlite3BtreeOpen(pVfs, zPath, db, &pNew->pBt, 0, flags); + db->nDb++; + pNew->zDbSName = sqlite3DbStrDup(db, zName); + } + db->noSharedCache = 0; + if( rc==SQLITE_CONSTRAINT ){ + rc = SQLITE_ERROR; + zErrDyn = sqlite3MPrintf(db, "database is already attached"); + }else if( rc==SQLITE_OK ){ + Pager *pPager; + pNew->pSchema = sqlite3SchemaGet(db, pNew->pBt); + if( !pNew->pSchema ){ + rc = SQLITE_NOMEM_BKPT; + }else if( pNew->pSchema->file_format && pNew->pSchema->enc!=ENC(db) ){ + zErrDyn = sqlite3MPrintf(db, + "attached databases must use the same text encoding as main database"); + rc = SQLITE_ERROR; + } + sqlite3BtreeEnter(pNew->pBt); + pPager = sqlite3BtreePager(pNew->pBt); + sqlite3PagerLockingMode(pPager, db->dfltLockMode); + sqlite3BtreeSecureDelete(pNew->pBt, + sqlite3BtreeSecureDelete(db->aDb[0].pBt,-1) ); +#ifndef SQLITE_OMIT_PAGER_PRAGMAS + sqlite3BtreeSetPagerFlags(pNew->pBt, + PAGER_SYNCHRONOUS_FULL | (db->flags & PAGER_FLAGS_MASK)); +#endif + sqlite3BtreeLeave(pNew->pBt); + } + pNew->safety_level = SQLITE_DEFAULT_SYNCHRONOUS+1; + if( rc==SQLITE_OK && pNew->zDbSName==0 ){ + rc = SQLITE_NOMEM_BKPT; + } + +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC + if( rc==SQLITE_OK ){ + extern int sqlcipherCodecAttach(sqlite3*, int, const void*, int); + extern void sqlcipherCodecGetKey(sqlite3*, int, void**, int*); + int nKey; + char *zKey; + int t = sqlite3_value_type(argv[2]); + switch( t ){ + case SQLITE_INTEGER: + case SQLITE_FLOAT: + zErrDyn = sqlite3DbStrDup(db, "Invalid key value"); + rc = SQLITE_ERROR; + break; + + case SQLITE_TEXT: + case SQLITE_BLOB: + nKey = sqlite3_value_bytes(argv[2]); + zKey = (char *)sqlite3_value_blob(argv[2]); + rc = sqlcipherCodecAttach(db, db->nDb-1, zKey, nKey); + break; + + case SQLITE_NULL: + /* No key specified. Use the key from URI filename, or if none, + ** use the key from the main database. */ + if( sqlite3CodecQueryParameters(db, zName, zPath)==0 ){ + sqlcipherCodecGetKey(db, 0, (void**)&zKey, &nKey); + if( nKey || sqlite3BtreeGetRequestedReserve(db->aDb[0].pBt)>0 ){ + rc = sqlcipherCodecAttach(db, db->nDb-1, zKey, nKey); + } + } + break; + } + } +#endif +/* END SQLCIPHER */ + sqlite3_free_filename( zPath ); + + /* If the file was opened successfully, read the schema for the new database. + ** If this fails, or if opening the file failed, then close the file and + ** remove the entry from the db->aDb[] array. i.e. put everything back the + ** way we found it. + */ + if( rc==SQLITE_OK ){ + sqlite3BtreeEnterAll(db); + db->init.iDb = 0; + db->mDbFlags &= ~(DBFLAG_SchemaKnownOk); + if( !REOPEN_AS_MEMDB(db) ){ + rc = sqlite3Init(db, &zErrDyn); + } + sqlite3BtreeLeaveAll(db); + assert( zErrDyn==0 || rc!=SQLITE_OK ); + } +#ifdef SQLITE_USER_AUTHENTICATION + if( rc==SQLITE_OK && !REOPEN_AS_MEMDB(db) ){ + u8 newAuth = 0; + rc = sqlite3UserAuthCheckLogin(db, zName, &newAuth); + if( newAuthauth.authLevel ){ + rc = SQLITE_AUTH_USER; + } + } +#endif + if( rc ){ + if( ALWAYS(!REOPEN_AS_MEMDB(db)) ){ + int iDb = db->nDb - 1; + assert( iDb>=2 ); + if( db->aDb[iDb].pBt ){ + sqlite3BtreeClose(db->aDb[iDb].pBt); + db->aDb[iDb].pBt = 0; + db->aDb[iDb].pSchema = 0; + } + sqlite3ResetAllSchemasOfConnection(db); + db->nDb = iDb; + if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){ + sqlite3OomFault(db); + sqlite3DbFree(db, zErrDyn); + zErrDyn = sqlite3MPrintf(db, "out of memory"); + }else if( zErrDyn==0 ){ + zErrDyn = sqlite3MPrintf(db, "unable to open database: %s", zFile); + } + } + goto attach_error; + } + + return; + +attach_error: + /* Return an error if we get here */ + if( zErrDyn ){ + sqlite3_result_error(context, zErrDyn, -1); + sqlite3DbFree(db, zErrDyn); + } + if( rc ) sqlite3_result_error_code(context, rc); +} + +/* +** An SQL user-function registered to do the work of an DETACH statement. The +** three arguments to the function come directly from a detach statement: +** +** DETACH DATABASE x +** +** SELECT sqlite_detach(x) +*/ +static void detachFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + const char *zName = (const char *)sqlite3_value_text(argv[0]); + sqlite3 *db = sqlite3_context_db_handle(context); + int i; + Db *pDb = 0; + HashElem *pEntry; + char zErr[128]; + + UNUSED_PARAMETER(NotUsed); + + if( zName==0 ) zName = ""; + for(i=0; inDb; i++){ + pDb = &db->aDb[i]; + if( pDb->pBt==0 ) continue; + if( sqlite3DbIsNamed(db, i, zName) ) break; + } + + if( i>=db->nDb ){ + sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName); + goto detach_error; + } + if( i<2 ){ + sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName); + goto detach_error; + } + if( sqlite3BtreeTxnState(pDb->pBt)!=SQLITE_TXN_NONE + || sqlite3BtreeIsInBackup(pDb->pBt) + ){ + sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName); + goto detach_error; + } + + /* If any TEMP triggers reference the schema being detached, move those + ** triggers to reference the TEMP schema itself. */ + assert( db->aDb[1].pSchema ); + pEntry = sqliteHashFirst(&db->aDb[1].pSchema->trigHash); + while( pEntry ){ + Trigger *pTrig = (Trigger*)sqliteHashData(pEntry); + if( pTrig->pTabSchema==pDb->pSchema ){ + pTrig->pTabSchema = pTrig->pSchema; + } + pEntry = sqliteHashNext(pEntry); + } + + sqlite3BtreeClose(pDb->pBt); + pDb->pBt = 0; + pDb->pSchema = 0; + sqlite3CollapseDatabaseArray(db); + return; + +detach_error: + sqlite3_result_error(context, zErr, -1); +} + +/* +** This procedure generates VDBE code for a single invocation of either the +** sqlite_detach() or sqlite_attach() SQL user functions. +*/ +static void codeAttach( + Parse *pParse, /* The parser context */ + int type, /* Either SQLITE_ATTACH or SQLITE_DETACH */ + FuncDef const *pFunc,/* FuncDef wrapper for detachFunc() or attachFunc() */ + Expr *pAuthArg, /* Expression to pass to authorization callback */ + Expr *pFilename, /* Name of database file */ + Expr *pDbname, /* Name of the database to use internally */ + Expr *pKey /* Database key for encryption extension */ +){ + int rc; + NameContext sName; + Vdbe *v; + sqlite3* db = pParse->db; + int regArgs; + + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ) goto attach_end; + + if( pParse->nErr ) goto attach_end; + memset(&sName, 0, sizeof(NameContext)); + sName.pParse = pParse; + + if( + SQLITE_OK!=resolveAttachExpr(&sName, pFilename) || + SQLITE_OK!=resolveAttachExpr(&sName, pDbname) || + SQLITE_OK!=resolveAttachExpr(&sName, pKey) + ){ + goto attach_end; + } + +#ifndef SQLITE_OMIT_AUTHORIZATION + if( ALWAYS(pAuthArg) ){ + char *zAuthArg; + if( pAuthArg->op==TK_STRING ){ + assert( !ExprHasProperty(pAuthArg, EP_IntValue) ); + zAuthArg = pAuthArg->u.zToken; + }else{ + zAuthArg = 0; + } + rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0); + if(rc!=SQLITE_OK ){ + goto attach_end; + } + } +#endif /* SQLITE_OMIT_AUTHORIZATION */ + + + v = sqlite3GetVdbe(pParse); + regArgs = sqlite3GetTempRange(pParse, 4); + sqlite3ExprCode(pParse, pFilename, regArgs); + sqlite3ExprCode(pParse, pDbname, regArgs+1); + sqlite3ExprCode(pParse, pKey, regArgs+2); + + assert( v || db->mallocFailed ); + if( v ){ + sqlite3VdbeAddFunctionCall(pParse, 0, regArgs+3-pFunc->nArg, regArgs+3, + pFunc->nArg, pFunc, 0); + /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this + ** statement only). For DETACH, set it to false (expire all existing + ** statements). + */ + sqlite3VdbeAddOp1(v, OP_Expire, (type==SQLITE_ATTACH)); + } + +attach_end: + sqlite3ExprDelete(db, pFilename); + sqlite3ExprDelete(db, pDbname); + sqlite3ExprDelete(db, pKey); +} + +/* +** Called by the parser to compile a DETACH statement. +** +** DETACH pDbname +*/ +SQLITE_PRIVATE void sqlite3Detach(Parse *pParse, Expr *pDbname){ + static const FuncDef detach_func = { + 1, /* nArg */ + SQLITE_UTF8, /* funcFlags */ + 0, /* pUserData */ + 0, /* pNext */ + detachFunc, /* xSFunc */ + 0, /* xFinalize */ + 0, 0, /* xValue, xInverse */ + "sqlite_detach", /* zName */ + {0} + }; + codeAttach(pParse, SQLITE_DETACH, &detach_func, pDbname, 0, 0, pDbname); +} + +/* +** Called by the parser to compile an ATTACH statement. +** +** ATTACH p AS pDbname KEY pKey +*/ +SQLITE_PRIVATE void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){ + static const FuncDef attach_func = { + 3, /* nArg */ + SQLITE_UTF8, /* funcFlags */ + 0, /* pUserData */ + 0, /* pNext */ + attachFunc, /* xSFunc */ + 0, /* xFinalize */ + 0, 0, /* xValue, xInverse */ + "sqlite_attach", /* zName */ + {0} + }; + codeAttach(pParse, SQLITE_ATTACH, &attach_func, p, p, pDbname, pKey); +} +#endif /* SQLITE_OMIT_ATTACH */ + +/* +** Expression callback used by sqlite3FixAAAA() routines. +*/ +static int fixExprCb(Walker *p, Expr *pExpr){ + DbFixer *pFix = p->u.pFix; + if( !pFix->bTemp ) ExprSetProperty(pExpr, EP_FromDDL); + if( pExpr->op==TK_VARIABLE ){ + if( pFix->pParse->db->init.busy ){ + pExpr->op = TK_NULL; + }else{ + sqlite3ErrorMsg(pFix->pParse, "%s cannot use variables", pFix->zType); + return WRC_Abort; + } + } + return WRC_Continue; +} + +/* +** Select callback used by sqlite3FixAAAA() routines. +*/ +static int fixSelectCb(Walker *p, Select *pSelect){ + DbFixer *pFix = p->u.pFix; + int i; + SrcItem *pItem; + sqlite3 *db = pFix->pParse->db; + int iDb = sqlite3FindDbName(db, pFix->zDb); + SrcList *pList = pSelect->pSrc; + + if( NEVER(pList==0) ) return WRC_Continue; + for(i=0, pItem=pList->a; inSrc; i++, pItem++){ + if( pFix->bTemp==0 ){ + if( pItem->zDatabase ){ + if( iDb!=sqlite3FindDbName(db, pItem->zDatabase) ){ + sqlite3ErrorMsg(pFix->pParse, + "%s %T cannot reference objects in database %s", + pFix->zType, pFix->pName, pItem->zDatabase); + return WRC_Abort; + } + sqlite3DbFree(db, pItem->zDatabase); + pItem->zDatabase = 0; + pItem->fg.notCte = 1; + } + pItem->pSchema = pFix->pSchema; + pItem->fg.fromDDL = 1; + } +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) + if( pList->a[i].fg.isUsing==0 + && sqlite3WalkExpr(&pFix->w, pList->a[i].u3.pOn) + ){ + return WRC_Abort; + } +#endif + } + if( pSelect->pWith ){ + for(i=0; ipWith->nCte; i++){ + if( sqlite3WalkSelect(p, pSelect->pWith->a[i].pSelect) ){ + return WRC_Abort; + } + } + } + return WRC_Continue; +} + +/* +** Initialize a DbFixer structure. This routine must be called prior +** to passing the structure to one of the sqliteFixAAAA() routines below. +*/ +SQLITE_PRIVATE void sqlite3FixInit( + DbFixer *pFix, /* The fixer to be initialized */ + Parse *pParse, /* Error messages will be written here */ + int iDb, /* This is the database that must be used */ + const char *zType, /* "view", "trigger", or "index" */ + const Token *pName /* Name of the view, trigger, or index */ +){ + sqlite3 *db = pParse->db; + assert( db->nDb>iDb ); + pFix->pParse = pParse; + pFix->zDb = db->aDb[iDb].zDbSName; + pFix->pSchema = db->aDb[iDb].pSchema; + pFix->zType = zType; + pFix->pName = pName; + pFix->bTemp = (iDb==1); + pFix->w.pParse = pParse; + pFix->w.xExprCallback = fixExprCb; + pFix->w.xSelectCallback = fixSelectCb; + pFix->w.xSelectCallback2 = sqlite3WalkWinDefnDummyCallback; + pFix->w.walkerDepth = 0; + pFix->w.eCode = 0; + pFix->w.u.pFix = pFix; +} + +/* +** The following set of routines walk through the parse tree and assign +** a specific database to all table references where the database name +** was left unspecified in the original SQL statement. The pFix structure +** must have been initialized by a prior call to sqlite3FixInit(). +** +** These routines are used to make sure that an index, trigger, or +** view in one database does not refer to objects in a different database. +** (Exception: indices, triggers, and views in the TEMP database are +** allowed to refer to anything.) If a reference is explicitly made +** to an object in a different database, an error message is added to +** pParse->zErrMsg and these routines return non-zero. If everything +** checks out, these routines return 0. +*/ +SQLITE_PRIVATE int sqlite3FixSrcList( + DbFixer *pFix, /* Context of the fixation */ + SrcList *pList /* The Source list to check and modify */ +){ + int res = 0; + if( pList ){ + Select s; + memset(&s, 0, sizeof(s)); + s.pSrc = pList; + res = sqlite3WalkSelect(&pFix->w, &s); + } + return res; +} +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) +SQLITE_PRIVATE int sqlite3FixSelect( + DbFixer *pFix, /* Context of the fixation */ + Select *pSelect /* The SELECT statement to be fixed to one database */ +){ + return sqlite3WalkSelect(&pFix->w, pSelect); +} +SQLITE_PRIVATE int sqlite3FixExpr( + DbFixer *pFix, /* Context of the fixation */ + Expr *pExpr /* The expression to be fixed to one database */ +){ + return sqlite3WalkExpr(&pFix->w, pExpr); +} +#endif + +#ifndef SQLITE_OMIT_TRIGGER +SQLITE_PRIVATE int sqlite3FixTriggerStep( + DbFixer *pFix, /* Context of the fixation */ + TriggerStep *pStep /* The trigger step be fixed to one database */ +){ + while( pStep ){ + if( sqlite3WalkSelect(&pFix->w, pStep->pSelect) + || sqlite3WalkExpr(&pFix->w, pStep->pWhere) + || sqlite3WalkExprList(&pFix->w, pStep->pExprList) + || sqlite3FixSrcList(pFix, pStep->pFrom) + ){ + return 1; + } +#ifndef SQLITE_OMIT_UPSERT + { + Upsert *pUp; + for(pUp=pStep->pUpsert; pUp; pUp=pUp->pNextUpsert){ + if( sqlite3WalkExprList(&pFix->w, pUp->pUpsertTarget) + || sqlite3WalkExpr(&pFix->w, pUp->pUpsertTargetWhere) + || sqlite3WalkExprList(&pFix->w, pUp->pUpsertSet) + || sqlite3WalkExpr(&pFix->w, pUp->pUpsertWhere) + ){ + return 1; + } + } + } +#endif + pStep = pStep->pNext; + } + + return 0; +} +#endif + +/************** End of attach.c **********************************************/ +/************** Begin file auth.c ********************************************/ +/* +** 2003 January 11 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to implement the sqlite3_set_authorizer() +** API. This facility is an optional feature of the library. Embedded +** systems that do not need this facility may omit it by recompiling +** the library with -DSQLITE_OMIT_AUTHORIZATION=1 +*/ +/* #include "sqliteInt.h" */ + +/* +** All of the code in this file may be omitted by defining a single +** macro. +*/ +#ifndef SQLITE_OMIT_AUTHORIZATION + +/* +** Set or clear the access authorization function. +** +** The access authorization function is be called during the compilation +** phase to verify that the user has read and/or write access permission on +** various fields of the database. The first argument to the auth function +** is a copy of the 3rd argument to this routine. The second argument +** to the auth function is one of these constants: +** +** SQLITE_CREATE_INDEX +** SQLITE_CREATE_TABLE +** SQLITE_CREATE_TEMP_INDEX +** SQLITE_CREATE_TEMP_TABLE +** SQLITE_CREATE_TEMP_TRIGGER +** SQLITE_CREATE_TEMP_VIEW +** SQLITE_CREATE_TRIGGER +** SQLITE_CREATE_VIEW +** SQLITE_DELETE +** SQLITE_DROP_INDEX +** SQLITE_DROP_TABLE +** SQLITE_DROP_TEMP_INDEX +** SQLITE_DROP_TEMP_TABLE +** SQLITE_DROP_TEMP_TRIGGER +** SQLITE_DROP_TEMP_VIEW +** SQLITE_DROP_TRIGGER +** SQLITE_DROP_VIEW +** SQLITE_INSERT +** SQLITE_PRAGMA +** SQLITE_READ +** SQLITE_SELECT +** SQLITE_TRANSACTION +** SQLITE_UPDATE +** +** The third and fourth arguments to the auth function are the name of +** the table and the column that are being accessed. The auth function +** should return either SQLITE_OK, SQLITE_DENY, or SQLITE_IGNORE. If +** SQLITE_OK is returned, it means that access is allowed. SQLITE_DENY +** means that the SQL statement will never-run - the sqlite3_exec() call +** will return with an error. SQLITE_IGNORE means that the SQL statement +** should run but attempts to read the specified column will return NULL +** and attempts to write the column will be ignored. +** +** Setting the auth function to NULL disables this hook. The default +** setting of the auth function is NULL. +*/ +SQLITE_API int sqlite3_set_authorizer( + sqlite3 *db, + int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), + void *pArg +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + db->xAuth = (sqlite3_xauth)xAuth; + db->pAuthArg = pArg; + if( db->xAuth ) sqlite3ExpirePreparedStatements(db, 1); + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +/* +** Write an error message into pParse->zErrMsg that explains that the +** user-supplied authorization function returned an illegal value. +*/ +static void sqliteAuthBadReturnCode(Parse *pParse){ + sqlite3ErrorMsg(pParse, "authorizer malfunction"); + pParse->rc = SQLITE_ERROR; +} + +/* +** Invoke the authorization callback for permission to read column zCol from +** table zTab in database zDb. This function assumes that an authorization +** callback has been registered (i.e. that sqlite3.xAuth is not NULL). +** +** If SQLITE_IGNORE is returned and pExpr is not NULL, then pExpr is changed +** to an SQL NULL expression. Otherwise, if pExpr is NULL, then SQLITE_IGNORE +** is treated as SQLITE_DENY. In this case an error is left in pParse. +*/ +SQLITE_PRIVATE int sqlite3AuthReadCol( + Parse *pParse, /* The parser context */ + const char *zTab, /* Table name */ + const char *zCol, /* Column name */ + int iDb /* Index of containing database. */ +){ + sqlite3 *db = pParse->db; /* Database handle */ + char *zDb = db->aDb[iDb].zDbSName; /* Schema name of attached database */ + int rc; /* Auth callback return code */ + + if( db->init.busy ) return SQLITE_OK; + rc = db->xAuth(db->pAuthArg, SQLITE_READ, zTab,zCol,zDb,pParse->zAuthContext +#ifdef SQLITE_USER_AUTHENTICATION + ,db->auth.zAuthUser +#endif + ); + if( rc==SQLITE_DENY ){ + char *z = sqlite3_mprintf("%s.%s", zTab, zCol); + if( db->nDb>2 || iDb!=0 ) z = sqlite3_mprintf("%s.%z", zDb, z); + sqlite3ErrorMsg(pParse, "access to %z is prohibited", z); + pParse->rc = SQLITE_AUTH; + }else if( rc!=SQLITE_IGNORE && rc!=SQLITE_OK ){ + sqliteAuthBadReturnCode(pParse); + } + return rc; +} + +/* +** The pExpr should be a TK_COLUMN expression. The table referred to +** is in pTabList or else it is the NEW or OLD table of a trigger. +** Check to see if it is OK to read this particular column. +** +** If the auth function returns SQLITE_IGNORE, change the TK_COLUMN +** instruction into a TK_NULL. If the auth function returns SQLITE_DENY, +** then generate an error. +*/ +SQLITE_PRIVATE void sqlite3AuthRead( + Parse *pParse, /* The parser context */ + Expr *pExpr, /* The expression to check authorization on */ + Schema *pSchema, /* The schema of the expression */ + SrcList *pTabList /* All table that pExpr might refer to */ +){ + Table *pTab = 0; /* The table being read */ + const char *zCol; /* Name of the column of the table */ + int iSrc; /* Index in pTabList->a[] of table being read */ + int iDb; /* The index of the database the expression refers to */ + int iCol; /* Index of column in table */ + + assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER ); + assert( !IN_RENAME_OBJECT ); + assert( pParse->db->xAuth!=0 ); + iDb = sqlite3SchemaToIndex(pParse->db, pSchema); + if( iDb<0 ){ + /* An attempt to read a column out of a subquery or other + ** temporary table. */ + return; + } + + if( pExpr->op==TK_TRIGGER ){ + pTab = pParse->pTriggerTab; + }else{ + assert( pTabList ); + for(iSrc=0; iSrcnSrc; iSrc++){ + if( pExpr->iTable==pTabList->a[iSrc].iCursor ){ + pTab = pTabList->a[iSrc].pTab; + break; + } + } + } + iCol = pExpr->iColumn; + if( pTab==0 ) return; + + if( iCol>=0 ){ + assert( iColnCol ); + zCol = pTab->aCol[iCol].zCnName; + }else if( pTab->iPKey>=0 ){ + assert( pTab->iPKeynCol ); + zCol = pTab->aCol[pTab->iPKey].zCnName; + }else{ + zCol = "ROWID"; + } + assert( iDb>=0 && iDbdb->nDb ); + if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){ + pExpr->op = TK_NULL; + } +} + +/* +** Do an authorization check using the code and arguments given. Return +** either SQLITE_OK (zero) or SQLITE_IGNORE or SQLITE_DENY. If SQLITE_DENY +** is returned, then the error count and error message in pParse are +** modified appropriately. +*/ +SQLITE_PRIVATE int sqlite3AuthCheck( + Parse *pParse, + int code, + const char *zArg1, + const char *zArg2, + const char *zArg3 +){ + sqlite3 *db = pParse->db; + int rc; + + /* Don't do any authorization checks if the database is initialising + ** or if the parser is being invoked from within sqlite3_declare_vtab. + */ + assert( !IN_RENAME_OBJECT || db->xAuth==0 ); + if( db->xAuth==0 || db->init.busy || IN_SPECIAL_PARSE ){ + return SQLITE_OK; + } + + /* EVIDENCE-OF: R-43249-19882 The third through sixth parameters to the + ** callback are either NULL pointers or zero-terminated strings that + ** contain additional details about the action to be authorized. + ** + ** The following testcase() macros show that any of the 3rd through 6th + ** parameters can be either NULL or a string. */ + testcase( zArg1==0 ); + testcase( zArg2==0 ); + testcase( zArg3==0 ); + testcase( pParse->zAuthContext==0 ); + + rc = db->xAuth(db->pAuthArg, code, zArg1, zArg2, zArg3, pParse->zAuthContext +#ifdef SQLITE_USER_AUTHENTICATION + ,db->auth.zAuthUser +#endif + ); + if( rc==SQLITE_DENY ){ + sqlite3ErrorMsg(pParse, "not authorized"); + pParse->rc = SQLITE_AUTH; + }else if( rc!=SQLITE_OK && rc!=SQLITE_IGNORE ){ + rc = SQLITE_DENY; + sqliteAuthBadReturnCode(pParse); + } + return rc; +} + +/* +** Push an authorization context. After this routine is called, the +** zArg3 argument to authorization callbacks will be zContext until +** popped. Or if pParse==0, this routine is a no-op. +*/ +SQLITE_PRIVATE void sqlite3AuthContextPush( + Parse *pParse, + AuthContext *pContext, + const char *zContext +){ + assert( pParse ); + pContext->pParse = pParse; + pContext->zAuthContext = pParse->zAuthContext; + pParse->zAuthContext = zContext; +} + +/* +** Pop an authorization context that was previously pushed +** by sqlite3AuthContextPush +*/ +SQLITE_PRIVATE void sqlite3AuthContextPop(AuthContext *pContext){ + if( pContext->pParse ){ + pContext->pParse->zAuthContext = pContext->zAuthContext; + pContext->pParse = 0; + } +} + +#endif /* SQLITE_OMIT_AUTHORIZATION */ + +/************** End of auth.c ************************************************/ +/************** Begin file build.c *******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that are called by the SQLite parser +** when syntax rules are reduced. The routines in this file handle the +** following kinds of SQL syntax: +** +** CREATE TABLE +** DROP TABLE +** CREATE INDEX +** DROP INDEX +** creating ID lists +** BEGIN TRANSACTION +** COMMIT +** ROLLBACK +*/ +/* #include "sqliteInt.h" */ + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** The TableLock structure is only used by the sqlite3TableLock() and +** codeTableLocks() functions. +*/ +struct TableLock { + int iDb; /* The database containing the table to be locked */ + Pgno iTab; /* The root page of the table to be locked */ + u8 isWriteLock; /* True for write lock. False for a read lock */ + const char *zLockName; /* Name of the table */ +}; + +/* +** Record the fact that we want to lock a table at run-time. +** +** The table to be locked has root page iTab and is found in database iDb. +** A read or a write lock can be taken depending on isWritelock. +** +** This routine just records the fact that the lock is desired. The +** code to make the lock occur is generated by a later call to +** codeTableLocks() which occurs during sqlite3FinishCoding(). +*/ +static SQLITE_NOINLINE void lockTable( + Parse *pParse, /* Parsing context */ + int iDb, /* Index of the database containing the table to lock */ + Pgno iTab, /* Root page number of the table to be locked */ + u8 isWriteLock, /* True for a write lock */ + const char *zName /* Name of the table to be locked */ +){ + Parse *pToplevel; + int i; + int nBytes; + TableLock *p; + assert( iDb>=0 ); + + pToplevel = sqlite3ParseToplevel(pParse); + for(i=0; inTableLock; i++){ + p = &pToplevel->aTableLock[i]; + if( p->iDb==iDb && p->iTab==iTab ){ + p->isWriteLock = (p->isWriteLock || isWriteLock); + return; + } + } + + nBytes = sizeof(TableLock) * (pToplevel->nTableLock+1); + pToplevel->aTableLock = + sqlite3DbReallocOrFree(pToplevel->db, pToplevel->aTableLock, nBytes); + if( pToplevel->aTableLock ){ + p = &pToplevel->aTableLock[pToplevel->nTableLock++]; + p->iDb = iDb; + p->iTab = iTab; + p->isWriteLock = isWriteLock; + p->zLockName = zName; + }else{ + pToplevel->nTableLock = 0; + sqlite3OomFault(pToplevel->db); + } +} +SQLITE_PRIVATE void sqlite3TableLock( + Parse *pParse, /* Parsing context */ + int iDb, /* Index of the database containing the table to lock */ + Pgno iTab, /* Root page number of the table to be locked */ + u8 isWriteLock, /* True for a write lock */ + const char *zName /* Name of the table to be locked */ +){ + if( iDb==1 ) return; + if( !sqlite3BtreeSharable(pParse->db->aDb[iDb].pBt) ) return; + lockTable(pParse, iDb, iTab, isWriteLock, zName); +} + +/* +** Code an OP_TableLock instruction for each table locked by the +** statement (configured by calls to sqlite3TableLock()). +*/ +static void codeTableLocks(Parse *pParse){ + int i; + Vdbe *pVdbe = pParse->pVdbe; + assert( pVdbe!=0 ); + + for(i=0; inTableLock; i++){ + TableLock *p = &pParse->aTableLock[i]; + int p1 = p->iDb; + sqlite3VdbeAddOp4(pVdbe, OP_TableLock, p1, p->iTab, p->isWriteLock, + p->zLockName, P4_STATIC); + } +} +#else + #define codeTableLocks(x) +#endif + +/* +** Return TRUE if the given yDbMask object is empty - if it contains no +** 1 bits. This routine is used by the DbMaskAllZero() and DbMaskNotZero() +** macros when SQLITE_MAX_ATTACHED is greater than 30. +*/ +#if SQLITE_MAX_ATTACHED>30 +SQLITE_PRIVATE int sqlite3DbMaskAllZero(yDbMask m){ + int i; + for(i=0; ipToplevel==0 ); + db = pParse->db; + assert( db->pParse==pParse ); + if( pParse->nested ) return; + if( pParse->nErr ){ + if( db->mallocFailed ) pParse->rc = SQLITE_NOMEM; + return; + } + assert( db->mallocFailed==0 ); + + /* Begin by generating some termination code at the end of the + ** vdbe program + */ + v = pParse->pVdbe; + if( v==0 ){ + if( db->init.busy ){ + pParse->rc = SQLITE_DONE; + return; + } + v = sqlite3GetVdbe(pParse); + if( v==0 ) pParse->rc = SQLITE_ERROR; + } + assert( !pParse->isMultiWrite + || sqlite3VdbeAssertMayAbort(v, pParse->mayAbort)); + if( v ){ + if( pParse->bReturning ){ + Returning *pReturning = pParse->u1.pReturning; + int addrRewind; + int reg; + + if( pReturning->nRetCol ){ + sqlite3VdbeAddOp0(v, OP_FkCheck); + addrRewind = + sqlite3VdbeAddOp1(v, OP_Rewind, pReturning->iRetCur); + VdbeCoverage(v); + reg = pReturning->iRetReg; + for(i=0; inRetCol; i++){ + sqlite3VdbeAddOp3(v, OP_Column, pReturning->iRetCur, i, reg+i); + } + sqlite3VdbeAddOp2(v, OP_ResultRow, reg, i); + sqlite3VdbeAddOp2(v, OP_Next, pReturning->iRetCur, addrRewind+1); + VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addrRewind); + } + } + sqlite3VdbeAddOp0(v, OP_Halt); + +#if SQLITE_USER_AUTHENTICATION + if( pParse->nTableLock>0 && db->init.busy==0 ){ + sqlite3UserAuthInit(db); + if( db->auth.authLevelrc = SQLITE_AUTH_USER; + return; + } + } +#endif + + /* The cookie mask contains one bit for each database file open. + ** (Bit 0 is for main, bit 1 is for temp, and so forth.) Bits are + ** set for each database that is used. Generate code to start a + ** transaction on each used database and to verify the schema cookie + ** on each used database. + */ + assert( pParse->nErr>0 || sqlite3VdbeGetOp(v, 0)->opcode==OP_Init ); + sqlite3VdbeJumpHere(v, 0); + assert( db->nDb>0 ); + iDb = 0; + do{ + Schema *pSchema; + if( DbMaskTest(pParse->cookieMask, iDb)==0 ) continue; + sqlite3VdbeUsesBtree(v, iDb); + pSchema = db->aDb[iDb].pSchema; + sqlite3VdbeAddOp4Int(v, + OP_Transaction, /* Opcode */ + iDb, /* P1 */ + DbMaskTest(pParse->writeMask,iDb), /* P2 */ + pSchema->schema_cookie, /* P3 */ + pSchema->iGeneration /* P4 */ + ); + if( db->init.busy==0 ) sqlite3VdbeChangeP5(v, 1); + VdbeComment((v, + "usesStmtJournal=%d", pParse->mayAbort && pParse->isMultiWrite)); + }while( ++iDbnDb ); +#ifndef SQLITE_OMIT_VIRTUALTABLE + for(i=0; inVtabLock; i++){ + char *vtab = (char *)sqlite3GetVTable(db, pParse->apVtabLock[i]); + sqlite3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB); + } + pParse->nVtabLock = 0; +#endif + + /* Once all the cookies have been verified and transactions opened, + ** obtain the required table-locks. This is a no-op unless the + ** shared-cache feature is enabled. + */ + codeTableLocks(pParse); + + /* Initialize any AUTOINCREMENT data structures required. + */ + sqlite3AutoincrementBegin(pParse); + + /* Code constant expressions that where factored out of inner loops. + ** + ** The pConstExpr list might also contain expressions that we simply + ** want to keep around until the Parse object is deleted. Such + ** expressions have iConstExprReg==0. Do not generate code for + ** those expressions, of course. + */ + if( pParse->pConstExpr ){ + ExprList *pEL = pParse->pConstExpr; + pParse->okConstFactor = 0; + for(i=0; inExpr; i++){ + int iReg = pEL->a[i].u.iConstExprReg; + sqlite3ExprCode(pParse, pEL->a[i].pExpr, iReg); + } + } + + if( pParse->bReturning ){ + Returning *pRet = pParse->u1.pReturning; + if( pRet->nRetCol ){ + sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pRet->iRetCur, pRet->nRetCol); + } + } + + /* Finally, jump back to the beginning of the executable code. */ + sqlite3VdbeGoto(v, 1); + } + + /* Get the VDBE program ready for execution + */ + assert( v!=0 || pParse->nErr ); + assert( db->mallocFailed==0 || pParse->nErr ); + if( pParse->nErr==0 ){ + /* A minimum of one cursor is required if autoincrement is used + * See ticket [a696379c1f08866] */ + assert( pParse->pAinc==0 || pParse->nTab>0 ); + sqlite3VdbeMakeReady(v, pParse); + pParse->rc = SQLITE_DONE; + }else{ + pParse->rc = SQLITE_ERROR; + } +} + +/* +** Run the parser and code generator recursively in order to generate +** code for the SQL statement given onto the end of the pParse context +** currently under construction. Notes: +** +** * The final OP_Halt is not appended and other initialization +** and finalization steps are omitted because those are handling by the +** outermost parser. +** +** * Built-in SQL functions always take precedence over application-defined +** SQL functions. In other words, it is not possible to override a +** built-in function. +*/ +SQLITE_PRIVATE void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){ + va_list ap; + char *zSql; + sqlite3 *db = pParse->db; + u32 savedDbFlags = db->mDbFlags; + char saveBuf[PARSE_TAIL_SZ]; + + if( pParse->nErr ) return; + if( pParse->eParseMode ) return; + assert( pParse->nested<10 ); /* Nesting should only be of limited depth */ + va_start(ap, zFormat); + zSql = sqlite3VMPrintf(db, zFormat, ap); + va_end(ap); + if( zSql==0 ){ + /* This can result either from an OOM or because the formatted string + ** exceeds SQLITE_LIMIT_LENGTH. In the latter case, we need to set + ** an error */ + if( !db->mallocFailed ) pParse->rc = SQLITE_TOOBIG; + pParse->nErr++; + return; + } + pParse->nested++; + memcpy(saveBuf, PARSE_TAIL(pParse), PARSE_TAIL_SZ); + memset(PARSE_TAIL(pParse), 0, PARSE_TAIL_SZ); + db->mDbFlags |= DBFLAG_PreferBuiltin; + sqlite3RunParser(pParse, zSql); + db->mDbFlags = savedDbFlags; + sqlite3DbFree(db, zSql); + memcpy(PARSE_TAIL(pParse), saveBuf, PARSE_TAIL_SZ); + pParse->nested--; +} + +#if SQLITE_USER_AUTHENTICATION +/* +** Return TRUE if zTable is the name of the system table that stores the +** list of users and their access credentials. +*/ +SQLITE_PRIVATE int sqlite3UserAuthTable(const char *zTable){ + return sqlite3_stricmp(zTable, "sqlite_user")==0; +} +#endif + +/* +** Locate the in-memory structure that describes a particular database +** table given the name of that table and (optionally) the name of the +** database containing the table. Return NULL if not found. +** +** If zDatabase is 0, all databases are searched for the table and the +** first matching table is returned. (No checking for duplicate table +** names is done.) The search order is TEMP first, then MAIN, then any +** auxiliary databases added using the ATTACH command. +** +** See also sqlite3LocateTable(). +*/ +SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){ + Table *p = 0; + int i; + + /* All mutexes are required for schema access. Make sure we hold them. */ + assert( zDatabase!=0 || sqlite3BtreeHoldsAllMutexes(db) ); +#if SQLITE_USER_AUTHENTICATION + /* Only the admin user is allowed to know that the sqlite_user table + ** exists */ + if( db->auth.authLevelnDb; i++){ + if( sqlite3StrICmp(zDatabase, db->aDb[i].zDbSName)==0 ) break; + } + if( i>=db->nDb ){ + /* No match against the official names. But always match "main" + ** to schema 0 as a legacy fallback. */ + if( sqlite3StrICmp(zDatabase,"main")==0 ){ + i = 0; + }else{ + return 0; + } + } + p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName); + if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){ + if( i==1 ){ + if( sqlite3StrICmp(zName+7, &PREFERRED_TEMP_SCHEMA_TABLE[7])==0 + || sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0 + || sqlite3StrICmp(zName+7, &LEGACY_SCHEMA_TABLE[7])==0 + ){ + p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash, + LEGACY_TEMP_SCHEMA_TABLE); + } + }else{ + if( sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0 ){ + p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, + LEGACY_SCHEMA_TABLE); + } + } + } + }else{ + /* Match against TEMP first */ + p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash, zName); + if( p ) return p; + /* The main database is second */ + p = sqlite3HashFind(&db->aDb[0].pSchema->tblHash, zName); + if( p ) return p; + /* Attached databases are in order of attachment */ + for(i=2; inDb; i++){ + assert( sqlite3SchemaMutexHeld(db, i, 0) ); + p = sqlite3HashFind(&db->aDb[i].pSchema->tblHash, zName); + if( p ) break; + } + if( p==0 && sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){ + if( sqlite3StrICmp(zName+7, &PREFERRED_SCHEMA_TABLE[7])==0 ){ + p = sqlite3HashFind(&db->aDb[0].pSchema->tblHash, LEGACY_SCHEMA_TABLE); + }else if( sqlite3StrICmp(zName+7, &PREFERRED_TEMP_SCHEMA_TABLE[7])==0 ){ + p = sqlite3HashFind(&db->aDb[1].pSchema->tblHash, + LEGACY_TEMP_SCHEMA_TABLE); + } + } + } + return p; +} + +/* +** Locate the in-memory structure that describes a particular database +** table given the name of that table and (optionally) the name of the +** database containing the table. Return NULL if not found. Also leave an +** error message in pParse->zErrMsg. +** +** The difference between this routine and sqlite3FindTable() is that this +** routine leaves an error message in pParse->zErrMsg where +** sqlite3FindTable() does not. +*/ +SQLITE_PRIVATE Table *sqlite3LocateTable( + Parse *pParse, /* context in which to report errors */ + u32 flags, /* LOCATE_VIEW or LOCATE_NOERR */ + const char *zName, /* Name of the table we are looking for */ + const char *zDbase /* Name of the database. Might be NULL */ +){ + Table *p; + sqlite3 *db = pParse->db; + + /* Read the database schema. If an error occurs, leave an error message + ** and code in pParse and return NULL. */ + if( (db->mDbFlags & DBFLAG_SchemaKnownOk)==0 + && SQLITE_OK!=sqlite3ReadSchema(pParse) + ){ + return 0; + } + + p = sqlite3FindTable(db, zName, zDbase); + if( p==0 ){ +#ifndef SQLITE_OMIT_VIRTUALTABLE + /* If zName is the not the name of a table in the schema created using + ** CREATE, then check to see if it is the name of an virtual table that + ** can be an eponymous virtual table. */ + if( (pParse->prepFlags & SQLITE_PREPARE_NO_VTAB)==0 && db->init.busy==0 ){ + Module *pMod = (Module*)sqlite3HashFind(&db->aModule, zName); + if( pMod==0 && sqlite3_strnicmp(zName, "pragma_", 7)==0 ){ + pMod = sqlite3PragmaVtabRegister(db, zName); + } + if( pMod && sqlite3VtabEponymousTableInit(pParse, pMod) ){ + testcase( pMod->pEpoTab==0 ); + return pMod->pEpoTab; + } + } +#endif + if( flags & LOCATE_NOERR ) return 0; + pParse->checkSchema = 1; + }else if( IsVirtual(p) && (pParse->prepFlags & SQLITE_PREPARE_NO_VTAB)!=0 ){ + p = 0; + } + + if( p==0 ){ + const char *zMsg = flags & LOCATE_VIEW ? "no such view" : "no such table"; + if( zDbase ){ + sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName); + }else{ + sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName); + } + }else{ + assert( HasRowid(p) || p->iPKey<0 ); + } + + return p; +} + +/* +** Locate the table identified by *p. +** +** This is a wrapper around sqlite3LocateTable(). The difference between +** sqlite3LocateTable() and this function is that this function restricts +** the search to schema (p->pSchema) if it is not NULL. p->pSchema may be +** non-NULL if it is part of a view or trigger program definition. See +** sqlite3FixSrcList() for details. +*/ +SQLITE_PRIVATE Table *sqlite3LocateTableItem( + Parse *pParse, + u32 flags, + SrcItem *p +){ + const char *zDb; + assert( p->pSchema==0 || p->zDatabase==0 ); + if( p->pSchema ){ + int iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema); + zDb = pParse->db->aDb[iDb].zDbSName; + }else{ + zDb = p->zDatabase; + } + return sqlite3LocateTable(pParse, flags, p->zName, zDb); +} + +/* +** Return the preferred table name for system tables. Translate legacy +** names into the new preferred names, as appropriate. +*/ +SQLITE_PRIVATE const char *sqlite3PreferredTableName(const char *zName){ + if( sqlite3StrNICmp(zName, "sqlite_", 7)==0 ){ + if( sqlite3StrICmp(zName+7, &LEGACY_SCHEMA_TABLE[7])==0 ){ + return PREFERRED_SCHEMA_TABLE; + } + if( sqlite3StrICmp(zName+7, &LEGACY_TEMP_SCHEMA_TABLE[7])==0 ){ + return PREFERRED_TEMP_SCHEMA_TABLE; + } + } + return zName; +} + +/* +** Locate the in-memory structure that describes +** a particular index given the name of that index +** and the name of the database that contains the index. +** Return NULL if not found. +** +** If zDatabase is 0, all databases are searched for the +** table and the first matching index is returned. (No checking +** for duplicate index names is done.) The search order is +** TEMP first, then MAIN, then any auxiliary databases added +** using the ATTACH command. +*/ +SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){ + Index *p = 0; + int i; + /* All mutexes are required for schema access. Make sure we hold them. */ + assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) ); + for(i=OMIT_TEMPDB; inDb; i++){ + int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */ + Schema *pSchema = db->aDb[j].pSchema; + assert( pSchema ); + if( zDb && sqlite3DbIsNamed(db, j, zDb)==0 ) continue; + assert( sqlite3SchemaMutexHeld(db, j, 0) ); + p = sqlite3HashFind(&pSchema->idxHash, zName); + if( p ) break; + } + return p; +} + +/* +** Reclaim the memory used by an index +*/ +SQLITE_PRIVATE void sqlite3FreeIndex(sqlite3 *db, Index *p){ +#ifndef SQLITE_OMIT_ANALYZE + sqlite3DeleteIndexSamples(db, p); +#endif + sqlite3ExprDelete(db, p->pPartIdxWhere); + sqlite3ExprListDelete(db, p->aColExpr); + sqlite3DbFree(db, p->zColAff); + if( p->isResized ) sqlite3DbFree(db, (void *)p->azColl); +#ifdef SQLITE_ENABLE_STAT4 + sqlite3_free(p->aiRowEst); +#endif + sqlite3DbFree(db, p); +} + +/* +** For the index called zIdxName which is found in the database iDb, +** unlike that index from its Table then remove the index from +** the index hash table and free all memory structures associated +** with the index. +*/ +SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){ + Index *pIndex; + Hash *pHash; + + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + pHash = &db->aDb[iDb].pSchema->idxHash; + pIndex = sqlite3HashInsert(pHash, zIdxName, 0); + if( ALWAYS(pIndex) ){ + if( pIndex->pTable->pIndex==pIndex ){ + pIndex->pTable->pIndex = pIndex->pNext; + }else{ + Index *p; + /* Justification of ALWAYS(); The index must be on the list of + ** indices. */ + p = pIndex->pTable->pIndex; + while( ALWAYS(p) && p->pNext!=pIndex ){ p = p->pNext; } + if( ALWAYS(p && p->pNext==pIndex) ){ + p->pNext = pIndex->pNext; + } + } + sqlite3FreeIndex(db, pIndex); + } + db->mDbFlags |= DBFLAG_SchemaChange; +} + +/* +** Look through the list of open database files in db->aDb[] and if +** any have been closed, remove them from the list. Reallocate the +** db->aDb[] structure to a smaller size, if possible. +** +** Entry 0 (the "main" database) and entry 1 (the "temp" database) +** are never candidates for being collapsed. +*/ +SQLITE_PRIVATE void sqlite3CollapseDatabaseArray(sqlite3 *db){ + int i, j; + for(i=j=2; inDb; i++){ + struct Db *pDb = &db->aDb[i]; + if( pDb->pBt==0 ){ + sqlite3DbFree(db, pDb->zDbSName); + pDb->zDbSName = 0; + continue; + } + if( jaDb[j] = db->aDb[i]; + } + j++; + } + db->nDb = j; + if( db->nDb<=2 && db->aDb!=db->aDbStatic ){ + memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0])); + sqlite3DbFree(db, db->aDb); + db->aDb = db->aDbStatic; + } +} + +/* +** Reset the schema for the database at index iDb. Also reset the +** TEMP schema. The reset is deferred if db->nSchemaLock is not zero. +** Deferred resets may be run by calling with iDb<0. +*/ +SQLITE_PRIVATE void sqlite3ResetOneSchema(sqlite3 *db, int iDb){ + int i; + assert( iDbnDb ); + + if( iDb>=0 ){ + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + DbSetProperty(db, iDb, DB_ResetWanted); + DbSetProperty(db, 1, DB_ResetWanted); + db->mDbFlags &= ~DBFLAG_SchemaKnownOk; + } + + if( db->nSchemaLock==0 ){ + for(i=0; inDb; i++){ + if( DbHasProperty(db, i, DB_ResetWanted) ){ + sqlite3SchemaClear(db->aDb[i].pSchema); + } + } + } +} + +/* +** Erase all schema information from all attached databases (including +** "main" and "temp") for a single database connection. +*/ +SQLITE_PRIVATE void sqlite3ResetAllSchemasOfConnection(sqlite3 *db){ + int i; + sqlite3BtreeEnterAll(db); + for(i=0; inDb; i++){ + Db *pDb = &db->aDb[i]; + if( pDb->pSchema ){ + if( db->nSchemaLock==0 ){ + sqlite3SchemaClear(pDb->pSchema); + }else{ + DbSetProperty(db, i, DB_ResetWanted); + } + } + } + db->mDbFlags &= ~(DBFLAG_SchemaChange|DBFLAG_SchemaKnownOk); + sqlite3VtabUnlockList(db); + sqlite3BtreeLeaveAll(db); + if( db->nSchemaLock==0 ){ + sqlite3CollapseDatabaseArray(db); + } +} + +/* +** This routine is called when a commit occurs. +*/ +SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3 *db){ + db->mDbFlags &= ~DBFLAG_SchemaChange; +} + +/* +** Set the expression associated with a column. This is usually +** the DEFAULT value, but might also be the expression that computes +** the value for a generated column. +*/ +SQLITE_PRIVATE void sqlite3ColumnSetExpr( + Parse *pParse, /* Parsing context */ + Table *pTab, /* The table containing the column */ + Column *pCol, /* The column to receive the new DEFAULT expression */ + Expr *pExpr /* The new default expression */ +){ + ExprList *pList; + assert( IsOrdinaryTable(pTab) ); + pList = pTab->u.tab.pDfltList; + if( pCol->iDflt==0 + || NEVER(pList==0) + || NEVER(pList->nExpriDflt) + ){ + pCol->iDflt = pList==0 ? 1 : pList->nExpr+1; + pTab->u.tab.pDfltList = sqlite3ExprListAppend(pParse, pList, pExpr); + }else{ + sqlite3ExprDelete(pParse->db, pList->a[pCol->iDflt-1].pExpr); + pList->a[pCol->iDflt-1].pExpr = pExpr; + } +} + +/* +** Return the expression associated with a column. The expression might be +** the DEFAULT clause or the AS clause of a generated column. +** Return NULL if the column has no associated expression. +*/ +SQLITE_PRIVATE Expr *sqlite3ColumnExpr(Table *pTab, Column *pCol){ + if( pCol->iDflt==0 ) return 0; + if( NEVER(!IsOrdinaryTable(pTab)) ) return 0; + if( NEVER(pTab->u.tab.pDfltList==0) ) return 0; + if( NEVER(pTab->u.tab.pDfltList->nExpriDflt) ) return 0; + return pTab->u.tab.pDfltList->a[pCol->iDflt-1].pExpr; +} + +/* +** Set the collating sequence name for a column. +*/ +SQLITE_PRIVATE void sqlite3ColumnSetColl( + sqlite3 *db, + Column *pCol, + const char *zColl +){ + i64 nColl; + i64 n; + char *zNew; + assert( zColl!=0 ); + n = sqlite3Strlen30(pCol->zCnName) + 1; + if( pCol->colFlags & COLFLAG_HASTYPE ){ + n += sqlite3Strlen30(pCol->zCnName+n) + 1; + } + nColl = sqlite3Strlen30(zColl) + 1; + zNew = sqlite3DbRealloc(db, pCol->zCnName, nColl+n); + if( zNew ){ + pCol->zCnName = zNew; + memcpy(pCol->zCnName + n, zColl, nColl); + pCol->colFlags |= COLFLAG_HASCOLL; + } +} + +/* +** Return the collating squence name for a column +*/ +SQLITE_PRIVATE const char *sqlite3ColumnColl(Column *pCol){ + const char *z; + if( (pCol->colFlags & COLFLAG_HASCOLL)==0 ) return 0; + z = pCol->zCnName; + while( *z ){ z++; } + if( pCol->colFlags & COLFLAG_HASTYPE ){ + do{ z++; }while( *z ); + } + return z+1; +} + +/* +** Delete memory allocated for the column names of a table or view (the +** Table.aCol[] array). +*/ +SQLITE_PRIVATE void sqlite3DeleteColumnNames(sqlite3 *db, Table *pTable){ + int i; + Column *pCol; + assert( pTable!=0 ); + assert( db!=0 ); + if( (pCol = pTable->aCol)!=0 ){ + for(i=0; inCol; i++, pCol++){ + assert( pCol->zCnName==0 || pCol->hName==sqlite3StrIHash(pCol->zCnName) ); + sqlite3DbFree(db, pCol->zCnName); + } + sqlite3DbNNFreeNN(db, pTable->aCol); + if( IsOrdinaryTable(pTable) ){ + sqlite3ExprListDelete(db, pTable->u.tab.pDfltList); + } + if( db->pnBytesFreed==0 ){ + pTable->aCol = 0; + pTable->nCol = 0; + if( IsOrdinaryTable(pTable) ){ + pTable->u.tab.pDfltList = 0; + } + } + } +} + +/* +** Remove the memory data structures associated with the given +** Table. No changes are made to disk by this routine. +** +** This routine just deletes the data structure. It does not unlink +** the table data structure from the hash table. But it does destroy +** memory structures of the indices and foreign keys associated with +** the table. +** +** The db parameter is optional. It is needed if the Table object +** contains lookaside memory. (Table objects in the schema do not use +** lookaside memory, but some ephemeral Table objects do.) Or the +** db parameter can be used with db->pnBytesFreed to measure the memory +** used by the Table object. +*/ +static void SQLITE_NOINLINE deleteTable(sqlite3 *db, Table *pTable){ + Index *pIndex, *pNext; + +#ifdef SQLITE_DEBUG + /* Record the number of outstanding lookaside allocations in schema Tables + ** prior to doing any free() operations. Since schema Tables do not use + ** lookaside, this number should not change. + ** + ** If malloc has already failed, it may be that it failed while allocating + ** a Table object that was going to be marked ephemeral. So do not check + ** that no lookaside memory is used in this case either. */ + int nLookaside = 0; + assert( db!=0 ); + if( !db->mallocFailed && (pTable->tabFlags & TF_Ephemeral)==0 ){ + nLookaside = sqlite3LookasideUsed(db, 0); + } +#endif + + /* Delete all indices associated with this table. */ + for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){ + pNext = pIndex->pNext; + assert( pIndex->pSchema==pTable->pSchema + || (IsVirtual(pTable) && pIndex->idxType!=SQLITE_IDXTYPE_APPDEF) ); + if( db->pnBytesFreed==0 && !IsVirtual(pTable) ){ + char *zName = pIndex->zName; + TESTONLY ( Index *pOld = ) sqlite3HashInsert( + &pIndex->pSchema->idxHash, zName, 0 + ); + assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) ); + assert( pOld==pIndex || pOld==0 ); + } + sqlite3FreeIndex(db, pIndex); + } + + if( IsOrdinaryTable(pTable) ){ + sqlite3FkDelete(db, pTable); + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + else if( IsVirtual(pTable) ){ + sqlite3VtabClear(db, pTable); + } +#endif + else{ + assert( IsView(pTable) ); + sqlite3SelectDelete(db, pTable->u.view.pSelect); + } + + /* Delete the Table structure itself. + */ + sqlite3DeleteColumnNames(db, pTable); + sqlite3DbFree(db, pTable->zName); + sqlite3DbFree(db, pTable->zColAff); + sqlite3ExprListDelete(db, pTable->pCheck); + sqlite3DbFree(db, pTable); + + /* Verify that no lookaside memory was used by schema tables */ + assert( nLookaside==0 || nLookaside==sqlite3LookasideUsed(db,0) ); +} +SQLITE_PRIVATE void sqlite3DeleteTable(sqlite3 *db, Table *pTable){ + /* Do not delete the table until the reference count reaches zero. */ + assert( db!=0 ); + if( !pTable ) return; + if( db->pnBytesFreed==0 && (--pTable->nTabRef)>0 ) return; + deleteTable(db, pTable); +} + + +/* +** Unlink the given table from the hash tables and the delete the +** table structure with all its indices and foreign keys. +*/ +SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){ + Table *p; + Db *pDb; + + assert( db!=0 ); + assert( iDb>=0 && iDbnDb ); + assert( zTabName ); + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + testcase( zTabName[0]==0 ); /* Zero-length table names are allowed */ + pDb = &db->aDb[iDb]; + p = sqlite3HashInsert(&pDb->pSchema->tblHash, zTabName, 0); + sqlite3DeleteTable(db, p); + db->mDbFlags |= DBFLAG_SchemaChange; +} + +/* +** Given a token, return a string that consists of the text of that +** token. Space to hold the returned string +** is obtained from sqliteMalloc() and must be freed by the calling +** function. +** +** Any quotation marks (ex: "name", 'name', [name], or `name`) that +** surround the body of the token are removed. +** +** Tokens are often just pointers into the original SQL text and so +** are not \000 terminated and are not persistent. The returned string +** is \000 terminated and is persistent. +*/ +SQLITE_PRIVATE char *sqlite3NameFromToken(sqlite3 *db, const Token *pName){ + char *zName; + if( pName ){ + zName = sqlite3DbStrNDup(db, (const char*)pName->z, pName->n); + sqlite3Dequote(zName); + }else{ + zName = 0; + } + return zName; +} + +/* +** Open the sqlite_schema table stored in database number iDb for +** writing. The table is opened using cursor 0. +*/ +SQLITE_PRIVATE void sqlite3OpenSchemaTable(Parse *p, int iDb){ + Vdbe *v = sqlite3GetVdbe(p); + sqlite3TableLock(p, iDb, SCHEMA_ROOT, 1, LEGACY_SCHEMA_TABLE); + sqlite3VdbeAddOp4Int(v, OP_OpenWrite, 0, SCHEMA_ROOT, iDb, 5); + if( p->nTab==0 ){ + p->nTab = 1; + } +} + +/* +** Parameter zName points to a nul-terminated buffer containing the name +** of a database ("main", "temp" or the name of an attached db). This +** function returns the index of the named database in db->aDb[], or +** -1 if the named db cannot be found. +*/ +SQLITE_PRIVATE int sqlite3FindDbName(sqlite3 *db, const char *zName){ + int i = -1; /* Database number */ + if( zName ){ + Db *pDb; + for(i=(db->nDb-1), pDb=&db->aDb[i]; i>=0; i--, pDb--){ + if( 0==sqlite3_stricmp(pDb->zDbSName, zName) ) break; + /* "main" is always an acceptable alias for the primary database + ** even if it has been renamed using SQLITE_DBCONFIG_MAINDBNAME. */ + if( i==0 && 0==sqlite3_stricmp("main", zName) ) break; + } + } + return i; +} + +/* +** The token *pName contains the name of a database (either "main" or +** "temp" or the name of an attached db). This routine returns the +** index of the named database in db->aDb[], or -1 if the named db +** does not exist. +*/ +SQLITE_PRIVATE int sqlite3FindDb(sqlite3 *db, Token *pName){ + int i; /* Database number */ + char *zName; /* Name we are searching for */ + zName = sqlite3NameFromToken(db, pName); + i = sqlite3FindDbName(db, zName); + sqlite3DbFree(db, zName); + return i; +} + +/* The table or view or trigger name is passed to this routine via tokens +** pName1 and pName2. If the table name was fully qualified, for example: +** +** CREATE TABLE xxx.yyy (...); +** +** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if +** the table name is not fully qualified, i.e.: +** +** CREATE TABLE yyy(...); +** +** Then pName1 is set to "yyy" and pName2 is "". +** +** This routine sets the *ppUnqual pointer to point at the token (pName1 or +** pName2) that stores the unqualified table name. The index of the +** database "xxx" is returned. +*/ +SQLITE_PRIVATE int sqlite3TwoPartName( + Parse *pParse, /* Parsing and code generating context */ + Token *pName1, /* The "xxx" in the name "xxx.yyy" or "xxx" */ + Token *pName2, /* The "yyy" in the name "xxx.yyy" */ + Token **pUnqual /* Write the unqualified object name here */ +){ + int iDb; /* Database holding the object */ + sqlite3 *db = pParse->db; + + assert( pName2!=0 ); + if( pName2->n>0 ){ + if( db->init.busy ) { + sqlite3ErrorMsg(pParse, "corrupt database"); + return -1; + } + *pUnqual = pName2; + iDb = sqlite3FindDb(db, pName1); + if( iDb<0 ){ + sqlite3ErrorMsg(pParse, "unknown database %T", pName1); + return -1; + } + }else{ + assert( db->init.iDb==0 || db->init.busy || IN_SPECIAL_PARSE + || (db->mDbFlags & DBFLAG_Vacuum)!=0); + iDb = db->init.iDb; + *pUnqual = pName1; + } + return iDb; +} + +/* +** True if PRAGMA writable_schema is ON +*/ +SQLITE_PRIVATE int sqlite3WritableSchema(sqlite3 *db){ + testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==0 ); + testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))== + SQLITE_WriteSchema ); + testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))== + SQLITE_Defensive ); + testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))== + (SQLITE_WriteSchema|SQLITE_Defensive) ); + return (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==SQLITE_WriteSchema; +} + +/* +** This routine is used to check if the UTF-8 string zName is a legal +** unqualified name for a new schema object (table, index, view or +** trigger). All names are legal except those that begin with the string +** "sqlite_" (in upper, lower or mixed case). This portion of the namespace +** is reserved for internal use. +** +** When parsing the sqlite_schema table, this routine also checks to +** make sure the "type", "name", and "tbl_name" columns are consistent +** with the SQL. +*/ +SQLITE_PRIVATE int sqlite3CheckObjectName( + Parse *pParse, /* Parsing context */ + const char *zName, /* Name of the object to check */ + const char *zType, /* Type of this object */ + const char *zTblName /* Parent table name for triggers and indexes */ +){ + sqlite3 *db = pParse->db; + if( sqlite3WritableSchema(db) + || db->init.imposterTable + || !sqlite3Config.bExtraSchemaChecks + ){ + /* Skip these error checks for writable_schema=ON */ + return SQLITE_OK; + } + if( db->init.busy ){ + if( sqlite3_stricmp(zType, db->init.azInit[0]) + || sqlite3_stricmp(zName, db->init.azInit[1]) + || sqlite3_stricmp(zTblName, db->init.azInit[2]) + ){ + sqlite3ErrorMsg(pParse, ""); /* corruptSchema() will supply the error */ + return SQLITE_ERROR; + } + }else{ + if( (pParse->nested==0 && 0==sqlite3StrNICmp(zName, "sqlite_", 7)) + || (sqlite3ReadOnlyShadowTables(db) && sqlite3ShadowTableName(db, zName)) + ){ + sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s", + zName); + return SQLITE_ERROR; + } + + } + return SQLITE_OK; +} + +/* +** Return the PRIMARY KEY index of a table +*/ +SQLITE_PRIVATE Index *sqlite3PrimaryKeyIndex(Table *pTab){ + Index *p; + for(p=pTab->pIndex; p && !IsPrimaryKeyIndex(p); p=p->pNext){} + return p; +} + +/* +** Convert an table column number into a index column number. That is, +** for the column iCol in the table (as defined by the CREATE TABLE statement) +** find the (first) offset of that column in index pIdx. Or return -1 +** if column iCol is not used in index pIdx. +*/ +SQLITE_PRIVATE i16 sqlite3TableColumnToIndex(Index *pIdx, i16 iCol){ + int i; + for(i=0; inColumn; i++){ + if( iCol==pIdx->aiColumn[i] ) return i; + } + return -1; +} + +#ifndef SQLITE_OMIT_GENERATED_COLUMNS +/* Convert a storage column number into a table column number. +** +** The storage column number (0,1,2,....) is the index of the value +** as it appears in the record on disk. The true column number +** is the index (0,1,2,...) of the column in the CREATE TABLE statement. +** +** The storage column number is less than the table column number if +** and only there are VIRTUAL columns to the left. +** +** If SQLITE_OMIT_GENERATED_COLUMNS, this routine is a no-op macro. +*/ +SQLITE_PRIVATE i16 sqlite3StorageColumnToTable(Table *pTab, i16 iCol){ + if( pTab->tabFlags & TF_HasVirtual ){ + int i; + for(i=0; i<=iCol; i++){ + if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) iCol++; + } + } + return iCol; +} +#endif + +#ifndef SQLITE_OMIT_GENERATED_COLUMNS +/* Convert a table column number into a storage column number. +** +** The storage column number (0,1,2,....) is the index of the value +** as it appears in the record on disk. Or, if the input column is +** the N-th virtual column (zero-based) then the storage number is +** the number of non-virtual columns in the table plus N. +** +** The true column number is the index (0,1,2,...) of the column in +** the CREATE TABLE statement. +** +** If the input column is a VIRTUAL column, then it should not appear +** in storage. But the value sometimes is cached in registers that +** follow the range of registers used to construct storage. This +** avoids computing the same VIRTUAL column multiple times, and provides +** values for use by OP_Param opcodes in triggers. Hence, if the +** input column is a VIRTUAL table, put it after all the other columns. +** +** In the following, N means "normal column", S means STORED, and +** V means VIRTUAL. Suppose the CREATE TABLE has columns like this: +** +** CREATE TABLE ex(N,S,V,N,S,V,N,S,V); +** -- 0 1 2 3 4 5 6 7 8 +** +** Then the mapping from this function is as follows: +** +** INPUTS: 0 1 2 3 4 5 6 7 8 +** OUTPUTS: 0 1 6 2 3 7 4 5 8 +** +** So, in other words, this routine shifts all the virtual columns to +** the end. +** +** If SQLITE_OMIT_GENERATED_COLUMNS then there are no virtual columns and +** this routine is a no-op macro. If the pTab does not have any virtual +** columns, then this routine is no-op that always return iCol. If iCol +** is negative (indicating the ROWID column) then this routine return iCol. +*/ +SQLITE_PRIVATE i16 sqlite3TableColumnToStorage(Table *pTab, i16 iCol){ + int i; + i16 n; + assert( iColnCol ); + if( (pTab->tabFlags & TF_HasVirtual)==0 || iCol<0 ) return iCol; + for(i=0, n=0; iaCol[i].colFlags & COLFLAG_VIRTUAL)==0 ) n++; + } + if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ){ + /* iCol is a virtual column itself */ + return pTab->nNVCol + i - n; + }else{ + /* iCol is a normal or stored column */ + return n; + } +} +#endif + +/* +** Insert a single OP_JournalMode query opcode in order to force the +** prepared statement to return false for sqlite3_stmt_readonly(). This +** is used by CREATE TABLE IF NOT EXISTS and similar if the table already +** exists, so that the prepared statement for CREATE TABLE IF NOT EXISTS +** will return false for sqlite3_stmt_readonly() even if that statement +** is a read-only no-op. +*/ +static void sqlite3ForceNotReadOnly(Parse *pParse){ + int iReg = ++pParse->nMem; + Vdbe *v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3VdbeAddOp3(v, OP_JournalMode, 0, iReg, PAGER_JOURNALMODE_QUERY); + sqlite3VdbeUsesBtree(v, 0); + } +} + +/* +** Begin constructing a new table representation in memory. This is +** the first of several action routines that get called in response +** to a CREATE TABLE statement. In particular, this routine is called +** after seeing tokens "CREATE" and "TABLE" and the table name. The isTemp +** flag is true if the table should be stored in the auxiliary database +** file instead of in the main database file. This is normally the case +** when the "TEMP" or "TEMPORARY" keyword occurs in between +** CREATE and TABLE. +** +** The new table record is initialized and put in pParse->pNewTable. +** As more of the CREATE TABLE statement is parsed, additional action +** routines will be called to add more information to this record. +** At the end of the CREATE TABLE statement, the sqlite3EndTable() routine +** is called to complete the construction of the new table record. +*/ +SQLITE_PRIVATE void sqlite3StartTable( + Parse *pParse, /* Parser context */ + Token *pName1, /* First part of the name of the table or view */ + Token *pName2, /* Second part of the name of the table or view */ + int isTemp, /* True if this is a TEMP table */ + int isView, /* True if this is a VIEW */ + int isVirtual, /* True if this is a VIRTUAL table */ + int noErr /* Do nothing if table already exists */ +){ + Table *pTable; + char *zName = 0; /* The name of the new table */ + sqlite3 *db = pParse->db; + Vdbe *v; + int iDb; /* Database number to create the table in */ + Token *pName; /* Unqualified name of the table to create */ + + if( db->init.busy && db->init.newTnum==1 ){ + /* Special case: Parsing the sqlite_schema or sqlite_temp_schema schema */ + iDb = db->init.iDb; + zName = sqlite3DbStrDup(db, SCHEMA_TABLE(iDb)); + pName = pName1; + }else{ + /* The common case */ + iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName); + if( iDb<0 ) return; + if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){ + /* If creating a temp table, the name may not be qualified. Unless + ** the database name is "temp" anyway. */ + sqlite3ErrorMsg(pParse, "temporary table name must be unqualified"); + return; + } + if( !OMIT_TEMPDB && isTemp ) iDb = 1; + zName = sqlite3NameFromToken(db, pName); + if( IN_RENAME_OBJECT ){ + sqlite3RenameTokenMap(pParse, (void*)zName, pName); + } + } + pParse->sNameToken = *pName; + if( zName==0 ) return; + if( sqlite3CheckObjectName(pParse, zName, isView?"view":"table", zName) ){ + goto begin_table_error; + } + if( db->init.iDb==1 ) isTemp = 1; +#ifndef SQLITE_OMIT_AUTHORIZATION + assert( isTemp==0 || isTemp==1 ); + assert( isView==0 || isView==1 ); + { + static const u8 aCode[] = { + SQLITE_CREATE_TABLE, + SQLITE_CREATE_TEMP_TABLE, + SQLITE_CREATE_VIEW, + SQLITE_CREATE_TEMP_VIEW + }; + char *zDb = db->aDb[iDb].zDbSName; + if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){ + goto begin_table_error; + } + if( !isVirtual && sqlite3AuthCheck(pParse, (int)aCode[isTemp+2*isView], + zName, 0, zDb) ){ + goto begin_table_error; + } + } +#endif + + /* Make sure the new table name does not collide with an existing + ** index or table name in the same database. Issue an error message if + ** it does. The exception is if the statement being parsed was passed + ** to an sqlite3_declare_vtab() call. In that case only the column names + ** and types will be used, so there is no need to test for namespace + ** collisions. + */ + if( !IN_SPECIAL_PARSE ){ + char *zDb = db->aDb[iDb].zDbSName; + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + goto begin_table_error; + } + pTable = sqlite3FindTable(db, zName, zDb); + if( pTable ){ + if( !noErr ){ + sqlite3ErrorMsg(pParse, "%s %T already exists", + (IsView(pTable)? "view" : "table"), pName); + }else{ + assert( !db->init.busy || CORRUPT_DB ); + sqlite3CodeVerifySchema(pParse, iDb); + sqlite3ForceNotReadOnly(pParse); + } + goto begin_table_error; + } + if( sqlite3FindIndex(db, zName, zDb)!=0 ){ + sqlite3ErrorMsg(pParse, "there is already an index named %s", zName); + goto begin_table_error; + } + } + + pTable = sqlite3DbMallocZero(db, sizeof(Table)); + if( pTable==0 ){ + assert( db->mallocFailed ); + pParse->rc = SQLITE_NOMEM_BKPT; + pParse->nErr++; + goto begin_table_error; + } + pTable->zName = zName; + pTable->iPKey = -1; + pTable->pSchema = db->aDb[iDb].pSchema; + pTable->nTabRef = 1; +#ifdef SQLITE_DEFAULT_ROWEST + pTable->nRowLogEst = sqlite3LogEst(SQLITE_DEFAULT_ROWEST); +#else + pTable->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) ); +#endif + assert( pParse->pNewTable==0 ); + pParse->pNewTable = pTable; + + /* Begin generating the code that will insert the table record into + ** the schema table. Note in particular that we must go ahead + ** and allocate the record number for the table entry now. Before any + ** PRIMARY KEY or UNIQUE keywords are parsed. Those keywords will cause + ** indices to be created and the table record must come before the + ** indices. Hence, the record number for the table must be allocated + ** now. + */ + if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){ + int addr1; + int fileFormat; + int reg1, reg2, reg3; + /* nullRow[] is an OP_Record encoding of a row containing 5 NULLs */ + static const char nullRow[] = { 6, 0, 0, 0, 0, 0 }; + sqlite3BeginWriteOperation(pParse, 1, iDb); + +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( isVirtual ){ + sqlite3VdbeAddOp0(v, OP_VBegin); + } +#endif + + /* If the file format and encoding in the database have not been set, + ** set them now. + */ + reg1 = pParse->regRowid = ++pParse->nMem; + reg2 = pParse->regRoot = ++pParse->nMem; + reg3 = ++pParse->nMem; + sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT); + sqlite3VdbeUsesBtree(v, iDb); + addr1 = sqlite3VdbeAddOp1(v, OP_If, reg3); VdbeCoverage(v); + fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ? + 1 : SQLITE_MAX_FILE_FORMAT; + sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, fileFormat); + sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, ENC(db)); + sqlite3VdbeJumpHere(v, addr1); + + /* This just creates a place-holder record in the sqlite_schema table. + ** The record created does not contain anything yet. It will be replaced + ** by the real entry in code generated at sqlite3EndTable(). + ** + ** The rowid for the new entry is left in register pParse->regRowid. + ** The root page number of the new table is left in reg pParse->regRoot. + ** The rowid and root page number values are needed by the code that + ** sqlite3EndTable will generate. + */ +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) + if( isView || isVirtual ){ + sqlite3VdbeAddOp2(v, OP_Integer, 0, reg2); + }else +#endif + { + assert( !pParse->bReturning ); + pParse->u1.addrCrTab = + sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, reg2, BTREE_INTKEY); + } + sqlite3OpenSchemaTable(pParse, iDb); + sqlite3VdbeAddOp2(v, OP_NewRowid, 0, reg1); + sqlite3VdbeAddOp4(v, OP_Blob, 6, reg3, 0, nullRow, P4_STATIC); + sqlite3VdbeAddOp3(v, OP_Insert, 0, reg3, reg1); + sqlite3VdbeChangeP5(v, OPFLAG_APPEND); + sqlite3VdbeAddOp0(v, OP_Close); + } + + /* Normal (non-error) return. */ + return; + + /* If an error occurs, we jump here */ +begin_table_error: + pParse->checkSchema = 1; + sqlite3DbFree(db, zName); + return; +} + +/* Set properties of a table column based on the (magical) +** name of the column. +*/ +#if SQLITE_ENABLE_HIDDEN_COLUMNS +SQLITE_PRIVATE void sqlite3ColumnPropertiesFromName(Table *pTab, Column *pCol){ + if( sqlite3_strnicmp(pCol->zCnName, "__hidden__", 10)==0 ){ + pCol->colFlags |= COLFLAG_HIDDEN; + if( pTab ) pTab->tabFlags |= TF_HasHidden; + }else if( pTab && pCol!=pTab->aCol && (pCol[-1].colFlags & COLFLAG_HIDDEN) ){ + pTab->tabFlags |= TF_OOOHidden; + } +} +#endif + +/* +** Name of the special TEMP trigger used to implement RETURNING. The +** name begins with "sqlite_" so that it is guaranteed not to collide +** with any application-generated triggers. +*/ +#define RETURNING_TRIGGER_NAME "sqlite_returning" + +/* +** Clean up the data structures associated with the RETURNING clause. +*/ +static void sqlite3DeleteReturning(sqlite3 *db, Returning *pRet){ + Hash *pHash; + pHash = &(db->aDb[1].pSchema->trigHash); + sqlite3HashInsert(pHash, RETURNING_TRIGGER_NAME, 0); + sqlite3ExprListDelete(db, pRet->pReturnEL); + sqlite3DbFree(db, pRet); +} + +/* +** Add the RETURNING clause to the parse currently underway. +** +** This routine creates a special TEMP trigger that will fire for each row +** of the DML statement. That TEMP trigger contains a single SELECT +** statement with a result set that is the argument of the RETURNING clause. +** The trigger has the Trigger.bReturning flag and an opcode of +** TK_RETURNING instead of TK_SELECT, so that the trigger code generator +** knows to handle it specially. The TEMP trigger is automatically +** removed at the end of the parse. +** +** When this routine is called, we do not yet know if the RETURNING clause +** is attached to a DELETE, INSERT, or UPDATE, so construct it as a +** RETURNING trigger instead. It will then be converted into the appropriate +** type on the first call to sqlite3TriggersExist(). +*/ +SQLITE_PRIVATE void sqlite3AddReturning(Parse *pParse, ExprList *pList){ + Returning *pRet; + Hash *pHash; + sqlite3 *db = pParse->db; + if( pParse->pNewTrigger ){ + sqlite3ErrorMsg(pParse, "cannot use RETURNING in a trigger"); + }else{ + assert( pParse->bReturning==0 || pParse->ifNotExists ); + } + pParse->bReturning = 1; + pRet = sqlite3DbMallocZero(db, sizeof(*pRet)); + if( pRet==0 ){ + sqlite3ExprListDelete(db, pList); + return; + } + pParse->u1.pReturning = pRet; + pRet->pParse = pParse; + pRet->pReturnEL = pList; + sqlite3ParserAddCleanup(pParse, + (void(*)(sqlite3*,void*))sqlite3DeleteReturning, pRet); + testcase( pParse->earlyCleanup ); + if( db->mallocFailed ) return; + pRet->retTrig.zName = RETURNING_TRIGGER_NAME; + pRet->retTrig.op = TK_RETURNING; + pRet->retTrig.tr_tm = TRIGGER_AFTER; + pRet->retTrig.bReturning = 1; + pRet->retTrig.pSchema = db->aDb[1].pSchema; + pRet->retTrig.pTabSchema = db->aDb[1].pSchema; + pRet->retTrig.step_list = &pRet->retTStep; + pRet->retTStep.op = TK_RETURNING; + pRet->retTStep.pTrig = &pRet->retTrig; + pRet->retTStep.pExprList = pList; + pHash = &(db->aDb[1].pSchema->trigHash); + assert( sqlite3HashFind(pHash, RETURNING_TRIGGER_NAME)==0 + || pParse->nErr || pParse->ifNotExists ); + if( sqlite3HashInsert(pHash, RETURNING_TRIGGER_NAME, &pRet->retTrig) + ==&pRet->retTrig ){ + sqlite3OomFault(db); + } +} + +/* +** Add a new column to the table currently being constructed. +** +** The parser calls this routine once for each column declaration +** in a CREATE TABLE statement. sqlite3StartTable() gets called +** first to get things going. Then this routine is called for each +** column. +*/ +SQLITE_PRIVATE void sqlite3AddColumn(Parse *pParse, Token sName, Token sType){ + Table *p; + int i; + char *z; + char *zType; + Column *pCol; + sqlite3 *db = pParse->db; + u8 hName; + Column *aNew; + u8 eType = COLTYPE_CUSTOM; + u8 szEst = 1; + char affinity = SQLITE_AFF_BLOB; + + if( (p = pParse->pNewTable)==0 ) return; + if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){ + sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName); + return; + } + if( !IN_RENAME_OBJECT ) sqlite3DequoteToken(&sName); + + /* Because keywords GENERATE ALWAYS can be converted into indentifiers + ** by the parser, we can sometimes end up with a typename that ends + ** with "generated always". Check for this case and omit the surplus + ** text. */ + if( sType.n>=16 + && sqlite3_strnicmp(sType.z+(sType.n-6),"always",6)==0 + ){ + sType.n -= 6; + while( ALWAYS(sType.n>0) && sqlite3Isspace(sType.z[sType.n-1]) ) sType.n--; + if( sType.n>=9 + && sqlite3_strnicmp(sType.z+(sType.n-9),"generated",9)==0 + ){ + sType.n -= 9; + while( sType.n>0 && sqlite3Isspace(sType.z[sType.n-1]) ) sType.n--; + } + } + + /* Check for standard typenames. For standard typenames we will + ** set the Column.eType field rather than storing the typename after + ** the column name, in order to save space. */ + if( sType.n>=3 ){ + sqlite3DequoteToken(&sType); + for(i=0; i0) ); + if( z==0 ) return; + if( IN_RENAME_OBJECT ) sqlite3RenameTokenMap(pParse, (void*)z, &sName); + memcpy(z, sName.z, sName.n); + z[sName.n] = 0; + sqlite3Dequote(z); + hName = sqlite3StrIHash(z); + for(i=0; inCol; i++){ + if( p->aCol[i].hName==hName && sqlite3StrICmp(z, p->aCol[i].zCnName)==0 ){ + sqlite3ErrorMsg(pParse, "duplicate column name: %s", z); + sqlite3DbFree(db, z); + return; + } + } + aNew = sqlite3DbRealloc(db,p->aCol,((i64)p->nCol+1)*sizeof(p->aCol[0])); + if( aNew==0 ){ + sqlite3DbFree(db, z); + return; + } + p->aCol = aNew; + pCol = &p->aCol[p->nCol]; + memset(pCol, 0, sizeof(p->aCol[0])); + pCol->zCnName = z; + pCol->hName = hName; + sqlite3ColumnPropertiesFromName(p, pCol); + + if( sType.n==0 ){ + /* If there is no type specified, columns have the default affinity + ** 'BLOB' with a default size of 4 bytes. */ + pCol->affinity = affinity; + pCol->eCType = eType; + pCol->szEst = szEst; +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + if( affinity==SQLITE_AFF_BLOB ){ + if( 4>=sqlite3GlobalConfig.szSorterRef ){ + pCol->colFlags |= COLFLAG_SORTERREF; + } + } +#endif + }else{ + zType = z + sqlite3Strlen30(z) + 1; + memcpy(zType, sType.z, sType.n); + zType[sType.n] = 0; + sqlite3Dequote(zType); + pCol->affinity = sqlite3AffinityType(zType, pCol); + pCol->colFlags |= COLFLAG_HASTYPE; + } + p->nCol++; + p->nNVCol++; + pParse->constraintName.n = 0; +} + +/* +** This routine is called by the parser while in the middle of +** parsing a CREATE TABLE statement. A "NOT NULL" constraint has +** been seen on a column. This routine sets the notNull flag on +** the column currently under construction. +*/ +SQLITE_PRIVATE void sqlite3AddNotNull(Parse *pParse, int onError){ + Table *p; + Column *pCol; + p = pParse->pNewTable; + if( p==0 || NEVER(p->nCol<1) ) return; + pCol = &p->aCol[p->nCol-1]; + pCol->notNull = (u8)onError; + p->tabFlags |= TF_HasNotNull; + + /* Set the uniqNotNull flag on any UNIQUE or PK indexes already created + ** on this column. */ + if( pCol->colFlags & COLFLAG_UNIQUE ){ + Index *pIdx; + for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){ + assert( pIdx->nKeyCol==1 && pIdx->onError!=OE_None ); + if( pIdx->aiColumn[0]==p->nCol-1 ){ + pIdx->uniqNotNull = 1; + } + } + } +} + +/* +** Scan the column type name zType (length nType) and return the +** associated affinity type. +** +** This routine does a case-independent search of zType for the +** substrings in the following table. If one of the substrings is +** found, the corresponding affinity is returned. If zType contains +** more than one of the substrings, entries toward the top of +** the table take priority. For example, if zType is 'BLOBINT', +** SQLITE_AFF_INTEGER is returned. +** +** Substring | Affinity +** -------------------------------- +** 'INT' | SQLITE_AFF_INTEGER +** 'CHAR' | SQLITE_AFF_TEXT +** 'CLOB' | SQLITE_AFF_TEXT +** 'TEXT' | SQLITE_AFF_TEXT +** 'BLOB' | SQLITE_AFF_BLOB +** 'REAL' | SQLITE_AFF_REAL +** 'FLOA' | SQLITE_AFF_REAL +** 'DOUB' | SQLITE_AFF_REAL +** +** If none of the substrings in the above table are found, +** SQLITE_AFF_NUMERIC is returned. +*/ +SQLITE_PRIVATE char sqlite3AffinityType(const char *zIn, Column *pCol){ + u32 h = 0; + char aff = SQLITE_AFF_NUMERIC; + const char *zChar = 0; + + assert( zIn!=0 ); + while( zIn[0] ){ + h = (h<<8) + sqlite3UpperToLower[(*zIn)&0xff]; + zIn++; + if( h==(('c'<<24)+('h'<<16)+('a'<<8)+'r') ){ /* CHAR */ + aff = SQLITE_AFF_TEXT; + zChar = zIn; + }else if( h==(('c'<<24)+('l'<<16)+('o'<<8)+'b') ){ /* CLOB */ + aff = SQLITE_AFF_TEXT; + }else if( h==(('t'<<24)+('e'<<16)+('x'<<8)+'t') ){ /* TEXT */ + aff = SQLITE_AFF_TEXT; + }else if( h==(('b'<<24)+('l'<<16)+('o'<<8)+'b') /* BLOB */ + && (aff==SQLITE_AFF_NUMERIC || aff==SQLITE_AFF_REAL) ){ + aff = SQLITE_AFF_BLOB; + if( zIn[0]=='(' ) zChar = zIn; +#ifndef SQLITE_OMIT_FLOATING_POINT + }else if( h==(('r'<<24)+('e'<<16)+('a'<<8)+'l') /* REAL */ + && aff==SQLITE_AFF_NUMERIC ){ + aff = SQLITE_AFF_REAL; + }else if( h==(('f'<<24)+('l'<<16)+('o'<<8)+'a') /* FLOA */ + && aff==SQLITE_AFF_NUMERIC ){ + aff = SQLITE_AFF_REAL; + }else if( h==(('d'<<24)+('o'<<16)+('u'<<8)+'b') /* DOUB */ + && aff==SQLITE_AFF_NUMERIC ){ + aff = SQLITE_AFF_REAL; +#endif + }else if( (h&0x00FFFFFF)==(('i'<<16)+('n'<<8)+'t') ){ /* INT */ + aff = SQLITE_AFF_INTEGER; + break; + } + } + + /* If pCol is not NULL, store an estimate of the field size. The + ** estimate is scaled so that the size of an integer is 1. */ + if( pCol ){ + int v = 0; /* default size is approx 4 bytes */ + if( aff r=(k/4+1) */ + sqlite3GetInt32(zChar, &v); + break; + } + zChar++; + } + }else{ + v = 16; /* BLOB, TEXT, CLOB -> r=5 (approx 20 bytes)*/ + } + } +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + if( v>=sqlite3GlobalConfig.szSorterRef ){ + pCol->colFlags |= COLFLAG_SORTERREF; + } +#endif + v = v/4 + 1; + if( v>255 ) v = 255; + pCol->szEst = v; + } + return aff; +} + +/* +** The expression is the default value for the most recently added column +** of the table currently under construction. +** +** Default value expressions must be constant. Raise an exception if this +** is not the case. +** +** This routine is called by the parser while in the middle of +** parsing a CREATE TABLE statement. +*/ +SQLITE_PRIVATE void sqlite3AddDefaultValue( + Parse *pParse, /* Parsing context */ + Expr *pExpr, /* The parsed expression of the default value */ + const char *zStart, /* Start of the default value text */ + const char *zEnd /* First character past end of defaut value text */ +){ + Table *p; + Column *pCol; + sqlite3 *db = pParse->db; + p = pParse->pNewTable; + if( p!=0 ){ + int isInit = db->init.busy && db->init.iDb!=1; + pCol = &(p->aCol[p->nCol-1]); + if( !sqlite3ExprIsConstantOrFunction(pExpr, isInit) ){ + sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant", + pCol->zCnName); +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + }else if( pCol->colFlags & COLFLAG_GENERATED ){ + testcase( pCol->colFlags & COLFLAG_VIRTUAL ); + testcase( pCol->colFlags & COLFLAG_STORED ); + sqlite3ErrorMsg(pParse, "cannot use DEFAULT on a generated column"); +#endif + }else{ + /* A copy of pExpr is used instead of the original, as pExpr contains + ** tokens that point to volatile memory. + */ + Expr x, *pDfltExpr; + memset(&x, 0, sizeof(x)); + x.op = TK_SPAN; + x.u.zToken = sqlite3DbSpanDup(db, zStart, zEnd); + x.pLeft = pExpr; + x.flags = EP_Skip; + pDfltExpr = sqlite3ExprDup(db, &x, EXPRDUP_REDUCE); + sqlite3DbFree(db, x.u.zToken); + sqlite3ColumnSetExpr(pParse, p, pCol, pDfltExpr); + } + } + if( IN_RENAME_OBJECT ){ + sqlite3RenameExprUnmap(pParse, pExpr); + } + sqlite3ExprDelete(db, pExpr); +} + +/* +** Backwards Compatibility Hack: +** +** Historical versions of SQLite accepted strings as column names in +** indexes and PRIMARY KEY constraints and in UNIQUE constraints. Example: +** +** CREATE TABLE xyz(a,b,c,d,e,PRIMARY KEY('a'),UNIQUE('b','c' COLLATE trim) +** CREATE INDEX abc ON xyz('c','d' DESC,'e' COLLATE nocase DESC); +** +** This is goofy. But to preserve backwards compatibility we continue to +** accept it. This routine does the necessary conversion. It converts +** the expression given in its argument from a TK_STRING into a TK_ID +** if the expression is just a TK_STRING with an optional COLLATE clause. +** If the expression is anything other than TK_STRING, the expression is +** unchanged. +*/ +static void sqlite3StringToId(Expr *p){ + if( p->op==TK_STRING ){ + p->op = TK_ID; + }else if( p->op==TK_COLLATE && p->pLeft->op==TK_STRING ){ + p->pLeft->op = TK_ID; + } +} + +/* +** Tag the given column as being part of the PRIMARY KEY +*/ +static void makeColumnPartOfPrimaryKey(Parse *pParse, Column *pCol){ + pCol->colFlags |= COLFLAG_PRIMKEY; +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + if( pCol->colFlags & COLFLAG_GENERATED ){ + testcase( pCol->colFlags & COLFLAG_VIRTUAL ); + testcase( pCol->colFlags & COLFLAG_STORED ); + sqlite3ErrorMsg(pParse, + "generated columns cannot be part of the PRIMARY KEY"); + } +#endif +} + +/* +** Designate the PRIMARY KEY for the table. pList is a list of names +** of columns that form the primary key. If pList is NULL, then the +** most recently added column of the table is the primary key. +** +** A table can have at most one primary key. If the table already has +** a primary key (and this is the second primary key) then create an +** error. +** +** If the PRIMARY KEY is on a single column whose datatype is INTEGER, +** then we will try to use that column as the rowid. Set the Table.iPKey +** field of the table under construction to be the index of the +** INTEGER PRIMARY KEY column. Table.iPKey is set to -1 if there is +** no INTEGER PRIMARY KEY. +** +** If the key is not an INTEGER PRIMARY KEY, then create a unique +** index for the key. No index is created for INTEGER PRIMARY KEYs. +*/ +SQLITE_PRIVATE void sqlite3AddPrimaryKey( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* List of field names to be indexed */ + int onError, /* What to do with a uniqueness conflict */ + int autoInc, /* True if the AUTOINCREMENT keyword is present */ + int sortOrder /* SQLITE_SO_ASC or SQLITE_SO_DESC */ +){ + Table *pTab = pParse->pNewTable; + Column *pCol = 0; + int iCol = -1, i; + int nTerm; + if( pTab==0 ) goto primary_key_exit; + if( pTab->tabFlags & TF_HasPrimaryKey ){ + sqlite3ErrorMsg(pParse, + "table \"%s\" has more than one primary key", pTab->zName); + goto primary_key_exit; + } + pTab->tabFlags |= TF_HasPrimaryKey; + if( pList==0 ){ + iCol = pTab->nCol - 1; + pCol = &pTab->aCol[iCol]; + makeColumnPartOfPrimaryKey(pParse, pCol); + nTerm = 1; + }else{ + nTerm = pList->nExpr; + for(i=0; ia[i].pExpr); + assert( pCExpr!=0 ); + sqlite3StringToId(pCExpr); + if( pCExpr->op==TK_ID ){ + const char *zCName; + assert( !ExprHasProperty(pCExpr, EP_IntValue) ); + zCName = pCExpr->u.zToken; + for(iCol=0; iColnCol; iCol++){ + if( sqlite3StrICmp(zCName, pTab->aCol[iCol].zCnName)==0 ){ + pCol = &pTab->aCol[iCol]; + makeColumnPartOfPrimaryKey(pParse, pCol); + break; + } + } + } + } + } + if( nTerm==1 + && pCol + && pCol->eCType==COLTYPE_INTEGER + && sortOrder!=SQLITE_SO_DESC + ){ + if( IN_RENAME_OBJECT && pList ){ + Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[0].pExpr); + sqlite3RenameTokenRemap(pParse, &pTab->iPKey, pCExpr); + } + pTab->iPKey = iCol; + pTab->keyConf = (u8)onError; + assert( autoInc==0 || autoInc==1 ); + pTab->tabFlags |= autoInc*TF_Autoincrement; + if( pList ) pParse->iPkSortOrder = pList->a[0].fg.sortFlags; + (void)sqlite3HasExplicitNulls(pParse, pList); + }else if( autoInc ){ +#ifndef SQLITE_OMIT_AUTOINCREMENT + sqlite3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an " + "INTEGER PRIMARY KEY"); +#endif + }else{ + sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0, + 0, sortOrder, 0, SQLITE_IDXTYPE_PRIMARYKEY); + pList = 0; + } + +primary_key_exit: + sqlite3ExprListDelete(pParse->db, pList); + return; +} + +/* +** Add a new CHECK constraint to the table currently under construction. +*/ +SQLITE_PRIVATE void sqlite3AddCheckConstraint( + Parse *pParse, /* Parsing context */ + Expr *pCheckExpr, /* The check expression */ + const char *zStart, /* Opening "(" */ + const char *zEnd /* Closing ")" */ +){ +#ifndef SQLITE_OMIT_CHECK + Table *pTab = pParse->pNewTable; + sqlite3 *db = pParse->db; + if( pTab && !IN_DECLARE_VTAB + && !sqlite3BtreeIsReadonly(db->aDb[db->init.iDb].pBt) + ){ + pTab->pCheck = sqlite3ExprListAppend(pParse, pTab->pCheck, pCheckExpr); + if( pParse->constraintName.n ){ + sqlite3ExprListSetName(pParse, pTab->pCheck, &pParse->constraintName, 1); + }else{ + Token t; + for(zStart++; sqlite3Isspace(zStart[0]); zStart++){} + while( sqlite3Isspace(zEnd[-1]) ){ zEnd--; } + t.z = zStart; + t.n = (int)(zEnd - t.z); + sqlite3ExprListSetName(pParse, pTab->pCheck, &t, 1); + } + }else +#endif + { + sqlite3ExprDelete(pParse->db, pCheckExpr); + } +} + +/* +** Set the collation function of the most recently parsed table column +** to the CollSeq given. +*/ +SQLITE_PRIVATE void sqlite3AddCollateType(Parse *pParse, Token *pToken){ + Table *p; + int i; + char *zColl; /* Dequoted name of collation sequence */ + sqlite3 *db; + + if( (p = pParse->pNewTable)==0 || IN_RENAME_OBJECT ) return; + i = p->nCol-1; + db = pParse->db; + zColl = sqlite3NameFromToken(db, pToken); + if( !zColl ) return; + + if( sqlite3LocateCollSeq(pParse, zColl) ){ + Index *pIdx; + sqlite3ColumnSetColl(db, &p->aCol[i], zColl); + + /* If the column is declared as " PRIMARY KEY COLLATE ", + ** then an index may have been created on this column before the + ** collation type was added. Correct this if it is the case. + */ + for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){ + assert( pIdx->nKeyCol==1 ); + if( pIdx->aiColumn[0]==i ){ + pIdx->azColl[0] = sqlite3ColumnColl(&p->aCol[i]); + } + } + } + sqlite3DbFree(db, zColl); +} + +/* Change the most recently parsed column to be a GENERATED ALWAYS AS +** column. +*/ +SQLITE_PRIVATE void sqlite3AddGenerated(Parse *pParse, Expr *pExpr, Token *pType){ +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + u8 eType = COLFLAG_VIRTUAL; + Table *pTab = pParse->pNewTable; + Column *pCol; + if( pTab==0 ){ + /* generated column in an CREATE TABLE IF NOT EXISTS that already exists */ + goto generated_done; + } + pCol = &(pTab->aCol[pTab->nCol-1]); + if( IN_DECLARE_VTAB ){ + sqlite3ErrorMsg(pParse, "virtual tables cannot use computed columns"); + goto generated_done; + } + if( pCol->iDflt>0 ) goto generated_error; + if( pType ){ + if( pType->n==7 && sqlite3StrNICmp("virtual",pType->z,7)==0 ){ + /* no-op */ + }else if( pType->n==6 && sqlite3StrNICmp("stored",pType->z,6)==0 ){ + eType = COLFLAG_STORED; + }else{ + goto generated_error; + } + } + if( eType==COLFLAG_VIRTUAL ) pTab->nNVCol--; + pCol->colFlags |= eType; + assert( TF_HasVirtual==COLFLAG_VIRTUAL ); + assert( TF_HasStored==COLFLAG_STORED ); + pTab->tabFlags |= eType; + if( pCol->colFlags & COLFLAG_PRIMKEY ){ + makeColumnPartOfPrimaryKey(pParse, pCol); /* For the error message */ + } + if( ALWAYS(pExpr) && pExpr->op==TK_ID ){ + /* The value of a generated column needs to be a real expression, not + ** just a reference to another column, in order for covering index + ** optimizations to work correctly. So if the value is not an expression, + ** turn it into one by adding a unary "+" operator. */ + pExpr = sqlite3PExpr(pParse, TK_UPLUS, pExpr, 0); + } + if( pExpr && pExpr->op!=TK_RAISE ) pExpr->affExpr = pCol->affinity; + sqlite3ColumnSetExpr(pParse, pTab, pCol, pExpr); + pExpr = 0; + goto generated_done; + +generated_error: + sqlite3ErrorMsg(pParse, "error in generated column \"%s\"", + pCol->zCnName); +generated_done: + sqlite3ExprDelete(pParse->db, pExpr); +#else + /* Throw and error for the GENERATED ALWAYS AS clause if the + ** SQLITE_OMIT_GENERATED_COLUMNS compile-time option is used. */ + sqlite3ErrorMsg(pParse, "generated columns not supported"); + sqlite3ExprDelete(pParse->db, pExpr); +#endif +} + +/* +** Generate code that will increment the schema cookie. +** +** The schema cookie is used to determine when the schema for the +** database changes. After each schema change, the cookie value +** changes. When a process first reads the schema it records the +** cookie. Thereafter, whenever it goes to access the database, +** it checks the cookie to make sure the schema has not changed +** since it was last read. +** +** This plan is not completely bullet-proof. It is possible for +** the schema to change multiple times and for the cookie to be +** set back to prior value. But schema changes are infrequent +** and the probability of hitting the same cookie value is only +** 1 chance in 2^32. So we're safe enough. +** +** IMPLEMENTATION-OF: R-34230-56049 SQLite automatically increments +** the schema-version whenever the schema changes. +*/ +SQLITE_PRIVATE void sqlite3ChangeCookie(Parse *pParse, int iDb){ + sqlite3 *db = pParse->db; + Vdbe *v = pParse->pVdbe; + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION, + (int)(1+(unsigned)db->aDb[iDb].pSchema->schema_cookie)); +} + +/* +** Measure the number of characters needed to output the given +** identifier. The number returned includes any quotes used +** but does not include the null terminator. +** +** The estimate is conservative. It might be larger that what is +** really needed. +*/ +static int identLength(const char *z){ + int n; + for(n=0; *z; n++, z++){ + if( *z=='"' ){ n++; } + } + return n + 2; +} + +/* +** The first parameter is a pointer to an output buffer. The second +** parameter is a pointer to an integer that contains the offset at +** which to write into the output buffer. This function copies the +** nul-terminated string pointed to by the third parameter, zSignedIdent, +** to the specified offset in the buffer and updates *pIdx to refer +** to the first byte after the last byte written before returning. +** +** If the string zSignedIdent consists entirely of alpha-numeric +** characters, does not begin with a digit and is not an SQL keyword, +** then it is copied to the output buffer exactly as it is. Otherwise, +** it is quoted using double-quotes. +*/ +static void identPut(char *z, int *pIdx, char *zSignedIdent){ + unsigned char *zIdent = (unsigned char*)zSignedIdent; + int i, j, needQuote; + i = *pIdx; + + for(j=0; zIdent[j]; j++){ + if( !sqlite3Isalnum(zIdent[j]) && zIdent[j]!='_' ) break; + } + needQuote = sqlite3Isdigit(zIdent[0]) + || sqlite3KeywordCode(zIdent, j)!=TK_ID + || zIdent[j]!=0 + || j==0; + + if( needQuote ) z[i++] = '"'; + for(j=0; zIdent[j]; j++){ + z[i++] = zIdent[j]; + if( zIdent[j]=='"' ) z[i++] = '"'; + } + if( needQuote ) z[i++] = '"'; + z[i] = 0; + *pIdx = i; +} + +/* +** Generate a CREATE TABLE statement appropriate for the given +** table. Memory to hold the text of the statement is obtained +** from sqliteMalloc() and must be freed by the calling function. +*/ +static char *createTableStmt(sqlite3 *db, Table *p){ + int i, k, n; + char *zStmt; + char *zSep, *zSep2, *zEnd; + Column *pCol; + n = 0; + for(pCol = p->aCol, i=0; inCol; i++, pCol++){ + n += identLength(pCol->zCnName) + 5; + } + n += identLength(p->zName); + if( n<50 ){ + zSep = ""; + zSep2 = ","; + zEnd = ")"; + }else{ + zSep = "\n "; + zSep2 = ",\n "; + zEnd = "\n)"; + } + n += 35 + 6*p->nCol; + zStmt = sqlite3DbMallocRaw(0, n); + if( zStmt==0 ){ + sqlite3OomFault(db); + return 0; + } + sqlite3_snprintf(n, zStmt, "CREATE TABLE "); + k = sqlite3Strlen30(zStmt); + identPut(zStmt, &k, p->zName); + zStmt[k++] = '('; + for(pCol=p->aCol, i=0; inCol; i++, pCol++){ + static const char * const azType[] = { + /* SQLITE_AFF_BLOB */ "", + /* SQLITE_AFF_TEXT */ " TEXT", + /* SQLITE_AFF_NUMERIC */ " NUM", + /* SQLITE_AFF_INTEGER */ " INT", + /* SQLITE_AFF_REAL */ " REAL", + /* SQLITE_AFF_FLEXNUM */ " NUM", + }; + int len; + const char *zType; + + sqlite3_snprintf(n-k, &zStmt[k], zSep); + k += sqlite3Strlen30(&zStmt[k]); + zSep = zSep2; + identPut(zStmt, &k, pCol->zCnName); + assert( pCol->affinity-SQLITE_AFF_BLOB >= 0 ); + assert( pCol->affinity-SQLITE_AFF_BLOB < ArraySize(azType) ); + testcase( pCol->affinity==SQLITE_AFF_BLOB ); + testcase( pCol->affinity==SQLITE_AFF_TEXT ); + testcase( pCol->affinity==SQLITE_AFF_NUMERIC ); + testcase( pCol->affinity==SQLITE_AFF_INTEGER ); + testcase( pCol->affinity==SQLITE_AFF_REAL ); + testcase( pCol->affinity==SQLITE_AFF_FLEXNUM ); + + zType = azType[pCol->affinity - SQLITE_AFF_BLOB]; + len = sqlite3Strlen30(zType); + assert( pCol->affinity==SQLITE_AFF_BLOB + || pCol->affinity==SQLITE_AFF_FLEXNUM + || pCol->affinity==sqlite3AffinityType(zType, 0) ); + memcpy(&zStmt[k], zType, len); + k += len; + assert( k<=n ); + } + sqlite3_snprintf(n-k, &zStmt[k], "%s", zEnd); + return zStmt; +} + +/* +** Resize an Index object to hold N columns total. Return SQLITE_OK +** on success and SQLITE_NOMEM on an OOM error. +*/ +static int resizeIndexObject(sqlite3 *db, Index *pIdx, int N){ + char *zExtra; + int nByte; + if( pIdx->nColumn>=N ) return SQLITE_OK; + assert( pIdx->isResized==0 ); + nByte = (sizeof(char*) + sizeof(LogEst) + sizeof(i16) + 1)*N; + zExtra = sqlite3DbMallocZero(db, nByte); + if( zExtra==0 ) return SQLITE_NOMEM_BKPT; + memcpy(zExtra, pIdx->azColl, sizeof(char*)*pIdx->nColumn); + pIdx->azColl = (const char**)zExtra; + zExtra += sizeof(char*)*N; + memcpy(zExtra, pIdx->aiRowLogEst, sizeof(LogEst)*(pIdx->nKeyCol+1)); + pIdx->aiRowLogEst = (LogEst*)zExtra; + zExtra += sizeof(LogEst)*N; + memcpy(zExtra, pIdx->aiColumn, sizeof(i16)*pIdx->nColumn); + pIdx->aiColumn = (i16*)zExtra; + zExtra += sizeof(i16)*N; + memcpy(zExtra, pIdx->aSortOrder, pIdx->nColumn); + pIdx->aSortOrder = (u8*)zExtra; + pIdx->nColumn = N; + pIdx->isResized = 1; + return SQLITE_OK; +} + +/* +** Estimate the total row width for a table. +*/ +static void estimateTableWidth(Table *pTab){ + unsigned wTable = 0; + const Column *pTabCol; + int i; + for(i=pTab->nCol, pTabCol=pTab->aCol; i>0; i--, pTabCol++){ + wTable += pTabCol->szEst; + } + if( pTab->iPKey<0 ) wTable++; + pTab->szTabRow = sqlite3LogEst(wTable*4); +} + +/* +** Estimate the average size of a row for an index. +*/ +static void estimateIndexWidth(Index *pIdx){ + unsigned wIndex = 0; + int i; + const Column *aCol = pIdx->pTable->aCol; + for(i=0; inColumn; i++){ + i16 x = pIdx->aiColumn[i]; + assert( xpTable->nCol ); + wIndex += x<0 ? 1 : aCol[pIdx->aiColumn[i]].szEst; + } + pIdx->szIdxRow = sqlite3LogEst(wIndex*4); +} + +/* Return true if column number x is any of the first nCol entries of aiCol[]. +** This is used to determine if the column number x appears in any of the +** first nCol entries of an index. +*/ +static int hasColumn(const i16 *aiCol, int nCol, int x){ + while( nCol-- > 0 ){ + if( x==*(aiCol++) ){ + return 1; + } + } + return 0; +} + +/* +** Return true if any of the first nKey entries of index pIdx exactly +** match the iCol-th entry of pPk. pPk is always a WITHOUT ROWID +** PRIMARY KEY index. pIdx is an index on the same table. pIdx may +** or may not be the same index as pPk. +** +** The first nKey entries of pIdx are guaranteed to be ordinary columns, +** not a rowid or expression. +** +** This routine differs from hasColumn() in that both the column and the +** collating sequence must match for this routine, but for hasColumn() only +** the column name must match. +*/ +static int isDupColumn(Index *pIdx, int nKey, Index *pPk, int iCol){ + int i, j; + assert( nKey<=pIdx->nColumn ); + assert( iColnColumn,pPk->nKeyCol) ); + assert( pPk->idxType==SQLITE_IDXTYPE_PRIMARYKEY ); + assert( pPk->pTable->tabFlags & TF_WithoutRowid ); + assert( pPk->pTable==pIdx->pTable ); + testcase( pPk==pIdx ); + j = pPk->aiColumn[iCol]; + assert( j!=XN_ROWID && j!=XN_EXPR ); + for(i=0; iaiColumn[i]>=0 || j>=0 ); + if( pIdx->aiColumn[i]==j + && sqlite3StrICmp(pIdx->azColl[i], pPk->azColl[iCol])==0 + ){ + return 1; + } + } + return 0; +} + +/* Recompute the colNotIdxed field of the Index. +** +** colNotIdxed is a bitmask that has a 0 bit representing each indexed +** columns that are within the first 63 columns of the table and a 1 for +** all other bits (all columns that are not in the index). The +** high-order bit of colNotIdxed is always 1. All unindexed columns +** of the table have a 1. +** +** 2019-10-24: For the purpose of this computation, virtual columns are +** not considered to be covered by the index, even if they are in the +** index, because we do not trust the logic in whereIndexExprTrans() to be +** able to find all instances of a reference to the indexed table column +** and convert them into references to the index. Hence we always want +** the actual table at hand in order to recompute the virtual column, if +** necessary. +** +** The colNotIdxed mask is AND-ed with the SrcList.a[].colUsed mask +** to determine if the index is covering index. +*/ +static void recomputeColumnsNotIndexed(Index *pIdx){ + Bitmask m = 0; + int j; + Table *pTab = pIdx->pTable; + for(j=pIdx->nColumn-1; j>=0; j--){ + int x = pIdx->aiColumn[j]; + if( x>=0 && (pTab->aCol[x].colFlags & COLFLAG_VIRTUAL)==0 ){ + testcase( x==BMS-1 ); + testcase( x==BMS-2 ); + if( xcolNotIdxed = ~m; + assert( (pIdx->colNotIdxed>>63)==1 ); /* See note-20221022-a */ +} + +/* +** This routine runs at the end of parsing a CREATE TABLE statement that +** has a WITHOUT ROWID clause. The job of this routine is to convert both +** internal schema data structures and the generated VDBE code so that they +** are appropriate for a WITHOUT ROWID table instead of a rowid table. +** Changes include: +** +** (1) Set all columns of the PRIMARY KEY schema object to be NOT NULL. +** (2) Convert P3 parameter of the OP_CreateBtree from BTREE_INTKEY +** into BTREE_BLOBKEY. +** (3) Bypass the creation of the sqlite_schema table entry +** for the PRIMARY KEY as the primary key index is now +** identified by the sqlite_schema table entry of the table itself. +** (4) Set the Index.tnum of the PRIMARY KEY Index object in the +** schema to the rootpage from the main table. +** (5) Add all table columns to the PRIMARY KEY Index object +** so that the PRIMARY KEY is a covering index. The surplus +** columns are part of KeyInfo.nAllField and are not used for +** sorting or lookup or uniqueness checks. +** (6) Replace the rowid tail on all automatically generated UNIQUE +** indices with the PRIMARY KEY columns. +** +** For virtual tables, only (1) is performed. +*/ +static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){ + Index *pIdx; + Index *pPk; + int nPk; + int nExtra; + int i, j; + sqlite3 *db = pParse->db; + Vdbe *v = pParse->pVdbe; + + /* Mark every PRIMARY KEY column as NOT NULL (except for imposter tables) + */ + if( !db->init.imposterTable ){ + for(i=0; inCol; i++){ + if( (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0 + && (pTab->aCol[i].notNull==OE_None) + ){ + pTab->aCol[i].notNull = OE_Abort; + } + } + pTab->tabFlags |= TF_HasNotNull; + } + + /* Convert the P3 operand of the OP_CreateBtree opcode from BTREE_INTKEY + ** into BTREE_BLOBKEY. + */ + assert( !pParse->bReturning ); + if( pParse->u1.addrCrTab ){ + assert( v ); + sqlite3VdbeChangeP3(v, pParse->u1.addrCrTab, BTREE_BLOBKEY); + } + + /* Locate the PRIMARY KEY index. Or, if this table was originally + ** an INTEGER PRIMARY KEY table, create a new PRIMARY KEY index. + */ + if( pTab->iPKey>=0 ){ + ExprList *pList; + Token ipkToken; + sqlite3TokenInit(&ipkToken, pTab->aCol[pTab->iPKey].zCnName); + pList = sqlite3ExprListAppend(pParse, 0, + sqlite3ExprAlloc(db, TK_ID, &ipkToken, 0)); + if( pList==0 ){ + pTab->tabFlags &= ~TF_WithoutRowid; + return; + } + if( IN_RENAME_OBJECT ){ + sqlite3RenameTokenRemap(pParse, pList->a[0].pExpr, &pTab->iPKey); + } + pList->a[0].fg.sortFlags = pParse->iPkSortOrder; + assert( pParse->pNewTable==pTab ); + pTab->iPKey = -1; + sqlite3CreateIndex(pParse, 0, 0, 0, pList, pTab->keyConf, 0, 0, 0, 0, + SQLITE_IDXTYPE_PRIMARYKEY); + if( pParse->nErr ){ + pTab->tabFlags &= ~TF_WithoutRowid; + return; + } + assert( db->mallocFailed==0 ); + pPk = sqlite3PrimaryKeyIndex(pTab); + assert( pPk->nKeyCol==1 ); + }else{ + pPk = sqlite3PrimaryKeyIndex(pTab); + assert( pPk!=0 ); + + /* + ** Remove all redundant columns from the PRIMARY KEY. For example, change + ** "PRIMARY KEY(a,b,a,b,c,b,c,d)" into just "PRIMARY KEY(a,b,c,d)". Later + ** code assumes the PRIMARY KEY contains no repeated columns. + */ + for(i=j=1; inKeyCol; i++){ + if( isDupColumn(pPk, j, pPk, i) ){ + pPk->nColumn--; + }else{ + testcase( hasColumn(pPk->aiColumn, j, pPk->aiColumn[i]) ); + pPk->azColl[j] = pPk->azColl[i]; + pPk->aSortOrder[j] = pPk->aSortOrder[i]; + pPk->aiColumn[j++] = pPk->aiColumn[i]; + } + } + pPk->nKeyCol = j; + } + assert( pPk!=0 ); + pPk->isCovering = 1; + if( !db->init.imposterTable ) pPk->uniqNotNull = 1; + nPk = pPk->nColumn = pPk->nKeyCol; + + /* Bypass the creation of the PRIMARY KEY btree and the sqlite_schema + ** table entry. This is only required if currently generating VDBE + ** code for a CREATE TABLE (not when parsing one as part of reading + ** a database schema). */ + if( v && pPk->tnum>0 ){ + assert( db->init.busy==0 ); + sqlite3VdbeChangeOpcode(v, (int)pPk->tnum, OP_Goto); + } + + /* The root page of the PRIMARY KEY is the table root page */ + pPk->tnum = pTab->tnum; + + /* Update the in-memory representation of all UNIQUE indices by converting + ** the final rowid column into one or more columns of the PRIMARY KEY. + */ + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + int n; + if( IsPrimaryKeyIndex(pIdx) ) continue; + for(i=n=0; inKeyCol, pPk, i) ){ + testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) ); + n++; + } + } + if( n==0 ){ + /* This index is a superset of the primary key */ + pIdx->nColumn = pIdx->nKeyCol; + continue; + } + if( resizeIndexObject(db, pIdx, pIdx->nKeyCol+n) ) return; + for(i=0, j=pIdx->nKeyCol; inKeyCol, pPk, i) ){ + testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) ); + pIdx->aiColumn[j] = pPk->aiColumn[i]; + pIdx->azColl[j] = pPk->azColl[i]; + if( pPk->aSortOrder[i] ){ + /* See ticket https://www.sqlite.org/src/info/bba7b69f9849b5bf */ + pIdx->bAscKeyBug = 1; + } + j++; + } + } + assert( pIdx->nColumn>=pIdx->nKeyCol+n ); + assert( pIdx->nColumn>=j ); + } + + /* Add all table columns to the PRIMARY KEY index + */ + nExtra = 0; + for(i=0; inCol; i++){ + if( !hasColumn(pPk->aiColumn, nPk, i) + && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ) nExtra++; + } + if( resizeIndexObject(db, pPk, nPk+nExtra) ) return; + for(i=0, j=nPk; inCol; i++){ + if( !hasColumn(pPk->aiColumn, j, i) + && (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 + ){ + assert( jnColumn ); + pPk->aiColumn[j] = i; + pPk->azColl[j] = sqlite3StrBINARY; + j++; + } + } + assert( pPk->nColumn==j ); + assert( pTab->nNVCol<=j ); + recomputeColumnsNotIndexed(pPk); +} + + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* +** Return true if pTab is a virtual table and zName is a shadow table name +** for that virtual table. +*/ +SQLITE_PRIVATE int sqlite3IsShadowTableOf(sqlite3 *db, Table *pTab, const char *zName){ + int nName; /* Length of zName */ + Module *pMod; /* Module for the virtual table */ + + if( !IsVirtual(pTab) ) return 0; + nName = sqlite3Strlen30(pTab->zName); + if( sqlite3_strnicmp(zName, pTab->zName, nName)!=0 ) return 0; + if( zName[nName]!='_' ) return 0; + pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->u.vtab.azArg[0]); + if( pMod==0 ) return 0; + if( pMod->pModule->iVersion<3 ) return 0; + if( pMod->pModule->xShadowName==0 ) return 0; + return pMod->pModule->xShadowName(zName+nName+1); +} +#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* +** Table pTab is a virtual table. If it the virtual table implementation +** exists and has an xShadowName method, then loop over all other ordinary +** tables within the same schema looking for shadow tables of pTab, and mark +** any shadow tables seen using the TF_Shadow flag. +*/ +SQLITE_PRIVATE void sqlite3MarkAllShadowTablesOf(sqlite3 *db, Table *pTab){ + int nName; /* Length of pTab->zName */ + Module *pMod; /* Module for the virtual table */ + HashElem *k; /* For looping through the symbol table */ + + assert( IsVirtual(pTab) ); + pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->u.vtab.azArg[0]); + if( pMod==0 ) return; + if( NEVER(pMod->pModule==0) ) return; + if( pMod->pModule->iVersion<3 ) return; + if( pMod->pModule->xShadowName==0 ) return; + assert( pTab->zName!=0 ); + nName = sqlite3Strlen30(pTab->zName); + for(k=sqliteHashFirst(&pTab->pSchema->tblHash); k; k=sqliteHashNext(k)){ + Table *pOther = sqliteHashData(k); + assert( pOther->zName!=0 ); + if( !IsOrdinaryTable(pOther) ) continue; + if( pOther->tabFlags & TF_Shadow ) continue; + if( sqlite3StrNICmp(pOther->zName, pTab->zName, nName)==0 + && pOther->zName[nName]=='_' + && pMod->pModule->xShadowName(pOther->zName+nName+1) + ){ + pOther->tabFlags |= TF_Shadow; + } + } +} +#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* +** Return true if zName is a shadow table name in the current database +** connection. +** +** zName is temporarily modified while this routine is running, but is +** restored to its original value prior to this routine returning. +*/ +SQLITE_PRIVATE int sqlite3ShadowTableName(sqlite3 *db, const char *zName){ + char *zTail; /* Pointer to the last "_" in zName */ + Table *pTab; /* Table that zName is a shadow of */ + zTail = strrchr(zName, '_'); + if( zTail==0 ) return 0; + *zTail = 0; + pTab = sqlite3FindTable(db, zName, 0); + *zTail = '_'; + if( pTab==0 ) return 0; + if( !IsVirtual(pTab) ) return 0; + return sqlite3IsShadowTableOf(db, pTab, zName); +} +#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */ + + +#ifdef SQLITE_DEBUG +/* +** Mark all nodes of an expression as EP_Immutable, indicating that +** they should not be changed. Expressions attached to a table or +** index definition are tagged this way to help ensure that we do +** not pass them into code generator routines by mistake. +*/ +static int markImmutableExprStep(Walker *pWalker, Expr *pExpr){ + (void)pWalker; + ExprSetVVAProperty(pExpr, EP_Immutable); + return WRC_Continue; +} +static void markExprListImmutable(ExprList *pList){ + if( pList ){ + Walker w; + memset(&w, 0, sizeof(w)); + w.xExprCallback = markImmutableExprStep; + w.xSelectCallback = sqlite3SelectWalkNoop; + w.xSelectCallback2 = 0; + sqlite3WalkExprList(&w, pList); + } +} +#else +#define markExprListImmutable(X) /* no-op */ +#endif /* SQLITE_DEBUG */ + + +/* +** This routine is called to report the final ")" that terminates +** a CREATE TABLE statement. +** +** The table structure that other action routines have been building +** is added to the internal hash tables, assuming no errors have +** occurred. +** +** An entry for the table is made in the schema table on disk, unless +** this is a temporary table or db->init.busy==1. When db->init.busy==1 +** it means we are reading the sqlite_schema table because we just +** connected to the database or because the sqlite_schema table has +** recently changed, so the entry for this table already exists in +** the sqlite_schema table. We do not want to create it again. +** +** If the pSelect argument is not NULL, it means that this routine +** was called to create a table generated from a +** "CREATE TABLE ... AS SELECT ..." statement. The column names of +** the new table will match the result set of the SELECT. +*/ +SQLITE_PRIVATE void sqlite3EndTable( + Parse *pParse, /* Parse context */ + Token *pCons, /* The ',' token after the last column defn. */ + Token *pEnd, /* The ')' before options in the CREATE TABLE */ + u32 tabOpts, /* Extra table options. Usually 0. */ + Select *pSelect /* Select from a "CREATE ... AS SELECT" */ +){ + Table *p; /* The new table */ + sqlite3 *db = pParse->db; /* The database connection */ + int iDb; /* Database in which the table lives */ + Index *pIdx; /* An implied index of the table */ + + if( pEnd==0 && pSelect==0 ){ + return; + } + p = pParse->pNewTable; + if( p==0 ) return; + + if( pSelect==0 && sqlite3ShadowTableName(db, p->zName) ){ + p->tabFlags |= TF_Shadow; + } + + /* If the db->init.busy is 1 it means we are reading the SQL off the + ** "sqlite_schema" or "sqlite_temp_schema" table on the disk. + ** So do not write to the disk again. Extract the root page number + ** for the table from the db->init.newTnum field. (The page number + ** should have been put there by the sqliteOpenCb routine.) + ** + ** If the root page number is 1, that means this is the sqlite_schema + ** table itself. So mark it read-only. + */ + if( db->init.busy ){ + if( pSelect || (!IsOrdinaryTable(p) && db->init.newTnum) ){ + sqlite3ErrorMsg(pParse, ""); + return; + } + p->tnum = db->init.newTnum; + if( p->tnum==1 ) p->tabFlags |= TF_Readonly; + } + + /* Special processing for tables that include the STRICT keyword: + ** + ** * Do not allow custom column datatypes. Every column must have + ** a datatype that is one of INT, INTEGER, REAL, TEXT, or BLOB. + ** + ** * If a PRIMARY KEY is defined, other than the INTEGER PRIMARY KEY, + ** then all columns of the PRIMARY KEY must have a NOT NULL + ** constraint. + */ + if( tabOpts & TF_Strict ){ + int ii; + p->tabFlags |= TF_Strict; + for(ii=0; iinCol; ii++){ + Column *pCol = &p->aCol[ii]; + if( pCol->eCType==COLTYPE_CUSTOM ){ + if( pCol->colFlags & COLFLAG_HASTYPE ){ + sqlite3ErrorMsg(pParse, + "unknown datatype for %s.%s: \"%s\"", + p->zName, pCol->zCnName, sqlite3ColumnType(pCol, "") + ); + }else{ + sqlite3ErrorMsg(pParse, "missing datatype for %s.%s", + p->zName, pCol->zCnName); + } + return; + }else if( pCol->eCType==COLTYPE_ANY ){ + pCol->affinity = SQLITE_AFF_BLOB; + } + if( (pCol->colFlags & COLFLAG_PRIMKEY)!=0 + && p->iPKey!=ii + && pCol->notNull == OE_None + ){ + pCol->notNull = OE_Abort; + p->tabFlags |= TF_HasNotNull; + } + } + } + + assert( (p->tabFlags & TF_HasPrimaryKey)==0 + || p->iPKey>=0 || sqlite3PrimaryKeyIndex(p)!=0 ); + assert( (p->tabFlags & TF_HasPrimaryKey)!=0 + || (p->iPKey<0 && sqlite3PrimaryKeyIndex(p)==0) ); + + /* Special processing for WITHOUT ROWID Tables */ + if( tabOpts & TF_WithoutRowid ){ + if( (p->tabFlags & TF_Autoincrement) ){ + sqlite3ErrorMsg(pParse, + "AUTOINCREMENT not allowed on WITHOUT ROWID tables"); + return; + } + if( (p->tabFlags & TF_HasPrimaryKey)==0 ){ + sqlite3ErrorMsg(pParse, "PRIMARY KEY missing on table %s", p->zName); + return; + } + p->tabFlags |= TF_WithoutRowid | TF_NoVisibleRowid; + convertToWithoutRowidTable(pParse, p); + } + iDb = sqlite3SchemaToIndex(db, p->pSchema); + +#ifndef SQLITE_OMIT_CHECK + /* Resolve names in all CHECK constraint expressions. + */ + if( p->pCheck ){ + sqlite3ResolveSelfReference(pParse, p, NC_IsCheck, 0, p->pCheck); + if( pParse->nErr ){ + /* If errors are seen, delete the CHECK constraints now, else they might + ** actually be used if PRAGMA writable_schema=ON is set. */ + sqlite3ExprListDelete(db, p->pCheck); + p->pCheck = 0; + }else{ + markExprListImmutable(p->pCheck); + } + } +#endif /* !defined(SQLITE_OMIT_CHECK) */ +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + if( p->tabFlags & TF_HasGenerated ){ + int ii, nNG = 0; + testcase( p->tabFlags & TF_HasVirtual ); + testcase( p->tabFlags & TF_HasStored ); + for(ii=0; iinCol; ii++){ + u32 colFlags = p->aCol[ii].colFlags; + if( (colFlags & COLFLAG_GENERATED)!=0 ){ + Expr *pX = sqlite3ColumnExpr(p, &p->aCol[ii]); + testcase( colFlags & COLFLAG_VIRTUAL ); + testcase( colFlags & COLFLAG_STORED ); + if( sqlite3ResolveSelfReference(pParse, p, NC_GenCol, pX, 0) ){ + /* If there are errors in resolving the expression, change the + ** expression to a NULL. This prevents code generators that operate + ** on the expression from inserting extra parts into the expression + ** tree that have been allocated from lookaside memory, which is + ** illegal in a schema and will lead to errors or heap corruption + ** when the database connection closes. */ + sqlite3ColumnSetExpr(pParse, p, &p->aCol[ii], + sqlite3ExprAlloc(db, TK_NULL, 0, 0)); + } + }else{ + nNG++; + } + } + if( nNG==0 ){ + sqlite3ErrorMsg(pParse, "must have at least one non-generated column"); + return; + } + } +#endif + + /* Estimate the average row size for the table and for all implied indices */ + estimateTableWidth(p); + for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){ + estimateIndexWidth(pIdx); + } + + /* If not initializing, then create a record for the new table + ** in the schema table of the database. + ** + ** If this is a TEMPORARY table, write the entry into the auxiliary + ** file instead of into the main database file. + */ + if( !db->init.busy ){ + int n; + Vdbe *v; + char *zType; /* "view" or "table" */ + char *zType2; /* "VIEW" or "TABLE" */ + char *zStmt; /* Text of the CREATE TABLE or CREATE VIEW statement */ + + v = sqlite3GetVdbe(pParse); + if( NEVER(v==0) ) return; + + sqlite3VdbeAddOp1(v, OP_Close, 0); + + /* + ** Initialize zType for the new view or table. + */ + if( IsOrdinaryTable(p) ){ + /* A regular table */ + zType = "table"; + zType2 = "TABLE"; +#ifndef SQLITE_OMIT_VIEW + }else{ + /* A view */ + zType = "view"; + zType2 = "VIEW"; +#endif + } + + /* If this is a CREATE TABLE xx AS SELECT ..., execute the SELECT + ** statement to populate the new table. The root-page number for the + ** new table is in register pParse->regRoot. + ** + ** Once the SELECT has been coded by sqlite3Select(), it is in a + ** suitable state to query for the column names and types to be used + ** by the new table. + ** + ** A shared-cache write-lock is not required to write to the new table, + ** as a schema-lock must have already been obtained to create it. Since + ** a schema-lock excludes all other database users, the write-lock would + ** be redundant. + */ + if( pSelect ){ + SelectDest dest; /* Where the SELECT should store results */ + int regYield; /* Register holding co-routine entry-point */ + int addrTop; /* Top of the co-routine */ + int regRec; /* A record to be insert into the new table */ + int regRowid; /* Rowid of the next row to insert */ + int addrInsLoop; /* Top of the loop for inserting rows */ + Table *pSelTab; /* A table that describes the SELECT results */ + + if( IN_SPECIAL_PARSE ){ + pParse->rc = SQLITE_ERROR; + pParse->nErr++; + return; + } + regYield = ++pParse->nMem; + regRec = ++pParse->nMem; + regRowid = ++pParse->nMem; + assert(pParse->nTab==1); + sqlite3MayAbort(pParse); + sqlite3VdbeAddOp3(v, OP_OpenWrite, 1, pParse->regRoot, iDb); + sqlite3VdbeChangeP5(v, OPFLAG_P2ISREG); + pParse->nTab = 2; + addrTop = sqlite3VdbeCurrentAddr(v) + 1; + sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop); + if( pParse->nErr ) return; + pSelTab = sqlite3ResultSetOfSelect(pParse, pSelect, SQLITE_AFF_BLOB); + if( pSelTab==0 ) return; + assert( p->aCol==0 ); + p->nCol = p->nNVCol = pSelTab->nCol; + p->aCol = pSelTab->aCol; + pSelTab->nCol = 0; + pSelTab->aCol = 0; + sqlite3DeleteTable(db, pSelTab); + sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield); + sqlite3Select(pParse, pSelect, &dest); + if( pParse->nErr ) return; + sqlite3VdbeEndCoroutine(v, regYield); + sqlite3VdbeJumpHere(v, addrTop - 1); + addrInsLoop = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm); + VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_MakeRecord, dest.iSdst, dest.nSdst, regRec); + sqlite3TableAffinity(v, p, 0); + sqlite3VdbeAddOp2(v, OP_NewRowid, 1, regRowid); + sqlite3VdbeAddOp3(v, OP_Insert, 1, regRec, regRowid); + sqlite3VdbeGoto(v, addrInsLoop); + sqlite3VdbeJumpHere(v, addrInsLoop); + sqlite3VdbeAddOp1(v, OP_Close, 1); + } + + /* Compute the complete text of the CREATE statement */ + if( pSelect ){ + zStmt = createTableStmt(db, p); + }else{ + Token *pEnd2 = tabOpts ? &pParse->sLastToken : pEnd; + n = (int)(pEnd2->z - pParse->sNameToken.z); + if( pEnd2->z[0]!=';' ) n += pEnd2->n; + zStmt = sqlite3MPrintf(db, + "CREATE %s %.*s", zType2, n, pParse->sNameToken.z + ); + } + + /* A slot for the record has already been allocated in the + ** schema table. We just need to update that slot with all + ** the information we've collected. + */ + sqlite3NestedParse(pParse, + "UPDATE %Q." LEGACY_SCHEMA_TABLE + " SET type='%s', name=%Q, tbl_name=%Q, rootpage=#%d, sql=%Q" + " WHERE rowid=#%d", + db->aDb[iDb].zDbSName, + zType, + p->zName, + p->zName, + pParse->regRoot, + zStmt, + pParse->regRowid + ); + sqlite3DbFree(db, zStmt); + sqlite3ChangeCookie(pParse, iDb); + +#ifndef SQLITE_OMIT_AUTOINCREMENT + /* Check to see if we need to create an sqlite_sequence table for + ** keeping track of autoincrement keys. + */ + if( (p->tabFlags & TF_Autoincrement)!=0 && !IN_SPECIAL_PARSE ){ + Db *pDb = &db->aDb[iDb]; + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + if( pDb->pSchema->pSeqTab==0 ){ + sqlite3NestedParse(pParse, + "CREATE TABLE %Q.sqlite_sequence(name,seq)", + pDb->zDbSName + ); + } + } +#endif + + /* Reparse everything to update our internal data structures */ + sqlite3VdbeAddParseSchemaOp(v, iDb, + sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName),0); + } + + /* Add the table to the in-memory representation of the database. + */ + if( db->init.busy ){ + Table *pOld; + Schema *pSchema = p->pSchema; + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + assert( HasRowid(p) || p->iPKey<0 ); + pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p); + if( pOld ){ + assert( p==pOld ); /* Malloc must have failed inside HashInsert() */ + sqlite3OomFault(db); + return; + } + pParse->pNewTable = 0; + db->mDbFlags |= DBFLAG_SchemaChange; + + /* If this is the magic sqlite_sequence table used by autoincrement, + ** then record a pointer to this table in the main database structure + ** so that INSERT can find the table easily. */ + assert( !pParse->nested ); +#ifndef SQLITE_OMIT_AUTOINCREMENT + if( strcmp(p->zName, "sqlite_sequence")==0 ){ + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + p->pSchema->pSeqTab = p; + } +#endif + } + +#ifndef SQLITE_OMIT_ALTERTABLE + if( !pSelect && IsOrdinaryTable(p) ){ + assert( pCons && pEnd ); + if( pCons->z==0 ){ + pCons = pEnd; + } + p->u.tab.addColOffset = 13 + (int)(pCons->z - pParse->sNameToken.z); + } +#endif +} + +#ifndef SQLITE_OMIT_VIEW +/* +** The parser calls this routine in order to create a new VIEW +*/ +SQLITE_PRIVATE void sqlite3CreateView( + Parse *pParse, /* The parsing context */ + Token *pBegin, /* The CREATE token that begins the statement */ + Token *pName1, /* The token that holds the name of the view */ + Token *pName2, /* The token that holds the name of the view */ + ExprList *pCNames, /* Optional list of view column names */ + Select *pSelect, /* A SELECT statement that will become the new view */ + int isTemp, /* TRUE for a TEMPORARY view */ + int noErr /* Suppress error messages if VIEW already exists */ +){ + Table *p; + int n; + const char *z; + Token sEnd; + DbFixer sFix; + Token *pName = 0; + int iDb; + sqlite3 *db = pParse->db; + + if( pParse->nVar>0 ){ + sqlite3ErrorMsg(pParse, "parameters are not allowed in views"); + goto create_view_fail; + } + sqlite3StartTable(pParse, pName1, pName2, isTemp, 1, 0, noErr); + p = pParse->pNewTable; + if( p==0 || pParse->nErr ) goto create_view_fail; + + /* Legacy versions of SQLite allowed the use of the magic "rowid" column + ** on a view, even though views do not have rowids. The following flag + ** setting fixes this problem. But the fix can be disabled by compiling + ** with -DSQLITE_ALLOW_ROWID_IN_VIEW in case there are legacy apps that + ** depend upon the old buggy behavior. */ +#ifndef SQLITE_ALLOW_ROWID_IN_VIEW + p->tabFlags |= TF_NoVisibleRowid; +#endif + + sqlite3TwoPartName(pParse, pName1, pName2, &pName); + iDb = sqlite3SchemaToIndex(db, p->pSchema); + sqlite3FixInit(&sFix, pParse, iDb, "view", pName); + if( sqlite3FixSelect(&sFix, pSelect) ) goto create_view_fail; + + /* Make a copy of the entire SELECT statement that defines the view. + ** This will force all the Expr.token.z values to be dynamically + ** allocated rather than point to the input string - which means that + ** they will persist after the current sqlite3_exec() call returns. + */ + pSelect->selFlags |= SF_View; + if( IN_RENAME_OBJECT ){ + p->u.view.pSelect = pSelect; + pSelect = 0; + }else{ + p->u.view.pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE); + } + p->pCheck = sqlite3ExprListDup(db, pCNames, EXPRDUP_REDUCE); + p->eTabType = TABTYP_VIEW; + if( db->mallocFailed ) goto create_view_fail; + + /* Locate the end of the CREATE VIEW statement. Make sEnd point to + ** the end. + */ + sEnd = pParse->sLastToken; + assert( sEnd.z[0]!=0 || sEnd.n==0 ); + if( sEnd.z[0]!=';' ){ + sEnd.z += sEnd.n; + } + sEnd.n = 0; + n = (int)(sEnd.z - pBegin->z); + assert( n>0 ); + z = pBegin->z; + while( sqlite3Isspace(z[n-1]) ){ n--; } + sEnd.z = &z[n-1]; + sEnd.n = 1; + + /* Use sqlite3EndTable() to add the view to the schema table */ + sqlite3EndTable(pParse, 0, &sEnd, 0, 0); + +create_view_fail: + sqlite3SelectDelete(db, pSelect); + if( IN_RENAME_OBJECT ){ + sqlite3RenameExprlistUnmap(pParse, pCNames); + } + sqlite3ExprListDelete(db, pCNames); + return; +} +#endif /* SQLITE_OMIT_VIEW */ + +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) +/* +** The Table structure pTable is really a VIEW. Fill in the names of +** the columns of the view in the pTable structure. Return the number +** of errors. If an error is seen leave an error message in pParse->zErrMsg. +*/ +static SQLITE_NOINLINE int viewGetColumnNames(Parse *pParse, Table *pTable){ + Table *pSelTab; /* A fake table from which we get the result set */ + Select *pSel; /* Copy of the SELECT that implements the view */ + int nErr = 0; /* Number of errors encountered */ + sqlite3 *db = pParse->db; /* Database connection for malloc errors */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + int rc; +#endif +#ifndef SQLITE_OMIT_AUTHORIZATION + sqlite3_xauth xAuth; /* Saved xAuth pointer */ +#endif + + assert( pTable ); + +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTable) ){ + db->nSchemaLock++; + rc = sqlite3VtabCallConnect(pParse, pTable); + db->nSchemaLock--; + return rc; + } +#endif + +#ifndef SQLITE_OMIT_VIEW + /* A positive nCol means the columns names for this view are + ** already known. This routine is not called unless either the + ** table is virtual or nCol is zero. + */ + assert( pTable->nCol<=0 ); + + /* A negative nCol is a special marker meaning that we are currently + ** trying to compute the column names. If we enter this routine with + ** a negative nCol, it means two or more views form a loop, like this: + ** + ** CREATE VIEW one AS SELECT * FROM two; + ** CREATE VIEW two AS SELECT * FROM one; + ** + ** Actually, the error above is now caught prior to reaching this point. + ** But the following test is still important as it does come up + ** in the following: + ** + ** CREATE TABLE main.ex1(a); + ** CREATE TEMP VIEW ex1 AS SELECT a FROM ex1; + ** SELECT * FROM temp.ex1; + */ + if( pTable->nCol<0 ){ + sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName); + return 1; + } + assert( pTable->nCol>=0 ); + + /* If we get this far, it means we need to compute the table names. + ** Note that the call to sqlite3ResultSetOfSelect() will expand any + ** "*" elements in the results set of the view and will assign cursors + ** to the elements of the FROM clause. But we do not want these changes + ** to be permanent. So the computation is done on a copy of the SELECT + ** statement that defines the view. + */ + assert( IsView(pTable) ); + pSel = sqlite3SelectDup(db, pTable->u.view.pSelect, 0); + if( pSel ){ + u8 eParseMode = pParse->eParseMode; + int nTab = pParse->nTab; + int nSelect = pParse->nSelect; + pParse->eParseMode = PARSE_MODE_NORMAL; + sqlite3SrcListAssignCursors(pParse, pSel->pSrc); + pTable->nCol = -1; + DisableLookaside; +#ifndef SQLITE_OMIT_AUTHORIZATION + xAuth = db->xAuth; + db->xAuth = 0; + pSelTab = sqlite3ResultSetOfSelect(pParse, pSel, SQLITE_AFF_NONE); + db->xAuth = xAuth; +#else + pSelTab = sqlite3ResultSetOfSelect(pParse, pSel, SQLITE_AFF_NONE); +#endif + pParse->nTab = nTab; + pParse->nSelect = nSelect; + if( pSelTab==0 ){ + pTable->nCol = 0; + nErr++; + }else if( pTable->pCheck ){ + /* CREATE VIEW name(arglist) AS ... + ** The names of the columns in the table are taken from + ** arglist which is stored in pTable->pCheck. The pCheck field + ** normally holds CHECK constraints on an ordinary table, but for + ** a VIEW it holds the list of column names. + */ + sqlite3ColumnsFromExprList(pParse, pTable->pCheck, + &pTable->nCol, &pTable->aCol); + if( pParse->nErr==0 + && pTable->nCol==pSel->pEList->nExpr + ){ + assert( db->mallocFailed==0 ); + sqlite3SubqueryColumnTypes(pParse, pTable, pSel, SQLITE_AFF_NONE); + } + }else{ + /* CREATE VIEW name AS... without an argument list. Construct + ** the column names from the SELECT statement that defines the view. + */ + assert( pTable->aCol==0 ); + pTable->nCol = pSelTab->nCol; + pTable->aCol = pSelTab->aCol; + pTable->tabFlags |= (pSelTab->tabFlags & COLFLAG_NOINSERT); + pSelTab->nCol = 0; + pSelTab->aCol = 0; + assert( sqlite3SchemaMutexHeld(db, 0, pTable->pSchema) ); + } + pTable->nNVCol = pTable->nCol; + sqlite3DeleteTable(db, pSelTab); + sqlite3SelectDelete(db, pSel); + EnableLookaside; + pParse->eParseMode = eParseMode; + } else { + nErr++; + } + pTable->pSchema->schemaFlags |= DB_UnresetViews; + if( db->mallocFailed ){ + sqlite3DeleteColumnNames(db, pTable); + } +#endif /* SQLITE_OMIT_VIEW */ + return nErr; +} +SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){ + assert( pTable!=0 ); + if( !IsVirtual(pTable) && pTable->nCol>0 ) return 0; + return viewGetColumnNames(pParse, pTable); +} +#endif /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */ + +#ifndef SQLITE_OMIT_VIEW +/* +** Clear the column names from every VIEW in database idx. +*/ +static void sqliteViewResetAll(sqlite3 *db, int idx){ + HashElem *i; + assert( sqlite3SchemaMutexHeld(db, idx, 0) ); + if( !DbHasProperty(db, idx, DB_UnresetViews) ) return; + for(i=sqliteHashFirst(&db->aDb[idx].pSchema->tblHash); i;i=sqliteHashNext(i)){ + Table *pTab = sqliteHashData(i); + if( IsView(pTab) ){ + sqlite3DeleteColumnNames(db, pTab); + } + } + DbClearProperty(db, idx, DB_UnresetViews); +} +#else +# define sqliteViewResetAll(A,B) +#endif /* SQLITE_OMIT_VIEW */ + +/* +** This function is called by the VDBE to adjust the internal schema +** used by SQLite when the btree layer moves a table root page. The +** root-page of a table or index in database iDb has changed from iFrom +** to iTo. +** +** Ticket #1728: The symbol table might still contain information +** on tables and/or indices that are the process of being deleted. +** If you are unlucky, one of those deleted indices or tables might +** have the same rootpage number as the real table or index that is +** being moved. So we cannot stop searching after the first match +** because the first match might be for one of the deleted indices +** or tables and not the table/index that is actually being moved. +** We must continue looping until all tables and indices with +** rootpage==iFrom have been converted to have a rootpage of iTo +** in order to be certain that we got the right one. +*/ +#ifndef SQLITE_OMIT_AUTOVACUUM +SQLITE_PRIVATE void sqlite3RootPageMoved(sqlite3 *db, int iDb, Pgno iFrom, Pgno iTo){ + HashElem *pElem; + Hash *pHash; + Db *pDb; + + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + pDb = &db->aDb[iDb]; + pHash = &pDb->pSchema->tblHash; + for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){ + Table *pTab = sqliteHashData(pElem); + if( pTab->tnum==iFrom ){ + pTab->tnum = iTo; + } + } + pHash = &pDb->pSchema->idxHash; + for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){ + Index *pIdx = sqliteHashData(pElem); + if( pIdx->tnum==iFrom ){ + pIdx->tnum = iTo; + } + } +} +#endif + +/* +** Write code to erase the table with root-page iTable from database iDb. +** Also write code to modify the sqlite_schema table and internal schema +** if a root-page of another table is moved by the btree-layer whilst +** erasing iTable (this can happen with an auto-vacuum database). +*/ +static void destroyRootPage(Parse *pParse, int iTable, int iDb){ + Vdbe *v = sqlite3GetVdbe(pParse); + int r1 = sqlite3GetTempReg(pParse); + if( iTable<2 ) sqlite3ErrorMsg(pParse, "corrupt schema"); + sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb); + sqlite3MayAbort(pParse); +#ifndef SQLITE_OMIT_AUTOVACUUM + /* OP_Destroy stores an in integer r1. If this integer + ** is non-zero, then it is the root page number of a table moved to + ** location iTable. The following code modifies the sqlite_schema table to + ** reflect this. + ** + ** The "#NNN" in the SQL is a special constant that means whatever value + ** is in register NNN. See grammar rules associated with the TK_REGISTER + ** token for additional information. + */ + sqlite3NestedParse(pParse, + "UPDATE %Q." LEGACY_SCHEMA_TABLE + " SET rootpage=%d WHERE #%d AND rootpage=#%d", + pParse->db->aDb[iDb].zDbSName, iTable, r1, r1); +#endif + sqlite3ReleaseTempReg(pParse, r1); +} + +/* +** Write VDBE code to erase table pTab and all associated indices on disk. +** Code to update the sqlite_schema tables and internal schema definitions +** in case a root-page belonging to another table is moved by the btree layer +** is also added (this can happen with an auto-vacuum database). +*/ +static void destroyTable(Parse *pParse, Table *pTab){ + /* If the database may be auto-vacuum capable (if SQLITE_OMIT_AUTOVACUUM + ** is not defined), then it is important to call OP_Destroy on the + ** table and index root-pages in order, starting with the numerically + ** largest root-page number. This guarantees that none of the root-pages + ** to be destroyed is relocated by an earlier OP_Destroy. i.e. if the + ** following were coded: + ** + ** OP_Destroy 4 0 + ** ... + ** OP_Destroy 5 0 + ** + ** and root page 5 happened to be the largest root-page number in the + ** database, then root page 5 would be moved to page 4 by the + ** "OP_Destroy 4 0" opcode. The subsequent "OP_Destroy 5 0" would hit + ** a free-list page. + */ + Pgno iTab = pTab->tnum; + Pgno iDestroyed = 0; + + while( 1 ){ + Index *pIdx; + Pgno iLargest = 0; + + if( iDestroyed==0 || iTabpIndex; pIdx; pIdx=pIdx->pNext){ + Pgno iIdx = pIdx->tnum; + assert( pIdx->pSchema==pTab->pSchema ); + if( (iDestroyed==0 || (iIdxiLargest ){ + iLargest = iIdx; + } + } + if( iLargest==0 ){ + return; + }else{ + int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + assert( iDb>=0 && iDbdb->nDb ); + destroyRootPage(pParse, iLargest, iDb); + iDestroyed = iLargest; + } + } +} + +/* +** Remove entries from the sqlite_statN tables (for N in (1,2,3)) +** after a DROP INDEX or DROP TABLE command. +*/ +static void sqlite3ClearStatTables( + Parse *pParse, /* The parsing context */ + int iDb, /* The database number */ + const char *zType, /* "idx" or "tbl" */ + const char *zName /* Name of index or table */ +){ + int i; + const char *zDbName = pParse->db->aDb[iDb].zDbSName; + for(i=1; i<=4; i++){ + char zTab[24]; + sqlite3_snprintf(sizeof(zTab),zTab,"sqlite_stat%d",i); + if( sqlite3FindTable(pParse->db, zTab, zDbName) ){ + sqlite3NestedParse(pParse, + "DELETE FROM %Q.%s WHERE %s=%Q", + zDbName, zTab, zType, zName + ); + } + } +} + +/* +** Generate code to drop a table. +*/ +SQLITE_PRIVATE void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView){ + Vdbe *v; + sqlite3 *db = pParse->db; + Trigger *pTrigger; + Db *pDb = &db->aDb[iDb]; + + v = sqlite3GetVdbe(pParse); + assert( v!=0 ); + sqlite3BeginWriteOperation(pParse, 1, iDb); + +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTab) ){ + sqlite3VdbeAddOp0(v, OP_VBegin); + } +#endif + + /* Drop all triggers associated with the table being dropped. Code + ** is generated to remove entries from sqlite_schema and/or + ** sqlite_temp_schema if required. + */ + pTrigger = sqlite3TriggerList(pParse, pTab); + while( pTrigger ){ + assert( pTrigger->pSchema==pTab->pSchema || + pTrigger->pSchema==db->aDb[1].pSchema ); + sqlite3DropTriggerPtr(pParse, pTrigger); + pTrigger = pTrigger->pNext; + } + +#ifndef SQLITE_OMIT_AUTOINCREMENT + /* Remove any entries of the sqlite_sequence table associated with + ** the table being dropped. This is done before the table is dropped + ** at the btree level, in case the sqlite_sequence table needs to + ** move as a result of the drop (can happen in auto-vacuum mode). + */ + if( pTab->tabFlags & TF_Autoincrement ){ + sqlite3NestedParse(pParse, + "DELETE FROM %Q.sqlite_sequence WHERE name=%Q", + pDb->zDbSName, pTab->zName + ); + } +#endif + + /* Drop all entries in the schema table that refer to the + ** table. The program name loops through the schema table and deletes + ** every row that refers to a table of the same name as the one being + ** dropped. Triggers are handled separately because a trigger can be + ** created in the temp database that refers to a table in another + ** database. + */ + sqlite3NestedParse(pParse, + "DELETE FROM %Q." LEGACY_SCHEMA_TABLE + " WHERE tbl_name=%Q and type!='trigger'", + pDb->zDbSName, pTab->zName); + if( !isView && !IsVirtual(pTab) ){ + destroyTable(pParse, pTab); + } + + /* Remove the table entry from SQLite's internal schema and modify + ** the schema cookie. + */ + if( IsVirtual(pTab) ){ + sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0); + sqlite3MayAbort(pParse); + } + sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0); + sqlite3ChangeCookie(pParse, iDb); + sqliteViewResetAll(db, iDb); +} + +/* +** Return TRUE if shadow tables should be read-only in the current +** context. +*/ +SQLITE_PRIVATE int sqlite3ReadOnlyShadowTables(sqlite3 *db){ +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( (db->flags & SQLITE_Defensive)!=0 + && db->pVtabCtx==0 + && db->nVdbeExec==0 + && !sqlite3VtabInSync(db) + ){ + return 1; + } +#endif + return 0; +} + +/* +** Return true if it is not allowed to drop the given table +*/ +static int tableMayNotBeDropped(sqlite3 *db, Table *pTab){ + if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){ + if( sqlite3StrNICmp(pTab->zName+7, "stat", 4)==0 ) return 0; + if( sqlite3StrNICmp(pTab->zName+7, "parameters", 10)==0 ) return 0; + return 1; + } + if( (pTab->tabFlags & TF_Shadow)!=0 && sqlite3ReadOnlyShadowTables(db) ){ + return 1; + } + if( pTab->tabFlags & TF_Eponymous ){ + return 1; + } + return 0; +} + +/* +** This routine is called to do the work of a DROP TABLE statement. +** pName is the name of the table to be dropped. +*/ +SQLITE_PRIVATE void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){ + Table *pTab; + Vdbe *v; + sqlite3 *db = pParse->db; + int iDb; + + if( db->mallocFailed ){ + goto exit_drop_table; + } + assert( pParse->nErr==0 ); + assert( pName->nSrc==1 ); + if( sqlite3ReadSchema(pParse) ) goto exit_drop_table; + if( noErr ) db->suppressErr++; + assert( isView==0 || isView==LOCATE_VIEW ); + pTab = sqlite3LocateTableItem(pParse, isView, &pName->a[0]); + if( noErr ) db->suppressErr--; + + if( pTab==0 ){ + if( noErr ){ + sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase); + sqlite3ForceNotReadOnly(pParse); + } + goto exit_drop_table; + } + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( iDb>=0 && iDbnDb ); + + /* If pTab is a virtual table, call ViewGetColumnNames() to ensure + ** it is initialized. + */ + if( IsVirtual(pTab) && sqlite3ViewGetColumnNames(pParse, pTab) ){ + goto exit_drop_table; + } +#ifndef SQLITE_OMIT_AUTHORIZATION + { + int code; + const char *zTab = SCHEMA_TABLE(iDb); + const char *zDb = db->aDb[iDb].zDbSName; + const char *zArg2 = 0; + if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){ + goto exit_drop_table; + } + if( isView ){ + if( !OMIT_TEMPDB && iDb==1 ){ + code = SQLITE_DROP_TEMP_VIEW; + }else{ + code = SQLITE_DROP_VIEW; + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + }else if( IsVirtual(pTab) ){ + code = SQLITE_DROP_VTABLE; + zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName; +#endif + }else{ + if( !OMIT_TEMPDB && iDb==1 ){ + code = SQLITE_DROP_TEMP_TABLE; + }else{ + code = SQLITE_DROP_TABLE; + } + } + if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){ + goto exit_drop_table; + } + if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){ + goto exit_drop_table; + } + } +#endif + if( tableMayNotBeDropped(db, pTab) ){ + sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName); + goto exit_drop_table; + } + +#ifndef SQLITE_OMIT_VIEW + /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used + ** on a table. + */ + if( isView && !IsView(pTab) ){ + sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName); + goto exit_drop_table; + } + if( !isView && IsView(pTab) ){ + sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName); + goto exit_drop_table; + } +#endif + + /* Generate code to remove the table from the schema table + ** on disk. + */ + v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3BeginWriteOperation(pParse, 1, iDb); + if( !isView ){ + sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName); + sqlite3FkDropTable(pParse, pName, pTab); + } + sqlite3CodeDropTable(pParse, pTab, iDb, isView); + } + +exit_drop_table: + sqlite3SrcListDelete(db, pName); +} + +/* +** This routine is called to create a new foreign key on the table +** currently under construction. pFromCol determines which columns +** in the current table point to the foreign key. If pFromCol==0 then +** connect the key to the last column inserted. pTo is the name of +** the table referred to (a.k.a the "parent" table). pToCol is a list +** of tables in the parent pTo table. flags contains all +** information about the conflict resolution algorithms specified +** in the ON DELETE, ON UPDATE and ON INSERT clauses. +** +** An FKey structure is created and added to the table currently +** under construction in the pParse->pNewTable field. +** +** The foreign key is set for IMMEDIATE processing. A subsequent call +** to sqlite3DeferForeignKey() might change this to DEFERRED. +*/ +SQLITE_PRIVATE void sqlite3CreateForeignKey( + Parse *pParse, /* Parsing context */ + ExprList *pFromCol, /* Columns in this table that point to other table */ + Token *pTo, /* Name of the other table */ + ExprList *pToCol, /* Columns in the other table */ + int flags /* Conflict resolution algorithms. */ +){ + sqlite3 *db = pParse->db; +#ifndef SQLITE_OMIT_FOREIGN_KEY + FKey *pFKey = 0; + FKey *pNextTo; + Table *p = pParse->pNewTable; + i64 nByte; + int i; + int nCol; + char *z; + + assert( pTo!=0 ); + if( p==0 || IN_DECLARE_VTAB ) goto fk_end; + if( pFromCol==0 ){ + int iCol = p->nCol-1; + if( NEVER(iCol<0) ) goto fk_end; + if( pToCol && pToCol->nExpr!=1 ){ + sqlite3ErrorMsg(pParse, "foreign key on %s" + " should reference only one column of table %T", + p->aCol[iCol].zCnName, pTo); + goto fk_end; + } + nCol = 1; + }else if( pToCol && pToCol->nExpr!=pFromCol->nExpr ){ + sqlite3ErrorMsg(pParse, + "number of columns in foreign key does not match the number of " + "columns in the referenced table"); + goto fk_end; + }else{ + nCol = pFromCol->nExpr; + } + nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1; + if( pToCol ){ + for(i=0; inExpr; i++){ + nByte += sqlite3Strlen30(pToCol->a[i].zEName) + 1; + } + } + pFKey = sqlite3DbMallocZero(db, nByte ); + if( pFKey==0 ){ + goto fk_end; + } + pFKey->pFrom = p; + assert( IsOrdinaryTable(p) ); + pFKey->pNextFrom = p->u.tab.pFKey; + z = (char*)&pFKey->aCol[nCol]; + pFKey->zTo = z; + if( IN_RENAME_OBJECT ){ + sqlite3RenameTokenMap(pParse, (void*)z, pTo); + } + memcpy(z, pTo->z, pTo->n); + z[pTo->n] = 0; + sqlite3Dequote(z); + z += pTo->n+1; + pFKey->nCol = nCol; + if( pFromCol==0 ){ + pFKey->aCol[0].iFrom = p->nCol-1; + }else{ + for(i=0; inCol; j++){ + if( sqlite3StrICmp(p->aCol[j].zCnName, pFromCol->a[i].zEName)==0 ){ + pFKey->aCol[i].iFrom = j; + break; + } + } + if( j>=p->nCol ){ + sqlite3ErrorMsg(pParse, + "unknown column \"%s\" in foreign key definition", + pFromCol->a[i].zEName); + goto fk_end; + } + if( IN_RENAME_OBJECT ){ + sqlite3RenameTokenRemap(pParse, &pFKey->aCol[i], pFromCol->a[i].zEName); + } + } + } + if( pToCol ){ + for(i=0; ia[i].zEName); + pFKey->aCol[i].zCol = z; + if( IN_RENAME_OBJECT ){ + sqlite3RenameTokenRemap(pParse, z, pToCol->a[i].zEName); + } + memcpy(z, pToCol->a[i].zEName, n); + z[n] = 0; + z += n+1; + } + } + pFKey->isDeferred = 0; + pFKey->aAction[0] = (u8)(flags & 0xff); /* ON DELETE action */ + pFKey->aAction[1] = (u8)((flags >> 8 ) & 0xff); /* ON UPDATE action */ + + assert( sqlite3SchemaMutexHeld(db, 0, p->pSchema) ); + pNextTo = (FKey *)sqlite3HashInsert(&p->pSchema->fkeyHash, + pFKey->zTo, (void *)pFKey + ); + if( pNextTo==pFKey ){ + sqlite3OomFault(db); + goto fk_end; + } + if( pNextTo ){ + assert( pNextTo->pPrevTo==0 ); + pFKey->pNextTo = pNextTo; + pNextTo->pPrevTo = pFKey; + } + + /* Link the foreign key to the table as the last step. + */ + assert( IsOrdinaryTable(p) ); + p->u.tab.pFKey = pFKey; + pFKey = 0; + +fk_end: + sqlite3DbFree(db, pFKey); +#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */ + sqlite3ExprListDelete(db, pFromCol); + sqlite3ExprListDelete(db, pToCol); +} + +/* +** This routine is called when an INITIALLY IMMEDIATE or INITIALLY DEFERRED +** clause is seen as part of a foreign key definition. The isDeferred +** parameter is 1 for INITIALLY DEFERRED and 0 for INITIALLY IMMEDIATE. +** The behavior of the most recently created foreign key is adjusted +** accordingly. +*/ +SQLITE_PRIVATE void sqlite3DeferForeignKey(Parse *pParse, int isDeferred){ +#ifndef SQLITE_OMIT_FOREIGN_KEY + Table *pTab; + FKey *pFKey; + if( (pTab = pParse->pNewTable)==0 ) return; + if( NEVER(!IsOrdinaryTable(pTab)) ) return; + if( (pFKey = pTab->u.tab.pFKey)==0 ) return; + assert( isDeferred==0 || isDeferred==1 ); /* EV: R-30323-21917 */ + pFKey->isDeferred = (u8)isDeferred; +#endif +} + +/* +** Generate code that will erase and refill index *pIdx. This is +** used to initialize a newly created index or to recompute the +** content of an index in response to a REINDEX command. +** +** if memRootPage is not negative, it means that the index is newly +** created. The register specified by memRootPage contains the +** root page number of the index. If memRootPage is negative, then +** the index already exists and must be cleared before being refilled and +** the root page number of the index is taken from pIndex->tnum. +*/ +static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){ + Table *pTab = pIndex->pTable; /* The table that is indexed */ + int iTab = pParse->nTab++; /* Btree cursor used for pTab */ + int iIdx = pParse->nTab++; /* Btree cursor used for pIndex */ + int iSorter; /* Cursor opened by OpenSorter (if in use) */ + int addr1; /* Address of top of loop */ + int addr2; /* Address to jump to for next iteration */ + Pgno tnum; /* Root page of index */ + int iPartIdxLabel; /* Jump to this label to skip a row */ + Vdbe *v; /* Generate code into this virtual machine */ + KeyInfo *pKey; /* KeyInfo for index */ + int regRecord; /* Register holding assembled index record */ + sqlite3 *db = pParse->db; /* The database connection */ + int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema); + +#ifndef SQLITE_OMIT_AUTHORIZATION + if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0, + db->aDb[iDb].zDbSName ) ){ + return; + } +#endif + + /* Require a write-lock on the table to perform this operation */ + sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName); + + v = sqlite3GetVdbe(pParse); + if( v==0 ) return; + if( memRootPage>=0 ){ + tnum = (Pgno)memRootPage; + }else{ + tnum = pIndex->tnum; + } + pKey = sqlite3KeyInfoOfIndex(pParse, pIndex); + assert( pKey!=0 || pParse->nErr ); + + /* Open the sorter cursor if we are to use one. */ + iSorter = pParse->nTab++; + sqlite3VdbeAddOp4(v, OP_SorterOpen, iSorter, 0, pIndex->nKeyCol, (char*) + sqlite3KeyInfoRef(pKey), P4_KEYINFO); + + /* Open the table. Loop through all rows of the table, inserting index + ** records into the sorter. */ + sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead); + addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0); VdbeCoverage(v); + regRecord = sqlite3GetTempReg(pParse); + sqlite3MultiWrite(pParse); + + sqlite3GenerateIndexKey(pParse,pIndex,iTab,regRecord,0,&iPartIdxLabel,0,0); + sqlite3VdbeAddOp2(v, OP_SorterInsert, iSorter, regRecord); + sqlite3ResolvePartIdxLabel(pParse, iPartIdxLabel); + sqlite3VdbeAddOp2(v, OP_Next, iTab, addr1+1); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addr1); + if( memRootPage<0 ) sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb); + sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, (int)tnum, iDb, + (char *)pKey, P4_KEYINFO); + sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR|((memRootPage>=0)?OPFLAG_P2ISREG:0)); + + addr1 = sqlite3VdbeAddOp2(v, OP_SorterSort, iSorter, 0); VdbeCoverage(v); + if( IsUniqueIndex(pIndex) ){ + int j2 = sqlite3VdbeGoto(v, 1); + addr2 = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeVerifyAbortable(v, OE_Abort); + sqlite3VdbeAddOp4Int(v, OP_SorterCompare, iSorter, j2, regRecord, + pIndex->nKeyCol); VdbeCoverage(v); + sqlite3UniqueConstraint(pParse, OE_Abort, pIndex); + sqlite3VdbeJumpHere(v, j2); + }else{ + /* Most CREATE INDEX and REINDEX statements that are not UNIQUE can not + ** abort. The exception is if one of the indexed expressions contains a + ** user function that throws an exception when it is evaluated. But the + ** overhead of adding a statement journal to a CREATE INDEX statement is + ** very small (since most of the pages written do not contain content that + ** needs to be restored if the statement aborts), so we call + ** sqlite3MayAbort() for all CREATE INDEX statements. */ + sqlite3MayAbort(pParse); + addr2 = sqlite3VdbeCurrentAddr(v); + } + sqlite3VdbeAddOp3(v, OP_SorterData, iSorter, regRecord, iIdx); + if( !pIndex->bAscKeyBug ){ + /* This OP_SeekEnd opcode makes index insert for a REINDEX go much + ** faster by avoiding unnecessary seeks. But the optimization does + ** not work for UNIQUE constraint indexes on WITHOUT ROWID tables + ** with DESC primary keys, since those indexes have there keys in + ** a different order from the main table. + ** See ticket: https://www.sqlite.org/src/info/bba7b69f9849b5bf + */ + sqlite3VdbeAddOp1(v, OP_SeekEnd, iIdx); + } + sqlite3VdbeAddOp2(v, OP_IdxInsert, iIdx, regRecord); + sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT); + sqlite3ReleaseTempReg(pParse, regRecord); + sqlite3VdbeAddOp2(v, OP_SorterNext, iSorter, addr2); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addr1); + + sqlite3VdbeAddOp1(v, OP_Close, iTab); + sqlite3VdbeAddOp1(v, OP_Close, iIdx); + sqlite3VdbeAddOp1(v, OP_Close, iSorter); +} + +/* +** Allocate heap space to hold an Index object with nCol columns. +** +** Increase the allocation size to provide an extra nExtra bytes +** of 8-byte aligned space after the Index object and return a +** pointer to this extra space in *ppExtra. +*/ +SQLITE_PRIVATE Index *sqlite3AllocateIndexObject( + sqlite3 *db, /* Database connection */ + i16 nCol, /* Total number of columns in the index */ + int nExtra, /* Number of bytes of extra space to alloc */ + char **ppExtra /* Pointer to the "extra" space */ +){ + Index *p; /* Allocated index object */ + int nByte; /* Bytes of space for Index object + arrays */ + + nByte = ROUND8(sizeof(Index)) + /* Index structure */ + ROUND8(sizeof(char*)*nCol) + /* Index.azColl */ + ROUND8(sizeof(LogEst)*(nCol+1) + /* Index.aiRowLogEst */ + sizeof(i16)*nCol + /* Index.aiColumn */ + sizeof(u8)*nCol); /* Index.aSortOrder */ + p = sqlite3DbMallocZero(db, nByte + nExtra); + if( p ){ + char *pExtra = ((char*)p)+ROUND8(sizeof(Index)); + p->azColl = (const char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol); + p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1); + p->aiColumn = (i16*)pExtra; pExtra += sizeof(i16)*nCol; + p->aSortOrder = (u8*)pExtra; + p->nColumn = nCol; + p->nKeyCol = nCol - 1; + *ppExtra = ((char*)p) + nByte; + } + return p; +} + +/* +** If expression list pList contains an expression that was parsed with +** an explicit "NULLS FIRST" or "NULLS LAST" clause, leave an error in +** pParse and return non-zero. Otherwise, return zero. +*/ +SQLITE_PRIVATE int sqlite3HasExplicitNulls(Parse *pParse, ExprList *pList){ + if( pList ){ + int i; + for(i=0; inExpr; i++){ + if( pList->a[i].fg.bNulls ){ + u8 sf = pList->a[i].fg.sortFlags; + sqlite3ErrorMsg(pParse, "unsupported use of NULLS %s", + (sf==0 || sf==3) ? "FIRST" : "LAST" + ); + return 1; + } + } + } + return 0; +} + +/* +** Create a new index for an SQL table. pName1.pName2 is the name of the index +** and pTblList is the name of the table that is to be indexed. Both will +** be NULL for a primary key or an index that is created to satisfy a +** UNIQUE constraint. If pTable and pIndex are NULL, use pParse->pNewTable +** as the table to be indexed. pParse->pNewTable is a table that is +** currently being constructed by a CREATE TABLE statement. +** +** pList is a list of columns to be indexed. pList will be NULL if this +** is a primary key or unique-constraint on the most recent column added +** to the table currently under construction. +*/ +SQLITE_PRIVATE void sqlite3CreateIndex( + Parse *pParse, /* All information about this parse */ + Token *pName1, /* First part of index name. May be NULL */ + Token *pName2, /* Second part of index name. May be NULL */ + SrcList *pTblName, /* Table to index. Use pParse->pNewTable if 0 */ + ExprList *pList, /* A list of columns to be indexed */ + int onError, /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */ + Token *pStart, /* The CREATE token that begins this statement */ + Expr *pPIWhere, /* WHERE clause for partial indices */ + int sortOrder, /* Sort order of primary key when pList==NULL */ + int ifNotExist, /* Omit error if index already exists */ + u8 idxType /* The index type */ +){ + Table *pTab = 0; /* Table to be indexed */ + Index *pIndex = 0; /* The index to be created */ + char *zName = 0; /* Name of the index */ + int nName; /* Number of characters in zName */ + int i, j; + DbFixer sFix; /* For assigning database names to pTable */ + int sortOrderMask; /* 1 to honor DESC in index. 0 to ignore. */ + sqlite3 *db = pParse->db; + Db *pDb; /* The specific table containing the indexed database */ + int iDb; /* Index of the database that is being written */ + Token *pName = 0; /* Unqualified name of the index to create */ + struct ExprList_item *pListItem; /* For looping over pList */ + int nExtra = 0; /* Space allocated for zExtra[] */ + int nExtraCol; /* Number of extra columns needed */ + char *zExtra = 0; /* Extra space after the Index object */ + Index *pPk = 0; /* PRIMARY KEY index for WITHOUT ROWID tables */ + + assert( db->pParse==pParse ); + if( pParse->nErr ){ + goto exit_create_index; + } + assert( db->mallocFailed==0 ); + if( IN_DECLARE_VTAB && idxType!=SQLITE_IDXTYPE_PRIMARYKEY ){ + goto exit_create_index; + } + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + goto exit_create_index; + } + if( sqlite3HasExplicitNulls(pParse, pList) ){ + goto exit_create_index; + } + + /* + ** Find the table that is to be indexed. Return early if not found. + */ + if( pTblName!=0 ){ + + /* Use the two-part index name to determine the database + ** to search for the table. 'Fix' the table name to this db + ** before looking up the table. + */ + assert( pName1 && pName2 ); + iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName); + if( iDb<0 ) goto exit_create_index; + assert( pName && pName->z ); + +#ifndef SQLITE_OMIT_TEMPDB + /* If the index name was unqualified, check if the table + ** is a temp table. If so, set the database to 1. Do not do this + ** if initialising a database schema. + */ + if( !db->init.busy ){ + pTab = sqlite3SrcListLookup(pParse, pTblName); + if( pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){ + iDb = 1; + } + } +#endif + + sqlite3FixInit(&sFix, pParse, iDb, "index", pName); + if( sqlite3FixSrcList(&sFix, pTblName) ){ + /* Because the parser constructs pTblName from a single identifier, + ** sqlite3FixSrcList can never fail. */ + assert(0); + } + pTab = sqlite3LocateTableItem(pParse, 0, &pTblName->a[0]); + assert( db->mallocFailed==0 || pTab==0 ); + if( pTab==0 ) goto exit_create_index; + if( iDb==1 && db->aDb[iDb].pSchema!=pTab->pSchema ){ + sqlite3ErrorMsg(pParse, + "cannot create a TEMP index on non-TEMP table \"%s\"", + pTab->zName); + goto exit_create_index; + } + if( !HasRowid(pTab) ) pPk = sqlite3PrimaryKeyIndex(pTab); + }else{ + assert( pName==0 ); + assert( pStart==0 ); + pTab = pParse->pNewTable; + if( !pTab ) goto exit_create_index; + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + } + pDb = &db->aDb[iDb]; + + assert( pTab!=0 ); + if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 + && db->init.busy==0 + && pTblName!=0 +#if SQLITE_USER_AUTHENTICATION + && sqlite3UserAuthTable(pTab->zName)==0 +#endif + ){ + sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName); + goto exit_create_index; + } +#ifndef SQLITE_OMIT_VIEW + if( IsView(pTab) ){ + sqlite3ErrorMsg(pParse, "views may not be indexed"); + goto exit_create_index; + } +#endif +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTab) ){ + sqlite3ErrorMsg(pParse, "virtual tables may not be indexed"); + goto exit_create_index; + } +#endif + + /* + ** Find the name of the index. Make sure there is not already another + ** index or table with the same name. + ** + ** Exception: If we are reading the names of permanent indices from the + ** sqlite_schema table (because some other process changed the schema) and + ** one of the index names collides with the name of a temporary table or + ** index, then we will continue to process this index. + ** + ** If pName==0 it means that we are + ** dealing with a primary key or UNIQUE constraint. We have to invent our + ** own name. + */ + if( pName ){ + zName = sqlite3NameFromToken(db, pName); + if( zName==0 ) goto exit_create_index; + assert( pName->z!=0 ); + if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName,"index",pTab->zName) ){ + goto exit_create_index; + } + if( !IN_RENAME_OBJECT ){ + if( !db->init.busy ){ + if( sqlite3FindTable(db, zName, pDb->zDbSName)!=0 ){ + sqlite3ErrorMsg(pParse, "there is already a table named %s", zName); + goto exit_create_index; + } + } + if( sqlite3FindIndex(db, zName, pDb->zDbSName)!=0 ){ + if( !ifNotExist ){ + sqlite3ErrorMsg(pParse, "index %s already exists", zName); + }else{ + assert( !db->init.busy ); + sqlite3CodeVerifySchema(pParse, iDb); + sqlite3ForceNotReadOnly(pParse); + } + goto exit_create_index; + } + } + }else{ + int n; + Index *pLoop; + for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){} + zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n); + if( zName==0 ){ + goto exit_create_index; + } + + /* Automatic index names generated from within sqlite3_declare_vtab() + ** must have names that are distinct from normal automatic index names. + ** The following statement converts "sqlite3_autoindex..." into + ** "sqlite3_butoindex..." in order to make the names distinct. + ** The "vtab_err.test" test demonstrates the need of this statement. */ + if( IN_SPECIAL_PARSE ) zName[7]++; + } + + /* Check for authorization to create an index. + */ +#ifndef SQLITE_OMIT_AUTHORIZATION + if( !IN_RENAME_OBJECT ){ + const char *zDb = pDb->zDbSName; + if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){ + goto exit_create_index; + } + i = SQLITE_CREATE_INDEX; + if( !OMIT_TEMPDB && iDb==1 ) i = SQLITE_CREATE_TEMP_INDEX; + if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){ + goto exit_create_index; + } + } +#endif + + /* If pList==0, it means this routine was called to make a primary + ** key out of the last column added to the table under construction. + ** So create a fake list to simulate this. + */ + if( pList==0 ){ + Token prevCol; + Column *pCol = &pTab->aCol[pTab->nCol-1]; + pCol->colFlags |= COLFLAG_UNIQUE; + sqlite3TokenInit(&prevCol, pCol->zCnName); + pList = sqlite3ExprListAppend(pParse, 0, + sqlite3ExprAlloc(db, TK_ID, &prevCol, 0)); + if( pList==0 ) goto exit_create_index; + assert( pList->nExpr==1 ); + sqlite3ExprListSetSortOrder(pList, sortOrder, SQLITE_SO_UNDEFINED); + }else{ + sqlite3ExprListCheckLength(pParse, pList, "index"); + if( pParse->nErr ) goto exit_create_index; + } + + /* Figure out how many bytes of space are required to store explicitly + ** specified collation sequence names. + */ + for(i=0; inExpr; i++){ + Expr *pExpr = pList->a[i].pExpr; + assert( pExpr!=0 ); + if( pExpr->op==TK_COLLATE ){ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + nExtra += (1 + sqlite3Strlen30(pExpr->u.zToken)); + } + } + + /* + ** Allocate the index structure. + */ + nName = sqlite3Strlen30(zName); + nExtraCol = pPk ? pPk->nKeyCol : 1; + assert( pList->nExpr + nExtraCol <= 32767 /* Fits in i16 */ ); + pIndex = sqlite3AllocateIndexObject(db, pList->nExpr + nExtraCol, + nName + nExtra + 1, &zExtra); + if( db->mallocFailed ){ + goto exit_create_index; + } + assert( EIGHT_BYTE_ALIGNMENT(pIndex->aiRowLogEst) ); + assert( EIGHT_BYTE_ALIGNMENT(pIndex->azColl) ); + pIndex->zName = zExtra; + zExtra += nName + 1; + memcpy(pIndex->zName, zName, nName+1); + pIndex->pTable = pTab; + pIndex->onError = (u8)onError; + pIndex->uniqNotNull = onError!=OE_None; + pIndex->idxType = idxType; + pIndex->pSchema = db->aDb[iDb].pSchema; + pIndex->nKeyCol = pList->nExpr; + if( pPIWhere ){ + sqlite3ResolveSelfReference(pParse, pTab, NC_PartIdx, pPIWhere, 0); + pIndex->pPartIdxWhere = pPIWhere; + pPIWhere = 0; + } + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + + /* Check to see if we should honor DESC requests on index columns + */ + if( pDb->pSchema->file_format>=4 ){ + sortOrderMask = -1; /* Honor DESC */ + }else{ + sortOrderMask = 0; /* Ignore DESC */ + } + + /* Analyze the list of expressions that form the terms of the index and + ** report any errors. In the common case where the expression is exactly + ** a table column, store that column in aiColumn[]. For general expressions, + ** populate pIndex->aColExpr and store XN_EXPR (-2) in aiColumn[]. + ** + ** TODO: Issue a warning if two or more columns of the index are identical. + ** TODO: Issue a warning if the table primary key is used as part of the + ** index key. + */ + pListItem = pList->a; + if( IN_RENAME_OBJECT ){ + pIndex->aColExpr = pList; + pList = 0; + } + for(i=0; inKeyCol; i++, pListItem++){ + Expr *pCExpr; /* The i-th index expression */ + int requestedSortOrder; /* ASC or DESC on the i-th expression */ + const char *zColl; /* Collation sequence name */ + + sqlite3StringToId(pListItem->pExpr); + sqlite3ResolveSelfReference(pParse, pTab, NC_IdxExpr, pListItem->pExpr, 0); + if( pParse->nErr ) goto exit_create_index; + pCExpr = sqlite3ExprSkipCollate(pListItem->pExpr); + if( pCExpr->op!=TK_COLUMN ){ + if( pTab==pParse->pNewTable ){ + sqlite3ErrorMsg(pParse, "expressions prohibited in PRIMARY KEY and " + "UNIQUE constraints"); + goto exit_create_index; + } + if( pIndex->aColExpr==0 ){ + pIndex->aColExpr = pList; + pList = 0; + } + j = XN_EXPR; + pIndex->aiColumn[i] = XN_EXPR; + pIndex->uniqNotNull = 0; + pIndex->bHasExpr = 1; + }else{ + j = pCExpr->iColumn; + assert( j<=0x7fff ); + if( j<0 ){ + j = pTab->iPKey; + }else{ + if( pTab->aCol[j].notNull==0 ){ + pIndex->uniqNotNull = 0; + } + if( pTab->aCol[j].colFlags & COLFLAG_VIRTUAL ){ + pIndex->bHasVCol = 1; + pIndex->bHasExpr = 1; + } + } + pIndex->aiColumn[i] = (i16)j; + } + zColl = 0; + if( pListItem->pExpr->op==TK_COLLATE ){ + int nColl; + assert( !ExprHasProperty(pListItem->pExpr, EP_IntValue) ); + zColl = pListItem->pExpr->u.zToken; + nColl = sqlite3Strlen30(zColl) + 1; + assert( nExtra>=nColl ); + memcpy(zExtra, zColl, nColl); + zColl = zExtra; + zExtra += nColl; + nExtra -= nColl; + }else if( j>=0 ){ + zColl = sqlite3ColumnColl(&pTab->aCol[j]); + } + if( !zColl ) zColl = sqlite3StrBINARY; + if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl) ){ + goto exit_create_index; + } + pIndex->azColl[i] = zColl; + requestedSortOrder = pListItem->fg.sortFlags & sortOrderMask; + pIndex->aSortOrder[i] = (u8)requestedSortOrder; + } + + /* Append the table key to the end of the index. For WITHOUT ROWID + ** tables (when pPk!=0) this will be the declared PRIMARY KEY. For + ** normal tables (when pPk==0) this will be the rowid. + */ + if( pPk ){ + for(j=0; jnKeyCol; j++){ + int x = pPk->aiColumn[j]; + assert( x>=0 ); + if( isDupColumn(pIndex, pIndex->nKeyCol, pPk, j) ){ + pIndex->nColumn--; + }else{ + testcase( hasColumn(pIndex->aiColumn,pIndex->nKeyCol,x) ); + pIndex->aiColumn[i] = x; + pIndex->azColl[i] = pPk->azColl[j]; + pIndex->aSortOrder[i] = pPk->aSortOrder[j]; + i++; + } + } + assert( i==pIndex->nColumn ); + }else{ + pIndex->aiColumn[i] = XN_ROWID; + pIndex->azColl[i] = sqlite3StrBINARY; + } + sqlite3DefaultRowEst(pIndex); + if( pParse->pNewTable==0 ) estimateIndexWidth(pIndex); + + /* If this index contains every column of its table, then mark + ** it as a covering index */ + assert( HasRowid(pTab) + || pTab->iPKey<0 || sqlite3TableColumnToIndex(pIndex, pTab->iPKey)>=0 ); + recomputeColumnsNotIndexed(pIndex); + if( pTblName!=0 && pIndex->nColumn>=pTab->nCol ){ + pIndex->isCovering = 1; + for(j=0; jnCol; j++){ + if( j==pTab->iPKey ) continue; + if( sqlite3TableColumnToIndex(pIndex,j)>=0 ) continue; + pIndex->isCovering = 0; + break; + } + } + + if( pTab==pParse->pNewTable ){ + /* This routine has been called to create an automatic index as a + ** result of a PRIMARY KEY or UNIQUE clause on a column definition, or + ** a PRIMARY KEY or UNIQUE clause following the column definitions. + ** i.e. one of: + ** + ** CREATE TABLE t(x PRIMARY KEY, y); + ** CREATE TABLE t(x, y, UNIQUE(x, y)); + ** + ** Either way, check to see if the table already has such an index. If + ** so, don't bother creating this one. This only applies to + ** automatically created indices. Users can do as they wish with + ** explicit indices. + ** + ** Two UNIQUE or PRIMARY KEY constraints are considered equivalent + ** (and thus suppressing the second one) even if they have different + ** sort orders. + ** + ** If there are different collating sequences or if the columns of + ** the constraint occur in different orders, then the constraints are + ** considered distinct and both result in separate indices. + */ + Index *pIdx; + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + int k; + assert( IsUniqueIndex(pIdx) ); + assert( pIdx->idxType!=SQLITE_IDXTYPE_APPDEF ); + assert( IsUniqueIndex(pIndex) ); + + if( pIdx->nKeyCol!=pIndex->nKeyCol ) continue; + for(k=0; knKeyCol; k++){ + const char *z1; + const char *z2; + assert( pIdx->aiColumn[k]>=0 ); + if( pIdx->aiColumn[k]!=pIndex->aiColumn[k] ) break; + z1 = pIdx->azColl[k]; + z2 = pIndex->azColl[k]; + if( sqlite3StrICmp(z1, z2) ) break; + } + if( k==pIdx->nKeyCol ){ + if( pIdx->onError!=pIndex->onError ){ + /* This constraint creates the same index as a previous + ** constraint specified somewhere in the CREATE TABLE statement. + ** However the ON CONFLICT clauses are different. If both this + ** constraint and the previous equivalent constraint have explicit + ** ON CONFLICT clauses this is an error. Otherwise, use the + ** explicitly specified behavior for the index. + */ + if( !(pIdx->onError==OE_Default || pIndex->onError==OE_Default) ){ + sqlite3ErrorMsg(pParse, + "conflicting ON CONFLICT clauses specified", 0); + } + if( pIdx->onError==OE_Default ){ + pIdx->onError = pIndex->onError; + } + } + if( idxType==SQLITE_IDXTYPE_PRIMARYKEY ) pIdx->idxType = idxType; + if( IN_RENAME_OBJECT ){ + pIndex->pNext = pParse->pNewIndex; + pParse->pNewIndex = pIndex; + pIndex = 0; + } + goto exit_create_index; + } + } + } + + if( !IN_RENAME_OBJECT ){ + + /* Link the new Index structure to its table and to the other + ** in-memory database structures. + */ + assert( pParse->nErr==0 ); + if( db->init.busy ){ + Index *p; + assert( !IN_SPECIAL_PARSE ); + assert( sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) ); + if( pTblName!=0 ){ + pIndex->tnum = db->init.newTnum; + if( sqlite3IndexHasDuplicateRootPage(pIndex) ){ + sqlite3ErrorMsg(pParse, "invalid rootpage"); + pParse->rc = SQLITE_CORRUPT_BKPT; + goto exit_create_index; + } + } + p = sqlite3HashInsert(&pIndex->pSchema->idxHash, + pIndex->zName, pIndex); + if( p ){ + assert( p==pIndex ); /* Malloc must have failed */ + sqlite3OomFault(db); + goto exit_create_index; + } + db->mDbFlags |= DBFLAG_SchemaChange; + } + + /* If this is the initial CREATE INDEX statement (or CREATE TABLE if the + ** index is an implied index for a UNIQUE or PRIMARY KEY constraint) then + ** emit code to allocate the index rootpage on disk and make an entry for + ** the index in the sqlite_schema table and populate the index with + ** content. But, do not do this if we are simply reading the sqlite_schema + ** table to parse the schema, or if this index is the PRIMARY KEY index + ** of a WITHOUT ROWID table. + ** + ** If pTblName==0 it means this index is generated as an implied PRIMARY KEY + ** or UNIQUE index in a CREATE TABLE statement. Since the table + ** has just been created, it contains no data and the index initialization + ** step can be skipped. + */ + else if( HasRowid(pTab) || pTblName!=0 ){ + Vdbe *v; + char *zStmt; + int iMem = ++pParse->nMem; + + v = sqlite3GetVdbe(pParse); + if( v==0 ) goto exit_create_index; + + sqlite3BeginWriteOperation(pParse, 1, iDb); + + /* Create the rootpage for the index using CreateIndex. But before + ** doing so, code a Noop instruction and store its address in + ** Index.tnum. This is required in case this index is actually a + ** PRIMARY KEY and the table is actually a WITHOUT ROWID table. In + ** that case the convertToWithoutRowidTable() routine will replace + ** the Noop with a Goto to jump over the VDBE code generated below. */ + pIndex->tnum = (Pgno)sqlite3VdbeAddOp0(v, OP_Noop); + sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, iMem, BTREE_BLOBKEY); + + /* Gather the complete text of the CREATE INDEX statement into + ** the zStmt variable + */ + assert( pName!=0 || pStart==0 ); + if( pStart ){ + int n = (int)(pParse->sLastToken.z - pName->z) + pParse->sLastToken.n; + if( pName->z[n-1]==';' ) n--; + /* A named index with an explicit CREATE INDEX statement */ + zStmt = sqlite3MPrintf(db, "CREATE%s INDEX %.*s", + onError==OE_None ? "" : " UNIQUE", n, pName->z); + }else{ + /* An automatic index created by a PRIMARY KEY or UNIQUE constraint */ + /* zStmt = sqlite3MPrintf(""); */ + zStmt = 0; + } + + /* Add an entry in sqlite_schema for this index + */ + sqlite3NestedParse(pParse, + "INSERT INTO %Q." LEGACY_SCHEMA_TABLE " VALUES('index',%Q,%Q,#%d,%Q);", + db->aDb[iDb].zDbSName, + pIndex->zName, + pTab->zName, + iMem, + zStmt + ); + sqlite3DbFree(db, zStmt); + + /* Fill the index with data and reparse the schema. Code an OP_Expire + ** to invalidate all pre-compiled statements. + */ + if( pTblName ){ + sqlite3RefillIndex(pParse, pIndex, iMem); + sqlite3ChangeCookie(pParse, iDb); + sqlite3VdbeAddParseSchemaOp(v, iDb, + sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName), 0); + sqlite3VdbeAddOp2(v, OP_Expire, 0, 1); + } + + sqlite3VdbeJumpHere(v, (int)pIndex->tnum); + } + } + if( db->init.busy || pTblName==0 ){ + pIndex->pNext = pTab->pIndex; + pTab->pIndex = pIndex; + pIndex = 0; + } + else if( IN_RENAME_OBJECT ){ + assert( pParse->pNewIndex==0 ); + pParse->pNewIndex = pIndex; + pIndex = 0; + } + + /* Clean up before exiting */ +exit_create_index: + if( pIndex ) sqlite3FreeIndex(db, pIndex); + if( pTab ){ + /* Ensure all REPLACE indexes on pTab are at the end of the pIndex list. + ** The list was already ordered when this routine was entered, so at this + ** point at most a single index (the newly added index) will be out of + ** order. So we have to reorder at most one index. */ + Index **ppFrom; + Index *pThis; + for(ppFrom=&pTab->pIndex; (pThis = *ppFrom)!=0; ppFrom=&pThis->pNext){ + Index *pNext; + if( pThis->onError!=OE_Replace ) continue; + while( (pNext = pThis->pNext)!=0 && pNext->onError!=OE_Replace ){ + *ppFrom = pNext; + pThis->pNext = pNext->pNext; + pNext->pNext = pThis; + ppFrom = &pNext->pNext; + } + break; + } +#ifdef SQLITE_DEBUG + /* Verify that all REPLACE indexes really are now at the end + ** of the index list. In other words, no other index type ever + ** comes after a REPLACE index on the list. */ + for(pThis = pTab->pIndex; pThis; pThis=pThis->pNext){ + assert( pThis->onError!=OE_Replace + || pThis->pNext==0 + || pThis->pNext->onError==OE_Replace ); + } +#endif + } + sqlite3ExprDelete(db, pPIWhere); + sqlite3ExprListDelete(db, pList); + sqlite3SrcListDelete(db, pTblName); + sqlite3DbFree(db, zName); +} + +/* +** Fill the Index.aiRowEst[] array with default information - information +** to be used when we have not run the ANALYZE command. +** +** aiRowEst[0] is supposed to contain the number of elements in the index. +** Since we do not know, guess 1 million. aiRowEst[1] is an estimate of the +** number of rows in the table that match any particular value of the +** first column of the index. aiRowEst[2] is an estimate of the number +** of rows that match any particular combination of the first 2 columns +** of the index. And so forth. It must always be the case that +* +** aiRowEst[N]<=aiRowEst[N-1] +** aiRowEst[N]>=1 +** +** Apart from that, we have little to go on besides intuition as to +** how aiRowEst[] should be initialized. The numbers generated here +** are based on typical values found in actual indices. +*/ +SQLITE_PRIVATE void sqlite3DefaultRowEst(Index *pIdx){ + /* 10, 9, 8, 7, 6 */ + static const LogEst aVal[] = { 33, 32, 30, 28, 26 }; + LogEst *a = pIdx->aiRowLogEst; + LogEst x; + int nCopy = MIN(ArraySize(aVal), pIdx->nKeyCol); + int i; + + /* Indexes with default row estimates should not have stat1 data */ + assert( !pIdx->hasStat1 ); + + /* Set the first entry (number of rows in the index) to the estimated + ** number of rows in the table, or half the number of rows in the table + ** for a partial index. + ** + ** 2020-05-27: If some of the stat data is coming from the sqlite_stat1 + ** table but other parts we are having to guess at, then do not let the + ** estimated number of rows in the table be less than 1000 (LogEst 99). + ** Failure to do this can cause the indexes for which we do not have + ** stat1 data to be ignored by the query planner. + */ + x = pIdx->pTable->nRowLogEst; + assert( 99==sqlite3LogEst(1000) ); + if( x<99 ){ + pIdx->pTable->nRowLogEst = x = 99; + } + if( pIdx->pPartIdxWhere!=0 ){ x -= 10; assert( 10==sqlite3LogEst(2) ); } + a[0] = x; + + /* Estimate that a[1] is 10, a[2] is 9, a[3] is 8, a[4] is 7, a[5] is + ** 6 and each subsequent value (if any) is 5. */ + memcpy(&a[1], aVal, nCopy*sizeof(LogEst)); + for(i=nCopy+1; i<=pIdx->nKeyCol; i++){ + a[i] = 23; assert( 23==sqlite3LogEst(5) ); + } + + assert( 0==sqlite3LogEst(1) ); + if( IsUniqueIndex(pIdx) ) a[pIdx->nKeyCol] = 0; +} + +/* +** This routine will drop an existing named index. This routine +** implements the DROP INDEX statement. +*/ +SQLITE_PRIVATE void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists){ + Index *pIndex; + Vdbe *v; + sqlite3 *db = pParse->db; + int iDb; + + if( db->mallocFailed ){ + goto exit_drop_index; + } + assert( pParse->nErr==0 ); /* Never called with prior non-OOM errors */ + assert( pName->nSrc==1 ); + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + goto exit_drop_index; + } + pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase); + if( pIndex==0 ){ + if( !ifExists ){ + sqlite3ErrorMsg(pParse, "no such index: %S", pName->a); + }else{ + sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase); + sqlite3ForceNotReadOnly(pParse); + } + pParse->checkSchema = 1; + goto exit_drop_index; + } + if( pIndex->idxType!=SQLITE_IDXTYPE_APPDEF ){ + sqlite3ErrorMsg(pParse, "index associated with UNIQUE " + "or PRIMARY KEY constraint cannot be dropped", 0); + goto exit_drop_index; + } + iDb = sqlite3SchemaToIndex(db, pIndex->pSchema); +#ifndef SQLITE_OMIT_AUTHORIZATION + { + int code = SQLITE_DROP_INDEX; + Table *pTab = pIndex->pTable; + const char *zDb = db->aDb[iDb].zDbSName; + const char *zTab = SCHEMA_TABLE(iDb); + if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){ + goto exit_drop_index; + } + if( !OMIT_TEMPDB && iDb==1 ) code = SQLITE_DROP_TEMP_INDEX; + if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){ + goto exit_drop_index; + } + } +#endif + + /* Generate code to remove the index and from the schema table */ + v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3BeginWriteOperation(pParse, 1, iDb); + sqlite3NestedParse(pParse, + "DELETE FROM %Q." LEGACY_SCHEMA_TABLE " WHERE name=%Q AND type='index'", + db->aDb[iDb].zDbSName, pIndex->zName + ); + sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName); + sqlite3ChangeCookie(pParse, iDb); + destroyRootPage(pParse, pIndex->tnum, iDb); + sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0); + } + +exit_drop_index: + sqlite3SrcListDelete(db, pName); +} + +/* +** pArray is a pointer to an array of objects. Each object in the +** array is szEntry bytes in size. This routine uses sqlite3DbRealloc() +** to extend the array so that there is space for a new object at the end. +** +** When this function is called, *pnEntry contains the current size of +** the array (in entries - so the allocation is ((*pnEntry) * szEntry) bytes +** in total). +** +** If the realloc() is successful (i.e. if no OOM condition occurs), the +** space allocated for the new object is zeroed, *pnEntry updated to +** reflect the new size of the array and a pointer to the new allocation +** returned. *pIdx is set to the index of the new array entry in this case. +** +** Otherwise, if the realloc() fails, *pIdx is set to -1, *pnEntry remains +** unchanged and a copy of pArray returned. +*/ +SQLITE_PRIVATE void *sqlite3ArrayAllocate( + sqlite3 *db, /* Connection to notify of malloc failures */ + void *pArray, /* Array of objects. Might be reallocated */ + int szEntry, /* Size of each object in the array */ + int *pnEntry, /* Number of objects currently in use */ + int *pIdx /* Write the index of a new slot here */ +){ + char *z; + sqlite3_int64 n = *pIdx = *pnEntry; + if( (n & (n-1))==0 ){ + sqlite3_int64 sz = (n==0) ? 1 : 2*n; + void *pNew = sqlite3DbRealloc(db, pArray, sz*szEntry); + if( pNew==0 ){ + *pIdx = -1; + return pArray; + } + pArray = pNew; + } + z = (char*)pArray; + memset(&z[n * szEntry], 0, szEntry); + ++*pnEntry; + return pArray; +} + +/* +** Append a new element to the given IdList. Create a new IdList if +** need be. +** +** A new IdList is returned, or NULL if malloc() fails. +*/ +SQLITE_PRIVATE IdList *sqlite3IdListAppend(Parse *pParse, IdList *pList, Token *pToken){ + sqlite3 *db = pParse->db; + int i; + if( pList==0 ){ + pList = sqlite3DbMallocZero(db, sizeof(IdList) ); + if( pList==0 ) return 0; + }else{ + IdList *pNew; + pNew = sqlite3DbRealloc(db, pList, + sizeof(IdList) + pList->nId*sizeof(pList->a)); + if( pNew==0 ){ + sqlite3IdListDelete(db, pList); + return 0; + } + pList = pNew; + } + i = pList->nId++; + pList->a[i].zName = sqlite3NameFromToken(db, pToken); + if( IN_RENAME_OBJECT && pList->a[i].zName ){ + sqlite3RenameTokenMap(pParse, (void*)pList->a[i].zName, pToken); + } + return pList; +} + +/* +** Delete an IdList. +*/ +SQLITE_PRIVATE void sqlite3IdListDelete(sqlite3 *db, IdList *pList){ + int i; + assert( db!=0 ); + if( pList==0 ) return; + assert( pList->eU4!=EU4_EXPR ); /* EU4_EXPR mode is not currently used */ + for(i=0; inId; i++){ + sqlite3DbFree(db, pList->a[i].zName); + } + sqlite3DbNNFreeNN(db, pList); +} + +/* +** Return the index in pList of the identifier named zId. Return -1 +** if not found. +*/ +SQLITE_PRIVATE int sqlite3IdListIndex(IdList *pList, const char *zName){ + int i; + assert( pList!=0 ); + for(i=0; inId; i++){ + if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i; + } + return -1; +} + +/* +** Maximum size of a SrcList object. +** The SrcList object is used to represent the FROM clause of a +** SELECT statement, and the query planner cannot deal with more +** than 64 tables in a join. So any value larger than 64 here +** is sufficient for most uses. Smaller values, like say 10, are +** appropriate for small and memory-limited applications. +*/ +#ifndef SQLITE_MAX_SRCLIST +# define SQLITE_MAX_SRCLIST 200 +#endif + +/* +** Expand the space allocated for the given SrcList object by +** creating nExtra new slots beginning at iStart. iStart is zero based. +** New slots are zeroed. +** +** For example, suppose a SrcList initially contains two entries: A,B. +** To append 3 new entries onto the end, do this: +** +** sqlite3SrcListEnlarge(db, pSrclist, 3, 2); +** +** After the call above it would contain: A, B, nil, nil, nil. +** If the iStart argument had been 1 instead of 2, then the result +** would have been: A, nil, nil, nil, B. To prepend the new slots, +** the iStart value would be 0. The result then would +** be: nil, nil, nil, A, B. +** +** If a memory allocation fails or the SrcList becomes too large, leave +** the original SrcList unchanged, return NULL, and leave an error message +** in pParse. +*/ +SQLITE_PRIVATE SrcList *sqlite3SrcListEnlarge( + Parse *pParse, /* Parsing context into which errors are reported */ + SrcList *pSrc, /* The SrcList to be enlarged */ + int nExtra, /* Number of new slots to add to pSrc->a[] */ + int iStart /* Index in pSrc->a[] of first new slot */ +){ + int i; + + /* Sanity checking on calling parameters */ + assert( iStart>=0 ); + assert( nExtra>=1 ); + assert( pSrc!=0 ); + assert( iStart<=pSrc->nSrc ); + + /* Allocate additional space if needed */ + if( (u32)pSrc->nSrc+nExtra>pSrc->nAlloc ){ + SrcList *pNew; + sqlite3_int64 nAlloc = 2*(sqlite3_int64)pSrc->nSrc+nExtra; + sqlite3 *db = pParse->db; + + if( pSrc->nSrc+nExtra>=SQLITE_MAX_SRCLIST ){ + sqlite3ErrorMsg(pParse, "too many FROM clause terms, max: %d", + SQLITE_MAX_SRCLIST); + return 0; + } + if( nAlloc>SQLITE_MAX_SRCLIST ) nAlloc = SQLITE_MAX_SRCLIST; + pNew = sqlite3DbRealloc(db, pSrc, + sizeof(*pSrc) + (nAlloc-1)*sizeof(pSrc->a[0]) ); + if( pNew==0 ){ + assert( db->mallocFailed ); + return 0; + } + pSrc = pNew; + pSrc->nAlloc = nAlloc; + } + + /* Move existing slots that come after the newly inserted slots + ** out of the way */ + for(i=pSrc->nSrc-1; i>=iStart; i--){ + pSrc->a[i+nExtra] = pSrc->a[i]; + } + pSrc->nSrc += nExtra; + + /* Zero the newly allocated slots */ + memset(&pSrc->a[iStart], 0, sizeof(pSrc->a[0])*nExtra); + for(i=iStart; ia[i].iCursor = -1; + } + + /* Return a pointer to the enlarged SrcList */ + return pSrc; +} + + +/* +** Append a new table name to the given SrcList. Create a new SrcList if +** need be. A new entry is created in the SrcList even if pTable is NULL. +** +** A SrcList is returned, or NULL if there is an OOM error or if the +** SrcList grows to large. The returned +** SrcList might be the same as the SrcList that was input or it might be +** a new one. If an OOM error does occurs, then the prior value of pList +** that is input to this routine is automatically freed. +** +** If pDatabase is not null, it means that the table has an optional +** database name prefix. Like this: "database.table". The pDatabase +** points to the table name and the pTable points to the database name. +** The SrcList.a[].zName field is filled with the table name which might +** come from pTable (if pDatabase is NULL) or from pDatabase. +** SrcList.a[].zDatabase is filled with the database name from pTable, +** or with NULL if no database is specified. +** +** In other words, if call like this: +** +** sqlite3SrcListAppend(D,A,B,0); +** +** Then B is a table name and the database name is unspecified. If called +** like this: +** +** sqlite3SrcListAppend(D,A,B,C); +** +** Then C is the table name and B is the database name. If C is defined +** then so is B. In other words, we never have a case where: +** +** sqlite3SrcListAppend(D,A,0,C); +** +** Both pTable and pDatabase are assumed to be quoted. They are dequoted +** before being added to the SrcList. +*/ +SQLITE_PRIVATE SrcList *sqlite3SrcListAppend( + Parse *pParse, /* Parsing context, in which errors are reported */ + SrcList *pList, /* Append to this SrcList. NULL creates a new SrcList */ + Token *pTable, /* Table to append */ + Token *pDatabase /* Database of the table */ +){ + SrcItem *pItem; + sqlite3 *db; + assert( pDatabase==0 || pTable!=0 ); /* Cannot have C without B */ + assert( pParse!=0 ); + assert( pParse->db!=0 ); + db = pParse->db; + if( pList==0 ){ + pList = sqlite3DbMallocRawNN(pParse->db, sizeof(SrcList) ); + if( pList==0 ) return 0; + pList->nAlloc = 1; + pList->nSrc = 1; + memset(&pList->a[0], 0, sizeof(pList->a[0])); + pList->a[0].iCursor = -1; + }else{ + SrcList *pNew = sqlite3SrcListEnlarge(pParse, pList, 1, pList->nSrc); + if( pNew==0 ){ + sqlite3SrcListDelete(db, pList); + return 0; + }else{ + pList = pNew; + } + } + pItem = &pList->a[pList->nSrc-1]; + if( pDatabase && pDatabase->z==0 ){ + pDatabase = 0; + } + if( pDatabase ){ + pItem->zName = sqlite3NameFromToken(db, pDatabase); + pItem->zDatabase = sqlite3NameFromToken(db, pTable); + }else{ + pItem->zName = sqlite3NameFromToken(db, pTable); + pItem->zDatabase = 0; + } + return pList; +} + +/* +** Assign VdbeCursor index numbers to all tables in a SrcList +*/ +SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){ + int i; + SrcItem *pItem; + assert( pList || pParse->db->mallocFailed ); + if( ALWAYS(pList) ){ + for(i=0, pItem=pList->a; inSrc; i++, pItem++){ + if( pItem->iCursor>=0 ) continue; + pItem->iCursor = pParse->nTab++; + if( pItem->pSelect ){ + sqlite3SrcListAssignCursors(pParse, pItem->pSelect->pSrc); + } + } + } +} + +/* +** Delete an entire SrcList including all its substructure. +*/ +SQLITE_PRIVATE void sqlite3SrcListDelete(sqlite3 *db, SrcList *pList){ + int i; + SrcItem *pItem; + assert( db!=0 ); + if( pList==0 ) return; + for(pItem=pList->a, i=0; inSrc; i++, pItem++){ + if( pItem->zDatabase ) sqlite3DbNNFreeNN(db, pItem->zDatabase); + if( pItem->zName ) sqlite3DbNNFreeNN(db, pItem->zName); + if( pItem->zAlias ) sqlite3DbNNFreeNN(db, pItem->zAlias); + if( pItem->fg.isIndexedBy ) sqlite3DbFree(db, pItem->u1.zIndexedBy); + if( pItem->fg.isTabFunc ) sqlite3ExprListDelete(db, pItem->u1.pFuncArg); + sqlite3DeleteTable(db, pItem->pTab); + if( pItem->pSelect ) sqlite3SelectDelete(db, pItem->pSelect); + if( pItem->fg.isUsing ){ + sqlite3IdListDelete(db, pItem->u3.pUsing); + }else if( pItem->u3.pOn ){ + sqlite3ExprDelete(db, pItem->u3.pOn); + } + } + sqlite3DbNNFreeNN(db, pList); +} + +/* +** This routine is called by the parser to add a new term to the +** end of a growing FROM clause. The "p" parameter is the part of +** the FROM clause that has already been constructed. "p" is NULL +** if this is the first term of the FROM clause. pTable and pDatabase +** are the name of the table and database named in the FROM clause term. +** pDatabase is NULL if the database name qualifier is missing - the +** usual case. If the term has an alias, then pAlias points to the +** alias token. If the term is a subquery, then pSubquery is the +** SELECT statement that the subquery encodes. The pTable and +** pDatabase parameters are NULL for subqueries. The pOn and pUsing +** parameters are the content of the ON and USING clauses. +** +** Return a new SrcList which encodes is the FROM with the new +** term added. +*/ +SQLITE_PRIVATE SrcList *sqlite3SrcListAppendFromTerm( + Parse *pParse, /* Parsing context */ + SrcList *p, /* The left part of the FROM clause already seen */ + Token *pTable, /* Name of the table to add to the FROM clause */ + Token *pDatabase, /* Name of the database containing pTable */ + Token *pAlias, /* The right-hand side of the AS subexpression */ + Select *pSubquery, /* A subquery used in place of a table name */ + OnOrUsing *pOnUsing /* Either the ON clause or the USING clause */ +){ + SrcItem *pItem; + sqlite3 *db = pParse->db; + if( !p && pOnUsing!=0 && (pOnUsing->pOn || pOnUsing->pUsing) ){ + sqlite3ErrorMsg(pParse, "a JOIN clause is required before %s", + (pOnUsing->pOn ? "ON" : "USING") + ); + goto append_from_error; + } + p = sqlite3SrcListAppend(pParse, p, pTable, pDatabase); + if( p==0 ){ + goto append_from_error; + } + assert( p->nSrc>0 ); + pItem = &p->a[p->nSrc-1]; + assert( (pTable==0)==(pDatabase==0) ); + assert( pItem->zName==0 || pDatabase!=0 ); + if( IN_RENAME_OBJECT && pItem->zName ){ + Token *pToken = (ALWAYS(pDatabase) && pDatabase->z) ? pDatabase : pTable; + sqlite3RenameTokenMap(pParse, pItem->zName, pToken); + } + assert( pAlias!=0 ); + if( pAlias->n ){ + pItem->zAlias = sqlite3NameFromToken(db, pAlias); + } + if( pSubquery ){ + pItem->pSelect = pSubquery; + if( pSubquery->selFlags & SF_NestedFrom ){ + pItem->fg.isNestedFrom = 1; + } + } + assert( pOnUsing==0 || pOnUsing->pOn==0 || pOnUsing->pUsing==0 ); + assert( pItem->fg.isUsing==0 ); + if( pOnUsing==0 ){ + pItem->u3.pOn = 0; + }else if( pOnUsing->pUsing ){ + pItem->fg.isUsing = 1; + pItem->u3.pUsing = pOnUsing->pUsing; + }else{ + pItem->u3.pOn = pOnUsing->pOn; + } + return p; + +append_from_error: + assert( p==0 ); + sqlite3ClearOnOrUsing(db, pOnUsing); + sqlite3SelectDelete(db, pSubquery); + return 0; +} + +/* +** Add an INDEXED BY or NOT INDEXED clause to the most recently added +** element of the source-list passed as the second argument. +*/ +SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){ + assert( pIndexedBy!=0 ); + if( p && pIndexedBy->n>0 ){ + SrcItem *pItem; + assert( p->nSrc>0 ); + pItem = &p->a[p->nSrc-1]; + assert( pItem->fg.notIndexed==0 ); + assert( pItem->fg.isIndexedBy==0 ); + assert( pItem->fg.isTabFunc==0 ); + if( pIndexedBy->n==1 && !pIndexedBy->z ){ + /* A "NOT INDEXED" clause was supplied. See parse.y + ** construct "indexed_opt" for details. */ + pItem->fg.notIndexed = 1; + }else{ + pItem->u1.zIndexedBy = sqlite3NameFromToken(pParse->db, pIndexedBy); + pItem->fg.isIndexedBy = 1; + assert( pItem->fg.isCte==0 ); /* No collision on union u2 */ + } + } +} + +/* +** Append the contents of SrcList p2 to SrcList p1 and return the resulting +** SrcList. Or, if an error occurs, return NULL. In all cases, p1 and p2 +** are deleted by this function. +*/ +SQLITE_PRIVATE SrcList *sqlite3SrcListAppendList(Parse *pParse, SrcList *p1, SrcList *p2){ + assert( p1 && p1->nSrc==1 ); + if( p2 ){ + SrcList *pNew = sqlite3SrcListEnlarge(pParse, p1, p2->nSrc, 1); + if( pNew==0 ){ + sqlite3SrcListDelete(pParse->db, p2); + }else{ + p1 = pNew; + memcpy(&p1->a[1], p2->a, p2->nSrc*sizeof(SrcItem)); + sqlite3DbFree(pParse->db, p2); + p1->a[0].fg.jointype |= (JT_LTORJ & p1->a[1].fg.jointype); + } + } + return p1; +} + +/* +** Add the list of function arguments to the SrcList entry for a +** table-valued-function. +*/ +SQLITE_PRIVATE void sqlite3SrcListFuncArgs(Parse *pParse, SrcList *p, ExprList *pList){ + if( p ){ + SrcItem *pItem = &p->a[p->nSrc-1]; + assert( pItem->fg.notIndexed==0 ); + assert( pItem->fg.isIndexedBy==0 ); + assert( pItem->fg.isTabFunc==0 ); + pItem->u1.pFuncArg = pList; + pItem->fg.isTabFunc = 1; + }else{ + sqlite3ExprListDelete(pParse->db, pList); + } +} + +/* +** When building up a FROM clause in the parser, the join operator +** is initially attached to the left operand. But the code generator +** expects the join operator to be on the right operand. This routine +** Shifts all join operators from left to right for an entire FROM +** clause. +** +** Example: Suppose the join is like this: +** +** A natural cross join B +** +** The operator is "natural cross join". The A and B operands are stored +** in p->a[0] and p->a[1], respectively. The parser initially stores the +** operator with A. This routine shifts that operator over to B. +** +** Additional changes: +** +** * All tables to the left of the right-most RIGHT JOIN are tagged with +** JT_LTORJ (mnemonic: Left Table Of Right Join) so that the +** code generator can easily tell that the table is part of +** the left operand of at least one RIGHT JOIN. +*/ +SQLITE_PRIVATE void sqlite3SrcListShiftJoinType(Parse *pParse, SrcList *p){ + (void)pParse; + if( p && p->nSrc>1 ){ + int i = p->nSrc-1; + u8 allFlags = 0; + do{ + allFlags |= p->a[i].fg.jointype = p->a[i-1].fg.jointype; + }while( (--i)>0 ); + p->a[0].fg.jointype = 0; + + /* All terms to the left of a RIGHT JOIN should be tagged with the + ** JT_LTORJ flags */ + if( allFlags & JT_RIGHT ){ + for(i=p->nSrc-1; ALWAYS(i>0) && (p->a[i].fg.jointype&JT_RIGHT)==0; i--){} + i--; + assert( i>=0 ); + do{ + p->a[i].fg.jointype |= JT_LTORJ; + }while( (--i)>=0 ); + } + } +} + +/* +** Generate VDBE code for a BEGIN statement. +*/ +SQLITE_PRIVATE void sqlite3BeginTransaction(Parse *pParse, int type){ + sqlite3 *db; + Vdbe *v; + int i; + + assert( pParse!=0 ); + db = pParse->db; + assert( db!=0 ); + if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ){ + return; + } + v = sqlite3GetVdbe(pParse); + if( !v ) return; + if( type!=TK_DEFERRED ){ + for(i=0; inDb; i++){ + int eTxnType; + Btree *pBt = db->aDb[i].pBt; + if( pBt && sqlite3BtreeIsReadonly(pBt) ){ + eTxnType = 0; /* Read txn */ + }else if( type==TK_EXCLUSIVE ){ + eTxnType = 2; /* Exclusive txn */ + }else{ + eTxnType = 1; /* Write txn */ + } + sqlite3VdbeAddOp2(v, OP_Transaction, i, eTxnType); + sqlite3VdbeUsesBtree(v, i); + } + } + sqlite3VdbeAddOp0(v, OP_AutoCommit); +} + +/* +** Generate VDBE code for a COMMIT or ROLLBACK statement. +** Code for ROLLBACK is generated if eType==TK_ROLLBACK. Otherwise +** code is generated for a COMMIT. +*/ +SQLITE_PRIVATE void sqlite3EndTransaction(Parse *pParse, int eType){ + Vdbe *v; + int isRollback; + + assert( pParse!=0 ); + assert( pParse->db!=0 ); + assert( eType==TK_COMMIT || eType==TK_END || eType==TK_ROLLBACK ); + isRollback = eType==TK_ROLLBACK; + if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, + isRollback ? "ROLLBACK" : "COMMIT", 0, 0) ){ + return; + } + v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, isRollback); + } +} + +/* +** This function is called by the parser when it parses a command to create, +** release or rollback an SQL savepoint. +*/ +SQLITE_PRIVATE void sqlite3Savepoint(Parse *pParse, int op, Token *pName){ + char *zName = sqlite3NameFromToken(pParse->db, pName); + if( zName ){ + Vdbe *v = sqlite3GetVdbe(pParse); +#ifndef SQLITE_OMIT_AUTHORIZATION + static const char * const az[] = { "BEGIN", "RELEASE", "ROLLBACK" }; + assert( !SAVEPOINT_BEGIN && SAVEPOINT_RELEASE==1 && SAVEPOINT_ROLLBACK==2 ); +#endif + if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){ + sqlite3DbFree(pParse->db, zName); + return; + } + sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC); + } +} + +/* +** Make sure the TEMP database is open and available for use. Return +** the number of errors. Leave any error messages in the pParse structure. +*/ +SQLITE_PRIVATE int sqlite3OpenTempDatabase(Parse *pParse){ + sqlite3 *db = pParse->db; + if( db->aDb[1].pBt==0 && !pParse->explain ){ + int rc; + Btree *pBt; + static const int flags = + SQLITE_OPEN_READWRITE | + SQLITE_OPEN_CREATE | + SQLITE_OPEN_EXCLUSIVE | + SQLITE_OPEN_DELETEONCLOSE | + SQLITE_OPEN_TEMP_DB; + + rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pBt, 0, flags); + if( rc!=SQLITE_OK ){ + sqlite3ErrorMsg(pParse, "unable to open a temporary database " + "file for storing temporary tables"); + pParse->rc = rc; + return 1; + } + db->aDb[1].pBt = pBt; + assert( db->aDb[1].pSchema ); + if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, 0, 0) ){ + sqlite3OomFault(db); + return 1; + } + } + return 0; +} + +/* +** Record the fact that the schema cookie will need to be verified +** for database iDb. The code to actually verify the schema cookie +** will occur at the end of the top-level VDBE and will be generated +** later, by sqlite3FinishCoding(). +*/ +static void sqlite3CodeVerifySchemaAtToplevel(Parse *pToplevel, int iDb){ + assert( iDb>=0 && iDbdb->nDb ); + assert( pToplevel->db->aDb[iDb].pBt!=0 || iDb==1 ); + assert( iDbdb, iDb, 0) ); + if( DbMaskTest(pToplevel->cookieMask, iDb)==0 ){ + DbMaskSet(pToplevel->cookieMask, iDb); + if( !OMIT_TEMPDB && iDb==1 ){ + sqlite3OpenTempDatabase(pToplevel); + } + } +} +SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse *pParse, int iDb){ + sqlite3CodeVerifySchemaAtToplevel(sqlite3ParseToplevel(pParse), iDb); +} + + +/* +** If argument zDb is NULL, then call sqlite3CodeVerifySchema() for each +** attached database. Otherwise, invoke it for the database named zDb only. +*/ +SQLITE_PRIVATE void sqlite3CodeVerifyNamedSchema(Parse *pParse, const char *zDb){ + sqlite3 *db = pParse->db; + int i; + for(i=0; inDb; i++){ + Db *pDb = &db->aDb[i]; + if( pDb->pBt && (!zDb || 0==sqlite3StrICmp(zDb, pDb->zDbSName)) ){ + sqlite3CodeVerifySchema(pParse, i); + } + } +} + +/* +** Generate VDBE code that prepares for doing an operation that +** might change the database. +** +** This routine starts a new transaction if we are not already within +** a transaction. If we are already within a transaction, then a checkpoint +** is set if the setStatement parameter is true. A checkpoint should +** be set for operations that might fail (due to a constraint) part of +** the way through and which will need to undo some writes without having to +** rollback the whole transaction. For operations where all constraints +** can be checked before any changes are made to the database, it is never +** necessary to undo a write and the checkpoint should not be set. +*/ +SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){ + Parse *pToplevel = sqlite3ParseToplevel(pParse); + sqlite3CodeVerifySchemaAtToplevel(pToplevel, iDb); + DbMaskSet(pToplevel->writeMask, iDb); + pToplevel->isMultiWrite |= setStatement; +} + +/* +** Indicate that the statement currently under construction might write +** more than one entry (example: deleting one row then inserting another, +** inserting multiple rows in a table, or inserting a row and index entries.) +** If an abort occurs after some of these writes have completed, then it will +** be necessary to undo the completed writes. +*/ +SQLITE_PRIVATE void sqlite3MultiWrite(Parse *pParse){ + Parse *pToplevel = sqlite3ParseToplevel(pParse); + pToplevel->isMultiWrite = 1; +} + +/* +** The code generator calls this routine if is discovers that it is +** possible to abort a statement prior to completion. In order to +** perform this abort without corrupting the database, we need to make +** sure that the statement is protected by a statement transaction. +** +** Technically, we only need to set the mayAbort flag if the +** isMultiWrite flag was previously set. There is a time dependency +** such that the abort must occur after the multiwrite. This makes +** some statements involving the REPLACE conflict resolution algorithm +** go a little faster. But taking advantage of this time dependency +** makes it more difficult to prove that the code is correct (in +** particular, it prevents us from writing an effective +** implementation of sqlite3AssertMayAbort()) and so we have chosen +** to take the safe route and skip the optimization. +*/ +SQLITE_PRIVATE void sqlite3MayAbort(Parse *pParse){ + Parse *pToplevel = sqlite3ParseToplevel(pParse); + pToplevel->mayAbort = 1; +} + +/* +** Code an OP_Halt that causes the vdbe to return an SQLITE_CONSTRAINT +** error. The onError parameter determines which (if any) of the statement +** and/or current transaction is rolled back. +*/ +SQLITE_PRIVATE void sqlite3HaltConstraint( + Parse *pParse, /* Parsing context */ + int errCode, /* extended error code */ + int onError, /* Constraint type */ + char *p4, /* Error message */ + i8 p4type, /* P4_STATIC or P4_TRANSIENT */ + u8 p5Errmsg /* P5_ErrMsg type */ +){ + Vdbe *v; + assert( pParse->pVdbe!=0 ); + v = sqlite3GetVdbe(pParse); + assert( (errCode&0xff)==SQLITE_CONSTRAINT || pParse->nested ); + if( onError==OE_Abort ){ + sqlite3MayAbort(pParse); + } + sqlite3VdbeAddOp4(v, OP_Halt, errCode, onError, 0, p4, p4type); + sqlite3VdbeChangeP5(v, p5Errmsg); +} + +/* +** Code an OP_Halt due to UNIQUE or PRIMARY KEY constraint violation. +*/ +SQLITE_PRIVATE void sqlite3UniqueConstraint( + Parse *pParse, /* Parsing context */ + int onError, /* Constraint type */ + Index *pIdx /* The index that triggers the constraint */ +){ + char *zErr; + int j; + StrAccum errMsg; + Table *pTab = pIdx->pTable; + + sqlite3StrAccumInit(&errMsg, pParse->db, 0, 0, + pParse->db->aLimit[SQLITE_LIMIT_LENGTH]); + if( pIdx->aColExpr ){ + sqlite3_str_appendf(&errMsg, "index '%q'", pIdx->zName); + }else{ + for(j=0; jnKeyCol; j++){ + char *zCol; + assert( pIdx->aiColumn[j]>=0 ); + zCol = pTab->aCol[pIdx->aiColumn[j]].zCnName; + if( j ) sqlite3_str_append(&errMsg, ", ", 2); + sqlite3_str_appendall(&errMsg, pTab->zName); + sqlite3_str_append(&errMsg, ".", 1); + sqlite3_str_appendall(&errMsg, zCol); + } + } + zErr = sqlite3StrAccumFinish(&errMsg); + sqlite3HaltConstraint(pParse, + IsPrimaryKeyIndex(pIdx) ? SQLITE_CONSTRAINT_PRIMARYKEY + : SQLITE_CONSTRAINT_UNIQUE, + onError, zErr, P4_DYNAMIC, P5_ConstraintUnique); +} + + +/* +** Code an OP_Halt due to non-unique rowid. +*/ +SQLITE_PRIVATE void sqlite3RowidConstraint( + Parse *pParse, /* Parsing context */ + int onError, /* Conflict resolution algorithm */ + Table *pTab /* The table with the non-unique rowid */ +){ + char *zMsg; + int rc; + if( pTab->iPKey>=0 ){ + zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName, + pTab->aCol[pTab->iPKey].zCnName); + rc = SQLITE_CONSTRAINT_PRIMARYKEY; + }else{ + zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName); + rc = SQLITE_CONSTRAINT_ROWID; + } + sqlite3HaltConstraint(pParse, rc, onError, zMsg, P4_DYNAMIC, + P5_ConstraintUnique); +} + +/* +** Check to see if pIndex uses the collating sequence pColl. Return +** true if it does and false if it does not. +*/ +#ifndef SQLITE_OMIT_REINDEX +static int collationMatch(const char *zColl, Index *pIndex){ + int i; + assert( zColl!=0 ); + for(i=0; inColumn; i++){ + const char *z = pIndex->azColl[i]; + assert( z!=0 || pIndex->aiColumn[i]<0 ); + if( pIndex->aiColumn[i]>=0 && 0==sqlite3StrICmp(z, zColl) ){ + return 1; + } + } + return 0; +} +#endif + +/* +** Recompute all indices of pTab that use the collating sequence pColl. +** If pColl==0 then recompute all indices of pTab. +*/ +#ifndef SQLITE_OMIT_REINDEX +static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){ + if( !IsVirtual(pTab) ){ + Index *pIndex; /* An index associated with pTab */ + + for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){ + if( zColl==0 || collationMatch(zColl, pIndex) ){ + int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + sqlite3BeginWriteOperation(pParse, 0, iDb); + sqlite3RefillIndex(pParse, pIndex, -1); + } + } + } +} +#endif + +/* +** Recompute all indices of all tables in all databases where the +** indices use the collating sequence pColl. If pColl==0 then recompute +** all indices everywhere. +*/ +#ifndef SQLITE_OMIT_REINDEX +static void reindexDatabases(Parse *pParse, char const *zColl){ + Db *pDb; /* A single database */ + int iDb; /* The database index number */ + sqlite3 *db = pParse->db; /* The database connection */ + HashElem *k; /* For looping over tables in pDb */ + Table *pTab; /* A table in the database */ + + assert( sqlite3BtreeHoldsAllMutexes(db) ); /* Needed for schema access */ + for(iDb=0, pDb=db->aDb; iDbnDb; iDb++, pDb++){ + assert( pDb!=0 ); + for(k=sqliteHashFirst(&pDb->pSchema->tblHash); k; k=sqliteHashNext(k)){ + pTab = (Table*)sqliteHashData(k); + reindexTable(pParse, pTab, zColl); + } + } +} +#endif + +/* +** Generate code for the REINDEX command. +** +** REINDEX -- 1 +** REINDEX -- 2 +** REINDEX ?.? -- 3 +** REINDEX ?.? -- 4 +** +** Form 1 causes all indices in all attached databases to be rebuilt. +** Form 2 rebuilds all indices in all databases that use the named +** collating function. Forms 3 and 4 rebuild the named index or all +** indices associated with the named table. +*/ +#ifndef SQLITE_OMIT_REINDEX +SQLITE_PRIVATE void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2){ + CollSeq *pColl; /* Collating sequence to be reindexed, or NULL */ + char *z; /* Name of a table or index */ + const char *zDb; /* Name of the database */ + Table *pTab; /* A table in the database */ + Index *pIndex; /* An index associated with pTab */ + int iDb; /* The database index number */ + sqlite3 *db = pParse->db; /* The database connection */ + Token *pObjName; /* Name of the table or index to be reindexed */ + + /* Read the database schema. If an error occurs, leave an error message + ** and code in pParse and return NULL. */ + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + return; + } + + if( pName1==0 ){ + reindexDatabases(pParse, 0); + return; + }else if( NEVER(pName2==0) || pName2->z==0 ){ + char *zColl; + assert( pName1->z ); + zColl = sqlite3NameFromToken(pParse->db, pName1); + if( !zColl ) return; + pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0); + if( pColl ){ + reindexDatabases(pParse, zColl); + sqlite3DbFree(db, zColl); + return; + } + sqlite3DbFree(db, zColl); + } + iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName); + if( iDb<0 ) return; + z = sqlite3NameFromToken(db, pObjName); + if( z==0 ) return; + zDb = db->aDb[iDb].zDbSName; + pTab = sqlite3FindTable(db, z, zDb); + if( pTab ){ + reindexTable(pParse, pTab, 0); + sqlite3DbFree(db, z); + return; + } + pIndex = sqlite3FindIndex(db, z, zDb); + sqlite3DbFree(db, z); + if( pIndex ){ + sqlite3BeginWriteOperation(pParse, 0, iDb); + sqlite3RefillIndex(pParse, pIndex, -1); + return; + } + sqlite3ErrorMsg(pParse, "unable to identify the object to be reindexed"); +} +#endif + +/* +** Return a KeyInfo structure that is appropriate for the given Index. +** +** The caller should invoke sqlite3KeyInfoUnref() on the returned object +** when it has finished using it. +*/ +SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoOfIndex(Parse *pParse, Index *pIdx){ + int i; + int nCol = pIdx->nColumn; + int nKey = pIdx->nKeyCol; + KeyInfo *pKey; + if( pParse->nErr ) return 0; + if( pIdx->uniqNotNull ){ + pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey); + }else{ + pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0); + } + if( pKey ){ + assert( sqlite3KeyInfoIsWriteable(pKey) ); + for(i=0; iazColl[i]; + pKey->aColl[i] = zColl==sqlite3StrBINARY ? 0 : + sqlite3LocateCollSeq(pParse, zColl); + pKey->aSortFlags[i] = pIdx->aSortOrder[i]; + assert( 0==(pKey->aSortFlags[i] & KEYINFO_ORDER_BIGNULL) ); + } + if( pParse->nErr ){ + assert( pParse->rc==SQLITE_ERROR_MISSING_COLLSEQ ); + if( pIdx->bNoQuery==0 ){ + /* Deactivate the index because it contains an unknown collating + ** sequence. The only way to reactive the index is to reload the + ** schema. Adding the missing collating sequence later does not + ** reactive the index. The application had the chance to register + ** the missing index using the collation-needed callback. For + ** simplicity, SQLite will not give the application a second chance. + */ + pIdx->bNoQuery = 1; + pParse->rc = SQLITE_ERROR_RETRY; + } + sqlite3KeyInfoUnref(pKey); + pKey = 0; + } + } + return pKey; +} + +#ifndef SQLITE_OMIT_CTE +/* +** Create a new CTE object +*/ +SQLITE_PRIVATE Cte *sqlite3CteNew( + Parse *pParse, /* Parsing context */ + Token *pName, /* Name of the common-table */ + ExprList *pArglist, /* Optional column name list for the table */ + Select *pQuery, /* Query used to initialize the table */ + u8 eM10d /* The MATERIALIZED flag */ +){ + Cte *pNew; + sqlite3 *db = pParse->db; + + pNew = sqlite3DbMallocZero(db, sizeof(*pNew)); + assert( pNew!=0 || db->mallocFailed ); + + if( db->mallocFailed ){ + sqlite3ExprListDelete(db, pArglist); + sqlite3SelectDelete(db, pQuery); + }else{ + pNew->pSelect = pQuery; + pNew->pCols = pArglist; + pNew->zName = sqlite3NameFromToken(pParse->db, pName); + pNew->eM10d = eM10d; + } + return pNew; +} + +/* +** Clear information from a Cte object, but do not deallocate storage +** for the object itself. +*/ +static void cteClear(sqlite3 *db, Cte *pCte){ + assert( pCte!=0 ); + sqlite3ExprListDelete(db, pCte->pCols); + sqlite3SelectDelete(db, pCte->pSelect); + sqlite3DbFree(db, pCte->zName); +} + +/* +** Free the contents of the CTE object passed as the second argument. +*/ +SQLITE_PRIVATE void sqlite3CteDelete(sqlite3 *db, Cte *pCte){ + assert( pCte!=0 ); + cteClear(db, pCte); + sqlite3DbFree(db, pCte); +} + +/* +** This routine is invoked once per CTE by the parser while parsing a +** WITH clause. The CTE described by teh third argument is added to +** the WITH clause of the second argument. If the second argument is +** NULL, then a new WITH argument is created. +*/ +SQLITE_PRIVATE With *sqlite3WithAdd( + Parse *pParse, /* Parsing context */ + With *pWith, /* Existing WITH clause, or NULL */ + Cte *pCte /* CTE to add to the WITH clause */ +){ + sqlite3 *db = pParse->db; + With *pNew; + char *zName; + + if( pCte==0 ){ + return pWith; + } + + /* Check that the CTE name is unique within this WITH clause. If + ** not, store an error in the Parse structure. */ + zName = pCte->zName; + if( zName && pWith ){ + int i; + for(i=0; inCte; i++){ + if( sqlite3StrICmp(zName, pWith->a[i].zName)==0 ){ + sqlite3ErrorMsg(pParse, "duplicate WITH table name: %s", zName); + } + } + } + + if( pWith ){ + sqlite3_int64 nByte = sizeof(*pWith) + (sizeof(pWith->a[1]) * pWith->nCte); + pNew = sqlite3DbRealloc(db, pWith, nByte); + }else{ + pNew = sqlite3DbMallocZero(db, sizeof(*pWith)); + } + assert( (pNew!=0 && zName!=0) || db->mallocFailed ); + + if( db->mallocFailed ){ + sqlite3CteDelete(db, pCte); + pNew = pWith; + }else{ + pNew->a[pNew->nCte++] = *pCte; + sqlite3DbFree(db, pCte); + } + + return pNew; +} + +/* +** Free the contents of the With object passed as the second argument. +*/ +SQLITE_PRIVATE void sqlite3WithDelete(sqlite3 *db, With *pWith){ + if( pWith ){ + int i; + for(i=0; inCte; i++){ + cteClear(db, &pWith->a[i]); + } + sqlite3DbFree(db, pWith); + } +} +#endif /* !defined(SQLITE_OMIT_CTE) */ + +/************** End of build.c ***********************************************/ +/************** Begin file callback.c ****************************************/ +/* +** 2005 May 23 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains functions used to access the internal hash tables +** of user defined functions and collation sequences. +*/ + +/* #include "sqliteInt.h" */ + +/* +** Invoke the 'collation needed' callback to request a collation sequence +** in the encoding enc of name zName, length nName. +*/ +static void callCollNeeded(sqlite3 *db, int enc, const char *zName){ + assert( !db->xCollNeeded || !db->xCollNeeded16 ); + if( db->xCollNeeded ){ + char *zExternal = sqlite3DbStrDup(db, zName); + if( !zExternal ) return; + db->xCollNeeded(db->pCollNeededArg, db, enc, zExternal); + sqlite3DbFree(db, zExternal); + } +#ifndef SQLITE_OMIT_UTF16 + if( db->xCollNeeded16 ){ + char const *zExternal; + sqlite3_value *pTmp = sqlite3ValueNew(db); + sqlite3ValueSetStr(pTmp, -1, zName, SQLITE_UTF8, SQLITE_STATIC); + zExternal = sqlite3ValueText(pTmp, SQLITE_UTF16NATIVE); + if( zExternal ){ + db->xCollNeeded16(db->pCollNeededArg, db, (int)ENC(db), zExternal); + } + sqlite3ValueFree(pTmp); + } +#endif +} + +/* +** This routine is called if the collation factory fails to deliver a +** collation function in the best encoding but there may be other versions +** of this collation function (for other text encodings) available. Use one +** of these instead if they exist. Avoid a UTF-8 <-> UTF-16 conversion if +** possible. +*/ +static int synthCollSeq(sqlite3 *db, CollSeq *pColl){ + CollSeq *pColl2; + char *z = pColl->zName; + int i; + static const u8 aEnc[] = { SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF8 }; + for(i=0; i<3; i++){ + pColl2 = sqlite3FindCollSeq(db, aEnc[i], z, 0); + if( pColl2->xCmp!=0 ){ + memcpy(pColl, pColl2, sizeof(CollSeq)); + pColl->xDel = 0; /* Do not copy the destructor */ + return SQLITE_OK; + } + } + return SQLITE_ERROR; +} + +/* +** This routine is called on a collation sequence before it is used to +** check that it is defined. An undefined collation sequence exists when +** a database is loaded that contains references to collation sequences +** that have not been defined by sqlite3_create_collation() etc. +** +** If required, this routine calls the 'collation needed' callback to +** request a definition of the collating sequence. If this doesn't work, +** an equivalent collating sequence that uses a text encoding different +** from the main database is substituted, if one is available. +*/ +SQLITE_PRIVATE int sqlite3CheckCollSeq(Parse *pParse, CollSeq *pColl){ + if( pColl && pColl->xCmp==0 ){ + const char *zName = pColl->zName; + sqlite3 *db = pParse->db; + CollSeq *p = sqlite3GetCollSeq(pParse, ENC(db), pColl, zName); + if( !p ){ + return SQLITE_ERROR; + } + assert( p==pColl ); + } + return SQLITE_OK; +} + + + +/* +** Locate and return an entry from the db.aCollSeq hash table. If the entry +** specified by zName and nName is not found and parameter 'create' is +** true, then create a new entry. Otherwise return NULL. +** +** Each pointer stored in the sqlite3.aCollSeq hash table contains an +** array of three CollSeq structures. The first is the collation sequence +** preferred for UTF-8, the second UTF-16le, and the third UTF-16be. +** +** Stored immediately after the three collation sequences is a copy of +** the collation sequence name. A pointer to this string is stored in +** each collation sequence structure. +*/ +static CollSeq *findCollSeqEntry( + sqlite3 *db, /* Database connection */ + const char *zName, /* Name of the collating sequence */ + int create /* Create a new entry if true */ +){ + CollSeq *pColl; + pColl = sqlite3HashFind(&db->aCollSeq, zName); + + if( 0==pColl && create ){ + int nName = sqlite3Strlen30(zName) + 1; + pColl = sqlite3DbMallocZero(db, 3*sizeof(*pColl) + nName); + if( pColl ){ + CollSeq *pDel = 0; + pColl[0].zName = (char*)&pColl[3]; + pColl[0].enc = SQLITE_UTF8; + pColl[1].zName = (char*)&pColl[3]; + pColl[1].enc = SQLITE_UTF16LE; + pColl[2].zName = (char*)&pColl[3]; + pColl[2].enc = SQLITE_UTF16BE; + memcpy(pColl[0].zName, zName, nName); + pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, pColl); + + /* If a malloc() failure occurred in sqlite3HashInsert(), it will + ** return the pColl pointer to be deleted (because it wasn't added + ** to the hash table). + */ + assert( pDel==0 || pDel==pColl ); + if( pDel!=0 ){ + sqlite3OomFault(db); + sqlite3DbFree(db, pDel); + pColl = 0; + } + } + } + return pColl; +} + +/* +** Parameter zName points to a UTF-8 encoded string nName bytes long. +** Return the CollSeq* pointer for the collation sequence named zName +** for the encoding 'enc' from the database 'db'. +** +** If the entry specified is not found and 'create' is true, then create a +** new entry. Otherwise return NULL. +** +** A separate function sqlite3LocateCollSeq() is a wrapper around +** this routine. sqlite3LocateCollSeq() invokes the collation factory +** if necessary and generates an error message if the collating sequence +** cannot be found. +** +** See also: sqlite3LocateCollSeq(), sqlite3GetCollSeq() +*/ +SQLITE_PRIVATE CollSeq *sqlite3FindCollSeq( + sqlite3 *db, /* Database connection to search */ + u8 enc, /* Desired text encoding */ + const char *zName, /* Name of the collating sequence. Might be NULL */ + int create /* True to create CollSeq if doesn't already exist */ +){ + CollSeq *pColl; + assert( SQLITE_UTF8==1 && SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 ); + assert( enc>=SQLITE_UTF8 && enc<=SQLITE_UTF16BE ); + if( zName ){ + pColl = findCollSeqEntry(db, zName, create); + if( pColl ) pColl += enc-1; + }else{ + pColl = db->pDfltColl; + } + return pColl; +} + +/* +** Change the text encoding for a database connection. This means that +** the pDfltColl must change as well. +*/ +SQLITE_PRIVATE void sqlite3SetTextEncoding(sqlite3 *db, u8 enc){ + assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE ); + db->enc = enc; + /* EVIDENCE-OF: R-08308-17224 The default collating function for all + ** strings is BINARY. + */ + db->pDfltColl = sqlite3FindCollSeq(db, enc, sqlite3StrBINARY, 0); + sqlite3ExpirePreparedStatements(db, 1); +} + +/* +** This function is responsible for invoking the collation factory callback +** or substituting a collation sequence of a different encoding when the +** requested collation sequence is not available in the desired encoding. +** +** If it is not NULL, then pColl must point to the database native encoding +** collation sequence with name zName, length nName. +** +** The return value is either the collation sequence to be used in database +** db for collation type name zName, length nName, or NULL, if no collation +** sequence can be found. If no collation is found, leave an error message. +** +** See also: sqlite3LocateCollSeq(), sqlite3FindCollSeq() +*/ +SQLITE_PRIVATE CollSeq *sqlite3GetCollSeq( + Parse *pParse, /* Parsing context */ + u8 enc, /* The desired encoding for the collating sequence */ + CollSeq *pColl, /* Collating sequence with native encoding, or NULL */ + const char *zName /* Collating sequence name */ +){ + CollSeq *p; + sqlite3 *db = pParse->db; + + p = pColl; + if( !p ){ + p = sqlite3FindCollSeq(db, enc, zName, 0); + } + if( !p || !p->xCmp ){ + /* No collation sequence of this type for this encoding is registered. + ** Call the collation factory to see if it can supply us with one. + */ + callCollNeeded(db, enc, zName); + p = sqlite3FindCollSeq(db, enc, zName, 0); + } + if( p && !p->xCmp && synthCollSeq(db, p) ){ + p = 0; + } + assert( !p || p->xCmp ); + if( p==0 ){ + sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName); + pParse->rc = SQLITE_ERROR_MISSING_COLLSEQ; + } + return p; +} + +/* +** This function returns the collation sequence for database native text +** encoding identified by the string zName. +** +** If the requested collation sequence is not available, or not available +** in the database native encoding, the collation factory is invoked to +** request it. If the collation factory does not supply such a sequence, +** and the sequence is available in another text encoding, then that is +** returned instead. +** +** If no versions of the requested collations sequence are available, or +** another error occurs, NULL is returned and an error message written into +** pParse. +** +** This routine is a wrapper around sqlite3FindCollSeq(). This routine +** invokes the collation factory if the named collation cannot be found +** and generates an error message. +** +** See also: sqlite3FindCollSeq(), sqlite3GetCollSeq() +*/ +SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){ + sqlite3 *db = pParse->db; + u8 enc = ENC(db); + u8 initbusy = db->init.busy; + CollSeq *pColl; + + pColl = sqlite3FindCollSeq(db, enc, zName, initbusy); + if( !initbusy && (!pColl || !pColl->xCmp) ){ + pColl = sqlite3GetCollSeq(pParse, enc, pColl, zName); + } + + return pColl; +} + +/* During the search for the best function definition, this procedure +** is called to test how well the function passed as the first argument +** matches the request for a function with nArg arguments in a system +** that uses encoding enc. The value returned indicates how well the +** request is matched. A higher value indicates a better match. +** +** If nArg is -1 that means to only return a match (non-zero) if p->nArg +** is also -1. In other words, we are searching for a function that +** takes a variable number of arguments. +** +** If nArg is -2 that means that we are searching for any function +** regardless of the number of arguments it uses, so return a positive +** match score for any +** +** The returned value is always between 0 and 6, as follows: +** +** 0: Not a match. +** 1: UTF8/16 conversion required and function takes any number of arguments. +** 2: UTF16 byte order change required and function takes any number of args. +** 3: encoding matches and function takes any number of arguments +** 4: UTF8/16 conversion required - argument count matches exactly +** 5: UTF16 byte order conversion required - argument count matches exactly +** 6: Perfect match: encoding and argument count match exactly. +** +** If nArg==(-2) then any function with a non-null xSFunc is +** a perfect match and any function with xSFunc NULL is +** a non-match. +*/ +#define FUNC_PERFECT_MATCH 6 /* The score for a perfect match */ +static int matchQuality( + FuncDef *p, /* The function we are evaluating for match quality */ + int nArg, /* Desired number of arguments. (-1)==any */ + u8 enc /* Desired text encoding */ +){ + int match; + assert( p->nArg>=-1 ); + + /* Wrong number of arguments means "no match" */ + if( p->nArg!=nArg ){ + if( nArg==(-2) ) return (p->xSFunc==0) ? 0 : FUNC_PERFECT_MATCH; + if( p->nArg>=0 ) return 0; + } + + /* Give a better score to a function with a specific number of arguments + ** than to function that accepts any number of arguments. */ + if( p->nArg==nArg ){ + match = 4; + }else{ + match = 1; + } + + /* Bonus points if the text encoding matches */ + if( enc==(p->funcFlags & SQLITE_FUNC_ENCMASK) ){ + match += 2; /* Exact encoding match */ + }else if( (enc & p->funcFlags & 2)!=0 ){ + match += 1; /* Both are UTF16, but with different byte orders */ + } + + return match; +} + +/* +** Search a FuncDefHash for a function with the given name. Return +** a pointer to the matching FuncDef if found, or 0 if there is no match. +*/ +SQLITE_PRIVATE FuncDef *sqlite3FunctionSearch( + int h, /* Hash of the name */ + const char *zFunc /* Name of function */ +){ + FuncDef *p; + for(p=sqlite3BuiltinFunctions.a[h]; p; p=p->u.pHash){ + assert( p->funcFlags & SQLITE_FUNC_BUILTIN ); + if( sqlite3StrICmp(p->zName, zFunc)==0 ){ + return p; + } + } + return 0; +} + +/* +** Insert a new FuncDef into a FuncDefHash hash table. +*/ +SQLITE_PRIVATE void sqlite3InsertBuiltinFuncs( + FuncDef *aDef, /* List of global functions to be inserted */ + int nDef /* Length of the apDef[] list */ +){ + int i; + for(i=0; ipNext!=&aDef[i] ); + aDef[i].pNext = pOther->pNext; + pOther->pNext = &aDef[i]; + }else{ + aDef[i].pNext = 0; + aDef[i].u.pHash = sqlite3BuiltinFunctions.a[h]; + sqlite3BuiltinFunctions.a[h] = &aDef[i]; + } + } +} + + + +/* +** Locate a user function given a name, a number of arguments and a flag +** indicating whether the function prefers UTF-16 over UTF-8. Return a +** pointer to the FuncDef structure that defines that function, or return +** NULL if the function does not exist. +** +** If the createFlag argument is true, then a new (blank) FuncDef +** structure is created and liked into the "db" structure if a +** no matching function previously existed. +** +** If nArg is -2, then the first valid function found is returned. A +** function is valid if xSFunc is non-zero. The nArg==(-2) +** case is used to see if zName is a valid function name for some number +** of arguments. If nArg is -2, then createFlag must be 0. +** +** If createFlag is false, then a function with the required name and +** number of arguments may be returned even if the eTextRep flag does not +** match that requested. +*/ +SQLITE_PRIVATE FuncDef *sqlite3FindFunction( + sqlite3 *db, /* An open database */ + const char *zName, /* Name of the function. zero-terminated */ + int nArg, /* Number of arguments. -1 means any number */ + u8 enc, /* Preferred text encoding */ + u8 createFlag /* Create new entry if true and does not otherwise exist */ +){ + FuncDef *p; /* Iterator variable */ + FuncDef *pBest = 0; /* Best match found so far */ + int bestScore = 0; /* Score of best match */ + int h; /* Hash value */ + int nName; /* Length of the name */ + + assert( nArg>=(-2) ); + assert( nArg>=(-1) || createFlag==0 ); + nName = sqlite3Strlen30(zName); + + /* First search for a match amongst the application-defined functions. + */ + p = (FuncDef*)sqlite3HashFind(&db->aFunc, zName); + while( p ){ + int score = matchQuality(p, nArg, enc); + if( score>bestScore ){ + pBest = p; + bestScore = score; + } + p = p->pNext; + } + + /* If no match is found, search the built-in functions. + ** + ** If the DBFLAG_PreferBuiltin flag is set, then search the built-in + ** functions even if a prior app-defined function was found. And give + ** priority to built-in functions. + ** + ** Except, if createFlag is true, that means that we are trying to + ** install a new function. Whatever FuncDef structure is returned it will + ** have fields overwritten with new information appropriate for the + ** new function. But the FuncDefs for built-in functions are read-only. + ** So we must not search for built-ins when creating a new function. + */ + if( !createFlag && (pBest==0 || (db->mDbFlags & DBFLAG_PreferBuiltin)!=0) ){ + bestScore = 0; + h = SQLITE_FUNC_HASH(sqlite3UpperToLower[(u8)zName[0]], nName); + p = sqlite3FunctionSearch(h, zName); + while( p ){ + int score = matchQuality(p, nArg, enc); + if( score>bestScore ){ + pBest = p; + bestScore = score; + } + p = p->pNext; + } + } + + /* If the createFlag parameter is true and the search did not reveal an + ** exact match for the name, number of arguments and encoding, then add a + ** new entry to the hash table and return it. + */ + if( createFlag && bestScorezName = (const char*)&pBest[1]; + pBest->nArg = (u16)nArg; + pBest->funcFlags = enc; + memcpy((char*)&pBest[1], zName, nName+1); + for(z=(u8*)pBest->zName; *z; z++) *z = sqlite3UpperToLower[*z]; + pOther = (FuncDef*)sqlite3HashInsert(&db->aFunc, pBest->zName, pBest); + if( pOther==pBest ){ + sqlite3DbFree(db, pBest); + sqlite3OomFault(db); + return 0; + }else{ + pBest->pNext = pOther; + } + } + + if( pBest && (pBest->xSFunc || createFlag) ){ + return pBest; + } + return 0; +} + +/* +** Free all resources held by the schema structure. The void* argument points +** at a Schema struct. This function does not call sqlite3DbFree(db, ) on the +** pointer itself, it just cleans up subsidiary resources (i.e. the contents +** of the schema hash tables). +** +** The Schema.cache_size variable is not cleared. +*/ +SQLITE_PRIVATE void sqlite3SchemaClear(void *p){ + Hash temp1; + Hash temp2; + HashElem *pElem; + Schema *pSchema = (Schema *)p; + sqlite3 xdb; + + memset(&xdb, 0, sizeof(xdb)); + temp1 = pSchema->tblHash; + temp2 = pSchema->trigHash; + sqlite3HashInit(&pSchema->trigHash); + sqlite3HashClear(&pSchema->idxHash); + for(pElem=sqliteHashFirst(&temp2); pElem; pElem=sqliteHashNext(pElem)){ + sqlite3DeleteTrigger(&xdb, (Trigger*)sqliteHashData(pElem)); + } + sqlite3HashClear(&temp2); + sqlite3HashInit(&pSchema->tblHash); + for(pElem=sqliteHashFirst(&temp1); pElem; pElem=sqliteHashNext(pElem)){ + Table *pTab = sqliteHashData(pElem); + sqlite3DeleteTable(&xdb, pTab); + } + sqlite3HashClear(&temp1); + sqlite3HashClear(&pSchema->fkeyHash); + pSchema->pSeqTab = 0; + if( pSchema->schemaFlags & DB_SchemaLoaded ){ + pSchema->iGeneration++; + } + pSchema->schemaFlags &= ~(DB_SchemaLoaded|DB_ResetWanted); +} + +/* +** Find and return the schema associated with a BTree. Create +** a new one if necessary. +*/ +SQLITE_PRIVATE Schema *sqlite3SchemaGet(sqlite3 *db, Btree *pBt){ + Schema * p; + if( pBt ){ + p = (Schema *)sqlite3BtreeSchema(pBt, sizeof(Schema), sqlite3SchemaClear); + }else{ + p = (Schema *)sqlite3DbMallocZero(0, sizeof(Schema)); + } + if( !p ){ + sqlite3OomFault(db); + }else if ( 0==p->file_format ){ + sqlite3HashInit(&p->tblHash); + sqlite3HashInit(&p->idxHash); + sqlite3HashInit(&p->trigHash); + sqlite3HashInit(&p->fkeyHash); + p->enc = SQLITE_UTF8; + } + return p; +} + +/************** End of callback.c ********************************************/ +/************** Begin file delete.c ******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that are called by the parser +** in order to generate code for DELETE FROM statements. +*/ +/* #include "sqliteInt.h" */ + +/* +** While a SrcList can in general represent multiple tables and subqueries +** (as in the FROM clause of a SELECT statement) in this case it contains +** the name of a single table, as one might find in an INSERT, DELETE, +** or UPDATE statement. Look up that table in the symbol table and +** return a pointer. Set an error message and return NULL if the table +** name is not found or if any other error occurs. +** +** The following fields are initialized appropriate in pSrc: +** +** pSrc->a[0].pTab Pointer to the Table object +** pSrc->a[0].pIndex Pointer to the INDEXED BY index, if there is one +** +*/ +SQLITE_PRIVATE Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){ + SrcItem *pItem = pSrc->a; + Table *pTab; + assert( pItem && pSrc->nSrc>=1 ); + pTab = sqlite3LocateTableItem(pParse, 0, pItem); + sqlite3DeleteTable(pParse->db, pItem->pTab); + pItem->pTab = pTab; + if( pTab ){ + pTab->nTabRef++; + if( pItem->fg.isIndexedBy && sqlite3IndexedByLookup(pParse, pItem) ){ + pTab = 0; + } + } + return pTab; +} + +/* Generate byte-code that will report the number of rows modified +** by a DELETE, INSERT, or UPDATE statement. +*/ +SQLITE_PRIVATE void sqlite3CodeChangeCount(Vdbe *v, int regCounter, const char *zColName){ + sqlite3VdbeAddOp0(v, OP_FkCheck); + sqlite3VdbeAddOp2(v, OP_ResultRow, regCounter, 1); + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zColName, SQLITE_STATIC); +} + +/* Return true if table pTab is read-only. +** +** A table is read-only if any of the following are true: +** +** 1) It is a virtual table and no implementation of the xUpdate method +** has been provided +** +** 2) A trigger is currently being coded and the table is a virtual table +** that is SQLITE_VTAB_DIRECTONLY or if PRAGMA trusted_schema=OFF and +** the table is not SQLITE_VTAB_INNOCUOUS. +** +** 3) It is a system table (i.e. sqlite_schema), this call is not +** part of a nested parse and writable_schema pragma has not +** been specified +** +** 4) The table is a shadow table, the database connection is in +** defensive mode, and the current sqlite3_prepare() +** is for a top-level SQL statement. +*/ +static int vtabIsReadOnly(Parse *pParse, Table *pTab){ + if( sqlite3GetVTable(pParse->db, pTab)->pMod->pModule->xUpdate==0 ){ + return 1; + } + + /* Within triggers: + ** * Do not allow DELETE, INSERT, or UPDATE of SQLITE_VTAB_DIRECTONLY + ** virtual tables + ** * Only allow DELETE, INSERT, or UPDATE of non-SQLITE_VTAB_INNOCUOUS + ** virtual tables if PRAGMA trusted_schema=ON. + */ + if( pParse->pToplevel!=0 + && pTab->u.vtab.p->eVtabRisk > + ((pParse->db->flags & SQLITE_TrustedSchema)!=0) + ){ + sqlite3ErrorMsg(pParse, "unsafe use of virtual table \"%s\"", + pTab->zName); + } + return 0; +} +static int tabIsReadOnly(Parse *pParse, Table *pTab){ + sqlite3 *db; + if( IsVirtual(pTab) ){ + return vtabIsReadOnly(pParse, pTab); + } + if( (pTab->tabFlags & (TF_Readonly|TF_Shadow))==0 ) return 0; + db = pParse->db; + if( (pTab->tabFlags & TF_Readonly)!=0 ){ + return sqlite3WritableSchema(db)==0 && pParse->nested==0; + } + assert( pTab->tabFlags & TF_Shadow ); + return sqlite3ReadOnlyShadowTables(db); +} + +/* +** Check to make sure the given table is writable. +** +** If pTab is not writable -> generate an error message and return 1. +** If pTab is writable but other errors have occurred -> return 1. +** If pTab is writable and no prior errors -> return 0; +*/ +SQLITE_PRIVATE int sqlite3IsReadOnly(Parse *pParse, Table *pTab, Trigger *pTrigger){ + if( tabIsReadOnly(pParse, pTab) ){ + sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName); + return 1; + } +#ifndef SQLITE_OMIT_VIEW + if( IsView(pTab) + && (pTrigger==0 || (pTrigger->bReturning && pTrigger->pNext==0)) + ){ + sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName); + return 1; + } +#endif + return 0; +} + + +#if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) +/* +** Evaluate a view and store its result in an ephemeral table. The +** pWhere argument is an optional WHERE clause that restricts the +** set of rows in the view that are to be added to the ephemeral table. +*/ +SQLITE_PRIVATE void sqlite3MaterializeView( + Parse *pParse, /* Parsing context */ + Table *pView, /* View definition */ + Expr *pWhere, /* Optional WHERE clause to be added */ + ExprList *pOrderBy, /* Optional ORDER BY clause */ + Expr *pLimit, /* Optional LIMIT clause */ + int iCur /* Cursor number for ephemeral table */ +){ + SelectDest dest; + Select *pSel; + SrcList *pFrom; + sqlite3 *db = pParse->db; + int iDb = sqlite3SchemaToIndex(db, pView->pSchema); + pWhere = sqlite3ExprDup(db, pWhere, 0); + pFrom = sqlite3SrcListAppend(pParse, 0, 0, 0); + if( pFrom ){ + assert( pFrom->nSrc==1 ); + pFrom->a[0].zName = sqlite3DbStrDup(db, pView->zName); + pFrom->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zDbSName); + assert( pFrom->a[0].fg.isUsing==0 ); + assert( pFrom->a[0].u3.pOn==0 ); + } + pSel = sqlite3SelectNew(pParse, 0, pFrom, pWhere, 0, 0, pOrderBy, + SF_IncludeHidden, pLimit); + sqlite3SelectDestInit(&dest, SRT_EphemTab, iCur); + sqlite3Select(pParse, pSel, &dest); + sqlite3SelectDelete(db, pSel); +} +#endif /* !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) */ + +#if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) +/* +** Generate an expression tree to implement the WHERE, ORDER BY, +** and LIMIT/OFFSET portion of DELETE and UPDATE statements. +** +** DELETE FROM table_wxyz WHERE a<5 ORDER BY a LIMIT 1; +** \__________________________/ +** pLimitWhere (pInClause) +*/ +SQLITE_PRIVATE Expr *sqlite3LimitWhere( + Parse *pParse, /* The parser context */ + SrcList *pSrc, /* the FROM clause -- which tables to scan */ + Expr *pWhere, /* The WHERE clause. May be null */ + ExprList *pOrderBy, /* The ORDER BY clause. May be null */ + Expr *pLimit, /* The LIMIT clause. May be null */ + char *zStmtType /* Either DELETE or UPDATE. For err msgs. */ +){ + sqlite3 *db = pParse->db; + Expr *pLhs = NULL; /* LHS of IN(SELECT...) operator */ + Expr *pInClause = NULL; /* WHERE rowid IN ( select ) */ + ExprList *pEList = NULL; /* Expression list contaning only pSelectRowid */ + SrcList *pSelectSrc = NULL; /* SELECT rowid FROM x ... (dup of pSrc) */ + Select *pSelect = NULL; /* Complete SELECT tree */ + Table *pTab; + + /* Check that there isn't an ORDER BY without a LIMIT clause. + */ + if( pOrderBy && pLimit==0 ) { + sqlite3ErrorMsg(pParse, "ORDER BY without LIMIT on %s", zStmtType); + sqlite3ExprDelete(pParse->db, pWhere); + sqlite3ExprListDelete(pParse->db, pOrderBy); + return 0; + } + + /* We only need to generate a select expression if there + ** is a limit/offset term to enforce. + */ + if( pLimit == 0 ) { + return pWhere; + } + + /* Generate a select expression tree to enforce the limit/offset + ** term for the DELETE or UPDATE statement. For example: + ** DELETE FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1 + ** becomes: + ** DELETE FROM table_a WHERE rowid IN ( + ** SELECT rowid FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1 + ** ); + */ + + pTab = pSrc->a[0].pTab; + if( HasRowid(pTab) ){ + pLhs = sqlite3PExpr(pParse, TK_ROW, 0, 0); + pEList = sqlite3ExprListAppend( + pParse, 0, sqlite3PExpr(pParse, TK_ROW, 0, 0) + ); + }else{ + Index *pPk = sqlite3PrimaryKeyIndex(pTab); + if( pPk->nKeyCol==1 ){ + const char *zName = pTab->aCol[pPk->aiColumn[0]].zCnName; + pLhs = sqlite3Expr(db, TK_ID, zName); + pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ID, zName)); + }else{ + int i; + for(i=0; inKeyCol; i++){ + Expr *p = sqlite3Expr(db, TK_ID, pTab->aCol[pPk->aiColumn[i]].zCnName); + pEList = sqlite3ExprListAppend(pParse, pEList, p); + } + pLhs = sqlite3PExpr(pParse, TK_VECTOR, 0, 0); + if( pLhs ){ + pLhs->x.pList = sqlite3ExprListDup(db, pEList, 0); + } + } + } + + /* duplicate the FROM clause as it is needed by both the DELETE/UPDATE tree + ** and the SELECT subtree. */ + pSrc->a[0].pTab = 0; + pSelectSrc = sqlite3SrcListDup(db, pSrc, 0); + pSrc->a[0].pTab = pTab; + if( pSrc->a[0].fg.isIndexedBy ){ + assert( pSrc->a[0].fg.isCte==0 ); + pSrc->a[0].u2.pIBIndex = 0; + pSrc->a[0].fg.isIndexedBy = 0; + sqlite3DbFree(db, pSrc->a[0].u1.zIndexedBy); + }else if( pSrc->a[0].fg.isCte ){ + pSrc->a[0].u2.pCteUse->nUse++; + } + + /* generate the SELECT expression tree. */ + pSelect = sqlite3SelectNew(pParse, pEList, pSelectSrc, pWhere, 0 ,0, + pOrderBy,0,pLimit + ); + + /* now generate the new WHERE rowid IN clause for the DELETE/UDPATE */ + pInClause = sqlite3PExpr(pParse, TK_IN, pLhs, 0); + sqlite3PExprAddSelect(pParse, pInClause, pSelect); + return pInClause; +} +#endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) */ + /* && !defined(SQLITE_OMIT_SUBQUERY) */ + +/* +** Generate code for a DELETE FROM statement. +** +** DELETE FROM table_wxyz WHERE a<5 AND b NOT NULL; +** \________/ \________________/ +** pTabList pWhere +*/ +SQLITE_PRIVATE void sqlite3DeleteFrom( + Parse *pParse, /* The parser context */ + SrcList *pTabList, /* The table from which we should delete things */ + Expr *pWhere, /* The WHERE clause. May be null */ + ExprList *pOrderBy, /* ORDER BY clause. May be null */ + Expr *pLimit /* LIMIT clause. May be null */ +){ + Vdbe *v; /* The virtual database engine */ + Table *pTab; /* The table from which records will be deleted */ + int i; /* Loop counter */ + WhereInfo *pWInfo; /* Information about the WHERE clause */ + Index *pIdx; /* For looping over indices of the table */ + int iTabCur; /* Cursor number for the table */ + int iDataCur = 0; /* VDBE cursor for the canonical data source */ + int iIdxCur = 0; /* Cursor number of the first index */ + int nIdx; /* Number of indices */ + sqlite3 *db; /* Main database structure */ + AuthContext sContext; /* Authorization context */ + NameContext sNC; /* Name context to resolve expressions in */ + int iDb; /* Database number */ + int memCnt = 0; /* Memory cell used for change counting */ + int rcauth; /* Value returned by authorization callback */ + int eOnePass; /* ONEPASS_OFF or _SINGLE or _MULTI */ + int aiCurOnePass[2]; /* The write cursors opened by WHERE_ONEPASS */ + u8 *aToOpen = 0; /* Open cursor iTabCur+j if aToOpen[j] is true */ + Index *pPk; /* The PRIMARY KEY index on the table */ + int iPk = 0; /* First of nPk registers holding PRIMARY KEY value */ + i16 nPk = 1; /* Number of columns in the PRIMARY KEY */ + int iKey; /* Memory cell holding key of row to be deleted */ + i16 nKey; /* Number of memory cells in the row key */ + int iEphCur = 0; /* Ephemeral table holding all primary key values */ + int iRowSet = 0; /* Register for rowset of rows to delete */ + int addrBypass = 0; /* Address of jump over the delete logic */ + int addrLoop = 0; /* Top of the delete loop */ + int addrEphOpen = 0; /* Instruction to open the Ephemeral table */ + int bComplex; /* True if there are triggers or FKs or + ** subqueries in the WHERE clause */ + +#ifndef SQLITE_OMIT_TRIGGER + int isView; /* True if attempting to delete from a view */ + Trigger *pTrigger; /* List of table triggers, if required */ +#endif + + memset(&sContext, 0, sizeof(sContext)); + db = pParse->db; + assert( db->pParse==pParse ); + if( pParse->nErr ){ + goto delete_from_cleanup; + } + assert( db->mallocFailed==0 ); + assert( pTabList->nSrc==1 ); + + /* Locate the table which we want to delete. This table has to be + ** put in an SrcList structure because some of the subroutines we + ** will be calling are designed to work with multiple tables and expect + ** an SrcList* parameter instead of just a Table* parameter. + */ + pTab = sqlite3SrcListLookup(pParse, pTabList); + if( pTab==0 ) goto delete_from_cleanup; + + /* Figure out if we have any triggers and if the table being + ** deleted from is a view + */ +#ifndef SQLITE_OMIT_TRIGGER + pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0); + isView = IsView(pTab); +#else +# define pTrigger 0 +# define isView 0 +#endif + bComplex = pTrigger || sqlite3FkRequired(pParse, pTab, 0, 0); +#ifdef SQLITE_OMIT_VIEW +# undef isView +# define isView 0 +#endif + +#if TREETRACE_ENABLED + if( sqlite3TreeTrace & 0x10000 ){ + sqlite3TreeViewLine(0, "In sqlite3Delete() at %s:%d", __FILE__, __LINE__); + sqlite3TreeViewDelete(pParse->pWith, pTabList, pWhere, + pOrderBy, pLimit, pTrigger); + } +#endif + +#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT + if( !isView ){ + pWhere = sqlite3LimitWhere( + pParse, pTabList, pWhere, pOrderBy, pLimit, "DELETE" + ); + pOrderBy = 0; + pLimit = 0; + } +#endif + + /* If pTab is really a view, make sure it has been initialized. + */ + if( sqlite3ViewGetColumnNames(pParse, pTab) ){ + goto delete_from_cleanup; + } + + if( sqlite3IsReadOnly(pParse, pTab, pTrigger) ){ + goto delete_from_cleanup; + } + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( iDbnDb ); + rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, + db->aDb[iDb].zDbSName); + assert( rcauth==SQLITE_OK || rcauth==SQLITE_DENY || rcauth==SQLITE_IGNORE ); + if( rcauth==SQLITE_DENY ){ + goto delete_from_cleanup; + } + assert(!isView || pTrigger); + + /* Assign cursor numbers to the table and all its indices. + */ + assert( pTabList->nSrc==1 ); + iTabCur = pTabList->a[0].iCursor = pParse->nTab++; + for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){ + pParse->nTab++; + } + + /* Start the view context + */ + if( isView ){ + sqlite3AuthContextPush(pParse, &sContext, pTab->zName); + } + + /* Begin generating code. + */ + v = sqlite3GetVdbe(pParse); + if( v==0 ){ + goto delete_from_cleanup; + } + if( pParse->nested==0 ) sqlite3VdbeCountChanges(v); + sqlite3BeginWriteOperation(pParse, bComplex, iDb); + + /* If we are trying to delete from a view, realize that view into + ** an ephemeral table. + */ +#if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) + if( isView ){ + sqlite3MaterializeView(pParse, pTab, + pWhere, pOrderBy, pLimit, iTabCur + ); + iDataCur = iIdxCur = iTabCur; + pOrderBy = 0; + pLimit = 0; + } +#endif + + /* Resolve the column names in the WHERE clause. + */ + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + sNC.pSrcList = pTabList; + if( sqlite3ResolveExprNames(&sNC, pWhere) ){ + goto delete_from_cleanup; + } + + /* Initialize the counter of the number of rows deleted, if + ** we are counting rows. + */ + if( (db->flags & SQLITE_CountRows)!=0 + && !pParse->nested + && !pParse->pTriggerTab + && !pParse->bReturning + ){ + memCnt = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Integer, 0, memCnt); + } + +#ifndef SQLITE_OMIT_TRUNCATE_OPTIMIZATION + /* Special case: A DELETE without a WHERE clause deletes everything. + ** It is easier just to erase the whole table. Prior to version 3.6.5, + ** this optimization caused the row change count (the value returned by + ** API function sqlite3_count_changes) to be set incorrectly. + ** + ** The "rcauth==SQLITE_OK" terms is the + ** IMPLEMENTATION-OF: R-17228-37124 If the action code is SQLITE_DELETE and + ** the callback returns SQLITE_IGNORE then the DELETE operation proceeds but + ** the truncate optimization is disabled and all rows are deleted + ** individually. + */ + if( rcauth==SQLITE_OK + && pWhere==0 + && !bComplex + && !IsVirtual(pTab) +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + && db->xPreUpdateCallback==0 +#endif + ){ + assert( !isView ); + sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName); + if( HasRowid(pTab) ){ + sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt ? memCnt : -1, + pTab->zName, P4_STATIC); + } + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + assert( pIdx->pSchema==pTab->pSchema ); + if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){ + sqlite3VdbeAddOp3(v, OP_Clear, pIdx->tnum, iDb, memCnt ? memCnt : -1); + }else{ + sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb); + } + } + }else +#endif /* SQLITE_OMIT_TRUNCATE_OPTIMIZATION */ + { + u16 wcf = WHERE_ONEPASS_DESIRED|WHERE_DUPLICATES_OK; + if( sNC.ncFlags & NC_Subquery ) bComplex = 1; + wcf |= (bComplex ? 0 : WHERE_ONEPASS_MULTIROW); + if( HasRowid(pTab) ){ + /* For a rowid table, initialize the RowSet to an empty set */ + pPk = 0; + nPk = 1; + iRowSet = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Null, 0, iRowSet); + }else{ + /* For a WITHOUT ROWID table, create an ephemeral table used to + ** hold all primary keys for rows to be deleted. */ + pPk = sqlite3PrimaryKeyIndex(pTab); + assert( pPk!=0 ); + nPk = pPk->nKeyCol; + iPk = pParse->nMem+1; + pParse->nMem += nPk; + iEphCur = pParse->nTab++; + addrEphOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEphCur, nPk); + sqlite3VdbeSetP4KeyInfo(pParse, pPk); + } + + /* Construct a query to find the rowid or primary key for every row + ** to be deleted, based on the WHERE clause. Set variable eOnePass + ** to indicate the strategy used to implement this delete: + ** + ** ONEPASS_OFF: Two-pass approach - use a FIFO for rowids/PK values. + ** ONEPASS_SINGLE: One-pass approach - at most one row deleted. + ** ONEPASS_MULTI: One-pass approach - any number of rows may be deleted. + */ + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0,0,wcf,iTabCur+1); + if( pWInfo==0 ) goto delete_from_cleanup; + eOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass); + assert( IsVirtual(pTab)==0 || eOnePass!=ONEPASS_MULTI ); + assert( IsVirtual(pTab) || bComplex || eOnePass!=ONEPASS_OFF ); + if( eOnePass!=ONEPASS_SINGLE ) sqlite3MultiWrite(pParse); + if( sqlite3WhereUsesDeferredSeek(pWInfo) ){ + sqlite3VdbeAddOp1(v, OP_FinishSeek, iTabCur); + } + + /* Keep track of the number of rows to be deleted */ + if( memCnt ){ + sqlite3VdbeAddOp2(v, OP_AddImm, memCnt, 1); + } + + /* Extract the rowid or primary key for the current row */ + if( pPk ){ + for(i=0; iaiColumn[i]>=0 ); + sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur, + pPk->aiColumn[i], iPk+i); + } + iKey = iPk; + }else{ + iKey = ++pParse->nMem; + sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur, -1, iKey); + } + + if( eOnePass!=ONEPASS_OFF ){ + /* For ONEPASS, no need to store the rowid/primary-key. There is only + ** one, so just keep it in its register(s) and fall through to the + ** delete code. */ + nKey = nPk; /* OP_Found will use an unpacked key */ + aToOpen = sqlite3DbMallocRawNN(db, nIdx+2); + if( aToOpen==0 ){ + sqlite3WhereEnd(pWInfo); + goto delete_from_cleanup; + } + memset(aToOpen, 1, nIdx+1); + aToOpen[nIdx+1] = 0; + if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iTabCur] = 0; + if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iTabCur] = 0; + if( addrEphOpen ) sqlite3VdbeChangeToNoop(v, addrEphOpen); + addrBypass = sqlite3VdbeMakeLabel(pParse); + }else{ + if( pPk ){ + /* Add the PK key for this row to the temporary table */ + iKey = ++pParse->nMem; + nKey = 0; /* Zero tells OP_Found to use a composite key */ + sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, iKey, + sqlite3IndexAffinityStr(pParse->db, pPk), nPk); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iEphCur, iKey, iPk, nPk); + }else{ + /* Add the rowid of the row to be deleted to the RowSet */ + nKey = 1; /* OP_DeferredSeek always uses a single rowid */ + sqlite3VdbeAddOp2(v, OP_RowSetAdd, iRowSet, iKey); + } + sqlite3WhereEnd(pWInfo); + } + + /* Unless this is a view, open cursors for the table we are + ** deleting from and all its indices. If this is a view, then the + ** only effect this statement has is to fire the INSTEAD OF + ** triggers. + */ + if( !isView ){ + int iAddrOnce = 0; + if( eOnePass==ONEPASS_MULTI ){ + iAddrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); + } + testcase( IsVirtual(pTab) ); + sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, OPFLAG_FORDELETE, + iTabCur, aToOpen, &iDataCur, &iIdxCur); + assert( pPk || IsVirtual(pTab) || iDataCur==iTabCur ); + assert( pPk || IsVirtual(pTab) || iIdxCur==iDataCur+1 ); + if( eOnePass==ONEPASS_MULTI ){ + sqlite3VdbeJumpHereOrPopInst(v, iAddrOnce); + } + } + + /* Set up a loop over the rowids/primary-keys that were found in the + ** where-clause loop above. + */ + if( eOnePass!=ONEPASS_OFF ){ + assert( nKey==nPk ); /* OP_Found will use an unpacked key */ + if( !IsVirtual(pTab) && aToOpen[iDataCur-iTabCur] ){ + assert( pPk!=0 || IsView(pTab) ); + sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, addrBypass, iKey, nKey); + VdbeCoverage(v); + } + }else if( pPk ){ + addrLoop = sqlite3VdbeAddOp1(v, OP_Rewind, iEphCur); VdbeCoverage(v); + if( IsVirtual(pTab) ){ + sqlite3VdbeAddOp3(v, OP_Column, iEphCur, 0, iKey); + }else{ + sqlite3VdbeAddOp2(v, OP_RowData, iEphCur, iKey); + } + assert( nKey==0 ); /* OP_Found will use a composite key */ + }else{ + addrLoop = sqlite3VdbeAddOp3(v, OP_RowSetRead, iRowSet, 0, iKey); + VdbeCoverage(v); + assert( nKey==1 ); + } + + /* Delete the row */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTab) ){ + const char *pVTab = (const char *)sqlite3GetVTable(db, pTab); + sqlite3VtabMakeWritable(pParse, pTab); + assert( eOnePass==ONEPASS_OFF || eOnePass==ONEPASS_SINGLE ); + sqlite3MayAbort(pParse); + if( eOnePass==ONEPASS_SINGLE ){ + sqlite3VdbeAddOp1(v, OP_Close, iTabCur); + if( sqlite3IsToplevel(pParse) ){ + pParse->isMultiWrite = 0; + } + } + sqlite3VdbeAddOp4(v, OP_VUpdate, 0, 1, iKey, pVTab, P4_VTAB); + sqlite3VdbeChangeP5(v, OE_Abort); + }else +#endif + { + int count = (pParse->nested==0); /* True to count changes */ + sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur, + iKey, nKey, count, OE_Default, eOnePass, aiCurOnePass[1]); + } + + /* End of the loop over all rowids/primary-keys. */ + if( eOnePass!=ONEPASS_OFF ){ + sqlite3VdbeResolveLabel(v, addrBypass); + sqlite3WhereEnd(pWInfo); + }else if( pPk ){ + sqlite3VdbeAddOp2(v, OP_Next, iEphCur, addrLoop+1); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addrLoop); + }else{ + sqlite3VdbeGoto(v, addrLoop); + sqlite3VdbeJumpHere(v, addrLoop); + } + } /* End non-truncate path */ + + /* Update the sqlite_sequence table by storing the content of the + ** maximum rowid counter values recorded while inserting into + ** autoincrement tables. + */ + if( pParse->nested==0 && pParse->pTriggerTab==0 ){ + sqlite3AutoincrementEnd(pParse); + } + + /* Return the number of rows that were deleted. If this routine is + ** generating code because of a call to sqlite3NestedParse(), do not + ** invoke the callback function. + */ + if( memCnt ){ + sqlite3CodeChangeCount(v, memCnt, "rows deleted"); + } + +delete_from_cleanup: + sqlite3AuthContextPop(&sContext); + sqlite3SrcListDelete(db, pTabList); + sqlite3ExprDelete(db, pWhere); +#if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) + sqlite3ExprListDelete(db, pOrderBy); + sqlite3ExprDelete(db, pLimit); +#endif + if( aToOpen ) sqlite3DbNNFreeNN(db, aToOpen); + return; +} +/* Make sure "isView" and other macros defined above are undefined. Otherwise +** they may interfere with compilation of other functions in this file +** (or in another file, if this file becomes part of the amalgamation). */ +#ifdef isView + #undef isView +#endif +#ifdef pTrigger + #undef pTrigger +#endif + +/* +** This routine generates VDBE code that causes a single row of a +** single table to be deleted. Both the original table entry and +** all indices are removed. +** +** Preconditions: +** +** 1. iDataCur is an open cursor on the btree that is the canonical data +** store for the table. (This will be either the table itself, +** in the case of a rowid table, or the PRIMARY KEY index in the case +** of a WITHOUT ROWID table.) +** +** 2. Read/write cursors for all indices of pTab must be open as +** cursor number iIdxCur+i for the i-th index. +** +** 3. The primary key for the row to be deleted must be stored in a +** sequence of nPk memory cells starting at iPk. If nPk==0 that means +** that a search record formed from OP_MakeRecord is contained in the +** single memory location iPk. +** +** eMode: +** Parameter eMode may be passed either ONEPASS_OFF (0), ONEPASS_SINGLE, or +** ONEPASS_MULTI. If eMode is not ONEPASS_OFF, then the cursor +** iDataCur already points to the row to delete. If eMode is ONEPASS_OFF +** then this function must seek iDataCur to the entry identified by iPk +** and nPk before reading from it. +** +** If eMode is ONEPASS_MULTI, then this call is being made as part +** of a ONEPASS delete that affects multiple rows. In this case, if +** iIdxNoSeek is a valid cursor number (>=0) and is not the same as +** iDataCur, then its position should be preserved following the delete +** operation. Or, if iIdxNoSeek is not a valid cursor number, the +** position of iDataCur should be preserved instead. +** +** iIdxNoSeek: +** If iIdxNoSeek is a valid cursor number (>=0) not equal to iDataCur, +** then it identifies an index cursor (from within array of cursors +** starting at iIdxCur) that already points to the index entry to be deleted. +** Except, this optimization is disabled if there are BEFORE triggers since +** the trigger body might have moved the cursor. +*/ +SQLITE_PRIVATE void sqlite3GenerateRowDelete( + Parse *pParse, /* Parsing context */ + Table *pTab, /* Table containing the row to be deleted */ + Trigger *pTrigger, /* List of triggers to (potentially) fire */ + int iDataCur, /* Cursor from which column data is extracted */ + int iIdxCur, /* First index cursor */ + int iPk, /* First memory cell containing the PRIMARY KEY */ + i16 nPk, /* Number of PRIMARY KEY memory cells */ + u8 count, /* If non-zero, increment the row change counter */ + u8 onconf, /* Default ON CONFLICT policy for triggers */ + u8 eMode, /* ONEPASS_OFF, _SINGLE, or _MULTI. See above */ + int iIdxNoSeek /* Cursor number of cursor that does not need seeking */ +){ + Vdbe *v = pParse->pVdbe; /* Vdbe */ + int iOld = 0; /* First register in OLD.* array */ + int iLabel; /* Label resolved to end of generated code */ + u8 opSeek; /* Seek opcode */ + + /* Vdbe is guaranteed to have been allocated by this stage. */ + assert( v ); + VdbeModuleComment((v, "BEGIN: GenRowDel(%d,%d,%d,%d)", + iDataCur, iIdxCur, iPk, (int)nPk)); + + /* Seek cursor iCur to the row to delete. If this row no longer exists + ** (this can happen if a trigger program has already deleted it), do + ** not attempt to delete it or fire any DELETE triggers. */ + iLabel = sqlite3VdbeMakeLabel(pParse); + opSeek = HasRowid(pTab) ? OP_NotExists : OP_NotFound; + if( eMode==ONEPASS_OFF ){ + sqlite3VdbeAddOp4Int(v, opSeek, iDataCur, iLabel, iPk, nPk); + VdbeCoverageIf(v, opSeek==OP_NotExists); + VdbeCoverageIf(v, opSeek==OP_NotFound); + } + + /* If there are any triggers to fire, allocate a range of registers to + ** use for the old.* references in the triggers. */ + if( sqlite3FkRequired(pParse, pTab, 0, 0) || pTrigger ){ + u32 mask; /* Mask of OLD.* columns in use */ + int iCol; /* Iterator used while populating OLD.* */ + int addrStart; /* Start of BEFORE trigger programs */ + + /* TODO: Could use temporary registers here. Also could attempt to + ** avoid copying the contents of the rowid register. */ + mask = sqlite3TriggerColmask( + pParse, pTrigger, 0, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onconf + ); + mask |= sqlite3FkOldmask(pParse, pTab); + iOld = pParse->nMem+1; + pParse->nMem += (1 + pTab->nCol); + + /* Populate the OLD.* pseudo-table register array. These values will be + ** used by any BEFORE and AFTER triggers that exist. */ + sqlite3VdbeAddOp2(v, OP_Copy, iPk, iOld); + for(iCol=0; iColnCol; iCol++){ + testcase( mask!=0xffffffff && iCol==31 ); + testcase( mask!=0xffffffff && iCol==32 ); + if( mask==0xffffffff || (iCol<=31 && (mask & MASKBIT32(iCol))!=0) ){ + int kk = sqlite3TableColumnToStorage(pTab, iCol); + sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, iCol, iOld+kk+1); + } + } + + /* Invoke BEFORE DELETE trigger programs. */ + addrStart = sqlite3VdbeCurrentAddr(v); + sqlite3CodeRowTrigger(pParse, pTrigger, + TK_DELETE, 0, TRIGGER_BEFORE, pTab, iOld, onconf, iLabel + ); + + /* If any BEFORE triggers were coded, then seek the cursor to the + ** row to be deleted again. It may be that the BEFORE triggers moved + ** the cursor or already deleted the row that the cursor was + ** pointing to. + ** + ** Also disable the iIdxNoSeek optimization since the BEFORE trigger + ** may have moved that cursor. + */ + if( addrStart=0 ); + iIdxNoSeek = -1; + } + + /* Do FK processing. This call checks that any FK constraints that + ** refer to this table (i.e. constraints attached to other tables) + ** are not violated by deleting this row. */ + sqlite3FkCheck(pParse, pTab, iOld, 0, 0, 0); + } + + /* Delete the index and table entries. Skip this step if pTab is really + ** a view (in which case the only effect of the DELETE statement is to + ** fire the INSTEAD OF triggers). + ** + ** If variable 'count' is non-zero, then this OP_Delete instruction should + ** invoke the update-hook. The pre-update-hook, on the other hand should + ** be invoked unless table pTab is a system table. The difference is that + ** the update-hook is not invoked for rows removed by REPLACE, but the + ** pre-update-hook is. + */ + if( !IsView(pTab) ){ + u8 p5 = 0; + sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur,0,iIdxNoSeek); + sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, (count?OPFLAG_NCHANGE:0)); + if( pParse->nested==0 || 0==sqlite3_stricmp(pTab->zName, "sqlite_stat1") ){ + sqlite3VdbeAppendP4(v, (char*)pTab, P4_TABLE); + } + if( eMode!=ONEPASS_OFF ){ + sqlite3VdbeChangeP5(v, OPFLAG_AUXDELETE); + } + if( iIdxNoSeek>=0 && iIdxNoSeek!=iDataCur ){ + sqlite3VdbeAddOp1(v, OP_Delete, iIdxNoSeek); + } + if( eMode==ONEPASS_MULTI ) p5 |= OPFLAG_SAVEPOSITION; + sqlite3VdbeChangeP5(v, p5); + } + + /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to + ** handle rows (possibly in other tables) that refer via a foreign key + ** to the row just deleted. */ + sqlite3FkActions(pParse, pTab, 0, iOld, 0, 0); + + /* Invoke AFTER DELETE trigger programs. */ + sqlite3CodeRowTrigger(pParse, pTrigger, + TK_DELETE, 0, TRIGGER_AFTER, pTab, iOld, onconf, iLabel + ); + + /* Jump here if the row had already been deleted before any BEFORE + ** trigger programs were invoked. Or if a trigger program throws a + ** RAISE(IGNORE) exception. */ + sqlite3VdbeResolveLabel(v, iLabel); + VdbeModuleComment((v, "END: GenRowDel()")); +} + +/* +** This routine generates VDBE code that causes the deletion of all +** index entries associated with a single row of a single table, pTab +** +** Preconditions: +** +** 1. A read/write cursor "iDataCur" must be open on the canonical storage +** btree for the table pTab. (This will be either the table itself +** for rowid tables or to the primary key index for WITHOUT ROWID +** tables.) +** +** 2. Read/write cursors for all indices of pTab must be open as +** cursor number iIdxCur+i for the i-th index. (The pTab->pIndex +** index is the 0-th index.) +** +** 3. The "iDataCur" cursor must be already be positioned on the row +** that is to be deleted. +*/ +SQLITE_PRIVATE void sqlite3GenerateRowIndexDelete( + Parse *pParse, /* Parsing and code generating context */ + Table *pTab, /* Table containing the row to be deleted */ + int iDataCur, /* Cursor of table holding data. */ + int iIdxCur, /* First index cursor */ + int *aRegIdx, /* Only delete if aRegIdx!=0 && aRegIdx[i]>0 */ + int iIdxNoSeek /* Do not delete from this cursor */ +){ + int i; /* Index loop counter */ + int r1 = -1; /* Register holding an index key */ + int iPartIdxLabel; /* Jump destination for skipping partial index entries */ + Index *pIdx; /* Current index */ + Index *pPrior = 0; /* Prior index */ + Vdbe *v; /* The prepared statement under construction */ + Index *pPk; /* PRIMARY KEY index, or NULL for rowid tables */ + + v = pParse->pVdbe; + pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab); + for(i=0, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){ + assert( iIdxCur+i!=iDataCur || pPk==pIdx ); + if( aRegIdx!=0 && aRegIdx[i]==0 ) continue; + if( pIdx==pPk ) continue; + if( iIdxCur+i==iIdxNoSeek ) continue; + VdbeModuleComment((v, "GenRowIdxDel for %s", pIdx->zName)); + r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 1, + &iPartIdxLabel, pPrior, r1); + sqlite3VdbeAddOp3(v, OP_IdxDelete, iIdxCur+i, r1, + pIdx->uniqNotNull ? pIdx->nKeyCol : pIdx->nColumn); + sqlite3VdbeChangeP5(v, 1); /* Cause IdxDelete to error if no entry found */ + sqlite3ResolvePartIdxLabel(pParse, iPartIdxLabel); + pPrior = pIdx; + } +} + +/* +** Generate code that will assemble an index key and stores it in register +** regOut. The key with be for index pIdx which is an index on pTab. +** iCur is the index of a cursor open on the pTab table and pointing to +** the entry that needs indexing. If pTab is a WITHOUT ROWID table, then +** iCur must be the cursor of the PRIMARY KEY index. +** +** Return a register number which is the first in a block of +** registers that holds the elements of the index key. The +** block of registers has already been deallocated by the time +** this routine returns. +** +** If *piPartIdxLabel is not NULL, fill it in with a label and jump +** to that label if pIdx is a partial index that should be skipped. +** The label should be resolved using sqlite3ResolvePartIdxLabel(). +** A partial index should be skipped if its WHERE clause evaluates +** to false or null. If pIdx is not a partial index, *piPartIdxLabel +** will be set to zero which is an empty label that is ignored by +** sqlite3ResolvePartIdxLabel(). +** +** The pPrior and regPrior parameters are used to implement a cache to +** avoid unnecessary register loads. If pPrior is not NULL, then it is +** a pointer to a different index for which an index key has just been +** computed into register regPrior. If the current pIdx index is generating +** its key into the same sequence of registers and if pPrior and pIdx share +** a column in common, then the register corresponding to that column already +** holds the correct value and the loading of that register is skipped. +** This optimization is helpful when doing a DELETE or an INTEGRITY_CHECK +** on a table with multiple indices, and especially with the ROWID or +** PRIMARY KEY columns of the index. +*/ +SQLITE_PRIVATE int sqlite3GenerateIndexKey( + Parse *pParse, /* Parsing context */ + Index *pIdx, /* The index for which to generate a key */ + int iDataCur, /* Cursor number from which to take column data */ + int regOut, /* Put the new key into this register if not 0 */ + int prefixOnly, /* Compute only a unique prefix of the key */ + int *piPartIdxLabel, /* OUT: Jump to this label to skip partial index */ + Index *pPrior, /* Previously generated index key */ + int regPrior /* Register holding previous generated key */ +){ + Vdbe *v = pParse->pVdbe; + int j; + int regBase; + int nCol; + + if( piPartIdxLabel ){ + if( pIdx->pPartIdxWhere ){ + *piPartIdxLabel = sqlite3VdbeMakeLabel(pParse); + pParse->iSelfTab = iDataCur + 1; + sqlite3ExprIfFalseDup(pParse, pIdx->pPartIdxWhere, *piPartIdxLabel, + SQLITE_JUMPIFNULL); + pParse->iSelfTab = 0; + pPrior = 0; /* Ticket a9efb42811fa41ee 2019-11-02; + ** pPartIdxWhere may have corrupted regPrior registers */ + }else{ + *piPartIdxLabel = 0; + } + } + nCol = (prefixOnly && pIdx->uniqNotNull) ? pIdx->nKeyCol : pIdx->nColumn; + regBase = sqlite3GetTempRange(pParse, nCol); + if( pPrior && (regBase!=regPrior || pPrior->pPartIdxWhere) ) pPrior = 0; + for(j=0; jaiColumn[j]==pIdx->aiColumn[j] + && pPrior->aiColumn[j]!=XN_EXPR + ){ + /* This column was already computed by the previous index */ + continue; + } + sqlite3ExprCodeLoadIndexColumn(pParse, pIdx, iDataCur, j, regBase+j); + if( pIdx->aiColumn[j]>=0 ){ + /* If the column affinity is REAL but the number is an integer, then it + ** might be stored in the table as an integer (using a compact + ** representation) then converted to REAL by an OP_RealAffinity opcode. + ** But we are getting ready to store this value back into an index, where + ** it should be converted by to INTEGER again. So omit the + ** OP_RealAffinity opcode if it is present */ + sqlite3VdbeDeletePriorOpcode(v, OP_RealAffinity); + } + } + if( regOut ){ + sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut); + } + sqlite3ReleaseTempRange(pParse, regBase, nCol); + return regBase; +} + +/* +** If a prior call to sqlite3GenerateIndexKey() generated a jump-over label +** because it was a partial index, then this routine should be called to +** resolve that label. +*/ +SQLITE_PRIVATE void sqlite3ResolvePartIdxLabel(Parse *pParse, int iLabel){ + if( iLabel ){ + sqlite3VdbeResolveLabel(pParse->pVdbe, iLabel); + } +} + +/************** End of delete.c **********************************************/ +/************** Begin file func.c ********************************************/ +/* +** 2002 February 23 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C-language implementations for many of the SQL +** functions of SQLite. (Some function, and in particular the date and +** time functions, are implemented separately.) +*/ +/* #include "sqliteInt.h" */ +/* #include */ +/* #include */ +#ifndef SQLITE_OMIT_FLOATING_POINT +/* #include */ +#endif +/* #include "vdbeInt.h" */ + +/* +** Return the collating function associated with a function. +*/ +static CollSeq *sqlite3GetFuncCollSeq(sqlite3_context *context){ + VdbeOp *pOp; + assert( context->pVdbe!=0 ); + pOp = &context->pVdbe->aOp[context->iOp-1]; + assert( pOp->opcode==OP_CollSeq ); + assert( pOp->p4type==P4_COLLSEQ ); + return pOp->p4.pColl; +} + +/* +** Indicate that the accumulator load should be skipped on this +** iteration of the aggregate loop. +*/ +static void sqlite3SkipAccumulatorLoad(sqlite3_context *context){ + assert( context->isError<=0 ); + context->isError = -1; + context->skipFlag = 1; +} + +/* +** Implementation of the non-aggregate min() and max() functions +*/ +static void minmaxFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int i; + int mask; /* 0 for min() or 0xffffffff for max() */ + int iBest; + CollSeq *pColl; + + assert( argc>1 ); + mask = sqlite3_user_data(context)==0 ? 0 : -1; + pColl = sqlite3GetFuncCollSeq(context); + assert( pColl ); + assert( mask==-1 || mask==0 ); + iBest = 0; + if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; + for(i=1; i=0 ){ + testcase( mask==0 ); + iBest = i; + } + } + sqlite3_result_value(context, argv[iBest]); +} + +/* +** Return the type of the argument. +*/ +static void typeofFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + static const char *azType[] = { "integer", "real", "text", "blob", "null" }; + int i = sqlite3_value_type(argv[0]) - 1; + UNUSED_PARAMETER(NotUsed); + assert( i>=0 && i=0xc0 ){ + while( (*z & 0xc0)==0x80 ){ z++; z0++; } + } + } + sqlite3_result_int(context, (int)(z-z0)); + break; + } + default: { + sqlite3_result_null(context); + break; + } + } +} + +/* +** Implementation of the abs() function. +** +** IMP: R-23979-26855 The abs(X) function returns the absolute value of +** the numeric argument X. +*/ +static void absFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ + assert( argc==1 ); + UNUSED_PARAMETER(argc); + switch( sqlite3_value_type(argv[0]) ){ + case SQLITE_INTEGER: { + i64 iVal = sqlite3_value_int64(argv[0]); + if( iVal<0 ){ + if( iVal==SMALLEST_INT64 ){ + /* IMP: R-31676-45509 If X is the integer -9223372036854775808 + ** then abs(X) throws an integer overflow error since there is no + ** equivalent positive 64-bit two complement value. */ + sqlite3_result_error(context, "integer overflow", -1); + return; + } + iVal = -iVal; + } + sqlite3_result_int64(context, iVal); + break; + } + case SQLITE_NULL: { + /* IMP: R-37434-19929 Abs(X) returns NULL if X is NULL. */ + sqlite3_result_null(context); + break; + } + default: { + /* Because sqlite3_value_double() returns 0.0 if the argument is not + ** something that can be converted into a number, we have: + ** IMP: R-01992-00519 Abs(X) returns 0.0 if X is a string or blob + ** that cannot be converted to a numeric value. + */ + double rVal = sqlite3_value_double(argv[0]); + if( rVal<0 ) rVal = -rVal; + sqlite3_result_double(context, rVal); + break; + } + } +} + +/* +** Implementation of the instr() function. +** +** instr(haystack,needle) finds the first occurrence of needle +** in haystack and returns the number of previous characters plus 1, +** or 0 if needle does not occur within haystack. +** +** If both haystack and needle are BLOBs, then the result is one more than +** the number of bytes in haystack prior to the first occurrence of needle, +** or 0 if needle never occurs in haystack. +*/ +static void instrFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *zHaystack; + const unsigned char *zNeedle; + int nHaystack; + int nNeedle; + int typeHaystack, typeNeedle; + int N = 1; + int isText; + unsigned char firstChar; + sqlite3_value *pC1 = 0; + sqlite3_value *pC2 = 0; + + UNUSED_PARAMETER(argc); + typeHaystack = sqlite3_value_type(argv[0]); + typeNeedle = sqlite3_value_type(argv[1]); + if( typeHaystack==SQLITE_NULL || typeNeedle==SQLITE_NULL ) return; + nHaystack = sqlite3_value_bytes(argv[0]); + nNeedle = sqlite3_value_bytes(argv[1]); + if( nNeedle>0 ){ + if( typeHaystack==SQLITE_BLOB && typeNeedle==SQLITE_BLOB ){ + zHaystack = sqlite3_value_blob(argv[0]); + zNeedle = sqlite3_value_blob(argv[1]); + isText = 0; + }else if( typeHaystack!=SQLITE_BLOB && typeNeedle!=SQLITE_BLOB ){ + zHaystack = sqlite3_value_text(argv[0]); + zNeedle = sqlite3_value_text(argv[1]); + isText = 1; + }else{ + pC1 = sqlite3_value_dup(argv[0]); + zHaystack = sqlite3_value_text(pC1); + if( zHaystack==0 ) goto endInstrOOM; + nHaystack = sqlite3_value_bytes(pC1); + pC2 = sqlite3_value_dup(argv[1]); + zNeedle = sqlite3_value_text(pC2); + if( zNeedle==0 ) goto endInstrOOM; + nNeedle = sqlite3_value_bytes(pC2); + isText = 1; + } + if( zNeedle==0 || (nHaystack && zHaystack==0) ) goto endInstrOOM; + firstChar = zNeedle[0]; + while( nNeedle<=nHaystack + && (zHaystack[0]!=firstChar || memcmp(zHaystack, zNeedle, nNeedle)!=0) + ){ + N++; + do{ + nHaystack--; + zHaystack++; + }while( isText && (zHaystack[0]&0xc0)==0x80 ); + } + if( nNeedle>nHaystack ) N = 0; + } + sqlite3_result_int(context, N); +endInstr: + sqlite3_value_free(pC1); + sqlite3_value_free(pC2); + return; +endInstrOOM: + sqlite3_result_error_nomem(context); + goto endInstr; +} + +/* +** Implementation of the printf() (a.k.a. format()) SQL function. +*/ +static void printfFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + PrintfArguments x; + StrAccum str; + const char *zFormat; + int n; + sqlite3 *db = sqlite3_context_db_handle(context); + + if( argc>=1 && (zFormat = (const char*)sqlite3_value_text(argv[0]))!=0 ){ + x.nArg = argc-1; + x.nUsed = 0; + x.apArg = argv+1; + sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]); + str.printfFlags = SQLITE_PRINTF_SQLFUNC; + sqlite3_str_appendf(&str, zFormat, &x); + n = str.nChar; + sqlite3_result_text(context, sqlite3StrAccumFinish(&str), n, + SQLITE_DYNAMIC); + } +} + +/* +** Implementation of the substr() function. +** +** substr(x,p1,p2) returns p2 characters of x[] beginning with p1. +** p1 is 1-indexed. So substr(x,1,1) returns the first character +** of x. If x is text, then we actually count UTF-8 characters. +** If x is a blob, then we count bytes. +** +** If p1 is negative, then we begin abs(p1) from the end of x[]. +** +** If p2 is negative, return the p2 characters preceding p1. +*/ +static void substrFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *z; + const unsigned char *z2; + int len; + int p0type; + i64 p1, p2; + int negP2 = 0; + + assert( argc==3 || argc==2 ); + if( sqlite3_value_type(argv[1])==SQLITE_NULL + || (argc==3 && sqlite3_value_type(argv[2])==SQLITE_NULL) + ){ + return; + } + p0type = sqlite3_value_type(argv[0]); + p1 = sqlite3_value_int(argv[1]); + if( p0type==SQLITE_BLOB ){ + len = sqlite3_value_bytes(argv[0]); + z = sqlite3_value_blob(argv[0]); + if( z==0 ) return; + assert( len==sqlite3_value_bytes(argv[0]) ); + }else{ + z = sqlite3_value_text(argv[0]); + if( z==0 ) return; + len = 0; + if( p1<0 ){ + for(z2=z; *z2; len++){ + SQLITE_SKIP_UTF8(z2); + } + } + } +#ifdef SQLITE_SUBSTR_COMPATIBILITY + /* If SUBSTR_COMPATIBILITY is defined then substr(X,0,N) work the same as + ** as substr(X,1,N) - it returns the first N characters of X. This + ** is essentially a back-out of the bug-fix in check-in [5fc125d362df4b8] + ** from 2009-02-02 for compatibility of applications that exploited the + ** old buggy behavior. */ + if( p1==0 ) p1 = 1; /* */ +#endif + if( argc==3 ){ + p2 = sqlite3_value_int(argv[2]); + if( p2<0 ){ + p2 = -p2; + negP2 = 1; + } + }else{ + p2 = sqlite3_context_db_handle(context)->aLimit[SQLITE_LIMIT_LENGTH]; + } + if( p1<0 ){ + p1 += len; + if( p1<0 ){ + p2 += p1; + if( p2<0 ) p2 = 0; + p1 = 0; + } + }else if( p1>0 ){ + p1--; + }else if( p2>0 ){ + p2--; + } + if( negP2 ){ + p1 -= p2; + if( p1<0 ){ + p2 += p1; + p1 = 0; + } + } + assert( p1>=0 && p2>=0 ); + if( p0type!=SQLITE_BLOB ){ + while( *z && p1 ){ + SQLITE_SKIP_UTF8(z); + p1--; + } + for(z2=z; *z2 && p2; p2--){ + SQLITE_SKIP_UTF8(z2); + } + sqlite3_result_text64(context, (char*)z, z2-z, SQLITE_TRANSIENT, + SQLITE_UTF8); + }else{ + if( p1+p2>len ){ + p2 = len-p1; + if( p2<0 ) p2 = 0; + } + sqlite3_result_blob64(context, (char*)&z[p1], (u64)p2, SQLITE_TRANSIENT); + } +} + +/* +** Implementation of the round() function +*/ +#ifndef SQLITE_OMIT_FLOATING_POINT +static void roundFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ + int n = 0; + double r; + char *zBuf; + assert( argc==1 || argc==2 ); + if( argc==2 ){ + if( SQLITE_NULL==sqlite3_value_type(argv[1]) ) return; + n = sqlite3_value_int(argv[1]); + if( n>30 ) n = 30; + if( n<0 ) n = 0; + } + if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; + r = sqlite3_value_double(argv[0]); + /* If Y==0 and X will fit in a 64-bit int, + ** handle the rounding directly, + ** otherwise use printf. + */ + if( r<-4503599627370496.0 || r>+4503599627370496.0 ){ + /* The value has no fractional part so there is nothing to round */ + }else if( n==0 ){ + r = (double)((sqlite_int64)(r+(r<0?-0.5:+0.5))); + }else{ + zBuf = sqlite3_mprintf("%.*f",n,r); + if( zBuf==0 ){ + sqlite3_result_error_nomem(context); + return; + } + sqlite3AtoF(zBuf, &r, sqlite3Strlen30(zBuf), SQLITE_UTF8); + sqlite3_free(zBuf); + } + sqlite3_result_double(context, r); +} +#endif + +/* +** Allocate nByte bytes of space using sqlite3Malloc(). If the +** allocation fails, call sqlite3_result_error_nomem() to notify +** the database handle that malloc() has failed and return NULL. +** If nByte is larger than the maximum string or blob length, then +** raise an SQLITE_TOOBIG exception and return NULL. +*/ +static void *contextMalloc(sqlite3_context *context, i64 nByte){ + char *z; + sqlite3 *db = sqlite3_context_db_handle(context); + assert( nByte>0 ); + testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] ); + testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 ); + if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){ + sqlite3_result_error_toobig(context); + z = 0; + }else{ + z = sqlite3Malloc(nByte); + if( !z ){ + sqlite3_result_error_nomem(context); + } + } + return z; +} + +/* +** Implementation of the upper() and lower() SQL functions. +*/ +static void upperFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ + char *z1; + const char *z2; + int i, n; + UNUSED_PARAMETER(argc); + z2 = (char*)sqlite3_value_text(argv[0]); + n = sqlite3_value_bytes(argv[0]); + /* Verify that the call to _bytes() does not invalidate the _text() pointer */ + assert( z2==(char*)sqlite3_value_text(argv[0]) ); + if( z2 ){ + z1 = contextMalloc(context, ((i64)n)+1); + if( z1 ){ + for(i=0; imatchOne; /* "?" or "_" */ + u32 matchAll = pInfo->matchAll; /* "*" or "%" */ + u8 noCase = pInfo->noCase; /* True if uppercase==lowercase */ + const u8 *zEscaped = 0; /* One past the last escaped input char */ + + while( (c = Utf8Read(zPattern))!=0 ){ + if( c==matchAll ){ /* Match "*" */ + /* Skip over multiple "*" characters in the pattern. If there + ** are also "?" characters, skip those as well, but consume a + ** single character of the input string for each "?" skipped */ + while( (c=Utf8Read(zPattern)) == matchAll + || (c == matchOne && matchOne!=0) ){ + if( c==matchOne && sqlite3Utf8Read(&zString)==0 ){ + return SQLITE_NOWILDCARDMATCH; + } + } + if( c==0 ){ + return SQLITE_MATCH; /* "*" at the end of the pattern matches */ + }else if( c==matchOther ){ + if( pInfo->matchSet==0 ){ + c = sqlite3Utf8Read(&zPattern); + if( c==0 ) return SQLITE_NOWILDCARDMATCH; + }else{ + /* "[...]" immediately follows the "*". We have to do a slow + ** recursive search in this case, but it is an unusual case. */ + assert( matchOther<0x80 ); /* '[' is a single-byte character */ + while( *zString ){ + int bMatch = patternCompare(&zPattern[-1],zString,pInfo,matchOther); + if( bMatch!=SQLITE_NOMATCH ) return bMatch; + SQLITE_SKIP_UTF8(zString); + } + return SQLITE_NOWILDCARDMATCH; + } + } + + /* At this point variable c contains the first character of the + ** pattern string past the "*". Search in the input string for the + ** first matching character and recursively continue the match from + ** that point. + ** + ** For a case-insensitive search, set variable cx to be the same as + ** c but in the other case and search the input string for either + ** c or cx. + */ + if( c<0x80 ){ + char zStop[3]; + int bMatch; + if( noCase ){ + zStop[0] = sqlite3Toupper(c); + zStop[1] = sqlite3Tolower(c); + zStop[2] = 0; + }else{ + zStop[0] = c; + zStop[1] = 0; + } + while(1){ + zString += strcspn((const char*)zString, zStop); + if( zString[0]==0 ) break; + zString++; + bMatch = patternCompare(zPattern,zString,pInfo,matchOther); + if( bMatch!=SQLITE_NOMATCH ) return bMatch; + } + }else{ + int bMatch; + while( (c2 = Utf8Read(zString))!=0 ){ + if( c2!=c ) continue; + bMatch = patternCompare(zPattern,zString,pInfo,matchOther); + if( bMatch!=SQLITE_NOMATCH ) return bMatch; + } + } + return SQLITE_NOWILDCARDMATCH; + } + if( c==matchOther ){ + if( pInfo->matchSet==0 ){ + c = sqlite3Utf8Read(&zPattern); + if( c==0 ) return SQLITE_NOMATCH; + zEscaped = zPattern; + }else{ + u32 prior_c = 0; + int seen = 0; + int invert = 0; + c = sqlite3Utf8Read(&zString); + if( c==0 ) return SQLITE_NOMATCH; + c2 = sqlite3Utf8Read(&zPattern); + if( c2=='^' ){ + invert = 1; + c2 = sqlite3Utf8Read(&zPattern); + } + if( c2==']' ){ + if( c==']' ) seen = 1; + c2 = sqlite3Utf8Read(&zPattern); + } + while( c2 && c2!=']' ){ + if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){ + c2 = sqlite3Utf8Read(&zPattern); + if( c>=prior_c && c<=c2 ) seen = 1; + prior_c = 0; + }else{ + if( c==c2 ){ + seen = 1; + } + prior_c = c2; + } + c2 = sqlite3Utf8Read(&zPattern); + } + if( c2==0 || (seen ^ invert)==0 ){ + return SQLITE_NOMATCH; + } + continue; + } + } + c2 = Utf8Read(zString); + if( c==c2 ) continue; + if( noCase && sqlite3Tolower(c)==sqlite3Tolower(c2) && c<0x80 && c2<0x80 ){ + continue; + } + if( c==matchOne && zPattern!=zEscaped && c2!=0 ) continue; + return SQLITE_NOMATCH; + } + return *zString==0 ? SQLITE_MATCH : SQLITE_NOMATCH; +} + +/* +** The sqlite3_strglob() interface. Return 0 on a match (like strcmp()) and +** non-zero if there is no match. +*/ +SQLITE_API int sqlite3_strglob(const char *zGlobPattern, const char *zString){ + if( zString==0 ){ + return zGlobPattern!=0; + }else if( zGlobPattern==0 ){ + return 1; + }else { + return patternCompare((u8*)zGlobPattern, (u8*)zString, &globInfo, '['); + } +} + +/* +** The sqlite3_strlike() interface. Return 0 on a match and non-zero for +** a miss - like strcmp(). +*/ +SQLITE_API int sqlite3_strlike(const char *zPattern, const char *zStr, unsigned int esc){ + if( zStr==0 ){ + return zPattern!=0; + }else if( zPattern==0 ){ + return 1; + }else{ + return patternCompare((u8*)zPattern, (u8*)zStr, &likeInfoNorm, esc); + } +} + +/* +** Count the number of times that the LIKE operator (or GLOB which is +** just a variation of LIKE) gets called. This is used for testing +** only. +*/ +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_like_count = 0; +#endif + + +/* +** Implementation of the like() SQL function. This function implements +** the build-in LIKE operator. The first argument to the function is the +** pattern and the second argument is the string. So, the SQL statements: +** +** A LIKE B +** +** is implemented as like(B,A). +** +** This same function (with a different compareInfo structure) computes +** the GLOB operator. +*/ +static void likeFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *zA, *zB; + u32 escape; + int nPat; + sqlite3 *db = sqlite3_context_db_handle(context); + struct compareInfo *pInfo = sqlite3_user_data(context); + struct compareInfo backupInfo; + +#ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS + if( sqlite3_value_type(argv[0])==SQLITE_BLOB + || sqlite3_value_type(argv[1])==SQLITE_BLOB + ){ +#ifdef SQLITE_TEST + sqlite3_like_count++; +#endif + sqlite3_result_int(context, 0); + return; + } +#endif + + /* Limit the length of the LIKE or GLOB pattern to avoid problems + ** of deep recursion and N*N behavior in patternCompare(). + */ + nPat = sqlite3_value_bytes(argv[0]); + testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ); + testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 ); + if( nPat > db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ){ + sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1); + return; + } + if( argc==3 ){ + /* The escape character string must consist of a single UTF-8 character. + ** Otherwise, return an error. + */ + const unsigned char *zEsc = sqlite3_value_text(argv[2]); + if( zEsc==0 ) return; + if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){ + sqlite3_result_error(context, + "ESCAPE expression must be a single character", -1); + return; + } + escape = sqlite3Utf8Read(&zEsc); + if( escape==pInfo->matchAll || escape==pInfo->matchOne ){ + memcpy(&backupInfo, pInfo, sizeof(backupInfo)); + pInfo = &backupInfo; + if( escape==pInfo->matchAll ) pInfo->matchAll = 0; + if( escape==pInfo->matchOne ) pInfo->matchOne = 0; + } + }else{ + escape = pInfo->matchSet; + } + zB = sqlite3_value_text(argv[0]); + zA = sqlite3_value_text(argv[1]); + if( zA && zB ){ +#ifdef SQLITE_TEST + sqlite3_like_count++; +#endif + sqlite3_result_int(context, + patternCompare(zB, zA, pInfo, escape)==SQLITE_MATCH); + } +} + +/* +** Implementation of the NULLIF(x,y) function. The result is the first +** argument if the arguments are different. The result is NULL if the +** arguments are equal to each other. +*/ +static void nullifFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + CollSeq *pColl = sqlite3GetFuncCollSeq(context); + UNUSED_PARAMETER(NotUsed); + if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){ + sqlite3_result_value(context, argv[0]); + } +} + +/* +** Implementation of the sqlite_version() function. The result is the version +** of the SQLite library that is running. +*/ +static void versionFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **NotUsed2 +){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + /* IMP: R-48699-48617 This function is an SQL wrapper around the + ** sqlite3_libversion() C-interface. */ + sqlite3_result_text(context, sqlite3_libversion(), -1, SQLITE_STATIC); +} + +/* +** Implementation of the sqlite_source_id() function. The result is a string +** that identifies the particular version of the source code used to build +** SQLite. +*/ +static void sourceidFunc( + sqlite3_context *context, + int NotUsed, + sqlite3_value **NotUsed2 +){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + /* IMP: R-24470-31136 This function is an SQL wrapper around the + ** sqlite3_sourceid() C interface. */ + sqlite3_result_text(context, sqlite3_sourceid(), -1, SQLITE_STATIC); +} + +/* +** Implementation of the sqlite_log() function. This is a wrapper around +** sqlite3_log(). The return value is NULL. The function exists purely for +** its side-effects. +*/ +static void errlogFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + UNUSED_PARAMETER(argc); + UNUSED_PARAMETER(context); + sqlite3_log(sqlite3_value_int(argv[0]), "%s", sqlite3_value_text(argv[1])); +} + +/* +** Implementation of the sqlite_compileoption_used() function. +** The result is an integer that identifies if the compiler option +** was used to build SQLite. +*/ +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS +static void compileoptionusedFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const char *zOptName; + assert( argc==1 ); + UNUSED_PARAMETER(argc); + /* IMP: R-39564-36305 The sqlite_compileoption_used() SQL + ** function is a wrapper around the sqlite3_compileoption_used() C/C++ + ** function. + */ + if( (zOptName = (const char*)sqlite3_value_text(argv[0]))!=0 ){ + sqlite3_result_int(context, sqlite3_compileoption_used(zOptName)); + } +} +#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ + +/* +** Implementation of the sqlite_compileoption_get() function. +** The result is a string that identifies the compiler options +** used to build SQLite. +*/ +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS +static void compileoptiongetFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int n; + assert( argc==1 ); + UNUSED_PARAMETER(argc); + /* IMP: R-04922-24076 The sqlite_compileoption_get() SQL function + ** is a wrapper around the sqlite3_compileoption_get() C/C++ function. + */ + n = sqlite3_value_int(argv[0]); + sqlite3_result_text(context, sqlite3_compileoption_get(n), -1, SQLITE_STATIC); +} +#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ + +/* Array for converting from half-bytes (nybbles) into ASCII hex +** digits. */ +static const char hexdigits[] = { + '0', '1', '2', '3', '4', '5', '6', '7', + '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' +}; + +/* +** Append to pStr text that is the SQL literal representation of the +** value contained in pValue. +*/ +SQLITE_PRIVATE void sqlite3QuoteValue(StrAccum *pStr, sqlite3_value *pValue){ + /* As currently implemented, the string must be initially empty. + ** we might relax this requirement in the future, but that will + ** require enhancements to the implementation. */ + assert( pStr!=0 && pStr->nChar==0 ); + + switch( sqlite3_value_type(pValue) ){ + case SQLITE_FLOAT: { + double r1, r2; + const char *zVal; + r1 = sqlite3_value_double(pValue); + sqlite3_str_appendf(pStr, "%!.15g", r1); + zVal = sqlite3_str_value(pStr); + if( zVal ){ + sqlite3AtoF(zVal, &r2, pStr->nChar, SQLITE_UTF8); + if( r1!=r2 ){ + sqlite3_str_reset(pStr); + sqlite3_str_appendf(pStr, "%!.20e", r1); + } + } + break; + } + case SQLITE_INTEGER: { + sqlite3_str_appendf(pStr, "%lld", sqlite3_value_int64(pValue)); + break; + } + case SQLITE_BLOB: { + char const *zBlob = sqlite3_value_blob(pValue); + i64 nBlob = sqlite3_value_bytes(pValue); + assert( zBlob==sqlite3_value_blob(pValue) ); /* No encoding change */ + sqlite3StrAccumEnlarge(pStr, nBlob*2 + 4); + if( pStr->accError==0 ){ + char *zText = pStr->zText; + int i; + for(i=0; i>4)&0x0F]; + zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F]; + } + zText[(nBlob*2)+2] = '\''; + zText[(nBlob*2)+3] = '\0'; + zText[0] = 'X'; + zText[1] = '\''; + pStr->nChar = nBlob*2 + 3; + } + break; + } + case SQLITE_TEXT: { + const unsigned char *zArg = sqlite3_value_text(pValue); + sqlite3_str_appendf(pStr, "%Q", zArg); + break; + } + default: { + assert( sqlite3_value_type(pValue)==SQLITE_NULL ); + sqlite3_str_append(pStr, "NULL", 4); + break; + } + } +} + +/* +** Implementation of the QUOTE() function. +** +** The quote(X) function returns the text of an SQL literal which is the +** value of its argument suitable for inclusion into an SQL statement. +** Strings are surrounded by single-quotes with escapes on interior quotes +** as needed. BLOBs are encoded as hexadecimal literals. Strings with +** embedded NUL characters cannot be represented as string literals in SQL +** and hence the returned string literal is truncated prior to the first NUL. +*/ +static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ + sqlite3_str str; + sqlite3 *db = sqlite3_context_db_handle(context); + assert( argc==1 ); + UNUSED_PARAMETER(argc); + sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]); + sqlite3QuoteValue(&str,argv[0]); + sqlite3_result_text(context, sqlite3StrAccumFinish(&str), str.nChar, + SQLITE_DYNAMIC); + if( str.accError!=SQLITE_OK ){ + sqlite3_result_null(context); + sqlite3_result_error_code(context, str.accError); + } +} + +/* +** The unicode() function. Return the integer unicode code-point value +** for the first character of the input string. +*/ +static void unicodeFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *z = sqlite3_value_text(argv[0]); + (void)argc; + if( z && z[0] ) sqlite3_result_int(context, sqlite3Utf8Read(&z)); +} + +/* +** The char() function takes zero or more arguments, each of which is +** an integer. It constructs a string where each character of the string +** is the unicode character for the corresponding integer argument. +*/ +static void charFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + unsigned char *z, *zOut; + int i; + zOut = z = sqlite3_malloc64( argc*4+1 ); + if( z==0 ){ + sqlite3_result_error_nomem(context); + return; + } + for(i=0; i0x10ffff ) x = 0xfffd; + c = (unsigned)(x & 0x1fffff); + if( c<0x00080 ){ + *zOut++ = (u8)(c&0xFF); + }else if( c<0x00800 ){ + *zOut++ = 0xC0 + (u8)((c>>6)&0x1F); + *zOut++ = 0x80 + (u8)(c & 0x3F); + }else if( c<0x10000 ){ + *zOut++ = 0xE0 + (u8)((c>>12)&0x0F); + *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); + *zOut++ = 0x80 + (u8)(c & 0x3F); + }else{ + *zOut++ = 0xF0 + (u8)((c>>18) & 0x07); + *zOut++ = 0x80 + (u8)((c>>12) & 0x3F); + *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); + *zOut++ = 0x80 + (u8)(c & 0x3F); + } \ + } + sqlite3_result_text64(context, (char*)z, zOut-z, sqlite3_free, SQLITE_UTF8); +} + +/* +** The hex() function. Interpret the argument as a blob. Return +** a hexadecimal rendering as text. +*/ +static void hexFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int i, n; + const unsigned char *pBlob; + char *zHex, *z; + assert( argc==1 ); + UNUSED_PARAMETER(argc); + pBlob = sqlite3_value_blob(argv[0]); + n = sqlite3_value_bytes(argv[0]); + assert( pBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */ + z = zHex = contextMalloc(context, ((i64)n)*2 + 1); + if( zHex ){ + for(i=0; i>4)&0xf]; + *(z++) = hexdigits[c&0xf]; + } + *z = 0; + sqlite3_result_text(context, zHex, n*2, sqlite3_free); + } +} + +/* +** Buffer zStr contains nStr bytes of utf-8 encoded text. Return 1 if zStr +** contains character ch, or 0 if it does not. +*/ +static int strContainsChar(const u8 *zStr, int nStr, u32 ch){ + const u8 *zEnd = &zStr[nStr]; + const u8 *z = zStr; + while( zmallocFailed ); + return; + } + if( zPattern[0]==0 ){ + assert( sqlite3_value_type(argv[1])!=SQLITE_NULL ); + sqlite3_result_value(context, argv[0]); + return; + } + nPattern = sqlite3_value_bytes(argv[1]); + assert( zPattern==sqlite3_value_text(argv[1]) ); /* No encoding change */ + zRep = sqlite3_value_text(argv[2]); + if( zRep==0 ) return; + nRep = sqlite3_value_bytes(argv[2]); + assert( zRep==sqlite3_value_text(argv[2]) ); + nOut = nStr + 1; + assert( nOutnPattern ){ + nOut += nRep - nPattern; + testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] ); + testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] ); + if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){ + sqlite3_result_error_toobig(context); + sqlite3_free(zOut); + return; + } + cntExpand++; + if( (cntExpand&(cntExpand-1))==0 ){ + /* Grow the size of the output buffer only on substitutions + ** whose index is a power of two: 1, 2, 4, 8, 16, 32, ... */ + u8 *zOld; + zOld = zOut; + zOut = sqlite3Realloc(zOut, (int)nOut + (nOut - nStr - 1)); + if( zOut==0 ){ + sqlite3_result_error_nomem(context); + sqlite3_free(zOld); + return; + } + } + } + memcpy(&zOut[j], zRep, nRep); + j += nRep; + i += nPattern-1; + } + } + assert( j+nStr-i+1<=nOut ); + memcpy(&zOut[j], &zStr[i], nStr-i); + j += nStr - i; + assert( j<=nOut ); + zOut[j] = 0; + sqlite3_result_text(context, (char*)zOut, j, sqlite3_free); +} + +/* +** Implementation of the TRIM(), LTRIM(), and RTRIM() functions. +** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both. +*/ +static void trimFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *zIn; /* Input string */ + const unsigned char *zCharSet; /* Set of characters to trim */ + unsigned int nIn; /* Number of bytes in input */ + int flags; /* 1: trimleft 2: trimright 3: trim */ + int i; /* Loop counter */ + unsigned int *aLen = 0; /* Length of each character in zCharSet */ + unsigned char **azChar = 0; /* Individual characters in zCharSet */ + int nChar; /* Number of characters in zCharSet */ + + if( sqlite3_value_type(argv[0])==SQLITE_NULL ){ + return; + } + zIn = sqlite3_value_text(argv[0]); + if( zIn==0 ) return; + nIn = (unsigned)sqlite3_value_bytes(argv[0]); + assert( zIn==sqlite3_value_text(argv[0]) ); + if( argc==1 ){ + static const unsigned lenOne[] = { 1 }; + static unsigned char * const azOne[] = { (u8*)" " }; + nChar = 1; + aLen = (unsigned*)lenOne; + azChar = (unsigned char **)azOne; + zCharSet = 0; + }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){ + return; + }else{ + const unsigned char *z; + for(z=zCharSet, nChar=0; *z; nChar++){ + SQLITE_SKIP_UTF8(z); + } + if( nChar>0 ){ + azChar = contextMalloc(context, + ((i64)nChar)*(sizeof(char*)+sizeof(unsigned))); + if( azChar==0 ){ + return; + } + aLen = (unsigned*)&azChar[nChar]; + for(z=zCharSet, nChar=0; *z; nChar++){ + azChar[nChar] = (unsigned char *)z; + SQLITE_SKIP_UTF8(z); + aLen[nChar] = (unsigned)(z - azChar[nChar]); + } + } + } + if( nChar>0 ){ + flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context)); + if( flags & 1 ){ + while( nIn>0 ){ + unsigned int len = 0; + for(i=0; i=nChar ) break; + zIn += len; + nIn -= len; + } + } + if( flags & 2 ){ + while( nIn>0 ){ + unsigned int len = 0; + for(i=0; i=nChar ) break; + nIn -= len; + } + } + if( zCharSet ){ + sqlite3_free(azChar); + } + } + sqlite3_result_text(context, (char*)zIn, nIn, SQLITE_TRANSIENT); +} + + +#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION +/* +** The "unknown" function is automatically substituted in place of +** any unrecognized function name when doing an EXPLAIN or EXPLAIN QUERY PLAN +** when the SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION compile-time option is used. +** When the "sqlite3" command-line shell is built using this functionality, +** that allows an EXPLAIN or EXPLAIN QUERY PLAN for complex queries +** involving application-defined functions to be examined in a generic +** sqlite3 shell. +*/ +static void unknownFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + /* no-op */ + (void)context; + (void)argc; + (void)argv; +} +#endif /*SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION*/ + + +/* IMP: R-25361-16150 This function is omitted from SQLite by default. It +** is only available if the SQLITE_SOUNDEX compile-time option is used +** when SQLite is built. +*/ +#ifdef SQLITE_SOUNDEX +/* +** Compute the soundex encoding of a word. +** +** IMP: R-59782-00072 The soundex(X) function returns a string that is the +** soundex encoding of the string X. +*/ +static void soundexFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + char zResult[8]; + const u8 *zIn; + int i, j; + static const unsigned char iCode[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, + 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, + 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, + }; + assert( argc==1 ); + zIn = (u8*)sqlite3_value_text(argv[0]); + if( zIn==0 ) zIn = (u8*)""; + for(i=0; zIn[i] && !sqlite3Isalpha(zIn[i]); i++){} + if( zIn[i] ){ + u8 prevcode = iCode[zIn[i]&0x7f]; + zResult[0] = sqlite3Toupper(zIn[i]); + for(j=1; j<4 && zIn[i]; i++){ + int code = iCode[zIn[i]&0x7f]; + if( code>0 ){ + if( code!=prevcode ){ + prevcode = code; + zResult[j++] = code + '0'; + } + }else{ + prevcode = 0; + } + } + while( j<4 ){ + zResult[j++] = '0'; + } + zResult[j] = 0; + sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT); + }else{ + /* IMP: R-64894-50321 The string "?000" is returned if the argument + ** is NULL or contains no ASCII alphabetic characters. */ + sqlite3_result_text(context, "?000", 4, SQLITE_STATIC); + } +} +#endif /* SQLITE_SOUNDEX */ + +#ifndef SQLITE_OMIT_LOAD_EXTENSION +/* +** A function that loads a shared-library extension then returns NULL. +*/ +static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){ + const char *zFile = (const char *)sqlite3_value_text(argv[0]); + const char *zProc; + sqlite3 *db = sqlite3_context_db_handle(context); + char *zErrMsg = 0; + + /* Disallow the load_extension() SQL function unless the SQLITE_LoadExtFunc + ** flag is set. See the sqlite3_enable_load_extension() API. + */ + if( (db->flags & SQLITE_LoadExtFunc)==0 ){ + sqlite3_result_error(context, "not authorized", -1); + return; + } + + if( argc==2 ){ + zProc = (const char *)sqlite3_value_text(argv[1]); + }else{ + zProc = 0; + } + if( zFile && sqlite3_load_extension(db, zFile, zProc, &zErrMsg) ){ + sqlite3_result_error(context, zErrMsg, -1); + sqlite3_free(zErrMsg); + } +} +#endif + + +/* +** An instance of the following structure holds the context of a +** sum() or avg() aggregate computation. +*/ +typedef struct SumCtx SumCtx; +struct SumCtx { + double rSum; /* Floating point sum */ + i64 iSum; /* Integer sum */ + i64 cnt; /* Number of elements summed */ + u8 overflow; /* True if integer overflow seen */ + u8 approx; /* True if non-integer value was input to the sum */ +}; + +/* +** Routines used to compute the sum, average, and total. +** +** The SUM() function follows the (broken) SQL standard which means +** that it returns NULL if it sums over no inputs. TOTAL returns +** 0.0 in that case. In addition, TOTAL always returns a float where +** SUM might return an integer if it never encounters a floating point +** value. TOTAL never fails, but SUM might through an exception if +** it overflows an integer. +*/ +static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){ + SumCtx *p; + int type; + assert( argc==1 ); + UNUSED_PARAMETER(argc); + p = sqlite3_aggregate_context(context, sizeof(*p)); + type = sqlite3_value_numeric_type(argv[0]); + if( p && type!=SQLITE_NULL ){ + p->cnt++; + if( type==SQLITE_INTEGER ){ + i64 v = sqlite3_value_int64(argv[0]); + p->rSum += v; + if( (p->approx|p->overflow)==0 && sqlite3AddInt64(&p->iSum, v) ){ + p->approx = p->overflow = 1; + } + }else{ + p->rSum += sqlite3_value_double(argv[0]); + p->approx = 1; + } + } +} +#ifndef SQLITE_OMIT_WINDOWFUNC +static void sumInverse(sqlite3_context *context, int argc, sqlite3_value**argv){ + SumCtx *p; + int type; + assert( argc==1 ); + UNUSED_PARAMETER(argc); + p = sqlite3_aggregate_context(context, sizeof(*p)); + type = sqlite3_value_numeric_type(argv[0]); + /* p is always non-NULL because sumStep() will have been called first + ** to initialize it */ + if( ALWAYS(p) && type!=SQLITE_NULL ){ + assert( p->cnt>0 ); + p->cnt--; + assert( type==SQLITE_INTEGER || p->approx ); + if( type==SQLITE_INTEGER && p->approx==0 ){ + i64 v = sqlite3_value_int64(argv[0]); + p->rSum -= v; + p->iSum -= v; + }else{ + p->rSum -= sqlite3_value_double(argv[0]); + } + } +} +#else +# define sumInverse 0 +#endif /* SQLITE_OMIT_WINDOWFUNC */ +static void sumFinalize(sqlite3_context *context){ + SumCtx *p; + p = sqlite3_aggregate_context(context, 0); + if( p && p->cnt>0 ){ + if( p->overflow ){ + sqlite3_result_error(context,"integer overflow",-1); + }else if( p->approx ){ + sqlite3_result_double(context, p->rSum); + }else{ + sqlite3_result_int64(context, p->iSum); + } + } +} +static void avgFinalize(sqlite3_context *context){ + SumCtx *p; + p = sqlite3_aggregate_context(context, 0); + if( p && p->cnt>0 ){ + sqlite3_result_double(context, p->rSum/(double)p->cnt); + } +} +static void totalFinalize(sqlite3_context *context){ + SumCtx *p; + p = sqlite3_aggregate_context(context, 0); + /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */ + sqlite3_result_double(context, p ? p->rSum : (double)0); +} + +/* +** The following structure keeps track of state information for the +** count() aggregate function. +*/ +typedef struct CountCtx CountCtx; +struct CountCtx { + i64 n; +#ifdef SQLITE_DEBUG + int bInverse; /* True if xInverse() ever called */ +#endif +}; + +/* +** Routines to implement the count() aggregate function. +*/ +static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){ + CountCtx *p; + p = sqlite3_aggregate_context(context, sizeof(*p)); + if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){ + p->n++; + } + +#ifndef SQLITE_OMIT_DEPRECATED + /* The sqlite3_aggregate_count() function is deprecated. But just to make + ** sure it still operates correctly, verify that its count agrees with our + ** internal count when using count(*) and when the total count can be + ** expressed as a 32-bit integer. */ + assert( argc==1 || p==0 || p->n>0x7fffffff || p->bInverse + || p->n==sqlite3_aggregate_count(context) ); +#endif +} +static void countFinalize(sqlite3_context *context){ + CountCtx *p; + p = sqlite3_aggregate_context(context, 0); + sqlite3_result_int64(context, p ? p->n : 0); +} +#ifndef SQLITE_OMIT_WINDOWFUNC +static void countInverse(sqlite3_context *ctx, int argc, sqlite3_value **argv){ + CountCtx *p; + p = sqlite3_aggregate_context(ctx, sizeof(*p)); + /* p is always non-NULL since countStep() will have been called first */ + if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && ALWAYS(p) ){ + p->n--; +#ifdef SQLITE_DEBUG + p->bInverse = 1; +#endif + } +} +#else +# define countInverse 0 +#endif /* SQLITE_OMIT_WINDOWFUNC */ + +/* +** Routines to implement min() and max() aggregate functions. +*/ +static void minmaxStep( + sqlite3_context *context, + int NotUsed, + sqlite3_value **argv +){ + Mem *pArg = (Mem *)argv[0]; + Mem *pBest; + UNUSED_PARAMETER(NotUsed); + + pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest)); + if( !pBest ) return; + + if( sqlite3_value_type(pArg)==SQLITE_NULL ){ + if( pBest->flags ) sqlite3SkipAccumulatorLoad(context); + }else if( pBest->flags ){ + int max; + int cmp; + CollSeq *pColl = sqlite3GetFuncCollSeq(context); + /* This step function is used for both the min() and max() aggregates, + ** the only difference between the two being that the sense of the + ** comparison is inverted. For the max() aggregate, the + ** sqlite3_user_data() function returns (void *)-1. For min() it + ** returns (void *)db, where db is the sqlite3* database pointer. + ** Therefore the next statement sets variable 'max' to 1 for the max() + ** aggregate, or 0 for min(). + */ + max = sqlite3_user_data(context)!=0; + cmp = sqlite3MemCompare(pBest, pArg, pColl); + if( (max && cmp<0) || (!max && cmp>0) ){ + sqlite3VdbeMemCopy(pBest, pArg); + }else{ + sqlite3SkipAccumulatorLoad(context); + } + }else{ + pBest->db = sqlite3_context_db_handle(context); + sqlite3VdbeMemCopy(pBest, pArg); + } +} +static void minMaxValueFinalize(sqlite3_context *context, int bValue){ + sqlite3_value *pRes; + pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0); + if( pRes ){ + if( pRes->flags ){ + sqlite3_result_value(context, pRes); + } + if( bValue==0 ) sqlite3VdbeMemRelease(pRes); + } +} +#ifndef SQLITE_OMIT_WINDOWFUNC +static void minMaxValue(sqlite3_context *context){ + minMaxValueFinalize(context, 1); +} +#else +# define minMaxValue 0 +#endif /* SQLITE_OMIT_WINDOWFUNC */ +static void minMaxFinalize(sqlite3_context *context){ + minMaxValueFinalize(context, 0); +} + +/* +** group_concat(EXPR, ?SEPARATOR?) +** +** The SEPARATOR goes before the EXPR string. This is tragic. The +** groupConcatInverse() implementation would have been easier if the +** SEPARATOR were appended after EXPR. And the order is undocumented, +** so we could change it, in theory. But the old behavior has been +** around for so long that we dare not, for fear of breaking something. +*/ +typedef struct { + StrAccum str; /* The accumulated concatenation */ +#ifndef SQLITE_OMIT_WINDOWFUNC + int nAccum; /* Number of strings presently concatenated */ + int nFirstSepLength; /* Used to detect separator length change */ + /* If pnSepLengths!=0, refs an array of inter-string separator lengths, + ** stored as actually incorporated into presently accumulated result. + ** (Hence, its slots in use number nAccum-1 between method calls.) + ** If pnSepLengths==0, nFirstSepLength is the length used throughout. + */ + int *pnSepLengths; +#endif +} GroupConcatCtx; + +static void groupConcatStep( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const char *zVal; + GroupConcatCtx *pGCC; + const char *zSep; + int nVal, nSep; + assert( argc==1 || argc==2 ); + if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; + pGCC = (GroupConcatCtx*)sqlite3_aggregate_context(context, sizeof(*pGCC)); + if( pGCC ){ + sqlite3 *db = sqlite3_context_db_handle(context); + int firstTerm = pGCC->str.mxAlloc==0; + pGCC->str.mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH]; + if( argc==1 ){ + if( !firstTerm ){ + sqlite3_str_appendchar(&pGCC->str, 1, ','); + } +#ifndef SQLITE_OMIT_WINDOWFUNC + else{ + pGCC->nFirstSepLength = 1; + } +#endif + }else if( !firstTerm ){ + zSep = (char*)sqlite3_value_text(argv[1]); + nSep = sqlite3_value_bytes(argv[1]); + if( zSep ){ + sqlite3_str_append(&pGCC->str, zSep, nSep); + } +#ifndef SQLITE_OMIT_WINDOWFUNC + else{ + nSep = 0; + } + if( nSep != pGCC->nFirstSepLength || pGCC->pnSepLengths != 0 ){ + int *pnsl = pGCC->pnSepLengths; + if( pnsl == 0 ){ + /* First separator length variation seen, start tracking them. */ + pnsl = (int*)sqlite3_malloc64((pGCC->nAccum+1) * sizeof(int)); + if( pnsl!=0 ){ + int i = 0, nA = pGCC->nAccum-1; + while( inFirstSepLength; + } + }else{ + pnsl = (int*)sqlite3_realloc64(pnsl, pGCC->nAccum * sizeof(int)); + } + if( pnsl!=0 ){ + if( ALWAYS(pGCC->nAccum>0) ){ + pnsl[pGCC->nAccum-1] = nSep; + } + pGCC->pnSepLengths = pnsl; + }else{ + sqlite3StrAccumSetError(&pGCC->str, SQLITE_NOMEM); + } + } +#endif + } +#ifndef SQLITE_OMIT_WINDOWFUNC + else{ + pGCC->nFirstSepLength = sqlite3_value_bytes(argv[1]); + } + pGCC->nAccum += 1; +#endif + zVal = (char*)sqlite3_value_text(argv[0]); + nVal = sqlite3_value_bytes(argv[0]); + if( zVal ) sqlite3_str_append(&pGCC->str, zVal, nVal); + } +} + +#ifndef SQLITE_OMIT_WINDOWFUNC +static void groupConcatInverse( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + GroupConcatCtx *pGCC; + assert( argc==1 || argc==2 ); + (void)argc; /* Suppress unused parameter warning */ + if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; + pGCC = (GroupConcatCtx*)sqlite3_aggregate_context(context, sizeof(*pGCC)); + /* pGCC is always non-NULL since groupConcatStep() will have always + ** run frist to initialize it */ + if( ALWAYS(pGCC) ){ + int nVS; + /* Must call sqlite3_value_text() to convert the argument into text prior + ** to invoking sqlite3_value_bytes(), in case the text encoding is UTF16 */ + (void)sqlite3_value_text(argv[0]); + nVS = sqlite3_value_bytes(argv[0]); + pGCC->nAccum -= 1; + if( pGCC->pnSepLengths!=0 ){ + assert(pGCC->nAccum >= 0); + if( pGCC->nAccum>0 ){ + nVS += *pGCC->pnSepLengths; + memmove(pGCC->pnSepLengths, pGCC->pnSepLengths+1, + (pGCC->nAccum-1)*sizeof(int)); + } + }else{ + /* If removing single accumulated string, harmlessly over-do. */ + nVS += pGCC->nFirstSepLength; + } + if( nVS>=(int)pGCC->str.nChar ){ + pGCC->str.nChar = 0; + }else{ + pGCC->str.nChar -= nVS; + memmove(pGCC->str.zText, &pGCC->str.zText[nVS], pGCC->str.nChar); + } + if( pGCC->str.nChar==0 ){ + pGCC->str.mxAlloc = 0; + sqlite3_free(pGCC->pnSepLengths); + pGCC->pnSepLengths = 0; + } + } +} +#else +# define groupConcatInverse 0 +#endif /* SQLITE_OMIT_WINDOWFUNC */ +static void groupConcatFinalize(sqlite3_context *context){ + GroupConcatCtx *pGCC + = (GroupConcatCtx*)sqlite3_aggregate_context(context, 0); + if( pGCC ){ + sqlite3ResultStrAccum(context, &pGCC->str); +#ifndef SQLITE_OMIT_WINDOWFUNC + sqlite3_free(pGCC->pnSepLengths); +#endif + } +} +#ifndef SQLITE_OMIT_WINDOWFUNC +static void groupConcatValue(sqlite3_context *context){ + GroupConcatCtx *pGCC + = (GroupConcatCtx*)sqlite3_aggregate_context(context, 0); + if( pGCC ){ + StrAccum *pAccum = &pGCC->str; + if( pAccum->accError==SQLITE_TOOBIG ){ + sqlite3_result_error_toobig(context); + }else if( pAccum->accError==SQLITE_NOMEM ){ + sqlite3_result_error_nomem(context); + }else{ + const char *zText = sqlite3_str_value(pAccum); + sqlite3_result_text(context, zText, pAccum->nChar, SQLITE_TRANSIENT); + } + } +} +#else +# define groupConcatValue 0 +#endif /* SQLITE_OMIT_WINDOWFUNC */ + +/* +** This routine does per-connection function registration. Most +** of the built-in functions above are part of the global function set. +** This routine only deals with those that are not global. +*/ +SQLITE_PRIVATE void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3 *db){ + int rc = sqlite3_overload_function(db, "MATCH", 2); + assert( rc==SQLITE_NOMEM || rc==SQLITE_OK ); + if( rc==SQLITE_NOMEM ){ + sqlite3OomFault(db); + } +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC + { + extern void sqlcipher_exportFunc(sqlite3_context *, int, sqlite3_value **); + sqlite3CreateFunc(db, "sqlcipher_export", -1, SQLITE_TEXT, 0, sqlcipher_exportFunc, 0, 0, 0, 0, 0); + } +#ifdef SQLCIPHER_EXT +#include "sqlcipher_funcs_init.h" +#endif +#endif +/* END SQLCIPHER */ +} + +/* +** Re-register the built-in LIKE functions. The caseSensitive +** parameter determines whether or not the LIKE operator is case +** sensitive. +*/ +SQLITE_PRIVATE void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){ + struct compareInfo *pInfo; + int flags; + if( caseSensitive ){ + pInfo = (struct compareInfo*)&likeInfoAlt; + flags = SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE; + }else{ + pInfo = (struct compareInfo*)&likeInfoNorm; + flags = SQLITE_FUNC_LIKE; + } + sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0, 0, 0); + sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0, 0, 0); + sqlite3FindFunction(db, "like", 2, SQLITE_UTF8, 0)->funcFlags |= flags; + sqlite3FindFunction(db, "like", 3, SQLITE_UTF8, 0)->funcFlags |= flags; +} + +/* +** pExpr points to an expression which implements a function. If +** it is appropriate to apply the LIKE optimization to that function +** then set aWc[0] through aWc[2] to the wildcard characters and the +** escape character and then return TRUE. If the function is not a +** LIKE-style function then return FALSE. +** +** The expression "a LIKE b ESCAPE c" is only considered a valid LIKE +** operator if c is a string literal that is exactly one byte in length. +** That one byte is stored in aWc[3]. aWc[3] is set to zero if there is +** no ESCAPE clause. +** +** *pIsNocase is set to true if uppercase and lowercase are equivalent for +** the function (default for LIKE). If the function makes the distinction +** between uppercase and lowercase (as does GLOB) then *pIsNocase is set to +** false. +*/ +SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){ + FuncDef *pDef; + int nExpr; + assert( pExpr!=0 ); + assert( pExpr->op==TK_FUNCTION ); + assert( ExprUseXList(pExpr) ); + if( !pExpr->x.pList ){ + return 0; + } + nExpr = pExpr->x.pList->nExpr; + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + pDef = sqlite3FindFunction(db, pExpr->u.zToken, nExpr, SQLITE_UTF8, 0); +#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION + if( pDef==0 ) return 0; +#endif + if( NEVER(pDef==0) || (pDef->funcFlags & SQLITE_FUNC_LIKE)==0 ){ + return 0; + } + + /* The memcpy() statement assumes that the wildcard characters are + ** the first three statements in the compareInfo structure. The + ** asserts() that follow verify that assumption + */ + memcpy(aWc, pDef->pUserData, 3); + assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll ); + assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne ); + assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet ); + + if( nExpr<3 ){ + aWc[3] = 0; + }else{ + Expr *pEscape = pExpr->x.pList->a[2].pExpr; + char *zEscape; + if( pEscape->op!=TK_STRING ) return 0; + assert( !ExprHasProperty(pEscape, EP_IntValue) ); + zEscape = pEscape->u.zToken; + if( zEscape[0]==0 || zEscape[1]!=0 ) return 0; + if( zEscape[0]==aWc[0] ) return 0; + if( zEscape[0]==aWc[1] ) return 0; + aWc[3] = zEscape[0]; + } + + *pIsNocase = (pDef->funcFlags & SQLITE_FUNC_CASE)==0; + return 1; +} + +/* Mathematical Constants */ +#ifndef M_PI +# define M_PI 3.141592653589793238462643383279502884 +#endif +#ifndef M_LN10 +# define M_LN10 2.302585092994045684017991454684364208 +#endif +#ifndef M_LN2 +# define M_LN2 0.693147180559945309417232121458176568 +#endif + + +/* Extra math functions that require linking with -lm +*/ +#ifdef SQLITE_ENABLE_MATH_FUNCTIONS +/* +** Implementation SQL functions: +** +** ceil(X) +** ceiling(X) +** floor(X) +** +** The sqlite3_user_data() pointer is a pointer to the libm implementation +** of the underlying C function. +*/ +static void ceilingFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + assert( argc==1 ); + switch( sqlite3_value_numeric_type(argv[0]) ){ + case SQLITE_INTEGER: { + sqlite3_result_int64(context, sqlite3_value_int64(argv[0])); + break; + } + case SQLITE_FLOAT: { + double (*x)(double) = (double(*)(double))sqlite3_user_data(context); + sqlite3_result_double(context, x(sqlite3_value_double(argv[0]))); + break; + } + default: { + break; + } + } +} + +/* +** On some systems, ceil() and floor() are intrinsic function. You are +** unable to take a pointer to these functions. Hence, we here wrap them +** in our own actual functions. +*/ +static double xCeil(double x){ return ceil(x); } +static double xFloor(double x){ return floor(x); } + +/* +** Some systems do not have log2() and log10() in their standard math +** libraries. +*/ +#if defined(HAVE_LOG10) && HAVE_LOG10==0 +# define log10(X) (0.4342944819032517867*log(X)) +#endif +#if defined(HAVE_LOG2) && HAVE_LOG2==0 +# define log2(X) (1.442695040888963456*log(X)) +#endif + + +/* +** Implementation of SQL functions: +** +** ln(X) - natural logarithm +** log(X) - log X base 10 +** log10(X) - log X base 10 +** log(B,X) - log X base B +*/ +static void logFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + double x, b, ans; + assert( argc==1 || argc==2 ); + switch( sqlite3_value_numeric_type(argv[0]) ){ + case SQLITE_INTEGER: + case SQLITE_FLOAT: + x = sqlite3_value_double(argv[0]); + if( x<=0.0 ) return; + break; + default: + return; + } + if( argc==2 ){ + switch( sqlite3_value_numeric_type(argv[0]) ){ + case SQLITE_INTEGER: + case SQLITE_FLOAT: + b = log(x); + if( b<=0.0 ) return; + x = sqlite3_value_double(argv[1]); + if( x<=0.0 ) return; + break; + default: + return; + } + ans = log(x)/b; + }else{ + switch( SQLITE_PTR_TO_INT(sqlite3_user_data(context)) ){ + case 1: + ans = log10(x); + break; + case 2: + ans = log2(x); + break; + default: + ans = log(x); + break; + } + } + sqlite3_result_double(context, ans); +} + +/* +** Functions to converts degrees to radians and radians to degrees. +*/ +static double degToRad(double x){ return x*(M_PI/180.0); } +static double radToDeg(double x){ return x*(180.0/M_PI); } + +/* +** Implementation of 1-argument SQL math functions: +** +** exp(X) - Compute e to the X-th power +*/ +static void math1Func( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int type0; + double v0, ans; + double (*x)(double); + assert( argc==1 ); + type0 = sqlite3_value_numeric_type(argv[0]); + if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return; + v0 = sqlite3_value_double(argv[0]); + x = (double(*)(double))sqlite3_user_data(context); + ans = x(v0); + sqlite3_result_double(context, ans); +} + +/* +** Implementation of 2-argument SQL math functions: +** +** power(X,Y) - Compute X to the Y-th power +*/ +static void math2Func( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int type0, type1; + double v0, v1, ans; + double (*x)(double,double); + assert( argc==2 ); + type0 = sqlite3_value_numeric_type(argv[0]); + if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return; + type1 = sqlite3_value_numeric_type(argv[1]); + if( type1!=SQLITE_INTEGER && type1!=SQLITE_FLOAT ) return; + v0 = sqlite3_value_double(argv[0]); + v1 = sqlite3_value_double(argv[1]); + x = (double(*)(double,double))sqlite3_user_data(context); + ans = x(v0, v1); + sqlite3_result_double(context, ans); +} + +/* +** Implementation of 0-argument pi() function. +*/ +static void piFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + assert( argc==0 ); + (void)argv; + sqlite3_result_double(context, M_PI); +} + +#endif /* SQLITE_ENABLE_MATH_FUNCTIONS */ + +/* +** Implementation of sign(X) function. +*/ +static void signFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int type0; + double x; + UNUSED_PARAMETER(argc); + assert( argc==1 ); + type0 = sqlite3_value_numeric_type(argv[0]); + if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return; + x = sqlite3_value_double(argv[0]); + sqlite3_result_int(context, x<0.0 ? -1 : x>0.0 ? +1 : 0); +} + +/* +** All of the FuncDef structures in the aBuiltinFunc[] array above +** to the global function hash table. This occurs at start-time (as +** a consequence of calling sqlite3_initialize()). +** +** After this routine runs +*/ +SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(void){ + /* + ** The following array holds FuncDef structures for all of the functions + ** defined in this file. + ** + ** The array cannot be constant since changes are made to the + ** FuncDef.pHash elements at start-time. The elements of this array + ** are read-only after initialization is complete. + ** + ** For peak efficiency, put the most frequently used function last. + */ + static FuncDef aBuiltinFunc[] = { +/***** Functions only available with SQLITE_TESTCTRL_INTERNAL_FUNCTIONS *****/ +#if !defined(SQLITE_UNTESTABLE) + TEST_FUNC(implies_nonnull_row, 2, INLINEFUNC_implies_nonnull_row, 0), + TEST_FUNC(expr_compare, 2, INLINEFUNC_expr_compare, 0), + TEST_FUNC(expr_implies_expr, 2, INLINEFUNC_expr_implies_expr, 0), + TEST_FUNC(affinity, 1, INLINEFUNC_affinity, 0), +#endif /* !defined(SQLITE_UNTESTABLE) */ +/***** Regular functions *****/ +#ifdef SQLITE_SOUNDEX + FUNCTION(soundex, 1, 0, 0, soundexFunc ), +#endif +#ifndef SQLITE_OMIT_LOAD_EXTENSION + SFUNCTION(load_extension, 1, 0, 0, loadExt ), + SFUNCTION(load_extension, 2, 0, 0, loadExt ), +#endif +#if SQLITE_USER_AUTHENTICATION + FUNCTION(sqlite_crypt, 2, 0, 0, sqlite3CryptFunc ), +#endif +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS + DFUNCTION(sqlite_compileoption_used,1, 0, 0, compileoptionusedFunc ), + DFUNCTION(sqlite_compileoption_get, 1, 0, 0, compileoptiongetFunc ), +#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ + INLINE_FUNC(unlikely, 1, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY), + INLINE_FUNC(likelihood, 2, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY), + INLINE_FUNC(likely, 1, INLINEFUNC_unlikely, SQLITE_FUNC_UNLIKELY), +#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC + INLINE_FUNC(sqlite_offset, 1, INLINEFUNC_sqlite_offset, 0 ), +#endif + FUNCTION(ltrim, 1, 1, 0, trimFunc ), + FUNCTION(ltrim, 2, 1, 0, trimFunc ), + FUNCTION(rtrim, 1, 2, 0, trimFunc ), + FUNCTION(rtrim, 2, 2, 0, trimFunc ), + FUNCTION(trim, 1, 3, 0, trimFunc ), + FUNCTION(trim, 2, 3, 0, trimFunc ), + FUNCTION(min, -1, 0, 1, minmaxFunc ), + FUNCTION(min, 0, 0, 1, 0 ), + WAGGREGATE(min, 1, 0, 1, minmaxStep, minMaxFinalize, minMaxValue, 0, + SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER ), + FUNCTION(max, -1, 1, 1, minmaxFunc ), + FUNCTION(max, 0, 1, 1, 0 ), + WAGGREGATE(max, 1, 1, 1, minmaxStep, minMaxFinalize, minMaxValue, 0, + SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER ), + FUNCTION2(typeof, 1, 0, 0, typeofFunc, SQLITE_FUNC_TYPEOF), + FUNCTION2(subtype, 1, 0, 0, subtypeFunc, SQLITE_FUNC_TYPEOF), + FUNCTION2(length, 1, 0, 0, lengthFunc, SQLITE_FUNC_LENGTH), + FUNCTION(instr, 2, 0, 0, instrFunc ), + FUNCTION(printf, -1, 0, 0, printfFunc ), + FUNCTION(format, -1, 0, 0, printfFunc ), + FUNCTION(unicode, 1, 0, 0, unicodeFunc ), + FUNCTION(char, -1, 0, 0, charFunc ), + FUNCTION(abs, 1, 0, 0, absFunc ), +#ifndef SQLITE_OMIT_FLOATING_POINT + FUNCTION(round, 1, 0, 0, roundFunc ), + FUNCTION(round, 2, 0, 0, roundFunc ), +#endif + FUNCTION(upper, 1, 0, 0, upperFunc ), + FUNCTION(lower, 1, 0, 0, lowerFunc ), + FUNCTION(hex, 1, 0, 0, hexFunc ), + FUNCTION(unhex, 1, 0, 0, unhexFunc ), + FUNCTION(unhex, 2, 0, 0, unhexFunc ), + INLINE_FUNC(ifnull, 2, INLINEFUNC_coalesce, 0 ), + VFUNCTION(random, 0, 0, 0, randomFunc ), + VFUNCTION(randomblob, 1, 0, 0, randomBlob ), + FUNCTION(nullif, 2, 0, 1, nullifFunc ), + DFUNCTION(sqlite_version, 0, 0, 0, versionFunc ), + DFUNCTION(sqlite_source_id, 0, 0, 0, sourceidFunc ), + FUNCTION(sqlite_log, 2, 0, 0, errlogFunc ), + FUNCTION(quote, 1, 0, 0, quoteFunc ), + VFUNCTION(last_insert_rowid, 0, 0, 0, last_insert_rowid), + VFUNCTION(changes, 0, 0, 0, changes ), + VFUNCTION(total_changes, 0, 0, 0, total_changes ), + FUNCTION(replace, 3, 0, 0, replaceFunc ), + FUNCTION(zeroblob, 1, 0, 0, zeroblobFunc ), + FUNCTION(substr, 2, 0, 0, substrFunc ), + FUNCTION(substr, 3, 0, 0, substrFunc ), + FUNCTION(substring, 2, 0, 0, substrFunc ), + FUNCTION(substring, 3, 0, 0, substrFunc ), + WAGGREGATE(sum, 1,0,0, sumStep, sumFinalize, sumFinalize, sumInverse, 0), + WAGGREGATE(total, 1,0,0, sumStep,totalFinalize,totalFinalize,sumInverse, 0), + WAGGREGATE(avg, 1,0,0, sumStep, avgFinalize, avgFinalize, sumInverse, 0), + WAGGREGATE(count, 0,0,0, countStep, + countFinalize, countFinalize, countInverse, + SQLITE_FUNC_COUNT|SQLITE_FUNC_ANYORDER ), + WAGGREGATE(count, 1,0,0, countStep, + countFinalize, countFinalize, countInverse, SQLITE_FUNC_ANYORDER ), + WAGGREGATE(group_concat, 1, 0, 0, groupConcatStep, + groupConcatFinalize, groupConcatValue, groupConcatInverse, 0), + WAGGREGATE(group_concat, 2, 0, 0, groupConcatStep, + groupConcatFinalize, groupConcatValue, groupConcatInverse, 0), + + LIKEFUNC(glob, 2, &globInfo, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), +#ifdef SQLITE_CASE_SENSITIVE_LIKE + LIKEFUNC(like, 2, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), + LIKEFUNC(like, 3, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE), +#else + LIKEFUNC(like, 2, &likeInfoNorm, SQLITE_FUNC_LIKE), + LIKEFUNC(like, 3, &likeInfoNorm, SQLITE_FUNC_LIKE), +#endif +#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION + FUNCTION(unknown, -1, 0, 0, unknownFunc ), +#endif + FUNCTION(coalesce, 1, 0, 0, 0 ), + FUNCTION(coalesce, 0, 0, 0, 0 ), +#ifdef SQLITE_ENABLE_MATH_FUNCTIONS + MFUNCTION(ceil, 1, xCeil, ceilingFunc ), + MFUNCTION(ceiling, 1, xCeil, ceilingFunc ), + MFUNCTION(floor, 1, xFloor, ceilingFunc ), +#if SQLITE_HAVE_C99_MATH_FUNCS + MFUNCTION(trunc, 1, trunc, ceilingFunc ), +#endif + FUNCTION(ln, 1, 0, 0, logFunc ), + FUNCTION(log, 1, 1, 0, logFunc ), + FUNCTION(log10, 1, 1, 0, logFunc ), + FUNCTION(log2, 1, 2, 0, logFunc ), + FUNCTION(log, 2, 0, 0, logFunc ), + MFUNCTION(exp, 1, exp, math1Func ), + MFUNCTION(pow, 2, pow, math2Func ), + MFUNCTION(power, 2, pow, math2Func ), + MFUNCTION(mod, 2, fmod, math2Func ), + MFUNCTION(acos, 1, acos, math1Func ), + MFUNCTION(asin, 1, asin, math1Func ), + MFUNCTION(atan, 1, atan, math1Func ), + MFUNCTION(atan2, 2, atan2, math2Func ), + MFUNCTION(cos, 1, cos, math1Func ), + MFUNCTION(sin, 1, sin, math1Func ), + MFUNCTION(tan, 1, tan, math1Func ), + MFUNCTION(cosh, 1, cosh, math1Func ), + MFUNCTION(sinh, 1, sinh, math1Func ), + MFUNCTION(tanh, 1, tanh, math1Func ), +#if SQLITE_HAVE_C99_MATH_FUNCS + MFUNCTION(acosh, 1, acosh, math1Func ), + MFUNCTION(asinh, 1, asinh, math1Func ), + MFUNCTION(atanh, 1, atanh, math1Func ), +#endif + MFUNCTION(sqrt, 1, sqrt, math1Func ), + MFUNCTION(radians, 1, degToRad, math1Func ), + MFUNCTION(degrees, 1, radToDeg, math1Func ), + FUNCTION(pi, 0, 0, 0, piFunc ), +#endif /* SQLITE_ENABLE_MATH_FUNCTIONS */ + FUNCTION(sign, 1, 0, 0, signFunc ), + INLINE_FUNC(coalesce, -1, INLINEFUNC_coalesce, 0 ), + INLINE_FUNC(iif, 3, INLINEFUNC_iif, 0 ), + }; +#ifndef SQLITE_OMIT_ALTERTABLE + sqlite3AlterFunctions(); +#endif + sqlite3WindowFunctions(); + sqlite3RegisterDateTimeFunctions(); + sqlite3RegisterJsonFunctions(); + sqlite3InsertBuiltinFuncs(aBuiltinFunc, ArraySize(aBuiltinFunc)); + +#if 0 /* Enable to print out how the built-in functions are hashed */ + { + int i; + FuncDef *p; + for(i=0; iu.pHash){ + int n = sqlite3Strlen30(p->zName); + int h = p->zName[0] + n; + assert( p->funcFlags & SQLITE_FUNC_BUILTIN ); + printf(" %s(%d)", p->zName, h); + } + printf("\n"); + } + } +#endif +} + +/************** End of func.c ************************************************/ +/************** Begin file fkey.c ********************************************/ +/* +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used by the compiler to add foreign key +** support to compiled SQL statements. +*/ +/* #include "sqliteInt.h" */ + +#ifndef SQLITE_OMIT_FOREIGN_KEY +#ifndef SQLITE_OMIT_TRIGGER + +/* +** Deferred and Immediate FKs +** -------------------------- +** +** Foreign keys in SQLite come in two flavours: deferred and immediate. +** If an immediate foreign key constraint is violated, +** SQLITE_CONSTRAINT_FOREIGNKEY is returned and the current +** statement transaction rolled back. If a +** deferred foreign key constraint is violated, no action is taken +** immediately. However if the application attempts to commit the +** transaction before fixing the constraint violation, the attempt fails. +** +** Deferred constraints are implemented using a simple counter associated +** with the database handle. The counter is set to zero each time a +** database transaction is opened. Each time a statement is executed +** that causes a foreign key violation, the counter is incremented. Each +** time a statement is executed that removes an existing violation from +** the database, the counter is decremented. When the transaction is +** committed, the commit fails if the current value of the counter is +** greater than zero. This scheme has two big drawbacks: +** +** * When a commit fails due to a deferred foreign key constraint, +** there is no way to tell which foreign constraint is not satisfied, +** or which row it is not satisfied for. +** +** * If the database contains foreign key violations when the +** transaction is opened, this may cause the mechanism to malfunction. +** +** Despite these problems, this approach is adopted as it seems simpler +** than the alternatives. +** +** INSERT operations: +** +** I.1) For each FK for which the table is the child table, search +** the parent table for a match. If none is found increment the +** constraint counter. +** +** I.2) For each FK for which the table is the parent table, +** search the child table for rows that correspond to the new +** row in the parent table. Decrement the counter for each row +** found (as the constraint is now satisfied). +** +** DELETE operations: +** +** D.1) For each FK for which the table is the child table, +** search the parent table for a row that corresponds to the +** deleted row in the child table. If such a row is not found, +** decrement the counter. +** +** D.2) For each FK for which the table is the parent table, search +** the child table for rows that correspond to the deleted row +** in the parent table. For each found increment the counter. +** +** UPDATE operations: +** +** An UPDATE command requires that all 4 steps above are taken, but only +** for FK constraints for which the affected columns are actually +** modified (values must be compared at runtime). +** +** Note that I.1 and D.1 are very similar operations, as are I.2 and D.2. +** This simplifies the implementation a bit. +** +** For the purposes of immediate FK constraints, the OR REPLACE conflict +** resolution is considered to delete rows before the new row is inserted. +** If a delete caused by OR REPLACE violates an FK constraint, an exception +** is thrown, even if the FK constraint would be satisfied after the new +** row is inserted. +** +** Immediate constraints are usually handled similarly. The only difference +** is that the counter used is stored as part of each individual statement +** object (struct Vdbe). If, after the statement has run, its immediate +** constraint counter is greater than zero, +** it returns SQLITE_CONSTRAINT_FOREIGNKEY +** and the statement transaction is rolled back. An exception is an INSERT +** statement that inserts a single row only (no triggers). In this case, +** instead of using a counter, an exception is thrown immediately if the +** INSERT violates a foreign key constraint. This is necessary as such +** an INSERT does not open a statement transaction. +** +** TODO: How should dropping a table be handled? How should renaming a +** table be handled? +** +** +** Query API Notes +** --------------- +** +** Before coding an UPDATE or DELETE row operation, the code-generator +** for those two operations needs to know whether or not the operation +** requires any FK processing and, if so, which columns of the original +** row are required by the FK processing VDBE code (i.e. if FKs were +** implemented using triggers, which of the old.* columns would be +** accessed). No information is required by the code-generator before +** coding an INSERT operation. The functions used by the UPDATE/DELETE +** generation code to query for this information are: +** +** sqlite3FkRequired() - Test to see if FK processing is required. +** sqlite3FkOldmask() - Query for the set of required old.* columns. +** +** +** Externally accessible module functions +** -------------------------------------- +** +** sqlite3FkCheck() - Check for foreign key violations. +** sqlite3FkActions() - Code triggers for ON UPDATE/ON DELETE actions. +** sqlite3FkDelete() - Delete an FKey structure. +*/ + +/* +** VDBE Calling Convention +** ----------------------- +** +** Example: +** +** For the following INSERT statement: +** +** CREATE TABLE t1(a, b INTEGER PRIMARY KEY, c); +** INSERT INTO t1 VALUES(1, 2, 3.1); +** +** Register (x): 2 (type integer) +** Register (x+1): 1 (type integer) +** Register (x+2): NULL (type NULL) +** Register (x+3): 3.1 (type real) +*/ + +/* +** A foreign key constraint requires that the key columns in the parent +** table are collectively subject to a UNIQUE or PRIMARY KEY constraint. +** Given that pParent is the parent table for foreign key constraint pFKey, +** search the schema for a unique index on the parent key columns. +** +** If successful, zero is returned. If the parent key is an INTEGER PRIMARY +** KEY column, then output variable *ppIdx is set to NULL. Otherwise, *ppIdx +** is set to point to the unique index. +** +** If the parent key consists of a single column (the foreign key constraint +** is not a composite foreign key), output variable *paiCol is set to NULL. +** Otherwise, it is set to point to an allocated array of size N, where +** N is the number of columns in the parent key. The first element of the +** array is the index of the child table column that is mapped by the FK +** constraint to the parent table column stored in the left-most column +** of index *ppIdx. The second element of the array is the index of the +** child table column that corresponds to the second left-most column of +** *ppIdx, and so on. +** +** If the required index cannot be found, either because: +** +** 1) The named parent key columns do not exist, or +** +** 2) The named parent key columns do exist, but are not subject to a +** UNIQUE or PRIMARY KEY constraint, or +** +** 3) No parent key columns were provided explicitly as part of the +** foreign key definition, and the parent table does not have a +** PRIMARY KEY, or +** +** 4) No parent key columns were provided explicitly as part of the +** foreign key definition, and the PRIMARY KEY of the parent table +** consists of a different number of columns to the child key in +** the child table. +** +** then non-zero is returned, and a "foreign key mismatch" error loaded +** into pParse. If an OOM error occurs, non-zero is returned and the +** pParse->db->mallocFailed flag is set. +*/ +SQLITE_PRIVATE int sqlite3FkLocateIndex( + Parse *pParse, /* Parse context to store any error in */ + Table *pParent, /* Parent table of FK constraint pFKey */ + FKey *pFKey, /* Foreign key to find index for */ + Index **ppIdx, /* OUT: Unique index on parent table */ + int **paiCol /* OUT: Map of index columns in pFKey */ +){ + Index *pIdx = 0; /* Value to return via *ppIdx */ + int *aiCol = 0; /* Value to return via *paiCol */ + int nCol = pFKey->nCol; /* Number of columns in parent key */ + char *zKey = pFKey->aCol[0].zCol; /* Name of left-most parent key column */ + + /* The caller is responsible for zeroing output parameters. */ + assert( ppIdx && *ppIdx==0 ); + assert( !paiCol || *paiCol==0 ); + assert( pParse ); + + /* If this is a non-composite (single column) foreign key, check if it + ** maps to the INTEGER PRIMARY KEY of table pParent. If so, leave *ppIdx + ** and *paiCol set to zero and return early. + ** + ** Otherwise, for a composite foreign key (more than one column), allocate + ** space for the aiCol array (returned via output parameter *paiCol). + ** Non-composite foreign keys do not require the aiCol array. + */ + if( nCol==1 ){ + /* The FK maps to the IPK if any of the following are true: + ** + ** 1) There is an INTEGER PRIMARY KEY column and the FK is implicitly + ** mapped to the primary key of table pParent, or + ** 2) The FK is explicitly mapped to a column declared as INTEGER + ** PRIMARY KEY. + */ + if( pParent->iPKey>=0 ){ + if( !zKey ) return 0; + if( !sqlite3StrICmp(pParent->aCol[pParent->iPKey].zCnName, zKey) ){ + return 0; + } + } + }else if( paiCol ){ + assert( nCol>1 ); + aiCol = (int *)sqlite3DbMallocRawNN(pParse->db, nCol*sizeof(int)); + if( !aiCol ) return 1; + *paiCol = aiCol; + } + + for(pIdx=pParent->pIndex; pIdx; pIdx=pIdx->pNext){ + if( pIdx->nKeyCol==nCol && IsUniqueIndex(pIdx) && pIdx->pPartIdxWhere==0 ){ + /* pIdx is a UNIQUE index (or a PRIMARY KEY) and has the right number + ** of columns. If each indexed column corresponds to a foreign key + ** column of pFKey, then this index is a winner. */ + + if( zKey==0 ){ + /* If zKey is NULL, then this foreign key is implicitly mapped to + ** the PRIMARY KEY of table pParent. The PRIMARY KEY index may be + ** identified by the test. */ + if( IsPrimaryKeyIndex(pIdx) ){ + if( aiCol ){ + int i; + for(i=0; iaCol[i].iFrom; + } + break; + } + }else{ + /* If zKey is non-NULL, then this foreign key was declared to + ** map to an explicit list of columns in table pParent. Check if this + ** index matches those columns. Also, check that the index uses + ** the default collation sequences for each column. */ + int i, j; + for(i=0; iaiColumn[i]; /* Index of column in parent tbl */ + const char *zDfltColl; /* Def. collation for column */ + char *zIdxCol; /* Name of indexed column */ + + if( iCol<0 ) break; /* No foreign keys against expression indexes */ + + /* If the index uses a collation sequence that is different from + ** the default collation sequence for the column, this index is + ** unusable. Bail out early in this case. */ + zDfltColl = sqlite3ColumnColl(&pParent->aCol[iCol]); + if( !zDfltColl ) zDfltColl = sqlite3StrBINARY; + if( sqlite3StrICmp(pIdx->azColl[i], zDfltColl) ) break; + + zIdxCol = pParent->aCol[iCol].zCnName; + for(j=0; jaCol[j].zCol, zIdxCol)==0 ){ + if( aiCol ) aiCol[i] = pFKey->aCol[j].iFrom; + break; + } + } + if( j==nCol ) break; + } + if( i==nCol ) break; /* pIdx is usable */ + } + } + } + + if( !pIdx ){ + if( !pParse->disableTriggers ){ + sqlite3ErrorMsg(pParse, + "foreign key mismatch - \"%w\" referencing \"%w\"", + pFKey->pFrom->zName, pFKey->zTo); + } + sqlite3DbFree(pParse->db, aiCol); + return 1; + } + + *ppIdx = pIdx; + return 0; +} + +/* +** This function is called when a row is inserted into or deleted from the +** child table of foreign key constraint pFKey. If an SQL UPDATE is executed +** on the child table of pFKey, this function is invoked twice for each row +** affected - once to "delete" the old row, and then again to "insert" the +** new row. +** +** Each time it is called, this function generates VDBE code to locate the +** row in the parent table that corresponds to the row being inserted into +** or deleted from the child table. If the parent row can be found, no +** special action is taken. Otherwise, if the parent row can *not* be +** found in the parent table: +** +** Operation | FK type | Action taken +** -------------------------------------------------------------------------- +** INSERT immediate Increment the "immediate constraint counter". +** +** DELETE immediate Decrement the "immediate constraint counter". +** +** INSERT deferred Increment the "deferred constraint counter". +** +** DELETE deferred Decrement the "deferred constraint counter". +** +** These operations are identified in the comment at the top of this file +** (fkey.c) as "I.1" and "D.1". +*/ +static void fkLookupParent( + Parse *pParse, /* Parse context */ + int iDb, /* Index of database housing pTab */ + Table *pTab, /* Parent table of FK pFKey */ + Index *pIdx, /* Unique index on parent key columns in pTab */ + FKey *pFKey, /* Foreign key constraint */ + int *aiCol, /* Map from parent key columns to child table columns */ + int regData, /* Address of array containing child table row */ + int nIncr, /* Increment constraint counter by this */ + int isIgnore /* If true, pretend pTab contains all NULL values */ +){ + int i; /* Iterator variable */ + Vdbe *v = sqlite3GetVdbe(pParse); /* Vdbe to add code to */ + int iCur = pParse->nTab - 1; /* Cursor number to use */ + int iOk = sqlite3VdbeMakeLabel(pParse); /* jump here if parent key found */ + + sqlite3VdbeVerifyAbortable(v, + (!pFKey->isDeferred + && !(pParse->db->flags & SQLITE_DeferFKs) + && !pParse->pToplevel + && !pParse->isMultiWrite) ? OE_Abort : OE_Ignore); + + /* If nIncr is less than zero, then check at runtime if there are any + ** outstanding constraints to resolve. If there are not, there is no need + ** to check if deleting this row resolves any outstanding violations. + ** + ** Check if any of the key columns in the child table row are NULL. If + ** any are, then the constraint is considered satisfied. No need to + ** search for a matching row in the parent table. */ + if( nIncr<0 ){ + sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, iOk); + VdbeCoverage(v); + } + for(i=0; inCol; i++){ + int iReg = sqlite3TableColumnToStorage(pFKey->pFrom,aiCol[i]) + regData + 1; + sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iOk); VdbeCoverage(v); + } + + if( isIgnore==0 ){ + if( pIdx==0 ){ + /* If pIdx is NULL, then the parent key is the INTEGER PRIMARY KEY + ** column of the parent table (table pTab). */ + int iMustBeInt; /* Address of MustBeInt instruction */ + int regTemp = sqlite3GetTempReg(pParse); + + /* Invoke MustBeInt to coerce the child key value to an integer (i.e. + ** apply the affinity of the parent key). If this fails, then there + ** is no matching parent key. Before using MustBeInt, make a copy of + ** the value. Otherwise, the value inserted into the child key column + ** will have INTEGER affinity applied to it, which may not be correct. */ + sqlite3VdbeAddOp2(v, OP_SCopy, + sqlite3TableColumnToStorage(pFKey->pFrom,aiCol[0])+1+regData, regTemp); + iMustBeInt = sqlite3VdbeAddOp2(v, OP_MustBeInt, regTemp, 0); + VdbeCoverage(v); + + /* If the parent table is the same as the child table, and we are about + ** to increment the constraint-counter (i.e. this is an INSERT operation), + ** then check if the row being inserted matches itself. If so, do not + ** increment the constraint-counter. */ + if( pTab==pFKey->pFrom && nIncr==1 ){ + sqlite3VdbeAddOp3(v, OP_Eq, regData, iOk, regTemp); VdbeCoverage(v); + sqlite3VdbeChangeP5(v, SQLITE_NOTNULL); + } + + sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead); + sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, regTemp); VdbeCoverage(v); + sqlite3VdbeGoto(v, iOk); + sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2); + sqlite3VdbeJumpHere(v, iMustBeInt); + sqlite3ReleaseTempReg(pParse, regTemp); + }else{ + int nCol = pFKey->nCol; + int regTemp = sqlite3GetTempRange(pParse, nCol); + + sqlite3VdbeAddOp3(v, OP_OpenRead, iCur, pIdx->tnum, iDb); + sqlite3VdbeSetP4KeyInfo(pParse, pIdx); + for(i=0; ipFrom, aiCol[i])+1+regData, + regTemp+i); + } + + /* If the parent table is the same as the child table, and we are about + ** to increment the constraint-counter (i.e. this is an INSERT operation), + ** then check if the row being inserted matches itself. If so, do not + ** increment the constraint-counter. + ** + ** If any of the parent-key values are NULL, then the row cannot match + ** itself. So set JUMPIFNULL to make sure we do the OP_Found if any + ** of the parent-key values are NULL (at this point it is known that + ** none of the child key values are). + */ + if( pTab==pFKey->pFrom && nIncr==1 ){ + int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1; + for(i=0; ipFrom,aiCol[i]) + +1+regData; + int iParent = 1+regData; + iParent += sqlite3TableColumnToStorage(pIdx->pTable, + pIdx->aiColumn[i]); + assert( pIdx->aiColumn[i]>=0 ); + assert( aiCol[i]!=pTab->iPKey ); + if( pIdx->aiColumn[i]==pTab->iPKey ){ + /* The parent key is a composite key that includes the IPK column */ + iParent = regData; + } + sqlite3VdbeAddOp3(v, OP_Ne, iChild, iJump, iParent); VdbeCoverage(v); + sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL); + } + sqlite3VdbeGoto(v, iOk); + } + + sqlite3VdbeAddOp4(v, OP_Affinity, regTemp, nCol, 0, + sqlite3IndexAffinityStr(pParse->db,pIdx), nCol); + sqlite3VdbeAddOp4Int(v, OP_Found, iCur, iOk, regTemp, nCol); + VdbeCoverage(v); + sqlite3ReleaseTempRange(pParse, regTemp, nCol); + } + } + + if( !pFKey->isDeferred && !(pParse->db->flags & SQLITE_DeferFKs) + && !pParse->pToplevel + && !pParse->isMultiWrite + ){ + /* Special case: If this is an INSERT statement that will insert exactly + ** one row into the table, raise a constraint immediately instead of + ** incrementing a counter. This is necessary as the VM code is being + ** generated for will not open a statement transaction. */ + assert( nIncr==1 ); + sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_FOREIGNKEY, + OE_Abort, 0, P4_STATIC, P5_ConstraintFK); + }else{ + if( nIncr>0 && pFKey->isDeferred==0 ){ + sqlite3MayAbort(pParse); + } + sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr); + } + + sqlite3VdbeResolveLabel(v, iOk); + sqlite3VdbeAddOp1(v, OP_Close, iCur); +} + + +/* +** Return an Expr object that refers to a memory register corresponding +** to column iCol of table pTab. +** +** regBase is the first of an array of register that contains the data +** for pTab. regBase itself holds the rowid. regBase+1 holds the first +** column. regBase+2 holds the second column, and so forth. +*/ +static Expr *exprTableRegister( + Parse *pParse, /* Parsing and code generating context */ + Table *pTab, /* The table whose content is at r[regBase]... */ + int regBase, /* Contents of table pTab */ + i16 iCol /* Which column of pTab is desired */ +){ + Expr *pExpr; + Column *pCol; + const char *zColl; + sqlite3 *db = pParse->db; + + pExpr = sqlite3Expr(db, TK_REGISTER, 0); + if( pExpr ){ + if( iCol>=0 && iCol!=pTab->iPKey ){ + pCol = &pTab->aCol[iCol]; + pExpr->iTable = regBase + sqlite3TableColumnToStorage(pTab,iCol) + 1; + pExpr->affExpr = pCol->affinity; + zColl = sqlite3ColumnColl(pCol); + if( zColl==0 ) zColl = db->pDfltColl->zName; + pExpr = sqlite3ExprAddCollateString(pParse, pExpr, zColl); + }else{ + pExpr->iTable = regBase; + pExpr->affExpr = SQLITE_AFF_INTEGER; + } + } + return pExpr; +} + +/* +** Return an Expr object that refers to column iCol of table pTab which +** has cursor iCur. +*/ +static Expr *exprTableColumn( + sqlite3 *db, /* The database connection */ + Table *pTab, /* The table whose column is desired */ + int iCursor, /* The open cursor on the table */ + i16 iCol /* The column that is wanted */ +){ + Expr *pExpr = sqlite3Expr(db, TK_COLUMN, 0); + if( pExpr ){ + assert( ExprUseYTab(pExpr) ); + pExpr->y.pTab = pTab; + pExpr->iTable = iCursor; + pExpr->iColumn = iCol; + } + return pExpr; +} + +/* +** This function is called to generate code executed when a row is deleted +** from the parent table of foreign key constraint pFKey and, if pFKey is +** deferred, when a row is inserted into the same table. When generating +** code for an SQL UPDATE operation, this function may be called twice - +** once to "delete" the old row and once to "insert" the new row. +** +** Parameter nIncr is passed -1 when inserting a row (as this may decrease +** the number of FK violations in the db) or +1 when deleting one (as this +** may increase the number of FK constraint problems). +** +** The code generated by this function scans through the rows in the child +** table that correspond to the parent table row being deleted or inserted. +** For each child row found, one of the following actions is taken: +** +** Operation | FK type | Action taken +** -------------------------------------------------------------------------- +** DELETE immediate Increment the "immediate constraint counter". +** +** INSERT immediate Decrement the "immediate constraint counter". +** +** DELETE deferred Increment the "deferred constraint counter". +** +** INSERT deferred Decrement the "deferred constraint counter". +** +** These operations are identified in the comment at the top of this file +** (fkey.c) as "I.2" and "D.2". +*/ +static void fkScanChildren( + Parse *pParse, /* Parse context */ + SrcList *pSrc, /* The child table to be scanned */ + Table *pTab, /* The parent table */ + Index *pIdx, /* Index on parent covering the foreign key */ + FKey *pFKey, /* The foreign key linking pSrc to pTab */ + int *aiCol, /* Map from pIdx cols to child table cols */ + int regData, /* Parent row data starts here */ + int nIncr /* Amount to increment deferred counter by */ +){ + sqlite3 *db = pParse->db; /* Database handle */ + int i; /* Iterator variable */ + Expr *pWhere = 0; /* WHERE clause to scan with */ + NameContext sNameContext; /* Context used to resolve WHERE clause */ + WhereInfo *pWInfo; /* Context used by sqlite3WhereXXX() */ + int iFkIfZero = 0; /* Address of OP_FkIfZero */ + Vdbe *v = sqlite3GetVdbe(pParse); + + assert( pIdx==0 || pIdx->pTable==pTab ); + assert( pIdx==0 || pIdx->nKeyCol==pFKey->nCol ); + assert( pIdx!=0 || pFKey->nCol==1 ); + assert( pIdx!=0 || HasRowid(pTab) ); + + if( nIncr<0 ){ + iFkIfZero = sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, 0); + VdbeCoverage(v); + } + + /* Create an Expr object representing an SQL expression like: + ** + ** = AND = ... + ** + ** The collation sequence used for the comparison should be that of + ** the parent key columns. The affinity of the parent key column should + ** be applied to each child key value before the comparison takes place. + */ + for(i=0; inCol; i++){ + Expr *pLeft; /* Value from parent table row */ + Expr *pRight; /* Column ref to child table */ + Expr *pEq; /* Expression (pLeft = pRight) */ + i16 iCol; /* Index of column in child table */ + const char *zCol; /* Name of column in child table */ + + iCol = pIdx ? pIdx->aiColumn[i] : -1; + pLeft = exprTableRegister(pParse, pTab, regData, iCol); + iCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom; + assert( iCol>=0 ); + zCol = pFKey->pFrom->aCol[iCol].zCnName; + pRight = sqlite3Expr(db, TK_ID, zCol); + pEq = sqlite3PExpr(pParse, TK_EQ, pLeft, pRight); + pWhere = sqlite3ExprAnd(pParse, pWhere, pEq); + } + + /* If the child table is the same as the parent table, then add terms + ** to the WHERE clause that prevent this entry from being scanned. + ** The added WHERE clause terms are like this: + ** + ** $current_rowid!=rowid + ** NOT( $current_a==a AND $current_b==b AND ... ) + ** + ** The first form is used for rowid tables. The second form is used + ** for WITHOUT ROWID tables. In the second form, the *parent* key is + ** (a,b,...). Either the parent or primary key could be used to + ** uniquely identify the current row, but the parent key is more convenient + ** as the required values have already been loaded into registers + ** by the caller. + */ + if( pTab==pFKey->pFrom && nIncr>0 ){ + Expr *pNe; /* Expression (pLeft != pRight) */ + Expr *pLeft; /* Value from parent table row */ + Expr *pRight; /* Column ref to child table */ + if( HasRowid(pTab) ){ + pLeft = exprTableRegister(pParse, pTab, regData, -1); + pRight = exprTableColumn(db, pTab, pSrc->a[0].iCursor, -1); + pNe = sqlite3PExpr(pParse, TK_NE, pLeft, pRight); + }else{ + Expr *pEq, *pAll = 0; + assert( pIdx!=0 ); + for(i=0; inKeyCol; i++){ + i16 iCol = pIdx->aiColumn[i]; + assert( iCol>=0 ); + pLeft = exprTableRegister(pParse, pTab, regData, iCol); + pRight = sqlite3Expr(db, TK_ID, pTab->aCol[iCol].zCnName); + pEq = sqlite3PExpr(pParse, TK_IS, pLeft, pRight); + pAll = sqlite3ExprAnd(pParse, pAll, pEq); + } + pNe = sqlite3PExpr(pParse, TK_NOT, pAll, 0); + } + pWhere = sqlite3ExprAnd(pParse, pWhere, pNe); + } + + /* Resolve the references in the WHERE clause. */ + memset(&sNameContext, 0, sizeof(NameContext)); + sNameContext.pSrcList = pSrc; + sNameContext.pParse = pParse; + sqlite3ResolveExprNames(&sNameContext, pWhere); + + /* Create VDBE to loop through the entries in pSrc that match the WHERE + ** clause. For each row found, increment either the deferred or immediate + ** foreign key constraint counter. */ + if( pParse->nErr==0 ){ + pWInfo = sqlite3WhereBegin(pParse, pSrc, pWhere, 0, 0, 0, 0, 0); + sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr); + if( pWInfo ){ + sqlite3WhereEnd(pWInfo); + } + } + + /* Clean up the WHERE clause constructed above. */ + sqlite3ExprDelete(db, pWhere); + if( iFkIfZero ){ + sqlite3VdbeJumpHereOrPopInst(v, iFkIfZero); + } +} + +/* +** This function returns a linked list of FKey objects (connected by +** FKey.pNextTo) holding all children of table pTab. For example, +** given the following schema: +** +** CREATE TABLE t1(a PRIMARY KEY); +** CREATE TABLE t2(b REFERENCES t1(a); +** +** Calling this function with table "t1" as an argument returns a pointer +** to the FKey structure representing the foreign key constraint on table +** "t2". Calling this function with "t2" as the argument would return a +** NULL pointer (as there are no FK constraints for which t2 is the parent +** table). +*/ +SQLITE_PRIVATE FKey *sqlite3FkReferences(Table *pTab){ + return (FKey *)sqlite3HashFind(&pTab->pSchema->fkeyHash, pTab->zName); +} + +/* +** The second argument is a Trigger structure allocated by the +** fkActionTrigger() routine. This function deletes the Trigger structure +** and all of its sub-components. +** +** The Trigger structure or any of its sub-components may be allocated from +** the lookaside buffer belonging to database handle dbMem. +*/ +static void fkTriggerDelete(sqlite3 *dbMem, Trigger *p){ + if( p ){ + TriggerStep *pStep = p->step_list; + sqlite3ExprDelete(dbMem, pStep->pWhere); + sqlite3ExprListDelete(dbMem, pStep->pExprList); + sqlite3SelectDelete(dbMem, pStep->pSelect); + sqlite3ExprDelete(dbMem, p->pWhen); + sqlite3DbFree(dbMem, p); + } +} + +/* +** Clear the apTrigger[] cache of CASCADE triggers for all foreign keys +** in a particular database. This needs to happen when the schema +** changes. +*/ +SQLITE_PRIVATE void sqlite3FkClearTriggerCache(sqlite3 *db, int iDb){ + HashElem *k; + Hash *pHash = &db->aDb[iDb].pSchema->tblHash; + for(k=sqliteHashFirst(pHash); k; k=sqliteHashNext(k)){ + Table *pTab = sqliteHashData(k); + FKey *pFKey; + if( !IsOrdinaryTable(pTab) ) continue; + for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){ + fkTriggerDelete(db, pFKey->apTrigger[0]); pFKey->apTrigger[0] = 0; + fkTriggerDelete(db, pFKey->apTrigger[1]); pFKey->apTrigger[1] = 0; + } + } +} + +/* +** This function is called to generate code that runs when table pTab is +** being dropped from the database. The SrcList passed as the second argument +** to this function contains a single entry guaranteed to resolve to +** table pTab. +** +** Normally, no code is required. However, if either +** +** (a) The table is the parent table of a FK constraint, or +** (b) The table is the child table of a deferred FK constraint and it is +** determined at runtime that there are outstanding deferred FK +** constraint violations in the database, +** +** then the equivalent of "DELETE FROM " is executed before dropping +** the table from the database. Triggers are disabled while running this +** DELETE, but foreign key actions are not. +*/ +SQLITE_PRIVATE void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTab){ + sqlite3 *db = pParse->db; + if( (db->flags&SQLITE_ForeignKeys) && IsOrdinaryTable(pTab) ){ + int iSkip = 0; + Vdbe *v = sqlite3GetVdbe(pParse); + + assert( v ); /* VDBE has already been allocated */ + assert( IsOrdinaryTable(pTab) ); + if( sqlite3FkReferences(pTab)==0 ){ + /* Search for a deferred foreign key constraint for which this table + ** is the child table. If one cannot be found, return without + ** generating any VDBE code. If one can be found, then jump over + ** the entire DELETE if there are no outstanding deferred constraints + ** when this statement is run. */ + FKey *p; + for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){ + if( p->isDeferred || (db->flags & SQLITE_DeferFKs) ) break; + } + if( !p ) return; + iSkip = sqlite3VdbeMakeLabel(pParse); + sqlite3VdbeAddOp2(v, OP_FkIfZero, 1, iSkip); VdbeCoverage(v); + } + + pParse->disableTriggers = 1; + sqlite3DeleteFrom(pParse, sqlite3SrcListDup(db, pName, 0), 0, 0, 0); + pParse->disableTriggers = 0; + + /* If the DELETE has generated immediate foreign key constraint + ** violations, halt the VDBE and return an error at this point, before + ** any modifications to the schema are made. This is because statement + ** transactions are not able to rollback schema changes. + ** + ** If the SQLITE_DeferFKs flag is set, then this is not required, as + ** the statement transaction will not be rolled back even if FK + ** constraints are violated. + */ + if( (db->flags & SQLITE_DeferFKs)==0 ){ + sqlite3VdbeVerifyAbortable(v, OE_Abort); + sqlite3VdbeAddOp2(v, OP_FkIfZero, 0, sqlite3VdbeCurrentAddr(v)+2); + VdbeCoverage(v); + sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_FOREIGNKEY, + OE_Abort, 0, P4_STATIC, P5_ConstraintFK); + } + + if( iSkip ){ + sqlite3VdbeResolveLabel(v, iSkip); + } + } +} + + +/* +** The second argument points to an FKey object representing a foreign key +** for which pTab is the child table. An UPDATE statement against pTab +** is currently being processed. For each column of the table that is +** actually updated, the corresponding element in the aChange[] array +** is zero or greater (if a column is unmodified the corresponding element +** is set to -1). If the rowid column is modified by the UPDATE statement +** the bChngRowid argument is non-zero. +** +** This function returns true if any of the columns that are part of the +** child key for FK constraint *p are modified. +*/ +static int fkChildIsModified( + Table *pTab, /* Table being updated */ + FKey *p, /* Foreign key for which pTab is the child */ + int *aChange, /* Array indicating modified columns */ + int bChngRowid /* True if rowid is modified by this update */ +){ + int i; + for(i=0; inCol; i++){ + int iChildKey = p->aCol[i].iFrom; + if( aChange[iChildKey]>=0 ) return 1; + if( iChildKey==pTab->iPKey && bChngRowid ) return 1; + } + return 0; +} + +/* +** The second argument points to an FKey object representing a foreign key +** for which pTab is the parent table. An UPDATE statement against pTab +** is currently being processed. For each column of the table that is +** actually updated, the corresponding element in the aChange[] array +** is zero or greater (if a column is unmodified the corresponding element +** is set to -1). If the rowid column is modified by the UPDATE statement +** the bChngRowid argument is non-zero. +** +** This function returns true if any of the columns that are part of the +** parent key for FK constraint *p are modified. +*/ +static int fkParentIsModified( + Table *pTab, + FKey *p, + int *aChange, + int bChngRowid +){ + int i; + for(i=0; inCol; i++){ + char *zKey = p->aCol[i].zCol; + int iKey; + for(iKey=0; iKeynCol; iKey++){ + if( aChange[iKey]>=0 || (iKey==pTab->iPKey && bChngRowid) ){ + Column *pCol = &pTab->aCol[iKey]; + if( zKey ){ + if( 0==sqlite3StrICmp(pCol->zCnName, zKey) ) return 1; + }else if( pCol->colFlags & COLFLAG_PRIMKEY ){ + return 1; + } + } + } + } + return 0; +} + +/* +** Return true if the parser passed as the first argument is being +** used to code a trigger that is really a "SET NULL" action belonging +** to trigger pFKey. +*/ +static int isSetNullAction(Parse *pParse, FKey *pFKey){ + Parse *pTop = sqlite3ParseToplevel(pParse); + if( pTop->pTriggerPrg ){ + Trigger *p = pTop->pTriggerPrg->pTrigger; + if( (p==pFKey->apTrigger[0] && pFKey->aAction[0]==OE_SetNull) + || (p==pFKey->apTrigger[1] && pFKey->aAction[1]==OE_SetNull) + ){ + return 1; + } + } + return 0; +} + +/* +** This function is called when inserting, deleting or updating a row of +** table pTab to generate VDBE code to perform foreign key constraint +** processing for the operation. +** +** For a DELETE operation, parameter regOld is passed the index of the +** first register in an array of (pTab->nCol+1) registers containing the +** rowid of the row being deleted, followed by each of the column values +** of the row being deleted, from left to right. Parameter regNew is passed +** zero in this case. +** +** For an INSERT operation, regOld is passed zero and regNew is passed the +** first register of an array of (pTab->nCol+1) registers containing the new +** row data. +** +** For an UPDATE operation, this function is called twice. Once before +** the original record is deleted from the table using the calling convention +** described for DELETE. Then again after the original record is deleted +** but before the new record is inserted using the INSERT convention. +*/ +SQLITE_PRIVATE void sqlite3FkCheck( + Parse *pParse, /* Parse context */ + Table *pTab, /* Row is being deleted from this table */ + int regOld, /* Previous row data is stored here */ + int regNew, /* New row data is stored here */ + int *aChange, /* Array indicating UPDATEd columns (or 0) */ + int bChngRowid /* True if rowid is UPDATEd */ +){ + sqlite3 *db = pParse->db; /* Database handle */ + FKey *pFKey; /* Used to iterate through FKs */ + int iDb; /* Index of database containing pTab */ + const char *zDb; /* Name of database containing pTab */ + int isIgnoreErrors = pParse->disableTriggers; + + /* Exactly one of regOld and regNew should be non-zero. */ + assert( (regOld==0)!=(regNew==0) ); + + /* If foreign-keys are disabled, this function is a no-op. */ + if( (db->flags&SQLITE_ForeignKeys)==0 ) return; + if( !IsOrdinaryTable(pTab) ) return; + + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + zDb = db->aDb[iDb].zDbSName; + + /* Loop through all the foreign key constraints for which pTab is the + ** child table (the table that the foreign key definition is part of). */ + for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){ + Table *pTo; /* Parent table of foreign key pFKey */ + Index *pIdx = 0; /* Index on key columns in pTo */ + int *aiFree = 0; + int *aiCol; + int iCol; + int i; + int bIgnore = 0; + + if( aChange + && sqlite3_stricmp(pTab->zName, pFKey->zTo)!=0 + && fkChildIsModified(pTab, pFKey, aChange, bChngRowid)==0 + ){ + continue; + } + + /* Find the parent table of this foreign key. Also find a unique index + ** on the parent key columns in the parent table. If either of these + ** schema items cannot be located, set an error in pParse and return + ** early. */ + if( pParse->disableTriggers ){ + pTo = sqlite3FindTable(db, pFKey->zTo, zDb); + }else{ + pTo = sqlite3LocateTable(pParse, 0, pFKey->zTo, zDb); + } + if( !pTo || sqlite3FkLocateIndex(pParse, pTo, pFKey, &pIdx, &aiFree) ){ + assert( isIgnoreErrors==0 || (regOld!=0 && regNew==0) ); + if( !isIgnoreErrors || db->mallocFailed ) return; + if( pTo==0 ){ + /* If isIgnoreErrors is true, then a table is being dropped. In this + ** case SQLite runs a "DELETE FROM xxx" on the table being dropped + ** before actually dropping it in order to check FK constraints. + ** If the parent table of an FK constraint on the current table is + ** missing, behave as if it is empty. i.e. decrement the relevant + ** FK counter for each row of the current table with non-NULL keys. + */ + Vdbe *v = sqlite3GetVdbe(pParse); + int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1; + for(i=0; inCol; i++){ + int iFromCol, iReg; + iFromCol = pFKey->aCol[i].iFrom; + iReg = sqlite3TableColumnToStorage(pFKey->pFrom,iFromCol) + regOld+1; + sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iJump); VdbeCoverage(v); + } + sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, -1); + } + continue; + } + assert( pFKey->nCol==1 || (aiFree && pIdx) ); + + if( aiFree ){ + aiCol = aiFree; + }else{ + iCol = pFKey->aCol[0].iFrom; + aiCol = &iCol; + } + for(i=0; inCol; i++){ + if( aiCol[i]==pTab->iPKey ){ + aiCol[i] = -1; + } + assert( pIdx==0 || pIdx->aiColumn[i]>=0 ); +#ifndef SQLITE_OMIT_AUTHORIZATION + /* Request permission to read the parent key columns. If the + ** authorization callback returns SQLITE_IGNORE, behave as if any + ** values read from the parent table are NULL. */ + if( db->xAuth ){ + int rcauth; + char *zCol = pTo->aCol[pIdx ? pIdx->aiColumn[i] : pTo->iPKey].zCnName; + rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb); + bIgnore = (rcauth==SQLITE_IGNORE); + } +#endif + } + + /* Take a shared-cache advisory read-lock on the parent table. Allocate + ** a cursor to use to search the unique index on the parent key columns + ** in the parent table. */ + sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName); + pParse->nTab++; + + if( regOld!=0 ){ + /* A row is being removed from the child table. Search for the parent. + ** If the parent does not exist, removing the child row resolves an + ** outstanding foreign key constraint violation. */ + fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regOld, -1, bIgnore); + } + if( regNew!=0 && !isSetNullAction(pParse, pFKey) ){ + /* A row is being added to the child table. If a parent row cannot + ** be found, adding the child row has violated the FK constraint. + ** + ** If this operation is being performed as part of a trigger program + ** that is actually a "SET NULL" action belonging to this very + ** foreign key, then omit this scan altogether. As all child key + ** values are guaranteed to be NULL, it is not possible for adding + ** this row to cause an FK violation. */ + fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regNew, +1, bIgnore); + } + + sqlite3DbFree(db, aiFree); + } + + /* Loop through all the foreign key constraints that refer to this table. + ** (the "child" constraints) */ + for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){ + Index *pIdx = 0; /* Foreign key index for pFKey */ + SrcList *pSrc; + int *aiCol = 0; + + if( aChange && fkParentIsModified(pTab, pFKey, aChange, bChngRowid)==0 ){ + continue; + } + + if( !pFKey->isDeferred && !(db->flags & SQLITE_DeferFKs) + && !pParse->pToplevel && !pParse->isMultiWrite + ){ + assert( regOld==0 && regNew!=0 ); + /* Inserting a single row into a parent table cannot cause (or fix) + ** an immediate foreign key violation. So do nothing in this case. */ + continue; + } + + if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ){ + if( !isIgnoreErrors || db->mallocFailed ) return; + continue; + } + assert( aiCol || pFKey->nCol==1 ); + + /* Create a SrcList structure containing the child table. We need the + ** child table as a SrcList for sqlite3WhereBegin() */ + pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0); + if( pSrc ){ + SrcItem *pItem = pSrc->a; + pItem->pTab = pFKey->pFrom; + pItem->zName = pFKey->pFrom->zName; + pItem->pTab->nTabRef++; + pItem->iCursor = pParse->nTab++; + + if( regNew!=0 ){ + fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regNew, -1); + } + if( regOld!=0 ){ + int eAction = pFKey->aAction[aChange!=0]; + fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regOld, 1); + /* If this is a deferred FK constraint, or a CASCADE or SET NULL + ** action applies, then any foreign key violations caused by + ** removing the parent key will be rectified by the action trigger. + ** So do not set the "may-abort" flag in this case. + ** + ** Note 1: If the FK is declared "ON UPDATE CASCADE", then the + ** may-abort flag will eventually be set on this statement anyway + ** (when this function is called as part of processing the UPDATE + ** within the action trigger). + ** + ** Note 2: At first glance it may seem like SQLite could simply omit + ** all OP_FkCounter related scans when either CASCADE or SET NULL + ** applies. The trouble starts if the CASCADE or SET NULL action + ** trigger causes other triggers or action rules attached to the + ** child table to fire. In these cases the fk constraint counters + ** might be set incorrectly if any OP_FkCounter related scans are + ** omitted. */ + if( !pFKey->isDeferred && eAction!=OE_Cascade && eAction!=OE_SetNull ){ + sqlite3MayAbort(pParse); + } + } + pItem->zName = 0; + sqlite3SrcListDelete(db, pSrc); + } + sqlite3DbFree(db, aiCol); + } +} + +#define COLUMN_MASK(x) (((x)>31) ? 0xffffffff : ((u32)1<<(x))) + +/* +** This function is called before generating code to update or delete a +** row contained in table pTab. +*/ +SQLITE_PRIVATE u32 sqlite3FkOldmask( + Parse *pParse, /* Parse context */ + Table *pTab /* Table being modified */ +){ + u32 mask = 0; + if( pParse->db->flags&SQLITE_ForeignKeys && IsOrdinaryTable(pTab) ){ + FKey *p; + int i; + for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){ + for(i=0; inCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom); + } + for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){ + Index *pIdx = 0; + sqlite3FkLocateIndex(pParse, pTab, p, &pIdx, 0); + if( pIdx ){ + for(i=0; inKeyCol; i++){ + assert( pIdx->aiColumn[i]>=0 ); + mask |= COLUMN_MASK(pIdx->aiColumn[i]); + } + } + } + } + return mask; +} + + +/* +** This function is called before generating code to update or delete a +** row contained in table pTab. If the operation is a DELETE, then +** parameter aChange is passed a NULL value. For an UPDATE, aChange points +** to an array of size N, where N is the number of columns in table pTab. +** If the i'th column is not modified by the UPDATE, then the corresponding +** entry in the aChange[] array is set to -1. If the column is modified, +** the value is 0 or greater. Parameter chngRowid is set to true if the +** UPDATE statement modifies the rowid fields of the table. +** +** If any foreign key processing will be required, this function returns +** non-zero. If there is no foreign key related processing, this function +** returns zero. +** +** For an UPDATE, this function returns 2 if: +** +** * There are any FKs for which pTab is the child and the parent table +** and any FK processing at all is required (even of a different FK), or +** +** * the UPDATE modifies one or more parent keys for which the action is +** not "NO ACTION" (i.e. is CASCADE, SET DEFAULT or SET NULL). +** +** Or, assuming some other foreign key processing is required, 1. +*/ +SQLITE_PRIVATE int sqlite3FkRequired( + Parse *pParse, /* Parse context */ + Table *pTab, /* Table being modified */ + int *aChange, /* Non-NULL for UPDATE operations */ + int chngRowid /* True for UPDATE that affects rowid */ +){ + int eRet = 1; /* Value to return if bHaveFK is true */ + int bHaveFK = 0; /* If FK processing is required */ + if( pParse->db->flags&SQLITE_ForeignKeys && IsOrdinaryTable(pTab) ){ + if( !aChange ){ + /* A DELETE operation. Foreign key processing is required if the + ** table in question is either the child or parent table for any + ** foreign key constraint. */ + bHaveFK = (sqlite3FkReferences(pTab) || pTab->u.tab.pFKey); + }else{ + /* This is an UPDATE. Foreign key processing is only required if the + ** operation modifies one or more child or parent key columns. */ + FKey *p; + + /* Check if any child key columns are being modified. */ + for(p=pTab->u.tab.pFKey; p; p=p->pNextFrom){ + if( fkChildIsModified(pTab, p, aChange, chngRowid) ){ + if( 0==sqlite3_stricmp(pTab->zName, p->zTo) ) eRet = 2; + bHaveFK = 1; + } + } + + /* Check if any parent key columns are being modified. */ + for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){ + if( fkParentIsModified(pTab, p, aChange, chngRowid) ){ + if( p->aAction[1]!=OE_None ) return 2; + bHaveFK = 1; + } + } + } + } + return bHaveFK ? eRet : 0; +} + +/* +** This function is called when an UPDATE or DELETE operation is being +** compiled on table pTab, which is the parent table of foreign-key pFKey. +** If the current operation is an UPDATE, then the pChanges parameter is +** passed a pointer to the list of columns being modified. If it is a +** DELETE, pChanges is passed a NULL pointer. +** +** It returns a pointer to a Trigger structure containing a trigger +** equivalent to the ON UPDATE or ON DELETE action specified by pFKey. +** If the action is "NO ACTION" then a NULL pointer is returned (these actions +** require no special handling by the triggers sub-system, code for them is +** created by fkScanChildren()). +** +** For example, if pFKey is the foreign key and pTab is table "p" in +** the following schema: +** +** CREATE TABLE p(pk PRIMARY KEY); +** CREATE TABLE c(ck REFERENCES p ON DELETE CASCADE); +** +** then the returned trigger structure is equivalent to: +** +** CREATE TRIGGER ... DELETE ON p BEGIN +** DELETE FROM c WHERE ck = old.pk; +** END; +** +** The returned pointer is cached as part of the foreign key object. It +** is eventually freed along with the rest of the foreign key object by +** sqlite3FkDelete(). +*/ +static Trigger *fkActionTrigger( + Parse *pParse, /* Parse context */ + Table *pTab, /* Table being updated or deleted from */ + FKey *pFKey, /* Foreign key to get action for */ + ExprList *pChanges /* Change-list for UPDATE, NULL for DELETE */ +){ + sqlite3 *db = pParse->db; /* Database handle */ + int action; /* One of OE_None, OE_Cascade etc. */ + Trigger *pTrigger; /* Trigger definition to return */ + int iAction = (pChanges!=0); /* 1 for UPDATE, 0 for DELETE */ + + action = pFKey->aAction[iAction]; + if( action==OE_Restrict && (db->flags & SQLITE_DeferFKs) ){ + return 0; + } + pTrigger = pFKey->apTrigger[iAction]; + + if( action!=OE_None && !pTrigger ){ + char const *zFrom; /* Name of child table */ + int nFrom; /* Length in bytes of zFrom */ + Index *pIdx = 0; /* Parent key index for this FK */ + int *aiCol = 0; /* child table cols -> parent key cols */ + TriggerStep *pStep = 0; /* First (only) step of trigger program */ + Expr *pWhere = 0; /* WHERE clause of trigger step */ + ExprList *pList = 0; /* Changes list if ON UPDATE CASCADE */ + Select *pSelect = 0; /* If RESTRICT, "SELECT RAISE(...)" */ + int i; /* Iterator variable */ + Expr *pWhen = 0; /* WHEN clause for the trigger */ + + if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ) return 0; + assert( aiCol || pFKey->nCol==1 ); + + for(i=0; inCol; i++){ + Token tOld = { "old", 3 }; /* Literal "old" token */ + Token tNew = { "new", 3 }; /* Literal "new" token */ + Token tFromCol; /* Name of column in child table */ + Token tToCol; /* Name of column in parent table */ + int iFromCol; /* Idx of column in child table */ + Expr *pEq; /* tFromCol = OLD.tToCol */ + + iFromCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom; + assert( iFromCol>=0 ); + assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKeynCol) ); + assert( pIdx==0 || pIdx->aiColumn[i]>=0 ); + sqlite3TokenInit(&tToCol, + pTab->aCol[pIdx ? pIdx->aiColumn[i] : pTab->iPKey].zCnName); + sqlite3TokenInit(&tFromCol, pFKey->pFrom->aCol[iFromCol].zCnName); + + /* Create the expression "OLD.zToCol = zFromCol". It is important + ** that the "OLD.zToCol" term is on the LHS of the = operator, so + ** that the affinity and collation sequence associated with the + ** parent table are used for the comparison. */ + pEq = sqlite3PExpr(pParse, TK_EQ, + sqlite3PExpr(pParse, TK_DOT, + sqlite3ExprAlloc(db, TK_ID, &tOld, 0), + sqlite3ExprAlloc(db, TK_ID, &tToCol, 0)), + sqlite3ExprAlloc(db, TK_ID, &tFromCol, 0) + ); + pWhere = sqlite3ExprAnd(pParse, pWhere, pEq); + + /* For ON UPDATE, construct the next term of the WHEN clause. + ** The final WHEN clause will be like this: + ** + ** WHEN NOT(old.col1 IS new.col1 AND ... AND old.colN IS new.colN) + */ + if( pChanges ){ + pEq = sqlite3PExpr(pParse, TK_IS, + sqlite3PExpr(pParse, TK_DOT, + sqlite3ExprAlloc(db, TK_ID, &tOld, 0), + sqlite3ExprAlloc(db, TK_ID, &tToCol, 0)), + sqlite3PExpr(pParse, TK_DOT, + sqlite3ExprAlloc(db, TK_ID, &tNew, 0), + sqlite3ExprAlloc(db, TK_ID, &tToCol, 0)) + ); + pWhen = sqlite3ExprAnd(pParse, pWhen, pEq); + } + + if( action!=OE_Restrict && (action!=OE_Cascade || pChanges) ){ + Expr *pNew; + if( action==OE_Cascade ){ + pNew = sqlite3PExpr(pParse, TK_DOT, + sqlite3ExprAlloc(db, TK_ID, &tNew, 0), + sqlite3ExprAlloc(db, TK_ID, &tToCol, 0)); + }else if( action==OE_SetDflt ){ + Column *pCol = pFKey->pFrom->aCol + iFromCol; + Expr *pDflt; + if( pCol->colFlags & COLFLAG_GENERATED ){ + testcase( pCol->colFlags & COLFLAG_VIRTUAL ); + testcase( pCol->colFlags & COLFLAG_STORED ); + pDflt = 0; + }else{ + pDflt = sqlite3ColumnExpr(pFKey->pFrom, pCol); + } + if( pDflt ){ + pNew = sqlite3ExprDup(db, pDflt, 0); + }else{ + pNew = sqlite3ExprAlloc(db, TK_NULL, 0, 0); + } + }else{ + pNew = sqlite3ExprAlloc(db, TK_NULL, 0, 0); + } + pList = sqlite3ExprListAppend(pParse, pList, pNew); + sqlite3ExprListSetName(pParse, pList, &tFromCol, 0); + } + } + sqlite3DbFree(db, aiCol); + + zFrom = pFKey->pFrom->zName; + nFrom = sqlite3Strlen30(zFrom); + + if( action==OE_Restrict ){ + int iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + SrcList *pSrc; + Expr *pRaise; + + pRaise = sqlite3Expr(db, TK_RAISE, "FOREIGN KEY constraint failed"); + if( pRaise ){ + pRaise->affExpr = OE_Abort; + } + pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0); + if( pSrc ){ + assert( pSrc->nSrc==1 ); + pSrc->a[0].zName = sqlite3DbStrDup(db, zFrom); + pSrc->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zDbSName); + } + pSelect = sqlite3SelectNew(pParse, + sqlite3ExprListAppend(pParse, 0, pRaise), + pSrc, + pWhere, + 0, 0, 0, 0, 0 + ); + pWhere = 0; + } + + /* Disable lookaside memory allocation */ + DisableLookaside; + + pTrigger = (Trigger *)sqlite3DbMallocZero(db, + sizeof(Trigger) + /* struct Trigger */ + sizeof(TriggerStep) + /* Single step in trigger program */ + nFrom + 1 /* Space for pStep->zTarget */ + ); + if( pTrigger ){ + pStep = pTrigger->step_list = (TriggerStep *)&pTrigger[1]; + pStep->zTarget = (char *)&pStep[1]; + memcpy((char *)pStep->zTarget, zFrom, nFrom); + + pStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE); + pStep->pExprList = sqlite3ExprListDup(db, pList, EXPRDUP_REDUCE); + pStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE); + if( pWhen ){ + pWhen = sqlite3PExpr(pParse, TK_NOT, pWhen, 0); + pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE); + } + } + + /* Re-enable the lookaside buffer, if it was disabled earlier. */ + EnableLookaside; + + sqlite3ExprDelete(db, pWhere); + sqlite3ExprDelete(db, pWhen); + sqlite3ExprListDelete(db, pList); + sqlite3SelectDelete(db, pSelect); + if( db->mallocFailed==1 ){ + fkTriggerDelete(db, pTrigger); + return 0; + } + assert( pStep!=0 ); + assert( pTrigger!=0 ); + + switch( action ){ + case OE_Restrict: + pStep->op = TK_SELECT; + break; + case OE_Cascade: + if( !pChanges ){ + pStep->op = TK_DELETE; + break; + } + /* no break */ deliberate_fall_through + default: + pStep->op = TK_UPDATE; + } + pStep->pTrig = pTrigger; + pTrigger->pSchema = pTab->pSchema; + pTrigger->pTabSchema = pTab->pSchema; + pFKey->apTrigger[iAction] = pTrigger; + pTrigger->op = (pChanges ? TK_UPDATE : TK_DELETE); + } + + return pTrigger; +} + +/* +** This function is called when deleting or updating a row to implement +** any required CASCADE, SET NULL or SET DEFAULT actions. +*/ +SQLITE_PRIVATE void sqlite3FkActions( + Parse *pParse, /* Parse context */ + Table *pTab, /* Table being updated or deleted from */ + ExprList *pChanges, /* Change-list for UPDATE, NULL for DELETE */ + int regOld, /* Address of array containing old row */ + int *aChange, /* Array indicating UPDATEd columns (or 0) */ + int bChngRowid /* True if rowid is UPDATEd */ +){ + /* If foreign-key support is enabled, iterate through all FKs that + ** refer to table pTab. If there is an action associated with the FK + ** for this operation (either update or delete), invoke the associated + ** trigger sub-program. */ + if( pParse->db->flags&SQLITE_ForeignKeys ){ + FKey *pFKey; /* Iterator variable */ + for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){ + if( aChange==0 || fkParentIsModified(pTab, pFKey, aChange, bChngRowid) ){ + Trigger *pAct = fkActionTrigger(pParse, pTab, pFKey, pChanges); + if( pAct ){ + sqlite3CodeRowTriggerDirect(pParse, pAct, pTab, regOld, OE_Abort, 0); + } + } + } + } +} + +#endif /* ifndef SQLITE_OMIT_TRIGGER */ + +/* +** Free all memory associated with foreign key definitions attached to +** table pTab. Remove the deleted foreign keys from the Schema.fkeyHash +** hash table. +*/ +SQLITE_PRIVATE void sqlite3FkDelete(sqlite3 *db, Table *pTab){ + FKey *pFKey; /* Iterator variable */ + FKey *pNext; /* Copy of pFKey->pNextFrom */ + + assert( IsOrdinaryTable(pTab) ); + assert( db!=0 ); + for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pNext){ + assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pTab->pSchema) ); + + /* Remove the FK from the fkeyHash hash table. */ + if( db->pnBytesFreed==0 ){ + if( pFKey->pPrevTo ){ + pFKey->pPrevTo->pNextTo = pFKey->pNextTo; + }else{ + void *p = (void *)pFKey->pNextTo; + const char *z = (p ? pFKey->pNextTo->zTo : pFKey->zTo); + sqlite3HashInsert(&pTab->pSchema->fkeyHash, z, p); + } + if( pFKey->pNextTo ){ + pFKey->pNextTo->pPrevTo = pFKey->pPrevTo; + } + } + + /* EV: R-30323-21917 Each foreign key constraint in SQLite is + ** classified as either immediate or deferred. + */ + assert( pFKey->isDeferred==0 || pFKey->isDeferred==1 ); + + /* Delete any triggers created to implement actions for this FK. */ +#ifndef SQLITE_OMIT_TRIGGER + fkTriggerDelete(db, pFKey->apTrigger[0]); + fkTriggerDelete(db, pFKey->apTrigger[1]); +#endif + + pNext = pFKey->pNextFrom; + sqlite3DbFree(db, pFKey); + } +} +#endif /* ifndef SQLITE_OMIT_FOREIGN_KEY */ + +/************** End of fkey.c ************************************************/ +/************** Begin file insert.c ******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that are called by the parser +** to handle INSERT statements in SQLite. +*/ +/* #include "sqliteInt.h" */ + +/* +** Generate code that will +** +** (1) acquire a lock for table pTab then +** (2) open pTab as cursor iCur. +** +** If pTab is a WITHOUT ROWID table, then it is the PRIMARY KEY index +** for that table that is actually opened. +*/ +SQLITE_PRIVATE void sqlite3OpenTable( + Parse *pParse, /* Generate code into this VDBE */ + int iCur, /* The cursor number of the table */ + int iDb, /* The database index in sqlite3.aDb[] */ + Table *pTab, /* The table to be opened */ + int opcode /* OP_OpenRead or OP_OpenWrite */ +){ + Vdbe *v; + assert( !IsVirtual(pTab) ); + assert( pParse->pVdbe!=0 ); + v = pParse->pVdbe; + assert( opcode==OP_OpenWrite || opcode==OP_OpenRead ); + sqlite3TableLock(pParse, iDb, pTab->tnum, + (opcode==OP_OpenWrite)?1:0, pTab->zName); + if( HasRowid(pTab) ){ + sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nNVCol); + VdbeComment((v, "%s", pTab->zName)); + }else{ + Index *pPk = sqlite3PrimaryKeyIndex(pTab); + assert( pPk!=0 ); + assert( pPk->tnum==pTab->tnum || CORRUPT_DB ); + sqlite3VdbeAddOp3(v, opcode, iCur, pPk->tnum, iDb); + sqlite3VdbeSetP4KeyInfo(pParse, pPk); + VdbeComment((v, "%s", pTab->zName)); + } +} + +/* +** Return a pointer to the column affinity string associated with index +** pIdx. A column affinity string has one character for each column in +** the table, according to the affinity of the column: +** +** Character Column affinity +** ------------------------------ +** 'A' BLOB +** 'B' TEXT +** 'C' NUMERIC +** 'D' INTEGER +** 'F' REAL +** +** An extra 'D' is appended to the end of the string to cover the +** rowid that appears as the last column in every index. +** +** Memory for the buffer containing the column index affinity string +** is managed along with the rest of the Index structure. It will be +** released when sqlite3DeleteIndex() is called. +*/ +static SQLITE_NOINLINE const char *computeIndexAffStr(sqlite3 *db, Index *pIdx){ + /* The first time a column affinity string for a particular index is + ** required, it is allocated and populated here. It is then stored as + ** a member of the Index structure for subsequent use. + ** + ** The column affinity string will eventually be deleted by + ** sqliteDeleteIndex() when the Index structure itself is cleaned + ** up. + */ + int n; + Table *pTab = pIdx->pTable; + pIdx->zColAff = (char *)sqlite3DbMallocRaw(0, pIdx->nColumn+1); + if( !pIdx->zColAff ){ + sqlite3OomFault(db); + return 0; + } + for(n=0; nnColumn; n++){ + i16 x = pIdx->aiColumn[n]; + char aff; + if( x>=0 ){ + aff = pTab->aCol[x].affinity; + }else if( x==XN_ROWID ){ + aff = SQLITE_AFF_INTEGER; + }else{ + assert( x==XN_EXPR ); + assert( pIdx->bHasExpr ); + assert( pIdx->aColExpr!=0 ); + aff = sqlite3ExprAffinity(pIdx->aColExpr->a[n].pExpr); + } + if( affSQLITE_AFF_NUMERIC) aff = SQLITE_AFF_NUMERIC; + pIdx->zColAff[n] = aff; + } + pIdx->zColAff[n] = 0; + return pIdx->zColAff; +} +SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(sqlite3 *db, Index *pIdx){ + if( !pIdx->zColAff ) return computeIndexAffStr(db, pIdx); + return pIdx->zColAff; +} + + +/* +** Compute an affinity string for a table. Space is obtained +** from sqlite3DbMalloc(). The caller is responsible for freeing +** the space when done. +*/ +SQLITE_PRIVATE char *sqlite3TableAffinityStr(sqlite3 *db, const Table *pTab){ + char *zColAff; + zColAff = (char *)sqlite3DbMallocRaw(db, pTab->nCol+1); + if( zColAff ){ + int i, j; + for(i=j=0; inCol; i++){ + if( (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ){ + zColAff[j++] = pTab->aCol[i].affinity; + } + } + do{ + zColAff[j--] = 0; + }while( j>=0 && zColAff[j]<=SQLITE_AFF_BLOB ); + } + return zColAff; +} + +/* +** Make changes to the evolving bytecode to do affinity transformations +** of values that are about to be gathered into a row for table pTab. +** +** For ordinary (legacy, non-strict) tables: +** ----------------------------------------- +** +** Compute the affinity string for table pTab, if it has not already been +** computed. As an optimization, omit trailing SQLITE_AFF_BLOB affinities. +** +** If the affinity string is empty (because it was all SQLITE_AFF_BLOB entries +** which were then optimized out) then this routine becomes a no-op. +** +** Otherwise if iReg>0 then code an OP_Affinity opcode that will set the +** affinities for register iReg and following. Or if iReg==0, +** then just set the P4 operand of the previous opcode (which should be +** an OP_MakeRecord) to the affinity string. +** +** A column affinity string has one character per column: +** +** Character Column affinity +** --------- --------------- +** 'A' BLOB +** 'B' TEXT +** 'C' NUMERIC +** 'D' INTEGER +** 'E' REAL +** +** For STRICT tables: +** ------------------ +** +** Generate an appropropriate OP_TypeCheck opcode that will verify the +** datatypes against the column definitions in pTab. If iReg==0, that +** means an OP_MakeRecord opcode has already been generated and should be +** the last opcode generated. The new OP_TypeCheck needs to be inserted +** before the OP_MakeRecord. The new OP_TypeCheck should use the same +** register set as the OP_MakeRecord. If iReg>0 then register iReg is +** the first of a series of registers that will form the new record. +** Apply the type checking to that array of registers. +*/ +SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe *v, Table *pTab, int iReg){ + int i; + char *zColAff; + if( pTab->tabFlags & TF_Strict ){ + if( iReg==0 ){ + /* Move the previous opcode (which should be OP_MakeRecord) forward + ** by one slot and insert a new OP_TypeCheck where the current + ** OP_MakeRecord is found */ + VdbeOp *pPrev; + sqlite3VdbeAppendP4(v, pTab, P4_TABLE); + pPrev = sqlite3VdbeGetLastOp(v); + assert( pPrev!=0 ); + assert( pPrev->opcode==OP_MakeRecord || sqlite3VdbeDb(v)->mallocFailed ); + pPrev->opcode = OP_TypeCheck; + sqlite3VdbeAddOp3(v, OP_MakeRecord, pPrev->p1, pPrev->p2, pPrev->p3); + }else{ + /* Insert an isolated OP_Typecheck */ + sqlite3VdbeAddOp2(v, OP_TypeCheck, iReg, pTab->nNVCol); + sqlite3VdbeAppendP4(v, pTab, P4_TABLE); + } + return; + } + zColAff = pTab->zColAff; + if( zColAff==0 ){ + zColAff = sqlite3TableAffinityStr(0, pTab); + if( !zColAff ){ + sqlite3OomFault(sqlite3VdbeDb(v)); + return; + } + pTab->zColAff = zColAff; + } + assert( zColAff!=0 ); + i = sqlite3Strlen30NN(zColAff); + if( i ){ + if( iReg ){ + sqlite3VdbeAddOp4(v, OP_Affinity, iReg, i, 0, zColAff, i); + }else{ + assert( sqlite3VdbeGetLastOp(v)->opcode==OP_MakeRecord + || sqlite3VdbeDb(v)->mallocFailed ); + sqlite3VdbeChangeP4(v, -1, zColAff, i); + } + } +} + +/* +** Return non-zero if the table pTab in database iDb or any of its indices +** have been opened at any point in the VDBE program. This is used to see if +** a statement of the form "INSERT INTO SELECT ..." can +** run without using a temporary table for the results of the SELECT. +*/ +static int readsTable(Parse *p, int iDb, Table *pTab){ + Vdbe *v = sqlite3GetVdbe(p); + int i; + int iEnd = sqlite3VdbeCurrentAddr(v); +#ifndef SQLITE_OMIT_VIRTUALTABLE + VTable *pVTab = IsVirtual(pTab) ? sqlite3GetVTable(p->db, pTab) : 0; +#endif + + for(i=1; iopcode==OP_OpenRead && pOp->p3==iDb ){ + Index *pIndex; + Pgno tnum = pOp->p2; + if( tnum==pTab->tnum ){ + return 1; + } + for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){ + if( tnum==pIndex->tnum ){ + return 1; + } + } + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( pOp->opcode==OP_VOpen && pOp->p4.pVtab==pVTab ){ + assert( pOp->p4.pVtab!=0 ); + assert( pOp->p4type==P4_VTAB ); + return 1; + } +#endif + } + return 0; +} + +/* This walker callback will compute the union of colFlags flags for all +** referenced columns in a CHECK constraint or generated column expression. +*/ +static int exprColumnFlagUnion(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_COLUMN && pExpr->iColumn>=0 ){ + assert( pExpr->iColumn < pWalker->u.pTab->nCol ); + pWalker->eCode |= pWalker->u.pTab->aCol[pExpr->iColumn].colFlags; + } + return WRC_Continue; +} + +#ifndef SQLITE_OMIT_GENERATED_COLUMNS +/* +** All regular columns for table pTab have been puts into registers +** starting with iRegStore. The registers that correspond to STORED +** or VIRTUAL columns have not yet been initialized. This routine goes +** back and computes the values for those columns based on the previously +** computed normal columns. +*/ +SQLITE_PRIVATE void sqlite3ComputeGeneratedColumns( + Parse *pParse, /* Parsing context */ + int iRegStore, /* Register holding the first column */ + Table *pTab /* The table */ +){ + int i; + Walker w; + Column *pRedo; + int eProgress; + VdbeOp *pOp; + + assert( pTab->tabFlags & TF_HasGenerated ); + testcase( pTab->tabFlags & TF_HasVirtual ); + testcase( pTab->tabFlags & TF_HasStored ); + + /* Before computing generated columns, first go through and make sure + ** that appropriate affinity has been applied to the regular columns + */ + sqlite3TableAffinity(pParse->pVdbe, pTab, iRegStore); + if( (pTab->tabFlags & TF_HasStored)!=0 ){ + pOp = sqlite3VdbeGetLastOp(pParse->pVdbe); + if( pOp->opcode==OP_Affinity ){ + /* Change the OP_Affinity argument to '@' (NONE) for all stored + ** columns. '@' is the no-op affinity and those columns have not + ** yet been computed. */ + int ii, jj; + char *zP4 = pOp->p4.z; + assert( zP4!=0 ); + assert( pOp->p4type==P4_DYNAMIC ); + for(ii=jj=0; zP4[jj]; ii++){ + if( pTab->aCol[ii].colFlags & COLFLAG_VIRTUAL ){ + continue; + } + if( pTab->aCol[ii].colFlags & COLFLAG_STORED ){ + zP4[jj] = SQLITE_AFF_NONE; + } + jj++; + } + }else if( pOp->opcode==OP_TypeCheck ){ + /* If an OP_TypeCheck was generated because the table is STRICT, + ** then set the P3 operand to indicate that generated columns should + ** not be checked */ + pOp->p3 = 1; + } + } + + /* Because there can be multiple generated columns that refer to one another, + ** this is a two-pass algorithm. On the first pass, mark all generated + ** columns as "not available". + */ + for(i=0; inCol; i++){ + if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){ + testcase( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ); + testcase( pTab->aCol[i].colFlags & COLFLAG_STORED ); + pTab->aCol[i].colFlags |= COLFLAG_NOTAVAIL; + } + } + + w.u.pTab = pTab; + w.xExprCallback = exprColumnFlagUnion; + w.xSelectCallback = 0; + w.xSelectCallback2 = 0; + + /* On the second pass, compute the value of each NOT-AVAILABLE column. + ** Companion code in the TK_COLUMN case of sqlite3ExprCodeTarget() will + ** compute dependencies and mark remove the COLSPAN_NOTAVAIL mark, as + ** they are needed. + */ + pParse->iSelfTab = -iRegStore; + do{ + eProgress = 0; + pRedo = 0; + for(i=0; inCol; i++){ + Column *pCol = pTab->aCol + i; + if( (pCol->colFlags & COLFLAG_NOTAVAIL)!=0 ){ + int x; + pCol->colFlags |= COLFLAG_BUSY; + w.eCode = 0; + sqlite3WalkExpr(&w, sqlite3ColumnExpr(pTab, pCol)); + pCol->colFlags &= ~COLFLAG_BUSY; + if( w.eCode & COLFLAG_NOTAVAIL ){ + pRedo = pCol; + continue; + } + eProgress = 1; + assert( pCol->colFlags & COLFLAG_GENERATED ); + x = sqlite3TableColumnToStorage(pTab, i) + iRegStore; + sqlite3ExprCodeGeneratedColumn(pParse, pTab, pCol, x); + pCol->colFlags &= ~COLFLAG_NOTAVAIL; + } + } + }while( pRedo && eProgress ); + if( pRedo ){ + sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", pRedo->zCnName); + } + pParse->iSelfTab = 0; +} +#endif /* SQLITE_OMIT_GENERATED_COLUMNS */ + + +#ifndef SQLITE_OMIT_AUTOINCREMENT +/* +** Locate or create an AutoincInfo structure associated with table pTab +** which is in database iDb. Return the register number for the register +** that holds the maximum rowid. Return zero if pTab is not an AUTOINCREMENT +** table. (Also return zero when doing a VACUUM since we do not want to +** update the AUTOINCREMENT counters during a VACUUM.) +** +** There is at most one AutoincInfo structure per table even if the +** same table is autoincremented multiple times due to inserts within +** triggers. A new AutoincInfo structure is created if this is the +** first use of table pTab. On 2nd and subsequent uses, the original +** AutoincInfo structure is used. +** +** Four consecutive registers are allocated: +** +** (1) The name of the pTab table. +** (2) The maximum ROWID of pTab. +** (3) The rowid in sqlite_sequence of pTab +** (4) The original value of the max ROWID in pTab, or NULL if none +** +** The 2nd register is the one that is returned. That is all the +** insert routine needs to know about. +*/ +static int autoIncBegin( + Parse *pParse, /* Parsing context */ + int iDb, /* Index of the database holding pTab */ + Table *pTab /* The table we are writing to */ +){ + int memId = 0; /* Register holding maximum rowid */ + assert( pParse->db->aDb[iDb].pSchema!=0 ); + if( (pTab->tabFlags & TF_Autoincrement)!=0 + && (pParse->db->mDbFlags & DBFLAG_Vacuum)==0 + ){ + Parse *pToplevel = sqlite3ParseToplevel(pParse); + AutoincInfo *pInfo; + Table *pSeqTab = pParse->db->aDb[iDb].pSchema->pSeqTab; + + /* Verify that the sqlite_sequence table exists and is an ordinary + ** rowid table with exactly two columns. + ** Ticket d8dc2b3a58cd5dc2918a1d4acb 2018-05-23 */ + if( pSeqTab==0 + || !HasRowid(pSeqTab) + || NEVER(IsVirtual(pSeqTab)) + || pSeqTab->nCol!=2 + ){ + pParse->nErr++; + pParse->rc = SQLITE_CORRUPT_SEQUENCE; + return 0; + } + + pInfo = pToplevel->pAinc; + while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; } + if( pInfo==0 ){ + pInfo = sqlite3DbMallocRawNN(pParse->db, sizeof(*pInfo)); + sqlite3ParserAddCleanup(pToplevel, sqlite3DbFree, pInfo); + testcase( pParse->earlyCleanup ); + if( pParse->db->mallocFailed ) return 0; + pInfo->pNext = pToplevel->pAinc; + pToplevel->pAinc = pInfo; + pInfo->pTab = pTab; + pInfo->iDb = iDb; + pToplevel->nMem++; /* Register to hold name of table */ + pInfo->regCtr = ++pToplevel->nMem; /* Max rowid register */ + pToplevel->nMem +=2; /* Rowid in sqlite_sequence + orig max val */ + } + memId = pInfo->regCtr; + } + return memId; +} + +/* +** This routine generates code that will initialize all of the +** register used by the autoincrement tracker. +*/ +SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse){ + AutoincInfo *p; /* Information about an AUTOINCREMENT */ + sqlite3 *db = pParse->db; /* The database connection */ + Db *pDb; /* Database only autoinc table */ + int memId; /* Register holding max rowid */ + Vdbe *v = pParse->pVdbe; /* VDBE under construction */ + + /* This routine is never called during trigger-generation. It is + ** only called from the top-level */ + assert( pParse->pTriggerTab==0 ); + assert( sqlite3IsToplevel(pParse) ); + + assert( v ); /* We failed long ago if this is not so */ + for(p = pParse->pAinc; p; p = p->pNext){ + static const int iLn = VDBE_OFFSET_LINENO(2); + static const VdbeOpList autoInc[] = { + /* 0 */ {OP_Null, 0, 0, 0}, + /* 1 */ {OP_Rewind, 0, 10, 0}, + /* 2 */ {OP_Column, 0, 0, 0}, + /* 3 */ {OP_Ne, 0, 9, 0}, + /* 4 */ {OP_Rowid, 0, 0, 0}, + /* 5 */ {OP_Column, 0, 1, 0}, + /* 6 */ {OP_AddImm, 0, 0, 0}, + /* 7 */ {OP_Copy, 0, 0, 0}, + /* 8 */ {OP_Goto, 0, 11, 0}, + /* 9 */ {OP_Next, 0, 2, 0}, + /* 10 */ {OP_Integer, 0, 0, 0}, + /* 11 */ {OP_Close, 0, 0, 0} + }; + VdbeOp *aOp; + pDb = &db->aDb[p->iDb]; + memId = p->regCtr; + assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) ); + sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenRead); + sqlite3VdbeLoadString(v, memId-1, p->pTab->zName); + aOp = sqlite3VdbeAddOpList(v, ArraySize(autoInc), autoInc, iLn); + if( aOp==0 ) break; + aOp[0].p2 = memId; + aOp[0].p3 = memId+2; + aOp[2].p3 = memId; + aOp[3].p1 = memId-1; + aOp[3].p3 = memId; + aOp[3].p5 = SQLITE_JUMPIFNULL; + aOp[4].p2 = memId+1; + aOp[5].p3 = memId; + aOp[6].p1 = memId; + aOp[7].p2 = memId+2; + aOp[7].p1 = memId; + aOp[10].p2 = memId; + if( pParse->nTab==0 ) pParse->nTab = 1; + } +} + +/* +** Update the maximum rowid for an autoincrement calculation. +** +** This routine should be called when the regRowid register holds a +** new rowid that is about to be inserted. If that new rowid is +** larger than the maximum rowid in the memId memory cell, then the +** memory cell is updated. +*/ +static void autoIncStep(Parse *pParse, int memId, int regRowid){ + if( memId>0 ){ + sqlite3VdbeAddOp2(pParse->pVdbe, OP_MemMax, memId, regRowid); + } +} + +/* +** This routine generates the code needed to write autoincrement +** maximum rowid values back into the sqlite_sequence register. +** Every statement that might do an INSERT into an autoincrement +** table (either directly or through triggers) needs to call this +** routine just before the "exit" code. +*/ +static SQLITE_NOINLINE void autoIncrementEnd(Parse *pParse){ + AutoincInfo *p; + Vdbe *v = pParse->pVdbe; + sqlite3 *db = pParse->db; + + assert( v ); + for(p = pParse->pAinc; p; p = p->pNext){ + static const int iLn = VDBE_OFFSET_LINENO(2); + static const VdbeOpList autoIncEnd[] = { + /* 0 */ {OP_NotNull, 0, 2, 0}, + /* 1 */ {OP_NewRowid, 0, 0, 0}, + /* 2 */ {OP_MakeRecord, 0, 2, 0}, + /* 3 */ {OP_Insert, 0, 0, 0}, + /* 4 */ {OP_Close, 0, 0, 0} + }; + VdbeOp *aOp; + Db *pDb = &db->aDb[p->iDb]; + int iRec; + int memId = p->regCtr; + + iRec = sqlite3GetTempReg(pParse); + assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) ); + sqlite3VdbeAddOp3(v, OP_Le, memId+2, sqlite3VdbeCurrentAddr(v)+7, memId); + VdbeCoverage(v); + sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite); + aOp = sqlite3VdbeAddOpList(v, ArraySize(autoIncEnd), autoIncEnd, iLn); + if( aOp==0 ) break; + aOp[0].p1 = memId+1; + aOp[1].p2 = memId+1; + aOp[2].p1 = memId-1; + aOp[2].p3 = iRec; + aOp[3].p2 = iRec; + aOp[3].p3 = memId+1; + aOp[3].p5 = OPFLAG_APPEND; + sqlite3ReleaseTempReg(pParse, iRec); + } +} +SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse){ + if( pParse->pAinc ) autoIncrementEnd(pParse); +} +#else +/* +** If SQLITE_OMIT_AUTOINCREMENT is defined, then the three routines +** above are all no-ops +*/ +# define autoIncBegin(A,B,C) (0) +# define autoIncStep(A,B,C) +#endif /* SQLITE_OMIT_AUTOINCREMENT */ + + +/* Forward declaration */ +static int xferOptimization( + Parse *pParse, /* Parser context */ + Table *pDest, /* The table we are inserting into */ + Select *pSelect, /* A SELECT statement to use as the data source */ + int onError, /* How to handle constraint errors */ + int iDbDest /* The database of pDest */ +); + +/* +** This routine is called to handle SQL of the following forms: +** +** insert into TABLE (IDLIST) values(EXPRLIST),(EXPRLIST),... +** insert into TABLE (IDLIST) select +** insert into TABLE (IDLIST) default values +** +** The IDLIST following the table name is always optional. If omitted, +** then a list of all (non-hidden) columns for the table is substituted. +** The IDLIST appears in the pColumn parameter. pColumn is NULL if IDLIST +** is omitted. +** +** For the pSelect parameter holds the values to be inserted for the +** first two forms shown above. A VALUES clause is really just short-hand +** for a SELECT statement that omits the FROM clause and everything else +** that follows. If the pSelect parameter is NULL, that means that the +** DEFAULT VALUES form of the INSERT statement is intended. +** +** The code generated follows one of four templates. For a simple +** insert with data coming from a single-row VALUES clause, the code executes +** once straight down through. Pseudo-code follows (we call this +** the "1st template"): +** +** open write cursor to
and its indices +** put VALUES clause expressions into registers +** write the resulting record into
+** cleanup +** +** The three remaining templates assume the statement is of the form +** +** INSERT INTO
SELECT ... +** +** If the SELECT clause is of the restricted form "SELECT * FROM " - +** in other words if the SELECT pulls all columns from a single table +** and there is no WHERE or LIMIT or GROUP BY or ORDER BY clauses, and +** if and are distinct tables but have identical +** schemas, including all the same indices, then a special optimization +** is invoked that copies raw records from over to . +** See the xferOptimization() function for the implementation of this +** template. This is the 2nd template. +** +** open a write cursor to
+** open read cursor on +** transfer all records in over to
+** close cursors +** foreach index on
+** open a write cursor on the
index +** open a read cursor on the corresponding index +** transfer all records from the read to the write cursors +** close cursors +** end foreach +** +** The 3rd template is for when the second template does not apply +** and the SELECT clause does not read from
at any time. +** The generated code follows this template: +** +** X <- A +** goto B +** A: setup for the SELECT +** loop over the rows in the SELECT +** load values into registers R..R+n +** yield X +** end loop +** cleanup after the SELECT +** end-coroutine X +** B: open write cursor to
and its indices +** C: yield X, at EOF goto D +** insert the select result into
from R..R+n +** goto C +** D: cleanup +** +** The 4th template is used if the insert statement takes its +** values from a SELECT but the data is being inserted into a table +** that is also read as part of the SELECT. In the third form, +** we have to use an intermediate table to store the results of +** the select. The template is like this: +** +** X <- A +** goto B +** A: setup for the SELECT +** loop over the tables in the SELECT +** load value into register R..R+n +** yield X +** end loop +** cleanup after the SELECT +** end co-routine R +** B: open temp table +** L: yield X, at EOF goto M +** insert row from R..R+n into temp table +** goto L +** M: open write cursor to
and its indices +** rewind temp table +** C: loop over rows of intermediate table +** transfer values form intermediate table into
+** end loop +** D: cleanup +*/ +SQLITE_PRIVATE void sqlite3Insert( + Parse *pParse, /* Parser context */ + SrcList *pTabList, /* Name of table into which we are inserting */ + Select *pSelect, /* A SELECT statement to use as the data source */ + IdList *pColumn, /* Column names corresponding to IDLIST, or NULL. */ + int onError, /* How to handle constraint errors */ + Upsert *pUpsert /* ON CONFLICT clauses for upsert, or NULL */ +){ + sqlite3 *db; /* The main database structure */ + Table *pTab; /* The table to insert into. aka TABLE */ + int i, j; /* Loop counters */ + Vdbe *v; /* Generate code into this virtual machine */ + Index *pIdx; /* For looping over indices of the table */ + int nColumn; /* Number of columns in the data */ + int nHidden = 0; /* Number of hidden columns if TABLE is virtual */ + int iDataCur = 0; /* VDBE cursor that is the main data repository */ + int iIdxCur = 0; /* First index cursor */ + int ipkColumn = -1; /* Column that is the INTEGER PRIMARY KEY */ + int endOfLoop; /* Label for the end of the insertion loop */ + int srcTab = 0; /* Data comes from this temporary cursor if >=0 */ + int addrInsTop = 0; /* Jump to label "D" */ + int addrCont = 0; /* Top of insert loop. Label "C" in templates 3 and 4 */ + SelectDest dest; /* Destination for SELECT on rhs of INSERT */ + int iDb; /* Index of database holding TABLE */ + u8 useTempTable = 0; /* Store SELECT results in intermediate table */ + u8 appendFlag = 0; /* True if the insert is likely to be an append */ + u8 withoutRowid; /* 0 for normal table. 1 for WITHOUT ROWID table */ + u8 bIdListInOrder; /* True if IDLIST is in table order */ + ExprList *pList = 0; /* List of VALUES() to be inserted */ + int iRegStore; /* Register in which to store next column */ + + /* Register allocations */ + int regFromSelect = 0;/* Base register for data coming from SELECT */ + int regAutoinc = 0; /* Register holding the AUTOINCREMENT counter */ + int regRowCount = 0; /* Memory cell used for the row counter */ + int regIns; /* Block of regs holding rowid+data being inserted */ + int regRowid; /* registers holding insert rowid */ + int regData; /* register holding first column to insert */ + int *aRegIdx = 0; /* One register allocated to each index */ + +#ifndef SQLITE_OMIT_TRIGGER + int isView; /* True if attempting to insert into a view */ + Trigger *pTrigger; /* List of triggers on pTab, if required */ + int tmask; /* Mask of trigger times */ +#endif + + db = pParse->db; + assert( db->pParse==pParse ); + if( pParse->nErr ){ + goto insert_cleanup; + } + assert( db->mallocFailed==0 ); + dest.iSDParm = 0; /* Suppress a harmless compiler warning */ + + /* If the Select object is really just a simple VALUES() list with a + ** single row (the common case) then keep that one row of values + ** and discard the other (unused) parts of the pSelect object + */ + if( pSelect && (pSelect->selFlags & SF_Values)!=0 && pSelect->pPrior==0 ){ + pList = pSelect->pEList; + pSelect->pEList = 0; + sqlite3SelectDelete(db, pSelect); + pSelect = 0; + } + + /* Locate the table into which we will be inserting new information. + */ + assert( pTabList->nSrc==1 ); + pTab = sqlite3SrcListLookup(pParse, pTabList); + if( pTab==0 ){ + goto insert_cleanup; + } + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( iDbnDb ); + if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, + db->aDb[iDb].zDbSName) ){ + goto insert_cleanup; + } + withoutRowid = !HasRowid(pTab); + + /* Figure out if we have any triggers and if the table being + ** inserted into is a view + */ +#ifndef SQLITE_OMIT_TRIGGER + pTrigger = sqlite3TriggersExist(pParse, pTab, TK_INSERT, 0, &tmask); + isView = IsView(pTab); +#else +# define pTrigger 0 +# define tmask 0 +# define isView 0 +#endif +#ifdef SQLITE_OMIT_VIEW +# undef isView +# define isView 0 +#endif + assert( (pTrigger && tmask) || (pTrigger==0 && tmask==0) ); + +#if TREETRACE_ENABLED + if( sqlite3TreeTrace & 0x10000 ){ + sqlite3TreeViewLine(0, "In sqlite3Insert() at %s:%d", __FILE__, __LINE__); + sqlite3TreeViewInsert(pParse->pWith, pTabList, pColumn, pSelect, pList, + onError, pUpsert, pTrigger); + } +#endif + + /* If pTab is really a view, make sure it has been initialized. + ** ViewGetColumnNames() is a no-op if pTab is not a view. + */ + if( sqlite3ViewGetColumnNames(pParse, pTab) ){ + goto insert_cleanup; + } + + /* Cannot insert into a read-only table. + */ + if( sqlite3IsReadOnly(pParse, pTab, pTrigger) ){ + goto insert_cleanup; + } + + /* Allocate a VDBE + */ + v = sqlite3GetVdbe(pParse); + if( v==0 ) goto insert_cleanup; + if( pParse->nested==0 ) sqlite3VdbeCountChanges(v); + sqlite3BeginWriteOperation(pParse, pSelect || pTrigger, iDb); + +#ifndef SQLITE_OMIT_XFER_OPT + /* If the statement is of the form + ** + ** INSERT INTO SELECT * FROM ; + ** + ** Then special optimizations can be applied that make the transfer + ** very fast and which reduce fragmentation of indices. + ** + ** This is the 2nd template. + */ + if( pColumn==0 + && pSelect!=0 + && pTrigger==0 + && xferOptimization(pParse, pTab, pSelect, onError, iDb) + ){ + assert( !pTrigger ); + assert( pList==0 ); + goto insert_end; + } +#endif /* SQLITE_OMIT_XFER_OPT */ + + /* If this is an AUTOINCREMENT table, look up the sequence number in the + ** sqlite_sequence table and store it in memory cell regAutoinc. + */ + regAutoinc = autoIncBegin(pParse, iDb, pTab); + + /* Allocate a block registers to hold the rowid and the values + ** for all columns of the new row. + */ + regRowid = regIns = pParse->nMem+1; + pParse->nMem += pTab->nCol + 1; + if( IsVirtual(pTab) ){ + regRowid++; + pParse->nMem++; + } + regData = regRowid+1; + + /* If the INSERT statement included an IDLIST term, then make sure + ** all elements of the IDLIST really are columns of the table and + ** remember the column indices. + ** + ** If the table has an INTEGER PRIMARY KEY column and that column + ** is named in the IDLIST, then record in the ipkColumn variable + ** the index into IDLIST of the primary key column. ipkColumn is + ** the index of the primary key as it appears in IDLIST, not as + ** is appears in the original table. (The index of the INTEGER + ** PRIMARY KEY in the original table is pTab->iPKey.) After this + ** loop, if ipkColumn==(-1), that means that integer primary key + ** is unspecified, and hence the table is either WITHOUT ROWID or + ** it will automatically generated an integer primary key. + ** + ** bIdListInOrder is true if the columns in IDLIST are in storage + ** order. This enables an optimization that avoids shuffling the + ** columns into storage order. False negatives are harmless, + ** but false positives will cause database corruption. + */ + bIdListInOrder = (pTab->tabFlags & (TF_OOOHidden|TF_HasStored))==0; + if( pColumn ){ + assert( pColumn->eU4!=EU4_EXPR ); + pColumn->eU4 = EU4_IDX; + for(i=0; inId; i++){ + pColumn->a[i].u4.idx = -1; + } + for(i=0; inId; i++){ + for(j=0; jnCol; j++){ + if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zCnName)==0 ){ + pColumn->a[i].u4.idx = j; + if( i!=j ) bIdListInOrder = 0; + if( j==pTab->iPKey ){ + ipkColumn = i; assert( !withoutRowid ); + } +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + if( pTab->aCol[j].colFlags & (COLFLAG_STORED|COLFLAG_VIRTUAL) ){ + sqlite3ErrorMsg(pParse, + "cannot INSERT into generated column \"%s\"", + pTab->aCol[j].zCnName); + goto insert_cleanup; + } +#endif + break; + } + } + if( j>=pTab->nCol ){ + if( sqlite3IsRowid(pColumn->a[i].zName) && !withoutRowid ){ + ipkColumn = i; + bIdListInOrder = 0; + }else{ + sqlite3ErrorMsg(pParse, "table %S has no column named %s", + pTabList->a, pColumn->a[i].zName); + pParse->checkSchema = 1; + goto insert_cleanup; + } + } + } + } + + /* Figure out how many columns of data are supplied. If the data + ** is coming from a SELECT statement, then generate a co-routine that + ** produces a single row of the SELECT on each invocation. The + ** co-routine is the common header to the 3rd and 4th templates. + */ + if( pSelect ){ + /* Data is coming from a SELECT or from a multi-row VALUES clause. + ** Generate a co-routine to run the SELECT. */ + int regYield; /* Register holding co-routine entry-point */ + int addrTop; /* Top of the co-routine */ + int rc; /* Result code */ + + regYield = ++pParse->nMem; + addrTop = sqlite3VdbeCurrentAddr(v) + 1; + sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop); + sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield); + dest.iSdst = bIdListInOrder ? regData : 0; + dest.nSdst = pTab->nCol; + rc = sqlite3Select(pParse, pSelect, &dest); + regFromSelect = dest.iSdst; + assert( db->pParse==pParse ); + if( rc || pParse->nErr ) goto insert_cleanup; + assert( db->mallocFailed==0 ); + sqlite3VdbeEndCoroutine(v, regYield); + sqlite3VdbeJumpHere(v, addrTop - 1); /* label B: */ + assert( pSelect->pEList ); + nColumn = pSelect->pEList->nExpr; + + /* Set useTempTable to TRUE if the result of the SELECT statement + ** should be written into a temporary table (template 4). Set to + ** FALSE if each output row of the SELECT can be written directly into + ** the destination table (template 3). + ** + ** A temp table must be used if the table being updated is also one + ** of the tables being read by the SELECT statement. Also use a + ** temp table in the case of row triggers. + */ + if( pTrigger || readsTable(pParse, iDb, pTab) ){ + useTempTable = 1; + } + + if( useTempTable ){ + /* Invoke the coroutine to extract information from the SELECT + ** and add it to a transient table srcTab. The code generated + ** here is from the 4th template: + ** + ** B: open temp table + ** L: yield X, goto M at EOF + ** insert row from R..R+n into temp table + ** goto L + ** M: ... + */ + int regRec; /* Register to hold packed record */ + int regTempRowid; /* Register to hold temp table ROWID */ + int addrL; /* Label "L" */ + + srcTab = pParse->nTab++; + regRec = sqlite3GetTempReg(pParse); + regTempRowid = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp2(v, OP_OpenEphemeral, srcTab, nColumn); + addrL = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm); VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_MakeRecord, regFromSelect, nColumn, regRec); + sqlite3VdbeAddOp2(v, OP_NewRowid, srcTab, regTempRowid); + sqlite3VdbeAddOp3(v, OP_Insert, srcTab, regRec, regTempRowid); + sqlite3VdbeGoto(v, addrL); + sqlite3VdbeJumpHere(v, addrL); + sqlite3ReleaseTempReg(pParse, regRec); + sqlite3ReleaseTempReg(pParse, regTempRowid); + } + }else{ + /* This is the case if the data for the INSERT is coming from a + ** single-row VALUES clause + */ + NameContext sNC; + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + srcTab = -1; + assert( useTempTable==0 ); + if( pList ){ + nColumn = pList->nExpr; + if( sqlite3ResolveExprListNames(&sNC, pList) ){ + goto insert_cleanup; + } + }else{ + nColumn = 0; + } + } + + /* If there is no IDLIST term but the table has an integer primary + ** key, the set the ipkColumn variable to the integer primary key + ** column index in the original table definition. + */ + if( pColumn==0 && nColumn>0 ){ + ipkColumn = pTab->iPKey; +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + if( ipkColumn>=0 && (pTab->tabFlags & TF_HasGenerated)!=0 ){ + testcase( pTab->tabFlags & TF_HasVirtual ); + testcase( pTab->tabFlags & TF_HasStored ); + for(i=ipkColumn-1; i>=0; i--){ + if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){ + testcase( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ); + testcase( pTab->aCol[i].colFlags & COLFLAG_STORED ); + ipkColumn--; + } + } + } +#endif + + /* Make sure the number of columns in the source data matches the number + ** of columns to be inserted into the table. + */ + assert( TF_HasHidden==COLFLAG_HIDDEN ); + assert( TF_HasGenerated==COLFLAG_GENERATED ); + assert( COLFLAG_NOINSERT==(COLFLAG_GENERATED|COLFLAG_HIDDEN) ); + if( (pTab->tabFlags & (TF_HasGenerated|TF_HasHidden))!=0 ){ + for(i=0; inCol; i++){ + if( pTab->aCol[i].colFlags & COLFLAG_NOINSERT ) nHidden++; + } + } + if( nColumn!=(pTab->nCol-nHidden) ){ + sqlite3ErrorMsg(pParse, + "table %S has %d columns but %d values were supplied", + pTabList->a, pTab->nCol-nHidden, nColumn); + goto insert_cleanup; + } + } + if( pColumn!=0 && nColumn!=pColumn->nId ){ + sqlite3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId); + goto insert_cleanup; + } + + /* Initialize the count of rows to be inserted + */ + if( (db->flags & SQLITE_CountRows)!=0 + && !pParse->nested + && !pParse->pTriggerTab + && !pParse->bReturning + ){ + regRowCount = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount); + } + + /* If this is not a view, open the table and and all indices */ + if( !isView ){ + int nIdx; + nIdx = sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, -1, 0, + &iDataCur, &iIdxCur); + aRegIdx = sqlite3DbMallocRawNN(db, sizeof(int)*(nIdx+2)); + if( aRegIdx==0 ){ + goto insert_cleanup; + } + for(i=0, pIdx=pTab->pIndex; ipNext, i++){ + assert( pIdx ); + aRegIdx[i] = ++pParse->nMem; + pParse->nMem += pIdx->nColumn; + } + aRegIdx[i] = ++pParse->nMem; /* Register to store the table record */ + } +#ifndef SQLITE_OMIT_UPSERT + if( pUpsert ){ + Upsert *pNx; + if( IsVirtual(pTab) ){ + sqlite3ErrorMsg(pParse, "UPSERT not implemented for virtual table \"%s\"", + pTab->zName); + goto insert_cleanup; + } + if( IsView(pTab) ){ + sqlite3ErrorMsg(pParse, "cannot UPSERT a view"); + goto insert_cleanup; + } + if( sqlite3HasExplicitNulls(pParse, pUpsert->pUpsertTarget) ){ + goto insert_cleanup; + } + pTabList->a[0].iCursor = iDataCur; + pNx = pUpsert; + do{ + pNx->pUpsertSrc = pTabList; + pNx->regData = regData; + pNx->iDataCur = iDataCur; + pNx->iIdxCur = iIdxCur; + if( pNx->pUpsertTarget ){ + if( sqlite3UpsertAnalyzeTarget(pParse, pTabList, pNx) ){ + goto insert_cleanup; + } + } + pNx = pNx->pNextUpsert; + }while( pNx!=0 ); + } +#endif + + + /* This is the top of the main insertion loop */ + if( useTempTable ){ + /* This block codes the top of loop only. The complete loop is the + ** following pseudocode (template 4): + ** + ** rewind temp table, if empty goto D + ** C: loop over rows of intermediate table + ** transfer values form intermediate table into
+ ** end loop + ** D: ... + */ + addrInsTop = sqlite3VdbeAddOp1(v, OP_Rewind, srcTab); VdbeCoverage(v); + addrCont = sqlite3VdbeCurrentAddr(v); + }else if( pSelect ){ + /* This block codes the top of loop only. The complete loop is the + ** following pseudocode (template 3): + ** + ** C: yield X, at EOF goto D + ** insert the select result into
from R..R+n + ** goto C + ** D: ... + */ + sqlite3VdbeReleaseRegisters(pParse, regData, pTab->nCol, 0, 0); + addrInsTop = addrCont = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm); + VdbeCoverage(v); + if( ipkColumn>=0 ){ + /* tag-20191021-001: If the INTEGER PRIMARY KEY is being generated by the + ** SELECT, go ahead and copy the value into the rowid slot now, so that + ** the value does not get overwritten by a NULL at tag-20191021-002. */ + sqlite3VdbeAddOp2(v, OP_Copy, regFromSelect+ipkColumn, regRowid); + } + } + + /* Compute data for ordinary columns of the new entry. Values + ** are written in storage order into registers starting with regData. + ** Only ordinary columns are computed in this loop. The rowid + ** (if there is one) is computed later and generated columns are + ** computed after the rowid since they might depend on the value + ** of the rowid. + */ + nHidden = 0; + iRegStore = regData; assert( regData==regRowid+1 ); + for(i=0; inCol; i++, iRegStore++){ + int k; + u32 colFlags; + assert( i>=nHidden ); + if( i==pTab->iPKey ){ + /* tag-20191021-002: References to the INTEGER PRIMARY KEY are filled + ** using the rowid. So put a NULL in the IPK slot of the record to avoid + ** using excess space. The file format definition requires this extra + ** NULL - we cannot optimize further by skipping the column completely */ + sqlite3VdbeAddOp1(v, OP_SoftNull, iRegStore); + continue; + } + if( ((colFlags = pTab->aCol[i].colFlags) & COLFLAG_NOINSERT)!=0 ){ + nHidden++; + if( (colFlags & COLFLAG_VIRTUAL)!=0 ){ + /* Virtual columns do not participate in OP_MakeRecord. So back up + ** iRegStore by one slot to compensate for the iRegStore++ in the + ** outer for() loop */ + iRegStore--; + continue; + }else if( (colFlags & COLFLAG_STORED)!=0 ){ + /* Stored columns are computed later. But if there are BEFORE + ** triggers, the slots used for stored columns will be OP_Copy-ed + ** to a second block of registers, so the register needs to be + ** initialized to NULL to avoid an uninitialized register read */ + if( tmask & TRIGGER_BEFORE ){ + sqlite3VdbeAddOp1(v, OP_SoftNull, iRegStore); + } + continue; + }else if( pColumn==0 ){ + /* Hidden columns that are not explicitly named in the INSERT + ** get there default value */ + sqlite3ExprCodeFactorable(pParse, + sqlite3ColumnExpr(pTab, &pTab->aCol[i]), + iRegStore); + continue; + } + } + if( pColumn ){ + assert( pColumn->eU4==EU4_IDX ); + for(j=0; jnId && pColumn->a[j].u4.idx!=i; j++){} + if( j>=pColumn->nId ){ + /* A column not named in the insert column list gets its + ** default value */ + sqlite3ExprCodeFactorable(pParse, + sqlite3ColumnExpr(pTab, &pTab->aCol[i]), + iRegStore); + continue; + } + k = j; + }else if( nColumn==0 ){ + /* This is INSERT INTO ... DEFAULT VALUES. Load the default value. */ + sqlite3ExprCodeFactorable(pParse, + sqlite3ColumnExpr(pTab, &pTab->aCol[i]), + iRegStore); + continue; + }else{ + k = i - nHidden; + } + + if( useTempTable ){ + sqlite3VdbeAddOp3(v, OP_Column, srcTab, k, iRegStore); + }else if( pSelect ){ + if( regFromSelect!=regData ){ + sqlite3VdbeAddOp2(v, OP_SCopy, regFromSelect+k, iRegStore); + } + }else{ + Expr *pX = pList->a[k].pExpr; + int y = sqlite3ExprCodeTarget(pParse, pX, iRegStore); + if( y!=iRegStore ){ + sqlite3VdbeAddOp2(v, + ExprHasProperty(pX, EP_Subquery) ? OP_Copy : OP_SCopy, y, iRegStore); + } + } + } + + + /* Run the BEFORE and INSTEAD OF triggers, if there are any + */ + endOfLoop = sqlite3VdbeMakeLabel(pParse); + if( tmask & TRIGGER_BEFORE ){ + int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1); + + /* build the NEW.* reference row. Note that if there is an INTEGER + ** PRIMARY KEY into which a NULL is being inserted, that NULL will be + ** translated into a unique ID for the row. But on a BEFORE trigger, + ** we do not know what the unique ID will be (because the insert has + ** not happened yet) so we substitute a rowid of -1 + */ + if( ipkColumn<0 ){ + sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols); + }else{ + int addr1; + assert( !withoutRowid ); + if( useTempTable ){ + sqlite3VdbeAddOp3(v, OP_Column, srcTab, ipkColumn, regCols); + }else{ + assert( pSelect==0 ); /* Otherwise useTempTable is true */ + sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regCols); + } + addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, regCols); VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols); + sqlite3VdbeJumpHere(v, addr1); + sqlite3VdbeAddOp1(v, OP_MustBeInt, regCols); VdbeCoverage(v); + } + + /* Copy the new data already generated. */ + assert( pTab->nNVCol>0 || pParse->nErr>0 ); + sqlite3VdbeAddOp3(v, OP_Copy, regRowid+1, regCols+1, pTab->nNVCol-1); + +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + /* Compute the new value for generated columns after all other + ** columns have already been computed. This must be done after + ** computing the ROWID in case one of the generated columns + ** refers to the ROWID. */ + if( pTab->tabFlags & TF_HasGenerated ){ + testcase( pTab->tabFlags & TF_HasVirtual ); + testcase( pTab->tabFlags & TF_HasStored ); + sqlite3ComputeGeneratedColumns(pParse, regCols+1, pTab); + } +#endif + + /* If this is an INSERT on a view with an INSTEAD OF INSERT trigger, + ** do not attempt any conversions before assembling the record. + ** If this is a real table, attempt conversions as required by the + ** table column affinities. + */ + if( !isView ){ + sqlite3TableAffinity(v, pTab, regCols+1); + } + + /* Fire BEFORE or INSTEAD OF triggers */ + sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_BEFORE, + pTab, regCols-pTab->nCol-1, onError, endOfLoop); + + sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1); + } + + if( !isView ){ + if( IsVirtual(pTab) ){ + /* The row that the VUpdate opcode will delete: none */ + sqlite3VdbeAddOp2(v, OP_Null, 0, regIns); + } + if( ipkColumn>=0 ){ + /* Compute the new rowid */ + if( useTempTable ){ + sqlite3VdbeAddOp3(v, OP_Column, srcTab, ipkColumn, regRowid); + }else if( pSelect ){ + /* Rowid already initialized at tag-20191021-001 */ + }else{ + Expr *pIpk = pList->a[ipkColumn].pExpr; + if( pIpk->op==TK_NULL && !IsVirtual(pTab) ){ + sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc); + appendFlag = 1; + }else{ + sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regRowid); + } + } + /* If the PRIMARY KEY expression is NULL, then use OP_NewRowid + ** to generate a unique primary key value. + */ + if( !appendFlag ){ + int addr1; + if( !IsVirtual(pTab) ){ + addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, regRowid); VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc); + sqlite3VdbeJumpHere(v, addr1); + }else{ + addr1 = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp2(v, OP_IsNull, regRowid, addr1+2); VdbeCoverage(v); + } + sqlite3VdbeAddOp1(v, OP_MustBeInt, regRowid); VdbeCoverage(v); + } + }else if( IsVirtual(pTab) || withoutRowid ){ + sqlite3VdbeAddOp2(v, OP_Null, 0, regRowid); + }else{ + sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc); + appendFlag = 1; + } + autoIncStep(pParse, regAutoinc, regRowid); + +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + /* Compute the new value for generated columns after all other + ** columns have already been computed. This must be done after + ** computing the ROWID in case one of the generated columns + ** is derived from the INTEGER PRIMARY KEY. */ + if( pTab->tabFlags & TF_HasGenerated ){ + sqlite3ComputeGeneratedColumns(pParse, regRowid+1, pTab); + } +#endif + + /* Generate code to check constraints and generate index keys and + ** do the insertion. + */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTab) ){ + const char *pVTab = (const char *)sqlite3GetVTable(db, pTab); + sqlite3VtabMakeWritable(pParse, pTab); + sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB); + sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError); + sqlite3MayAbort(pParse); + }else +#endif + { + int isReplace = 0;/* Set to true if constraints may cause a replace */ + int bUseSeek; /* True to use OPFLAG_SEEKRESULT */ + sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur, + regIns, 0, ipkColumn>=0, onError, endOfLoop, &isReplace, 0, pUpsert + ); + if( db->flags & SQLITE_ForeignKeys ){ + sqlite3FkCheck(pParse, pTab, 0, regIns, 0, 0); + } + + /* Set the OPFLAG_USESEEKRESULT flag if either (a) there are no REPLACE + ** constraints or (b) there are no triggers and this table is not a + ** parent table in a foreign key constraint. It is safe to set the + ** flag in the second case as if any REPLACE constraint is hit, an + ** OP_Delete or OP_IdxDelete instruction will be executed on each + ** cursor that is disturbed. And these instructions both clear the + ** VdbeCursor.seekResult variable, disabling the OPFLAG_USESEEKRESULT + ** functionality. */ + bUseSeek = (isReplace==0 || !sqlite3VdbeHasSubProgram(v)); + sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur, + regIns, aRegIdx, 0, appendFlag, bUseSeek + ); + } +#ifdef SQLITE_ALLOW_ROWID_IN_VIEW + }else if( pParse->bReturning ){ + /* If there is a RETURNING clause, populate the rowid register with + ** constant value -1, in case one or more of the returned expressions + ** refer to the "rowid" of the view. */ + sqlite3VdbeAddOp2(v, OP_Integer, -1, regRowid); +#endif + } + + /* Update the count of rows that are inserted + */ + if( regRowCount ){ + sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1); + } + + if( pTrigger ){ + /* Code AFTER triggers */ + sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_AFTER, + pTab, regData-2-pTab->nCol, onError, endOfLoop); + } + + /* The bottom of the main insertion loop, if the data source + ** is a SELECT statement. + */ + sqlite3VdbeResolveLabel(v, endOfLoop); + if( useTempTable ){ + sqlite3VdbeAddOp2(v, OP_Next, srcTab, addrCont); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addrInsTop); + sqlite3VdbeAddOp1(v, OP_Close, srcTab); + }else if( pSelect ){ + sqlite3VdbeGoto(v, addrCont); +#ifdef SQLITE_DEBUG + /* If we are jumping back to an OP_Yield that is preceded by an + ** OP_ReleaseReg, set the p5 flag on the OP_Goto so that the + ** OP_ReleaseReg will be included in the loop. */ + if( sqlite3VdbeGetOp(v, addrCont-1)->opcode==OP_ReleaseReg ){ + assert( sqlite3VdbeGetOp(v, addrCont)->opcode==OP_Yield ); + sqlite3VdbeChangeP5(v, 1); + } +#endif + sqlite3VdbeJumpHere(v, addrInsTop); + } + +#ifndef SQLITE_OMIT_XFER_OPT +insert_end: +#endif /* SQLITE_OMIT_XFER_OPT */ + /* Update the sqlite_sequence table by storing the content of the + ** maximum rowid counter values recorded while inserting into + ** autoincrement tables. + */ + if( pParse->nested==0 && pParse->pTriggerTab==0 ){ + sqlite3AutoincrementEnd(pParse); + } + + /* + ** Return the number of rows inserted. If this routine is + ** generating code because of a call to sqlite3NestedParse(), do not + ** invoke the callback function. + */ + if( regRowCount ){ + sqlite3CodeChangeCount(v, regRowCount, "rows inserted"); + } + +insert_cleanup: + sqlite3SrcListDelete(db, pTabList); + sqlite3ExprListDelete(db, pList); + sqlite3UpsertDelete(db, pUpsert); + sqlite3SelectDelete(db, pSelect); + sqlite3IdListDelete(db, pColumn); + if( aRegIdx ) sqlite3DbNNFreeNN(db, aRegIdx); +} + +/* Make sure "isView" and other macros defined above are undefined. Otherwise +** they may interfere with compilation of other functions in this file +** (or in another file, if this file becomes part of the amalgamation). */ +#ifdef isView + #undef isView +#endif +#ifdef pTrigger + #undef pTrigger +#endif +#ifdef tmask + #undef tmask +#endif + +/* +** Meanings of bits in of pWalker->eCode for +** sqlite3ExprReferencesUpdatedColumn() +*/ +#define CKCNSTRNT_COLUMN 0x01 /* CHECK constraint uses a changing column */ +#define CKCNSTRNT_ROWID 0x02 /* CHECK constraint references the ROWID */ + +/* This is the Walker callback from sqlite3ExprReferencesUpdatedColumn(). +* Set bit 0x01 of pWalker->eCode if pWalker->eCode to 0 and if this +** expression node references any of the +** columns that are being modifed by an UPDATE statement. +*/ +static int checkConstraintExprNode(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_COLUMN ){ + assert( pExpr->iColumn>=0 || pExpr->iColumn==-1 ); + if( pExpr->iColumn>=0 ){ + if( pWalker->u.aiCol[pExpr->iColumn]>=0 ){ + pWalker->eCode |= CKCNSTRNT_COLUMN; + } + }else{ + pWalker->eCode |= CKCNSTRNT_ROWID; + } + } + return WRC_Continue; +} + +/* +** pExpr is a CHECK constraint on a row that is being UPDATE-ed. The +** only columns that are modified by the UPDATE are those for which +** aiChng[i]>=0, and also the ROWID is modified if chngRowid is true. +** +** Return true if CHECK constraint pExpr uses any of the +** changing columns (or the rowid if it is changing). In other words, +** return true if this CHECK constraint must be validated for +** the new row in the UPDATE statement. +** +** 2018-09-15: pExpr might also be an expression for an index-on-expressions. +** The operation of this routine is the same - return true if an only if +** the expression uses one or more of columns identified by the second and +** third arguments. +*/ +SQLITE_PRIVATE int sqlite3ExprReferencesUpdatedColumn( + Expr *pExpr, /* The expression to be checked */ + int *aiChng, /* aiChng[x]>=0 if column x changed by the UPDATE */ + int chngRowid /* True if UPDATE changes the rowid */ +){ + Walker w; + memset(&w, 0, sizeof(w)); + w.eCode = 0; + w.xExprCallback = checkConstraintExprNode; + w.u.aiCol = aiChng; + sqlite3WalkExpr(&w, pExpr); + if( !chngRowid ){ + testcase( (w.eCode & CKCNSTRNT_ROWID)!=0 ); + w.eCode &= ~CKCNSTRNT_ROWID; + } + testcase( w.eCode==0 ); + testcase( w.eCode==CKCNSTRNT_COLUMN ); + testcase( w.eCode==CKCNSTRNT_ROWID ); + testcase( w.eCode==(CKCNSTRNT_ROWID|CKCNSTRNT_COLUMN) ); + return w.eCode!=0; +} + +/* +** The sqlite3GenerateConstraintChecks() routine usually wants to visit +** the indexes of a table in the order provided in the Table->pIndex list. +** However, sometimes (rarely - when there is an upsert) it wants to visit +** the indexes in a different order. The following data structures accomplish +** this. +** +** The IndexIterator object is used to walk through all of the indexes +** of a table in either Index.pNext order, or in some other order established +** by an array of IndexListTerm objects. +*/ +typedef struct IndexListTerm IndexListTerm; +typedef struct IndexIterator IndexIterator; +struct IndexIterator { + int eType; /* 0 for Index.pNext list. 1 for an array of IndexListTerm */ + int i; /* Index of the current item from the list */ + union { + struct { /* Use this object for eType==0: A Index.pNext list */ + Index *pIdx; /* The current Index */ + } lx; + struct { /* Use this object for eType==1; Array of IndexListTerm */ + int nIdx; /* Size of the array */ + IndexListTerm *aIdx; /* Array of IndexListTerms */ + } ax; + } u; +}; + +/* When IndexIterator.eType==1, then each index is an array of instances +** of the following object +*/ +struct IndexListTerm { + Index *p; /* The index */ + int ix; /* Which entry in the original Table.pIndex list is this index*/ +}; + +/* Return the first index on the list */ +static Index *indexIteratorFirst(IndexIterator *pIter, int *pIx){ + assert( pIter->i==0 ); + if( pIter->eType ){ + *pIx = pIter->u.ax.aIdx[0].ix; + return pIter->u.ax.aIdx[0].p; + }else{ + *pIx = 0; + return pIter->u.lx.pIdx; + } +} + +/* Return the next index from the list. Return NULL when out of indexes */ +static Index *indexIteratorNext(IndexIterator *pIter, int *pIx){ + if( pIter->eType ){ + int i = ++pIter->i; + if( i>=pIter->u.ax.nIdx ){ + *pIx = i; + return 0; + } + *pIx = pIter->u.ax.aIdx[i].ix; + return pIter->u.ax.aIdx[i].p; + }else{ + ++(*pIx); + pIter->u.lx.pIdx = pIter->u.lx.pIdx->pNext; + return pIter->u.lx.pIdx; + } +} + +/* +** Generate code to do constraint checks prior to an INSERT or an UPDATE +** on table pTab. +** +** The regNewData parameter is the first register in a range that contains +** the data to be inserted or the data after the update. There will be +** pTab->nCol+1 registers in this range. The first register (the one +** that regNewData points to) will contain the new rowid, or NULL in the +** case of a WITHOUT ROWID table. The second register in the range will +** contain the content of the first table column. The third register will +** contain the content of the second table column. And so forth. +** +** The regOldData parameter is similar to regNewData except that it contains +** the data prior to an UPDATE rather than afterwards. regOldData is zero +** for an INSERT. This routine can distinguish between UPDATE and INSERT by +** checking regOldData for zero. +** +** For an UPDATE, the pkChng boolean is true if the true primary key (the +** rowid for a normal table or the PRIMARY KEY for a WITHOUT ROWID table) +** might be modified by the UPDATE. If pkChng is false, then the key of +** the iDataCur content table is guaranteed to be unchanged by the UPDATE. +** +** For an INSERT, the pkChng boolean indicates whether or not the rowid +** was explicitly specified as part of the INSERT statement. If pkChng +** is zero, it means that the either rowid is computed automatically or +** that the table is a WITHOUT ROWID table and has no rowid. On an INSERT, +** pkChng will only be true if the INSERT statement provides an integer +** value for either the rowid column or its INTEGER PRIMARY KEY alias. +** +** The code generated by this routine will store new index entries into +** registers identified by aRegIdx[]. No index entry is created for +** indices where aRegIdx[i]==0. The order of indices in aRegIdx[] is +** the same as the order of indices on the linked list of indices +** at pTab->pIndex. +** +** (2019-05-07) The generated code also creates a new record for the +** main table, if pTab is a rowid table, and stores that record in the +** register identified by aRegIdx[nIdx] - in other words in the first +** entry of aRegIdx[] past the last index. It is important that the +** record be generated during constraint checks to avoid affinity changes +** to the register content that occur after constraint checks but before +** the new record is inserted. +** +** The caller must have already opened writeable cursors on the main +** table and all applicable indices (that is to say, all indices for which +** aRegIdx[] is not zero). iDataCur is the cursor for the main table when +** inserting or updating a rowid table, or the cursor for the PRIMARY KEY +** index when operating on a WITHOUT ROWID table. iIdxCur is the cursor +** for the first index in the pTab->pIndex list. Cursors for other indices +** are at iIdxCur+N for the N-th element of the pTab->pIndex list. +** +** This routine also generates code to check constraints. NOT NULL, +** CHECK, and UNIQUE constraints are all checked. If a constraint fails, +** then the appropriate action is performed. There are five possible +** actions: ROLLBACK, ABORT, FAIL, REPLACE, and IGNORE. +** +** Constraint type Action What Happens +** --------------- ---------- ---------------------------------------- +** any ROLLBACK The current transaction is rolled back and +** sqlite3_step() returns immediately with a +** return code of SQLITE_CONSTRAINT. +** +** any ABORT Back out changes from the current command +** only (do not do a complete rollback) then +** cause sqlite3_step() to return immediately +** with SQLITE_CONSTRAINT. +** +** any FAIL Sqlite3_step() returns immediately with a +** return code of SQLITE_CONSTRAINT. The +** transaction is not rolled back and any +** changes to prior rows are retained. +** +** any IGNORE The attempt in insert or update the current +** row is skipped, without throwing an error. +** Processing continues with the next row. +** (There is an immediate jump to ignoreDest.) +** +** NOT NULL REPLACE The NULL value is replace by the default +** value for that column. If the default value +** is NULL, the action is the same as ABORT. +** +** UNIQUE REPLACE The other row that conflicts with the row +** being inserted is removed. +** +** CHECK REPLACE Illegal. The results in an exception. +** +** Which action to take is determined by the overrideError parameter. +** Or if overrideError==OE_Default, then the pParse->onError parameter +** is used. Or if pParse->onError==OE_Default then the onError value +** for the constraint is used. +*/ +SQLITE_PRIVATE void sqlite3GenerateConstraintChecks( + Parse *pParse, /* The parser context */ + Table *pTab, /* The table being inserted or updated */ + int *aRegIdx, /* Use register aRegIdx[i] for index i. 0 for unused */ + int iDataCur, /* Canonical data cursor (main table or PK index) */ + int iIdxCur, /* First index cursor */ + int regNewData, /* First register in a range holding values to insert */ + int regOldData, /* Previous content. 0 for INSERTs */ + u8 pkChng, /* Non-zero if the rowid or PRIMARY KEY changed */ + u8 overrideError, /* Override onError to this if not OE_Default */ + int ignoreDest, /* Jump to this label on an OE_Ignore resolution */ + int *pbMayReplace, /* OUT: Set to true if constraint may cause a replace */ + int *aiChng, /* column i is unchanged if aiChng[i]<0 */ + Upsert *pUpsert /* ON CONFLICT clauses, if any. NULL otherwise */ +){ + Vdbe *v; /* VDBE under constrution */ + Index *pIdx; /* Pointer to one of the indices */ + Index *pPk = 0; /* The PRIMARY KEY index for WITHOUT ROWID tables */ + sqlite3 *db; /* Database connection */ + int i; /* loop counter */ + int ix; /* Index loop counter */ + int nCol; /* Number of columns */ + int onError; /* Conflict resolution strategy */ + int seenReplace = 0; /* True if REPLACE is used to resolve INT PK conflict */ + int nPkField; /* Number of fields in PRIMARY KEY. 1 for ROWID tables */ + Upsert *pUpsertClause = 0; /* The specific ON CONFLICT clause for pIdx */ + u8 isUpdate; /* True if this is an UPDATE operation */ + u8 bAffinityDone = 0; /* True if the OP_Affinity operation has been run */ + int upsertIpkReturn = 0; /* Address of Goto at end of IPK uniqueness check */ + int upsertIpkDelay = 0; /* Address of Goto to bypass initial IPK check */ + int ipkTop = 0; /* Top of the IPK uniqueness check */ + int ipkBottom = 0; /* OP_Goto at the end of the IPK uniqueness check */ + /* Variables associated with retesting uniqueness constraints after + ** replace triggers fire have run */ + int regTrigCnt; /* Register used to count replace trigger invocations */ + int addrRecheck = 0; /* Jump here to recheck all uniqueness constraints */ + int lblRecheckOk = 0; /* Each recheck jumps to this label if it passes */ + Trigger *pTrigger; /* List of DELETE triggers on the table pTab */ + int nReplaceTrig = 0; /* Number of replace triggers coded */ + IndexIterator sIdxIter; /* Index iterator */ + + isUpdate = regOldData!=0; + db = pParse->db; + v = pParse->pVdbe; + assert( v!=0 ); + assert( !IsView(pTab) ); /* This table is not a VIEW */ + nCol = pTab->nCol; + + /* pPk is the PRIMARY KEY index for WITHOUT ROWID tables and NULL for + ** normal rowid tables. nPkField is the number of key fields in the + ** pPk index or 1 for a rowid table. In other words, nPkField is the + ** number of fields in the true primary key of the table. */ + if( HasRowid(pTab) ){ + pPk = 0; + nPkField = 1; + }else{ + pPk = sqlite3PrimaryKeyIndex(pTab); + nPkField = pPk->nKeyCol; + } + + /* Record that this module has started */ + VdbeModuleComment((v, "BEGIN: GenCnstCks(%d,%d,%d,%d,%d)", + iDataCur, iIdxCur, regNewData, regOldData, pkChng)); + + /* Test all NOT NULL constraints. + */ + if( pTab->tabFlags & TF_HasNotNull ){ + int b2ndPass = 0; /* True if currently running 2nd pass */ + int nSeenReplace = 0; /* Number of ON CONFLICT REPLACE operations */ + int nGenerated = 0; /* Number of generated columns with NOT NULL */ + while(1){ /* Make 2 passes over columns. Exit loop via "break" */ + for(i=0; iaCol[i]; /* The column to check for NOT NULL */ + int isGenerated; /* non-zero if column is generated */ + onError = pCol->notNull; + if( onError==OE_None ) continue; /* No NOT NULL on this column */ + if( i==pTab->iPKey ){ + continue; /* ROWID is never NULL */ + } + isGenerated = pCol->colFlags & COLFLAG_GENERATED; + if( isGenerated && !b2ndPass ){ + nGenerated++; + continue; /* Generated columns processed on 2nd pass */ + } + if( aiChng && aiChng[i]<0 && !isGenerated ){ + /* Do not check NOT NULL on columns that do not change */ + continue; + } + if( overrideError!=OE_Default ){ + onError = overrideError; + }else if( onError==OE_Default ){ + onError = OE_Abort; + } + if( onError==OE_Replace ){ + if( b2ndPass /* REPLACE becomes ABORT on the 2nd pass */ + || pCol->iDflt==0 /* REPLACE is ABORT if no DEFAULT value */ + ){ + testcase( pCol->colFlags & COLFLAG_VIRTUAL ); + testcase( pCol->colFlags & COLFLAG_STORED ); + testcase( pCol->colFlags & COLFLAG_GENERATED ); + onError = OE_Abort; + }else{ + assert( !isGenerated ); + } + }else if( b2ndPass && !isGenerated ){ + continue; + } + assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail + || onError==OE_Ignore || onError==OE_Replace ); + testcase( i!=sqlite3TableColumnToStorage(pTab, i) ); + iReg = sqlite3TableColumnToStorage(pTab, i) + regNewData + 1; + switch( onError ){ + case OE_Replace: { + int addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, iReg); + VdbeCoverage(v); + assert( (pCol->colFlags & COLFLAG_GENERATED)==0 ); + nSeenReplace++; + sqlite3ExprCodeCopy(pParse, + sqlite3ColumnExpr(pTab, pCol), iReg); + sqlite3VdbeJumpHere(v, addr1); + break; + } + case OE_Abort: + sqlite3MayAbort(pParse); + /* no break */ deliberate_fall_through + case OE_Rollback: + case OE_Fail: { + char *zMsg = sqlite3MPrintf(db, "%s.%s", pTab->zName, + pCol->zCnName); + testcase( zMsg==0 && db->mallocFailed==0 ); + sqlite3VdbeAddOp3(v, OP_HaltIfNull, SQLITE_CONSTRAINT_NOTNULL, + onError, iReg); + sqlite3VdbeAppendP4(v, zMsg, P4_DYNAMIC); + sqlite3VdbeChangeP5(v, P5_ConstraintNotNull); + VdbeCoverage(v); + break; + } + default: { + assert( onError==OE_Ignore ); + sqlite3VdbeAddOp2(v, OP_IsNull, iReg, ignoreDest); + VdbeCoverage(v); + break; + } + } /* end switch(onError) */ + } /* end loop i over columns */ + if( nGenerated==0 && nSeenReplace==0 ){ + /* If there are no generated columns with NOT NULL constraints + ** and no NOT NULL ON CONFLICT REPLACE constraints, then a single + ** pass is sufficient */ + break; + } + if( b2ndPass ) break; /* Never need more than 2 passes */ + b2ndPass = 1; +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + if( nSeenReplace>0 && (pTab->tabFlags & TF_HasGenerated)!=0 ){ + /* If any NOT NULL ON CONFLICT REPLACE constraints fired on the + ** first pass, recomputed values for all generated columns, as + ** those values might depend on columns affected by the REPLACE. + */ + sqlite3ComputeGeneratedColumns(pParse, regNewData+1, pTab); + } +#endif + } /* end of 2-pass loop */ + } /* end if( has-not-null-constraints ) */ + + /* Test all CHECK constraints + */ +#ifndef SQLITE_OMIT_CHECK + if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){ + ExprList *pCheck = pTab->pCheck; + pParse->iSelfTab = -(regNewData+1); + onError = overrideError!=OE_Default ? overrideError : OE_Abort; + for(i=0; inExpr; i++){ + int allOk; + Expr *pCopy; + Expr *pExpr = pCheck->a[i].pExpr; + if( aiChng + && !sqlite3ExprReferencesUpdatedColumn(pExpr, aiChng, pkChng) + ){ + /* The check constraints do not reference any of the columns being + ** updated so there is no point it verifying the check constraint */ + continue; + } + if( bAffinityDone==0 ){ + sqlite3TableAffinity(v, pTab, regNewData+1); + bAffinityDone = 1; + } + allOk = sqlite3VdbeMakeLabel(pParse); + sqlite3VdbeVerifyAbortable(v, onError); + pCopy = sqlite3ExprDup(db, pExpr, 0); + if( !db->mallocFailed ){ + sqlite3ExprIfTrue(pParse, pCopy, allOk, SQLITE_JUMPIFNULL); + } + sqlite3ExprDelete(db, pCopy); + if( onError==OE_Ignore ){ + sqlite3VdbeGoto(v, ignoreDest); + }else{ + char *zName = pCheck->a[i].zEName; + assert( zName!=0 || pParse->db->mallocFailed ); + if( onError==OE_Replace ) onError = OE_Abort; /* IMP: R-26383-51744 */ + sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_CHECK, + onError, zName, P4_TRANSIENT, + P5_ConstraintCheck); + } + sqlite3VdbeResolveLabel(v, allOk); + } + pParse->iSelfTab = 0; + } +#endif /* !defined(SQLITE_OMIT_CHECK) */ + + /* UNIQUE and PRIMARY KEY constraints should be handled in the following + ** order: + ** + ** (1) OE_Update + ** (2) OE_Abort, OE_Fail, OE_Rollback, OE_Ignore + ** (3) OE_Replace + ** + ** OE_Fail and OE_Ignore must happen before any changes are made. + ** OE_Update guarantees that only a single row will change, so it + ** must happen before OE_Replace. Technically, OE_Abort and OE_Rollback + ** could happen in any order, but they are grouped up front for + ** convenience. + ** + ** 2018-08-14: Ticket https://www.sqlite.org/src/info/908f001483982c43 + ** The order of constraints used to have OE_Update as (2) and OE_Abort + ** and so forth as (1). But apparently PostgreSQL checks the OE_Update + ** constraint before any others, so it had to be moved. + ** + ** Constraint checking code is generated in this order: + ** (A) The rowid constraint + ** (B) Unique index constraints that do not have OE_Replace as their + ** default conflict resolution strategy + ** (C) Unique index that do use OE_Replace by default. + ** + ** The ordering of (2) and (3) is accomplished by making sure the linked + ** list of indexes attached to a table puts all OE_Replace indexes last + ** in the list. See sqlite3CreateIndex() for where that happens. + */ + sIdxIter.eType = 0; + sIdxIter.i = 0; + sIdxIter.u.ax.aIdx = 0; /* Silence harmless compiler warning */ + sIdxIter.u.lx.pIdx = pTab->pIndex; + if( pUpsert ){ + if( pUpsert->pUpsertTarget==0 ){ + /* There is just on ON CONFLICT clause and it has no constraint-target */ + assert( pUpsert->pNextUpsert==0 ); + if( pUpsert->isDoUpdate==0 ){ + /* A single ON CONFLICT DO NOTHING clause, without a constraint-target. + ** Make all unique constraint resolution be OE_Ignore */ + overrideError = OE_Ignore; + pUpsert = 0; + }else{ + /* A single ON CONFLICT DO UPDATE. Make all resolutions OE_Update */ + overrideError = OE_Update; + } + }else if( pTab->pIndex!=0 ){ + /* Otherwise, we'll need to run the IndexListTerm array version of the + ** iterator to ensure that all of the ON CONFLICT conditions are + ** checked first and in order. */ + int nIdx, jj; + u64 nByte; + Upsert *pTerm; + u8 *bUsed; + for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){ + assert( aRegIdx[nIdx]>0 ); + } + sIdxIter.eType = 1; + sIdxIter.u.ax.nIdx = nIdx; + nByte = (sizeof(IndexListTerm)+1)*nIdx + nIdx; + sIdxIter.u.ax.aIdx = sqlite3DbMallocZero(db, nByte); + if( sIdxIter.u.ax.aIdx==0 ) return; /* OOM */ + bUsed = (u8*)&sIdxIter.u.ax.aIdx[nIdx]; + pUpsert->pToFree = sIdxIter.u.ax.aIdx; + for(i=0, pTerm=pUpsert; pTerm; pTerm=pTerm->pNextUpsert){ + if( pTerm->pUpsertTarget==0 ) break; + if( pTerm->pUpsertIdx==0 ) continue; /* Skip ON CONFLICT for the IPK */ + jj = 0; + pIdx = pTab->pIndex; + while( ALWAYS(pIdx!=0) && pIdx!=pTerm->pUpsertIdx ){ + pIdx = pIdx->pNext; + jj++; + } + if( bUsed[jj] ) continue; /* Duplicate ON CONFLICT clause ignored */ + bUsed[jj] = 1; + sIdxIter.u.ax.aIdx[i].p = pIdx; + sIdxIter.u.ax.aIdx[i].ix = jj; + i++; + } + for(jj=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, jj++){ + if( bUsed[jj] ) continue; + sIdxIter.u.ax.aIdx[i].p = pIdx; + sIdxIter.u.ax.aIdx[i].ix = jj; + i++; + } + assert( i==nIdx ); + } + } + + /* Determine if it is possible that triggers (either explicitly coded + ** triggers or FK resolution actions) might run as a result of deletes + ** that happen when OE_Replace conflict resolution occurs. (Call these + ** "replace triggers".) If any replace triggers run, we will need to + ** recheck all of the uniqueness constraints after they have all run. + ** But on the recheck, the resolution is OE_Abort instead of OE_Replace. + ** + ** If replace triggers are a possibility, then + ** + ** (1) Allocate register regTrigCnt and initialize it to zero. + ** That register will count the number of replace triggers that + ** fire. Constraint recheck only occurs if the number is positive. + ** (2) Initialize pTrigger to the list of all DELETE triggers on pTab. + ** (3) Initialize addrRecheck and lblRecheckOk + ** + ** The uniqueness rechecking code will create a series of tests to run + ** in a second pass. The addrRecheck and lblRecheckOk variables are + ** used to link together these tests which are separated from each other + ** in the generate bytecode. + */ + if( (db->flags & (SQLITE_RecTriggers|SQLITE_ForeignKeys))==0 ){ + /* There are not DELETE triggers nor FK constraints. No constraint + ** rechecks are needed. */ + pTrigger = 0; + regTrigCnt = 0; + }else{ + if( db->flags&SQLITE_RecTriggers ){ + pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0); + regTrigCnt = pTrigger!=0 || sqlite3FkRequired(pParse, pTab, 0, 0); + }else{ + pTrigger = 0; + regTrigCnt = sqlite3FkRequired(pParse, pTab, 0, 0); + } + if( regTrigCnt ){ + /* Replace triggers might exist. Allocate the counter and + ** initialize it to zero. */ + regTrigCnt = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Integer, 0, regTrigCnt); + VdbeComment((v, "trigger count")); + lblRecheckOk = sqlite3VdbeMakeLabel(pParse); + addrRecheck = lblRecheckOk; + } + } + + /* If rowid is changing, make sure the new rowid does not previously + ** exist in the table. + */ + if( pkChng && pPk==0 ){ + int addrRowidOk = sqlite3VdbeMakeLabel(pParse); + + /* Figure out what action to take in case of a rowid collision */ + onError = pTab->keyConf; + if( overrideError!=OE_Default ){ + onError = overrideError; + }else if( onError==OE_Default ){ + onError = OE_Abort; + } + + /* figure out whether or not upsert applies in this case */ + if( pUpsert ){ + pUpsertClause = sqlite3UpsertOfIndex(pUpsert,0); + if( pUpsertClause!=0 ){ + if( pUpsertClause->isDoUpdate==0 ){ + onError = OE_Ignore; /* DO NOTHING is the same as INSERT OR IGNORE */ + }else{ + onError = OE_Update; /* DO UPDATE */ + } + } + if( pUpsertClause!=pUpsert ){ + /* The first ON CONFLICT clause has a conflict target other than + ** the IPK. We have to jump ahead to that first ON CONFLICT clause + ** and then come back here and deal with the IPK afterwards */ + upsertIpkDelay = sqlite3VdbeAddOp0(v, OP_Goto); + } + } + + /* If the response to a rowid conflict is REPLACE but the response + ** to some other UNIQUE constraint is FAIL or IGNORE, then we need + ** to defer the running of the rowid conflict checking until after + ** the UNIQUE constraints have run. + */ + if( onError==OE_Replace /* IPK rule is REPLACE */ + && onError!=overrideError /* Rules for other constraints are different */ + && pTab->pIndex /* There exist other constraints */ + && !upsertIpkDelay /* IPK check already deferred by UPSERT */ + ){ + ipkTop = sqlite3VdbeAddOp0(v, OP_Goto)+1; + VdbeComment((v, "defer IPK REPLACE until last")); + } + + if( isUpdate ){ + /* pkChng!=0 does not mean that the rowid has changed, only that + ** it might have changed. Skip the conflict logic below if the rowid + ** is unchanged. */ + sqlite3VdbeAddOp3(v, OP_Eq, regNewData, addrRowidOk, regOldData); + sqlite3VdbeChangeP5(v, SQLITE_NOTNULL); + VdbeCoverage(v); + } + + /* Check to see if the new rowid already exists in the table. Skip + ** the following conflict logic if it does not. */ + VdbeNoopComment((v, "uniqueness check for ROWID")); + sqlite3VdbeVerifyAbortable(v, onError); + sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, addrRowidOk, regNewData); + VdbeCoverage(v); + + switch( onError ){ + default: { + onError = OE_Abort; + /* no break */ deliberate_fall_through + } + case OE_Rollback: + case OE_Abort: + case OE_Fail: { + testcase( onError==OE_Rollback ); + testcase( onError==OE_Abort ); + testcase( onError==OE_Fail ); + sqlite3RowidConstraint(pParse, onError, pTab); + break; + } + case OE_Replace: { + /* If there are DELETE triggers on this table and the + ** recursive-triggers flag is set, call GenerateRowDelete() to + ** remove the conflicting row from the table. This will fire + ** the triggers and remove both the table and index b-tree entries. + ** + ** Otherwise, if there are no triggers or the recursive-triggers + ** flag is not set, but the table has one or more indexes, call + ** GenerateRowIndexDelete(). This removes the index b-tree entries + ** only. The table b-tree entry will be replaced by the new entry + ** when it is inserted. + ** + ** If either GenerateRowDelete() or GenerateRowIndexDelete() is called, + ** also invoke MultiWrite() to indicate that this VDBE may require + ** statement rollback (if the statement is aborted after the delete + ** takes place). Earlier versions called sqlite3MultiWrite() regardless, + ** but being more selective here allows statements like: + ** + ** REPLACE INTO t(rowid) VALUES($newrowid) + ** + ** to run without a statement journal if there are no indexes on the + ** table. + */ + if( regTrigCnt ){ + sqlite3MultiWrite(pParse); + sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur, + regNewData, 1, 0, OE_Replace, 1, -1); + sqlite3VdbeAddOp2(v, OP_AddImm, regTrigCnt, 1); /* incr trigger cnt */ + nReplaceTrig++; + }else{ +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + assert( HasRowid(pTab) ); + /* This OP_Delete opcode fires the pre-update-hook only. It does + ** not modify the b-tree. It is more efficient to let the coming + ** OP_Insert replace the existing entry than it is to delete the + ** existing entry and then insert a new one. */ + sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, OPFLAG_ISNOOP); + sqlite3VdbeAppendP4(v, pTab, P4_TABLE); +#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ + if( pTab->pIndex ){ + sqlite3MultiWrite(pParse); + sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur,0,-1); + } + } + seenReplace = 1; + break; + } +#ifndef SQLITE_OMIT_UPSERT + case OE_Update: { + sqlite3UpsertDoUpdate(pParse, pUpsert, pTab, 0, iDataCur); + /* no break */ deliberate_fall_through + } +#endif + case OE_Ignore: { + testcase( onError==OE_Ignore ); + sqlite3VdbeGoto(v, ignoreDest); + break; + } + } + sqlite3VdbeResolveLabel(v, addrRowidOk); + if( pUpsert && pUpsertClause!=pUpsert ){ + upsertIpkReturn = sqlite3VdbeAddOp0(v, OP_Goto); + }else if( ipkTop ){ + ipkBottom = sqlite3VdbeAddOp0(v, OP_Goto); + sqlite3VdbeJumpHere(v, ipkTop-1); + } + } + + /* Test all UNIQUE constraints by creating entries for each UNIQUE + ** index and making sure that duplicate entries do not already exist. + ** Compute the revised record entries for indices as we go. + ** + ** This loop also handles the case of the PRIMARY KEY index for a + ** WITHOUT ROWID table. + */ + for(pIdx = indexIteratorFirst(&sIdxIter, &ix); + pIdx; + pIdx = indexIteratorNext(&sIdxIter, &ix) + ){ + int regIdx; /* Range of registers hold conent for pIdx */ + int regR; /* Range of registers holding conflicting PK */ + int iThisCur; /* Cursor for this UNIQUE index */ + int addrUniqueOk; /* Jump here if the UNIQUE constraint is satisfied */ + int addrConflictCk; /* First opcode in the conflict check logic */ + + if( aRegIdx[ix]==0 ) continue; /* Skip indices that do not change */ + if( pUpsert ){ + pUpsertClause = sqlite3UpsertOfIndex(pUpsert, pIdx); + if( upsertIpkDelay && pUpsertClause==pUpsert ){ + sqlite3VdbeJumpHere(v, upsertIpkDelay); + } + } + addrUniqueOk = sqlite3VdbeMakeLabel(pParse); + if( bAffinityDone==0 ){ + sqlite3TableAffinity(v, pTab, regNewData+1); + bAffinityDone = 1; + } + VdbeNoopComment((v, "prep index %s", pIdx->zName)); + iThisCur = iIdxCur+ix; + + + /* Skip partial indices for which the WHERE clause is not true */ + if( pIdx->pPartIdxWhere ){ + sqlite3VdbeAddOp2(v, OP_Null, 0, aRegIdx[ix]); + pParse->iSelfTab = -(regNewData+1); + sqlite3ExprIfFalseDup(pParse, pIdx->pPartIdxWhere, addrUniqueOk, + SQLITE_JUMPIFNULL); + pParse->iSelfTab = 0; + } + + /* Create a record for this index entry as it should appear after + ** the insert or update. Store that record in the aRegIdx[ix] register + */ + regIdx = aRegIdx[ix]+1; + for(i=0; inColumn; i++){ + int iField = pIdx->aiColumn[i]; + int x; + if( iField==XN_EXPR ){ + pParse->iSelfTab = -(regNewData+1); + sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[i].pExpr, regIdx+i); + pParse->iSelfTab = 0; + VdbeComment((v, "%s column %d", pIdx->zName, i)); + }else if( iField==XN_ROWID || iField==pTab->iPKey ){ + x = regNewData; + sqlite3VdbeAddOp2(v, OP_IntCopy, x, regIdx+i); + VdbeComment((v, "rowid")); + }else{ + testcase( sqlite3TableColumnToStorage(pTab, iField)!=iField ); + x = sqlite3TableColumnToStorage(pTab, iField) + regNewData + 1; + sqlite3VdbeAddOp2(v, OP_SCopy, x, regIdx+i); + VdbeComment((v, "%s", pTab->aCol[iField].zCnName)); + } + } + sqlite3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn, aRegIdx[ix]); + VdbeComment((v, "for %s", pIdx->zName)); +#ifdef SQLITE_ENABLE_NULL_TRIM + if( pIdx->idxType==SQLITE_IDXTYPE_PRIMARYKEY ){ + sqlite3SetMakeRecordP5(v, pIdx->pTable); + } +#endif + sqlite3VdbeReleaseRegisters(pParse, regIdx, pIdx->nColumn, 0, 0); + + /* In an UPDATE operation, if this index is the PRIMARY KEY index + ** of a WITHOUT ROWID table and there has been no change the + ** primary key, then no collision is possible. The collision detection + ** logic below can all be skipped. */ + if( isUpdate && pPk==pIdx && pkChng==0 ){ + sqlite3VdbeResolveLabel(v, addrUniqueOk); + continue; + } + + /* Find out what action to take in case there is a uniqueness conflict */ + onError = pIdx->onError; + if( onError==OE_None ){ + sqlite3VdbeResolveLabel(v, addrUniqueOk); + continue; /* pIdx is not a UNIQUE index */ + } + if( overrideError!=OE_Default ){ + onError = overrideError; + }else if( onError==OE_Default ){ + onError = OE_Abort; + } + + /* Figure out if the upsert clause applies to this index */ + if( pUpsertClause ){ + if( pUpsertClause->isDoUpdate==0 ){ + onError = OE_Ignore; /* DO NOTHING is the same as INSERT OR IGNORE */ + }else{ + onError = OE_Update; /* DO UPDATE */ + } + } + + /* Collision detection may be omitted if all of the following are true: + ** (1) The conflict resolution algorithm is REPLACE + ** (2) The table is a WITHOUT ROWID table + ** (3) There are no secondary indexes on the table + ** (4) No delete triggers need to be fired if there is a conflict + ** (5) No FK constraint counters need to be updated if a conflict occurs. + ** + ** This is not possible for ENABLE_PREUPDATE_HOOK builds, as the row + ** must be explicitly deleted in order to ensure any pre-update hook + ** is invoked. */ + assert( IsOrdinaryTable(pTab) ); +#ifndef SQLITE_ENABLE_PREUPDATE_HOOK + if( (ix==0 && pIdx->pNext==0) /* Condition 3 */ + && pPk==pIdx /* Condition 2 */ + && onError==OE_Replace /* Condition 1 */ + && ( 0==(db->flags&SQLITE_RecTriggers) || /* Condition 4 */ + 0==sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0)) + && ( 0==(db->flags&SQLITE_ForeignKeys) || /* Condition 5 */ + (0==pTab->u.tab.pFKey && 0==sqlite3FkReferences(pTab))) + ){ + sqlite3VdbeResolveLabel(v, addrUniqueOk); + continue; + } +#endif /* ifndef SQLITE_ENABLE_PREUPDATE_HOOK */ + + /* Check to see if the new index entry will be unique */ + sqlite3VdbeVerifyAbortable(v, onError); + addrConflictCk = + sqlite3VdbeAddOp4Int(v, OP_NoConflict, iThisCur, addrUniqueOk, + regIdx, pIdx->nKeyCol); VdbeCoverage(v); + + /* Generate code to handle collisions */ + regR = pIdx==pPk ? regIdx : sqlite3GetTempRange(pParse, nPkField); + if( isUpdate || onError==OE_Replace ){ + if( HasRowid(pTab) ){ + sqlite3VdbeAddOp2(v, OP_IdxRowid, iThisCur, regR); + /* Conflict only if the rowid of the existing index entry + ** is different from old-rowid */ + if( isUpdate ){ + sqlite3VdbeAddOp3(v, OP_Eq, regR, addrUniqueOk, regOldData); + sqlite3VdbeChangeP5(v, SQLITE_NOTNULL); + VdbeCoverage(v); + } + }else{ + int x; + /* Extract the PRIMARY KEY from the end of the index entry and + ** store it in registers regR..regR+nPk-1 */ + if( pIdx!=pPk ){ + for(i=0; inKeyCol; i++){ + assert( pPk->aiColumn[i]>=0 ); + x = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[i]); + sqlite3VdbeAddOp3(v, OP_Column, iThisCur, x, regR+i); + VdbeComment((v, "%s.%s", pTab->zName, + pTab->aCol[pPk->aiColumn[i]].zCnName)); + } + } + if( isUpdate ){ + /* If currently processing the PRIMARY KEY of a WITHOUT ROWID + ** table, only conflict if the new PRIMARY KEY values are actually + ** different from the old. See TH3 withoutrowid04.test. + ** + ** For a UNIQUE index, only conflict if the PRIMARY KEY values + ** of the matched index row are different from the original PRIMARY + ** KEY values of this row before the update. */ + int addrJump = sqlite3VdbeCurrentAddr(v)+pPk->nKeyCol; + int op = OP_Ne; + int regCmp = (IsPrimaryKeyIndex(pIdx) ? regIdx : regR); + + for(i=0; inKeyCol; i++){ + char *p4 = (char*)sqlite3LocateCollSeq(pParse, pPk->azColl[i]); + x = pPk->aiColumn[i]; + assert( x>=0 ); + if( i==(pPk->nKeyCol-1) ){ + addrJump = addrUniqueOk; + op = OP_Eq; + } + x = sqlite3TableColumnToStorage(pTab, x); + sqlite3VdbeAddOp4(v, op, + regOldData+1+x, addrJump, regCmp+i, p4, P4_COLLSEQ + ); + sqlite3VdbeChangeP5(v, SQLITE_NOTNULL); + VdbeCoverageIf(v, op==OP_Eq); + VdbeCoverageIf(v, op==OP_Ne); + } + } + } + } + + /* Generate code that executes if the new index entry is not unique */ + assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail + || onError==OE_Ignore || onError==OE_Replace || onError==OE_Update ); + switch( onError ){ + case OE_Rollback: + case OE_Abort: + case OE_Fail: { + testcase( onError==OE_Rollback ); + testcase( onError==OE_Abort ); + testcase( onError==OE_Fail ); + sqlite3UniqueConstraint(pParse, onError, pIdx); + break; + } +#ifndef SQLITE_OMIT_UPSERT + case OE_Update: { + sqlite3UpsertDoUpdate(pParse, pUpsert, pTab, pIdx, iIdxCur+ix); + /* no break */ deliberate_fall_through + } +#endif + case OE_Ignore: { + testcase( onError==OE_Ignore ); + sqlite3VdbeGoto(v, ignoreDest); + break; + } + default: { + int nConflictCk; /* Number of opcodes in conflict check logic */ + + assert( onError==OE_Replace ); + nConflictCk = sqlite3VdbeCurrentAddr(v) - addrConflictCk; + assert( nConflictCk>0 || db->mallocFailed ); + testcase( nConflictCk<=0 ); + testcase( nConflictCk>1 ); + if( regTrigCnt ){ + sqlite3MultiWrite(pParse); + nReplaceTrig++; + } + if( pTrigger && isUpdate ){ + sqlite3VdbeAddOp1(v, OP_CursorLock, iDataCur); + } + sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur, + regR, nPkField, 0, OE_Replace, + (pIdx==pPk ? ONEPASS_SINGLE : ONEPASS_OFF), iThisCur); + if( pTrigger && isUpdate ){ + sqlite3VdbeAddOp1(v, OP_CursorUnlock, iDataCur); + } + if( regTrigCnt ){ + int addrBypass; /* Jump destination to bypass recheck logic */ + + sqlite3VdbeAddOp2(v, OP_AddImm, regTrigCnt, 1); /* incr trigger cnt */ + addrBypass = sqlite3VdbeAddOp0(v, OP_Goto); /* Bypass recheck */ + VdbeComment((v, "bypass recheck")); + + /* Here we insert code that will be invoked after all constraint + ** checks have run, if and only if one or more replace triggers + ** fired. */ + sqlite3VdbeResolveLabel(v, lblRecheckOk); + lblRecheckOk = sqlite3VdbeMakeLabel(pParse); + if( pIdx->pPartIdxWhere ){ + /* Bypass the recheck if this partial index is not defined + ** for the current row */ + sqlite3VdbeAddOp2(v, OP_IsNull, regIdx-1, lblRecheckOk); + VdbeCoverage(v); + } + /* Copy the constraint check code from above, except change + ** the constraint-ok jump destination to be the address of + ** the next retest block */ + while( nConflictCk>0 ){ + VdbeOp x; /* Conflict check opcode to copy */ + /* The sqlite3VdbeAddOp4() call might reallocate the opcode array. + ** Hence, make a complete copy of the opcode, rather than using + ** a pointer to the opcode. */ + x = *sqlite3VdbeGetOp(v, addrConflictCk); + if( x.opcode!=OP_IdxRowid ){ + int p2; /* New P2 value for copied conflict check opcode */ + const char *zP4; + if( sqlite3OpcodeProperty[x.opcode]&OPFLG_JUMP ){ + p2 = lblRecheckOk; + }else{ + p2 = x.p2; + } + zP4 = x.p4type==P4_INT32 ? SQLITE_INT_TO_PTR(x.p4.i) : x.p4.z; + sqlite3VdbeAddOp4(v, x.opcode, x.p1, p2, x.p3, zP4, x.p4type); + sqlite3VdbeChangeP5(v, x.p5); + VdbeCoverageIf(v, p2!=x.p2); + } + nConflictCk--; + addrConflictCk++; + } + /* If the retest fails, issue an abort */ + sqlite3UniqueConstraint(pParse, OE_Abort, pIdx); + + sqlite3VdbeJumpHere(v, addrBypass); /* Terminate the recheck bypass */ + } + seenReplace = 1; + break; + } + } + sqlite3VdbeResolveLabel(v, addrUniqueOk); + if( regR!=regIdx ) sqlite3ReleaseTempRange(pParse, regR, nPkField); + if( pUpsertClause + && upsertIpkReturn + && sqlite3UpsertNextIsIPK(pUpsertClause) + ){ + sqlite3VdbeGoto(v, upsertIpkDelay+1); + sqlite3VdbeJumpHere(v, upsertIpkReturn); + upsertIpkReturn = 0; + } + } + + /* If the IPK constraint is a REPLACE, run it last */ + if( ipkTop ){ + sqlite3VdbeGoto(v, ipkTop); + VdbeComment((v, "Do IPK REPLACE")); + assert( ipkBottom>0 ); + sqlite3VdbeJumpHere(v, ipkBottom); + } + + /* Recheck all uniqueness constraints after replace triggers have run */ + testcase( regTrigCnt!=0 && nReplaceTrig==0 ); + assert( regTrigCnt!=0 || nReplaceTrig==0 ); + if( nReplaceTrig ){ + sqlite3VdbeAddOp2(v, OP_IfNot, regTrigCnt, lblRecheckOk);VdbeCoverage(v); + if( !pPk ){ + if( isUpdate ){ + sqlite3VdbeAddOp3(v, OP_Eq, regNewData, addrRecheck, regOldData); + sqlite3VdbeChangeP5(v, SQLITE_NOTNULL); + VdbeCoverage(v); + } + sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, addrRecheck, regNewData); + VdbeCoverage(v); + sqlite3RowidConstraint(pParse, OE_Abort, pTab); + }else{ + sqlite3VdbeGoto(v, addrRecheck); + } + sqlite3VdbeResolveLabel(v, lblRecheckOk); + } + + /* Generate the table record */ + if( HasRowid(pTab) ){ + int regRec = aRegIdx[ix]; + sqlite3VdbeAddOp3(v, OP_MakeRecord, regNewData+1, pTab->nNVCol, regRec); + sqlite3SetMakeRecordP5(v, pTab); + if( !bAffinityDone ){ + sqlite3TableAffinity(v, pTab, 0); + } + } + + *pbMayReplace = seenReplace; + VdbeModuleComment((v, "END: GenCnstCks(%d)", seenReplace)); +} + +#ifdef SQLITE_ENABLE_NULL_TRIM +/* +** Change the P5 operand on the last opcode (which should be an OP_MakeRecord) +** to be the number of columns in table pTab that must not be NULL-trimmed. +** +** Or if no columns of pTab may be NULL-trimmed, leave P5 at zero. +*/ +SQLITE_PRIVATE void sqlite3SetMakeRecordP5(Vdbe *v, Table *pTab){ + u16 i; + + /* Records with omitted columns are only allowed for schema format + ** version 2 and later (SQLite version 3.1.4, 2005-02-20). */ + if( pTab->pSchema->file_format<2 ) return; + + for(i=pTab->nCol-1; i>0; i--){ + if( pTab->aCol[i].iDflt!=0 ) break; + if( pTab->aCol[i].colFlags & COLFLAG_PRIMKEY ) break; + } + sqlite3VdbeChangeP5(v, i+1); +} +#endif + +/* +** Table pTab is a WITHOUT ROWID table that is being written to. The cursor +** number is iCur, and register regData contains the new record for the +** PK index. This function adds code to invoke the pre-update hook, +** if one is registered. +*/ +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK +static void codeWithoutRowidPreupdate( + Parse *pParse, /* Parse context */ + Table *pTab, /* Table being updated */ + int iCur, /* Cursor number for table */ + int regData /* Data containing new record */ +){ + Vdbe *v = pParse->pVdbe; + int r = sqlite3GetTempReg(pParse); + assert( !HasRowid(pTab) ); + assert( 0==(pParse->db->mDbFlags & DBFLAG_Vacuum) || CORRUPT_DB ); + sqlite3VdbeAddOp2(v, OP_Integer, 0, r); + sqlite3VdbeAddOp4(v, OP_Insert, iCur, regData, r, (char*)pTab, P4_TABLE); + sqlite3VdbeChangeP5(v, OPFLAG_ISNOOP); + sqlite3ReleaseTempReg(pParse, r); +} +#else +# define codeWithoutRowidPreupdate(a,b,c,d) +#endif + +/* +** This routine generates code to finish the INSERT or UPDATE operation +** that was started by a prior call to sqlite3GenerateConstraintChecks. +** A consecutive range of registers starting at regNewData contains the +** rowid and the content to be inserted. +** +** The arguments to this routine should be the same as the first six +** arguments to sqlite3GenerateConstraintChecks. +*/ +SQLITE_PRIVATE void sqlite3CompleteInsertion( + Parse *pParse, /* The parser context */ + Table *pTab, /* the table into which we are inserting */ + int iDataCur, /* Cursor of the canonical data source */ + int iIdxCur, /* First index cursor */ + int regNewData, /* Range of content */ + int *aRegIdx, /* Register used by each index. 0 for unused indices */ + int update_flags, /* True for UPDATE, False for INSERT */ + int appendBias, /* True if this is likely to be an append */ + int useSeekResult /* True to set the USESEEKRESULT flag on OP_[Idx]Insert */ +){ + Vdbe *v; /* Prepared statements under construction */ + Index *pIdx; /* An index being inserted or updated */ + u8 pik_flags; /* flag values passed to the btree insert */ + int i; /* Loop counter */ + + assert( update_flags==0 + || update_flags==OPFLAG_ISUPDATE + || update_flags==(OPFLAG_ISUPDATE|OPFLAG_SAVEPOSITION) + ); + + v = pParse->pVdbe; + assert( v!=0 ); + assert( !IsView(pTab) ); /* This table is not a VIEW */ + for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){ + /* All REPLACE indexes are at the end of the list */ + assert( pIdx->onError!=OE_Replace + || pIdx->pNext==0 + || pIdx->pNext->onError==OE_Replace ); + if( aRegIdx[i]==0 ) continue; + if( pIdx->pPartIdxWhere ){ + sqlite3VdbeAddOp2(v, OP_IsNull, aRegIdx[i], sqlite3VdbeCurrentAddr(v)+2); + VdbeCoverage(v); + } + pik_flags = (useSeekResult ? OPFLAG_USESEEKRESULT : 0); + if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){ + pik_flags |= OPFLAG_NCHANGE; + pik_flags |= (update_flags & OPFLAG_SAVEPOSITION); + if( update_flags==0 ){ + codeWithoutRowidPreupdate(pParse, pTab, iIdxCur+i, aRegIdx[i]); + } + } + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iIdxCur+i, aRegIdx[i], + aRegIdx[i]+1, + pIdx->uniqNotNull ? pIdx->nKeyCol: pIdx->nColumn); + sqlite3VdbeChangeP5(v, pik_flags); + } + if( !HasRowid(pTab) ) return; + if( pParse->nested ){ + pik_flags = 0; + }else{ + pik_flags = OPFLAG_NCHANGE; + pik_flags |= (update_flags?update_flags:OPFLAG_LASTROWID); + } + if( appendBias ){ + pik_flags |= OPFLAG_APPEND; + } + if( useSeekResult ){ + pik_flags |= OPFLAG_USESEEKRESULT; + } + sqlite3VdbeAddOp3(v, OP_Insert, iDataCur, aRegIdx[i], regNewData); + if( !pParse->nested ){ + sqlite3VdbeAppendP4(v, pTab, P4_TABLE); + } + sqlite3VdbeChangeP5(v, pik_flags); +} + +/* +** Allocate cursors for the pTab table and all its indices and generate +** code to open and initialized those cursors. +** +** The cursor for the object that contains the complete data (normally +** the table itself, but the PRIMARY KEY index in the case of a WITHOUT +** ROWID table) is returned in *piDataCur. The first index cursor is +** returned in *piIdxCur. The number of indices is returned. +** +** Use iBase as the first cursor (either the *piDataCur for rowid tables +** or the first index for WITHOUT ROWID tables) if it is non-negative. +** If iBase is negative, then allocate the next available cursor. +** +** For a rowid table, *piDataCur will be exactly one less than *piIdxCur. +** For a WITHOUT ROWID table, *piDataCur will be somewhere in the range +** of *piIdxCurs, depending on where the PRIMARY KEY index appears on the +** pTab->pIndex list. +** +** If pTab is a virtual table, then this routine is a no-op and the +** *piDataCur and *piIdxCur values are left uninitialized. +*/ +SQLITE_PRIVATE int sqlite3OpenTableAndIndices( + Parse *pParse, /* Parsing context */ + Table *pTab, /* Table to be opened */ + int op, /* OP_OpenRead or OP_OpenWrite */ + u8 p5, /* P5 value for OP_Open* opcodes (except on WITHOUT ROWID) */ + int iBase, /* Use this for the table cursor, if there is one */ + u8 *aToOpen, /* If not NULL: boolean for each table and index */ + int *piDataCur, /* Write the database source cursor number here */ + int *piIdxCur /* Write the first index cursor number here */ +){ + int i; + int iDb; + int iDataCur; + Index *pIdx; + Vdbe *v; + + assert( op==OP_OpenRead || op==OP_OpenWrite ); + assert( op==OP_OpenWrite || p5==0 ); + if( IsVirtual(pTab) ){ + /* This routine is a no-op for virtual tables. Leave the output + ** variables *piDataCur and *piIdxCur set to illegal cursor numbers + ** for improved error detection. */ + *piDataCur = *piIdxCur = -999; + return 0; + } + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + v = pParse->pVdbe; + assert( v!=0 ); + if( iBase<0 ) iBase = pParse->nTab; + iDataCur = iBase++; + if( piDataCur ) *piDataCur = iDataCur; + if( HasRowid(pTab) && (aToOpen==0 || aToOpen[0]) ){ + sqlite3OpenTable(pParse, iDataCur, iDb, pTab, op); + }else{ + sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName); + } + if( piIdxCur ) *piIdxCur = iBase; + for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){ + int iIdxCur = iBase++; + assert( pIdx->pSchema==pTab->pSchema ); + if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){ + if( piDataCur ) *piDataCur = iIdxCur; + p5 = 0; + } + if( aToOpen==0 || aToOpen[i+1] ){ + sqlite3VdbeAddOp3(v, op, iIdxCur, pIdx->tnum, iDb); + sqlite3VdbeSetP4KeyInfo(pParse, pIdx); + sqlite3VdbeChangeP5(v, p5); + VdbeComment((v, "%s", pIdx->zName)); + } + } + if( iBase>pParse->nTab ) pParse->nTab = iBase; + return i; +} + + +#ifdef SQLITE_TEST +/* +** The following global variable is incremented whenever the +** transfer optimization is used. This is used for testing +** purposes only - to make sure the transfer optimization really +** is happening when it is supposed to. +*/ +SQLITE_API int sqlite3_xferopt_count; +#endif /* SQLITE_TEST */ + + +#ifndef SQLITE_OMIT_XFER_OPT +/* +** Check to see if index pSrc is compatible as a source of data +** for index pDest in an insert transfer optimization. The rules +** for a compatible index: +** +** * The index is over the same set of columns +** * The same DESC and ASC markings occurs on all columns +** * The same onError processing (OE_Abort, OE_Ignore, etc) +** * The same collating sequence on each column +** * The index has the exact same WHERE clause +*/ +static int xferCompatibleIndex(Index *pDest, Index *pSrc){ + int i; + assert( pDest && pSrc ); + assert( pDest->pTable!=pSrc->pTable ); + if( pDest->nKeyCol!=pSrc->nKeyCol || pDest->nColumn!=pSrc->nColumn ){ + return 0; /* Different number of columns */ + } + if( pDest->onError!=pSrc->onError ){ + return 0; /* Different conflict resolution strategies */ + } + for(i=0; inKeyCol; i++){ + if( pSrc->aiColumn[i]!=pDest->aiColumn[i] ){ + return 0; /* Different columns indexed */ + } + if( pSrc->aiColumn[i]==XN_EXPR ){ + assert( pSrc->aColExpr!=0 && pDest->aColExpr!=0 ); + if( sqlite3ExprCompare(0, pSrc->aColExpr->a[i].pExpr, + pDest->aColExpr->a[i].pExpr, -1)!=0 ){ + return 0; /* Different expressions in the index */ + } + } + if( pSrc->aSortOrder[i]!=pDest->aSortOrder[i] ){ + return 0; /* Different sort orders */ + } + if( sqlite3_stricmp(pSrc->azColl[i],pDest->azColl[i])!=0 ){ + return 0; /* Different collating sequences */ + } + } + if( sqlite3ExprCompare(0, pSrc->pPartIdxWhere, pDest->pPartIdxWhere, -1) ){ + return 0; /* Different WHERE clauses */ + } + + /* If no test above fails then the indices must be compatible */ + return 1; +} + +/* +** Attempt the transfer optimization on INSERTs of the form +** +** INSERT INTO tab1 SELECT * FROM tab2; +** +** The xfer optimization transfers raw records from tab2 over to tab1. +** Columns are not decoded and reassembled, which greatly improves +** performance. Raw index records are transferred in the same way. +** +** The xfer optimization is only attempted if tab1 and tab2 are compatible. +** There are lots of rules for determining compatibility - see comments +** embedded in the code for details. +** +** This routine returns TRUE if the optimization is guaranteed to be used. +** Sometimes the xfer optimization will only work if the destination table +** is empty - a factor that can only be determined at run-time. In that +** case, this routine generates code for the xfer optimization but also +** does a test to see if the destination table is empty and jumps over the +** xfer optimization code if the test fails. In that case, this routine +** returns FALSE so that the caller will know to go ahead and generate +** an unoptimized transfer. This routine also returns FALSE if there +** is no chance that the xfer optimization can be applied. +** +** This optimization is particularly useful at making VACUUM run faster. +*/ +static int xferOptimization( + Parse *pParse, /* Parser context */ + Table *pDest, /* The table we are inserting into */ + Select *pSelect, /* A SELECT statement to use as the data source */ + int onError, /* How to handle constraint errors */ + int iDbDest /* The database of pDest */ +){ + sqlite3 *db = pParse->db; + ExprList *pEList; /* The result set of the SELECT */ + Table *pSrc; /* The table in the FROM clause of SELECT */ + Index *pSrcIdx, *pDestIdx; /* Source and destination indices */ + SrcItem *pItem; /* An element of pSelect->pSrc */ + int i; /* Loop counter */ + int iDbSrc; /* The database of pSrc */ + int iSrc, iDest; /* Cursors from source and destination */ + int addr1, addr2; /* Loop addresses */ + int emptyDestTest = 0; /* Address of test for empty pDest */ + int emptySrcTest = 0; /* Address of test for empty pSrc */ + Vdbe *v; /* The VDBE we are building */ + int regAutoinc; /* Memory register used by AUTOINC */ + int destHasUniqueIdx = 0; /* True if pDest has a UNIQUE index */ + int regData, regRowid; /* Registers holding data and rowid */ + + assert( pSelect!=0 ); + if( pParse->pWith || pSelect->pWith ){ + /* Do not attempt to process this query if there are an WITH clauses + ** attached to it. Proceeding may generate a false "no such table: xxx" + ** error if pSelect reads from a CTE named "xxx". */ + return 0; + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pDest) ){ + return 0; /* tab1 must not be a virtual table */ + } +#endif + if( onError==OE_Default ){ + if( pDest->iPKey>=0 ) onError = pDest->keyConf; + if( onError==OE_Default ) onError = OE_Abort; + } + assert(pSelect->pSrc); /* allocated even if there is no FROM clause */ + if( pSelect->pSrc->nSrc!=1 ){ + return 0; /* FROM clause must have exactly one term */ + } + if( pSelect->pSrc->a[0].pSelect ){ + return 0; /* FROM clause cannot contain a subquery */ + } + if( pSelect->pWhere ){ + return 0; /* SELECT may not have a WHERE clause */ + } + if( pSelect->pOrderBy ){ + return 0; /* SELECT may not have an ORDER BY clause */ + } + /* Do not need to test for a HAVING clause. If HAVING is present but + ** there is no ORDER BY, we will get an error. */ + if( pSelect->pGroupBy ){ + return 0; /* SELECT may not have a GROUP BY clause */ + } + if( pSelect->pLimit ){ + return 0; /* SELECT may not have a LIMIT clause */ + } + if( pSelect->pPrior ){ + return 0; /* SELECT may not be a compound query */ + } + if( pSelect->selFlags & SF_Distinct ){ + return 0; /* SELECT may not be DISTINCT */ + } + pEList = pSelect->pEList; + assert( pEList!=0 ); + if( pEList->nExpr!=1 ){ + return 0; /* The result set must have exactly one column */ + } + assert( pEList->a[0].pExpr ); + if( pEList->a[0].pExpr->op!=TK_ASTERISK ){ + return 0; /* The result set must be the special operator "*" */ + } + + /* At this point we have established that the statement is of the + ** correct syntactic form to participate in this optimization. Now + ** we have to check the semantics. + */ + pItem = pSelect->pSrc->a; + pSrc = sqlite3LocateTableItem(pParse, 0, pItem); + if( pSrc==0 ){ + return 0; /* FROM clause does not contain a real table */ + } + if( pSrc->tnum==pDest->tnum && pSrc->pSchema==pDest->pSchema ){ + testcase( pSrc!=pDest ); /* Possible due to bad sqlite_schema.rootpage */ + return 0; /* tab1 and tab2 may not be the same table */ + } + if( HasRowid(pDest)!=HasRowid(pSrc) ){ + return 0; /* source and destination must both be WITHOUT ROWID or not */ + } + if( !IsOrdinaryTable(pSrc) ){ + return 0; /* tab2 may not be a view or virtual table */ + } + if( pDest->nCol!=pSrc->nCol ){ + return 0; /* Number of columns must be the same in tab1 and tab2 */ + } + if( pDest->iPKey!=pSrc->iPKey ){ + return 0; /* Both tables must have the same INTEGER PRIMARY KEY */ + } + if( (pDest->tabFlags & TF_Strict)!=0 && (pSrc->tabFlags & TF_Strict)==0 ){ + return 0; /* Cannot feed from a non-strict into a strict table */ + } + for(i=0; inCol; i++){ + Column *pDestCol = &pDest->aCol[i]; + Column *pSrcCol = &pSrc->aCol[i]; +#ifdef SQLITE_ENABLE_HIDDEN_COLUMNS + if( (db->mDbFlags & DBFLAG_Vacuum)==0 + && (pDestCol->colFlags | pSrcCol->colFlags) & COLFLAG_HIDDEN + ){ + return 0; /* Neither table may have __hidden__ columns */ + } +#endif +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + /* Even if tables t1 and t2 have identical schemas, if they contain + ** generated columns, then this statement is semantically incorrect: + ** + ** INSERT INTO t2 SELECT * FROM t1; + ** + ** The reason is that generated column values are returned by the + ** the SELECT statement on the right but the INSERT statement on the + ** left wants them to be omitted. + ** + ** Nevertheless, this is a useful notational shorthand to tell SQLite + ** to do a bulk transfer all of the content from t1 over to t2. + ** + ** We could, in theory, disable this (except for internal use by the + ** VACUUM command where it is actually needed). But why do that? It + ** seems harmless enough, and provides a useful service. + */ + if( (pDestCol->colFlags & COLFLAG_GENERATED) != + (pSrcCol->colFlags & COLFLAG_GENERATED) ){ + return 0; /* Both columns have the same generated-column type */ + } + /* But the transfer is only allowed if both the source and destination + ** tables have the exact same expressions for generated columns. + ** This requirement could be relaxed for VIRTUAL columns, I suppose. + */ + if( (pDestCol->colFlags & COLFLAG_GENERATED)!=0 ){ + if( sqlite3ExprCompare(0, + sqlite3ColumnExpr(pSrc, pSrcCol), + sqlite3ColumnExpr(pDest, pDestCol), -1)!=0 ){ + testcase( pDestCol->colFlags & COLFLAG_VIRTUAL ); + testcase( pDestCol->colFlags & COLFLAG_STORED ); + return 0; /* Different generator expressions */ + } + } +#endif + if( pDestCol->affinity!=pSrcCol->affinity ){ + return 0; /* Affinity must be the same on all columns */ + } + if( sqlite3_stricmp(sqlite3ColumnColl(pDestCol), + sqlite3ColumnColl(pSrcCol))!=0 ){ + return 0; /* Collating sequence must be the same on all columns */ + } + if( pDestCol->notNull && !pSrcCol->notNull ){ + return 0; /* tab2 must be NOT NULL if tab1 is */ + } + /* Default values for second and subsequent columns need to match. */ + if( (pDestCol->colFlags & COLFLAG_GENERATED)==0 && i>0 ){ + Expr *pDestExpr = sqlite3ColumnExpr(pDest, pDestCol); + Expr *pSrcExpr = sqlite3ColumnExpr(pSrc, pSrcCol); + assert( pDestExpr==0 || pDestExpr->op==TK_SPAN ); + assert( pDestExpr==0 || !ExprHasProperty(pDestExpr, EP_IntValue) ); + assert( pSrcExpr==0 || pSrcExpr->op==TK_SPAN ); + assert( pSrcExpr==0 || !ExprHasProperty(pSrcExpr, EP_IntValue) ); + if( (pDestExpr==0)!=(pSrcExpr==0) + || (pDestExpr!=0 && strcmp(pDestExpr->u.zToken, + pSrcExpr->u.zToken)!=0) + ){ + return 0; /* Default values must be the same for all columns */ + } + } + } + for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){ + if( IsUniqueIndex(pDestIdx) ){ + destHasUniqueIdx = 1; + } + for(pSrcIdx=pSrc->pIndex; pSrcIdx; pSrcIdx=pSrcIdx->pNext){ + if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break; + } + if( pSrcIdx==0 ){ + return 0; /* pDestIdx has no corresponding index in pSrc */ + } + if( pSrcIdx->tnum==pDestIdx->tnum && pSrc->pSchema==pDest->pSchema + && sqlite3FaultSim(411)==SQLITE_OK ){ + /* The sqlite3FaultSim() call allows this corruption test to be + ** bypassed during testing, in order to exercise other corruption tests + ** further downstream. */ + return 0; /* Corrupt schema - two indexes on the same btree */ + } + } +#ifndef SQLITE_OMIT_CHECK + if( pDest->pCheck && sqlite3ExprListCompare(pSrc->pCheck,pDest->pCheck,-1) ){ + return 0; /* Tables have different CHECK constraints. Ticket #2252 */ + } +#endif +#ifndef SQLITE_OMIT_FOREIGN_KEY + /* Disallow the transfer optimization if the destination table constains + ** any foreign key constraints. This is more restrictive than necessary. + ** But the main beneficiary of the transfer optimization is the VACUUM + ** command, and the VACUUM command disables foreign key constraints. So + ** the extra complication to make this rule less restrictive is probably + ** not worth the effort. Ticket [6284df89debdfa61db8073e062908af0c9b6118e] + */ + assert( IsOrdinaryTable(pDest) ); + if( (db->flags & SQLITE_ForeignKeys)!=0 && pDest->u.tab.pFKey!=0 ){ + return 0; + } +#endif + if( (db->flags & SQLITE_CountRows)!=0 ){ + return 0; /* xfer opt does not play well with PRAGMA count_changes */ + } + + /* If we get this far, it means that the xfer optimization is at + ** least a possibility, though it might only work if the destination + ** table (tab1) is initially empty. + */ +#ifdef SQLITE_TEST + sqlite3_xferopt_count++; +#endif + iDbSrc = sqlite3SchemaToIndex(db, pSrc->pSchema); + v = sqlite3GetVdbe(pParse); + sqlite3CodeVerifySchema(pParse, iDbSrc); + iSrc = pParse->nTab++; + iDest = pParse->nTab++; + regAutoinc = autoIncBegin(pParse, iDbDest, pDest); + regData = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp2(v, OP_Null, 0, regData); + regRowid = sqlite3GetTempReg(pParse); + sqlite3OpenTable(pParse, iDest, iDbDest, pDest, OP_OpenWrite); + assert( HasRowid(pDest) || destHasUniqueIdx ); + if( (db->mDbFlags & DBFLAG_Vacuum)==0 && ( + (pDest->iPKey<0 && pDest->pIndex!=0) /* (1) */ + || destHasUniqueIdx /* (2) */ + || (onError!=OE_Abort && onError!=OE_Rollback) /* (3) */ + )){ + /* In some circumstances, we are able to run the xfer optimization + ** only if the destination table is initially empty. Unless the + ** DBFLAG_Vacuum flag is set, this block generates code to make + ** that determination. If DBFLAG_Vacuum is set, then the destination + ** table is always empty. + ** + ** Conditions under which the destination must be empty: + ** + ** (1) There is no INTEGER PRIMARY KEY but there are indices. + ** (If the destination is not initially empty, the rowid fields + ** of index entries might need to change.) + ** + ** (2) The destination has a unique index. (The xfer optimization + ** is unable to test uniqueness.) + ** + ** (3) onError is something other than OE_Abort and OE_Rollback. + */ + addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iDest, 0); VdbeCoverage(v); + emptyDestTest = sqlite3VdbeAddOp0(v, OP_Goto); + sqlite3VdbeJumpHere(v, addr1); + } + if( HasRowid(pSrc) ){ + u8 insFlags; + sqlite3OpenTable(pParse, iSrc, iDbSrc, pSrc, OP_OpenRead); + emptySrcTest = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v); + if( pDest->iPKey>=0 ){ + addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid); + if( (db->mDbFlags & DBFLAG_Vacuum)==0 ){ + sqlite3VdbeVerifyAbortable(v, onError); + addr2 = sqlite3VdbeAddOp3(v, OP_NotExists, iDest, 0, regRowid); + VdbeCoverage(v); + sqlite3RowidConstraint(pParse, onError, pDest); + sqlite3VdbeJumpHere(v, addr2); + } + autoIncStep(pParse, regAutoinc, regRowid); + }else if( pDest->pIndex==0 && !(db->mDbFlags & DBFLAG_VacuumInto) ){ + addr1 = sqlite3VdbeAddOp2(v, OP_NewRowid, iDest, regRowid); + }else{ + addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid); + assert( (pDest->tabFlags & TF_Autoincrement)==0 ); + } + + if( db->mDbFlags & DBFLAG_Vacuum ){ + sqlite3VdbeAddOp1(v, OP_SeekEnd, iDest); + insFlags = OPFLAG_APPEND|OPFLAG_USESEEKRESULT|OPFLAG_PREFORMAT; + }else{ + insFlags = OPFLAG_NCHANGE|OPFLAG_LASTROWID|OPFLAG_APPEND|OPFLAG_PREFORMAT; + } +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + if( (db->mDbFlags & DBFLAG_Vacuum)==0 ){ + sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1); + insFlags &= ~OPFLAG_PREFORMAT; + }else +#endif + { + sqlite3VdbeAddOp3(v, OP_RowCell, iDest, iSrc, regRowid); + } + sqlite3VdbeAddOp3(v, OP_Insert, iDest, regData, regRowid); + if( (db->mDbFlags & DBFLAG_Vacuum)==0 ){ + sqlite3VdbeChangeP4(v, -1, (char*)pDest, P4_TABLE); + } + sqlite3VdbeChangeP5(v, insFlags); + + sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1); VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0); + sqlite3VdbeAddOp2(v, OP_Close, iDest, 0); + }else{ + sqlite3TableLock(pParse, iDbDest, pDest->tnum, 1, pDest->zName); + sqlite3TableLock(pParse, iDbSrc, pSrc->tnum, 0, pSrc->zName); + } + for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){ + u8 idxInsFlags = 0; + for(pSrcIdx=pSrc->pIndex; ALWAYS(pSrcIdx); pSrcIdx=pSrcIdx->pNext){ + if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break; + } + assert( pSrcIdx ); + sqlite3VdbeAddOp3(v, OP_OpenRead, iSrc, pSrcIdx->tnum, iDbSrc); + sqlite3VdbeSetP4KeyInfo(pParse, pSrcIdx); + VdbeComment((v, "%s", pSrcIdx->zName)); + sqlite3VdbeAddOp3(v, OP_OpenWrite, iDest, pDestIdx->tnum, iDbDest); + sqlite3VdbeSetP4KeyInfo(pParse, pDestIdx); + sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR); + VdbeComment((v, "%s", pDestIdx->zName)); + addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v); + if( db->mDbFlags & DBFLAG_Vacuum ){ + /* This INSERT command is part of a VACUUM operation, which guarantees + ** that the destination table is empty. If all indexed columns use + ** collation sequence BINARY, then it can also be assumed that the + ** index will be populated by inserting keys in strictly sorted + ** order. In this case, instead of seeking within the b-tree as part + ** of every OP_IdxInsert opcode, an OP_SeekEnd is added before the + ** OP_IdxInsert to seek to the point within the b-tree where each key + ** should be inserted. This is faster. + ** + ** If any of the indexed columns use a collation sequence other than + ** BINARY, this optimization is disabled. This is because the user + ** might change the definition of a collation sequence and then run + ** a VACUUM command. In that case keys may not be written in strictly + ** sorted order. */ + for(i=0; inColumn; i++){ + const char *zColl = pSrcIdx->azColl[i]; + if( sqlite3_stricmp(sqlite3StrBINARY, zColl) ) break; + } + if( i==pSrcIdx->nColumn ){ + idxInsFlags = OPFLAG_USESEEKRESULT|OPFLAG_PREFORMAT; + sqlite3VdbeAddOp1(v, OP_SeekEnd, iDest); + sqlite3VdbeAddOp2(v, OP_RowCell, iDest, iSrc); + } + }else if( !HasRowid(pSrc) && pDestIdx->idxType==SQLITE_IDXTYPE_PRIMARYKEY ){ + idxInsFlags |= OPFLAG_NCHANGE; + } + if( idxInsFlags!=(OPFLAG_USESEEKRESULT|OPFLAG_PREFORMAT) ){ + sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1); + if( (db->mDbFlags & DBFLAG_Vacuum)==0 + && !HasRowid(pDest) + && IsPrimaryKeyIndex(pDestIdx) + ){ + codeWithoutRowidPreupdate(pParse, pDest, iDest, regData); + } + } + sqlite3VdbeAddOp2(v, OP_IdxInsert, iDest, regData); + sqlite3VdbeChangeP5(v, idxInsFlags|OPFLAG_APPEND); + sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1+1); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addr1); + sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0); + sqlite3VdbeAddOp2(v, OP_Close, iDest, 0); + } + if( emptySrcTest ) sqlite3VdbeJumpHere(v, emptySrcTest); + sqlite3ReleaseTempReg(pParse, regRowid); + sqlite3ReleaseTempReg(pParse, regData); + if( emptyDestTest ){ + sqlite3AutoincrementEnd(pParse); + sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_OK, 0); + sqlite3VdbeJumpHere(v, emptyDestTest); + sqlite3VdbeAddOp2(v, OP_Close, iDest, 0); + return 0; + }else{ + return 1; + } +} +#endif /* SQLITE_OMIT_XFER_OPT */ + +/************** End of insert.c **********************************************/ +/************** Begin file legacy.c ******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** Main file for the SQLite library. The routines in this file +** implement the programmer interface to the library. Routines in +** other files are for internal use by SQLite and should not be +** accessed by users of the library. +*/ + +/* #include "sqliteInt.h" */ + +/* +** Execute SQL code. Return one of the SQLITE_ success/failure +** codes. Also write an error message into memory obtained from +** malloc() and make *pzErrMsg point to that message. +** +** If the SQL is a query, then for each row in the query result +** the xCallback() function is called. pArg becomes the first +** argument to xCallback(). If xCallback=NULL then no callback +** is invoked, even for queries. +*/ +SQLITE_API int sqlite3_exec( + sqlite3 *db, /* The database on which the SQL executes */ + const char *zSql, /* The SQL to be executed */ + sqlite3_callback xCallback, /* Invoke this callback routine */ + void *pArg, /* First argument to xCallback() */ + char **pzErrMsg /* Write error messages here */ +){ + int rc = SQLITE_OK; /* Return code */ + const char *zLeftover; /* Tail of unprocessed SQL */ + sqlite3_stmt *pStmt = 0; /* The current SQL statement */ + char **azCols = 0; /* Names of result columns */ + int callbackIsInit; /* True if callback data is initialized */ + + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; + if( zSql==0 ) zSql = ""; + + sqlite3_mutex_enter(db->mutex); + sqlite3Error(db, SQLITE_OK); + while( rc==SQLITE_OK && zSql[0] ){ + int nCol = 0; + char **azVals = 0; + + pStmt = 0; + rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover); + assert( rc==SQLITE_OK || pStmt==0 ); + if( rc!=SQLITE_OK ){ + continue; + } + if( !pStmt ){ + /* this happens for a comment or white-space */ + zSql = zLeftover; + continue; + } + callbackIsInit = 0; + + while( 1 ){ + int i; + rc = sqlite3_step(pStmt); + + /* Invoke the callback function if required */ + if( xCallback && (SQLITE_ROW==rc || + (SQLITE_DONE==rc && !callbackIsInit + && db->flags&SQLITE_NullCallback)) ){ + if( !callbackIsInit ){ + nCol = sqlite3_column_count(pStmt); + azCols = sqlite3DbMallocRaw(db, (2*nCol+1)*sizeof(const char*)); + if( azCols==0 ){ + goto exec_out; + } + for(i=0; ierrMask)==rc ); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/************** End of legacy.c **********************************************/ +/************** Begin file loadext.c *****************************************/ +/* +** 2006 June 7 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to dynamically load extensions into +** the SQLite library. +*/ + +#ifndef SQLITE_CORE + #define SQLITE_CORE 1 /* Disable the API redefinition in sqlite3ext.h */ +#endif +/************** Include sqlite3ext.h in the middle of loadext.c **************/ +/************** Begin file sqlite3ext.h **************************************/ +/* +** 2006 June 7 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This header file defines the SQLite interface for use by +** shared libraries that want to be imported as extensions into +** an SQLite instance. Shared libraries that intend to be loaded +** as extensions by SQLite should #include this file instead of +** sqlite3.h. +*/ +#ifndef SQLITE3EXT_H +#define SQLITE3EXT_H +/* #include "sqlite3.h" */ + +/* +** The following structure holds pointers to all of the SQLite API +** routines. +** +** WARNING: In order to maintain backwards compatibility, add new +** interfaces to the end of this structure only. If you insert new +** interfaces in the middle of this structure, then older different +** versions of SQLite will not be able to load each other's shared +** libraries! +*/ +struct sqlite3_api_routines { + void * (*aggregate_context)(sqlite3_context*,int nBytes); + int (*aggregate_count)(sqlite3_context*); + int (*bind_blob)(sqlite3_stmt*,int,const void*,int n,void(*)(void*)); + int (*bind_double)(sqlite3_stmt*,int,double); + int (*bind_int)(sqlite3_stmt*,int,int); + int (*bind_int64)(sqlite3_stmt*,int,sqlite_int64); + int (*bind_null)(sqlite3_stmt*,int); + int (*bind_parameter_count)(sqlite3_stmt*); + int (*bind_parameter_index)(sqlite3_stmt*,const char*zName); + const char * (*bind_parameter_name)(sqlite3_stmt*,int); + int (*bind_text)(sqlite3_stmt*,int,const char*,int n,void(*)(void*)); + int (*bind_text16)(sqlite3_stmt*,int,const void*,int,void(*)(void*)); + int (*bind_value)(sqlite3_stmt*,int,const sqlite3_value*); + int (*busy_handler)(sqlite3*,int(*)(void*,int),void*); + int (*busy_timeout)(sqlite3*,int ms); + int (*changes)(sqlite3*); + int (*close)(sqlite3*); + int (*collation_needed)(sqlite3*,void*,void(*)(void*,sqlite3*, + int eTextRep,const char*)); + int (*collation_needed16)(sqlite3*,void*,void(*)(void*,sqlite3*, + int eTextRep,const void*)); + const void * (*column_blob)(sqlite3_stmt*,int iCol); + int (*column_bytes)(sqlite3_stmt*,int iCol); + int (*column_bytes16)(sqlite3_stmt*,int iCol); + int (*column_count)(sqlite3_stmt*pStmt); + const char * (*column_database_name)(sqlite3_stmt*,int); + const void * (*column_database_name16)(sqlite3_stmt*,int); + const char * (*column_decltype)(sqlite3_stmt*,int i); + const void * (*column_decltype16)(sqlite3_stmt*,int); + double (*column_double)(sqlite3_stmt*,int iCol); + int (*column_int)(sqlite3_stmt*,int iCol); + sqlite_int64 (*column_int64)(sqlite3_stmt*,int iCol); + const char * (*column_name)(sqlite3_stmt*,int); + const void * (*column_name16)(sqlite3_stmt*,int); + const char * (*column_origin_name)(sqlite3_stmt*,int); + const void * (*column_origin_name16)(sqlite3_stmt*,int); + const char * (*column_table_name)(sqlite3_stmt*,int); + const void * (*column_table_name16)(sqlite3_stmt*,int); + const unsigned char * (*column_text)(sqlite3_stmt*,int iCol); + const void * (*column_text16)(sqlite3_stmt*,int iCol); + int (*column_type)(sqlite3_stmt*,int iCol); + sqlite3_value* (*column_value)(sqlite3_stmt*,int iCol); + void * (*commit_hook)(sqlite3*,int(*)(void*),void*); + int (*complete)(const char*sql); + int (*complete16)(const void*sql); + int (*create_collation)(sqlite3*,const char*,int,void*, + int(*)(void*,int,const void*,int,const void*)); + int (*create_collation16)(sqlite3*,const void*,int,void*, + int(*)(void*,int,const void*,int,const void*)); + int (*create_function)(sqlite3*,const char*,int,int,void*, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*)); + int (*create_function16)(sqlite3*,const void*,int,int,void*, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*)); + int (*create_module)(sqlite3*,const char*,const sqlite3_module*,void*); + int (*data_count)(sqlite3_stmt*pStmt); + sqlite3 * (*db_handle)(sqlite3_stmt*); + int (*declare_vtab)(sqlite3*,const char*); + int (*enable_shared_cache)(int); + int (*errcode)(sqlite3*db); + const char * (*errmsg)(sqlite3*); + const void * (*errmsg16)(sqlite3*); + int (*exec)(sqlite3*,const char*,sqlite3_callback,void*,char**); + int (*expired)(sqlite3_stmt*); + int (*finalize)(sqlite3_stmt*pStmt); + void (*free)(void*); + void (*free_table)(char**result); + int (*get_autocommit)(sqlite3*); + void * (*get_auxdata)(sqlite3_context*,int); + int (*get_table)(sqlite3*,const char*,char***,int*,int*,char**); + int (*global_recover)(void); + void (*interruptx)(sqlite3*); + sqlite_int64 (*last_insert_rowid)(sqlite3*); + const char * (*libversion)(void); + int (*libversion_number)(void); + void *(*malloc)(int); + char * (*mprintf)(const char*,...); + int (*open)(const char*,sqlite3**); + int (*open16)(const void*,sqlite3**); + int (*prepare)(sqlite3*,const char*,int,sqlite3_stmt**,const char**); + int (*prepare16)(sqlite3*,const void*,int,sqlite3_stmt**,const void**); + void * (*profile)(sqlite3*,void(*)(void*,const char*,sqlite_uint64),void*); + void (*progress_handler)(sqlite3*,int,int(*)(void*),void*); + void *(*realloc)(void*,int); + int (*reset)(sqlite3_stmt*pStmt); + void (*result_blob)(sqlite3_context*,const void*,int,void(*)(void*)); + void (*result_double)(sqlite3_context*,double); + void (*result_error)(sqlite3_context*,const char*,int); + void (*result_error16)(sqlite3_context*,const void*,int); + void (*result_int)(sqlite3_context*,int); + void (*result_int64)(sqlite3_context*,sqlite_int64); + void (*result_null)(sqlite3_context*); + void (*result_text)(sqlite3_context*,const char*,int,void(*)(void*)); + void (*result_text16)(sqlite3_context*,const void*,int,void(*)(void*)); + void (*result_text16be)(sqlite3_context*,const void*,int,void(*)(void*)); + void (*result_text16le)(sqlite3_context*,const void*,int,void(*)(void*)); + void (*result_value)(sqlite3_context*,sqlite3_value*); + void * (*rollback_hook)(sqlite3*,void(*)(void*),void*); + int (*set_authorizer)(sqlite3*,int(*)(void*,int,const char*,const char*, + const char*,const char*),void*); + void (*set_auxdata)(sqlite3_context*,int,void*,void (*)(void*)); + char * (*xsnprintf)(int,char*,const char*,...); + int (*step)(sqlite3_stmt*); + int (*table_column_metadata)(sqlite3*,const char*,const char*,const char*, + char const**,char const**,int*,int*,int*); + void (*thread_cleanup)(void); + int (*total_changes)(sqlite3*); + void * (*trace)(sqlite3*,void(*xTrace)(void*,const char*),void*); + int (*transfer_bindings)(sqlite3_stmt*,sqlite3_stmt*); + void * (*update_hook)(sqlite3*,void(*)(void*,int ,char const*,char const*, + sqlite_int64),void*); + void * (*user_data)(sqlite3_context*); + const void * (*value_blob)(sqlite3_value*); + int (*value_bytes)(sqlite3_value*); + int (*value_bytes16)(sqlite3_value*); + double (*value_double)(sqlite3_value*); + int (*value_int)(sqlite3_value*); + sqlite_int64 (*value_int64)(sqlite3_value*); + int (*value_numeric_type)(sqlite3_value*); + const unsigned char * (*value_text)(sqlite3_value*); + const void * (*value_text16)(sqlite3_value*); + const void * (*value_text16be)(sqlite3_value*); + const void * (*value_text16le)(sqlite3_value*); + int (*value_type)(sqlite3_value*); + char *(*vmprintf)(const char*,va_list); + /* Added ??? */ + int (*overload_function)(sqlite3*, const char *zFuncName, int nArg); + /* Added by 3.3.13 */ + int (*prepare_v2)(sqlite3*,const char*,int,sqlite3_stmt**,const char**); + int (*prepare16_v2)(sqlite3*,const void*,int,sqlite3_stmt**,const void**); + int (*clear_bindings)(sqlite3_stmt*); + /* Added by 3.4.1 */ + int (*create_module_v2)(sqlite3*,const char*,const sqlite3_module*,void*, + void (*xDestroy)(void *)); + /* Added by 3.5.0 */ + int (*bind_zeroblob)(sqlite3_stmt*,int,int); + int (*blob_bytes)(sqlite3_blob*); + int (*blob_close)(sqlite3_blob*); + int (*blob_open)(sqlite3*,const char*,const char*,const char*,sqlite3_int64, + int,sqlite3_blob**); + int (*blob_read)(sqlite3_blob*,void*,int,int); + int (*blob_write)(sqlite3_blob*,const void*,int,int); + int (*create_collation_v2)(sqlite3*,const char*,int,void*, + int(*)(void*,int,const void*,int,const void*), + void(*)(void*)); + int (*file_control)(sqlite3*,const char*,int,void*); + sqlite3_int64 (*memory_highwater)(int); + sqlite3_int64 (*memory_used)(void); + sqlite3_mutex *(*mutex_alloc)(int); + void (*mutex_enter)(sqlite3_mutex*); + void (*mutex_free)(sqlite3_mutex*); + void (*mutex_leave)(sqlite3_mutex*); + int (*mutex_try)(sqlite3_mutex*); + int (*open_v2)(const char*,sqlite3**,int,const char*); + int (*release_memory)(int); + void (*result_error_nomem)(sqlite3_context*); + void (*result_error_toobig)(sqlite3_context*); + int (*sleep)(int); + void (*soft_heap_limit)(int); + sqlite3_vfs *(*vfs_find)(const char*); + int (*vfs_register)(sqlite3_vfs*,int); + int (*vfs_unregister)(sqlite3_vfs*); + int (*xthreadsafe)(void); + void (*result_zeroblob)(sqlite3_context*,int); + void (*result_error_code)(sqlite3_context*,int); + int (*test_control)(int, ...); + void (*randomness)(int,void*); + sqlite3 *(*context_db_handle)(sqlite3_context*); + int (*extended_result_codes)(sqlite3*,int); + int (*limit)(sqlite3*,int,int); + sqlite3_stmt *(*next_stmt)(sqlite3*,sqlite3_stmt*); + const char *(*sql)(sqlite3_stmt*); + int (*status)(int,int*,int*,int); + int (*backup_finish)(sqlite3_backup*); + sqlite3_backup *(*backup_init)(sqlite3*,const char*,sqlite3*,const char*); + int (*backup_pagecount)(sqlite3_backup*); + int (*backup_remaining)(sqlite3_backup*); + int (*backup_step)(sqlite3_backup*,int); + const char *(*compileoption_get)(int); + int (*compileoption_used)(const char*); + int (*create_function_v2)(sqlite3*,const char*,int,int,void*, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*), + void(*xDestroy)(void*)); + int (*db_config)(sqlite3*,int,...); + sqlite3_mutex *(*db_mutex)(sqlite3*); + int (*db_status)(sqlite3*,int,int*,int*,int); + int (*extended_errcode)(sqlite3*); + void (*log)(int,const char*,...); + sqlite3_int64 (*soft_heap_limit64)(sqlite3_int64); + const char *(*sourceid)(void); + int (*stmt_status)(sqlite3_stmt*,int,int); + int (*strnicmp)(const char*,const char*,int); + int (*unlock_notify)(sqlite3*,void(*)(void**,int),void*); + int (*wal_autocheckpoint)(sqlite3*,int); + int (*wal_checkpoint)(sqlite3*,const char*); + void *(*wal_hook)(sqlite3*,int(*)(void*,sqlite3*,const char*,int),void*); + int (*blob_reopen)(sqlite3_blob*,sqlite3_int64); + int (*vtab_config)(sqlite3*,int op,...); + int (*vtab_on_conflict)(sqlite3*); + /* Version 3.7.16 and later */ + int (*close_v2)(sqlite3*); + const char *(*db_filename)(sqlite3*,const char*); + int (*db_readonly)(sqlite3*,const char*); + int (*db_release_memory)(sqlite3*); + const char *(*errstr)(int); + int (*stmt_busy)(sqlite3_stmt*); + int (*stmt_readonly)(sqlite3_stmt*); + int (*stricmp)(const char*,const char*); + int (*uri_boolean)(const char*,const char*,int); + sqlite3_int64 (*uri_int64)(const char*,const char*,sqlite3_int64); + const char *(*uri_parameter)(const char*,const char*); + char *(*xvsnprintf)(int,char*,const char*,va_list); + int (*wal_checkpoint_v2)(sqlite3*,const char*,int,int*,int*); + /* Version 3.8.7 and later */ + int (*auto_extension)(void(*)(void)); + int (*bind_blob64)(sqlite3_stmt*,int,const void*,sqlite3_uint64, + void(*)(void*)); + int (*bind_text64)(sqlite3_stmt*,int,const char*,sqlite3_uint64, + void(*)(void*),unsigned char); + int (*cancel_auto_extension)(void(*)(void)); + int (*load_extension)(sqlite3*,const char*,const char*,char**); + void *(*malloc64)(sqlite3_uint64); + sqlite3_uint64 (*msize)(void*); + void *(*realloc64)(void*,sqlite3_uint64); + void (*reset_auto_extension)(void); + void (*result_blob64)(sqlite3_context*,const void*,sqlite3_uint64, + void(*)(void*)); + void (*result_text64)(sqlite3_context*,const char*,sqlite3_uint64, + void(*)(void*), unsigned char); + int (*strglob)(const char*,const char*); + /* Version 3.8.11 and later */ + sqlite3_value *(*value_dup)(const sqlite3_value*); + void (*value_free)(sqlite3_value*); + int (*result_zeroblob64)(sqlite3_context*,sqlite3_uint64); + int (*bind_zeroblob64)(sqlite3_stmt*, int, sqlite3_uint64); + /* Version 3.9.0 and later */ + unsigned int (*value_subtype)(sqlite3_value*); + void (*result_subtype)(sqlite3_context*,unsigned int); + /* Version 3.10.0 and later */ + int (*status64)(int,sqlite3_int64*,sqlite3_int64*,int); + int (*strlike)(const char*,const char*,unsigned int); + int (*db_cacheflush)(sqlite3*); + /* Version 3.12.0 and later */ + int (*system_errno)(sqlite3*); + /* Version 3.14.0 and later */ + int (*trace_v2)(sqlite3*,unsigned,int(*)(unsigned,void*,void*,void*),void*); + char *(*expanded_sql)(sqlite3_stmt*); + /* Version 3.18.0 and later */ + void (*set_last_insert_rowid)(sqlite3*,sqlite3_int64); + /* Version 3.20.0 and later */ + int (*prepare_v3)(sqlite3*,const char*,int,unsigned int, + sqlite3_stmt**,const char**); + int (*prepare16_v3)(sqlite3*,const void*,int,unsigned int, + sqlite3_stmt**,const void**); + int (*bind_pointer)(sqlite3_stmt*,int,void*,const char*,void(*)(void*)); + void (*result_pointer)(sqlite3_context*,void*,const char*,void(*)(void*)); + void *(*value_pointer)(sqlite3_value*,const char*); + int (*vtab_nochange)(sqlite3_context*); + int (*value_nochange)(sqlite3_value*); + const char *(*vtab_collation)(sqlite3_index_info*,int); + /* Version 3.24.0 and later */ + int (*keyword_count)(void); + int (*keyword_name)(int,const char**,int*); + int (*keyword_check)(const char*,int); + sqlite3_str *(*str_new)(sqlite3*); + char *(*str_finish)(sqlite3_str*); + void (*str_appendf)(sqlite3_str*, const char *zFormat, ...); + void (*str_vappendf)(sqlite3_str*, const char *zFormat, va_list); + void (*str_append)(sqlite3_str*, const char *zIn, int N); + void (*str_appendall)(sqlite3_str*, const char *zIn); + void (*str_appendchar)(sqlite3_str*, int N, char C); + void (*str_reset)(sqlite3_str*); + int (*str_errcode)(sqlite3_str*); + int (*str_length)(sqlite3_str*); + char *(*str_value)(sqlite3_str*); + /* Version 3.25.0 and later */ + int (*create_window_function)(sqlite3*,const char*,int,int,void*, + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*), + void (*xValue)(sqlite3_context*), + void (*xInv)(sqlite3_context*,int,sqlite3_value**), + void(*xDestroy)(void*)); + /* Version 3.26.0 and later */ + const char *(*normalized_sql)(sqlite3_stmt*); + /* Version 3.28.0 and later */ + int (*stmt_isexplain)(sqlite3_stmt*); + int (*value_frombind)(sqlite3_value*); + /* Version 3.30.0 and later */ + int (*drop_modules)(sqlite3*,const char**); + /* Version 3.31.0 and later */ + sqlite3_int64 (*hard_heap_limit64)(sqlite3_int64); + const char *(*uri_key)(const char*,int); + const char *(*filename_database)(const char*); + const char *(*filename_journal)(const char*); + const char *(*filename_wal)(const char*); + /* Version 3.32.0 and later */ + const char *(*create_filename)(const char*,const char*,const char*, + int,const char**); + void (*free_filename)(const char*); + sqlite3_file *(*database_file_object)(const char*); + /* Version 3.34.0 and later */ + int (*txn_state)(sqlite3*,const char*); + /* Version 3.36.1 and later */ + sqlite3_int64 (*changes64)(sqlite3*); + sqlite3_int64 (*total_changes64)(sqlite3*); + /* Version 3.37.0 and later */ + int (*autovacuum_pages)(sqlite3*, + unsigned int(*)(void*,const char*,unsigned int,unsigned int,unsigned int), + void*, void(*)(void*)); + /* Version 3.38.0 and later */ + int (*error_offset)(sqlite3*); + int (*vtab_rhs_value)(sqlite3_index_info*,int,sqlite3_value**); + int (*vtab_distinct)(sqlite3_index_info*); + int (*vtab_in)(sqlite3_index_info*,int,int); + int (*vtab_in_first)(sqlite3_value*,sqlite3_value**); + int (*vtab_in_next)(sqlite3_value*,sqlite3_value**); + /* Version 3.39.0 and later */ + int (*deserialize)(sqlite3*,const char*,unsigned char*, + sqlite3_int64,sqlite3_int64,unsigned); + unsigned char *(*serialize)(sqlite3*,const char *,sqlite3_int64*, + unsigned int); + const char *(*db_name)(sqlite3*,int); + /* Version 3.40.0 and later */ + int (*value_encoding)(sqlite3_value*); + /* Version 3.41.0 and later */ + int (*is_interrupted)(sqlite3*); +}; + +/* +** This is the function signature used for all extension entry points. It +** is also defined in the file "loadext.c". +*/ +typedef int (*sqlite3_loadext_entry)( + sqlite3 *db, /* Handle to the database. */ + char **pzErrMsg, /* Used to set error string on failure. */ + const sqlite3_api_routines *pThunk /* Extension API function pointers. */ +); + +/* +** The following macros redefine the API routines so that they are +** redirected through the global sqlite3_api structure. +** +** This header file is also used by the loadext.c source file +** (part of the main SQLite library - not an extension) so that +** it can get access to the sqlite3_api_routines structure +** definition. But the main library does not want to redefine +** the API. So the redefinition macros are only valid if the +** SQLITE_CORE macros is undefined. +*/ +#if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) +#define sqlite3_aggregate_context sqlite3_api->aggregate_context +#ifndef SQLITE_OMIT_DEPRECATED +#define sqlite3_aggregate_count sqlite3_api->aggregate_count +#endif +#define sqlite3_bind_blob sqlite3_api->bind_blob +#define sqlite3_bind_double sqlite3_api->bind_double +#define sqlite3_bind_int sqlite3_api->bind_int +#define sqlite3_bind_int64 sqlite3_api->bind_int64 +#define sqlite3_bind_null sqlite3_api->bind_null +#define sqlite3_bind_parameter_count sqlite3_api->bind_parameter_count +#define sqlite3_bind_parameter_index sqlite3_api->bind_parameter_index +#define sqlite3_bind_parameter_name sqlite3_api->bind_parameter_name +#define sqlite3_bind_text sqlite3_api->bind_text +#define sqlite3_bind_text16 sqlite3_api->bind_text16 +#define sqlite3_bind_value sqlite3_api->bind_value +#define sqlite3_busy_handler sqlite3_api->busy_handler +#define sqlite3_busy_timeout sqlite3_api->busy_timeout +#define sqlite3_changes sqlite3_api->changes +#define sqlite3_close sqlite3_api->close +#define sqlite3_collation_needed sqlite3_api->collation_needed +#define sqlite3_collation_needed16 sqlite3_api->collation_needed16 +#define sqlite3_column_blob sqlite3_api->column_blob +#define sqlite3_column_bytes sqlite3_api->column_bytes +#define sqlite3_column_bytes16 sqlite3_api->column_bytes16 +#define sqlite3_column_count sqlite3_api->column_count +#define sqlite3_column_database_name sqlite3_api->column_database_name +#define sqlite3_column_database_name16 sqlite3_api->column_database_name16 +#define sqlite3_column_decltype sqlite3_api->column_decltype +#define sqlite3_column_decltype16 sqlite3_api->column_decltype16 +#define sqlite3_column_double sqlite3_api->column_double +#define sqlite3_column_int sqlite3_api->column_int +#define sqlite3_column_int64 sqlite3_api->column_int64 +#define sqlite3_column_name sqlite3_api->column_name +#define sqlite3_column_name16 sqlite3_api->column_name16 +#define sqlite3_column_origin_name sqlite3_api->column_origin_name +#define sqlite3_column_origin_name16 sqlite3_api->column_origin_name16 +#define sqlite3_column_table_name sqlite3_api->column_table_name +#define sqlite3_column_table_name16 sqlite3_api->column_table_name16 +#define sqlite3_column_text sqlite3_api->column_text +#define sqlite3_column_text16 sqlite3_api->column_text16 +#define sqlite3_column_type sqlite3_api->column_type +#define sqlite3_column_value sqlite3_api->column_value +#define sqlite3_commit_hook sqlite3_api->commit_hook +#define sqlite3_complete sqlite3_api->complete +#define sqlite3_complete16 sqlite3_api->complete16 +#define sqlite3_create_collation sqlite3_api->create_collation +#define sqlite3_create_collation16 sqlite3_api->create_collation16 +#define sqlite3_create_function sqlite3_api->create_function +#define sqlite3_create_function16 sqlite3_api->create_function16 +#define sqlite3_create_module sqlite3_api->create_module +#define sqlite3_create_module_v2 sqlite3_api->create_module_v2 +#define sqlite3_data_count sqlite3_api->data_count +#define sqlite3_db_handle sqlite3_api->db_handle +#define sqlite3_declare_vtab sqlite3_api->declare_vtab +#define sqlite3_enable_shared_cache sqlite3_api->enable_shared_cache +#define sqlite3_errcode sqlite3_api->errcode +#define sqlite3_errmsg sqlite3_api->errmsg +#define sqlite3_errmsg16 sqlite3_api->errmsg16 +#define sqlite3_exec sqlite3_api->exec +#ifndef SQLITE_OMIT_DEPRECATED +#define sqlite3_expired sqlite3_api->expired +#endif +#define sqlite3_finalize sqlite3_api->finalize +#define sqlite3_free sqlite3_api->free +#define sqlite3_free_table sqlite3_api->free_table +#define sqlite3_get_autocommit sqlite3_api->get_autocommit +#define sqlite3_get_auxdata sqlite3_api->get_auxdata +#define sqlite3_get_table sqlite3_api->get_table +#ifndef SQLITE_OMIT_DEPRECATED +#define sqlite3_global_recover sqlite3_api->global_recover +#endif +#define sqlite3_interrupt sqlite3_api->interruptx +#define sqlite3_last_insert_rowid sqlite3_api->last_insert_rowid +#define sqlite3_libversion sqlite3_api->libversion +#define sqlite3_libversion_number sqlite3_api->libversion_number +#define sqlite3_malloc sqlite3_api->malloc +#define sqlite3_mprintf sqlite3_api->mprintf +#define sqlite3_open sqlite3_api->open +#define sqlite3_open16 sqlite3_api->open16 +#define sqlite3_prepare sqlite3_api->prepare +#define sqlite3_prepare16 sqlite3_api->prepare16 +#define sqlite3_prepare_v2 sqlite3_api->prepare_v2 +#define sqlite3_prepare16_v2 sqlite3_api->prepare16_v2 +#define sqlite3_profile sqlite3_api->profile +#define sqlite3_progress_handler sqlite3_api->progress_handler +#define sqlite3_realloc sqlite3_api->realloc +#define sqlite3_reset sqlite3_api->reset +#define sqlite3_result_blob sqlite3_api->result_blob +#define sqlite3_result_double sqlite3_api->result_double +#define sqlite3_result_error sqlite3_api->result_error +#define sqlite3_result_error16 sqlite3_api->result_error16 +#define sqlite3_result_int sqlite3_api->result_int +#define sqlite3_result_int64 sqlite3_api->result_int64 +#define sqlite3_result_null sqlite3_api->result_null +#define sqlite3_result_text sqlite3_api->result_text +#define sqlite3_result_text16 sqlite3_api->result_text16 +#define sqlite3_result_text16be sqlite3_api->result_text16be +#define sqlite3_result_text16le sqlite3_api->result_text16le +#define sqlite3_result_value sqlite3_api->result_value +#define sqlite3_rollback_hook sqlite3_api->rollback_hook +#define sqlite3_set_authorizer sqlite3_api->set_authorizer +#define sqlite3_set_auxdata sqlite3_api->set_auxdata +#define sqlite3_snprintf sqlite3_api->xsnprintf +#define sqlite3_step sqlite3_api->step +#define sqlite3_table_column_metadata sqlite3_api->table_column_metadata +#define sqlite3_thread_cleanup sqlite3_api->thread_cleanup +#define sqlite3_total_changes sqlite3_api->total_changes +#define sqlite3_trace sqlite3_api->trace +#ifndef SQLITE_OMIT_DEPRECATED +#define sqlite3_transfer_bindings sqlite3_api->transfer_bindings +#endif +#define sqlite3_update_hook sqlite3_api->update_hook +#define sqlite3_user_data sqlite3_api->user_data +#define sqlite3_value_blob sqlite3_api->value_blob +#define sqlite3_value_bytes sqlite3_api->value_bytes +#define sqlite3_value_bytes16 sqlite3_api->value_bytes16 +#define sqlite3_value_double sqlite3_api->value_double +#define sqlite3_value_int sqlite3_api->value_int +#define sqlite3_value_int64 sqlite3_api->value_int64 +#define sqlite3_value_numeric_type sqlite3_api->value_numeric_type +#define sqlite3_value_text sqlite3_api->value_text +#define sqlite3_value_text16 sqlite3_api->value_text16 +#define sqlite3_value_text16be sqlite3_api->value_text16be +#define sqlite3_value_text16le sqlite3_api->value_text16le +#define sqlite3_value_type sqlite3_api->value_type +#define sqlite3_vmprintf sqlite3_api->vmprintf +#define sqlite3_vsnprintf sqlite3_api->xvsnprintf +#define sqlite3_overload_function sqlite3_api->overload_function +#define sqlite3_prepare_v2 sqlite3_api->prepare_v2 +#define sqlite3_prepare16_v2 sqlite3_api->prepare16_v2 +#define sqlite3_clear_bindings sqlite3_api->clear_bindings +#define sqlite3_bind_zeroblob sqlite3_api->bind_zeroblob +#define sqlite3_blob_bytes sqlite3_api->blob_bytes +#define sqlite3_blob_close sqlite3_api->blob_close +#define sqlite3_blob_open sqlite3_api->blob_open +#define sqlite3_blob_read sqlite3_api->blob_read +#define sqlite3_blob_write sqlite3_api->blob_write +#define sqlite3_create_collation_v2 sqlite3_api->create_collation_v2 +#define sqlite3_file_control sqlite3_api->file_control +#define sqlite3_memory_highwater sqlite3_api->memory_highwater +#define sqlite3_memory_used sqlite3_api->memory_used +#define sqlite3_mutex_alloc sqlite3_api->mutex_alloc +#define sqlite3_mutex_enter sqlite3_api->mutex_enter +#define sqlite3_mutex_free sqlite3_api->mutex_free +#define sqlite3_mutex_leave sqlite3_api->mutex_leave +#define sqlite3_mutex_try sqlite3_api->mutex_try +#define sqlite3_open_v2 sqlite3_api->open_v2 +#define sqlite3_release_memory sqlite3_api->release_memory +#define sqlite3_result_error_nomem sqlite3_api->result_error_nomem +#define sqlite3_result_error_toobig sqlite3_api->result_error_toobig +#define sqlite3_sleep sqlite3_api->sleep +#define sqlite3_soft_heap_limit sqlite3_api->soft_heap_limit +#define sqlite3_vfs_find sqlite3_api->vfs_find +#define sqlite3_vfs_register sqlite3_api->vfs_register +#define sqlite3_vfs_unregister sqlite3_api->vfs_unregister +#define sqlite3_threadsafe sqlite3_api->xthreadsafe +#define sqlite3_result_zeroblob sqlite3_api->result_zeroblob +#define sqlite3_result_error_code sqlite3_api->result_error_code +#define sqlite3_test_control sqlite3_api->test_control +#define sqlite3_randomness sqlite3_api->randomness +#define sqlite3_context_db_handle sqlite3_api->context_db_handle +#define sqlite3_extended_result_codes sqlite3_api->extended_result_codes +#define sqlite3_limit sqlite3_api->limit +#define sqlite3_next_stmt sqlite3_api->next_stmt +#define sqlite3_sql sqlite3_api->sql +#define sqlite3_status sqlite3_api->status +#define sqlite3_backup_finish sqlite3_api->backup_finish +#define sqlite3_backup_init sqlite3_api->backup_init +#define sqlite3_backup_pagecount sqlite3_api->backup_pagecount +#define sqlite3_backup_remaining sqlite3_api->backup_remaining +#define sqlite3_backup_step sqlite3_api->backup_step +#define sqlite3_compileoption_get sqlite3_api->compileoption_get +#define sqlite3_compileoption_used sqlite3_api->compileoption_used +#define sqlite3_create_function_v2 sqlite3_api->create_function_v2 +#define sqlite3_db_config sqlite3_api->db_config +#define sqlite3_db_mutex sqlite3_api->db_mutex +#define sqlite3_db_status sqlite3_api->db_status +#define sqlite3_extended_errcode sqlite3_api->extended_errcode +#define sqlite3_log sqlite3_api->log +#define sqlite3_soft_heap_limit64 sqlite3_api->soft_heap_limit64 +#define sqlite3_sourceid sqlite3_api->sourceid +#define sqlite3_stmt_status sqlite3_api->stmt_status +#define sqlite3_strnicmp sqlite3_api->strnicmp +#define sqlite3_unlock_notify sqlite3_api->unlock_notify +#define sqlite3_wal_autocheckpoint sqlite3_api->wal_autocheckpoint +#define sqlite3_wal_checkpoint sqlite3_api->wal_checkpoint +#define sqlite3_wal_hook sqlite3_api->wal_hook +#define sqlite3_blob_reopen sqlite3_api->blob_reopen +#define sqlite3_vtab_config sqlite3_api->vtab_config +#define sqlite3_vtab_on_conflict sqlite3_api->vtab_on_conflict +/* Version 3.7.16 and later */ +#define sqlite3_close_v2 sqlite3_api->close_v2 +#define sqlite3_db_filename sqlite3_api->db_filename +#define sqlite3_db_readonly sqlite3_api->db_readonly +#define sqlite3_db_release_memory sqlite3_api->db_release_memory +#define sqlite3_errstr sqlite3_api->errstr +#define sqlite3_stmt_busy sqlite3_api->stmt_busy +#define sqlite3_stmt_readonly sqlite3_api->stmt_readonly +#define sqlite3_stricmp sqlite3_api->stricmp +#define sqlite3_uri_boolean sqlite3_api->uri_boolean +#define sqlite3_uri_int64 sqlite3_api->uri_int64 +#define sqlite3_uri_parameter sqlite3_api->uri_parameter +#define sqlite3_uri_vsnprintf sqlite3_api->xvsnprintf +#define sqlite3_wal_checkpoint_v2 sqlite3_api->wal_checkpoint_v2 +/* Version 3.8.7 and later */ +#define sqlite3_auto_extension sqlite3_api->auto_extension +#define sqlite3_bind_blob64 sqlite3_api->bind_blob64 +#define sqlite3_bind_text64 sqlite3_api->bind_text64 +#define sqlite3_cancel_auto_extension sqlite3_api->cancel_auto_extension +#define sqlite3_load_extension sqlite3_api->load_extension +#define sqlite3_malloc64 sqlite3_api->malloc64 +#define sqlite3_msize sqlite3_api->msize +#define sqlite3_realloc64 sqlite3_api->realloc64 +#define sqlite3_reset_auto_extension sqlite3_api->reset_auto_extension +#define sqlite3_result_blob64 sqlite3_api->result_blob64 +#define sqlite3_result_text64 sqlite3_api->result_text64 +#define sqlite3_strglob sqlite3_api->strglob +/* Version 3.8.11 and later */ +#define sqlite3_value_dup sqlite3_api->value_dup +#define sqlite3_value_free sqlite3_api->value_free +#define sqlite3_result_zeroblob64 sqlite3_api->result_zeroblob64 +#define sqlite3_bind_zeroblob64 sqlite3_api->bind_zeroblob64 +/* Version 3.9.0 and later */ +#define sqlite3_value_subtype sqlite3_api->value_subtype +#define sqlite3_result_subtype sqlite3_api->result_subtype +/* Version 3.10.0 and later */ +#define sqlite3_status64 sqlite3_api->status64 +#define sqlite3_strlike sqlite3_api->strlike +#define sqlite3_db_cacheflush sqlite3_api->db_cacheflush +/* Version 3.12.0 and later */ +#define sqlite3_system_errno sqlite3_api->system_errno +/* Version 3.14.0 and later */ +#define sqlite3_trace_v2 sqlite3_api->trace_v2 +#define sqlite3_expanded_sql sqlite3_api->expanded_sql +/* Version 3.18.0 and later */ +#define sqlite3_set_last_insert_rowid sqlite3_api->set_last_insert_rowid +/* Version 3.20.0 and later */ +#define sqlite3_prepare_v3 sqlite3_api->prepare_v3 +#define sqlite3_prepare16_v3 sqlite3_api->prepare16_v3 +#define sqlite3_bind_pointer sqlite3_api->bind_pointer +#define sqlite3_result_pointer sqlite3_api->result_pointer +#define sqlite3_value_pointer sqlite3_api->value_pointer +/* Version 3.22.0 and later */ +#define sqlite3_vtab_nochange sqlite3_api->vtab_nochange +#define sqlite3_value_nochange sqlite3_api->value_nochange +#define sqlite3_vtab_collation sqlite3_api->vtab_collation +/* Version 3.24.0 and later */ +#define sqlite3_keyword_count sqlite3_api->keyword_count +#define sqlite3_keyword_name sqlite3_api->keyword_name +#define sqlite3_keyword_check sqlite3_api->keyword_check +#define sqlite3_str_new sqlite3_api->str_new +#define sqlite3_str_finish sqlite3_api->str_finish +#define sqlite3_str_appendf sqlite3_api->str_appendf +#define sqlite3_str_vappendf sqlite3_api->str_vappendf +#define sqlite3_str_append sqlite3_api->str_append +#define sqlite3_str_appendall sqlite3_api->str_appendall +#define sqlite3_str_appendchar sqlite3_api->str_appendchar +#define sqlite3_str_reset sqlite3_api->str_reset +#define sqlite3_str_errcode sqlite3_api->str_errcode +#define sqlite3_str_length sqlite3_api->str_length +#define sqlite3_str_value sqlite3_api->str_value +/* Version 3.25.0 and later */ +#define sqlite3_create_window_function sqlite3_api->create_window_function +/* Version 3.26.0 and later */ +#define sqlite3_normalized_sql sqlite3_api->normalized_sql +/* Version 3.28.0 and later */ +#define sqlite3_stmt_isexplain sqlite3_api->stmt_isexplain +#define sqlite3_value_frombind sqlite3_api->value_frombind +/* Version 3.30.0 and later */ +#define sqlite3_drop_modules sqlite3_api->drop_modules +/* Version 3.31.0 and later */ +#define sqlite3_hard_heap_limit64 sqlite3_api->hard_heap_limit64 +#define sqlite3_uri_key sqlite3_api->uri_key +#define sqlite3_filename_database sqlite3_api->filename_database +#define sqlite3_filename_journal sqlite3_api->filename_journal +#define sqlite3_filename_wal sqlite3_api->filename_wal +/* Version 3.32.0 and later */ +#define sqlite3_create_filename sqlite3_api->create_filename +#define sqlite3_free_filename sqlite3_api->free_filename +#define sqlite3_database_file_object sqlite3_api->database_file_object +/* Version 3.34.0 and later */ +#define sqlite3_txn_state sqlite3_api->txn_state +/* Version 3.36.1 and later */ +#define sqlite3_changes64 sqlite3_api->changes64 +#define sqlite3_total_changes64 sqlite3_api->total_changes64 +/* Version 3.37.0 and later */ +#define sqlite3_autovacuum_pages sqlite3_api->autovacuum_pages +/* Version 3.38.0 and later */ +#define sqlite3_error_offset sqlite3_api->error_offset +#define sqlite3_vtab_rhs_value sqlite3_api->vtab_rhs_value +#define sqlite3_vtab_distinct sqlite3_api->vtab_distinct +#define sqlite3_vtab_in sqlite3_api->vtab_in +#define sqlite3_vtab_in_first sqlite3_api->vtab_in_first +#define sqlite3_vtab_in_next sqlite3_api->vtab_in_next +/* Version 3.39.0 and later */ +#ifndef SQLITE_OMIT_DESERIALIZE +#define sqlite3_deserialize sqlite3_api->deserialize +#define sqlite3_serialize sqlite3_api->serialize +#endif +#define sqlite3_db_name sqlite3_api->db_name +/* Version 3.40.0 and later */ +#define sqlite3_value_encoding sqlite3_api->value_encoding +/* Version 3.41.0 and later */ +#define sqlite3_is_interrupted sqlite3_api->is_interrupted +#endif /* !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) */ + +#if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) + /* This case when the file really is being compiled as a loadable + ** extension */ +# define SQLITE_EXTENSION_INIT1 const sqlite3_api_routines *sqlite3_api=0; +# define SQLITE_EXTENSION_INIT2(v) sqlite3_api=v; +# define SQLITE_EXTENSION_INIT3 \ + extern const sqlite3_api_routines *sqlite3_api; +#else + /* This case when the file is being statically linked into the + ** application */ +# define SQLITE_EXTENSION_INIT1 /*no-op*/ +# define SQLITE_EXTENSION_INIT2(v) (void)v; /* unused parameter */ +# define SQLITE_EXTENSION_INIT3 /*no-op*/ +#endif + +#endif /* SQLITE3EXT_H */ + +/************** End of sqlite3ext.h ******************************************/ +/************** Continuing where we left off in loadext.c ********************/ +/* #include "sqliteInt.h" */ + +#ifndef SQLITE_OMIT_LOAD_EXTENSION +/* +** Some API routines are omitted when various features are +** excluded from a build of SQLite. Substitute a NULL pointer +** for any missing APIs. +*/ +#ifndef SQLITE_ENABLE_COLUMN_METADATA +# define sqlite3_column_database_name 0 +# define sqlite3_column_database_name16 0 +# define sqlite3_column_table_name 0 +# define sqlite3_column_table_name16 0 +# define sqlite3_column_origin_name 0 +# define sqlite3_column_origin_name16 0 +#endif + +#ifdef SQLITE_OMIT_AUTHORIZATION +# define sqlite3_set_authorizer 0 +#endif + +#ifdef SQLITE_OMIT_UTF16 +# define sqlite3_bind_text16 0 +# define sqlite3_collation_needed16 0 +# define sqlite3_column_decltype16 0 +# define sqlite3_column_name16 0 +# define sqlite3_column_text16 0 +# define sqlite3_complete16 0 +# define sqlite3_create_collation16 0 +# define sqlite3_create_function16 0 +# define sqlite3_errmsg16 0 +# define sqlite3_open16 0 +# define sqlite3_prepare16 0 +# define sqlite3_prepare16_v2 0 +# define sqlite3_prepare16_v3 0 +# define sqlite3_result_error16 0 +# define sqlite3_result_text16 0 +# define sqlite3_result_text16be 0 +# define sqlite3_result_text16le 0 +# define sqlite3_value_text16 0 +# define sqlite3_value_text16be 0 +# define sqlite3_value_text16le 0 +# define sqlite3_column_database_name16 0 +# define sqlite3_column_table_name16 0 +# define sqlite3_column_origin_name16 0 +#endif + +#ifdef SQLITE_OMIT_COMPLETE +# define sqlite3_complete 0 +# define sqlite3_complete16 0 +#endif + +#ifdef SQLITE_OMIT_DECLTYPE +# define sqlite3_column_decltype16 0 +# define sqlite3_column_decltype 0 +#endif + +#ifdef SQLITE_OMIT_PROGRESS_CALLBACK +# define sqlite3_progress_handler 0 +#endif + +#ifdef SQLITE_OMIT_VIRTUALTABLE +# define sqlite3_create_module 0 +# define sqlite3_create_module_v2 0 +# define sqlite3_declare_vtab 0 +# define sqlite3_vtab_config 0 +# define sqlite3_vtab_on_conflict 0 +# define sqlite3_vtab_collation 0 +#endif + +#ifdef SQLITE_OMIT_SHARED_CACHE +# define sqlite3_enable_shared_cache 0 +#endif + +#if defined(SQLITE_OMIT_TRACE) || defined(SQLITE_OMIT_DEPRECATED) +# define sqlite3_profile 0 +# define sqlite3_trace 0 +#endif + +#ifdef SQLITE_OMIT_GET_TABLE +# define sqlite3_free_table 0 +# define sqlite3_get_table 0 +#endif + +#ifdef SQLITE_OMIT_INCRBLOB +#define sqlite3_bind_zeroblob 0 +#define sqlite3_blob_bytes 0 +#define sqlite3_blob_close 0 +#define sqlite3_blob_open 0 +#define sqlite3_blob_read 0 +#define sqlite3_blob_write 0 +#define sqlite3_blob_reopen 0 +#endif + +#if defined(SQLITE_OMIT_TRACE) +# define sqlite3_trace_v2 0 +#endif + +/* +** The following structure contains pointers to all SQLite API routines. +** A pointer to this structure is passed into extensions when they are +** loaded so that the extension can make calls back into the SQLite +** library. +** +** When adding new APIs, add them to the bottom of this structure +** in order to preserve backwards compatibility. +** +** Extensions that use newer APIs should first call the +** sqlite3_libversion_number() to make sure that the API they +** intend to use is supported by the library. Extensions should +** also check to make sure that the pointer to the function is +** not NULL before calling it. +*/ +static const sqlite3_api_routines sqlite3Apis = { + sqlite3_aggregate_context, +#ifndef SQLITE_OMIT_DEPRECATED + sqlite3_aggregate_count, +#else + 0, +#endif + sqlite3_bind_blob, + sqlite3_bind_double, + sqlite3_bind_int, + sqlite3_bind_int64, + sqlite3_bind_null, + sqlite3_bind_parameter_count, + sqlite3_bind_parameter_index, + sqlite3_bind_parameter_name, + sqlite3_bind_text, + sqlite3_bind_text16, + sqlite3_bind_value, + sqlite3_busy_handler, + sqlite3_busy_timeout, + sqlite3_changes, + sqlite3_close, + sqlite3_collation_needed, + sqlite3_collation_needed16, + sqlite3_column_blob, + sqlite3_column_bytes, + sqlite3_column_bytes16, + sqlite3_column_count, + sqlite3_column_database_name, + sqlite3_column_database_name16, + sqlite3_column_decltype, + sqlite3_column_decltype16, + sqlite3_column_double, + sqlite3_column_int, + sqlite3_column_int64, + sqlite3_column_name, + sqlite3_column_name16, + sqlite3_column_origin_name, + sqlite3_column_origin_name16, + sqlite3_column_table_name, + sqlite3_column_table_name16, + sqlite3_column_text, + sqlite3_column_text16, + sqlite3_column_type, + sqlite3_column_value, + sqlite3_commit_hook, + sqlite3_complete, + sqlite3_complete16, + sqlite3_create_collation, + sqlite3_create_collation16, + sqlite3_create_function, + sqlite3_create_function16, + sqlite3_create_module, + sqlite3_data_count, + sqlite3_db_handle, + sqlite3_declare_vtab, + sqlite3_enable_shared_cache, + sqlite3_errcode, + sqlite3_errmsg, + sqlite3_errmsg16, + sqlite3_exec, +#ifndef SQLITE_OMIT_DEPRECATED + sqlite3_expired, +#else + 0, +#endif + sqlite3_finalize, + sqlite3_free, + sqlite3_free_table, + sqlite3_get_autocommit, + sqlite3_get_auxdata, + sqlite3_get_table, + 0, /* Was sqlite3_global_recover(), but that function is deprecated */ + sqlite3_interrupt, + sqlite3_last_insert_rowid, + sqlite3_libversion, + sqlite3_libversion_number, + sqlite3_malloc, + sqlite3_mprintf, + sqlite3_open, + sqlite3_open16, + sqlite3_prepare, + sqlite3_prepare16, + sqlite3_profile, + sqlite3_progress_handler, + sqlite3_realloc, + sqlite3_reset, + sqlite3_result_blob, + sqlite3_result_double, + sqlite3_result_error, + sqlite3_result_error16, + sqlite3_result_int, + sqlite3_result_int64, + sqlite3_result_null, + sqlite3_result_text, + sqlite3_result_text16, + sqlite3_result_text16be, + sqlite3_result_text16le, + sqlite3_result_value, + sqlite3_rollback_hook, + sqlite3_set_authorizer, + sqlite3_set_auxdata, + sqlite3_snprintf, + sqlite3_step, + sqlite3_table_column_metadata, +#ifndef SQLITE_OMIT_DEPRECATED + sqlite3_thread_cleanup, +#else + 0, +#endif + sqlite3_total_changes, + sqlite3_trace, +#ifndef SQLITE_OMIT_DEPRECATED + sqlite3_transfer_bindings, +#else + 0, +#endif + sqlite3_update_hook, + sqlite3_user_data, + sqlite3_value_blob, + sqlite3_value_bytes, + sqlite3_value_bytes16, + sqlite3_value_double, + sqlite3_value_int, + sqlite3_value_int64, + sqlite3_value_numeric_type, + sqlite3_value_text, + sqlite3_value_text16, + sqlite3_value_text16be, + sqlite3_value_text16le, + sqlite3_value_type, + sqlite3_vmprintf, + /* + ** The original API set ends here. All extensions can call any + ** of the APIs above provided that the pointer is not NULL. But + ** before calling APIs that follow, extension should check the + ** sqlite3_libversion_number() to make sure they are dealing with + ** a library that is new enough to support that API. + ************************************************************************* + */ + sqlite3_overload_function, + + /* + ** Added after 3.3.13 + */ + sqlite3_prepare_v2, + sqlite3_prepare16_v2, + sqlite3_clear_bindings, + + /* + ** Added for 3.4.1 + */ + sqlite3_create_module_v2, + + /* + ** Added for 3.5.0 + */ + sqlite3_bind_zeroblob, + sqlite3_blob_bytes, + sqlite3_blob_close, + sqlite3_blob_open, + sqlite3_blob_read, + sqlite3_blob_write, + sqlite3_create_collation_v2, + sqlite3_file_control, + sqlite3_memory_highwater, + sqlite3_memory_used, +#ifdef SQLITE_MUTEX_OMIT + 0, + 0, + 0, + 0, + 0, +#else + sqlite3_mutex_alloc, + sqlite3_mutex_enter, + sqlite3_mutex_free, + sqlite3_mutex_leave, + sqlite3_mutex_try, +#endif + sqlite3_open_v2, + sqlite3_release_memory, + sqlite3_result_error_nomem, + sqlite3_result_error_toobig, + sqlite3_sleep, + sqlite3_soft_heap_limit, + sqlite3_vfs_find, + sqlite3_vfs_register, + sqlite3_vfs_unregister, + + /* + ** Added for 3.5.8 + */ + sqlite3_threadsafe, + sqlite3_result_zeroblob, + sqlite3_result_error_code, + sqlite3_test_control, + sqlite3_randomness, + sqlite3_context_db_handle, + + /* + ** Added for 3.6.0 + */ + sqlite3_extended_result_codes, + sqlite3_limit, + sqlite3_next_stmt, + sqlite3_sql, + sqlite3_status, + + /* + ** Added for 3.7.4 + */ + sqlite3_backup_finish, + sqlite3_backup_init, + sqlite3_backup_pagecount, + sqlite3_backup_remaining, + sqlite3_backup_step, +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS + sqlite3_compileoption_get, + sqlite3_compileoption_used, +#else + 0, + 0, +#endif + sqlite3_create_function_v2, + sqlite3_db_config, + sqlite3_db_mutex, + sqlite3_db_status, + sqlite3_extended_errcode, + sqlite3_log, + sqlite3_soft_heap_limit64, + sqlite3_sourceid, + sqlite3_stmt_status, + sqlite3_strnicmp, +#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY + sqlite3_unlock_notify, +#else + 0, +#endif +#ifndef SQLITE_OMIT_WAL + sqlite3_wal_autocheckpoint, + sqlite3_wal_checkpoint, + sqlite3_wal_hook, +#else + 0, + 0, + 0, +#endif + sqlite3_blob_reopen, + sqlite3_vtab_config, + sqlite3_vtab_on_conflict, + sqlite3_close_v2, + sqlite3_db_filename, + sqlite3_db_readonly, + sqlite3_db_release_memory, + sqlite3_errstr, + sqlite3_stmt_busy, + sqlite3_stmt_readonly, + sqlite3_stricmp, + sqlite3_uri_boolean, + sqlite3_uri_int64, + sqlite3_uri_parameter, + sqlite3_vsnprintf, + sqlite3_wal_checkpoint_v2, + /* Version 3.8.7 and later */ + sqlite3_auto_extension, + sqlite3_bind_blob64, + sqlite3_bind_text64, + sqlite3_cancel_auto_extension, + sqlite3_load_extension, + sqlite3_malloc64, + sqlite3_msize, + sqlite3_realloc64, + sqlite3_reset_auto_extension, + sqlite3_result_blob64, + sqlite3_result_text64, + sqlite3_strglob, + /* Version 3.8.11 and later */ + (sqlite3_value*(*)(const sqlite3_value*))sqlite3_value_dup, + sqlite3_value_free, + sqlite3_result_zeroblob64, + sqlite3_bind_zeroblob64, + /* Version 3.9.0 and later */ + sqlite3_value_subtype, + sqlite3_result_subtype, + /* Version 3.10.0 and later */ + sqlite3_status64, + sqlite3_strlike, + sqlite3_db_cacheflush, + /* Version 3.12.0 and later */ + sqlite3_system_errno, + /* Version 3.14.0 and later */ + sqlite3_trace_v2, + sqlite3_expanded_sql, + /* Version 3.18.0 and later */ + sqlite3_set_last_insert_rowid, + /* Version 3.20.0 and later */ + sqlite3_prepare_v3, + sqlite3_prepare16_v3, + sqlite3_bind_pointer, + sqlite3_result_pointer, + sqlite3_value_pointer, + /* Version 3.22.0 and later */ + sqlite3_vtab_nochange, + sqlite3_value_nochange, + sqlite3_vtab_collation, + /* Version 3.24.0 and later */ + sqlite3_keyword_count, + sqlite3_keyword_name, + sqlite3_keyword_check, + sqlite3_str_new, + sqlite3_str_finish, + sqlite3_str_appendf, + sqlite3_str_vappendf, + sqlite3_str_append, + sqlite3_str_appendall, + sqlite3_str_appendchar, + sqlite3_str_reset, + sqlite3_str_errcode, + sqlite3_str_length, + sqlite3_str_value, + /* Version 3.25.0 and later */ + sqlite3_create_window_function, + /* Version 3.26.0 and later */ +#ifdef SQLITE_ENABLE_NORMALIZE + sqlite3_normalized_sql, +#else + 0, +#endif + /* Version 3.28.0 and later */ + sqlite3_stmt_isexplain, + sqlite3_value_frombind, + /* Version 3.30.0 and later */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + sqlite3_drop_modules, +#else + 0, +#endif + /* Version 3.31.0 and later */ + sqlite3_hard_heap_limit64, + sqlite3_uri_key, + sqlite3_filename_database, + sqlite3_filename_journal, + sqlite3_filename_wal, + /* Version 3.32.0 and later */ + sqlite3_create_filename, + sqlite3_free_filename, + sqlite3_database_file_object, + /* Version 3.34.0 and later */ + sqlite3_txn_state, + /* Version 3.36.1 and later */ + sqlite3_changes64, + sqlite3_total_changes64, + /* Version 3.37.0 and later */ + sqlite3_autovacuum_pages, + /* Version 3.38.0 and later */ + sqlite3_error_offset, +#ifndef SQLITE_OMIT_VIRTUALTABLE + sqlite3_vtab_rhs_value, + sqlite3_vtab_distinct, + sqlite3_vtab_in, + sqlite3_vtab_in_first, + sqlite3_vtab_in_next, +#else + 0, + 0, + 0, + 0, + 0, +#endif + /* Version 3.39.0 and later */ +#ifndef SQLITE_OMIT_DESERIALIZE + sqlite3_deserialize, + sqlite3_serialize, +#else + 0, + 0, +#endif + sqlite3_db_name, + /* Version 3.40.0 and later */ + sqlite3_value_encoding, + /* Version 3.41.0 and later */ + sqlite3_is_interrupted +}; + +/* True if x is the directory separator character +*/ +#if SQLITE_OS_WIN +# define DirSep(X) ((X)=='/'||(X)=='\\') +#else +# define DirSep(X) ((X)=='/') +#endif + +/* +** Attempt to load an SQLite extension library contained in the file +** zFile. The entry point is zProc. zProc may be 0 in which case a +** default entry point name (sqlite3_extension_init) is used. Use +** of the default name is recommended. +** +** Return SQLITE_OK on success and SQLITE_ERROR if something goes wrong. +** +** If an error occurs and pzErrMsg is not 0, then fill *pzErrMsg with +** error message text. The calling function should free this memory +** by calling sqlite3DbFree(db, ). +*/ +static int sqlite3LoadExtension( + sqlite3 *db, /* Load the extension into this database connection */ + const char *zFile, /* Name of the shared library containing extension */ + const char *zProc, /* Entry point. Use "sqlite3_extension_init" if 0 */ + char **pzErrMsg /* Put error message here if not 0 */ +){ + sqlite3_vfs *pVfs = db->pVfs; + void *handle; + sqlite3_loadext_entry xInit; + char *zErrmsg = 0; + const char *zEntry; + char *zAltEntry = 0; + void **aHandle; + u64 nMsg = strlen(zFile); + int ii; + int rc; + + /* Shared library endings to try if zFile cannot be loaded as written */ + static const char *azEndings[] = { +#if SQLITE_OS_WIN + "dll" +#elif defined(__APPLE__) + "dylib" +#else + "so" +#endif + }; + + + if( pzErrMsg ) *pzErrMsg = 0; + + /* Ticket #1863. To avoid a creating security problems for older + ** applications that relink against newer versions of SQLite, the + ** ability to run load_extension is turned off by default. One + ** must call either sqlite3_enable_load_extension(db) or + ** sqlite3_db_config(db, SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, 1, 0) + ** to turn on extension loading. + */ + if( (db->flags & SQLITE_LoadExtension)==0 ){ + if( pzErrMsg ){ + *pzErrMsg = sqlite3_mprintf("not authorized"); + } + return SQLITE_ERROR; + } + + zEntry = zProc ? zProc : "sqlite3_extension_init"; + + /* tag-20210611-1. Some dlopen() implementations will segfault if given + ** an oversize filename. Most filesystems have a pathname limit of 4K, + ** so limit the extension filename length to about twice that. + ** https://sqlite.org/forum/forumpost/08a0d6d9bf + ** + ** Later (2023-03-25): Save an extra 6 bytes for the filename suffix. + ** See https://sqlite.org/forum/forumpost/24083b579d. + */ + if( nMsg>SQLITE_MAX_PATHLEN ) goto extension_not_found; + + handle = sqlite3OsDlOpen(pVfs, zFile); +#if SQLITE_OS_UNIX || SQLITE_OS_WIN + for(ii=0; ii sqlite3_example_init + ** C:/lib/mathfuncs.dll ==> sqlite3_mathfuncs_init + */ + if( xInit==0 && zProc==0 ){ + int iFile, iEntry, c; + int ncFile = sqlite3Strlen30(zFile); + zAltEntry = sqlite3_malloc64(ncFile+30); + if( zAltEntry==0 ){ + sqlite3OsDlClose(pVfs, handle); + return SQLITE_NOMEM_BKPT; + } + memcpy(zAltEntry, "sqlite3_", 8); + for(iFile=ncFile-1; iFile>=0 && !DirSep(zFile[iFile]); iFile--){} + iFile++; + if( sqlite3_strnicmp(zFile+iFile, "lib", 3)==0 ) iFile += 3; + for(iEntry=8; (c = zFile[iFile])!=0 && c!='.'; iFile++){ + if( sqlite3Isalpha(c) ){ + zAltEntry[iEntry++] = (char)sqlite3UpperToLower[(unsigned)c]; + } + } + memcpy(zAltEntry+iEntry, "_init", 6); + zEntry = zAltEntry; + xInit = (sqlite3_loadext_entry)sqlite3OsDlSym(pVfs, handle, zEntry); + } + if( xInit==0 ){ + if( pzErrMsg ){ + nMsg += strlen(zEntry) + 300; + *pzErrMsg = zErrmsg = sqlite3_malloc64(nMsg); + if( zErrmsg ){ + assert( nMsg<0x7fffffff ); /* zErrmsg would be NULL if not so */ + sqlite3_snprintf((int)nMsg, zErrmsg, + "no entry point [%s] in shared library [%s]", zEntry, zFile); + sqlite3OsDlError(pVfs, nMsg-1, zErrmsg); + } + } + sqlite3OsDlClose(pVfs, handle); + sqlite3_free(zAltEntry); + return SQLITE_ERROR; + } + sqlite3_free(zAltEntry); + rc = xInit(db, &zErrmsg, &sqlite3Apis); + if( rc ){ + if( rc==SQLITE_OK_LOAD_PERMANENTLY ) return SQLITE_OK; + if( pzErrMsg ){ + *pzErrMsg = sqlite3_mprintf("error during initialization: %s", zErrmsg); + } + sqlite3_free(zErrmsg); + sqlite3OsDlClose(pVfs, handle); + return SQLITE_ERROR; + } + + /* Append the new shared library handle to the db->aExtension array. */ + aHandle = sqlite3DbMallocZero(db, sizeof(handle)*(db->nExtension+1)); + if( aHandle==0 ){ + return SQLITE_NOMEM_BKPT; + } + if( db->nExtension>0 ){ + memcpy(aHandle, db->aExtension, sizeof(handle)*db->nExtension); + } + sqlite3DbFree(db, db->aExtension); + db->aExtension = aHandle; + + db->aExtension[db->nExtension++] = handle; + return SQLITE_OK; + +extension_not_found: + if( pzErrMsg ){ + nMsg += 300; + *pzErrMsg = zErrmsg = sqlite3_malloc64(nMsg); + if( zErrmsg ){ + assert( nMsg<0x7fffffff ); /* zErrmsg would be NULL if not so */ + sqlite3_snprintf((int)nMsg, zErrmsg, + "unable to open shared library [%.*s]", SQLITE_MAX_PATHLEN, zFile); + sqlite3OsDlError(pVfs, nMsg-1, zErrmsg); + } + } + return SQLITE_ERROR; +} +SQLITE_API int sqlite3_load_extension( + sqlite3 *db, /* Load the extension into this database connection */ + const char *zFile, /* Name of the shared library containing extension */ + const char *zProc, /* Entry point. Use "sqlite3_extension_init" if 0 */ + char **pzErrMsg /* Put error message here if not 0 */ +){ + int rc; + sqlite3_mutex_enter(db->mutex); + rc = sqlite3LoadExtension(db, zFile, zProc, pzErrMsg); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Call this routine when the database connection is closing in order +** to clean up loaded extensions +*/ +SQLITE_PRIVATE void sqlite3CloseExtensions(sqlite3 *db){ + int i; + assert( sqlite3_mutex_held(db->mutex) ); + for(i=0; inExtension; i++){ + sqlite3OsDlClose(db->pVfs, db->aExtension[i]); + } + sqlite3DbFree(db, db->aExtension); +} + +/* +** Enable or disable extension loading. Extension loading is disabled by +** default so as not to open security holes in older applications. +*/ +SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff){ + sqlite3_mutex_enter(db->mutex); + if( onoff ){ + db->flags |= SQLITE_LoadExtension|SQLITE_LoadExtFunc; + }else{ + db->flags &= ~(u64)(SQLITE_LoadExtension|SQLITE_LoadExtFunc); + } + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +#endif /* !defined(SQLITE_OMIT_LOAD_EXTENSION) */ + +/* +** The following object holds the list of automatically loaded +** extensions. +** +** This list is shared across threads. The SQLITE_MUTEX_STATIC_MAIN +** mutex must be held while accessing this list. +*/ +typedef struct sqlite3AutoExtList sqlite3AutoExtList; +static SQLITE_WSD struct sqlite3AutoExtList { + u32 nExt; /* Number of entries in aExt[] */ + void (**aExt)(void); /* Pointers to the extension init functions */ +} sqlite3Autoext = { 0, 0 }; + +/* The "wsdAutoext" macro will resolve to the autoextension +** state vector. If writable static data is unsupported on the target, +** we have to locate the state vector at run-time. In the more common +** case where writable static data is supported, wsdStat can refer directly +** to the "sqlite3Autoext" state vector declared above. +*/ +#ifdef SQLITE_OMIT_WSD +# define wsdAutoextInit \ + sqlite3AutoExtList *x = &GLOBAL(sqlite3AutoExtList,sqlite3Autoext) +# define wsdAutoext x[0] +#else +# define wsdAutoextInit +# define wsdAutoext sqlite3Autoext +#endif + + +/* +** Register a statically linked extension that is automatically +** loaded by every new database connection. +*/ +SQLITE_API int sqlite3_auto_extension( + void (*xInit)(void) +){ + int rc = SQLITE_OK; +#ifndef SQLITE_OMIT_AUTOINIT + rc = sqlite3_initialize(); + if( rc ){ + return rc; + }else +#endif + { + u32 i; +#if SQLITE_THREADSAFE + sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); +#endif + wsdAutoextInit; + sqlite3_mutex_enter(mutex); + for(i=0; i=0; i--){ + if( wsdAutoext.aExt[i]==xInit ){ + wsdAutoext.nExt--; + wsdAutoext.aExt[i] = wsdAutoext.aExt[wsdAutoext.nExt]; + n++; + break; + } + } + sqlite3_mutex_leave(mutex); + return n; +} + +/* +** Reset the automatic extension loading mechanism. +*/ +SQLITE_API void sqlite3_reset_auto_extension(void){ +#ifndef SQLITE_OMIT_AUTOINIT + if( sqlite3_initialize()==SQLITE_OK ) +#endif + { +#if SQLITE_THREADSAFE + sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); +#endif + wsdAutoextInit; + sqlite3_mutex_enter(mutex); + sqlite3_free(wsdAutoext.aExt); + wsdAutoext.aExt = 0; + wsdAutoext.nExt = 0; + sqlite3_mutex_leave(mutex); + } +} + +/* +** Load all automatic extensions. +** +** If anything goes wrong, set an error in the database connection. +*/ +SQLITE_PRIVATE void sqlite3AutoLoadExtensions(sqlite3 *db){ + u32 i; + int go = 1; + int rc; + sqlite3_loadext_entry xInit; + + wsdAutoextInit; + if( wsdAutoext.nExt==0 ){ + /* Common case: early out without every having to acquire a mutex */ + return; + } + for(i=0; go; i++){ + char *zErrmsg; +#if SQLITE_THREADSAFE + sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); +#endif +#ifdef SQLITE_OMIT_LOAD_EXTENSION + const sqlite3_api_routines *pThunk = 0; +#else + const sqlite3_api_routines *pThunk = &sqlite3Apis; +#endif + sqlite3_mutex_enter(mutex); + if( i>=wsdAutoext.nExt ){ + xInit = 0; + go = 0; + }else{ + xInit = (sqlite3_loadext_entry)wsdAutoext.aExt[i]; + } + sqlite3_mutex_leave(mutex); + zErrmsg = 0; + if( xInit && (rc = xInit(db, &zErrmsg, pThunk))!=0 ){ + sqlite3ErrorWithMsg(db, rc, + "automatic extension loading failed: %s", zErrmsg); + go = 0; + } + sqlite3_free(zErrmsg); + } +} + +/************** End of loadext.c *********************************************/ +/************** Begin file pragma.c ******************************************/ +/* +** 2003 April 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to implement the PRAGMA command. +*/ +/* #include "sqliteInt.h" */ + +#if !defined(SQLITE_ENABLE_LOCKING_STYLE) +# if defined(__APPLE__) +# define SQLITE_ENABLE_LOCKING_STYLE 1 +# else +# define SQLITE_ENABLE_LOCKING_STYLE 0 +# endif +#endif + +/*************************************************************************** +** The "pragma.h" include file is an automatically generated file that +** that includes the PragType_XXXX macro definitions and the aPragmaName[] +** object. This ensures that the aPragmaName[] table is arranged in +** lexicographical order to facility a binary search of the pragma name. +** Do not edit pragma.h directly. Edit and rerun the script in at +** ../tool/mkpragmatab.tcl. */ +/************** Include pragma.h in the middle of pragma.c *******************/ +/************** Begin file pragma.h ******************************************/ +/* DO NOT EDIT! +** This file is automatically generated by the script at +** ../tool/mkpragmatab.tcl. To update the set of pragmas, edit +** that script and rerun it. +*/ + +/* The various pragma types */ +#define PragTyp_KEY 255 +#define PragTyp_ACTIVATE_EXTENSIONS 0 +#define PragTyp_ANALYSIS_LIMIT 1 +#define PragTyp_HEADER_VALUE 2 +#define PragTyp_AUTO_VACUUM 3 +#define PragTyp_FLAG 4 +#define PragTyp_BUSY_TIMEOUT 5 +#define PragTyp_CACHE_SIZE 6 +#define PragTyp_CACHE_SPILL 7 +#define PragTyp_CASE_SENSITIVE_LIKE 8 +#define PragTyp_COLLATION_LIST 9 +#define PragTyp_COMPILE_OPTIONS 10 +#define PragTyp_DATA_STORE_DIRECTORY 11 +#define PragTyp_DATABASE_LIST 12 +#define PragTyp_DEFAULT_CACHE_SIZE 13 +#define PragTyp_ENCODING 14 +#define PragTyp_FOREIGN_KEY_CHECK 15 +#define PragTyp_FOREIGN_KEY_LIST 16 +#define PragTyp_FUNCTION_LIST 17 +#define PragTyp_HARD_HEAP_LIMIT 18 +#define PragTyp_INCREMENTAL_VACUUM 19 +#define PragTyp_INDEX_INFO 20 +#define PragTyp_INDEX_LIST 21 +#define PragTyp_INTEGRITY_CHECK 22 +#define PragTyp_JOURNAL_MODE 23 +#define PragTyp_JOURNAL_SIZE_LIMIT 24 +#define PragTyp_LOCK_PROXY_FILE 25 +#define PragTyp_LOCKING_MODE 26 +#define PragTyp_PAGE_COUNT 27 +#define PragTyp_MMAP_SIZE 28 +#define PragTyp_MODULE_LIST 29 +#define PragTyp_OPTIMIZE 30 +#define PragTyp_PAGE_SIZE 31 +#define PragTyp_PRAGMA_LIST 32 +#define PragTyp_SECURE_DELETE 33 +#define PragTyp_SHRINK_MEMORY 34 +#define PragTyp_SOFT_HEAP_LIMIT 35 +#define PragTyp_SYNCHRONOUS 36 +#define PragTyp_TABLE_INFO 37 +#define PragTyp_TABLE_LIST 38 +#define PragTyp_TEMP_STORE 39 +#define PragTyp_TEMP_STORE_DIRECTORY 40 +#define PragTyp_THREADS 41 +#define PragTyp_WAL_AUTOCHECKPOINT 42 +#define PragTyp_WAL_CHECKPOINT 43 +#define PragTyp_LOCK_STATUS 44 +#define PragTyp_STATS 45 + +/* Property flags associated with various pragma. */ +#define PragFlg_NeedSchema 0x01 /* Force schema load before running */ +#define PragFlg_NoColumns 0x02 /* OP_ResultRow called with zero columns */ +#define PragFlg_NoColumns1 0x04 /* zero columns if RHS argument is present */ +#define PragFlg_ReadOnly 0x08 /* Read-only HEADER_VALUE */ +#define PragFlg_Result0 0x10 /* Acts as query when no argument */ +#define PragFlg_Result1 0x20 /* Acts as query when has one argument */ +#define PragFlg_SchemaOpt 0x40 /* Schema restricts name search if present */ +#define PragFlg_SchemaReq 0x80 /* Schema required - "main" is default */ + +/* Names of columns for pragmas that return multi-column result +** or that return single-column results where the name of the +** result column is different from the name of the pragma +*/ +static const char *const pragCName[] = { + /* 0 */ "id", /* Used by: foreign_key_list */ + /* 1 */ "seq", + /* 2 */ "table", + /* 3 */ "from", + /* 4 */ "to", + /* 5 */ "on_update", + /* 6 */ "on_delete", + /* 7 */ "match", + /* 8 */ "cid", /* Used by: table_xinfo */ + /* 9 */ "name", + /* 10 */ "type", + /* 11 */ "notnull", + /* 12 */ "dflt_value", + /* 13 */ "pk", + /* 14 */ "hidden", + /* table_info reuses 8 */ + /* 15 */ "schema", /* Used by: table_list */ + /* 16 */ "name", + /* 17 */ "type", + /* 18 */ "ncol", + /* 19 */ "wr", + /* 20 */ "strict", + /* 21 */ "seqno", /* Used by: index_xinfo */ + /* 22 */ "cid", + /* 23 */ "name", + /* 24 */ "desc", + /* 25 */ "coll", + /* 26 */ "key", + /* 27 */ "name", /* Used by: function_list */ + /* 28 */ "builtin", + /* 29 */ "type", + /* 30 */ "enc", + /* 31 */ "narg", + /* 32 */ "flags", + /* 33 */ "tbl", /* Used by: stats */ + /* 34 */ "idx", + /* 35 */ "wdth", + /* 36 */ "hght", + /* 37 */ "flgs", + /* 38 */ "seq", /* Used by: index_list */ + /* 39 */ "name", + /* 40 */ "unique", + /* 41 */ "origin", + /* 42 */ "partial", + /* 43 */ "table", /* Used by: foreign_key_check */ + /* 44 */ "rowid", + /* 45 */ "parent", + /* 46 */ "fkid", + /* index_info reuses 21 */ + /* 47 */ "seq", /* Used by: database_list */ + /* 48 */ "name", + /* 49 */ "file", + /* 50 */ "busy", /* Used by: wal_checkpoint */ + /* 51 */ "log", + /* 52 */ "checkpointed", + /* collation_list reuses 38 */ + /* 53 */ "database", /* Used by: lock_status */ + /* 54 */ "status", + /* 55 */ "cache_size", /* Used by: default_cache_size */ + /* module_list pragma_list reuses 9 */ + /* 56 */ "timeout", /* Used by: busy_timeout */ +}; + +/* Definitions of all built-in pragmas */ +typedef struct PragmaName { + const char *const zName; /* Name of pragma */ + u8 ePragTyp; /* PragTyp_XXX value */ + u8 mPragFlg; /* Zero or more PragFlg_XXX values */ + u8 iPragCName; /* Start of column names in pragCName[] */ + u8 nPragCName; /* Num of col names. 0 means use pragma name */ + u64 iArg; /* Extra argument */ +} PragmaName; +static const PragmaName aPragmaName[] = { +#if defined(SQLITE_ENABLE_CEROD) + {/* zName: */ "activate_extensions", + /* ePragTyp: */ PragTyp_ACTIVATE_EXTENSIONS, + /* ePragFlg: */ 0, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif + {/* zName: */ "analysis_limit", + /* ePragTyp: */ PragTyp_ANALYSIS_LIMIT, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS) + {/* zName: */ "application_id", + /* ePragTyp: */ PragTyp_HEADER_VALUE, + /* ePragFlg: */ PragFlg_NoColumns1|PragFlg_Result0, + /* ColNames: */ 0, 0, + /* iArg: */ BTREE_APPLICATION_ID }, +#endif +#if !defined(SQLITE_OMIT_AUTOVACUUM) + {/* zName: */ "auto_vacuum", + /* ePragTyp: */ PragTyp_AUTO_VACUUM, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) +#if !defined(SQLITE_OMIT_AUTOMATIC_INDEX) + {/* zName: */ "automatic_index", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_AutoIndex }, +#endif +#endif + {/* zName: */ "busy_timeout", + /* ePragTyp: */ PragTyp_BUSY_TIMEOUT, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 56, 1, + /* iArg: */ 0 }, +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) + {/* zName: */ "cache_size", + /* ePragTyp: */ PragTyp_CACHE_SIZE, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + {/* zName: */ "cache_spill", + /* ePragTyp: */ PragTyp_CACHE_SPILL, + /* ePragFlg: */ PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_CASE_SENSITIVE_LIKE_PRAGMA) + {/* zName: */ "case_sensitive_like", + /* ePragTyp: */ PragTyp_CASE_SENSITIVE_LIKE, + /* ePragFlg: */ PragFlg_NoColumns, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif + {/* zName: */ "cell_size_check", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_CellSizeCk }, +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + {/* zName: */ "checkpoint_fullfsync", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_CkptFullFSync }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) + {/* zName: */ "collation_list", + /* ePragTyp: */ PragTyp_COLLATION_LIST, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 38, 2, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_COMPILEOPTION_DIAGS) + {/* zName: */ "compile_options", + /* ePragTyp: */ PragTyp_COMPILE_OPTIONS, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + {/* zName: */ "count_changes", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_CountRows }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && SQLITE_OS_WIN + {/* zName: */ "data_store_directory", + /* ePragTyp: */ PragTyp_DATA_STORE_DIRECTORY, + /* ePragFlg: */ PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS) + {/* zName: */ "data_version", + /* ePragTyp: */ PragTyp_HEADER_VALUE, + /* ePragFlg: */ PragFlg_ReadOnly|PragFlg_Result0, + /* ColNames: */ 0, 0, + /* iArg: */ BTREE_DATA_VERSION }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) + {/* zName: */ "database_list", + /* ePragTyp: */ PragTyp_DATABASE_LIST, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 47, 3, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED) + {/* zName: */ "default_cache_size", + /* ePragTyp: */ PragTyp_DEFAULT_CACHE_SIZE, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1, + /* ColNames: */ 55, 1, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) +#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER) + {/* zName: */ "defer_foreign_keys", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_DeferFKs }, +#endif +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + {/* zName: */ "empty_result_callbacks", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_NullCallback }, +#endif +#if !defined(SQLITE_OMIT_UTF16) + {/* zName: */ "encoding", + /* ePragTyp: */ PragTyp_ENCODING, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER) + {/* zName: */ "foreign_key_check", + /* ePragTyp: */ PragTyp_FOREIGN_KEY_CHECK, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_Result1|PragFlg_SchemaOpt, + /* ColNames: */ 43, 4, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FOREIGN_KEY) + {/* zName: */ "foreign_key_list", + /* ePragTyp: */ PragTyp_FOREIGN_KEY_LIST, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt, + /* ColNames: */ 0, 8, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) +#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER) + {/* zName: */ "foreign_keys", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_ForeignKeys }, +#endif +#endif +#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS) + {/* zName: */ "freelist_count", + /* ePragTyp: */ PragTyp_HEADER_VALUE, + /* ePragFlg: */ PragFlg_ReadOnly|PragFlg_Result0, + /* ColNames: */ 0, 0, + /* iArg: */ BTREE_FREE_PAGE_COUNT }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + {/* zName: */ "full_column_names", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_FullColNames }, + {/* zName: */ "fullfsync", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_FullFSync }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) +#if !defined(SQLITE_OMIT_INTROSPECTION_PRAGMAS) + {/* zName: */ "function_list", + /* ePragTyp: */ PragTyp_FUNCTION_LIST, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 27, 6, + /* iArg: */ 0 }, +#endif +#endif + {/* zName: */ "hard_heap_limit", + /* ePragTyp: */ PragTyp_HARD_HEAP_LIMIT, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +/* BEGIN SQLCIPHER */ +#if defined(SQLITE_HAS_CODEC) + {/* zName: */ "hexkey", + /* ePragTyp: */ PragTyp_KEY, + /* ePragFlg: */ 0, + /* ColNames: */ 0, 0, + /* iArg: */ 2 }, + {/* zName: */ "hexrekey", + /* ePragTyp: */ PragTyp_KEY, + /* ePragFlg: */ 0, + /* ColNames: */ 0, 0, + /* iArg: */ 3 }, +#endif +/* END SQLCIPHER */ +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) +#if !defined(SQLITE_OMIT_CHECK) + {/* zName: */ "ignore_check_constraints", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_IgnoreChecks }, +#endif +#endif +#if !defined(SQLITE_OMIT_AUTOVACUUM) + {/* zName: */ "incremental_vacuum", + /* ePragTyp: */ PragTyp_INCREMENTAL_VACUUM, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_NoColumns, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) + {/* zName: */ "index_info", + /* ePragTyp: */ PragTyp_INDEX_INFO, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt, + /* ColNames: */ 21, 3, + /* iArg: */ 0 }, + {/* zName: */ "index_list", + /* ePragTyp: */ PragTyp_INDEX_LIST, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt, + /* ColNames: */ 38, 5, + /* iArg: */ 0 }, + {/* zName: */ "index_xinfo", + /* ePragTyp: */ PragTyp_INDEX_INFO, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt, + /* ColNames: */ 21, 6, + /* iArg: */ 1 }, +#endif +#if !defined(SQLITE_OMIT_INTEGRITY_CHECK) + {/* zName: */ "integrity_check", + /* ePragTyp: */ PragTyp_INTEGRITY_CHECK, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_Result1|PragFlg_SchemaOpt, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) + {/* zName: */ "journal_mode", + /* ePragTyp: */ PragTyp_JOURNAL_MODE, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, + {/* zName: */ "journal_size_limit", + /* ePragTyp: */ PragTyp_JOURNAL_SIZE_LIMIT, + /* ePragFlg: */ PragFlg_Result0|PragFlg_SchemaReq, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +/* BEGIN SQLCIPHER */ +#if defined(SQLITE_HAS_CODEC) + {/* zName: */ "key", + /* ePragTyp: */ PragTyp_KEY, + /* ePragFlg: */ 0, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +/* END SQLCIPHER */ +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + {/* zName: */ "legacy_alter_table", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_LegacyAlter }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && SQLITE_ENABLE_LOCKING_STYLE + {/* zName: */ "lock_proxy_file", + /* ePragTyp: */ PragTyp_LOCK_PROXY_FILE, + /* ePragFlg: */ PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + {/* zName: */ "lock_status", + /* ePragTyp: */ PragTyp_LOCK_STATUS, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 53, 2, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) + {/* zName: */ "locking_mode", + /* ePragTyp: */ PragTyp_LOCKING_MODE, + /* ePragFlg: */ PragFlg_Result0|PragFlg_SchemaReq, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, + {/* zName: */ "max_page_count", + /* ePragTyp: */ PragTyp_PAGE_COUNT, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, + {/* zName: */ "mmap_size", + /* ePragTyp: */ PragTyp_MMAP_SIZE, + /* ePragFlg: */ 0, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) +#if !defined(SQLITE_OMIT_VIRTUALTABLE) +#if !defined(SQLITE_OMIT_INTROSPECTION_PRAGMAS) + {/* zName: */ "module_list", + /* ePragTyp: */ PragTyp_MODULE_LIST, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 9, 1, + /* iArg: */ 0 }, +#endif +#endif +#endif + {/* zName: */ "optimize", + /* ePragTyp: */ PragTyp_OPTIMIZE, + /* ePragFlg: */ PragFlg_Result1|PragFlg_NeedSchema, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) + {/* zName: */ "page_count", + /* ePragTyp: */ PragTyp_PAGE_COUNT, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, + {/* zName: */ "page_size", + /* ePragTyp: */ PragTyp_PAGE_SIZE, + /* ePragFlg: */ PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) +#if defined(SQLITE_DEBUG) + {/* zName: */ "parser_trace", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_ParserTrace }, +#endif +#endif +#if !defined(SQLITE_OMIT_INTROSPECTION_PRAGMAS) + {/* zName: */ "pragma_list", + /* ePragTyp: */ PragTyp_PRAGMA_LIST, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 9, 1, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + {/* zName: */ "query_only", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_QueryOnly }, +#endif +#if !defined(SQLITE_OMIT_INTEGRITY_CHECK) + {/* zName: */ "quick_check", + /* ePragTyp: */ PragTyp_INTEGRITY_CHECK, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_Result1|PragFlg_SchemaOpt, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + {/* zName: */ "read_uncommitted", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_ReadUncommit }, + {/* zName: */ "recursive_triggers", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_RecTriggers }, +#endif +/* BEGIN SQLCIPHER */ +#if defined(SQLITE_HAS_CODEC) + {/* zName: */ "rekey", + /* ePragTyp: */ PragTyp_KEY, + /* ePragFlg: */ 0, + /* ColNames: */ 0, 0, + /* iArg: */ 1 }, +#endif +/* END SQLCIPHER */ +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + {/* zName: */ "reverse_unordered_selects", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_ReverseOrder }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS) + {/* zName: */ "schema_version", + /* ePragTyp: */ PragTyp_HEADER_VALUE, + /* ePragFlg: */ PragFlg_NoColumns1|PragFlg_Result0, + /* ColNames: */ 0, 0, + /* iArg: */ BTREE_SCHEMA_VERSION }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) + {/* zName: */ "secure_delete", + /* ePragTyp: */ PragTyp_SECURE_DELETE, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + {/* zName: */ "short_column_names", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_ShortColNames }, +#endif + {/* zName: */ "shrink_memory", + /* ePragTyp: */ PragTyp_SHRINK_MEMORY, + /* ePragFlg: */ PragFlg_NoColumns, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, + {/* zName: */ "soft_heap_limit", + /* ePragTyp: */ PragTyp_SOFT_HEAP_LIMIT, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) +#if defined(SQLITE_DEBUG) + {/* zName: */ "sql_trace", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_SqlTrace }, +#endif +#endif +#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) && defined(SQLITE_DEBUG) + {/* zName: */ "stats", + /* ePragTyp: */ PragTyp_STATS, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq, + /* ColNames: */ 33, 5, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) + {/* zName: */ "synchronous", + /* ePragTyp: */ PragTyp_SYNCHRONOUS, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result0|PragFlg_SchemaReq|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS) + {/* zName: */ "table_info", + /* ePragTyp: */ PragTyp_TABLE_INFO, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt, + /* ColNames: */ 8, 6, + /* iArg: */ 0 }, + {/* zName: */ "table_list", + /* ePragTyp: */ PragTyp_TABLE_LIST, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result1, + /* ColNames: */ 15, 6, + /* iArg: */ 0 }, + {/* zName: */ "table_xinfo", + /* ePragTyp: */ PragTyp_TABLE_INFO, + /* ePragFlg: */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt, + /* ColNames: */ 8, 7, + /* iArg: */ 1 }, +#endif +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) + {/* zName: */ "temp_store", + /* ePragTyp: */ PragTyp_TEMP_STORE, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, + {/* zName: */ "temp_store_directory", + /* ePragTyp: */ PragTyp_TEMP_STORE_DIRECTORY, + /* ePragFlg: */ PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#endif +/* BEGIN SQLCIPHER */ +#if defined(SQLITE_HAS_CODEC) + {/* zName: */ "textkey", + /* ePragTyp: */ PragTyp_KEY, + /* ePragFlg: */ 0, + /* ColNames: */ 0, 0, + /* iArg: */ 4 }, + {/* zName: */ "textrekey", + /* ePragTyp: */ PragTyp_KEY, + /* ePragFlg: */ 0, + /* ColNames: */ 0, 0, + /* iArg: */ 5 }, +#endif +/* END SQLCIPHER */ + {/* zName: */ "threads", + /* ePragTyp: */ PragTyp_THREADS, + /* ePragFlg: */ PragFlg_Result0, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + {/* zName: */ "trusted_schema", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_TrustedSchema }, +#endif +#if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS) + {/* zName: */ "user_version", + /* ePragTyp: */ PragTyp_HEADER_VALUE, + /* ePragFlg: */ PragFlg_NoColumns1|PragFlg_Result0, + /* ColNames: */ 0, 0, + /* iArg: */ BTREE_USER_VERSION }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) +#if defined(SQLITE_DEBUG) + {/* zName: */ "vdbe_addoptrace", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_VdbeAddopTrace }, + {/* zName: */ "vdbe_debug", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_SqlTrace|SQLITE_VdbeListing|SQLITE_VdbeTrace }, + {/* zName: */ "vdbe_eqp", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_VdbeEQP }, + {/* zName: */ "vdbe_listing", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_VdbeListing }, + {/* zName: */ "vdbe_trace", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_VdbeTrace }, +#endif +#endif +#if !defined(SQLITE_OMIT_WAL) + {/* zName: */ "wal_autocheckpoint", + /* ePragTyp: */ PragTyp_WAL_AUTOCHECKPOINT, + /* ePragFlg: */ 0, + /* ColNames: */ 0, 0, + /* iArg: */ 0 }, + {/* zName: */ "wal_checkpoint", + /* ePragTyp: */ PragTyp_WAL_CHECKPOINT, + /* ePragFlg: */ PragFlg_NeedSchema, + /* ColNames: */ 50, 3, + /* iArg: */ 0 }, +#endif +#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) + {/* zName: */ "writable_schema", + /* ePragTyp: */ PragTyp_FLAG, + /* ePragFlg: */ PragFlg_Result0|PragFlg_NoColumns1, + /* ColNames: */ 0, 0, + /* iArg: */ SQLITE_WriteSchema|SQLITE_NoSchemaError }, +#endif +}; +/* Number of pragmas: 68 on by default, 78 total. */ + +/************** End of pragma.h **********************************************/ +/************** Continuing where we left off in pragma.c *********************/ + +/* +** Interpret the given string as a safety level. Return 0 for OFF, +** 1 for ON or NORMAL, 2 for FULL, and 3 for EXTRA. Return 1 for an empty or +** unrecognized string argument. The FULL and EXTRA option is disallowed +** if the omitFull parameter it 1. +** +** Note that the values returned are one less that the values that +** should be passed into sqlite3BtreeSetSafetyLevel(). The is done +** to support legacy SQL code. The safety level used to be boolean +** and older scripts may have used numbers 0 for OFF and 1 for ON. +*/ +static u8 getSafetyLevel(const char *z, int omitFull, u8 dflt){ + /* 123456789 123456789 123 */ + static const char zText[] = "onoffalseyestruextrafull"; + static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 15, 20}; + static const u8 iLength[] = {2, 2, 3, 5, 3, 4, 5, 4}; + static const u8 iValue[] = {1, 0, 0, 0, 1, 1, 3, 2}; + /* on no off false yes true extra full */ + int i, n; + if( sqlite3Isdigit(*z) ){ + return (u8)sqlite3Atoi(z); + } + n = sqlite3Strlen30(z); + for(i=0; i=0&&i<=2)?i:0); +} +#endif /* ifndef SQLITE_OMIT_AUTOVACUUM */ + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +/* +** Interpret the given string as a temp db location. Return 1 for file +** backed temporary databases, 2 for the Red-Black tree in memory database +** and 0 to use the compile-time default. +*/ +static int getTempStore(const char *z){ + if( z[0]>='0' && z[0]<='2' ){ + return z[0] - '0'; + }else if( sqlite3StrICmp(z, "file")==0 ){ + return 1; + }else if( sqlite3StrICmp(z, "memory")==0 ){ + return 2; + }else{ + return 0; + } +} +#endif /* SQLITE_PAGER_PRAGMAS */ + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +/* +** Invalidate temp storage, either when the temp storage is changed +** from default, or when 'file' and the temp_store_directory has changed +*/ +static int invalidateTempStorage(Parse *pParse){ + sqlite3 *db = pParse->db; + if( db->aDb[1].pBt!=0 ){ + if( !db->autoCommit + || sqlite3BtreeTxnState(db->aDb[1].pBt)!=SQLITE_TXN_NONE + ){ + sqlite3ErrorMsg(pParse, "temporary storage cannot be changed " + "from within a transaction"); + return SQLITE_ERROR; + } + sqlite3BtreeClose(db->aDb[1].pBt); + db->aDb[1].pBt = 0; + sqlite3ResetAllSchemasOfConnection(db); + } + return SQLITE_OK; +} +#endif /* SQLITE_PAGER_PRAGMAS */ + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +/* +** If the TEMP database is open, close it and mark the database schema +** as needing reloading. This must be done when using the SQLITE_TEMP_STORE +** or DEFAULT_TEMP_STORE pragmas. +*/ +static int changeTempStorage(Parse *pParse, const char *zStorageType){ + int ts = getTempStore(zStorageType); + sqlite3 *db = pParse->db; + if( db->temp_store==ts ) return SQLITE_OK; + if( invalidateTempStorage( pParse ) != SQLITE_OK ){ + return SQLITE_ERROR; + } + db->temp_store = (u8)ts; + return SQLITE_OK; +} +#endif /* SQLITE_PAGER_PRAGMAS */ + +/* +** Set result column names for a pragma. +*/ +static void setPragmaResultColumnNames( + Vdbe *v, /* The query under construction */ + const PragmaName *pPragma /* The pragma */ +){ + u8 n = pPragma->nPragCName; + sqlite3VdbeSetNumCols(v, n==0 ? 1 : n); + if( n==0 ){ + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, pPragma->zName, SQLITE_STATIC); + }else{ + int i, j; + for(i=0, j=pPragma->iPragCName; iautoCommit ){ + Db *pDb = db->aDb; + int n = db->nDb; + assert( SQLITE_FullFSync==PAGER_FULLFSYNC ); + assert( SQLITE_CkptFullFSync==PAGER_CKPT_FULLFSYNC ); + assert( SQLITE_CacheSpill==PAGER_CACHESPILL ); + assert( (PAGER_FULLFSYNC | PAGER_CKPT_FULLFSYNC | PAGER_CACHESPILL) + == PAGER_FLAGS_MASK ); + assert( (pDb->safety_level & PAGER_SYNCHRONOUS_MASK)==pDb->safety_level ); + while( (n--) > 0 ){ + if( pDb->pBt ){ + sqlite3BtreeSetPagerFlags(pDb->pBt, + pDb->safety_level | (db->flags & PAGER_FLAGS_MASK) ); + } + pDb++; + } + } +} +#else +# define setAllPagerFlags(X) /* no-op */ +#endif + + +/* +** Return a human-readable name for a constraint resolution action. +*/ +#ifndef SQLITE_OMIT_FOREIGN_KEY +static const char *actionName(u8 action){ + const char *zName; + switch( action ){ + case OE_SetNull: zName = "SET NULL"; break; + case OE_SetDflt: zName = "SET DEFAULT"; break; + case OE_Cascade: zName = "CASCADE"; break; + case OE_Restrict: zName = "RESTRICT"; break; + default: zName = "NO ACTION"; + assert( action==OE_None ); break; + } + return zName; +} +#endif + + +/* +** Parameter eMode must be one of the PAGER_JOURNALMODE_XXX constants +** defined in pager.h. This function returns the associated lowercase +** journal-mode name. +*/ +SQLITE_PRIVATE const char *sqlite3JournalModename(int eMode){ + static char * const azModeName[] = { + "delete", "persist", "off", "truncate", "memory" +#ifndef SQLITE_OMIT_WAL + , "wal" +#endif + }; + assert( PAGER_JOURNALMODE_DELETE==0 ); + assert( PAGER_JOURNALMODE_PERSIST==1 ); + assert( PAGER_JOURNALMODE_OFF==2 ); + assert( PAGER_JOURNALMODE_TRUNCATE==3 ); + assert( PAGER_JOURNALMODE_MEMORY==4 ); + assert( PAGER_JOURNALMODE_WAL==5 ); + assert( eMode>=0 && eMode<=ArraySize(azModeName) ); + + if( eMode==ArraySize(azModeName) ) return 0; + return azModeName[eMode]; +} + +/* +** Locate a pragma in the aPragmaName[] array. +*/ +static const PragmaName *pragmaLocate(const char *zName){ + int upr, lwr, mid = 0, rc; + lwr = 0; + upr = ArraySize(aPragmaName)-1; + while( lwr<=upr ){ + mid = (lwr+upr)/2; + rc = sqlite3_stricmp(zName, aPragmaName[mid].zName); + if( rc==0 ) break; + if( rc<0 ){ + upr = mid - 1; + }else{ + lwr = mid + 1; + } + } + return lwr>upr ? 0 : &aPragmaName[mid]; +} + +/* +** Create zero or more entries in the output for the SQL functions +** defined by FuncDef p. +*/ +static void pragmaFunclistLine( + Vdbe *v, /* The prepared statement being created */ + FuncDef *p, /* A particular function definition */ + int isBuiltin, /* True if this is a built-in function */ + int showInternFuncs /* True if showing internal functions */ +){ + u32 mask = + SQLITE_DETERMINISTIC | + SQLITE_DIRECTONLY | + SQLITE_SUBTYPE | + SQLITE_INNOCUOUS | + SQLITE_FUNC_INTERNAL + ; + if( showInternFuncs ) mask = 0xffffffff; + for(; p; p=p->pNext){ + const char *zType; + static const char *azEnc[] = { 0, "utf8", "utf16le", "utf16be" }; + + assert( SQLITE_FUNC_ENCMASK==0x3 ); + assert( strcmp(azEnc[SQLITE_UTF8],"utf8")==0 ); + assert( strcmp(azEnc[SQLITE_UTF16LE],"utf16le")==0 ); + assert( strcmp(azEnc[SQLITE_UTF16BE],"utf16be")==0 ); + + if( p->xSFunc==0 ) continue; + if( (p->funcFlags & SQLITE_FUNC_INTERNAL)!=0 + && showInternFuncs==0 + ){ + continue; + } + if( p->xValue!=0 ){ + zType = "w"; + }else if( p->xFinalize!=0 ){ + zType = "a"; + }else{ + zType = "s"; + } + sqlite3VdbeMultiLoad(v, 1, "sissii", + p->zName, isBuiltin, + zType, azEnc[p->funcFlags&SQLITE_FUNC_ENCMASK], + p->nArg, + (p->funcFlags & mask) ^ SQLITE_INNOCUOUS + ); + } +} + + +/* +** Helper subroutine for PRAGMA integrity_check: +** +** Generate code to output a single-column result row with a value of the +** string held in register 3. Decrement the result count in register 1 +** and halt if the maximum number of result rows have been issued. +*/ +static int integrityCheckResultRow(Vdbe *v){ + int addr; + sqlite3VdbeAddOp2(v, OP_ResultRow, 3, 1); + addr = sqlite3VdbeAddOp3(v, OP_IfPos, 1, sqlite3VdbeCurrentAddr(v)+2, 1); + VdbeCoverage(v); + sqlite3VdbeAddOp0(v, OP_Halt); + return addr; +} + +/* +** Process a pragma statement. +** +** Pragmas are of this form: +** +** PRAGMA [schema.]id [= value] +** +** The identifier might also be a string. The value is a string, and +** identifier, or a number. If minusFlag is true, then the value is +** a number that was preceded by a minus sign. +** +** If the left side is "database.id" then pId1 is the database name +** and pId2 is the id. If the left side is just "id" then pId1 is the +** id and pId2 is any empty string. +*/ +SQLITE_PRIVATE void sqlite3Pragma( + Parse *pParse, + Token *pId1, /* First part of [schema.]id field */ + Token *pId2, /* Second part of [schema.]id field, or NULL */ + Token *pValue, /* Token for , or NULL */ + int minusFlag /* True if a '-' sign preceded */ +){ + char *zLeft = 0; /* Nul-terminated UTF-8 string */ + char *zRight = 0; /* Nul-terminated UTF-8 string , or NULL */ + const char *zDb = 0; /* The database name */ + Token *pId; /* Pointer to token */ + char *aFcntl[4]; /* Argument to SQLITE_FCNTL_PRAGMA */ + int iDb; /* Database index for */ + int rc; /* return value form SQLITE_FCNTL_PRAGMA */ + sqlite3 *db = pParse->db; /* The database connection */ + Db *pDb; /* The specific database being pragmaed */ + Vdbe *v = sqlite3GetVdbe(pParse); /* Prepared statement */ + const PragmaName *pPragma; /* The pragma */ +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC + extern int sqlcipher_codec_pragma(sqlite3*, int, Parse *, const char *, const char *); +#endif +/* END SQLCIPHER */ + + if( v==0 ) return; + sqlite3VdbeRunOnlyOnce(v); + pParse->nMem = 2; + + /* Interpret the [schema.] part of the pragma statement. iDb is the + ** index of the database this pragma is being applied to in db.aDb[]. */ + iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId); + if( iDb<0 ) return; + pDb = &db->aDb[iDb]; + + /* If the temp database has been explicitly named as part of the + ** pragma, make sure it is open. + */ + if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){ + return; + } + + zLeft = sqlite3NameFromToken(db, pId); + if( !zLeft ) return; + if( minusFlag ){ + zRight = sqlite3MPrintf(db, "-%T", pValue); + }else{ + zRight = sqlite3NameFromToken(db, pValue); + } + + assert( pId2 ); + zDb = pId2->n>0 ? pDb->zDbSName : 0; + if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){ + goto pragma_out; + } + + /* Send an SQLITE_FCNTL_PRAGMA file-control to the underlying VFS + ** connection. If it returns SQLITE_OK, then assume that the VFS + ** handled the pragma and generate a no-op prepared statement. + ** + ** IMPLEMENTATION-OF: R-12238-55120 Whenever a PRAGMA statement is parsed, + ** an SQLITE_FCNTL_PRAGMA file control is sent to the open sqlite3_file + ** object corresponding to the database file to which the pragma + ** statement refers. + ** + ** IMPLEMENTATION-OF: R-29875-31678 The argument to the SQLITE_FCNTL_PRAGMA + ** file control is an array of pointers to strings (char**) in which the + ** second element of the array is the name of the pragma and the third + ** element is the argument to the pragma or NULL if the pragma has no + ** argument. + */ + aFcntl[0] = 0; + aFcntl[1] = zLeft; + aFcntl[2] = zRight; + aFcntl[3] = 0; + db->busyHandler.nBusy = 0; + rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_PRAGMA, (void*)aFcntl); + if( rc==SQLITE_OK ){ + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, aFcntl[0], SQLITE_TRANSIENT); + returnSingleText(v, aFcntl[0]); + sqlite3_free(aFcntl[0]); + goto pragma_out; + } + if( rc!=SQLITE_NOTFOUND ){ + if( aFcntl[0] ){ + sqlite3ErrorMsg(pParse, "%s", aFcntl[0]); + sqlite3_free(aFcntl[0]); + } + pParse->nErr++; + pParse->rc = rc; + + goto pragma_out; + } + +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC + if(sqlcipher_codec_pragma(db, iDb, pParse, zLeft, zRight)) { + /* sqlcipher_codec_pragma executes internal */ + goto pragma_out; + } +#endif +/* END SQLCIPHER */ + + /* Locate the pragma in the lookup table */ + pPragma = pragmaLocate(zLeft); + if( pPragma==0 ){ + /* IMP: R-43042-22504 No error messages are generated if an + ** unknown pragma is issued. */ + goto pragma_out; + } + + /* Make sure the database schema is loaded if the pragma requires that */ + if( (pPragma->mPragFlg & PragFlg_NeedSchema)!=0 ){ + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + } + + /* Register the result column names for pragmas that return results */ + if( (pPragma->mPragFlg & PragFlg_NoColumns)==0 + && ((pPragma->mPragFlg & PragFlg_NoColumns1)==0 || zRight==0) + ){ + setPragmaResultColumnNames(v, pPragma); + } + + /* Jump to the appropriate pragma handler */ + switch( pPragma->ePragTyp ){ + +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED) + /* + ** PRAGMA [schema.]default_cache_size + ** PRAGMA [schema.]default_cache_size=N + ** + ** The first form reports the current persistent setting for the + ** page cache size. The value returned is the maximum number of + ** pages in the page cache. The second form sets both the current + ** page cache size value and the persistent page cache size value + ** stored in the database file. + ** + ** Older versions of SQLite would set the default cache size to a + ** negative number to indicate synchronous=OFF. These days, synchronous + ** is always on by default regardless of the sign of the default cache + ** size. But continue to take the absolute value of the default cache + ** size of historical compatibility. + */ + case PragTyp_DEFAULT_CACHE_SIZE: { + static const int iLn = VDBE_OFFSET_LINENO(2); + static const VdbeOpList getCacheSize[] = { + { OP_Transaction, 0, 0, 0}, /* 0 */ + { OP_ReadCookie, 0, 1, BTREE_DEFAULT_CACHE_SIZE}, /* 1 */ + { OP_IfPos, 1, 8, 0}, + { OP_Integer, 0, 2, 0}, + { OP_Subtract, 1, 2, 1}, + { OP_IfPos, 1, 8, 0}, + { OP_Integer, 0, 1, 0}, /* 6 */ + { OP_Noop, 0, 0, 0}, + { OP_ResultRow, 1, 1, 0}, + }; + VdbeOp *aOp; + sqlite3VdbeUsesBtree(v, iDb); + if( !zRight ){ + pParse->nMem += 2; + sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(getCacheSize)); + aOp = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize, iLn); + if( ONLY_IF_REALLOC_STRESS(aOp==0) ) break; + aOp[0].p1 = iDb; + aOp[1].p1 = iDb; + aOp[6].p1 = SQLITE_DEFAULT_CACHE_SIZE; + }else{ + int size = sqlite3AbsInt32(sqlite3Atoi(zRight)); + sqlite3BeginWriteOperation(pParse, 0, iDb); + sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_DEFAULT_CACHE_SIZE, size); + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + pDb->pSchema->cache_size = size; + sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size); + } + break; + } +#endif /* !SQLITE_OMIT_PAGER_PRAGMAS && !SQLITE_OMIT_DEPRECATED */ + +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) + /* + ** PRAGMA [schema.]page_size + ** PRAGMA [schema.]page_size=N + ** + ** The first form reports the current setting for the + ** database page size in bytes. The second form sets the + ** database page size value. The value can only be set if + ** the database has not yet been created. + */ + case PragTyp_PAGE_SIZE: { + Btree *pBt = pDb->pBt; + assert( pBt!=0 ); + if( !zRight ){ + int size = ALWAYS(pBt) ? sqlite3BtreeGetPageSize(pBt) : 0; + returnSingleInt(v, size); + }else{ + /* Malloc may fail when setting the page-size, as there is an internal + ** buffer that the pager module resizes using sqlite3_realloc(). + */ + db->nextPagesize = sqlite3Atoi(zRight); + if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize,0,0) ){ + sqlite3OomFault(db); + } + } + break; + } + + /* + ** PRAGMA [schema.]secure_delete + ** PRAGMA [schema.]secure_delete=ON/OFF/FAST + ** + ** The first form reports the current setting for the + ** secure_delete flag. The second form changes the secure_delete + ** flag setting and reports the new value. + */ + case PragTyp_SECURE_DELETE: { + Btree *pBt = pDb->pBt; + int b = -1; + assert( pBt!=0 ); + if( zRight ){ + if( sqlite3_stricmp(zRight, "fast")==0 ){ + b = 2; + }else{ + b = sqlite3GetBoolean(zRight, 0); + } + } + if( pId2->n==0 && b>=0 ){ + int ii; + for(ii=0; iinDb; ii++){ + sqlite3BtreeSecureDelete(db->aDb[ii].pBt, b); + } + } + b = sqlite3BtreeSecureDelete(pBt, b); + returnSingleInt(v, b); + break; + } + + /* + ** PRAGMA [schema.]max_page_count + ** PRAGMA [schema.]max_page_count=N + ** + ** The first form reports the current setting for the + ** maximum number of pages in the database file. The + ** second form attempts to change this setting. Both + ** forms return the current setting. + ** + ** The absolute value of N is used. This is undocumented and might + ** change. The only purpose is to provide an easy way to test + ** the sqlite3AbsInt32() function. + ** + ** PRAGMA [schema.]page_count + ** + ** Return the number of pages in the specified database. + */ + case PragTyp_PAGE_COUNT: { + int iReg; + i64 x = 0; + sqlite3CodeVerifySchema(pParse, iDb); + iReg = ++pParse->nMem; + if( sqlite3Tolower(zLeft[0])=='p' ){ + sqlite3VdbeAddOp2(v, OP_Pagecount, iDb, iReg); + }else{ + if( zRight && sqlite3DecOrHexToI64(zRight,&x)==0 ){ + if( x<0 ) x = 0; + else if( x>0xfffffffe ) x = 0xfffffffe; + }else{ + x = 0; + } + sqlite3VdbeAddOp3(v, OP_MaxPgcnt, iDb, iReg, (int)x); + } + sqlite3VdbeAddOp2(v, OP_ResultRow, iReg, 1); + break; + } + + /* + ** PRAGMA [schema.]locking_mode + ** PRAGMA [schema.]locking_mode = (normal|exclusive) + */ + case PragTyp_LOCKING_MODE: { + const char *zRet = "normal"; + int eMode = getLockingMode(zRight); + + if( pId2->n==0 && eMode==PAGER_LOCKINGMODE_QUERY ){ + /* Simple "PRAGMA locking_mode;" statement. This is a query for + ** the current default locking mode (which may be different to + ** the locking-mode of the main database). + */ + eMode = db->dfltLockMode; + }else{ + Pager *pPager; + if( pId2->n==0 ){ + /* This indicates that no database name was specified as part + ** of the PRAGMA command. In this case the locking-mode must be + ** set on all attached databases, as well as the main db file. + ** + ** Also, the sqlite3.dfltLockMode variable is set so that + ** any subsequently attached databases also use the specified + ** locking mode. + */ + int ii; + assert(pDb==&db->aDb[0]); + for(ii=2; iinDb; ii++){ + pPager = sqlite3BtreePager(db->aDb[ii].pBt); + sqlite3PagerLockingMode(pPager, eMode); + } + db->dfltLockMode = (u8)eMode; + } + pPager = sqlite3BtreePager(pDb->pBt); + eMode = sqlite3PagerLockingMode(pPager, eMode); + } + + assert( eMode==PAGER_LOCKINGMODE_NORMAL + || eMode==PAGER_LOCKINGMODE_EXCLUSIVE ); + if( eMode==PAGER_LOCKINGMODE_EXCLUSIVE ){ + zRet = "exclusive"; + } + returnSingleText(v, zRet); + break; + } + + /* + ** PRAGMA [schema.]journal_mode + ** PRAGMA [schema.]journal_mode = + ** (delete|persist|off|truncate|memory|wal|off) + */ + case PragTyp_JOURNAL_MODE: { + int eMode; /* One of the PAGER_JOURNALMODE_XXX symbols */ + int ii; /* Loop counter */ + + if( zRight==0 ){ + /* If there is no "=MODE" part of the pragma, do a query for the + ** current mode */ + eMode = PAGER_JOURNALMODE_QUERY; + }else{ + const char *zMode; + int n = sqlite3Strlen30(zRight); + for(eMode=0; (zMode = sqlite3JournalModename(eMode))!=0; eMode++){ + if( sqlite3StrNICmp(zRight, zMode, n)==0 ) break; + } + if( !zMode ){ + /* If the "=MODE" part does not match any known journal mode, + ** then do a query */ + eMode = PAGER_JOURNALMODE_QUERY; + } + if( eMode==PAGER_JOURNALMODE_OFF && (db->flags & SQLITE_Defensive)!=0 ){ + /* Do not allow journal-mode "OFF" in defensive since the database + ** can become corrupted using ordinary SQL when the journal is off */ + eMode = PAGER_JOURNALMODE_QUERY; + } + } + if( eMode==PAGER_JOURNALMODE_QUERY && pId2->n==0 ){ + /* Convert "PRAGMA journal_mode" into "PRAGMA main.journal_mode" */ + iDb = 0; + pId2->n = 1; + } + for(ii=db->nDb-1; ii>=0; ii--){ + if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){ + sqlite3VdbeUsesBtree(v, ii); + sqlite3VdbeAddOp3(v, OP_JournalMode, ii, 1, eMode); + } + } + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1); + break; + } + + /* + ** PRAGMA [schema.]journal_size_limit + ** PRAGMA [schema.]journal_size_limit=N + ** + ** Get or set the size limit on rollback journal files. + */ + case PragTyp_JOURNAL_SIZE_LIMIT: { + Pager *pPager = sqlite3BtreePager(pDb->pBt); + i64 iLimit = -2; + if( zRight ){ + sqlite3DecOrHexToI64(zRight, &iLimit); + if( iLimit<-1 ) iLimit = -1; + } + iLimit = sqlite3PagerJournalSizeLimit(pPager, iLimit); + returnSingleInt(v, iLimit); + break; + } + +#endif /* SQLITE_OMIT_PAGER_PRAGMAS */ + + /* + ** PRAGMA [schema.]auto_vacuum + ** PRAGMA [schema.]auto_vacuum=N + ** + ** Get or set the value of the database 'auto-vacuum' parameter. + ** The value is one of: 0 NONE 1 FULL 2 INCREMENTAL + */ +#ifndef SQLITE_OMIT_AUTOVACUUM + case PragTyp_AUTO_VACUUM: { + Btree *pBt = pDb->pBt; + assert( pBt!=0 ); + if( !zRight ){ + returnSingleInt(v, sqlite3BtreeGetAutoVacuum(pBt)); + }else{ + int eAuto = getAutoVacuum(zRight); + assert( eAuto>=0 && eAuto<=2 ); + db->nextAutovac = (u8)eAuto; + /* Call SetAutoVacuum() to set initialize the internal auto and + ** incr-vacuum flags. This is required in case this connection + ** creates the database file. It is important that it is created + ** as an auto-vacuum capable db. + */ + rc = sqlite3BtreeSetAutoVacuum(pBt, eAuto); + if( rc==SQLITE_OK && (eAuto==1 || eAuto==2) ){ + /* When setting the auto_vacuum mode to either "full" or + ** "incremental", write the value of meta[6] in the database + ** file. Before writing to meta[6], check that meta[3] indicates + ** that this really is an auto-vacuum capable database. + */ + static const int iLn = VDBE_OFFSET_LINENO(2); + static const VdbeOpList setMeta6[] = { + { OP_Transaction, 0, 1, 0}, /* 0 */ + { OP_ReadCookie, 0, 1, BTREE_LARGEST_ROOT_PAGE}, + { OP_If, 1, 0, 0}, /* 2 */ + { OP_Halt, SQLITE_OK, OE_Abort, 0}, /* 3 */ + { OP_SetCookie, 0, BTREE_INCR_VACUUM, 0}, /* 4 */ + }; + VdbeOp *aOp; + int iAddr = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(setMeta6)); + aOp = sqlite3VdbeAddOpList(v, ArraySize(setMeta6), setMeta6, iLn); + if( ONLY_IF_REALLOC_STRESS(aOp==0) ) break; + aOp[0].p1 = iDb; + aOp[1].p1 = iDb; + aOp[2].p2 = iAddr+4; + aOp[4].p1 = iDb; + aOp[4].p3 = eAuto - 1; + sqlite3VdbeUsesBtree(v, iDb); + } + } + break; + } +#endif + + /* + ** PRAGMA [schema.]incremental_vacuum(N) + ** + ** Do N steps of incremental vacuuming on a database. + */ +#ifndef SQLITE_OMIT_AUTOVACUUM + case PragTyp_INCREMENTAL_VACUUM: { + int iLimit = 0, addr; + if( zRight==0 || !sqlite3GetInt32(zRight, &iLimit) || iLimit<=0 ){ + iLimit = 0x7fffffff; + } + sqlite3BeginWriteOperation(pParse, 0, iDb); + sqlite3VdbeAddOp2(v, OP_Integer, iLimit, 1); + addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb); VdbeCoverage(v); + sqlite3VdbeAddOp1(v, OP_ResultRow, 1); + sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1); + sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addr); + break; + } +#endif + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS + /* + ** PRAGMA [schema.]cache_size + ** PRAGMA [schema.]cache_size=N + ** + ** The first form reports the current local setting for the + ** page cache size. The second form sets the local + ** page cache size value. If N is positive then that is the + ** number of pages in the cache. If N is negative, then the + ** number of pages is adjusted so that the cache uses -N kibibytes + ** of memory. + */ + case PragTyp_CACHE_SIZE: { + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + if( !zRight ){ + returnSingleInt(v, pDb->pSchema->cache_size); + }else{ + int size = sqlite3Atoi(zRight); + pDb->pSchema->cache_size = size; + sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size); + } + break; + } + + /* + ** PRAGMA [schema.]cache_spill + ** PRAGMA cache_spill=BOOLEAN + ** PRAGMA [schema.]cache_spill=N + ** + ** The first form reports the current local setting for the + ** page cache spill size. The second form turns cache spill on + ** or off. When turnning cache spill on, the size is set to the + ** current cache_size. The third form sets a spill size that + ** may be different form the cache size. + ** If N is positive then that is the + ** number of pages in the cache. If N is negative, then the + ** number of pages is adjusted so that the cache uses -N kibibytes + ** of memory. + ** + ** If the number of cache_spill pages is less then the number of + ** cache_size pages, no spilling occurs until the page count exceeds + ** the number of cache_size pages. + ** + ** The cache_spill=BOOLEAN setting applies to all attached schemas, + ** not just the schema specified. + */ + case PragTyp_CACHE_SPILL: { + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + if( !zRight ){ + returnSingleInt(v, + (db->flags & SQLITE_CacheSpill)==0 ? 0 : + sqlite3BtreeSetSpillSize(pDb->pBt,0)); + }else{ + int size = 1; + if( sqlite3GetInt32(zRight, &size) ){ + sqlite3BtreeSetSpillSize(pDb->pBt, size); + } + if( sqlite3GetBoolean(zRight, size!=0) ){ + db->flags |= SQLITE_CacheSpill; + }else{ + db->flags &= ~(u64)SQLITE_CacheSpill; + } + setAllPagerFlags(db); + } + break; + } + + /* + ** PRAGMA [schema.]mmap_size(N) + ** + ** Used to set mapping size limit. The mapping size limit is + ** used to limit the aggregate size of all memory mapped regions of the + ** database file. If this parameter is set to zero, then memory mapping + ** is not used at all. If N is negative, then the default memory map + ** limit determined by sqlite3_config(SQLITE_CONFIG_MMAP_SIZE) is set. + ** The parameter N is measured in bytes. + ** + ** This value is advisory. The underlying VFS is free to memory map + ** as little or as much as it wants. Except, if N is set to 0 then the + ** upper layers will never invoke the xFetch interfaces to the VFS. + */ + case PragTyp_MMAP_SIZE: { + sqlite3_int64 sz; +#if SQLITE_MAX_MMAP_SIZE>0 + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + if( zRight ){ + int ii; + sqlite3DecOrHexToI64(zRight, &sz); + if( sz<0 ) sz = sqlite3GlobalConfig.szMmap; + if( pId2->n==0 ) db->szMmap = sz; + for(ii=db->nDb-1; ii>=0; ii--){ + if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){ + sqlite3BtreeSetMmapLimit(db->aDb[ii].pBt, sz); + } + } + } + sz = -1; + rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_MMAP_SIZE, &sz); +#else + sz = 0; + rc = SQLITE_OK; +#endif + if( rc==SQLITE_OK ){ + returnSingleInt(v, sz); + }else if( rc!=SQLITE_NOTFOUND ){ + pParse->nErr++; + pParse->rc = rc; + } + break; + } + + /* + ** PRAGMA temp_store + ** PRAGMA temp_store = "default"|"memory"|"file" + ** + ** Return or set the local value of the temp_store flag. Changing + ** the local value does not make changes to the disk file and the default + ** value will be restored the next time the database is opened. + ** + ** Note that it is possible for the library compile-time options to + ** override this setting + */ + case PragTyp_TEMP_STORE: { + if( !zRight ){ + returnSingleInt(v, db->temp_store); + }else{ + changeTempStorage(pParse, zRight); + } + break; + } + + /* + ** PRAGMA temp_store_directory + ** PRAGMA temp_store_directory = ""|"directory_name" + ** + ** Return or set the local value of the temp_store_directory flag. Changing + ** the value sets a specific directory to be used for temporary files. + ** Setting to a null string reverts to the default temporary directory search. + ** If temporary directory is changed, then invalidateTempStorage. + ** + */ + case PragTyp_TEMP_STORE_DIRECTORY: { + sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR)); + if( !zRight ){ + returnSingleText(v, sqlite3_temp_directory); + }else{ +#ifndef SQLITE_OMIT_WSD + if( zRight[0] ){ + int res; + rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res); + if( rc!=SQLITE_OK || res==0 ){ + sqlite3ErrorMsg(pParse, "not a writable directory"); + sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR)); + goto pragma_out; + } + } + if( SQLITE_TEMP_STORE==0 + || (SQLITE_TEMP_STORE==1 && db->temp_store<=1) + || (SQLITE_TEMP_STORE==2 && db->temp_store==1) + ){ + invalidateTempStorage(pParse); + } + sqlite3_free(sqlite3_temp_directory); + if( zRight[0] ){ + sqlite3_temp_directory = sqlite3_mprintf("%s", zRight); + }else{ + sqlite3_temp_directory = 0; + } +#endif /* SQLITE_OMIT_WSD */ + } + sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR)); + break; + } + +#if SQLITE_OS_WIN + /* + ** PRAGMA data_store_directory + ** PRAGMA data_store_directory = ""|"directory_name" + ** + ** Return or set the local value of the data_store_directory flag. Changing + ** the value sets a specific directory to be used for database files that + ** were specified with a relative pathname. Setting to a null string reverts + ** to the default database directory, which for database files specified with + ** a relative path will probably be based on the current directory for the + ** process. Database file specified with an absolute path are not impacted + ** by this setting, regardless of its value. + ** + */ + case PragTyp_DATA_STORE_DIRECTORY: { + sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR)); + if( !zRight ){ + returnSingleText(v, sqlite3_data_directory); + }else{ +#ifndef SQLITE_OMIT_WSD + if( zRight[0] ){ + int res; + rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res); + if( rc!=SQLITE_OK || res==0 ){ + sqlite3ErrorMsg(pParse, "not a writable directory"); + sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR)); + goto pragma_out; + } + } + sqlite3_free(sqlite3_data_directory); + if( zRight[0] ){ + sqlite3_data_directory = sqlite3_mprintf("%s", zRight); + }else{ + sqlite3_data_directory = 0; + } +#endif /* SQLITE_OMIT_WSD */ + } + sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR)); + break; + } +#endif + +#if SQLITE_ENABLE_LOCKING_STYLE + /* + ** PRAGMA [schema.]lock_proxy_file + ** PRAGMA [schema.]lock_proxy_file = ":auto:"|"lock_file_path" + ** + ** Return or set the value of the lock_proxy_file flag. Changing + ** the value sets a specific file to be used for database access locks. + ** + */ + case PragTyp_LOCK_PROXY_FILE: { + if( !zRight ){ + Pager *pPager = sqlite3BtreePager(pDb->pBt); + char *proxy_file_path = NULL; + sqlite3_file *pFile = sqlite3PagerFile(pPager); + sqlite3OsFileControlHint(pFile, SQLITE_GET_LOCKPROXYFILE, + &proxy_file_path); + returnSingleText(v, proxy_file_path); + }else{ + Pager *pPager = sqlite3BtreePager(pDb->pBt); + sqlite3_file *pFile = sqlite3PagerFile(pPager); + int res; + if( zRight[0] ){ + res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE, + zRight); + } else { + res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE, + NULL); + } + if( res!=SQLITE_OK ){ + sqlite3ErrorMsg(pParse, "failed to set lock proxy file"); + goto pragma_out; + } + } + break; + } +#endif /* SQLITE_ENABLE_LOCKING_STYLE */ + + /* + ** PRAGMA [schema.]synchronous + ** PRAGMA [schema.]synchronous=OFF|ON|NORMAL|FULL|EXTRA + ** + ** Return or set the local value of the synchronous flag. Changing + ** the local value does not make changes to the disk file and the + ** default value will be restored the next time the database is + ** opened. + */ + case PragTyp_SYNCHRONOUS: { + if( !zRight ){ + returnSingleInt(v, pDb->safety_level-1); + }else{ + if( !db->autoCommit ){ + sqlite3ErrorMsg(pParse, + "Safety level may not be changed inside a transaction"); + }else if( iDb!=1 ){ + int iLevel = (getSafetyLevel(zRight,0,1)+1) & PAGER_SYNCHRONOUS_MASK; + if( iLevel==0 ) iLevel = 1; + pDb->safety_level = iLevel; + pDb->bSyncSet = 1; + setAllPagerFlags(db); + } + } + break; + } +#endif /* SQLITE_OMIT_PAGER_PRAGMAS */ + +#ifndef SQLITE_OMIT_FLAG_PRAGMAS + case PragTyp_FLAG: { + if( zRight==0 ){ + setPragmaResultColumnNames(v, pPragma); + returnSingleInt(v, (db->flags & pPragma->iArg)!=0 ); + }else{ + u64 mask = pPragma->iArg; /* Mask of bits to set or clear. */ + if( db->autoCommit==0 ){ + /* Foreign key support may not be enabled or disabled while not + ** in auto-commit mode. */ + mask &= ~(SQLITE_ForeignKeys); + } +#if SQLITE_USER_AUTHENTICATION + if( db->auth.authLevel==UAUTH_User ){ + /* Do not allow non-admin users to modify the schema arbitrarily */ + mask &= ~(SQLITE_WriteSchema); + } +#endif + + if( sqlite3GetBoolean(zRight, 0) ){ + db->flags |= mask; + }else{ + db->flags &= ~mask; + if( mask==SQLITE_DeferFKs ) db->nDeferredImmCons = 0; + if( (mask & SQLITE_WriteSchema)!=0 + && sqlite3_stricmp(zRight, "reset")==0 + ){ + /* IMP: R-60817-01178 If the argument is "RESET" then schema + ** writing is disabled (as with "PRAGMA writable_schema=OFF") and, + ** in addition, the schema is reloaded. */ + sqlite3ResetAllSchemasOfConnection(db); + } + } + + /* Many of the flag-pragmas modify the code generated by the SQL + ** compiler (eg. count_changes). So add an opcode to expire all + ** compiled SQL statements after modifying a pragma value. + */ + sqlite3VdbeAddOp0(v, OP_Expire); + setAllPagerFlags(db); + } + break; + } +#endif /* SQLITE_OMIT_FLAG_PRAGMAS */ + +#ifndef SQLITE_OMIT_SCHEMA_PRAGMAS + /* + ** PRAGMA table_info(
) + ** + ** Return a single row for each column of the named table. The columns of + ** the returned data set are: + ** + ** cid: Column id (numbered from left to right, starting at 0) + ** name: Column name + ** type: Column declaration type. + ** notnull: True if 'NOT NULL' is part of column declaration + ** dflt_value: The default value for the column, if any. + ** pk: Non-zero for PK fields. + */ + case PragTyp_TABLE_INFO: if( zRight ){ + Table *pTab; + sqlite3CodeVerifyNamedSchema(pParse, zDb); + pTab = sqlite3LocateTable(pParse, LOCATE_NOERR, zRight, zDb); + if( pTab ){ + int i, k; + int nHidden = 0; + Column *pCol; + Index *pPk = sqlite3PrimaryKeyIndex(pTab); + pParse->nMem = 7; + sqlite3ViewGetColumnNames(pParse, pTab); + for(i=0, pCol=pTab->aCol; inCol; i++, pCol++){ + int isHidden = 0; + const Expr *pColExpr; + if( pCol->colFlags & COLFLAG_NOINSERT ){ + if( pPragma->iArg==0 ){ + nHidden++; + continue; + } + if( pCol->colFlags & COLFLAG_VIRTUAL ){ + isHidden = 2; /* GENERATED ALWAYS AS ... VIRTUAL */ + }else if( pCol->colFlags & COLFLAG_STORED ){ + isHidden = 3; /* GENERATED ALWAYS AS ... STORED */ + }else{ assert( pCol->colFlags & COLFLAG_HIDDEN ); + isHidden = 1; /* HIDDEN */ + } + } + if( (pCol->colFlags & COLFLAG_PRIMKEY)==0 ){ + k = 0; + }else if( pPk==0 ){ + k = 1; + }else{ + for(k=1; k<=pTab->nCol && pPk->aiColumn[k-1]!=i; k++){} + } + pColExpr = sqlite3ColumnExpr(pTab,pCol); + assert( pColExpr==0 || pColExpr->op==TK_SPAN || isHidden>=2 ); + assert( pColExpr==0 || !ExprHasProperty(pColExpr, EP_IntValue) + || isHidden>=2 ); + sqlite3VdbeMultiLoad(v, 1, pPragma->iArg ? "issisii" : "issisi", + i-nHidden, + pCol->zCnName, + sqlite3ColumnType(pCol,""), + pCol->notNull ? 1 : 0, + (isHidden>=2 || pColExpr==0) ? 0 : pColExpr->u.zToken, + k, + isHidden); + } + } + } + break; + + /* + ** PRAGMA table_list + ** + ** Return a single row for each table, virtual table, or view in the + ** entire schema. + ** + ** schema: Name of attached database hold this table + ** name: Name of the table itself + ** type: "table", "view", "virtual", "shadow" + ** ncol: Number of columns + ** wr: True for a WITHOUT ROWID table + ** strict: True for a STRICT table + */ + case PragTyp_TABLE_LIST: { + int ii; + pParse->nMem = 6; + sqlite3CodeVerifyNamedSchema(pParse, zDb); + for(ii=0; iinDb; ii++){ + HashElem *k; + Hash *pHash; + int initNCol; + if( zDb && sqlite3_stricmp(zDb, db->aDb[ii].zDbSName)!=0 ) continue; + + /* Ensure that the Table.nCol field is initialized for all views + ** and virtual tables. Each time we initialize a Table.nCol value + ** for a table, that can potentially disrupt the hash table, so restart + ** the initialization scan. + */ + pHash = &db->aDb[ii].pSchema->tblHash; + initNCol = sqliteHashCount(pHash); + while( initNCol-- ){ + for(k=sqliteHashFirst(pHash); 1; k=sqliteHashNext(k) ){ + Table *pTab; + if( k==0 ){ initNCol = 0; break; } + pTab = sqliteHashData(k); + if( pTab->nCol==0 ){ + char *zSql = sqlite3MPrintf(db, "SELECT*FROM\"%w\"", pTab->zName); + if( zSql ){ + sqlite3_stmt *pDummy = 0; + (void)sqlite3_prepare(db, zSql, -1, &pDummy, 0); + (void)sqlite3_finalize(pDummy); + sqlite3DbFree(db, zSql); + } + if( db->mallocFailed ){ + sqlite3ErrorMsg(db->pParse, "out of memory"); + db->pParse->rc = SQLITE_NOMEM_BKPT; + } + pHash = &db->aDb[ii].pSchema->tblHash; + break; + } + } + } + + for(k=sqliteHashFirst(pHash); k; k=sqliteHashNext(k) ){ + Table *pTab = sqliteHashData(k); + const char *zType; + if( zRight && sqlite3_stricmp(zRight, pTab->zName)!=0 ) continue; + if( IsView(pTab) ){ + zType = "view"; + }else if( IsVirtual(pTab) ){ + zType = "virtual"; + }else if( pTab->tabFlags & TF_Shadow ){ + zType = "shadow"; + }else{ + zType = "table"; + } + sqlite3VdbeMultiLoad(v, 1, "sssiii", + db->aDb[ii].zDbSName, + sqlite3PreferredTableName(pTab->zName), + zType, + pTab->nCol, + (pTab->tabFlags & TF_WithoutRowid)!=0, + (pTab->tabFlags & TF_Strict)!=0 + ); + } + } + } + break; + +#ifdef SQLITE_DEBUG + case PragTyp_STATS: { + Index *pIdx; + HashElem *i; + pParse->nMem = 5; + sqlite3CodeVerifySchema(pParse, iDb); + for(i=sqliteHashFirst(&pDb->pSchema->tblHash); i; i=sqliteHashNext(i)){ + Table *pTab = sqliteHashData(i); + sqlite3VdbeMultiLoad(v, 1, "ssiii", + sqlite3PreferredTableName(pTab->zName), + 0, + pTab->szTabRow, + pTab->nRowLogEst, + pTab->tabFlags); + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + sqlite3VdbeMultiLoad(v, 2, "siiiX", + pIdx->zName, + pIdx->szIdxRow, + pIdx->aiRowLogEst[0], + pIdx->hasStat1); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 5); + } + } + } + break; +#endif + + case PragTyp_INDEX_INFO: if( zRight ){ + Index *pIdx; + Table *pTab; + pIdx = sqlite3FindIndex(db, zRight, zDb); + if( pIdx==0 ){ + /* If there is no index named zRight, check to see if there is a + ** WITHOUT ROWID table named zRight, and if there is, show the + ** structure of the PRIMARY KEY index for that table. */ + pTab = sqlite3LocateTable(pParse, LOCATE_NOERR, zRight, zDb); + if( pTab && !HasRowid(pTab) ){ + pIdx = sqlite3PrimaryKeyIndex(pTab); + } + } + if( pIdx ){ + int iIdxDb = sqlite3SchemaToIndex(db, pIdx->pSchema); + int i; + int mx; + if( pPragma->iArg ){ + /* PRAGMA index_xinfo (newer version with more rows and columns) */ + mx = pIdx->nColumn; + pParse->nMem = 6; + }else{ + /* PRAGMA index_info (legacy version) */ + mx = pIdx->nKeyCol; + pParse->nMem = 3; + } + pTab = pIdx->pTable; + sqlite3CodeVerifySchema(pParse, iIdxDb); + assert( pParse->nMem<=pPragma->nPragCName ); + for(i=0; iaiColumn[i]; + sqlite3VdbeMultiLoad(v, 1, "iisX", i, cnum, + cnum<0 ? 0 : pTab->aCol[cnum].zCnName); + if( pPragma->iArg ){ + sqlite3VdbeMultiLoad(v, 4, "isiX", + pIdx->aSortOrder[i], + pIdx->azColl[i], + inKeyCol); + } + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, pParse->nMem); + } + } + } + break; + + case PragTyp_INDEX_LIST: if( zRight ){ + Index *pIdx; + Table *pTab; + int i; + pTab = sqlite3FindTable(db, zRight, zDb); + if( pTab ){ + int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema); + pParse->nMem = 5; + sqlite3CodeVerifySchema(pParse, iTabDb); + for(pIdx=pTab->pIndex, i=0; pIdx; pIdx=pIdx->pNext, i++){ + const char *azOrigin[] = { "c", "u", "pk" }; + sqlite3VdbeMultiLoad(v, 1, "isisi", + i, + pIdx->zName, + IsUniqueIndex(pIdx), + azOrigin[pIdx->idxType], + pIdx->pPartIdxWhere!=0); + } + } + } + break; + + case PragTyp_DATABASE_LIST: { + int i; + pParse->nMem = 3; + for(i=0; inDb; i++){ + if( db->aDb[i].pBt==0 ) continue; + assert( db->aDb[i].zDbSName!=0 ); + sqlite3VdbeMultiLoad(v, 1, "iss", + i, + db->aDb[i].zDbSName, + sqlite3BtreeGetFilename(db->aDb[i].pBt)); + } + } + break; + + case PragTyp_COLLATION_LIST: { + int i = 0; + HashElem *p; + pParse->nMem = 2; + for(p=sqliteHashFirst(&db->aCollSeq); p; p=sqliteHashNext(p)){ + CollSeq *pColl = (CollSeq *)sqliteHashData(p); + sqlite3VdbeMultiLoad(v, 1, "is", i++, pColl->zName); + } + } + break; + +#ifndef SQLITE_OMIT_INTROSPECTION_PRAGMAS + case PragTyp_FUNCTION_LIST: { + int i; + HashElem *j; + FuncDef *p; + int showInternFunc = (db->mDbFlags & DBFLAG_InternalFunc)!=0; + pParse->nMem = 6; + for(i=0; iu.pHash ){ + assert( p->funcFlags & SQLITE_FUNC_BUILTIN ); + pragmaFunclistLine(v, p, 1, showInternFunc); + } + } + for(j=sqliteHashFirst(&db->aFunc); j; j=sqliteHashNext(j)){ + p = (FuncDef*)sqliteHashData(j); + assert( (p->funcFlags & SQLITE_FUNC_BUILTIN)==0 ); + pragmaFunclistLine(v, p, 0, showInternFunc); + } + } + break; + +#ifndef SQLITE_OMIT_VIRTUALTABLE + case PragTyp_MODULE_LIST: { + HashElem *j; + pParse->nMem = 1; + for(j=sqliteHashFirst(&db->aModule); j; j=sqliteHashNext(j)){ + Module *pMod = (Module*)sqliteHashData(j); + sqlite3VdbeMultiLoad(v, 1, "s", pMod->zName); + } + } + break; +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + + case PragTyp_PRAGMA_LIST: { + int i; + for(i=0; iu.tab.pFKey; + if( pFK ){ + int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema); + int i = 0; + pParse->nMem = 8; + sqlite3CodeVerifySchema(pParse, iTabDb); + while(pFK){ + int j; + for(j=0; jnCol; j++){ + sqlite3VdbeMultiLoad(v, 1, "iissssss", + i, + j, + pFK->zTo, + pTab->aCol[pFK->aCol[j].iFrom].zCnName, + pFK->aCol[j].zCol, + actionName(pFK->aAction[1]), /* ON UPDATE */ + actionName(pFK->aAction[0]), /* ON DELETE */ + "NONE"); + } + ++i; + pFK = pFK->pNextFrom; + } + } + } + } + break; +#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */ + +#ifndef SQLITE_OMIT_FOREIGN_KEY +#ifndef SQLITE_OMIT_TRIGGER + case PragTyp_FOREIGN_KEY_CHECK: { + FKey *pFK; /* A foreign key constraint */ + Table *pTab; /* Child table contain "REFERENCES" keyword */ + Table *pParent; /* Parent table that child points to */ + Index *pIdx; /* Index in the parent table */ + int i; /* Loop counter: Foreign key number for pTab */ + int j; /* Loop counter: Field of the foreign key */ + HashElem *k; /* Loop counter: Next table in schema */ + int x; /* result variable */ + int regResult; /* 3 registers to hold a result row */ + int regRow; /* Registers to hold a row from pTab */ + int addrTop; /* Top of a loop checking foreign keys */ + int addrOk; /* Jump here if the key is OK */ + int *aiCols; /* child to parent column mapping */ + + regResult = pParse->nMem+1; + pParse->nMem += 4; + regRow = ++pParse->nMem; + k = sqliteHashFirst(&db->aDb[iDb].pSchema->tblHash); + while( k ){ + if( zRight ){ + pTab = sqlite3LocateTable(pParse, 0, zRight, zDb); + k = 0; + }else{ + pTab = (Table*)sqliteHashData(k); + k = sqliteHashNext(k); + } + if( pTab==0 || !IsOrdinaryTable(pTab) || pTab->u.tab.pFKey==0 ) continue; + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + zDb = db->aDb[iDb].zDbSName; + sqlite3CodeVerifySchema(pParse, iDb); + sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName); + sqlite3TouchRegister(pParse, pTab->nCol+regRow); + sqlite3OpenTable(pParse, 0, iDb, pTab, OP_OpenRead); + sqlite3VdbeLoadString(v, regResult, pTab->zName); + assert( IsOrdinaryTable(pTab) ); + for(i=1, pFK=pTab->u.tab.pFKey; pFK; i++, pFK=pFK->pNextFrom){ + pParent = sqlite3FindTable(db, pFK->zTo, zDb); + if( pParent==0 ) continue; + pIdx = 0; + sqlite3TableLock(pParse, iDb, pParent->tnum, 0, pParent->zName); + x = sqlite3FkLocateIndex(pParse, pParent, pFK, &pIdx, 0); + if( x==0 ){ + if( pIdx==0 ){ + sqlite3OpenTable(pParse, i, iDb, pParent, OP_OpenRead); + }else{ + sqlite3VdbeAddOp3(v, OP_OpenRead, i, pIdx->tnum, iDb); + sqlite3VdbeSetP4KeyInfo(pParse, pIdx); + } + }else{ + k = 0; + break; + } + } + assert( pParse->nErr>0 || pFK==0 ); + if( pFK ) break; + if( pParse->nTabnTab = i; + addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, 0); VdbeCoverage(v); + assert( IsOrdinaryTable(pTab) ); + for(i=1, pFK=pTab->u.tab.pFKey; pFK; i++, pFK=pFK->pNextFrom){ + pParent = sqlite3FindTable(db, pFK->zTo, zDb); + pIdx = 0; + aiCols = 0; + if( pParent ){ + x = sqlite3FkLocateIndex(pParse, pParent, pFK, &pIdx, &aiCols); + assert( x==0 || db->mallocFailed ); + } + addrOk = sqlite3VdbeMakeLabel(pParse); + + /* Generate code to read the child key values into registers + ** regRow..regRow+n. If any of the child key values are NULL, this + ** row cannot cause an FK violation. Jump directly to addrOk in + ** this case. */ + sqlite3TouchRegister(pParse, regRow + pFK->nCol); + for(j=0; jnCol; j++){ + int iCol = aiCols ? aiCols[j] : pFK->aCol[j].iFrom; + sqlite3ExprCodeGetColumnOfTable(v, pTab, 0, iCol, regRow+j); + sqlite3VdbeAddOp2(v, OP_IsNull, regRow+j, addrOk); VdbeCoverage(v); + } + + /* Generate code to query the parent index for a matching parent + ** key. If a match is found, jump to addrOk. */ + if( pIdx ){ + sqlite3VdbeAddOp4(v, OP_Affinity, regRow, pFK->nCol, 0, + sqlite3IndexAffinityStr(db,pIdx), pFK->nCol); + sqlite3VdbeAddOp4Int(v, OP_Found, i, addrOk, regRow, pFK->nCol); + VdbeCoverage(v); + }else if( pParent ){ + int jmp = sqlite3VdbeCurrentAddr(v)+2; + sqlite3VdbeAddOp3(v, OP_SeekRowid, i, jmp, regRow); VdbeCoverage(v); + sqlite3VdbeGoto(v, addrOk); + assert( pFK->nCol==1 || db->mallocFailed ); + } + + /* Generate code to report an FK violation to the caller. */ + if( HasRowid(pTab) ){ + sqlite3VdbeAddOp2(v, OP_Rowid, 0, regResult+1); + }else{ + sqlite3VdbeAddOp2(v, OP_Null, 0, regResult+1); + } + sqlite3VdbeMultiLoad(v, regResult+2, "siX", pFK->zTo, i-1); + sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, 4); + sqlite3VdbeResolveLabel(v, addrOk); + sqlite3DbFree(db, aiCols); + } + sqlite3VdbeAddOp2(v, OP_Next, 0, addrTop+1); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addrTop); + } + } + break; +#endif /* !defined(SQLITE_OMIT_TRIGGER) */ +#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */ + +#ifndef SQLITE_OMIT_CASE_SENSITIVE_LIKE_PRAGMA + /* Reinstall the LIKE and GLOB functions. The variant of LIKE + ** used will be case sensitive or not depending on the RHS. + */ + case PragTyp_CASE_SENSITIVE_LIKE: { + if( zRight ){ + sqlite3RegisterLikeFunctions(db, sqlite3GetBoolean(zRight, 0)); + } + } + break; +#endif /* SQLITE_OMIT_CASE_SENSITIVE_LIKE_PRAGMA */ + +#ifndef SQLITE_INTEGRITY_CHECK_ERROR_MAX +# define SQLITE_INTEGRITY_CHECK_ERROR_MAX 100 +#endif + +#ifndef SQLITE_OMIT_INTEGRITY_CHECK + /* PRAGMA integrity_check + ** PRAGMA integrity_check(N) + ** PRAGMA quick_check + ** PRAGMA quick_check(N) + ** + ** Verify the integrity of the database. + ** + ** The "quick_check" is reduced version of + ** integrity_check designed to detect most database corruption + ** without the overhead of cross-checking indexes. Quick_check + ** is linear time wherease integrity_check is O(NlogN). + ** + ** The maximum nubmer of errors is 100 by default. A different default + ** can be specified using a numeric parameter N. + ** + ** Or, the parameter N can be the name of a table. In that case, only + ** the one table named is verified. The freelist is only verified if + ** the named table is "sqlite_schema" (or one of its aliases). + ** + ** All schemas are checked by default. To check just a single + ** schema, use the form: + ** + ** PRAGMA schema.integrity_check; + */ + case PragTyp_INTEGRITY_CHECK: { + int i, j, addr, mxErr; + Table *pObjTab = 0; /* Check only this one table, if not NULL */ + + int isQuick = (sqlite3Tolower(zLeft[0])=='q'); + + /* If the PRAGMA command was of the form "PRAGMA .integrity_check", + ** then iDb is set to the index of the database identified by . + ** In this case, the integrity of database iDb only is verified by + ** the VDBE created below. + ** + ** Otherwise, if the command was simply "PRAGMA integrity_check" (or + ** "PRAGMA quick_check"), then iDb is set to 0. In this case, set iDb + ** to -1 here, to indicate that the VDBE should verify the integrity + ** of all attached databases. */ + assert( iDb>=0 ); + assert( iDb==0 || pId2->z ); + if( pId2->z==0 ) iDb = -1; + + /* Initialize the VDBE program */ + pParse->nMem = 6; + + /* Set the maximum error count */ + mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX; + if( zRight ){ + if( sqlite3GetInt32(zRight, &mxErr) ){ + if( mxErr<=0 ){ + mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX; + } + }else{ + pObjTab = sqlite3LocateTable(pParse, 0, zRight, + iDb>=0 ? db->aDb[iDb].zDbSName : 0); + } + } + sqlite3VdbeAddOp2(v, OP_Integer, mxErr-1, 1); /* reg[1] holds errors left */ + + /* Do an integrity check on each database file */ + for(i=0; inDb; i++){ + HashElem *x; /* For looping over tables in the schema */ + Hash *pTbls; /* Set of all tables in the schema */ + int *aRoot; /* Array of root page numbers of all btrees */ + int cnt = 0; /* Number of entries in aRoot[] */ + int mxIdx = 0; /* Maximum number of indexes for any table */ + + if( OMIT_TEMPDB && i==1 ) continue; + if( iDb>=0 && i!=iDb ) continue; + + sqlite3CodeVerifySchema(pParse, i); + pParse->okConstFactor = 0; /* tag-20230327-1 */ + + /* Do an integrity check of the B-Tree + ** + ** Begin by finding the root pages numbers + ** for all tables and indices in the database. + */ + assert( sqlite3SchemaMutexHeld(db, i, 0) ); + pTbls = &db->aDb[i].pSchema->tblHash; + for(cnt=0, x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){ + Table *pTab = sqliteHashData(x); /* Current table */ + Index *pIdx; /* An index on pTab */ + int nIdx; /* Number of indexes on pTab */ + if( pObjTab && pObjTab!=pTab ) continue; + if( HasRowid(pTab) ) cnt++; + for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){ cnt++; } + if( nIdx>mxIdx ) mxIdx = nIdx; + } + if( cnt==0 ) continue; + if( pObjTab ) cnt++; + aRoot = sqlite3DbMallocRawNN(db, sizeof(int)*(cnt+1)); + if( aRoot==0 ) break; + cnt = 0; + if( pObjTab ) aRoot[++cnt] = 0; + for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){ + Table *pTab = sqliteHashData(x); + Index *pIdx; + if( pObjTab && pObjTab!=pTab ) continue; + if( HasRowid(pTab) ) aRoot[++cnt] = pTab->tnum; + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + aRoot[++cnt] = pIdx->tnum; + } + } + aRoot[0] = cnt; + + /* Make sure sufficient number of registers have been allocated */ + sqlite3TouchRegister(pParse, 8+mxIdx); + sqlite3ClearTempRegCache(pParse); + + /* Do the b-tree integrity checks */ + sqlite3VdbeAddOp4(v, OP_IntegrityCk, 2, cnt, 1, (char*)aRoot,P4_INTARRAY); + sqlite3VdbeChangeP5(v, (u8)i); + addr = sqlite3VdbeAddOp1(v, OP_IsNull, 2); VdbeCoverage(v); + sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, + sqlite3MPrintf(db, "*** in database %s ***\n", db->aDb[i].zDbSName), + P4_DYNAMIC); + sqlite3VdbeAddOp3(v, OP_Concat, 2, 3, 3); + integrityCheckResultRow(v); + sqlite3VdbeJumpHere(v, addr); + + /* Make sure all the indices are constructed correctly. + */ + for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){ + Table *pTab = sqliteHashData(x); + Index *pIdx, *pPk; + Index *pPrior = 0; /* Previous index */ + int loopTop; + int iDataCur, iIdxCur; + int r1 = -1; + int bStrict; /* True for a STRICT table */ + int r2; /* Previous key for WITHOUT ROWID tables */ + int mxCol; /* Maximum non-virtual column number */ + + if( !IsOrdinaryTable(pTab) ) continue; + if( pObjTab && pObjTab!=pTab ) continue; + if( isQuick || HasRowid(pTab) ){ + pPk = 0; + r2 = 0; + }else{ + pPk = sqlite3PrimaryKeyIndex(pTab); + r2 = sqlite3GetTempRange(pParse, pPk->nKeyCol); + sqlite3VdbeAddOp3(v, OP_Null, 1, r2, r2+pPk->nKeyCol-1); + } + sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenRead, 0, + 1, 0, &iDataCur, &iIdxCur); + /* reg[7] counts the number of entries in the table. + ** reg[8+i] counts the number of entries in the i-th index + */ + sqlite3VdbeAddOp2(v, OP_Integer, 0, 7); + for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ + sqlite3VdbeAddOp2(v, OP_Integer, 0, 8+j); /* index entries counter */ + } + assert( pParse->nMem>=8+j ); + assert( sqlite3NoTempsInRange(pParse,1,7+j) ); + sqlite3VdbeAddOp2(v, OP_Rewind, iDataCur, 0); VdbeCoverage(v); + loopTop = sqlite3VdbeAddOp2(v, OP_AddImm, 7, 1); + + /* Fetch the right-most column from the table. This will cause + ** the entire record header to be parsed and sanity checked. It + ** will also prepopulate the cursor column cache that is used + ** by the OP_IsType code, so it is a required step. + */ + assert( !IsVirtual(pTab) ); + if( HasRowid(pTab) ){ + mxCol = -1; + for(j=0; jnCol; j++){ + if( (pTab->aCol[j].colFlags & COLFLAG_VIRTUAL)==0 ) mxCol++; + } + if( mxCol==pTab->iPKey ) mxCol--; + }else{ + /* COLFLAG_VIRTUAL columns are not included in the WITHOUT ROWID + ** PK index column-count, so there is no need to account for them + ** in this case. */ + mxCol = sqlite3PrimaryKeyIndex(pTab)->nColumn-1; + } + if( mxCol>=0 ){ + sqlite3VdbeAddOp3(v, OP_Column, iDataCur, mxCol, 3); + sqlite3VdbeTypeofColumn(v, 3); + } + + if( !isQuick ){ + if( pPk ){ + /* Verify WITHOUT ROWID keys are in ascending order */ + int a1; + char *zErr; + a1 = sqlite3VdbeAddOp4Int(v, OP_IdxGT, iDataCur, 0,r2,pPk->nKeyCol); + VdbeCoverage(v); + sqlite3VdbeAddOp1(v, OP_IsNull, r2); VdbeCoverage(v); + zErr = sqlite3MPrintf(db, + "row not in PRIMARY KEY order for %s", + pTab->zName); + sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC); + integrityCheckResultRow(v); + sqlite3VdbeJumpHere(v, a1); + sqlite3VdbeJumpHere(v, a1+1); + for(j=0; jnKeyCol; j++){ + sqlite3ExprCodeLoadIndexColumn(pParse, pPk, iDataCur, j, r2+j); + } + } + } + /* Verify datatypes for all columns: + ** + ** (1) NOT NULL columns may not contain a NULL + ** (2) Datatype must be exact for non-ANY columns in STRICT tables + ** (3) Datatype for TEXT columns in non-STRICT tables must be + ** NULL, TEXT, or BLOB. + ** (4) Datatype for numeric columns in non-STRICT tables must not + ** be a TEXT value that can be losslessly converted to numeric. + */ + bStrict = (pTab->tabFlags & TF_Strict)!=0; + for(j=0; jnCol; j++){ + char *zErr; + Column *pCol = pTab->aCol + j; /* The column to be checked */ + int labelError; /* Jump here to report an error */ + int labelOk; /* Jump here if all looks ok */ + int p1, p3, p4; /* Operands to the OP_IsType opcode */ + int doTypeCheck; /* Check datatypes (besides NOT NULL) */ + + if( j==pTab->iPKey ) continue; + if( bStrict ){ + doTypeCheck = pCol->eCType>COLTYPE_ANY; + }else{ + doTypeCheck = pCol->affinity>SQLITE_AFF_BLOB; + } + if( pCol->notNull==0 && !doTypeCheck ) continue; + + /* Compute the operands that will be needed for OP_IsType */ + p4 = SQLITE_NULL; + if( pCol->colFlags & COLFLAG_VIRTUAL ){ + sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, j, 3); + p1 = -1; + p3 = 3; + }else{ + if( pCol->iDflt ){ + sqlite3_value *pDfltValue = 0; + sqlite3ValueFromExpr(db, sqlite3ColumnExpr(pTab,pCol), ENC(db), + pCol->affinity, &pDfltValue); + if( pDfltValue ){ + p4 = sqlite3_value_type(pDfltValue); + sqlite3ValueFree(pDfltValue); + } + } + p1 = iDataCur; + if( !HasRowid(pTab) ){ + testcase( j!=sqlite3TableColumnToStorage(pTab, j) ); + p3 = sqlite3TableColumnToIndex(sqlite3PrimaryKeyIndex(pTab), j); + }else{ + p3 = sqlite3TableColumnToStorage(pTab,j); + testcase( p3!=j); + } + } + + labelError = sqlite3VdbeMakeLabel(pParse); + labelOk = sqlite3VdbeMakeLabel(pParse); + if( pCol->notNull ){ + /* (1) NOT NULL columns may not contain a NULL */ + int jmp3; + int jmp2 = sqlite3VdbeAddOp4Int(v, OP_IsType, p1, labelOk, p3, p4); + VdbeCoverage(v); + if( p1<0 ){ + sqlite3VdbeChangeP5(v, 0x0f); /* INT, REAL, TEXT, or BLOB */ + jmp3 = jmp2; + }else{ + sqlite3VdbeChangeP5(v, 0x0d); /* INT, TEXT, or BLOB */ + /* OP_IsType does not detect NaN values in the database file + ** which should be treated as a NULL. So if the header type + ** is REAL, we have to load the actual data using OP_Column + ** to reliably determine if the value is a NULL. */ + sqlite3VdbeAddOp3(v, OP_Column, p1, p3, 3); + jmp3 = sqlite3VdbeAddOp2(v, OP_NotNull, 3, labelOk); + VdbeCoverage(v); + } + zErr = sqlite3MPrintf(db, "NULL value in %s.%s", pTab->zName, + pCol->zCnName); + sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC); + if( doTypeCheck ){ + sqlite3VdbeGoto(v, labelError); + sqlite3VdbeJumpHere(v, jmp2); + sqlite3VdbeJumpHere(v, jmp3); + }else{ + /* VDBE byte code will fall thru */ + } + } + if( bStrict && doTypeCheck ){ + /* (2) Datatype must be exact for non-ANY columns in STRICT tables*/ + static unsigned char aStdTypeMask[] = { + 0x1f, /* ANY */ + 0x18, /* BLOB */ + 0x11, /* INT */ + 0x11, /* INTEGER */ + 0x13, /* REAL */ + 0x14 /* TEXT */ + }; + sqlite3VdbeAddOp4Int(v, OP_IsType, p1, labelOk, p3, p4); + assert( pCol->eCType>=1 && pCol->eCType<=sizeof(aStdTypeMask) ); + sqlite3VdbeChangeP5(v, aStdTypeMask[pCol->eCType-1]); + VdbeCoverage(v); + zErr = sqlite3MPrintf(db, "non-%s value in %s.%s", + sqlite3StdType[pCol->eCType-1], + pTab->zName, pTab->aCol[j].zCnName); + sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC); + }else if( !bStrict && pCol->affinity==SQLITE_AFF_TEXT ){ + /* (3) Datatype for TEXT columns in non-STRICT tables must be + ** NULL, TEXT, or BLOB. */ + sqlite3VdbeAddOp4Int(v, OP_IsType, p1, labelOk, p3, p4); + sqlite3VdbeChangeP5(v, 0x1c); /* NULL, TEXT, or BLOB */ + VdbeCoverage(v); + zErr = sqlite3MPrintf(db, "NUMERIC value in %s.%s", + pTab->zName, pTab->aCol[j].zCnName); + sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC); + }else if( !bStrict && pCol->affinity>=SQLITE_AFF_NUMERIC ){ + /* (4) Datatype for numeric columns in non-STRICT tables must not + ** be a TEXT value that can be converted to numeric. */ + sqlite3VdbeAddOp4Int(v, OP_IsType, p1, labelOk, p3, p4); + sqlite3VdbeChangeP5(v, 0x1b); /* NULL, INT, FLOAT, or BLOB */ + VdbeCoverage(v); + if( p1>=0 ){ + sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, j, 3); + } + sqlite3VdbeAddOp4(v, OP_Affinity, 3, 1, 0, "C", P4_STATIC); + sqlite3VdbeAddOp4Int(v, OP_IsType, -1, labelOk, 3, p4); + sqlite3VdbeChangeP5(v, 0x1c); /* NULL, TEXT, or BLOB */ + VdbeCoverage(v); + zErr = sqlite3MPrintf(db, "TEXT value in %s.%s", + pTab->zName, pTab->aCol[j].zCnName); + sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC); + } + sqlite3VdbeResolveLabel(v, labelError); + integrityCheckResultRow(v); + sqlite3VdbeResolveLabel(v, labelOk); + } + /* Verify CHECK constraints */ + if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){ + ExprList *pCheck = sqlite3ExprListDup(db, pTab->pCheck, 0); + if( db->mallocFailed==0 ){ + int addrCkFault = sqlite3VdbeMakeLabel(pParse); + int addrCkOk = sqlite3VdbeMakeLabel(pParse); + char *zErr; + int k; + pParse->iSelfTab = iDataCur + 1; + for(k=pCheck->nExpr-1; k>0; k--){ + sqlite3ExprIfFalse(pParse, pCheck->a[k].pExpr, addrCkFault, 0); + } + sqlite3ExprIfTrue(pParse, pCheck->a[0].pExpr, addrCkOk, + SQLITE_JUMPIFNULL); + sqlite3VdbeResolveLabel(v, addrCkFault); + pParse->iSelfTab = 0; + zErr = sqlite3MPrintf(db, "CHECK constraint failed in %s", + pTab->zName); + sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC); + integrityCheckResultRow(v); + sqlite3VdbeResolveLabel(v, addrCkOk); + } + sqlite3ExprListDelete(db, pCheck); + } + if( !isQuick ){ /* Omit the remaining tests for quick_check */ + /* Validate index entries for the current row */ + for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ + int jmp2, jmp3, jmp4, jmp5, label6; + int kk; + int ckUniq = sqlite3VdbeMakeLabel(pParse); + if( pPk==pIdx ) continue; + r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 0, &jmp3, + pPrior, r1); + pPrior = pIdx; + sqlite3VdbeAddOp2(v, OP_AddImm, 8+j, 1);/* increment entry count */ + /* Verify that an index entry exists for the current table row */ + jmp2 = sqlite3VdbeAddOp4Int(v, OP_Found, iIdxCur+j, ckUniq, r1, + pIdx->nColumn); VdbeCoverage(v); + sqlite3VdbeLoadString(v, 3, "row "); + sqlite3VdbeAddOp3(v, OP_Concat, 7, 3, 3); + sqlite3VdbeLoadString(v, 4, " missing from index "); + sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 3); + jmp5 = sqlite3VdbeLoadString(v, 4, pIdx->zName); + sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 3); + jmp4 = integrityCheckResultRow(v); + sqlite3VdbeJumpHere(v, jmp2); + + /* The OP_IdxRowid opcode is an optimized version of OP_Column + ** that extracts the rowid off the end of the index record. + ** But it only works correctly if index record does not have + ** any extra bytes at the end. Verify that this is the case. */ + if( HasRowid(pTab) ){ + int jmp7; + sqlite3VdbeAddOp2(v, OP_IdxRowid, iIdxCur+j, 3); + jmp7 = sqlite3VdbeAddOp3(v, OP_Eq, 3, 0, r1+pIdx->nColumn-1); + VdbeCoverageNeverNull(v); + sqlite3VdbeLoadString(v, 3, + "rowid not at end-of-record for row "); + sqlite3VdbeAddOp3(v, OP_Concat, 7, 3, 3); + sqlite3VdbeLoadString(v, 4, " of index "); + sqlite3VdbeGoto(v, jmp5-1); + sqlite3VdbeJumpHere(v, jmp7); + } + + /* Any indexed columns with non-BINARY collations must still hold + ** the exact same text value as the table. */ + label6 = 0; + for(kk=0; kknKeyCol; kk++){ + if( pIdx->azColl[kk]==sqlite3StrBINARY ) continue; + if( label6==0 ) label6 = sqlite3VdbeMakeLabel(pParse); + sqlite3VdbeAddOp3(v, OP_Column, iIdxCur+j, kk, 3); + sqlite3VdbeAddOp3(v, OP_Ne, 3, label6, r1+kk); VdbeCoverage(v); + } + if( label6 ){ + int jmp6 = sqlite3VdbeAddOp0(v, OP_Goto); + sqlite3VdbeResolveLabel(v, label6); + sqlite3VdbeLoadString(v, 3, "row "); + sqlite3VdbeAddOp3(v, OP_Concat, 7, 3, 3); + sqlite3VdbeLoadString(v, 4, " values differ from index "); + sqlite3VdbeGoto(v, jmp5-1); + sqlite3VdbeJumpHere(v, jmp6); + } + + /* For UNIQUE indexes, verify that only one entry exists with the + ** current key. The entry is unique if (1) any column is NULL + ** or (2) the next entry has a different key */ + if( IsUniqueIndex(pIdx) ){ + int uniqOk = sqlite3VdbeMakeLabel(pParse); + int jmp6; + for(kk=0; kknKeyCol; kk++){ + int iCol = pIdx->aiColumn[kk]; + assert( iCol!=XN_ROWID && iColnCol ); + if( iCol>=0 && pTab->aCol[iCol].notNull ) continue; + sqlite3VdbeAddOp2(v, OP_IsNull, r1+kk, uniqOk); + VdbeCoverage(v); + } + jmp6 = sqlite3VdbeAddOp1(v, OP_Next, iIdxCur+j); VdbeCoverage(v); + sqlite3VdbeGoto(v, uniqOk); + sqlite3VdbeJumpHere(v, jmp6); + sqlite3VdbeAddOp4Int(v, OP_IdxGT, iIdxCur+j, uniqOk, r1, + pIdx->nKeyCol); VdbeCoverage(v); + sqlite3VdbeLoadString(v, 3, "non-unique entry in index "); + sqlite3VdbeGoto(v, jmp5); + sqlite3VdbeResolveLabel(v, uniqOk); + } + sqlite3VdbeJumpHere(v, jmp4); + sqlite3ResolvePartIdxLabel(pParse, jmp3); + } + } + sqlite3VdbeAddOp2(v, OP_Next, iDataCur, loopTop); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, loopTop-1); + if( !isQuick ){ + sqlite3VdbeLoadString(v, 2, "wrong # of entries in index "); + for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ + if( pPk==pIdx ) continue; + sqlite3VdbeAddOp2(v, OP_Count, iIdxCur+j, 3); + addr = sqlite3VdbeAddOp3(v, OP_Eq, 8+j, 0, 3); VdbeCoverage(v); + sqlite3VdbeChangeP5(v, SQLITE_NOTNULL); + sqlite3VdbeLoadString(v, 4, pIdx->zName); + sqlite3VdbeAddOp3(v, OP_Concat, 4, 2, 3); + integrityCheckResultRow(v); + sqlite3VdbeJumpHere(v, addr); + } + if( pPk ){ + sqlite3ReleaseTempRange(pParse, r2, pPk->nKeyCol); + } + } + } + } + { + static const int iLn = VDBE_OFFSET_LINENO(2); + static const VdbeOpList endCode[] = { + { OP_AddImm, 1, 0, 0}, /* 0 */ + { OP_IfNotZero, 1, 4, 0}, /* 1 */ + { OP_String8, 0, 3, 0}, /* 2 */ + { OP_ResultRow, 3, 1, 0}, /* 3 */ + { OP_Halt, 0, 0, 0}, /* 4 */ + { OP_String8, 0, 3, 0}, /* 5 */ + { OP_Goto, 0, 3, 0}, /* 6 */ + }; + VdbeOp *aOp; + + aOp = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode, iLn); + if( aOp ){ + aOp[0].p2 = 1-mxErr; + aOp[2].p4type = P4_STATIC; + aOp[2].p4.z = "ok"; + aOp[5].p4type = P4_STATIC; + aOp[5].p4.z = (char*)sqlite3ErrStr(SQLITE_CORRUPT); + } + sqlite3VdbeChangeP3(v, 0, sqlite3VdbeCurrentAddr(v)-2); + } + } + break; +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +#ifndef SQLITE_OMIT_UTF16 + /* + ** PRAGMA encoding + ** PRAGMA encoding = "utf-8"|"utf-16"|"utf-16le"|"utf-16be" + ** + ** In its first form, this pragma returns the encoding of the main + ** database. If the database is not initialized, it is initialized now. + ** + ** The second form of this pragma is a no-op if the main database file + ** has not already been initialized. In this case it sets the default + ** encoding that will be used for the main database file if a new file + ** is created. If an existing main database file is opened, then the + ** default text encoding for the existing database is used. + ** + ** In all cases new databases created using the ATTACH command are + ** created to use the same default text encoding as the main database. If + ** the main database has not been initialized and/or created when ATTACH + ** is executed, this is done before the ATTACH operation. + ** + ** In the second form this pragma sets the text encoding to be used in + ** new database files created using this database handle. It is only + ** useful if invoked immediately after the main database i + */ + case PragTyp_ENCODING: { + static const struct EncName { + char *zName; + u8 enc; + } encnames[] = { + { "UTF8", SQLITE_UTF8 }, + { "UTF-8", SQLITE_UTF8 }, /* Must be element [1] */ + { "UTF-16le", SQLITE_UTF16LE }, /* Must be element [2] */ + { "UTF-16be", SQLITE_UTF16BE }, /* Must be element [3] */ + { "UTF16le", SQLITE_UTF16LE }, + { "UTF16be", SQLITE_UTF16BE }, + { "UTF-16", 0 }, /* SQLITE_UTF16NATIVE */ + { "UTF16", 0 }, /* SQLITE_UTF16NATIVE */ + { 0, 0 } + }; + const struct EncName *pEnc; + if( !zRight ){ /* "PRAGMA encoding" */ + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + assert( encnames[SQLITE_UTF8].enc==SQLITE_UTF8 ); + assert( encnames[SQLITE_UTF16LE].enc==SQLITE_UTF16LE ); + assert( encnames[SQLITE_UTF16BE].enc==SQLITE_UTF16BE ); + returnSingleText(v, encnames[ENC(pParse->db)].zName); + }else{ /* "PRAGMA encoding = XXX" */ + /* Only change the value of sqlite.enc if the database handle is not + ** initialized. If the main database exists, the new sqlite.enc value + ** will be overwritten when the schema is next loaded. If it does not + ** already exists, it will be created to use the new encoding value. + */ + if( (db->mDbFlags & DBFLAG_EncodingFixed)==0 ){ + for(pEnc=&encnames[0]; pEnc->zName; pEnc++){ + if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){ + u8 enc = pEnc->enc ? pEnc->enc : SQLITE_UTF16NATIVE; + SCHEMA_ENC(db) = enc; + sqlite3SetTextEncoding(db, enc); + break; + } + } + if( !pEnc->zName ){ + sqlite3ErrorMsg(pParse, "unsupported encoding: %s", zRight); + } + } + } + } + break; +#endif /* SQLITE_OMIT_UTF16 */ + +#ifndef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS + /* + ** PRAGMA [schema.]schema_version + ** PRAGMA [schema.]schema_version = + ** + ** PRAGMA [schema.]user_version + ** PRAGMA [schema.]user_version = + ** + ** PRAGMA [schema.]freelist_count + ** + ** PRAGMA [schema.]data_version + ** + ** PRAGMA [schema.]application_id + ** PRAGMA [schema.]application_id = + ** + ** The pragma's schema_version and user_version are used to set or get + ** the value of the schema-version and user-version, respectively. Both + ** the schema-version and the user-version are 32-bit signed integers + ** stored in the database header. + ** + ** The schema-cookie is usually only manipulated internally by SQLite. It + ** is incremented by SQLite whenever the database schema is modified (by + ** creating or dropping a table or index). The schema version is used by + ** SQLite each time a query is executed to ensure that the internal cache + ** of the schema used when compiling the SQL query matches the schema of + ** the database against which the compiled query is actually executed. + ** Subverting this mechanism by using "PRAGMA schema_version" to modify + ** the schema-version is potentially dangerous and may lead to program + ** crashes or database corruption. Use with caution! + ** + ** The user-version is not used internally by SQLite. It may be used by + ** applications for any purpose. + */ + case PragTyp_HEADER_VALUE: { + int iCookie = pPragma->iArg; /* Which cookie to read or write */ + sqlite3VdbeUsesBtree(v, iDb); + if( zRight && (pPragma->mPragFlg & PragFlg_ReadOnly)==0 ){ + /* Write the specified cookie value */ + static const VdbeOpList setCookie[] = { + { OP_Transaction, 0, 1, 0}, /* 0 */ + { OP_SetCookie, 0, 0, 0}, /* 1 */ + }; + VdbeOp *aOp; + sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(setCookie)); + aOp = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie, 0); + if( ONLY_IF_REALLOC_STRESS(aOp==0) ) break; + aOp[0].p1 = iDb; + aOp[1].p1 = iDb; + aOp[1].p2 = iCookie; + aOp[1].p3 = sqlite3Atoi(zRight); + aOp[1].p5 = 1; + if( iCookie==BTREE_SCHEMA_VERSION && (db->flags & SQLITE_Defensive)!=0 ){ + /* Do not allow the use of PRAGMA schema_version=VALUE in defensive + ** mode. Change the OP_SetCookie opcode into a no-op. */ + aOp[1].opcode = OP_Noop; + } + }else{ + /* Read the specified cookie value */ + static const VdbeOpList readCookie[] = { + { OP_Transaction, 0, 0, 0}, /* 0 */ + { OP_ReadCookie, 0, 1, 0}, /* 1 */ + { OP_ResultRow, 1, 1, 0} + }; + VdbeOp *aOp; + sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(readCookie)); + aOp = sqlite3VdbeAddOpList(v, ArraySize(readCookie),readCookie,0); + if( ONLY_IF_REALLOC_STRESS(aOp==0) ) break; + aOp[0].p1 = iDb; + aOp[1].p1 = iDb; + aOp[1].p3 = iCookie; + sqlite3VdbeReusable(v); + } + } + break; +#endif /* SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS */ + +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS + /* + ** PRAGMA compile_options + ** + ** Return the names of all compile-time options used in this build, + ** one option per row. + */ + case PragTyp_COMPILE_OPTIONS: { + int i = 0; + const char *zOpt; + pParse->nMem = 1; + while( (zOpt = sqlite3_compileoption_get(i++))!=0 ){ + sqlite3VdbeLoadString(v, 1, zOpt); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1); + } + sqlite3VdbeReusable(v); + } + break; +#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */ + +#ifndef SQLITE_OMIT_WAL + /* + ** PRAGMA [schema.]wal_checkpoint = passive|full|restart|truncate + ** + ** Checkpoint the database. + */ + case PragTyp_WAL_CHECKPOINT: { + int iBt = (pId2->z?iDb:SQLITE_MAX_DB); + int eMode = SQLITE_CHECKPOINT_PASSIVE; + if( zRight ){ + if( sqlite3StrICmp(zRight, "full")==0 ){ + eMode = SQLITE_CHECKPOINT_FULL; + }else if( sqlite3StrICmp(zRight, "restart")==0 ){ + eMode = SQLITE_CHECKPOINT_RESTART; + }else if( sqlite3StrICmp(zRight, "truncate")==0 ){ + eMode = SQLITE_CHECKPOINT_TRUNCATE; + } + } + pParse->nMem = 3; + sqlite3VdbeAddOp3(v, OP_Checkpoint, iBt, eMode, 1); + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3); + } + break; + + /* + ** PRAGMA wal_autocheckpoint + ** PRAGMA wal_autocheckpoint = N + ** + ** Configure a database connection to automatically checkpoint a database + ** after accumulating N frames in the log. Or query for the current value + ** of N. + */ + case PragTyp_WAL_AUTOCHECKPOINT: { + if( zRight ){ + sqlite3_wal_autocheckpoint(db, sqlite3Atoi(zRight)); + } + returnSingleInt(v, + db->xWalCallback==sqlite3WalDefaultHook ? + SQLITE_PTR_TO_INT(db->pWalArg) : 0); + } + break; +#endif + + /* + ** PRAGMA shrink_memory + ** + ** IMPLEMENTATION-OF: R-23445-46109 This pragma causes the database + ** connection on which it is invoked to free up as much memory as it + ** can, by calling sqlite3_db_release_memory(). + */ + case PragTyp_SHRINK_MEMORY: { + sqlite3_db_release_memory(db); + break; + } + + /* + ** PRAGMA optimize + ** PRAGMA optimize(MASK) + ** PRAGMA schema.optimize + ** PRAGMA schema.optimize(MASK) + ** + ** Attempt to optimize the database. All schemas are optimized in the first + ** two forms, and only the specified schema is optimized in the latter two. + ** + ** The details of optimizations performed by this pragma are expected + ** to change and improve over time. Applications should anticipate that + ** this pragma will perform new optimizations in future releases. + ** + ** The optional argument is a bitmask of optimizations to perform: + ** + ** 0x0001 Debugging mode. Do not actually perform any optimizations + ** but instead return one line of text for each optimization + ** that would have been done. Off by default. + ** + ** 0x0002 Run ANALYZE on tables that might benefit. On by default. + ** See below for additional information. + ** + ** 0x0004 (Not yet implemented) Record usage and performance + ** information from the current session in the + ** database file so that it will be available to "optimize" + ** pragmas run by future database connections. + ** + ** 0x0008 (Not yet implemented) Create indexes that might have + ** been helpful to recent queries + ** + ** The default MASK is and always shall be 0xfffe. 0xfffe means perform all + ** of the optimizations listed above except Debug Mode, including new + ** optimizations that have not yet been invented. If new optimizations are + ** ever added that should be off by default, those off-by-default + ** optimizations will have bitmasks of 0x10000 or larger. + ** + ** DETERMINATION OF WHEN TO RUN ANALYZE + ** + ** In the current implementation, a table is analyzed if only if all of + ** the following are true: + ** + ** (1) MASK bit 0x02 is set. + ** + ** (2) The query planner used sqlite_stat1-style statistics for one or + ** more indexes of the table at some point during the lifetime of + ** the current connection. + ** + ** (3) One or more indexes of the table are currently unanalyzed OR + ** the number of rows in the table has increased by 25 times or more + ** since the last time ANALYZE was run. + ** + ** The rules for when tables are analyzed are likely to change in + ** future releases. + */ + case PragTyp_OPTIMIZE: { + int iDbLast; /* Loop termination point for the schema loop */ + int iTabCur; /* Cursor for a table whose size needs checking */ + HashElem *k; /* Loop over tables of a schema */ + Schema *pSchema; /* The current schema */ + Table *pTab; /* A table in the schema */ + Index *pIdx; /* An index of the table */ + LogEst szThreshold; /* Size threshold above which reanalysis is needd */ + char *zSubSql; /* SQL statement for the OP_SqlExec opcode */ + u32 opMask; /* Mask of operations to perform */ + + if( zRight ){ + opMask = (u32)sqlite3Atoi(zRight); + if( (opMask & 0x02)==0 ) break; + }else{ + opMask = 0xfffe; + } + iTabCur = pParse->nTab++; + for(iDbLast = zDb?iDb:db->nDb-1; iDb<=iDbLast; iDb++){ + if( iDb==1 ) continue; + sqlite3CodeVerifySchema(pParse, iDb); + pSchema = db->aDb[iDb].pSchema; + for(k=sqliteHashFirst(&pSchema->tblHash); k; k=sqliteHashNext(k)){ + pTab = (Table*)sqliteHashData(k); + + /* If table pTab has not been used in a way that would benefit from + ** having analysis statistics during the current session, then skip it. + ** This also has the effect of skipping virtual tables and views */ + if( (pTab->tabFlags & TF_StatsUsed)==0 ) continue; + + /* Reanalyze if the table is 25 times larger than the last analysis */ + szThreshold = pTab->nRowLogEst + 46; assert( sqlite3LogEst(25)==46 ); + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + if( !pIdx->hasStat1 ){ + szThreshold = 0; /* Always analyze if any index lacks statistics */ + break; + } + } + if( szThreshold ){ + sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead); + sqlite3VdbeAddOp3(v, OP_IfSmaller, iTabCur, + sqlite3VdbeCurrentAddr(v)+2+(opMask&1), szThreshold); + VdbeCoverage(v); + } + zSubSql = sqlite3MPrintf(db, "ANALYZE \"%w\".\"%w\"", + db->aDb[iDb].zDbSName, pTab->zName); + if( opMask & 0x01 ){ + int r1 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp4(v, OP_String8, 0, r1, 0, zSubSql, P4_DYNAMIC); + sqlite3VdbeAddOp2(v, OP_ResultRow, r1, 1); + }else{ + sqlite3VdbeAddOp4(v, OP_SqlExec, 0, 0, 0, zSubSql, P4_DYNAMIC); + } + } + } + sqlite3VdbeAddOp0(v, OP_Expire); + break; + } + + /* + ** PRAGMA busy_timeout + ** PRAGMA busy_timeout = N + ** + ** Call sqlite3_busy_timeout(db, N). Return the current timeout value + ** if one is set. If no busy handler or a different busy handler is set + ** then 0 is returned. Setting the busy_timeout to 0 or negative + ** disables the timeout. + */ + /*case PragTyp_BUSY_TIMEOUT*/ default: { + assert( pPragma->ePragTyp==PragTyp_BUSY_TIMEOUT ); + if( zRight ){ + sqlite3_busy_timeout(db, sqlite3Atoi(zRight)); + } + returnSingleInt(v, db->busyTimeout); + break; + } + + /* + ** PRAGMA soft_heap_limit + ** PRAGMA soft_heap_limit = N + ** + ** IMPLEMENTATION-OF: R-26343-45930 This pragma invokes the + ** sqlite3_soft_heap_limit64() interface with the argument N, if N is + ** specified and is a non-negative integer. + ** IMPLEMENTATION-OF: R-64451-07163 The soft_heap_limit pragma always + ** returns the same integer that would be returned by the + ** sqlite3_soft_heap_limit64(-1) C-language function. + */ + case PragTyp_SOFT_HEAP_LIMIT: { + sqlite3_int64 N; + if( zRight && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK ){ + sqlite3_soft_heap_limit64(N); + } + returnSingleInt(v, sqlite3_soft_heap_limit64(-1)); + break; + } + + /* + ** PRAGMA hard_heap_limit + ** PRAGMA hard_heap_limit = N + ** + ** Invoke sqlite3_hard_heap_limit64() to query or set the hard heap + ** limit. The hard heap limit can be activated or lowered by this + ** pragma, but not raised or deactivated. Only the + ** sqlite3_hard_heap_limit64() C-language API can raise or deactivate + ** the hard heap limit. This allows an application to set a heap limit + ** constraint that cannot be relaxed by an untrusted SQL script. + */ + case PragTyp_HARD_HEAP_LIMIT: { + sqlite3_int64 N; + if( zRight && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK ){ + sqlite3_int64 iPrior = sqlite3_hard_heap_limit64(-1); + if( N>0 && (iPrior==0 || iPrior>N) ) sqlite3_hard_heap_limit64(N); + } + returnSingleInt(v, sqlite3_hard_heap_limit64(-1)); + break; + } + + /* + ** PRAGMA threads + ** PRAGMA threads = N + ** + ** Configure the maximum number of worker threads. Return the new + ** maximum, which might be less than requested. + */ + case PragTyp_THREADS: { + sqlite3_int64 N; + if( zRight + && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK + && N>=0 + ){ + sqlite3_limit(db, SQLITE_LIMIT_WORKER_THREADS, (int)(N&0x7fffffff)); + } + returnSingleInt(v, sqlite3_limit(db, SQLITE_LIMIT_WORKER_THREADS, -1)); + break; + } + + /* + ** PRAGMA analysis_limit + ** PRAGMA analysis_limit = N + ** + ** Configure the maximum number of rows that ANALYZE will examine + ** in each index that it looks at. Return the new limit. + */ + case PragTyp_ANALYSIS_LIMIT: { + sqlite3_int64 N; + if( zRight + && sqlite3DecOrHexToI64(zRight, &N)==SQLITE_OK /* IMP: R-40975-20399 */ + && N>=0 + ){ + db->nAnalysisLimit = (int)(N&0x7fffffff); + } + returnSingleInt(v, db->nAnalysisLimit); /* IMP: R-57594-65522 */ + break; + } + +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + /* + ** Report the current state of file logs for all databases + */ + case PragTyp_LOCK_STATUS: { + static const char *const azLockName[] = { + "unlocked", "shared", "reserved", "pending", "exclusive" + }; + int i; + pParse->nMem = 2; + for(i=0; inDb; i++){ + Btree *pBt; + const char *zState = "unknown"; + int j; + if( db->aDb[i].zDbSName==0 ) continue; + pBt = db->aDb[i].pBt; + if( pBt==0 || sqlite3BtreePager(pBt)==0 ){ + zState = "closed"; + }else if( sqlite3_file_control(db, i ? db->aDb[i].zDbSName : 0, + SQLITE_FCNTL_LOCKSTATE, &j)==SQLITE_OK ){ + zState = azLockName[j]; + } + sqlite3VdbeMultiLoad(v, 1, "ss", db->aDb[i].zDbSName, zState); + } + break; + } +#endif + +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC + /* Pragma iArg + ** ---------- ------ + ** key 0 + ** rekey 1 + ** hexkey 2 + ** hexrekey 3 + ** textkey 4 + ** textrekey 5 + */ + case PragTyp_KEY: { + if( zRight ){ + char zBuf[40]; + const char *zKey = zRight; + int n; + if( pPragma->iArg==2 || pPragma->iArg==3 ){ + u8 iByte; + int i; + for(i=0, iByte=0; iiArg<4 ? sqlite3Strlen30(zRight) : -1; + } + if( (pPragma->iArg & 1)==0 ){ + rc = sqlite3_key_v2(db, zDb, zKey, n); + }else{ + rc = sqlite3_rekey_v2(db, zDb, zKey, n); + } + if( rc==SQLITE_OK && n!=0 ){ + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "ok", SQLITE_STATIC); + returnSingleText(v, "ok"); + } else { + sqlite3ErrorMsg(pParse, "An error occurred with PRAGMA key or rekey. " + "PRAGMA key requires a key of one or more characters. " + "PRAGMA rekey can only be run on an existing encrypted database. " + "Use sqlcipher_export() and ATTACH to convert encrypted/plaintext databases."); + goto pragma_out; + } + } + break; + } +#endif +/* END SQLCIPHER */ +#if defined(SQLITE_ENABLE_CEROD) + case PragTyp_ACTIVATE_EXTENSIONS: if( zRight ){ + if( sqlite3StrNICmp(zRight, "cerod-", 6)==0 ){ + sqlite3_activate_cerod(&zRight[6]); + } + } + break; +#endif + + } /* End of the PRAGMA switch */ + + /* The following block is a no-op unless SQLITE_DEBUG is defined. Its only + ** purpose is to execute assert() statements to verify that if the + ** PragFlg_NoColumns1 flag is set and the caller specified an argument + ** to the PRAGMA, the implementation has not added any OP_ResultRow + ** instructions to the VM. */ + if( (pPragma->mPragFlg & PragFlg_NoColumns1) && zRight ){ + sqlite3VdbeVerifyNoResultRow(v); + } + +pragma_out: + sqlite3DbFree(db, zLeft); + sqlite3DbFree(db, zRight); +} +#ifndef SQLITE_OMIT_VIRTUALTABLE +/***************************************************************************** +** Implementation of an eponymous virtual table that runs a pragma. +** +*/ +typedef struct PragmaVtab PragmaVtab; +typedef struct PragmaVtabCursor PragmaVtabCursor; +struct PragmaVtab { + sqlite3_vtab base; /* Base class. Must be first */ + sqlite3 *db; /* The database connection to which it belongs */ + const PragmaName *pName; /* Name of the pragma */ + u8 nHidden; /* Number of hidden columns */ + u8 iHidden; /* Index of the first hidden column */ +}; +struct PragmaVtabCursor { + sqlite3_vtab_cursor base; /* Base class. Must be first */ + sqlite3_stmt *pPragma; /* The pragma statement to run */ + sqlite_int64 iRowid; /* Current rowid */ + char *azArg[2]; /* Value of the argument and schema */ +}; + +/* +** Pragma virtual table module xConnect method. +*/ +static int pragmaVtabConnect( + sqlite3 *db, + void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVtab, + char **pzErr +){ + const PragmaName *pPragma = (const PragmaName*)pAux; + PragmaVtab *pTab = 0; + int rc; + int i, j; + char cSep = '('; + StrAccum acc; + char zBuf[200]; + + UNUSED_PARAMETER(argc); + UNUSED_PARAMETER(argv); + sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0); + sqlite3_str_appendall(&acc, "CREATE TABLE x"); + for(i=0, j=pPragma->iPragCName; inPragCName; i++, j++){ + sqlite3_str_appendf(&acc, "%c\"%s\"", cSep, pragCName[j]); + cSep = ','; + } + if( i==0 ){ + sqlite3_str_appendf(&acc, "(\"%s\"", pPragma->zName); + i++; + } + j = 0; + if( pPragma->mPragFlg & PragFlg_Result1 ){ + sqlite3_str_appendall(&acc, ",arg HIDDEN"); + j++; + } + if( pPragma->mPragFlg & (PragFlg_SchemaOpt|PragFlg_SchemaReq) ){ + sqlite3_str_appendall(&acc, ",schema HIDDEN"); + j++; + } + sqlite3_str_append(&acc, ")", 1); + sqlite3StrAccumFinish(&acc); + assert( strlen(zBuf) < sizeof(zBuf)-1 ); + rc = sqlite3_declare_vtab(db, zBuf); + if( rc==SQLITE_OK ){ + pTab = (PragmaVtab*)sqlite3_malloc(sizeof(PragmaVtab)); + if( pTab==0 ){ + rc = SQLITE_NOMEM; + }else{ + memset(pTab, 0, sizeof(PragmaVtab)); + pTab->pName = pPragma; + pTab->db = db; + pTab->iHidden = i; + pTab->nHidden = j; + } + }else{ + *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + } + + *ppVtab = (sqlite3_vtab*)pTab; + return rc; +} + +/* +** Pragma virtual table module xDisconnect method. +*/ +static int pragmaVtabDisconnect(sqlite3_vtab *pVtab){ + PragmaVtab *pTab = (PragmaVtab*)pVtab; + sqlite3_free(pTab); + return SQLITE_OK; +} + +/* Figure out the best index to use to search a pragma virtual table. +** +** There are not really any index choices. But we want to encourage the +** query planner to give == constraints on as many hidden parameters as +** possible, and especially on the first hidden parameter. So return a +** high cost if hidden parameters are unconstrained. +*/ +static int pragmaVtabBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){ + PragmaVtab *pTab = (PragmaVtab*)tab; + const struct sqlite3_index_constraint *pConstraint; + int i, j; + int seen[2]; + + pIdxInfo->estimatedCost = (double)1; + if( pTab->nHidden==0 ){ return SQLITE_OK; } + pConstraint = pIdxInfo->aConstraint; + seen[0] = 0; + seen[1] = 0; + for(i=0; inConstraint; i++, pConstraint++){ + if( pConstraint->usable==0 ) continue; + if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue; + if( pConstraint->iColumn < pTab->iHidden ) continue; + j = pConstraint->iColumn - pTab->iHidden; + assert( j < 2 ); + seen[j] = i+1; + } + if( seen[0]==0 ){ + pIdxInfo->estimatedCost = (double)2147483647; + pIdxInfo->estimatedRows = 2147483647; + return SQLITE_OK; + } + j = seen[0]-1; + pIdxInfo->aConstraintUsage[j].argvIndex = 1; + pIdxInfo->aConstraintUsage[j].omit = 1; + if( seen[1]==0 ) return SQLITE_OK; + pIdxInfo->estimatedCost = (double)20; + pIdxInfo->estimatedRows = 20; + j = seen[1]-1; + pIdxInfo->aConstraintUsage[j].argvIndex = 2; + pIdxInfo->aConstraintUsage[j].omit = 1; + return SQLITE_OK; +} + +/* Create a new cursor for the pragma virtual table */ +static int pragmaVtabOpen(sqlite3_vtab *pVtab, sqlite3_vtab_cursor **ppCursor){ + PragmaVtabCursor *pCsr; + pCsr = (PragmaVtabCursor*)sqlite3_malloc(sizeof(*pCsr)); + if( pCsr==0 ) return SQLITE_NOMEM; + memset(pCsr, 0, sizeof(PragmaVtabCursor)); + pCsr->base.pVtab = pVtab; + *ppCursor = &pCsr->base; + return SQLITE_OK; +} + +/* Clear all content from pragma virtual table cursor. */ +static void pragmaVtabCursorClear(PragmaVtabCursor *pCsr){ + int i; + sqlite3_finalize(pCsr->pPragma); + pCsr->pPragma = 0; + for(i=0; iazArg); i++){ + sqlite3_free(pCsr->azArg[i]); + pCsr->azArg[i] = 0; + } +} + +/* Close a pragma virtual table cursor */ +static int pragmaVtabClose(sqlite3_vtab_cursor *cur){ + PragmaVtabCursor *pCsr = (PragmaVtabCursor*)cur; + pragmaVtabCursorClear(pCsr); + sqlite3_free(pCsr); + return SQLITE_OK; +} + +/* Advance the pragma virtual table cursor to the next row */ +static int pragmaVtabNext(sqlite3_vtab_cursor *pVtabCursor){ + PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor; + int rc = SQLITE_OK; + + /* Increment the xRowid value */ + pCsr->iRowid++; + assert( pCsr->pPragma ); + if( SQLITE_ROW!=sqlite3_step(pCsr->pPragma) ){ + rc = sqlite3_finalize(pCsr->pPragma); + pCsr->pPragma = 0; + pragmaVtabCursorClear(pCsr); + } + return rc; +} + +/* +** Pragma virtual table module xFilter method. +*/ +static int pragmaVtabFilter( + sqlite3_vtab_cursor *pVtabCursor, + int idxNum, const char *idxStr, + int argc, sqlite3_value **argv +){ + PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor; + PragmaVtab *pTab = (PragmaVtab*)(pVtabCursor->pVtab); + int rc; + int i, j; + StrAccum acc; + char *zSql; + + UNUSED_PARAMETER(idxNum); + UNUSED_PARAMETER(idxStr); + pragmaVtabCursorClear(pCsr); + j = (pTab->pName->mPragFlg & PragFlg_Result1)!=0 ? 0 : 1; + for(i=0; iazArg) ); + assert( pCsr->azArg[j]==0 ); + if( zText ){ + pCsr->azArg[j] = sqlite3_mprintf("%s", zText); + if( pCsr->azArg[j]==0 ){ + return SQLITE_NOMEM; + } + } + } + sqlite3StrAccumInit(&acc, 0, 0, 0, pTab->db->aLimit[SQLITE_LIMIT_SQL_LENGTH]); + sqlite3_str_appendall(&acc, "PRAGMA "); + if( pCsr->azArg[1] ){ + sqlite3_str_appendf(&acc, "%Q.", pCsr->azArg[1]); + } + sqlite3_str_appendall(&acc, pTab->pName->zName); + if( pCsr->azArg[0] ){ + sqlite3_str_appendf(&acc, "=%Q", pCsr->azArg[0]); + } + zSql = sqlite3StrAccumFinish(&acc); + if( zSql==0 ) return SQLITE_NOMEM; + rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pPragma, 0); + sqlite3_free(zSql); + if( rc!=SQLITE_OK ){ + pTab->base.zErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(pTab->db)); + return rc; + } + return pragmaVtabNext(pVtabCursor); +} + +/* +** Pragma virtual table module xEof method. +*/ +static int pragmaVtabEof(sqlite3_vtab_cursor *pVtabCursor){ + PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor; + return (pCsr->pPragma==0); +} + +/* The xColumn method simply returns the corresponding column from +** the PRAGMA. +*/ +static int pragmaVtabColumn( + sqlite3_vtab_cursor *pVtabCursor, + sqlite3_context *ctx, + int i +){ + PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor; + PragmaVtab *pTab = (PragmaVtab*)(pVtabCursor->pVtab); + if( iiHidden ){ + sqlite3_result_value(ctx, sqlite3_column_value(pCsr->pPragma, i)); + }else{ + sqlite3_result_text(ctx, pCsr->azArg[i-pTab->iHidden],-1,SQLITE_TRANSIENT); + } + return SQLITE_OK; +} + +/* +** Pragma virtual table module xRowid method. +*/ +static int pragmaVtabRowid(sqlite3_vtab_cursor *pVtabCursor, sqlite_int64 *p){ + PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor; + *p = pCsr->iRowid; + return SQLITE_OK; +} + +/* The pragma virtual table object */ +static const sqlite3_module pragmaVtabModule = { + 0, /* iVersion */ + 0, /* xCreate - create a table */ + pragmaVtabConnect, /* xConnect - connect to an existing table */ + pragmaVtabBestIndex, /* xBestIndex - Determine search strategy */ + pragmaVtabDisconnect, /* xDisconnect - Disconnect from a table */ + 0, /* xDestroy - Drop a table */ + pragmaVtabOpen, /* xOpen - open a cursor */ + pragmaVtabClose, /* xClose - close a cursor */ + pragmaVtabFilter, /* xFilter - configure scan constraints */ + pragmaVtabNext, /* xNext - advance a cursor */ + pragmaVtabEof, /* xEof */ + pragmaVtabColumn, /* xColumn - read data */ + pragmaVtabRowid, /* xRowid - read data */ + 0, /* xUpdate - write data */ + 0, /* xBegin - begin transaction */ + 0, /* xSync - sync transaction */ + 0, /* xCommit - commit transaction */ + 0, /* xRollback - rollback transaction */ + 0, /* xFindFunction - function overloading */ + 0, /* xRename - rename the table */ + 0, /* xSavepoint */ + 0, /* xRelease */ + 0, /* xRollbackTo */ + 0 /* xShadowName */ +}; + +/* +** Check to see if zTabName is really the name of a pragma. If it is, +** then register an eponymous virtual table for that pragma and return +** a pointer to the Module object for the new virtual table. +*/ +SQLITE_PRIVATE Module *sqlite3PragmaVtabRegister(sqlite3 *db, const char *zName){ + const PragmaName *pName; + assert( sqlite3_strnicmp(zName, "pragma_", 7)==0 ); + pName = pragmaLocate(zName+7); + if( pName==0 ) return 0; + if( (pName->mPragFlg & (PragFlg_Result0|PragFlg_Result1))==0 ) return 0; + assert( sqlite3HashFind(&db->aModule, zName)==0 ); + return sqlite3VtabCreateModule(db, zName, &pragmaVtabModule, (void*)pName, 0); +} + +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +#endif /* SQLITE_OMIT_PRAGMA */ + +/************** End of pragma.c **********************************************/ +/************** Begin file prepare.c *****************************************/ +/* +** 2005 May 25 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the implementation of the sqlite3_prepare() +** interface, and routines that contribute to loading the database schema +** from disk. +*/ +/* #include "sqliteInt.h" */ + +/* +** Fill the InitData structure with an error message that indicates +** that the database is corrupt. +*/ +static void corruptSchema( + InitData *pData, /* Initialization context */ + char **azObj, /* Type and name of object being parsed */ + const char *zExtra /* Error information */ +){ + sqlite3 *db = pData->db; + if( db->mallocFailed ){ + pData->rc = SQLITE_NOMEM_BKPT; + }else if( pData->pzErrMsg[0]!=0 ){ + /* A error message has already been generated. Do not overwrite it */ + }else if( pData->mInitFlags & (INITFLAG_AlterMask) ){ + static const char *azAlterType[] = { + "rename", + "drop column", + "add column" + }; + *pData->pzErrMsg = sqlite3MPrintf(db, + "error in %s %s after %s: %s", azObj[0], azObj[1], + azAlterType[(pData->mInitFlags&INITFLAG_AlterMask)-1], + zExtra + ); + pData->rc = SQLITE_ERROR; + }else if( db->flags & SQLITE_WriteSchema ){ + pData->rc = SQLITE_CORRUPT_BKPT; + }else{ + char *z; + const char *zObj = azObj[1] ? azObj[1] : "?"; + z = sqlite3MPrintf(db, "malformed database schema (%s)", zObj); + if( zExtra && zExtra[0] ) z = sqlite3MPrintf(db, "%z - %s", z, zExtra); + *pData->pzErrMsg = z; + pData->rc = SQLITE_CORRUPT_BKPT; + } +} + +/* +** Check to see if any sibling index (another index on the same table) +** of pIndex has the same root page number, and if it does, return true. +** This would indicate a corrupt schema. +*/ +SQLITE_PRIVATE int sqlite3IndexHasDuplicateRootPage(Index *pIndex){ + Index *p; + for(p=pIndex->pTable->pIndex; p; p=p->pNext){ + if( p->tnum==pIndex->tnum && p!=pIndex ) return 1; + } + return 0; +} + +/* forward declaration */ +static int sqlite3Prepare( + sqlite3 *db, /* Database handle. */ + const char *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ + Vdbe *pReprepare, /* VM being reprepared */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const char **pzTail /* OUT: End of parsed string */ +); + + +/* +** This is the callback routine for the code that initializes the +** database. See sqlite3Init() below for additional information. +** This routine is also called from the OP_ParseSchema opcode of the VDBE. +** +** Each callback contains the following information: +** +** argv[0] = type of object: "table", "index", "trigger", or "view". +** argv[1] = name of thing being created +** argv[2] = associated table if an index or trigger +** argv[3] = root page number for table or index. 0 for trigger or view. +** argv[4] = SQL text for the CREATE statement. +** +*/ +SQLITE_PRIVATE int sqlite3InitCallback(void *pInit, int argc, char **argv, char **NotUsed){ + InitData *pData = (InitData*)pInit; + sqlite3 *db = pData->db; + int iDb = pData->iDb; + + assert( argc==5 ); + UNUSED_PARAMETER2(NotUsed, argc); + assert( sqlite3_mutex_held(db->mutex) ); + db->mDbFlags |= DBFLAG_EncodingFixed; + if( argv==0 ) return 0; /* Might happen if EMPTY_RESULT_CALLBACKS are on */ + pData->nInitRow++; + if( db->mallocFailed ){ + corruptSchema(pData, argv, 0); + return 1; + } + + assert( iDb>=0 && iDbnDb ); + if( argv[3]==0 ){ + corruptSchema(pData, argv, 0); + }else if( argv[4] + && 'c'==sqlite3UpperToLower[(unsigned char)argv[4][0]] + && 'r'==sqlite3UpperToLower[(unsigned char)argv[4][1]] ){ + /* Call the parser to process a CREATE TABLE, INDEX or VIEW. + ** But because db->init.busy is set to 1, no VDBE code is generated + ** or executed. All the parser does is build the internal data + ** structures that describe the table, index, or view. + ** + ** No other valid SQL statement, other than the variable CREATE statements, + ** can begin with the letters "C" and "R". Thus, it is not possible run + ** any other kind of statement while parsing the schema, even a corrupt + ** schema. + */ + int rc; + u8 saved_iDb = db->init.iDb; + sqlite3_stmt *pStmt; + TESTONLY(int rcp); /* Return code from sqlite3_prepare() */ + + assert( db->init.busy ); + db->init.iDb = iDb; + if( sqlite3GetUInt32(argv[3], &db->init.newTnum)==0 + || (db->init.newTnum>pData->mxPage && pData->mxPage>0) + ){ + if( sqlite3Config.bExtraSchemaChecks ){ + corruptSchema(pData, argv, "invalid rootpage"); + } + } + db->init.orphanTrigger = 0; + db->init.azInit = (const char**)argv; + pStmt = 0; + TESTONLY(rcp = ) sqlite3Prepare(db, argv[4], -1, 0, 0, &pStmt, 0); + rc = db->errCode; + assert( (rc&0xFF)==(rcp&0xFF) ); + db->init.iDb = saved_iDb; + /* assert( saved_iDb==0 || (db->mDbFlags & DBFLAG_Vacuum)!=0 ); */ + if( SQLITE_OK!=rc ){ + if( db->init.orphanTrigger ){ + assert( iDb==1 ); + }else{ + if( rc > pData->rc ) pData->rc = rc; + if( rc==SQLITE_NOMEM ){ + sqlite3OomFault(db); + }else if( rc!=SQLITE_INTERRUPT && (rc&0xFF)!=SQLITE_LOCKED ){ + corruptSchema(pData, argv, sqlite3_errmsg(db)); + } + } + } + db->init.azInit = sqlite3StdType; /* Any array of string ptrs will do */ + sqlite3_finalize(pStmt); + }else if( argv[1]==0 || (argv[4]!=0 && argv[4][0]!=0) ){ + corruptSchema(pData, argv, 0); + }else{ + /* If the SQL column is blank it means this is an index that + ** was created to be the PRIMARY KEY or to fulfill a UNIQUE + ** constraint for a CREATE TABLE. The index should have already + ** been created when we processed the CREATE TABLE. All we have + ** to do here is record the root page number for that index. + */ + Index *pIndex; + pIndex = sqlite3FindIndex(db, argv[1], db->aDb[iDb].zDbSName); + if( pIndex==0 ){ + corruptSchema(pData, argv, "orphan index"); + }else + if( sqlite3GetUInt32(argv[3],&pIndex->tnum)==0 + || pIndex->tnum<2 + || pIndex->tnum>pData->mxPage + || sqlite3IndexHasDuplicateRootPage(pIndex) + ){ + if( sqlite3Config.bExtraSchemaChecks ){ + corruptSchema(pData, argv, "invalid rootpage"); + } + } + } + return 0; +} + +/* +** Attempt to read the database schema and initialize internal +** data structures for a single database file. The index of the +** database file is given by iDb. iDb==0 is used for the main +** database. iDb==1 should never be used. iDb>=2 is used for +** auxiliary databases. Return one of the SQLITE_ error codes to +** indicate success or failure. +*/ +SQLITE_PRIVATE int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFlags){ + int rc; + int i; +#ifndef SQLITE_OMIT_DEPRECATED + int size; +#endif + Db *pDb; + char const *azArg[6]; + int meta[5]; + InitData initData; + const char *zSchemaTabName; + int openedTransaction = 0; + int mask = ((db->mDbFlags & DBFLAG_EncodingFixed) | ~DBFLAG_EncodingFixed); + + assert( (db->mDbFlags & DBFLAG_SchemaKnownOk)==0 ); + assert( iDb>=0 && iDbnDb ); + assert( db->aDb[iDb].pSchema ); + assert( sqlite3_mutex_held(db->mutex) ); + assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) ); + + db->init.busy = 1; + + /* Construct the in-memory representation schema tables (sqlite_schema or + ** sqlite_temp_schema) by invoking the parser directly. The appropriate + ** table name will be inserted automatically by the parser so we can just + ** use the abbreviation "x" here. The parser will also automatically tag + ** the schema table as read-only. */ + azArg[0] = "table"; + azArg[1] = zSchemaTabName = SCHEMA_TABLE(iDb); + azArg[2] = azArg[1]; + azArg[3] = "1"; + azArg[4] = "CREATE TABLE x(type text,name text,tbl_name text," + "rootpage int,sql text)"; + azArg[5] = 0; + initData.db = db; + initData.iDb = iDb; + initData.rc = SQLITE_OK; + initData.pzErrMsg = pzErrMsg; + initData.mInitFlags = mFlags; + initData.nInitRow = 0; + initData.mxPage = 0; + sqlite3InitCallback(&initData, 5, (char **)azArg, 0); + db->mDbFlags &= mask; + if( initData.rc ){ + rc = initData.rc; + goto error_out; + } + + /* Create a cursor to hold the database open + */ + pDb = &db->aDb[iDb]; + if( pDb->pBt==0 ){ + assert( iDb==1 ); + DbSetProperty(db, 1, DB_SchemaLoaded); + rc = SQLITE_OK; + goto error_out; + } + + /* If there is not already a read-only (or read-write) transaction opened + ** on the b-tree database, open one now. If a transaction is opened, it + ** will be closed before this function returns. */ + sqlite3BtreeEnter(pDb->pBt); + if( sqlite3BtreeTxnState(pDb->pBt)==SQLITE_TXN_NONE ){ + rc = sqlite3BtreeBeginTrans(pDb->pBt, 0, 0); + if( rc!=SQLITE_OK ){ + sqlite3SetString(pzErrMsg, db, sqlite3ErrStr(rc)); + goto initone_error_out; + } + openedTransaction = 1; + } + + /* Get the database meta information. + ** + ** Meta values are as follows: + ** meta[0] Schema cookie. Changes with each schema change. + ** meta[1] File format of schema layer. + ** meta[2] Size of the page cache. + ** meta[3] Largest rootpage (auto/incr_vacuum mode) + ** meta[4] Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE + ** meta[5] User version + ** meta[6] Incremental vacuum mode + ** meta[7] unused + ** meta[8] unused + ** meta[9] unused + ** + ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to + ** the possible values of meta[4]. + */ + for(i=0; ipBt, i+1, (u32 *)&meta[i]); + } + if( (db->flags & SQLITE_ResetDatabase)!=0 ){ + memset(meta, 0, sizeof(meta)); + } + pDb->pSchema->schema_cookie = meta[BTREE_SCHEMA_VERSION-1]; + + /* If opening a non-empty database, check the text encoding. For the + ** main database, set sqlite3.enc to the encoding of the main database. + ** For an attached db, it is an error if the encoding is not the same + ** as sqlite3.enc. + */ + if( meta[BTREE_TEXT_ENCODING-1] ){ /* text encoding */ + if( iDb==0 && (db->mDbFlags & DBFLAG_EncodingFixed)==0 ){ + u8 encoding; +#ifndef SQLITE_OMIT_UTF16 + /* If opening the main database, set ENC(db). */ + encoding = (u8)meta[BTREE_TEXT_ENCODING-1] & 3; + if( encoding==0 ) encoding = SQLITE_UTF8; +#else + encoding = SQLITE_UTF8; +#endif + if( db->nVdbeActive>0 && encoding!=ENC(db) + && (db->mDbFlags & DBFLAG_Vacuum)==0 + ){ + rc = SQLITE_LOCKED; + goto initone_error_out; + }else{ + sqlite3SetTextEncoding(db, encoding); + } + }else{ + /* If opening an attached database, the encoding much match ENC(db) */ + if( (meta[BTREE_TEXT_ENCODING-1] & 3)!=ENC(db) ){ + sqlite3SetString(pzErrMsg, db, "attached databases must use the same" + " text encoding as main database"); + rc = SQLITE_ERROR; + goto initone_error_out; + } + } + } + pDb->pSchema->enc = ENC(db); + + if( pDb->pSchema->cache_size==0 ){ +#ifndef SQLITE_OMIT_DEPRECATED + size = sqlite3AbsInt32(meta[BTREE_DEFAULT_CACHE_SIZE-1]); + if( size==0 ){ size = SQLITE_DEFAULT_CACHE_SIZE; } + pDb->pSchema->cache_size = size; +#else + pDb->pSchema->cache_size = SQLITE_DEFAULT_CACHE_SIZE; +#endif + sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size); + } + + /* + ** file_format==1 Version 3.0.0. + ** file_format==2 Version 3.1.3. // ALTER TABLE ADD COLUMN + ** file_format==3 Version 3.1.4. // ditto but with non-NULL defaults + ** file_format==4 Version 3.3.0. // DESC indices. Boolean constants + */ + pDb->pSchema->file_format = (u8)meta[BTREE_FILE_FORMAT-1]; + if( pDb->pSchema->file_format==0 ){ + pDb->pSchema->file_format = 1; + } + if( pDb->pSchema->file_format>SQLITE_MAX_FILE_FORMAT ){ + sqlite3SetString(pzErrMsg, db, "unsupported file format"); + rc = SQLITE_ERROR; + goto initone_error_out; + } + + /* Ticket #2804: When we open a database in the newer file format, + ** clear the legacy_file_format pragma flag so that a VACUUM will + ** not downgrade the database and thus invalidate any descending + ** indices that the user might have created. + */ + if( iDb==0 && meta[BTREE_FILE_FORMAT-1]>=4 ){ + db->flags &= ~(u64)SQLITE_LegacyFileFmt; + } + + /* Read the schema information out of the schema tables + */ + assert( db->init.busy ); + initData.mxPage = sqlite3BtreeLastPage(pDb->pBt); + { + char *zSql; + zSql = sqlite3MPrintf(db, + "SELECT*FROM\"%w\".%s ORDER BY rowid", + db->aDb[iDb].zDbSName, zSchemaTabName); +#ifndef SQLITE_OMIT_AUTHORIZATION + { + sqlite3_xauth xAuth; + xAuth = db->xAuth; + db->xAuth = 0; +#endif + rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0); +#ifndef SQLITE_OMIT_AUTHORIZATION + db->xAuth = xAuth; + } +#endif + if( rc==SQLITE_OK ) rc = initData.rc; + sqlite3DbFree(db, zSql); +#ifndef SQLITE_OMIT_ANALYZE + if( rc==SQLITE_OK ){ + sqlite3AnalysisLoad(db, iDb); + } +#endif + } + assert( pDb == &(db->aDb[iDb]) ); + if( db->mallocFailed ){ + rc = SQLITE_NOMEM_BKPT; + sqlite3ResetAllSchemasOfConnection(db); + pDb = &db->aDb[iDb]; + }else + if( rc==SQLITE_OK || ((db->flags&SQLITE_NoSchemaError) && rc!=SQLITE_NOMEM)){ + /* Hack: If the SQLITE_NoSchemaError flag is set, then consider + ** the schema loaded, even if errors (other than OOM) occurred. In + ** this situation the current sqlite3_prepare() operation will fail, + ** but the following one will attempt to compile the supplied statement + ** against whatever subset of the schema was loaded before the error + ** occurred. + ** + ** The primary purpose of this is to allow access to the sqlite_schema + ** table even when its contents have been corrupted. + */ + DbSetProperty(db, iDb, DB_SchemaLoaded); + rc = SQLITE_OK; + } + + /* Jump here for an error that occurs after successfully allocating + ** curMain and calling sqlite3BtreeEnter(). For an error that occurs + ** before that point, jump to error_out. + */ +initone_error_out: + if( openedTransaction ){ + sqlite3BtreeCommit(pDb->pBt); + } + sqlite3BtreeLeave(pDb->pBt); + +error_out: + if( rc ){ + if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){ + sqlite3OomFault(db); + } + sqlite3ResetOneSchema(db, iDb); + } + db->init.busy = 0; + return rc; +} + +/* +** Initialize all database files - the main database file, the file +** used to store temporary tables, and any additional database files +** created using ATTACH statements. Return a success code. If an +** error occurs, write an error message into *pzErrMsg. +** +** After a database is initialized, the DB_SchemaLoaded bit is set +** bit is set in the flags field of the Db structure. +*/ +SQLITE_PRIVATE int sqlite3Init(sqlite3 *db, char **pzErrMsg){ + int i, rc; + int commit_internal = !(db->mDbFlags&DBFLAG_SchemaChange); + + assert( sqlite3_mutex_held(db->mutex) ); + assert( sqlite3BtreeHoldsMutex(db->aDb[0].pBt) ); + assert( db->init.busy==0 ); + ENC(db) = SCHEMA_ENC(db); + assert( db->nDb>0 ); + /* Do the main schema first */ + if( !DbHasProperty(db, 0, DB_SchemaLoaded) ){ + rc = sqlite3InitOne(db, 0, pzErrMsg, 0); + if( rc ) return rc; + } + /* All other schemas after the main schema. The "temp" schema must be last */ + for(i=db->nDb-1; i>0; i--){ + assert( i==1 || sqlite3BtreeHoldsMutex(db->aDb[i].pBt) ); + if( !DbHasProperty(db, i, DB_SchemaLoaded) ){ + rc = sqlite3InitOne(db, i, pzErrMsg, 0); + if( rc ) return rc; + } + } + if( commit_internal ){ + sqlite3CommitInternalChanges(db); + } + return SQLITE_OK; +} + +/* +** This routine is a no-op if the database schema is already initialized. +** Otherwise, the schema is loaded. An error code is returned. +*/ +SQLITE_PRIVATE int sqlite3ReadSchema(Parse *pParse){ + int rc = SQLITE_OK; + sqlite3 *db = pParse->db; + assert( sqlite3_mutex_held(db->mutex) ); + if( !db->init.busy ){ + rc = sqlite3Init(db, &pParse->zErrMsg); + if( rc!=SQLITE_OK ){ + pParse->rc = rc; + pParse->nErr++; + }else if( db->noSharedCache ){ + db->mDbFlags |= DBFLAG_SchemaKnownOk; + } + } + return rc; +} + + +/* +** Check schema cookies in all databases. If any cookie is out +** of date set pParse->rc to SQLITE_SCHEMA. If all schema cookies +** make no changes to pParse->rc. +*/ +static void schemaIsValid(Parse *pParse){ + sqlite3 *db = pParse->db; + int iDb; + int rc; + int cookie; + + assert( pParse->checkSchema ); + assert( sqlite3_mutex_held(db->mutex) ); + for(iDb=0; iDbnDb; iDb++){ + int openedTransaction = 0; /* True if a transaction is opened */ + Btree *pBt = db->aDb[iDb].pBt; /* Btree database to read cookie from */ + if( pBt==0 ) continue; + + /* If there is not already a read-only (or read-write) transaction opened + ** on the b-tree database, open one now. If a transaction is opened, it + ** will be closed immediately after reading the meta-value. */ + if( sqlite3BtreeTxnState(pBt)==SQLITE_TXN_NONE ){ + rc = sqlite3BtreeBeginTrans(pBt, 0, 0); + if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){ + sqlite3OomFault(db); + pParse->rc = SQLITE_NOMEM; + } + if( rc!=SQLITE_OK ) return; + openedTransaction = 1; + } + + /* Read the schema cookie from the database. If it does not match the + ** value stored as part of the in-memory schema representation, + ** set Parse.rc to SQLITE_SCHEMA. */ + sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&cookie); + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + if( cookie!=db->aDb[iDb].pSchema->schema_cookie ){ + if( DbHasProperty(db, iDb, DB_SchemaLoaded) ) pParse->rc = SQLITE_SCHEMA; + sqlite3ResetOneSchema(db, iDb); + } + + /* Close the transaction, if one was opened. */ + if( openedTransaction ){ + sqlite3BtreeCommit(pBt); + } + } +} + +/* +** Convert a schema pointer into the iDb index that indicates +** which database file in db->aDb[] the schema refers to. +** +** If the same database is attached more than once, the first +** attached database is returned. +*/ +SQLITE_PRIVATE int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){ + int i = -32768; + + /* If pSchema is NULL, then return -32768. This happens when code in + ** expr.c is trying to resolve a reference to a transient table (i.e. one + ** created by a sub-select). In this case the return value of this + ** function should never be used. + ** + ** We return -32768 instead of the more usual -1 simply because using + ** -32768 as the incorrect index into db->aDb[] is much + ** more likely to cause a segfault than -1 (of course there are assert() + ** statements too, but it never hurts to play the odds) and + ** -32768 will still fit into a 16-bit signed integer. + */ + assert( sqlite3_mutex_held(db->mutex) ); + if( pSchema ){ + for(i=0; 1; i++){ + assert( inDb ); + if( db->aDb[i].pSchema==pSchema ){ + break; + } + } + assert( i>=0 && inDb ); + } + return i; +} + +/* +** Free all memory allocations in the pParse object +*/ +SQLITE_PRIVATE void sqlite3ParseObjectReset(Parse *pParse){ + sqlite3 *db = pParse->db; + assert( db!=0 ); + assert( db->pParse==pParse ); + assert( pParse->nested==0 ); +#ifndef SQLITE_OMIT_SHARED_CACHE + if( pParse->aTableLock ) sqlite3DbNNFreeNN(db, pParse->aTableLock); +#endif + while( pParse->pCleanup ){ + ParseCleanup *pCleanup = pParse->pCleanup; + pParse->pCleanup = pCleanup->pNext; + pCleanup->xCleanup(db, pCleanup->pPtr); + sqlite3DbNNFreeNN(db, pCleanup); + } + if( pParse->aLabel ) sqlite3DbNNFreeNN(db, pParse->aLabel); + if( pParse->pConstExpr ){ + sqlite3ExprListDelete(db, pParse->pConstExpr); + } + assert( db->lookaside.bDisable >= pParse->disableLookaside ); + db->lookaside.bDisable -= pParse->disableLookaside; + db->lookaside.sz = db->lookaside.bDisable ? 0 : db->lookaside.szTrue; + assert( pParse->db->pParse==pParse ); + db->pParse = pParse->pOuterParse; + pParse->db = 0; + pParse->disableLookaside = 0; +} + +/* +** Add a new cleanup operation to a Parser. The cleanup should happen when +** the parser object is destroyed. But, beware: the cleanup might happen +** immediately. +** +** Use this mechanism for uncommon cleanups. There is a higher setup +** cost for this mechansim (an extra malloc), so it should not be used +** for common cleanups that happen on most calls. But for less +** common cleanups, we save a single NULL-pointer comparison in +** sqlite3ParseObjectReset(), which reduces the total CPU cycle count. +** +** If a memory allocation error occurs, then the cleanup happens immediately. +** When either SQLITE_DEBUG or SQLITE_COVERAGE_TEST are defined, the +** pParse->earlyCleanup flag is set in that case. Calling code show verify +** that test cases exist for which this happens, to guard against possible +** use-after-free errors following an OOM. The preferred way to do this is +** to immediately follow the call to this routine with: +** +** testcase( pParse->earlyCleanup ); +** +** This routine returns a copy of its pPtr input (the third parameter) +** except if an early cleanup occurs, in which case it returns NULL. So +** another way to check for early cleanup is to check the return value. +** Or, stop using the pPtr parameter with this call and use only its +** return value thereafter. Something like this: +** +** pObj = sqlite3ParserAddCleanup(pParse, destructor, pObj); +*/ +SQLITE_PRIVATE void *sqlite3ParserAddCleanup( + Parse *pParse, /* Destroy when this Parser finishes */ + void (*xCleanup)(sqlite3*,void*), /* The cleanup routine */ + void *pPtr /* Pointer to object to be cleaned up */ +){ + ParseCleanup *pCleanup = sqlite3DbMallocRaw(pParse->db, sizeof(*pCleanup)); + if( pCleanup ){ + pCleanup->pNext = pParse->pCleanup; + pParse->pCleanup = pCleanup; + pCleanup->pPtr = pPtr; + pCleanup->xCleanup = xCleanup; + }else{ + xCleanup(pParse->db, pPtr); + pPtr = 0; +#if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST) + pParse->earlyCleanup = 1; +#endif + } + return pPtr; +} + +/* +** Turn bulk memory into a valid Parse object and link that Parse object +** into database connection db. +** +** Call sqlite3ParseObjectReset() to undo this operation. +** +** Caution: Do not confuse this routine with sqlite3ParseObjectInit() which +** is generated by Lemon. +*/ +SQLITE_PRIVATE void sqlite3ParseObjectInit(Parse *pParse, sqlite3 *db){ + memset(PARSE_HDR(pParse), 0, PARSE_HDR_SZ); + memset(PARSE_TAIL(pParse), 0, PARSE_TAIL_SZ); + assert( db->pParse!=pParse ); + pParse->pOuterParse = db->pParse; + db->pParse = pParse; + pParse->db = db; + if( db->mallocFailed ) sqlite3ErrorMsg(pParse, "out of memory"); +} + +/* +** Maximum number of times that we will try again to prepare a statement +** that returns SQLITE_ERROR_RETRY. +*/ +#ifndef SQLITE_MAX_PREPARE_RETRY +# define SQLITE_MAX_PREPARE_RETRY 25 +#endif + +/* +** Compile the UTF-8 encoded SQL statement zSql into a statement handle. +*/ +static int sqlite3Prepare( + sqlite3 *db, /* Database handle. */ + const char *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ + Vdbe *pReprepare, /* VM being reprepared */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const char **pzTail /* OUT: End of parsed string */ +){ + int rc = SQLITE_OK; /* Result code */ + int i; /* Loop counter */ + Parse sParse; /* Parsing context */ + + /* sqlite3ParseObjectInit(&sParse, db); // inlined for performance */ + memset(PARSE_HDR(&sParse), 0, PARSE_HDR_SZ); + memset(PARSE_TAIL(&sParse), 0, PARSE_TAIL_SZ); + sParse.pOuterParse = db->pParse; + db->pParse = &sParse; + sParse.db = db; + sParse.pReprepare = pReprepare; + assert( ppStmt && *ppStmt==0 ); + if( db->mallocFailed ){ + sqlite3ErrorMsg(&sParse, "out of memory"); + db->errCode = rc = SQLITE_NOMEM; + goto end_prepare; + } + assert( sqlite3_mutex_held(db->mutex) ); + + /* For a long-term use prepared statement avoid the use of + ** lookaside memory. + */ + if( prepFlags & SQLITE_PREPARE_PERSISTENT ){ + sParse.disableLookaside++; + DisableLookaside; + } + sParse.prepFlags = prepFlags & 0xff; + + /* Check to verify that it is possible to get a read lock on all + ** database schemas. The inability to get a read lock indicates that + ** some other database connection is holding a write-lock, which in + ** turn means that the other connection has made uncommitted changes + ** to the schema. + ** + ** Were we to proceed and prepare the statement against the uncommitted + ** schema changes and if those schema changes are subsequently rolled + ** back and different changes are made in their place, then when this + ** prepared statement goes to run the schema cookie would fail to detect + ** the schema change. Disaster would follow. + ** + ** This thread is currently holding mutexes on all Btrees (because + ** of the sqlite3BtreeEnterAll() in sqlite3LockAndPrepare()) so it + ** is not possible for another thread to start a new schema change + ** while this routine is running. Hence, we do not need to hold + ** locks on the schema, we just need to make sure nobody else is + ** holding them. + ** + ** Note that setting READ_UNCOMMITTED overrides most lock detection, + ** but it does *not* override schema lock detection, so this all still + ** works even if READ_UNCOMMITTED is set. + */ + if( !db->noSharedCache ){ + for(i=0; inDb; i++) { + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + assert( sqlite3BtreeHoldsMutex(pBt) ); + rc = sqlite3BtreeSchemaLocked(pBt); + if( rc ){ + const char *zDb = db->aDb[i].zDbSName; + sqlite3ErrorWithMsg(db, rc, "database schema is locked: %s", zDb); + testcase( db->flags & SQLITE_ReadUncommit ); + goto end_prepare; + } + } + } + } + +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( db->pDisconnect ) sqlite3VtabUnlockList(db); +#endif + + if( nBytes>=0 && (nBytes==0 || zSql[nBytes-1]!=0) ){ + char *zSqlCopy; + int mxLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH]; + testcase( nBytes==mxLen ); + testcase( nBytes==mxLen+1 ); + if( nBytes>mxLen ){ + sqlite3ErrorWithMsg(db, SQLITE_TOOBIG, "statement too long"); + rc = sqlite3ApiExit(db, SQLITE_TOOBIG); + goto end_prepare; + } + zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes); + if( zSqlCopy ){ + sqlite3RunParser(&sParse, zSqlCopy); + sParse.zTail = &zSql[sParse.zTail-zSqlCopy]; + sqlite3DbFree(db, zSqlCopy); + }else{ + sParse.zTail = &zSql[nBytes]; + } + }else{ + sqlite3RunParser(&sParse, zSql); + } + assert( 0==sParse.nQueryLoop ); + + if( pzTail ){ + *pzTail = sParse.zTail; + } + + if( db->init.busy==0 ){ + sqlite3VdbeSetSql(sParse.pVdbe, zSql, (int)(sParse.zTail-zSql), prepFlags); + } + if( db->mallocFailed ){ + sParse.rc = SQLITE_NOMEM_BKPT; + sParse.checkSchema = 0; + } + if( sParse.rc!=SQLITE_OK && sParse.rc!=SQLITE_DONE ){ + if( sParse.checkSchema && db->init.busy==0 ){ + schemaIsValid(&sParse); + } + if( sParse.pVdbe ){ + sqlite3VdbeFinalize(sParse.pVdbe); + } + assert( 0==(*ppStmt) ); + rc = sParse.rc; + if( sParse.zErrMsg ){ + sqlite3ErrorWithMsg(db, rc, "%s", sParse.zErrMsg); + sqlite3DbFree(db, sParse.zErrMsg); + }else{ + sqlite3Error(db, rc); + } + }else{ + assert( sParse.zErrMsg==0 ); + *ppStmt = (sqlite3_stmt*)sParse.pVdbe; + rc = SQLITE_OK; + sqlite3ErrorClear(db); + } + + + /* Delete any TriggerPrg structures allocated while parsing this statement. */ + while( sParse.pTriggerPrg ){ + TriggerPrg *pT = sParse.pTriggerPrg; + sParse.pTriggerPrg = pT->pNext; + sqlite3DbFree(db, pT); + } + +end_prepare: + + sqlite3ParseObjectReset(&sParse); + return rc; +} +static int sqlite3LockAndPrepare( + sqlite3 *db, /* Database handle. */ + const char *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ + Vdbe *pOld, /* VM being reprepared */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const char **pzTail /* OUT: End of parsed string */ +){ + int rc; + int cnt = 0; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( ppStmt==0 ) return SQLITE_MISUSE_BKPT; +#endif + *ppStmt = 0; + if( !sqlite3SafetyCheckOk(db)||zSql==0 ){ + return SQLITE_MISUSE_BKPT; + } + sqlite3_mutex_enter(db->mutex); + sqlite3BtreeEnterAll(db); + do{ + /* Make multiple attempts to compile the SQL, until it either succeeds + ** or encounters a permanent error. A schema problem after one schema + ** reset is considered a permanent error. */ + rc = sqlite3Prepare(db, zSql, nBytes, prepFlags, pOld, ppStmt, pzTail); + assert( rc==SQLITE_OK || *ppStmt==0 ); + if( rc==SQLITE_OK || db->mallocFailed ) break; + }while( (rc==SQLITE_ERROR_RETRY && (cnt++)errMask)==rc ); + db->busyHandler.nBusy = 0; + sqlite3_mutex_leave(db->mutex); + return rc; +} + + +/* +** Rerun the compilation of a statement after a schema change. +** +** If the statement is successfully recompiled, return SQLITE_OK. Otherwise, +** if the statement cannot be recompiled because another connection has +** locked the sqlite3_schema table, return SQLITE_LOCKED. If any other error +** occurs, return SQLITE_SCHEMA. +*/ +SQLITE_PRIVATE int sqlite3Reprepare(Vdbe *p){ + int rc; + sqlite3_stmt *pNew; + const char *zSql; + sqlite3 *db; + u8 prepFlags; + + assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) ); + zSql = sqlite3_sql((sqlite3_stmt *)p); + assert( zSql!=0 ); /* Reprepare only called for prepare_v2() statements */ + db = sqlite3VdbeDb(p); + assert( sqlite3_mutex_held(db->mutex) ); + prepFlags = sqlite3VdbePrepareFlags(p); + rc = sqlite3LockAndPrepare(db, zSql, -1, prepFlags, p, &pNew, 0); + if( rc ){ + if( rc==SQLITE_NOMEM ){ + sqlite3OomFault(db); + } + assert( pNew==0 ); + return rc; + }else{ + assert( pNew!=0 ); + } + sqlite3VdbeSwap((Vdbe*)pNew, p); + sqlite3TransferBindings(pNew, (sqlite3_stmt*)p); + sqlite3VdbeResetStepResult((Vdbe*)pNew); + sqlite3VdbeFinalize((Vdbe*)pNew); + return SQLITE_OK; +} + + +/* +** Two versions of the official API. Legacy and new use. In the legacy +** version, the original SQL text is not saved in the prepared statement +** and so if a schema change occurs, SQLITE_SCHEMA is returned by +** sqlite3_step(). In the new version, the original SQL text is retained +** and the statement is automatically recompiled if an schema change +** occurs. +*/ +SQLITE_API int sqlite3_prepare( + sqlite3 *db, /* Database handle. */ + const char *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const char **pzTail /* OUT: End of parsed string */ +){ + int rc; + rc = sqlite3LockAndPrepare(db,zSql,nBytes,0,0,ppStmt,pzTail); + assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ + return rc; +} +SQLITE_API int sqlite3_prepare_v2( + sqlite3 *db, /* Database handle. */ + const char *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const char **pzTail /* OUT: End of parsed string */ +){ + int rc; + /* EVIDENCE-OF: R-37923-12173 The sqlite3_prepare_v2() interface works + ** exactly the same as sqlite3_prepare_v3() with a zero prepFlags + ** parameter. + ** + ** Proof in that the 5th parameter to sqlite3LockAndPrepare is 0 */ + rc = sqlite3LockAndPrepare(db,zSql,nBytes,SQLITE_PREPARE_SAVESQL,0, + ppStmt,pzTail); + assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); + return rc; +} +SQLITE_API int sqlite3_prepare_v3( + sqlite3 *db, /* Database handle. */ + const char *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const char **pzTail /* OUT: End of parsed string */ +){ + int rc; + /* EVIDENCE-OF: R-56861-42673 sqlite3_prepare_v3() differs from + ** sqlite3_prepare_v2() only in having the extra prepFlags parameter, + ** which is a bit array consisting of zero or more of the + ** SQLITE_PREPARE_* flags. + ** + ** Proof by comparison to the implementation of sqlite3_prepare_v2() + ** directly above. */ + rc = sqlite3LockAndPrepare(db,zSql,nBytes, + SQLITE_PREPARE_SAVESQL|(prepFlags&SQLITE_PREPARE_MASK), + 0,ppStmt,pzTail); + assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); + return rc; +} + + +#ifndef SQLITE_OMIT_UTF16 +/* +** Compile the UTF-16 encoded SQL statement zSql into a statement handle. +*/ +static int sqlite3Prepare16( + sqlite3 *db, /* Database handle. */ + const void *zSql, /* UTF-16 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const void **pzTail /* OUT: End of parsed string */ +){ + /* This function currently works by first transforming the UTF-16 + ** encoded string to UTF-8, then invoking sqlite3_prepare(). The + ** tricky bit is figuring out the pointer to return in *pzTail. + */ + char *zSql8; + const char *zTail8 = 0; + int rc = SQLITE_OK; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( ppStmt==0 ) return SQLITE_MISUSE_BKPT; +#endif + *ppStmt = 0; + if( !sqlite3SafetyCheckOk(db)||zSql==0 ){ + return SQLITE_MISUSE_BKPT; + } + if( nBytes>=0 ){ + int sz; + const char *z = (const char*)zSql; + for(sz=0; szmutex); + zSql8 = sqlite3Utf16to8(db, zSql, nBytes, SQLITE_UTF16NATIVE); + if( zSql8 ){ + rc = sqlite3LockAndPrepare(db, zSql8, -1, prepFlags, 0, ppStmt, &zTail8); + } + + if( zTail8 && pzTail ){ + /* If sqlite3_prepare returns a tail pointer, we calculate the + ** equivalent pointer into the UTF-16 string by counting the unicode + ** characters between zSql8 and zTail8, and then returning a pointer + ** the same number of characters into the UTF-16 string. + */ + int chars_parsed = sqlite3Utf8CharLen(zSql8, (int)(zTail8-zSql8)); + *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed); + } + sqlite3DbFree(db, zSql8); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Two versions of the official API. Legacy and new use. In the legacy +** version, the original SQL text is not saved in the prepared statement +** and so if a schema change occurs, SQLITE_SCHEMA is returned by +** sqlite3_step(). In the new version, the original SQL text is retained +** and the statement is automatically recompiled if an schema change +** occurs. +*/ +SQLITE_API int sqlite3_prepare16( + sqlite3 *db, /* Database handle. */ + const void *zSql, /* UTF-16 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const void **pzTail /* OUT: End of parsed string */ +){ + int rc; + rc = sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail); + assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ + return rc; +} +SQLITE_API int sqlite3_prepare16_v2( + sqlite3 *db, /* Database handle. */ + const void *zSql, /* UTF-16 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const void **pzTail /* OUT: End of parsed string */ +){ + int rc; + rc = sqlite3Prepare16(db,zSql,nBytes,SQLITE_PREPARE_SAVESQL,ppStmt,pzTail); + assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ + return rc; +} +SQLITE_API int sqlite3_prepare16_v3( + sqlite3 *db, /* Database handle. */ + const void *zSql, /* UTF-16 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const void **pzTail /* OUT: End of parsed string */ +){ + int rc; + rc = sqlite3Prepare16(db,zSql,nBytes, + SQLITE_PREPARE_SAVESQL|(prepFlags&SQLITE_PREPARE_MASK), + ppStmt,pzTail); + assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ + return rc; +} + +#endif /* SQLITE_OMIT_UTF16 */ + +/************** End of prepare.c *********************************************/ +/************** Begin file select.c ******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that are called by the parser +** to handle SELECT statements in SQLite. +*/ +/* #include "sqliteInt.h" */ + +/* +** An instance of the following object is used to record information about +** how to process the DISTINCT keyword, to simplify passing that information +** into the selectInnerLoop() routine. +*/ +typedef struct DistinctCtx DistinctCtx; +struct DistinctCtx { + u8 isTnct; /* 0: Not distinct. 1: DISTICT 2: DISTINCT and ORDER BY */ + u8 eTnctType; /* One of the WHERE_DISTINCT_* operators */ + int tabTnct; /* Ephemeral table used for DISTINCT processing */ + int addrTnct; /* Address of OP_OpenEphemeral opcode for tabTnct */ +}; + +/* +** An instance of the following object is used to record information about +** the ORDER BY (or GROUP BY) clause of query is being coded. +** +** The aDefer[] array is used by the sorter-references optimization. For +** example, assuming there is no index that can be used for the ORDER BY, +** for the query: +** +** SELECT a, bigblob FROM t1 ORDER BY a LIMIT 10; +** +** it may be more efficient to add just the "a" values to the sorter, and +** retrieve the associated "bigblob" values directly from table t1 as the +** 10 smallest "a" values are extracted from the sorter. +** +** When the sorter-reference optimization is used, there is one entry in the +** aDefer[] array for each database table that may be read as values are +** extracted from the sorter. +*/ +typedef struct SortCtx SortCtx; +struct SortCtx { + ExprList *pOrderBy; /* The ORDER BY (or GROUP BY clause) */ + int nOBSat; /* Number of ORDER BY terms satisfied by indices */ + int iECursor; /* Cursor number for the sorter */ + int regReturn; /* Register holding block-output return address */ + int labelBkOut; /* Start label for the block-output subroutine */ + int addrSortIndex; /* Address of the OP_SorterOpen or OP_OpenEphemeral */ + int labelDone; /* Jump here when done, ex: LIMIT reached */ + int labelOBLopt; /* Jump here when sorter is full */ + u8 sortFlags; /* Zero or more SORTFLAG_* bits */ +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + u8 nDefer; /* Number of valid entries in aDefer[] */ + struct DeferredCsr { + Table *pTab; /* Table definition */ + int iCsr; /* Cursor number for table */ + int nKey; /* Number of PK columns for table pTab (>=1) */ + } aDefer[4]; +#endif + struct RowLoadInfo *pDeferredRowLoad; /* Deferred row loading info or NULL */ +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + int addrPush; /* First instruction to push data into sorter */ + int addrPushEnd; /* Last instruction that pushes data into sorter */ +#endif +}; +#define SORTFLAG_UseSorter 0x01 /* Use SorterOpen instead of OpenEphemeral */ + +/* +** Delete all the content of a Select structure. Deallocate the structure +** itself depending on the value of bFree +** +** If bFree==1, call sqlite3DbFree() on the p object. +** If bFree==0, Leave the first Select object unfreed +*/ +static void clearSelect(sqlite3 *db, Select *p, int bFree){ + assert( db!=0 ); + while( p ){ + Select *pPrior = p->pPrior; + sqlite3ExprListDelete(db, p->pEList); + sqlite3SrcListDelete(db, p->pSrc); + sqlite3ExprDelete(db, p->pWhere); + sqlite3ExprListDelete(db, p->pGroupBy); + sqlite3ExprDelete(db, p->pHaving); + sqlite3ExprListDelete(db, p->pOrderBy); + sqlite3ExprDelete(db, p->pLimit); + if( OK_IF_ALWAYS_TRUE(p->pWith) ) sqlite3WithDelete(db, p->pWith); +#ifndef SQLITE_OMIT_WINDOWFUNC + if( OK_IF_ALWAYS_TRUE(p->pWinDefn) ){ + sqlite3WindowListDelete(db, p->pWinDefn); + } + while( p->pWin ){ + assert( p->pWin->ppThis==&p->pWin ); + sqlite3WindowUnlinkFromSelect(p->pWin); + } +#endif + if( bFree ) sqlite3DbNNFreeNN(db, p); + p = pPrior; + bFree = 1; + } +} + +/* +** Initialize a SelectDest structure. +*/ +SQLITE_PRIVATE void sqlite3SelectDestInit(SelectDest *pDest, int eDest, int iParm){ + pDest->eDest = (u8)eDest; + pDest->iSDParm = iParm; + pDest->iSDParm2 = 0; + pDest->zAffSdst = 0; + pDest->iSdst = 0; + pDest->nSdst = 0; +} + + +/* +** Allocate a new Select structure and return a pointer to that +** structure. +*/ +SQLITE_PRIVATE Select *sqlite3SelectNew( + Parse *pParse, /* Parsing context */ + ExprList *pEList, /* which columns to include in the result */ + SrcList *pSrc, /* the FROM clause -- which tables to scan */ + Expr *pWhere, /* the WHERE clause */ + ExprList *pGroupBy, /* the GROUP BY clause */ + Expr *pHaving, /* the HAVING clause */ + ExprList *pOrderBy, /* the ORDER BY clause */ + u32 selFlags, /* Flag parameters, such as SF_Distinct */ + Expr *pLimit /* LIMIT value. NULL means not used */ +){ + Select *pNew, *pAllocated; + Select standin; + pAllocated = pNew = sqlite3DbMallocRawNN(pParse->db, sizeof(*pNew) ); + if( pNew==0 ){ + assert( pParse->db->mallocFailed ); + pNew = &standin; + } + if( pEList==0 ){ + pEList = sqlite3ExprListAppend(pParse, 0, + sqlite3Expr(pParse->db,TK_ASTERISK,0)); + } + pNew->pEList = pEList; + pNew->op = TK_SELECT; + pNew->selFlags = selFlags; + pNew->iLimit = 0; + pNew->iOffset = 0; + pNew->selId = ++pParse->nSelect; + pNew->addrOpenEphm[0] = -1; + pNew->addrOpenEphm[1] = -1; + pNew->nSelectRow = 0; + if( pSrc==0 ) pSrc = sqlite3DbMallocZero(pParse->db, sizeof(*pSrc)); + pNew->pSrc = pSrc; + pNew->pWhere = pWhere; + pNew->pGroupBy = pGroupBy; + pNew->pHaving = pHaving; + pNew->pOrderBy = pOrderBy; + pNew->pPrior = 0; + pNew->pNext = 0; + pNew->pLimit = pLimit; + pNew->pWith = 0; +#ifndef SQLITE_OMIT_WINDOWFUNC + pNew->pWin = 0; + pNew->pWinDefn = 0; +#endif + if( pParse->db->mallocFailed ) { + clearSelect(pParse->db, pNew, pNew!=&standin); + pAllocated = 0; + }else{ + assert( pNew->pSrc!=0 || pParse->nErr>0 ); + } + return pAllocated; +} + + +/* +** Delete the given Select structure and all of its substructures. +*/ +SQLITE_PRIVATE void sqlite3SelectDelete(sqlite3 *db, Select *p){ + if( OK_IF_ALWAYS_TRUE(p) ) clearSelect(db, p, 1); +} + +/* +** Return a pointer to the right-most SELECT statement in a compound. +*/ +static Select *findRightmost(Select *p){ + while( p->pNext ) p = p->pNext; + return p; +} + +/* +** Given 1 to 3 identifiers preceding the JOIN keyword, determine the +** type of join. Return an integer constant that expresses that type +** in terms of the following bit values: +** +** JT_INNER +** JT_CROSS +** JT_OUTER +** JT_NATURAL +** JT_LEFT +** JT_RIGHT +** +** A full outer join is the combination of JT_LEFT and JT_RIGHT. +** +** If an illegal or unsupported join type is seen, then still return +** a join type, but put an error in the pParse structure. +** +** These are the valid join types: +** +** +** pA pB pC Return Value +** ------- ----- ----- ------------ +** CROSS - - JT_CROSS +** INNER - - JT_INNER +** LEFT - - JT_LEFT|JT_OUTER +** LEFT OUTER - JT_LEFT|JT_OUTER +** RIGHT - - JT_RIGHT|JT_OUTER +** RIGHT OUTER - JT_RIGHT|JT_OUTER +** FULL - - JT_LEFT|JT_RIGHT|JT_OUTER +** FULL OUTER - JT_LEFT|JT_RIGHT|JT_OUTER +** NATURAL INNER - JT_NATURAL|JT_INNER +** NATURAL LEFT - JT_NATURAL|JT_LEFT|JT_OUTER +** NATURAL LEFT OUTER JT_NATURAL|JT_LEFT|JT_OUTER +** NATURAL RIGHT - JT_NATURAL|JT_RIGHT|JT_OUTER +** NATURAL RIGHT OUTER JT_NATURAL|JT_RIGHT|JT_OUTER +** NATURAL FULL - JT_NATURAL|JT_LEFT|JT_RIGHT +** NATURAL FULL OUTER JT_NATRUAL|JT_LEFT|JT_RIGHT +** +** To preserve historical compatibly, SQLite also accepts a variety +** of other non-standard and in many cases non-sensical join types. +** This routine makes as much sense at it can from the nonsense join +** type and returns a result. Examples of accepted nonsense join types +** include but are not limited to: +** +** INNER CROSS JOIN -> same as JOIN +** NATURAL CROSS JOIN -> same as NATURAL JOIN +** OUTER LEFT JOIN -> same as LEFT JOIN +** LEFT NATURAL JOIN -> same as NATURAL LEFT JOIN +** LEFT RIGHT JOIN -> same as FULL JOIN +** RIGHT OUTER FULL JOIN -> same as FULL JOIN +** CROSS CROSS CROSS JOIN -> same as JOIN +** +** The only restrictions on the join type name are: +** +** * "INNER" cannot appear together with "OUTER", "LEFT", "RIGHT", +** or "FULL". +** +** * "CROSS" cannot appear together with "OUTER", "LEFT", "RIGHT, +** or "FULL". +** +** * If "OUTER" is present then there must also be one of +** "LEFT", "RIGHT", or "FULL" +*/ +SQLITE_PRIVATE int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){ + int jointype = 0; + Token *apAll[3]; + Token *p; + /* 0123456789 123456789 123456789 123 */ + static const char zKeyText[] = "naturaleftouterightfullinnercross"; + static const struct { + u8 i; /* Beginning of keyword text in zKeyText[] */ + u8 nChar; /* Length of the keyword in characters */ + u8 code; /* Join type mask */ + } aKeyword[] = { + /* (0) natural */ { 0, 7, JT_NATURAL }, + /* (1) left */ { 6, 4, JT_LEFT|JT_OUTER }, + /* (2) outer */ { 10, 5, JT_OUTER }, + /* (3) right */ { 14, 5, JT_RIGHT|JT_OUTER }, + /* (4) full */ { 19, 4, JT_LEFT|JT_RIGHT|JT_OUTER }, + /* (5) inner */ { 23, 5, JT_INNER }, + /* (6) cross */ { 28, 5, JT_INNER|JT_CROSS }, + }; + int i, j; + apAll[0] = pA; + apAll[1] = pB; + apAll[2] = pC; + for(i=0; i<3 && apAll[i]; i++){ + p = apAll[i]; + for(j=0; jn==aKeyword[j].nChar + && sqlite3StrNICmp((char*)p->z, &zKeyText[aKeyword[j].i], p->n)==0 ){ + jointype |= aKeyword[j].code; + break; + } + } + testcase( j==0 || j==1 || j==2 || j==3 || j==4 || j==5 || j==6 ); + if( j>=ArraySize(aKeyword) ){ + jointype |= JT_ERROR; + break; + } + } + if( + (jointype & (JT_INNER|JT_OUTER))==(JT_INNER|JT_OUTER) || + (jointype & JT_ERROR)!=0 || + (jointype & (JT_OUTER|JT_LEFT|JT_RIGHT))==JT_OUTER + ){ + const char *zSp1 = " "; + const char *zSp2 = " "; + if( pB==0 ){ zSp1++; } + if( pC==0 ){ zSp2++; } + sqlite3ErrorMsg(pParse, "unknown join type: " + "%T%s%T%s%T", pA, zSp1, pB, zSp2, pC); + jointype = JT_INNER; + } + return jointype; +} + +/* +** Return the index of a column in a table. Return -1 if the column +** is not contained in the table. +*/ +SQLITE_PRIVATE int sqlite3ColumnIndex(Table *pTab, const char *zCol){ + int i; + u8 h = sqlite3StrIHash(zCol); + Column *pCol; + for(pCol=pTab->aCol, i=0; inCol; pCol++, i++){ + if( pCol->hName==h && sqlite3StrICmp(pCol->zCnName, zCol)==0 ) return i; + } + return -1; +} + +/* +** Mark a subquery result column as having been used. +*/ +SQLITE_PRIVATE void sqlite3SrcItemColumnUsed(SrcItem *pItem, int iCol){ + assert( pItem!=0 ); + assert( (int)pItem->fg.isNestedFrom == IsNestedFrom(pItem->pSelect) ); + if( pItem->fg.isNestedFrom ){ + ExprList *pResults; + assert( pItem->pSelect!=0 ); + pResults = pItem->pSelect->pEList; + assert( pResults!=0 ); + assert( iCol>=0 && iColnExpr ); + pResults->a[iCol].fg.bUsed = 1; + } +} + +/* +** Search the tables iStart..iEnd (inclusive) in pSrc, looking for a +** table that has a column named zCol. The search is left-to-right. +** The first match found is returned. +** +** When found, set *piTab and *piCol to the table index and column index +** of the matching column and return TRUE. +** +** If not found, return FALSE. +*/ +static int tableAndColumnIndex( + SrcList *pSrc, /* Array of tables to search */ + int iStart, /* First member of pSrc->a[] to check */ + int iEnd, /* Last member of pSrc->a[] to check */ + const char *zCol, /* Name of the column we are looking for */ + int *piTab, /* Write index of pSrc->a[] here */ + int *piCol, /* Write index of pSrc->a[*piTab].pTab->aCol[] here */ + int bIgnoreHidden /* Ignore hidden columns */ +){ + int i; /* For looping over tables in pSrc */ + int iCol; /* Index of column matching zCol */ + + assert( iEndnSrc ); + assert( iStart>=0 ); + assert( (piTab==0)==(piCol==0) ); /* Both or neither are NULL */ + + for(i=iStart; i<=iEnd; i++){ + iCol = sqlite3ColumnIndex(pSrc->a[i].pTab, zCol); + if( iCol>=0 + && (bIgnoreHidden==0 || IsHiddenColumn(&pSrc->a[i].pTab->aCol[iCol])==0) + ){ + if( piTab ){ + sqlite3SrcItemColumnUsed(&pSrc->a[i], iCol); + *piTab = i; + *piCol = iCol; + } + return 1; + } + } + return 0; +} + +/* +** Set the EP_OuterON property on all terms of the given expression. +** And set the Expr.w.iJoin to iTable for every term in the +** expression. +** +** The EP_OuterON property is used on terms of an expression to tell +** the OUTER JOIN processing logic that this term is part of the +** join restriction specified in the ON or USING clause and not a part +** of the more general WHERE clause. These terms are moved over to the +** WHERE clause during join processing but we need to remember that they +** originated in the ON or USING clause. +** +** The Expr.w.iJoin tells the WHERE clause processing that the +** expression depends on table w.iJoin even if that table is not +** explicitly mentioned in the expression. That information is needed +** for cases like this: +** +** SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.b AND t1.x=5 +** +** The where clause needs to defer the handling of the t1.x=5 +** term until after the t2 loop of the join. In that way, a +** NULL t2 row will be inserted whenever t1.x!=5. If we do not +** defer the handling of t1.x=5, it will be processed immediately +** after the t1 loop and rows with t1.x!=5 will never appear in +** the output, which is incorrect. +*/ +SQLITE_PRIVATE void sqlite3SetJoinExpr(Expr *p, int iTable, u32 joinFlag){ + assert( joinFlag==EP_OuterON || joinFlag==EP_InnerON ); + while( p ){ + ExprSetProperty(p, joinFlag); + assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) ); + ExprSetVVAProperty(p, EP_NoReduce); + p->w.iJoin = iTable; + if( p->op==TK_FUNCTION ){ + assert( ExprUseXList(p) ); + if( p->x.pList ){ + int i; + for(i=0; ix.pList->nExpr; i++){ + sqlite3SetJoinExpr(p->x.pList->a[i].pExpr, iTable, joinFlag); + } + } + } + sqlite3SetJoinExpr(p->pLeft, iTable, joinFlag); + p = p->pRight; + } +} + +/* Undo the work of sqlite3SetJoinExpr(). This is used when a LEFT JOIN +** is simplified into an ordinary JOIN, and when an ON expression is +** "pushed down" into the WHERE clause of a subquery. +** +** Convert every term that is marked with EP_OuterON and w.iJoin==iTable into +** an ordinary term that omits the EP_OuterON mark. Or if iTable<0, then +** just clear every EP_OuterON and EP_InnerON mark from the expression tree. +** +** If nullable is true, that means that Expr p might evaluate to NULL even +** if it is a reference to a NOT NULL column. This can happen, for example, +** if the table that p references is on the left side of a RIGHT JOIN. +** If nullable is true, then take care to not remove the EP_CanBeNull bit. +** See forum thread https://sqlite.org/forum/forumpost/b40696f50145d21c +*/ +static void unsetJoinExpr(Expr *p, int iTable, int nullable){ + while( p ){ + if( iTable<0 || (ExprHasProperty(p, EP_OuterON) && p->w.iJoin==iTable) ){ + ExprClearProperty(p, EP_OuterON|EP_InnerON); + if( iTable>=0 ) ExprSetProperty(p, EP_InnerON); + } + if( p->op==TK_COLUMN && p->iTable==iTable && !nullable ){ + ExprClearProperty(p, EP_CanBeNull); + } + if( p->op==TK_FUNCTION ){ + assert( ExprUseXList(p) ); + if( p->x.pList ){ + int i; + for(i=0; ix.pList->nExpr; i++){ + unsetJoinExpr(p->x.pList->a[i].pExpr, iTable, nullable); + } + } + } + unsetJoinExpr(p->pLeft, iTable, nullable); + p = p->pRight; + } +} + +/* +** This routine processes the join information for a SELECT statement. +** +** * A NATURAL join is converted into a USING join. After that, we +** do not need to be concerned with NATURAL joins and we only have +** think about USING joins. +** +** * ON and USING clauses result in extra terms being added to the +** WHERE clause to enforce the specified constraints. The extra +** WHERE clause terms will be tagged with EP_OuterON or +** EP_InnerON so that we know that they originated in ON/USING. +** +** The terms of a FROM clause are contained in the Select.pSrc structure. +** The left most table is the first entry in Select.pSrc. The right-most +** table is the last entry. The join operator is held in the entry to +** the right. Thus entry 1 contains the join operator for the join between +** entries 0 and 1. Any ON or USING clauses associated with the join are +** also attached to the right entry. +** +** This routine returns the number of errors encountered. +*/ +static int sqlite3ProcessJoin(Parse *pParse, Select *p){ + SrcList *pSrc; /* All tables in the FROM clause */ + int i, j; /* Loop counters */ + SrcItem *pLeft; /* Left table being joined */ + SrcItem *pRight; /* Right table being joined */ + + pSrc = p->pSrc; + pLeft = &pSrc->a[0]; + pRight = &pLeft[1]; + for(i=0; inSrc-1; i++, pRight++, pLeft++){ + Table *pRightTab = pRight->pTab; + u32 joinType; + + if( NEVER(pLeft->pTab==0 || pRightTab==0) ) continue; + joinType = (pRight->fg.jointype & JT_OUTER)!=0 ? EP_OuterON : EP_InnerON; + + /* If this is a NATURAL join, synthesize an approprate USING clause + ** to specify which columns should be joined. + */ + if( pRight->fg.jointype & JT_NATURAL ){ + IdList *pUsing = 0; + if( pRight->fg.isUsing || pRight->u3.pOn ){ + sqlite3ErrorMsg(pParse, "a NATURAL join may not have " + "an ON or USING clause", 0); + return 1; + } + for(j=0; jnCol; j++){ + char *zName; /* Name of column in the right table */ + + if( IsHiddenColumn(&pRightTab->aCol[j]) ) continue; + zName = pRightTab->aCol[j].zCnName; + if( tableAndColumnIndex(pSrc, 0, i, zName, 0, 0, 1) ){ + pUsing = sqlite3IdListAppend(pParse, pUsing, 0); + if( pUsing ){ + assert( pUsing->nId>0 ); + assert( pUsing->a[pUsing->nId-1].zName==0 ); + pUsing->a[pUsing->nId-1].zName = sqlite3DbStrDup(pParse->db, zName); + } + } + } + if( pUsing ){ + pRight->fg.isUsing = 1; + pRight->fg.isSynthUsing = 1; + pRight->u3.pUsing = pUsing; + } + if( pParse->nErr ) return 1; + } + + /* Create extra terms on the WHERE clause for each column named + ** in the USING clause. Example: If the two tables to be joined are + ** A and B and the USING clause names X, Y, and Z, then add this + ** to the WHERE clause: A.X=B.X AND A.Y=B.Y AND A.Z=B.Z + ** Report an error if any column mentioned in the USING clause is + ** not contained in both tables to be joined. + */ + if( pRight->fg.isUsing ){ + IdList *pList = pRight->u3.pUsing; + sqlite3 *db = pParse->db; + assert( pList!=0 ); + for(j=0; jnId; j++){ + char *zName; /* Name of the term in the USING clause */ + int iLeft; /* Table on the left with matching column name */ + int iLeftCol; /* Column number of matching column on the left */ + int iRightCol; /* Column number of matching column on the right */ + Expr *pE1; /* Reference to the column on the LEFT of the join */ + Expr *pE2; /* Reference to the column on the RIGHT of the join */ + Expr *pEq; /* Equality constraint. pE1 == pE2 */ + + zName = pList->a[j].zName; + iRightCol = sqlite3ColumnIndex(pRightTab, zName); + if( iRightCol<0 + || tableAndColumnIndex(pSrc, 0, i, zName, &iLeft, &iLeftCol, + pRight->fg.isSynthUsing)==0 + ){ + sqlite3ErrorMsg(pParse, "cannot join using column %s - column " + "not present in both tables", zName); + return 1; + } + pE1 = sqlite3CreateColumnExpr(db, pSrc, iLeft, iLeftCol); + sqlite3SrcItemColumnUsed(&pSrc->a[iLeft], iLeftCol); + if( (pSrc->a[0].fg.jointype & JT_LTORJ)!=0 ){ + /* This branch runs if the query contains one or more RIGHT or FULL + ** JOINs. If only a single table on the left side of this join + ** contains the zName column, then this branch is a no-op. + ** But if there are two or more tables on the left side + ** of the join, construct a coalesce() function that gathers all + ** such tables. Raise an error if more than one of those references + ** to zName is not also within a prior USING clause. + ** + ** We really ought to raise an error if there are two or more + ** non-USING references to zName on the left of an INNER or LEFT + ** JOIN. But older versions of SQLite do not do that, so we avoid + ** adding a new error so as to not break legacy applications. + */ + ExprList *pFuncArgs = 0; /* Arguments to the coalesce() */ + static const Token tkCoalesce = { "coalesce", 8 }; + while( tableAndColumnIndex(pSrc, iLeft+1, i, zName, &iLeft, &iLeftCol, + pRight->fg.isSynthUsing)!=0 ){ + if( pSrc->a[iLeft].fg.isUsing==0 + || sqlite3IdListIndex(pSrc->a[iLeft].u3.pUsing, zName)<0 + ){ + sqlite3ErrorMsg(pParse, "ambiguous reference to %s in USING()", + zName); + break; + } + pFuncArgs = sqlite3ExprListAppend(pParse, pFuncArgs, pE1); + pE1 = sqlite3CreateColumnExpr(db, pSrc, iLeft, iLeftCol); + sqlite3SrcItemColumnUsed(&pSrc->a[iLeft], iLeftCol); + } + if( pFuncArgs ){ + pFuncArgs = sqlite3ExprListAppend(pParse, pFuncArgs, pE1); + pE1 = sqlite3ExprFunction(pParse, pFuncArgs, &tkCoalesce, 0); + } + } + pE2 = sqlite3CreateColumnExpr(db, pSrc, i+1, iRightCol); + sqlite3SrcItemColumnUsed(pRight, iRightCol); + pEq = sqlite3PExpr(pParse, TK_EQ, pE1, pE2); + assert( pE2!=0 || pEq==0 ); + if( pEq ){ + ExprSetProperty(pEq, joinType); + assert( !ExprHasProperty(pEq, EP_TokenOnly|EP_Reduced) ); + ExprSetVVAProperty(pEq, EP_NoReduce); + pEq->w.iJoin = pE2->iTable; + } + p->pWhere = sqlite3ExprAnd(pParse, p->pWhere, pEq); + } + } + + /* Add the ON clause to the end of the WHERE clause, connected by + ** an AND operator. + */ + else if( pRight->u3.pOn ){ + sqlite3SetJoinExpr(pRight->u3.pOn, pRight->iCursor, joinType); + p->pWhere = sqlite3ExprAnd(pParse, p->pWhere, pRight->u3.pOn); + pRight->u3.pOn = 0; + pRight->fg.isOn = 1; + } + } + return 0; +} + +/* +** An instance of this object holds information (beyond pParse and pSelect) +** needed to load the next result row that is to be added to the sorter. +*/ +typedef struct RowLoadInfo RowLoadInfo; +struct RowLoadInfo { + int regResult; /* Store results in array of registers here */ + u8 ecelFlags; /* Flag argument to ExprCodeExprList() */ +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + ExprList *pExtra; /* Extra columns needed by sorter refs */ + int regExtraResult; /* Where to load the extra columns */ +#endif +}; + +/* +** This routine does the work of loading query data into an array of +** registers so that it can be added to the sorter. +*/ +static void innerLoopLoadRow( + Parse *pParse, /* Statement under construction */ + Select *pSelect, /* The query being coded */ + RowLoadInfo *pInfo /* Info needed to complete the row load */ +){ + sqlite3ExprCodeExprList(pParse, pSelect->pEList, pInfo->regResult, + 0, pInfo->ecelFlags); +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + if( pInfo->pExtra ){ + sqlite3ExprCodeExprList(pParse, pInfo->pExtra, pInfo->regExtraResult, 0, 0); + sqlite3ExprListDelete(pParse->db, pInfo->pExtra); + } +#endif +} + +/* +** Code the OP_MakeRecord instruction that generates the entry to be +** added into the sorter. +** +** Return the register in which the result is stored. +*/ +static int makeSorterRecord( + Parse *pParse, + SortCtx *pSort, + Select *pSelect, + int regBase, + int nBase +){ + int nOBSat = pSort->nOBSat; + Vdbe *v = pParse->pVdbe; + int regOut = ++pParse->nMem; + if( pSort->pDeferredRowLoad ){ + innerLoopLoadRow(pParse, pSelect, pSort->pDeferredRowLoad); + } + sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase+nOBSat, nBase-nOBSat, regOut); + return regOut; +} + +/* +** Generate code that will push the record in registers regData +** through regData+nData-1 onto the sorter. +*/ +static void pushOntoSorter( + Parse *pParse, /* Parser context */ + SortCtx *pSort, /* Information about the ORDER BY clause */ + Select *pSelect, /* The whole SELECT statement */ + int regData, /* First register holding data to be sorted */ + int regOrigData, /* First register holding data before packing */ + int nData, /* Number of elements in the regData data array */ + int nPrefixReg /* No. of reg prior to regData available for use */ +){ + Vdbe *v = pParse->pVdbe; /* Stmt under construction */ + int bSeq = ((pSort->sortFlags & SORTFLAG_UseSorter)==0); + int nExpr = pSort->pOrderBy->nExpr; /* No. of ORDER BY terms */ + int nBase = nExpr + bSeq + nData; /* Fields in sorter record */ + int regBase; /* Regs for sorter record */ + int regRecord = 0; /* Assembled sorter record */ + int nOBSat = pSort->nOBSat; /* ORDER BY terms to skip */ + int op; /* Opcode to add sorter record to sorter */ + int iLimit; /* LIMIT counter */ + int iSkip = 0; /* End of the sorter insert loop */ + + assert( bSeq==0 || bSeq==1 ); + + /* Three cases: + ** (1) The data to be sorted has already been packed into a Record + ** by a prior OP_MakeRecord. In this case nData==1 and regData + ** will be completely unrelated to regOrigData. + ** (2) All output columns are included in the sort record. In that + ** case regData==regOrigData. + ** (3) Some output columns are omitted from the sort record due to + ** the SQLITE_ENABLE_SORTER_REFERENCES optimization, or due to the + ** SQLITE_ECEL_OMITREF optimization, or due to the + ** SortCtx.pDeferredRowLoad optimiation. In any of these cases + ** regOrigData is 0 to prevent this routine from trying to copy + ** values that might not yet exist. + */ + assert( nData==1 || regData==regOrigData || regOrigData==0 ); + +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + pSort->addrPush = sqlite3VdbeCurrentAddr(v); +#endif + + if( nPrefixReg ){ + assert( nPrefixReg==nExpr+bSeq ); + regBase = regData - nPrefixReg; + }else{ + regBase = pParse->nMem + 1; + pParse->nMem += nBase; + } + assert( pSelect->iOffset==0 || pSelect->iLimit!=0 ); + iLimit = pSelect->iOffset ? pSelect->iOffset+1 : pSelect->iLimit; + pSort->labelDone = sqlite3VdbeMakeLabel(pParse); + sqlite3ExprCodeExprList(pParse, pSort->pOrderBy, regBase, regOrigData, + SQLITE_ECEL_DUP | (regOrigData? SQLITE_ECEL_REF : 0)); + if( bSeq ){ + sqlite3VdbeAddOp2(v, OP_Sequence, pSort->iECursor, regBase+nExpr); + } + if( nPrefixReg==0 && nData>0 ){ + sqlite3ExprCodeMove(pParse, regData, regBase+nExpr+bSeq, nData); + } + if( nOBSat>0 ){ + int regPrevKey; /* The first nOBSat columns of the previous row */ + int addrFirst; /* Address of the OP_IfNot opcode */ + int addrJmp; /* Address of the OP_Jump opcode */ + VdbeOp *pOp; /* Opcode that opens the sorter */ + int nKey; /* Number of sorting key columns, including OP_Sequence */ + KeyInfo *pKI; /* Original KeyInfo on the sorter table */ + + regRecord = makeSorterRecord(pParse, pSort, pSelect, regBase, nBase); + regPrevKey = pParse->nMem+1; + pParse->nMem += pSort->nOBSat; + nKey = nExpr - pSort->nOBSat + bSeq; + if( bSeq ){ + addrFirst = sqlite3VdbeAddOp1(v, OP_IfNot, regBase+nExpr); + }else{ + addrFirst = sqlite3VdbeAddOp1(v, OP_SequenceTest, pSort->iECursor); + } + VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_Compare, regPrevKey, regBase, pSort->nOBSat); + pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex); + if( pParse->db->mallocFailed ) return; + pOp->p2 = nKey + nData; + pKI = pOp->p4.pKeyInfo; + memset(pKI->aSortFlags, 0, pKI->nKeyField); /* Makes OP_Jump testable */ + sqlite3VdbeChangeP4(v, -1, (char*)pKI, P4_KEYINFO); + testcase( pKI->nAllField > pKI->nKeyField+2 ); + pOp->p4.pKeyInfo = sqlite3KeyInfoFromExprList(pParse,pSort->pOrderBy,nOBSat, + pKI->nAllField-pKI->nKeyField-1); + pOp = 0; /* Ensure pOp not used after sqltie3VdbeAddOp3() */ + addrJmp = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp3(v, OP_Jump, addrJmp+1, 0, addrJmp+1); VdbeCoverage(v); + pSort->labelBkOut = sqlite3VdbeMakeLabel(pParse); + pSort->regReturn = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Gosub, pSort->regReturn, pSort->labelBkOut); + sqlite3VdbeAddOp1(v, OP_ResetSorter, pSort->iECursor); + if( iLimit ){ + sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, pSort->labelDone); + VdbeCoverage(v); + } + sqlite3VdbeJumpHere(v, addrFirst); + sqlite3ExprCodeMove(pParse, regBase, regPrevKey, pSort->nOBSat); + sqlite3VdbeJumpHere(v, addrJmp); + } + if( iLimit ){ + /* At this point the values for the new sorter entry are stored + ** in an array of registers. They need to be composed into a record + ** and inserted into the sorter if either (a) there are currently + ** less than LIMIT+OFFSET items or (b) the new record is smaller than + ** the largest record currently in the sorter. If (b) is true and there + ** are already LIMIT+OFFSET items in the sorter, delete the largest + ** entry before inserting the new one. This way there are never more + ** than LIMIT+OFFSET items in the sorter. + ** + ** If the new record does not need to be inserted into the sorter, + ** jump to the next iteration of the loop. If the pSort->labelOBLopt + ** value is not zero, then it is a label of where to jump. Otherwise, + ** just bypass the row insert logic. See the header comment on the + ** sqlite3WhereOrderByLimitOptLabel() function for additional info. + */ + int iCsr = pSort->iECursor; + sqlite3VdbeAddOp2(v, OP_IfNotZero, iLimit, sqlite3VdbeCurrentAddr(v)+4); + VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_Last, iCsr, 0); + iSkip = sqlite3VdbeAddOp4Int(v, OP_IdxLE, + iCsr, 0, regBase+nOBSat, nExpr-nOBSat); + VdbeCoverage(v); + sqlite3VdbeAddOp1(v, OP_Delete, iCsr); + } + if( regRecord==0 ){ + regRecord = makeSorterRecord(pParse, pSort, pSelect, regBase, nBase); + } + if( pSort->sortFlags & SORTFLAG_UseSorter ){ + op = OP_SorterInsert; + }else{ + op = OP_IdxInsert; + } + sqlite3VdbeAddOp4Int(v, op, pSort->iECursor, regRecord, + regBase+nOBSat, nBase-nOBSat); + if( iSkip ){ + sqlite3VdbeChangeP2(v, iSkip, + pSort->labelOBLopt ? pSort->labelOBLopt : sqlite3VdbeCurrentAddr(v)); + } +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + pSort->addrPushEnd = sqlite3VdbeCurrentAddr(v)-1; +#endif +} + +/* +** Add code to implement the OFFSET +*/ +static void codeOffset( + Vdbe *v, /* Generate code into this VM */ + int iOffset, /* Register holding the offset counter */ + int iContinue /* Jump here to skip the current record */ +){ + if( iOffset>0 ){ + sqlite3VdbeAddOp3(v, OP_IfPos, iOffset, iContinue, 1); VdbeCoverage(v); + VdbeComment((v, "OFFSET")); + } +} + +/* +** Add code that will check to make sure the array of registers starting at +** iMem form a distinct entry. This is used by both "SELECT DISTINCT ..." and +** distinct aggregates ("SELECT count(DISTINCT ) ..."). Three strategies +** are available. Which is used depends on the value of parameter eTnctType, +** as follows: +** +** WHERE_DISTINCT_UNORDERED/WHERE_DISTINCT_NOOP: +** Build an ephemeral table that contains all entries seen before and +** skip entries which have been seen before. +** +** Parameter iTab is the cursor number of an ephemeral table that must +** be opened before the VM code generated by this routine is executed. +** The ephemeral cursor table is queried for a record identical to the +** record formed by the current array of registers. If one is found, +** jump to VM address addrRepeat. Otherwise, insert a new record into +** the ephemeral cursor and proceed. +** +** The returned value in this case is a copy of parameter iTab. +** +** WHERE_DISTINCT_ORDERED: +** In this case rows are being delivered sorted order. The ephermal +** table is not required. Instead, the current set of values +** is compared against previous row. If they match, the new row +** is not distinct and control jumps to VM address addrRepeat. Otherwise, +** the VM program proceeds with processing the new row. +** +** The returned value in this case is the register number of the first +** in an array of registers used to store the previous result row so that +** it can be compared to the next. The caller must ensure that this +** register is initialized to NULL. (The fixDistinctOpenEph() routine +** will take care of this initialization.) +** +** WHERE_DISTINCT_UNIQUE: +** In this case it has already been determined that the rows are distinct. +** No special action is required. The return value is zero. +** +** Parameter pEList is the list of expressions used to generated the +** contents of each row. It is used by this routine to determine (a) +** how many elements there are in the array of registers and (b) the +** collation sequences that should be used for the comparisons if +** eTnctType is WHERE_DISTINCT_ORDERED. +*/ +static int codeDistinct( + Parse *pParse, /* Parsing and code generating context */ + int eTnctType, /* WHERE_DISTINCT_* value */ + int iTab, /* A sorting index used to test for distinctness */ + int addrRepeat, /* Jump to here if not distinct */ + ExprList *pEList, /* Expression for each element */ + int regElem /* First element */ +){ + int iRet = 0; + int nResultCol = pEList->nExpr; + Vdbe *v = pParse->pVdbe; + + switch( eTnctType ){ + case WHERE_DISTINCT_ORDERED: { + int i; + int iJump; /* Jump destination */ + int regPrev; /* Previous row content */ + + /* Allocate space for the previous row */ + iRet = regPrev = pParse->nMem+1; + pParse->nMem += nResultCol; + + iJump = sqlite3VdbeCurrentAddr(v) + nResultCol; + for(i=0; ia[i].pExpr); + if( idb->mallocFailed ); + sqlite3VdbeAddOp3(v, OP_Copy, regElem, regPrev, nResultCol-1); + break; + } + + case WHERE_DISTINCT_UNIQUE: { + /* nothing to do */ + break; + } + + default: { + int r1 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp4Int(v, OP_Found, iTab, addrRepeat, regElem, nResultCol); + VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_MakeRecord, regElem, nResultCol, r1); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iTab, r1, regElem, nResultCol); + sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT); + sqlite3ReleaseTempReg(pParse, r1); + iRet = iTab; + break; + } + } + + return iRet; +} + +/* +** This routine runs after codeDistinct(). It makes necessary +** adjustments to the OP_OpenEphemeral opcode that the codeDistinct() +** routine made use of. This processing must be done separately since +** sometimes codeDistinct is called before the OP_OpenEphemeral is actually +** laid down. +** +** WHERE_DISTINCT_NOOP: +** WHERE_DISTINCT_UNORDERED: +** +** No adjustments necessary. This function is a no-op. +** +** WHERE_DISTINCT_UNIQUE: +** +** The ephemeral table is not needed. So change the +** OP_OpenEphemeral opcode into an OP_Noop. +** +** WHERE_DISTINCT_ORDERED: +** +** The ephemeral table is not needed. But we do need register +** iVal to be initialized to NULL. So change the OP_OpenEphemeral +** into an OP_Null on the iVal register. +*/ +static void fixDistinctOpenEph( + Parse *pParse, /* Parsing and code generating context */ + int eTnctType, /* WHERE_DISTINCT_* value */ + int iVal, /* Value returned by codeDistinct() */ + int iOpenEphAddr /* Address of OP_OpenEphemeral instruction for iTab */ +){ + if( pParse->nErr==0 + && (eTnctType==WHERE_DISTINCT_UNIQUE || eTnctType==WHERE_DISTINCT_ORDERED) + ){ + Vdbe *v = pParse->pVdbe; + sqlite3VdbeChangeToNoop(v, iOpenEphAddr); + if( sqlite3VdbeGetOp(v, iOpenEphAddr+1)->opcode==OP_Explain ){ + sqlite3VdbeChangeToNoop(v, iOpenEphAddr+1); + } + if( eTnctType==WHERE_DISTINCT_ORDERED ){ + /* Change the OP_OpenEphemeral to an OP_Null that sets the MEM_Cleared + ** bit on the first register of the previous value. This will cause the + ** OP_Ne added in codeDistinct() to always fail on the first iteration of + ** the loop even if the first row is all NULLs. */ + VdbeOp *pOp = sqlite3VdbeGetOp(v, iOpenEphAddr); + pOp->opcode = OP_Null; + pOp->p1 = 1; + pOp->p2 = iVal; + } + } +} + +#ifdef SQLITE_ENABLE_SORTER_REFERENCES +/* +** This function is called as part of inner-loop generation for a SELECT +** statement with an ORDER BY that is not optimized by an index. It +** determines the expressions, if any, that the sorter-reference +** optimization should be used for. The sorter-reference optimization +** is used for SELECT queries like: +** +** SELECT a, bigblob FROM t1 ORDER BY a LIMIT 10 +** +** If the optimization is used for expression "bigblob", then instead of +** storing values read from that column in the sorter records, the PK of +** the row from table t1 is stored instead. Then, as records are extracted from +** the sorter to return to the user, the required value of bigblob is +** retrieved directly from table t1. If the values are very large, this +** can be more efficient than storing them directly in the sorter records. +** +** The ExprList_item.fg.bSorterRef flag is set for each expression in pEList +** for which the sorter-reference optimization should be enabled. +** Additionally, the pSort->aDefer[] array is populated with entries +** for all cursors required to evaluate all selected expressions. Finally. +** output variable (*ppExtra) is set to an expression list containing +** expressions for all extra PK values that should be stored in the +** sorter records. +*/ +static void selectExprDefer( + Parse *pParse, /* Leave any error here */ + SortCtx *pSort, /* Sorter context */ + ExprList *pEList, /* Expressions destined for sorter */ + ExprList **ppExtra /* Expressions to append to sorter record */ +){ + int i; + int nDefer = 0; + ExprList *pExtra = 0; + for(i=0; inExpr; i++){ + struct ExprList_item *pItem = &pEList->a[i]; + if( pItem->u.x.iOrderByCol==0 ){ + Expr *pExpr = pItem->pExpr; + Table *pTab; + if( pExpr->op==TK_COLUMN + && pExpr->iColumn>=0 + && ALWAYS( ExprUseYTab(pExpr) ) + && (pTab = pExpr->y.pTab)!=0 + && IsOrdinaryTable(pTab) + && (pTab->aCol[pExpr->iColumn].colFlags & COLFLAG_SORTERREF)!=0 + ){ + int j; + for(j=0; jaDefer[j].iCsr==pExpr->iTable ) break; + } + if( j==nDefer ){ + if( nDefer==ArraySize(pSort->aDefer) ){ + continue; + }else{ + int nKey = 1; + int k; + Index *pPk = 0; + if( !HasRowid(pTab) ){ + pPk = sqlite3PrimaryKeyIndex(pTab); + nKey = pPk->nKeyCol; + } + for(k=0; kiTable = pExpr->iTable; + assert( ExprUseYTab(pNew) ); + pNew->y.pTab = pExpr->y.pTab; + pNew->iColumn = pPk ? pPk->aiColumn[k] : -1; + pExtra = sqlite3ExprListAppend(pParse, pExtra, pNew); + } + } + pSort->aDefer[nDefer].pTab = pExpr->y.pTab; + pSort->aDefer[nDefer].iCsr = pExpr->iTable; + pSort->aDefer[nDefer].nKey = nKey; + nDefer++; + } + } + pItem->fg.bSorterRef = 1; + } + } + } + pSort->nDefer = (u8)nDefer; + *ppExtra = pExtra; +} +#endif + +/* +** This routine generates the code for the inside of the inner loop +** of a SELECT. +** +** If srcTab is negative, then the p->pEList expressions +** are evaluated in order to get the data for this row. If srcTab is +** zero or more, then data is pulled from srcTab and p->pEList is used only +** to get the number of columns and the collation sequence for each column. +*/ +static void selectInnerLoop( + Parse *pParse, /* The parser context */ + Select *p, /* The complete select statement being coded */ + int srcTab, /* Pull data from this table if non-negative */ + SortCtx *pSort, /* If not NULL, info on how to process ORDER BY */ + DistinctCtx *pDistinct, /* If not NULL, info on how to process DISTINCT */ + SelectDest *pDest, /* How to dispose of the results */ + int iContinue, /* Jump here to continue with next row */ + int iBreak /* Jump here to break out of the inner loop */ +){ + Vdbe *v = pParse->pVdbe; + int i; + int hasDistinct; /* True if the DISTINCT keyword is present */ + int eDest = pDest->eDest; /* How to dispose of results */ + int iParm = pDest->iSDParm; /* First argument to disposal method */ + int nResultCol; /* Number of result columns */ + int nPrefixReg = 0; /* Number of extra registers before regResult */ + RowLoadInfo sRowLoadInfo; /* Info for deferred row loading */ + + /* Usually, regResult is the first cell in an array of memory cells + ** containing the current result row. In this case regOrig is set to the + ** same value. However, if the results are being sent to the sorter, the + ** values for any expressions that are also part of the sort-key are omitted + ** from this array. In this case regOrig is set to zero. */ + int regResult; /* Start of memory holding current results */ + int regOrig; /* Start of memory holding full result (or 0) */ + + assert( v ); + assert( p->pEList!=0 ); + hasDistinct = pDistinct ? pDistinct->eTnctType : WHERE_DISTINCT_NOOP; + if( pSort && pSort->pOrderBy==0 ) pSort = 0; + if( pSort==0 && !hasDistinct ){ + assert( iContinue!=0 ); + codeOffset(v, p->iOffset, iContinue); + } + + /* Pull the requested columns. + */ + nResultCol = p->pEList->nExpr; + + if( pDest->iSdst==0 ){ + if( pSort ){ + nPrefixReg = pSort->pOrderBy->nExpr; + if( !(pSort->sortFlags & SORTFLAG_UseSorter) ) nPrefixReg++; + pParse->nMem += nPrefixReg; + } + pDest->iSdst = pParse->nMem+1; + pParse->nMem += nResultCol; + }else if( pDest->iSdst+nResultCol > pParse->nMem ){ + /* This is an error condition that can result, for example, when a SELECT + ** on the right-hand side of an INSERT contains more result columns than + ** there are columns in the table on the left. The error will be caught + ** and reported later. But we need to make sure enough memory is allocated + ** to avoid other spurious errors in the meantime. */ + pParse->nMem += nResultCol; + } + pDest->nSdst = nResultCol; + regOrig = regResult = pDest->iSdst; + if( srcTab>=0 ){ + for(i=0; ipEList->a[i].zEName)); + } + }else if( eDest!=SRT_Exists ){ +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + ExprList *pExtra = 0; +#endif + /* If the destination is an EXISTS(...) expression, the actual + ** values returned by the SELECT are not required. + */ + u8 ecelFlags; /* "ecel" is an abbreviation of "ExprCodeExprList" */ + ExprList *pEList; + if( eDest==SRT_Mem || eDest==SRT_Output || eDest==SRT_Coroutine ){ + ecelFlags = SQLITE_ECEL_DUP; + }else{ + ecelFlags = 0; + } + if( pSort && hasDistinct==0 && eDest!=SRT_EphemTab && eDest!=SRT_Table ){ + /* For each expression in p->pEList that is a copy of an expression in + ** the ORDER BY clause (pSort->pOrderBy), set the associated + ** iOrderByCol value to one more than the index of the ORDER BY + ** expression within the sort-key that pushOntoSorter() will generate. + ** This allows the p->pEList field to be omitted from the sorted record, + ** saving space and CPU cycles. */ + ecelFlags |= (SQLITE_ECEL_OMITREF|SQLITE_ECEL_REF); + + for(i=pSort->nOBSat; ipOrderBy->nExpr; i++){ + int j; + if( (j = pSort->pOrderBy->a[i].u.x.iOrderByCol)>0 ){ + p->pEList->a[j-1].u.x.iOrderByCol = i+1-pSort->nOBSat; + } + } +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + selectExprDefer(pParse, pSort, p->pEList, &pExtra); + if( pExtra && pParse->db->mallocFailed==0 ){ + /* If there are any extra PK columns to add to the sorter records, + ** allocate extra memory cells and adjust the OpenEphemeral + ** instruction to account for the larger records. This is only + ** required if there are one or more WITHOUT ROWID tables with + ** composite primary keys in the SortCtx.aDefer[] array. */ + VdbeOp *pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex); + pOp->p2 += (pExtra->nExpr - pSort->nDefer); + pOp->p4.pKeyInfo->nAllField += (pExtra->nExpr - pSort->nDefer); + pParse->nMem += pExtra->nExpr; + } +#endif + + /* Adjust nResultCol to account for columns that are omitted + ** from the sorter by the optimizations in this branch */ + pEList = p->pEList; + for(i=0; inExpr; i++){ + if( pEList->a[i].u.x.iOrderByCol>0 +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + || pEList->a[i].fg.bSorterRef +#endif + ){ + nResultCol--; + regOrig = 0; + } + } + + testcase( regOrig ); + testcase( eDest==SRT_Set ); + testcase( eDest==SRT_Mem ); + testcase( eDest==SRT_Coroutine ); + testcase( eDest==SRT_Output ); + assert( eDest==SRT_Set || eDest==SRT_Mem + || eDest==SRT_Coroutine || eDest==SRT_Output + || eDest==SRT_Upfrom ); + } + sRowLoadInfo.regResult = regResult; + sRowLoadInfo.ecelFlags = ecelFlags; +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + sRowLoadInfo.pExtra = pExtra; + sRowLoadInfo.regExtraResult = regResult + nResultCol; + if( pExtra ) nResultCol += pExtra->nExpr; +#endif + if( p->iLimit + && (ecelFlags & SQLITE_ECEL_OMITREF)!=0 + && nPrefixReg>0 + ){ + assert( pSort!=0 ); + assert( hasDistinct==0 ); + pSort->pDeferredRowLoad = &sRowLoadInfo; + regOrig = 0; + }else{ + innerLoopLoadRow(pParse, p, &sRowLoadInfo); + } + } + + /* If the DISTINCT keyword was present on the SELECT statement + ** and this row has been seen before, then do not make this row + ** part of the result. + */ + if( hasDistinct ){ + int eType = pDistinct->eTnctType; + int iTab = pDistinct->tabTnct; + assert( nResultCol==p->pEList->nExpr ); + iTab = codeDistinct(pParse, eType, iTab, iContinue, p->pEList, regResult); + fixDistinctOpenEph(pParse, eType, iTab, pDistinct->addrTnct); + if( pSort==0 ){ + codeOffset(v, p->iOffset, iContinue); + } + } + + switch( eDest ){ + /* In this mode, write each query result to the key of the temporary + ** table iParm. + */ +#ifndef SQLITE_OMIT_COMPOUND_SELECT + case SRT_Union: { + int r1; + r1 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, nResultCol); + sqlite3ReleaseTempReg(pParse, r1); + break; + } + + /* Construct a record from the query result, but instead of + ** saving that record, use it as a key to delete elements from + ** the temporary table iParm. + */ + case SRT_Except: { + sqlite3VdbeAddOp3(v, OP_IdxDelete, iParm, regResult, nResultCol); + break; + } +#endif /* SQLITE_OMIT_COMPOUND_SELECT */ + + /* Store the result as data using a unique key. + */ + case SRT_Fifo: + case SRT_DistFifo: + case SRT_Table: + case SRT_EphemTab: { + int r1 = sqlite3GetTempRange(pParse, nPrefixReg+1); + testcase( eDest==SRT_Table ); + testcase( eDest==SRT_EphemTab ); + testcase( eDest==SRT_Fifo ); + testcase( eDest==SRT_DistFifo ); + sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1+nPrefixReg); +#ifndef SQLITE_OMIT_CTE + if( eDest==SRT_DistFifo ){ + /* If the destination is DistFifo, then cursor (iParm+1) is open + ** on an ephemeral index. If the current row is already present + ** in the index, do not write it to the output. If not, add the + ** current row to the index and proceed with writing it to the + ** output table as well. */ + int addr = sqlite3VdbeCurrentAddr(v) + 4; + sqlite3VdbeAddOp4Int(v, OP_Found, iParm+1, addr, r1, 0); + VdbeCoverage(v); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm+1, r1,regResult,nResultCol); + assert( pSort==0 ); + } +#endif + if( pSort ){ + assert( regResult==regOrig ); + pushOntoSorter(pParse, pSort, p, r1+nPrefixReg, regOrig, 1, nPrefixReg); + }else{ + int r2 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, r2); + sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, r2); + sqlite3VdbeChangeP5(v, OPFLAG_APPEND); + sqlite3ReleaseTempReg(pParse, r2); + } + sqlite3ReleaseTempRange(pParse, r1, nPrefixReg+1); + break; + } + + case SRT_Upfrom: { + if( pSort ){ + pushOntoSorter( + pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg); + }else{ + int i2 = pDest->iSDParm2; + int r1 = sqlite3GetTempReg(pParse); + + /* If the UPDATE FROM join is an aggregate that matches no rows, it + ** might still be trying to return one row, because that is what + ** aggregates do. Don't record that empty row in the output table. */ + sqlite3VdbeAddOp2(v, OP_IsNull, regResult, iBreak); VdbeCoverage(v); + + sqlite3VdbeAddOp3(v, OP_MakeRecord, + regResult+(i2<0), nResultCol-(i2<0), r1); + if( i2<0 ){ + sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, regResult); + }else{ + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, i2); + } + } + break; + } + +#ifndef SQLITE_OMIT_SUBQUERY + /* If we are creating a set for an "expr IN (SELECT ...)" construct, + ** then there should be a single item on the stack. Write this + ** item into the set table with bogus data. + */ + case SRT_Set: { + if( pSort ){ + /* At first glance you would think we could optimize out the + ** ORDER BY in this case since the order of entries in the set + ** does not matter. But there might be a LIMIT clause, in which + ** case the order does matter */ + pushOntoSorter( + pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg); + }else{ + int r1 = sqlite3GetTempReg(pParse); + assert( sqlite3Strlen30(pDest->zAffSdst)==nResultCol ); + sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult, nResultCol, + r1, pDest->zAffSdst, nResultCol); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, nResultCol); + sqlite3ReleaseTempReg(pParse, r1); + } + break; + } + + + /* If any row exist in the result set, record that fact and abort. + */ + case SRT_Exists: { + sqlite3VdbeAddOp2(v, OP_Integer, 1, iParm); + /* The LIMIT clause will terminate the loop for us */ + break; + } + + /* If this is a scalar select that is part of an expression, then + ** store the results in the appropriate memory cell or array of + ** memory cells and break out of the scan loop. + */ + case SRT_Mem: { + if( pSort ){ + assert( nResultCol<=pDest->nSdst ); + pushOntoSorter( + pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg); + }else{ + assert( nResultCol==pDest->nSdst ); + assert( regResult==iParm ); + /* The LIMIT clause will jump out of the loop for us */ + } + break; + } +#endif /* #ifndef SQLITE_OMIT_SUBQUERY */ + + case SRT_Coroutine: /* Send data to a co-routine */ + case SRT_Output: { /* Return the results */ + testcase( eDest==SRT_Coroutine ); + testcase( eDest==SRT_Output ); + if( pSort ){ + pushOntoSorter(pParse, pSort, p, regResult, regOrig, nResultCol, + nPrefixReg); + }else if( eDest==SRT_Coroutine ){ + sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm); + }else{ + sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, nResultCol); + } + break; + } + +#ifndef SQLITE_OMIT_CTE + /* Write the results into a priority queue that is order according to + ** pDest->pOrderBy (in pSO). pDest->iSDParm (in iParm) is the cursor for an + ** index with pSO->nExpr+2 columns. Build a key using pSO for the first + ** pSO->nExpr columns, then make sure all keys are unique by adding a + ** final OP_Sequence column. The last column is the record as a blob. + */ + case SRT_DistQueue: + case SRT_Queue: { + int nKey; + int r1, r2, r3; + int addrTest = 0; + ExprList *pSO; + pSO = pDest->pOrderBy; + assert( pSO ); + nKey = pSO->nExpr; + r1 = sqlite3GetTempReg(pParse); + r2 = sqlite3GetTempRange(pParse, nKey+2); + r3 = r2+nKey+1; + if( eDest==SRT_DistQueue ){ + /* If the destination is DistQueue, then cursor (iParm+1) is open + ** on a second ephemeral index that holds all values every previously + ** added to the queue. */ + addrTest = sqlite3VdbeAddOp4Int(v, OP_Found, iParm+1, 0, + regResult, nResultCol); + VdbeCoverage(v); + } + sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r3); + if( eDest==SRT_DistQueue ){ + sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm+1, r3); + sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT); + } + for(i=0; ia[i].u.x.iOrderByCol - 1, + r2+i); + } + sqlite3VdbeAddOp2(v, OP_Sequence, iParm, r2+nKey); + sqlite3VdbeAddOp3(v, OP_MakeRecord, r2, nKey+2, r1); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, r2, nKey+2); + if( addrTest ) sqlite3VdbeJumpHere(v, addrTest); + sqlite3ReleaseTempReg(pParse, r1); + sqlite3ReleaseTempRange(pParse, r2, nKey+2); + break; + } +#endif /* SQLITE_OMIT_CTE */ + + + +#if !defined(SQLITE_OMIT_TRIGGER) + /* Discard the results. This is used for SELECT statements inside + ** the body of a TRIGGER. The purpose of such selects is to call + ** user-defined functions that have side effects. We do not care + ** about the actual results of the select. + */ + default: { + assert( eDest==SRT_Discard ); + break; + } +#endif + } + + /* Jump to the end of the loop if the LIMIT is reached. Except, if + ** there is a sorter, in which case the sorter has already limited + ** the output for us. + */ + if( pSort==0 && p->iLimit ){ + sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v); + } +} + +/* +** Allocate a KeyInfo object sufficient for an index of N key columns and +** X extra columns. +*/ +SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoAlloc(sqlite3 *db, int N, int X){ + int nExtra = (N+X)*(sizeof(CollSeq*)+1) - sizeof(CollSeq*); + KeyInfo *p = sqlite3DbMallocRawNN(db, sizeof(KeyInfo) + nExtra); + if( p ){ + p->aSortFlags = (u8*)&p->aColl[N+X]; + p->nKeyField = (u16)N; + p->nAllField = (u16)(N+X); + p->enc = ENC(db); + p->db = db; + p->nRef = 1; + memset(&p[1], 0, nExtra); + }else{ + return (KeyInfo*)sqlite3OomFault(db); + } + return p; +} + +/* +** Deallocate a KeyInfo object +*/ +SQLITE_PRIVATE void sqlite3KeyInfoUnref(KeyInfo *p){ + if( p ){ + assert( p->db!=0 ); + assert( p->nRef>0 ); + p->nRef--; + if( p->nRef==0 ) sqlite3DbNNFreeNN(p->db, p); + } +} + +/* +** Make a new pointer to a KeyInfo object +*/ +SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoRef(KeyInfo *p){ + if( p ){ + assert( p->nRef>0 ); + p->nRef++; + } + return p; +} + +#ifdef SQLITE_DEBUG +/* +** Return TRUE if a KeyInfo object can be change. The KeyInfo object +** can only be changed if this is just a single reference to the object. +** +** This routine is used only inside of assert() statements. +*/ +SQLITE_PRIVATE int sqlite3KeyInfoIsWriteable(KeyInfo *p){ return p->nRef==1; } +#endif /* SQLITE_DEBUG */ + +/* +** Given an expression list, generate a KeyInfo structure that records +** the collating sequence for each expression in that expression list. +** +** If the ExprList is an ORDER BY or GROUP BY clause then the resulting +** KeyInfo structure is appropriate for initializing a virtual index to +** implement that clause. If the ExprList is the result set of a SELECT +** then the KeyInfo structure is appropriate for initializing a virtual +** index to implement a DISTINCT test. +** +** Space to hold the KeyInfo structure is obtained from malloc. The calling +** function is responsible for seeing that this structure is eventually +** freed. +*/ +SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoFromExprList( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* Form the KeyInfo object from this ExprList */ + int iStart, /* Begin with this column of pList */ + int nExtra /* Add this many extra columns to the end */ +){ + int nExpr; + KeyInfo *pInfo; + struct ExprList_item *pItem; + sqlite3 *db = pParse->db; + int i; + + nExpr = pList->nExpr; + pInfo = sqlite3KeyInfoAlloc(db, nExpr-iStart, nExtra+1); + if( pInfo ){ + assert( sqlite3KeyInfoIsWriteable(pInfo) ); + for(i=iStart, pItem=pList->a+iStart; iaColl[i-iStart] = sqlite3ExprNNCollSeq(pParse, pItem->pExpr); + pInfo->aSortFlags[i-iStart] = pItem->fg.sortFlags; + } + } + return pInfo; +} + +/* +** Name of the connection operator, used for error messages. +*/ +SQLITE_PRIVATE const char *sqlite3SelectOpName(int id){ + char *z; + switch( id ){ + case TK_ALL: z = "UNION ALL"; break; + case TK_INTERSECT: z = "INTERSECT"; break; + case TK_EXCEPT: z = "EXCEPT"; break; + default: z = "UNION"; break; + } + return z; +} + +#ifndef SQLITE_OMIT_EXPLAIN +/* +** Unless an "EXPLAIN QUERY PLAN" command is being processed, this function +** is a no-op. Otherwise, it adds a single row of output to the EQP result, +** where the caption is of the form: +** +** "USE TEMP B-TREE FOR xxx" +** +** where xxx is one of "DISTINCT", "ORDER BY" or "GROUP BY". Exactly which +** is determined by the zUsage argument. +*/ +static void explainTempTable(Parse *pParse, const char *zUsage){ + ExplainQueryPlan((pParse, 0, "USE TEMP B-TREE FOR %s", zUsage)); +} + +/* +** Assign expression b to lvalue a. A second, no-op, version of this macro +** is provided when SQLITE_OMIT_EXPLAIN is defined. This allows the code +** in sqlite3Select() to assign values to structure member variables that +** only exist if SQLITE_OMIT_EXPLAIN is not defined without polluting the +** code with #ifndef directives. +*/ +# define explainSetInteger(a, b) a = b + +#else +/* No-op versions of the explainXXX() functions and macros. */ +# define explainTempTable(y,z) +# define explainSetInteger(y,z) +#endif + + +/* +** If the inner loop was generated using a non-null pOrderBy argument, +** then the results were placed in a sorter. After the loop is terminated +** we need to run the sorter and output the results. The following +** routine generates the code needed to do that. +*/ +static void generateSortTail( + Parse *pParse, /* Parsing context */ + Select *p, /* The SELECT statement */ + SortCtx *pSort, /* Information on the ORDER BY clause */ + int nColumn, /* Number of columns of data */ + SelectDest *pDest /* Write the sorted results here */ +){ + Vdbe *v = pParse->pVdbe; /* The prepared statement */ + int addrBreak = pSort->labelDone; /* Jump here to exit loop */ + int addrContinue = sqlite3VdbeMakeLabel(pParse);/* Jump here for next cycle */ + int addr; /* Top of output loop. Jump for Next. */ + int addrOnce = 0; + int iTab; + ExprList *pOrderBy = pSort->pOrderBy; + int eDest = pDest->eDest; + int iParm = pDest->iSDParm; + int regRow; + int regRowid; + int iCol; + int nKey; /* Number of key columns in sorter record */ + int iSortTab; /* Sorter cursor to read from */ + int i; + int bSeq; /* True if sorter record includes seq. no. */ + int nRefKey = 0; + struct ExprList_item *aOutEx = p->pEList->a; +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + int addrExplain; /* Address of OP_Explain instruction */ +#endif + + ExplainQueryPlan2(addrExplain, (pParse, 0, + "USE TEMP B-TREE FOR %sORDER BY", pSort->nOBSat>0?"RIGHT PART OF ":"") + ); + sqlite3VdbeScanStatusRange(v, addrExplain,pSort->addrPush,pSort->addrPushEnd); + sqlite3VdbeScanStatusCounters(v, addrExplain, addrExplain, pSort->addrPush); + + + assert( addrBreak<0 ); + if( pSort->labelBkOut ){ + sqlite3VdbeAddOp2(v, OP_Gosub, pSort->regReturn, pSort->labelBkOut); + sqlite3VdbeGoto(v, addrBreak); + sqlite3VdbeResolveLabel(v, pSort->labelBkOut); + } + +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + /* Open any cursors needed for sorter-reference expressions */ + for(i=0; inDefer; i++){ + Table *pTab = pSort->aDefer[i].pTab; + int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + sqlite3OpenTable(pParse, pSort->aDefer[i].iCsr, iDb, pTab, OP_OpenRead); + nRefKey = MAX(nRefKey, pSort->aDefer[i].nKey); + } +#endif + + iTab = pSort->iECursor; + if( eDest==SRT_Output || eDest==SRT_Coroutine || eDest==SRT_Mem ){ + if( eDest==SRT_Mem && p->iOffset ){ + sqlite3VdbeAddOp2(v, OP_Null, 0, pDest->iSdst); + } + regRowid = 0; + regRow = pDest->iSdst; + }else{ + regRowid = sqlite3GetTempReg(pParse); + if( eDest==SRT_EphemTab || eDest==SRT_Table ){ + regRow = sqlite3GetTempReg(pParse); + nColumn = 0; + }else{ + regRow = sqlite3GetTempRange(pParse, nColumn); + } + } + nKey = pOrderBy->nExpr - pSort->nOBSat; + if( pSort->sortFlags & SORTFLAG_UseSorter ){ + int regSortOut = ++pParse->nMem; + iSortTab = pParse->nTab++; + if( pSort->labelBkOut ){ + addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); + } + sqlite3VdbeAddOp3(v, OP_OpenPseudo, iSortTab, regSortOut, + nKey+1+nColumn+nRefKey); + if( addrOnce ) sqlite3VdbeJumpHere(v, addrOnce); + addr = 1 + sqlite3VdbeAddOp2(v, OP_SorterSort, iTab, addrBreak); + VdbeCoverage(v); + assert( p->iLimit==0 && p->iOffset==0 ); + sqlite3VdbeAddOp3(v, OP_SorterData, iTab, regSortOut, iSortTab); + bSeq = 0; + }else{ + addr = 1 + sqlite3VdbeAddOp2(v, OP_Sort, iTab, addrBreak); VdbeCoverage(v); + codeOffset(v, p->iOffset, addrContinue); + iSortTab = iTab; + bSeq = 1; + if( p->iOffset>0 ){ + sqlite3VdbeAddOp2(v, OP_AddImm, p->iLimit, -1); + } + } + for(i=0, iCol=nKey+bSeq-1; inDefer ){ + int iKey = iCol+1; + int regKey = sqlite3GetTempRange(pParse, nRefKey); + + for(i=0; inDefer; i++){ + int iCsr = pSort->aDefer[i].iCsr; + Table *pTab = pSort->aDefer[i].pTab; + int nKey = pSort->aDefer[i].nKey; + + sqlite3VdbeAddOp1(v, OP_NullRow, iCsr); + if( HasRowid(pTab) ){ + sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iKey++, regKey); + sqlite3VdbeAddOp3(v, OP_SeekRowid, iCsr, + sqlite3VdbeCurrentAddr(v)+1, regKey); + }else{ + int k; + int iJmp; + assert( sqlite3PrimaryKeyIndex(pTab)->nKeyCol==nKey ); + for(k=0; k=0; i--){ +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + if( aOutEx[i].fg.bSorterRef ){ + sqlite3ExprCode(pParse, aOutEx[i].pExpr, regRow+i); + }else +#endif + { + int iRead; + if( aOutEx[i].u.x.iOrderByCol ){ + iRead = aOutEx[i].u.x.iOrderByCol-1; + }else{ + iRead = iCol--; + } + sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iRead, regRow+i); + VdbeComment((v, "%s", aOutEx[i].zEName)); + } + } + sqlite3VdbeScanStatusRange(v, addrExplain, addrExplain, -1); + switch( eDest ){ + case SRT_Table: + case SRT_EphemTab: { + sqlite3VdbeAddOp3(v, OP_Column, iSortTab, nKey+bSeq, regRow); + sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, regRowid); + sqlite3VdbeAddOp3(v, OP_Insert, iParm, regRow, regRowid); + sqlite3VdbeChangeP5(v, OPFLAG_APPEND); + break; + } +#ifndef SQLITE_OMIT_SUBQUERY + case SRT_Set: { + assert( nColumn==sqlite3Strlen30(pDest->zAffSdst) ); + sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, nColumn, regRowid, + pDest->zAffSdst, nColumn); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, regRowid, regRow, nColumn); + break; + } + case SRT_Mem: { + /* The LIMIT clause will terminate the loop for us */ + break; + } +#endif + case SRT_Upfrom: { + int i2 = pDest->iSDParm2; + int r1 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_MakeRecord,regRow+(i2<0),nColumn-(i2<0),r1); + if( i2<0 ){ + sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, regRow); + }else{ + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regRow, i2); + } + break; + } + default: { + assert( eDest==SRT_Output || eDest==SRT_Coroutine ); + testcase( eDest==SRT_Output ); + testcase( eDest==SRT_Coroutine ); + if( eDest==SRT_Output ){ + sqlite3VdbeAddOp2(v, OP_ResultRow, pDest->iSdst, nColumn); + }else{ + sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm); + } + break; + } + } + if( regRowid ){ + if( eDest==SRT_Set ){ + sqlite3ReleaseTempRange(pParse, regRow, nColumn); + }else{ + sqlite3ReleaseTempReg(pParse, regRow); + } + sqlite3ReleaseTempReg(pParse, regRowid); + } + /* The bottom of the loop + */ + sqlite3VdbeResolveLabel(v, addrContinue); + if( pSort->sortFlags & SORTFLAG_UseSorter ){ + sqlite3VdbeAddOp2(v, OP_SorterNext, iTab, addr); VdbeCoverage(v); + }else{ + sqlite3VdbeAddOp2(v, OP_Next, iTab, addr); VdbeCoverage(v); + } + sqlite3VdbeScanStatusRange(v, addrExplain, sqlite3VdbeCurrentAddr(v)-1, -1); + if( pSort->regReturn ) sqlite3VdbeAddOp1(v, OP_Return, pSort->regReturn); + sqlite3VdbeResolveLabel(v, addrBreak); +} + +/* +** Return a pointer to a string containing the 'declaration type' of the +** expression pExpr. The string may be treated as static by the caller. +** +** The declaration type is the exact datatype definition extracted from the +** original CREATE TABLE statement if the expression is a column. The +** declaration type for a ROWID field is INTEGER. Exactly when an expression +** is considered a column can be complex in the presence of subqueries. The +** result-set expression in all of the following SELECT statements is +** considered a column by this function. +** +** SELECT col FROM tbl; +** SELECT (SELECT col FROM tbl; +** SELECT (SELECT col FROM tbl); +** SELECT abc FROM (SELECT col AS abc FROM tbl); +** +** The declaration type for any expression other than a column is NULL. +** +** This routine has either 3 or 6 parameters depending on whether or not +** the SQLITE_ENABLE_COLUMN_METADATA compile-time option is used. +*/ +#ifdef SQLITE_ENABLE_COLUMN_METADATA +# define columnType(A,B,C,D,E) columnTypeImpl(A,B,C,D,E) +#else /* if !defined(SQLITE_ENABLE_COLUMN_METADATA) */ +# define columnType(A,B,C,D,E) columnTypeImpl(A,B) +#endif +static const char *columnTypeImpl( + NameContext *pNC, +#ifndef SQLITE_ENABLE_COLUMN_METADATA + Expr *pExpr +#else + Expr *pExpr, + const char **pzOrigDb, + const char **pzOrigTab, + const char **pzOrigCol +#endif +){ + char const *zType = 0; + int j; +#ifdef SQLITE_ENABLE_COLUMN_METADATA + char const *zOrigDb = 0; + char const *zOrigTab = 0; + char const *zOrigCol = 0; +#endif + + assert( pExpr!=0 ); + assert( pNC->pSrcList!=0 ); + switch( pExpr->op ){ + case TK_COLUMN: { + /* The expression is a column. Locate the table the column is being + ** extracted from in NameContext.pSrcList. This table may be real + ** database table or a subquery. + */ + Table *pTab = 0; /* Table structure column is extracted from */ + Select *pS = 0; /* Select the column is extracted from */ + int iCol = pExpr->iColumn; /* Index of column in pTab */ + while( pNC && !pTab ){ + SrcList *pTabList = pNC->pSrcList; + for(j=0;jnSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++); + if( jnSrc ){ + pTab = pTabList->a[j].pTab; + pS = pTabList->a[j].pSelect; + }else{ + pNC = pNC->pNext; + } + } + + if( pTab==0 ){ + /* At one time, code such as "SELECT new.x" within a trigger would + ** cause this condition to run. Since then, we have restructured how + ** trigger code is generated and so this condition is no longer + ** possible. However, it can still be true for statements like + ** the following: + ** + ** CREATE TABLE t1(col INTEGER); + ** SELECT (SELECT t1.col) FROM FROM t1; + ** + ** when columnType() is called on the expression "t1.col" in the + ** sub-select. In this case, set the column type to NULL, even + ** though it should really be "INTEGER". + ** + ** This is not a problem, as the column type of "t1.col" is never + ** used. When columnType() is called on the expression + ** "(SELECT t1.col)", the correct type is returned (see the TK_SELECT + ** branch below. */ + break; + } + + assert( pTab && ExprUseYTab(pExpr) && pExpr->y.pTab==pTab ); + if( pS ){ + /* The "table" is actually a sub-select or a view in the FROM clause + ** of the SELECT statement. Return the declaration type and origin + ** data for the result-set column of the sub-select. + */ + if( iColpEList->nExpr +#ifdef SQLITE_ALLOW_ROWID_IN_VIEW + && iCol>=0 +#else + && ALWAYS(iCol>=0) +#endif + ){ + /* If iCol is less than zero, then the expression requests the + ** rowid of the sub-select or view. This expression is legal (see + ** test case misc2.2.2) - it always evaluates to NULL. + */ + NameContext sNC; + Expr *p = pS->pEList->a[iCol].pExpr; + sNC.pSrcList = pS->pSrc; + sNC.pNext = pNC; + sNC.pParse = pNC->pParse; + zType = columnType(&sNC, p,&zOrigDb,&zOrigTab,&zOrigCol); + } + }else{ + /* A real table or a CTE table */ + assert( !pS ); +#ifdef SQLITE_ENABLE_COLUMN_METADATA + if( iCol<0 ) iCol = pTab->iPKey; + assert( iCol==XN_ROWID || (iCol>=0 && iColnCol) ); + if( iCol<0 ){ + zType = "INTEGER"; + zOrigCol = "rowid"; + }else{ + zOrigCol = pTab->aCol[iCol].zCnName; + zType = sqlite3ColumnType(&pTab->aCol[iCol],0); + } + zOrigTab = pTab->zName; + if( pNC->pParse && pTab->pSchema ){ + int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema); + zOrigDb = pNC->pParse->db->aDb[iDb].zDbSName; + } +#else + assert( iCol==XN_ROWID || (iCol>=0 && iColnCol) ); + if( iCol<0 ){ + zType = "INTEGER"; + }else{ + zType = sqlite3ColumnType(&pTab->aCol[iCol],0); + } +#endif + } + break; + } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_SELECT: { + /* The expression is a sub-select. Return the declaration type and + ** origin info for the single column in the result set of the SELECT + ** statement. + */ + NameContext sNC; + Select *pS; + Expr *p; + assert( ExprUseXSelect(pExpr) ); + pS = pExpr->x.pSelect; + p = pS->pEList->a[0].pExpr; + sNC.pSrcList = pS->pSrc; + sNC.pNext = pNC; + sNC.pParse = pNC->pParse; + zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol); + break; + } +#endif + } + +#ifdef SQLITE_ENABLE_COLUMN_METADATA + if( pzOrigDb ){ + assert( pzOrigTab && pzOrigCol ); + *pzOrigDb = zOrigDb; + *pzOrigTab = zOrigTab; + *pzOrigCol = zOrigCol; + } +#endif + return zType; +} + +/* +** Generate code that will tell the VDBE the declaration types of columns +** in the result set. +*/ +static void generateColumnTypes( + Parse *pParse, /* Parser context */ + SrcList *pTabList, /* List of tables */ + ExprList *pEList /* Expressions defining the result set */ +){ +#ifndef SQLITE_OMIT_DECLTYPE + Vdbe *v = pParse->pVdbe; + int i; + NameContext sNC; + sNC.pSrcList = pTabList; + sNC.pParse = pParse; + sNC.pNext = 0; + for(i=0; inExpr; i++){ + Expr *p = pEList->a[i].pExpr; + const char *zType; +#ifdef SQLITE_ENABLE_COLUMN_METADATA + const char *zOrigDb = 0; + const char *zOrigTab = 0; + const char *zOrigCol = 0; + zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol); + + /* The vdbe must make its own copy of the column-type and other + ** column specific strings, in case the schema is reset before this + ** virtual machine is deleted. + */ + sqlite3VdbeSetColName(v, i, COLNAME_DATABASE, zOrigDb, SQLITE_TRANSIENT); + sqlite3VdbeSetColName(v, i, COLNAME_TABLE, zOrigTab, SQLITE_TRANSIENT); + sqlite3VdbeSetColName(v, i, COLNAME_COLUMN, zOrigCol, SQLITE_TRANSIENT); +#else + zType = columnType(&sNC, p, 0, 0, 0); +#endif + sqlite3VdbeSetColName(v, i, COLNAME_DECLTYPE, zType, SQLITE_TRANSIENT); + } +#endif /* !defined(SQLITE_OMIT_DECLTYPE) */ +} + + +/* +** Compute the column names for a SELECT statement. +** +** The only guarantee that SQLite makes about column names is that if the +** column has an AS clause assigning it a name, that will be the name used. +** That is the only documented guarantee. However, countless applications +** developed over the years have made baseless assumptions about column names +** and will break if those assumptions changes. Hence, use extreme caution +** when modifying this routine to avoid breaking legacy. +** +** See Also: sqlite3ColumnsFromExprList() +** +** The PRAGMA short_column_names and PRAGMA full_column_names settings are +** deprecated. The default setting is short=ON, full=OFF. 99.9% of all +** applications should operate this way. Nevertheless, we need to support the +** other modes for legacy: +** +** short=OFF, full=OFF: Column name is the text of the expression has it +** originally appears in the SELECT statement. In +** other words, the zSpan of the result expression. +** +** short=ON, full=OFF: (This is the default setting). If the result +** refers directly to a table column, then the +** result column name is just the table column +** name: COLUMN. Otherwise use zSpan. +** +** full=ON, short=ANY: If the result refers directly to a table column, +** then the result column name with the table name +** prefix, ex: TABLE.COLUMN. Otherwise use zSpan. +*/ +SQLITE_PRIVATE void sqlite3GenerateColumnNames( + Parse *pParse, /* Parser context */ + Select *pSelect /* Generate column names for this SELECT statement */ +){ + Vdbe *v = pParse->pVdbe; + int i; + Table *pTab; + SrcList *pTabList; + ExprList *pEList; + sqlite3 *db = pParse->db; + int fullName; /* TABLE.COLUMN if no AS clause and is a direct table ref */ + int srcName; /* COLUMN or TABLE.COLUMN if no AS clause and is direct */ + +#ifndef SQLITE_OMIT_EXPLAIN + /* If this is an EXPLAIN, skip this step */ + if( pParse->explain ){ + return; + } +#endif + + if( pParse->colNamesSet ) return; + /* Column names are determined by the left-most term of a compound select */ + while( pSelect->pPrior ) pSelect = pSelect->pPrior; + TREETRACE(0x80,pParse,pSelect,("generating column names\n")); + pTabList = pSelect->pSrc; + pEList = pSelect->pEList; + assert( v!=0 ); + assert( pTabList!=0 ); + pParse->colNamesSet = 1; + fullName = (db->flags & SQLITE_FullColNames)!=0; + srcName = (db->flags & SQLITE_ShortColNames)!=0 || fullName; + sqlite3VdbeSetNumCols(v, pEList->nExpr); + for(i=0; inExpr; i++){ + Expr *p = pEList->a[i].pExpr; + + assert( p!=0 ); + assert( p->op!=TK_AGG_COLUMN ); /* Agg processing has not run yet */ + assert( p->op!=TK_COLUMN + || (ExprUseYTab(p) && p->y.pTab!=0) ); /* Covering idx not yet coded */ + if( pEList->a[i].zEName && pEList->a[i].fg.eEName==ENAME_NAME ){ + /* An AS clause always takes first priority */ + char *zName = pEList->a[i].zEName; + sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_TRANSIENT); + }else if( srcName && p->op==TK_COLUMN ){ + char *zCol; + int iCol = p->iColumn; + pTab = p->y.pTab; + assert( pTab!=0 ); + if( iCol<0 ) iCol = pTab->iPKey; + assert( iCol==-1 || (iCol>=0 && iColnCol) ); + if( iCol<0 ){ + zCol = "rowid"; + }else{ + zCol = pTab->aCol[iCol].zCnName; + } + if( fullName ){ + char *zName = 0; + zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol); + sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_DYNAMIC); + }else{ + sqlite3VdbeSetColName(v, i, COLNAME_NAME, zCol, SQLITE_TRANSIENT); + } + }else{ + const char *z = pEList->a[i].zEName; + z = z==0 ? sqlite3MPrintf(db, "column%d", i+1) : sqlite3DbStrDup(db, z); + sqlite3VdbeSetColName(v, i, COLNAME_NAME, z, SQLITE_DYNAMIC); + } + } + generateColumnTypes(pParse, pTabList, pEList); +} + +/* +** Given an expression list (which is really the list of expressions +** that form the result set of a SELECT statement) compute appropriate +** column names for a table that would hold the expression list. +** +** All column names will be unique. +** +** Only the column names are computed. Column.zType, Column.zColl, +** and other fields of Column are zeroed. +** +** Return SQLITE_OK on success. If a memory allocation error occurs, +** store NULL in *paCol and 0 in *pnCol and return SQLITE_NOMEM. +** +** The only guarantee that SQLite makes about column names is that if the +** column has an AS clause assigning it a name, that will be the name used. +** That is the only documented guarantee. However, countless applications +** developed over the years have made baseless assumptions about column names +** and will break if those assumptions changes. Hence, use extreme caution +** when modifying this routine to avoid breaking legacy. +** +** See Also: sqlite3GenerateColumnNames() +*/ +SQLITE_PRIVATE int sqlite3ColumnsFromExprList( + Parse *pParse, /* Parsing context */ + ExprList *pEList, /* Expr list from which to derive column names */ + i16 *pnCol, /* Write the number of columns here */ + Column **paCol /* Write the new column list here */ +){ + sqlite3 *db = pParse->db; /* Database connection */ + int i, j; /* Loop counters */ + u32 cnt; /* Index added to make the name unique */ + Column *aCol, *pCol; /* For looping over result columns */ + int nCol; /* Number of columns in the result set */ + char *zName; /* Column name */ + int nName; /* Size of name in zName[] */ + Hash ht; /* Hash table of column names */ + Table *pTab; + + sqlite3HashInit(&ht); + if( pEList ){ + nCol = pEList->nExpr; + aCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol); + testcase( aCol==0 ); + if( NEVER(nCol>32767) ) nCol = 32767; + }else{ + nCol = 0; + aCol = 0; + } + assert( nCol==(i16)nCol ); + *pnCol = nCol; + *paCol = aCol; + + for(i=0, pCol=aCol; inErr; i++, pCol++){ + struct ExprList_item *pX = &pEList->a[i]; + struct ExprList_item *pCollide; + /* Get an appropriate name for the column + */ + if( (zName = pX->zEName)!=0 && pX->fg.eEName==ENAME_NAME ){ + /* If the column contains an "AS " phrase, use as the name */ + }else{ + Expr *pColExpr = sqlite3ExprSkipCollateAndLikely(pX->pExpr); + while( ALWAYS(pColExpr!=0) && pColExpr->op==TK_DOT ){ + pColExpr = pColExpr->pRight; + assert( pColExpr!=0 ); + } + if( pColExpr->op==TK_COLUMN + && ALWAYS( ExprUseYTab(pColExpr) ) + && ALWAYS( pColExpr->y.pTab!=0 ) + ){ + /* For columns use the column name name */ + int iCol = pColExpr->iColumn; + pTab = pColExpr->y.pTab; + if( iCol<0 ) iCol = pTab->iPKey; + zName = iCol>=0 ? pTab->aCol[iCol].zCnName : "rowid"; + }else if( pColExpr->op==TK_ID ){ + assert( !ExprHasProperty(pColExpr, EP_IntValue) ); + zName = pColExpr->u.zToken; + }else{ + /* Use the original text of the column expression as its name */ + assert( zName==pX->zEName ); /* pointer comparison intended */ + } + } + if( zName && !sqlite3IsTrueOrFalse(zName) ){ + zName = sqlite3DbStrDup(db, zName); + }else{ + zName = sqlite3MPrintf(db,"column%d",i+1); + } + + /* Make sure the column name is unique. If the name is not unique, + ** append an integer to the name so that it becomes unique. + */ + cnt = 0; + while( zName && (pCollide = sqlite3HashFind(&ht, zName))!=0 ){ + if( pCollide->fg.bUsingTerm ){ + pCol->colFlags |= COLFLAG_NOEXPAND; + } + nName = sqlite3Strlen30(zName); + if( nName>0 ){ + for(j=nName-1; j>0 && sqlite3Isdigit(zName[j]); j--){} + if( zName[j]==':' ) nName = j; + } + zName = sqlite3MPrintf(db, "%.*z:%u", nName, zName, ++cnt); + sqlite3ProgressCheck(pParse); + if( cnt>3 ){ + sqlite3_randomness(sizeof(cnt), &cnt); + } + } + pCol->zCnName = zName; + pCol->hName = sqlite3StrIHash(zName); + if( pX->fg.bNoExpand ){ + pCol->colFlags |= COLFLAG_NOEXPAND; + } + sqlite3ColumnPropertiesFromName(0, pCol); + if( zName && sqlite3HashInsert(&ht, zName, pX)==pX ){ + sqlite3OomFault(db); + } + } + sqlite3HashClear(&ht); + if( pParse->nErr ){ + for(j=0; jrc; + } + return SQLITE_OK; +} + +/* +** pTab is a transient Table object that represents a subquery of some +** kind (maybe a parenthesized subquery in the FROM clause of a larger +** query, or a VIEW, or a CTE). This routine computes type information +** for that Table object based on the Select object that implements the +** subquery. For the purposes of this routine, "type infomation" means: +** +** * The datatype name, as it might appear in a CREATE TABLE statement +** * Which collating sequence to use for the column +** * The affinity of the column +*/ +SQLITE_PRIVATE void sqlite3SubqueryColumnTypes( + Parse *pParse, /* Parsing contexts */ + Table *pTab, /* Add column type information to this table */ + Select *pSelect, /* SELECT used to determine types and collations */ + char aff /* Default affinity. */ +){ + sqlite3 *db = pParse->db; + Column *pCol; + CollSeq *pColl; + int i,j; + Expr *p; + struct ExprList_item *a; + NameContext sNC; + + assert( pSelect!=0 ); + assert( (pSelect->selFlags & SF_Resolved)!=0 ); + assert( pTab->nCol==pSelect->pEList->nExpr || pParse->nErr>0 ); + assert( aff==SQLITE_AFF_NONE || aff==SQLITE_AFF_BLOB ); + if( db->mallocFailed || IN_RENAME_OBJECT ) return; + while( pSelect->pPrior ) pSelect = pSelect->pPrior; + a = pSelect->pEList->a; + memset(&sNC, 0, sizeof(sNC)); + sNC.pSrcList = pSelect->pSrc; + for(i=0, pCol=pTab->aCol; inCol; i++, pCol++){ + const char *zType; + i64 n; + pTab->tabFlags |= (pCol->colFlags & COLFLAG_NOINSERT); + p = a[i].pExpr; + /* pCol->szEst = ... // Column size est for SELECT tables never used */ + pCol->affinity = sqlite3ExprAffinity(p); + if( pCol->affinity<=SQLITE_AFF_NONE ){ + pCol->affinity = aff; + } + if( pCol->affinity>=SQLITE_AFF_TEXT && pSelect->pNext ){ + int m = 0; + Select *pS2; + for(m=0, pS2=pSelect->pNext; pS2; pS2=pS2->pNext){ + m |= sqlite3ExprDataType(pS2->pEList->a[i].pExpr); + } + if( pCol->affinity==SQLITE_AFF_TEXT && (m&0x01)!=0 ){ + pCol->affinity = SQLITE_AFF_BLOB; + }else + if( pCol->affinity>=SQLITE_AFF_NUMERIC && (m&0x02)!=0 ){ + pCol->affinity = SQLITE_AFF_BLOB; + } + if( pCol->affinity>=SQLITE_AFF_NUMERIC && p->op==TK_CAST ){ + pCol->affinity = SQLITE_AFF_FLEXNUM; + } + } + zType = columnType(&sNC, p, 0, 0, 0); + if( zType==0 || pCol->affinity!=sqlite3AffinityType(zType, 0) ){ + if( pCol->affinity==SQLITE_AFF_NUMERIC + || pCol->affinity==SQLITE_AFF_FLEXNUM + ){ + zType = "NUM"; + }else{ + zType = 0; + for(j=1; jaffinity ){ + zType = sqlite3StdType[j]; + break; + } + } + } + } + if( zType ){ + i64 m = sqlite3Strlen30(zType); + n = sqlite3Strlen30(pCol->zCnName); + pCol->zCnName = sqlite3DbReallocOrFree(db, pCol->zCnName, n+m+2); + pCol->colFlags &= ~(COLFLAG_HASTYPE|COLFLAG_HASCOLL); + if( pCol->zCnName ){ + memcpy(&pCol->zCnName[n+1], zType, m+1); + pCol->colFlags |= COLFLAG_HASTYPE; + } + } + pColl = sqlite3ExprCollSeq(pParse, p); + if( pColl ){ + assert( pTab->pIndex==0 ); + sqlite3ColumnSetColl(db, pCol, pColl->zName); + } + } + pTab->szTabRow = 1; /* Any non-zero value works */ +} + +/* +** Given a SELECT statement, generate a Table structure that describes +** the result set of that SELECT. +*/ +SQLITE_PRIVATE Table *sqlite3ResultSetOfSelect(Parse *pParse, Select *pSelect, char aff){ + Table *pTab; + sqlite3 *db = pParse->db; + u64 savedFlags; + + savedFlags = db->flags; + db->flags &= ~(u64)SQLITE_FullColNames; + db->flags |= SQLITE_ShortColNames; + sqlite3SelectPrep(pParse, pSelect, 0); + db->flags = savedFlags; + if( pParse->nErr ) return 0; + while( pSelect->pPrior ) pSelect = pSelect->pPrior; + pTab = sqlite3DbMallocZero(db, sizeof(Table) ); + if( pTab==0 ){ + return 0; + } + pTab->nTabRef = 1; + pTab->zName = 0; + pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) ); + sqlite3ColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol); + sqlite3SubqueryColumnTypes(pParse, pTab, pSelect, aff); + pTab->iPKey = -1; + if( db->mallocFailed ){ + sqlite3DeleteTable(db, pTab); + return 0; + } + return pTab; +} + +/* +** Get a VDBE for the given parser context. Create a new one if necessary. +** If an error occurs, return NULL and leave a message in pParse. +*/ +SQLITE_PRIVATE Vdbe *sqlite3GetVdbe(Parse *pParse){ + if( pParse->pVdbe ){ + return pParse->pVdbe; + } + if( pParse->pToplevel==0 + && OptimizationEnabled(pParse->db,SQLITE_FactorOutConst) + ){ + pParse->okConstFactor = 1; + } + return sqlite3VdbeCreate(pParse); +} + + +/* +** Compute the iLimit and iOffset fields of the SELECT based on the +** pLimit expressions. pLimit->pLeft and pLimit->pRight hold the expressions +** that appear in the original SQL statement after the LIMIT and OFFSET +** keywords. Or NULL if those keywords are omitted. iLimit and iOffset +** are the integer memory register numbers for counters used to compute +** the limit and offset. If there is no limit and/or offset, then +** iLimit and iOffset are negative. +** +** This routine changes the values of iLimit and iOffset only if +** a limit or offset is defined by pLimit->pLeft and pLimit->pRight. iLimit +** and iOffset should have been preset to appropriate default values (zero) +** prior to calling this routine. +** +** The iOffset register (if it exists) is initialized to the value +** of the OFFSET. The iLimit register is initialized to LIMIT. Register +** iOffset+1 is initialized to LIMIT+OFFSET. +** +** Only if pLimit->pLeft!=0 do the limit registers get +** redefined. The UNION ALL operator uses this property to force +** the reuse of the same limit and offset registers across multiple +** SELECT statements. +*/ +static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){ + Vdbe *v = 0; + int iLimit = 0; + int iOffset; + int n; + Expr *pLimit = p->pLimit; + + if( p->iLimit ) return; + + /* + ** "LIMIT -1" always shows all rows. There is some + ** controversy about what the correct behavior should be. + ** The current implementation interprets "LIMIT 0" to mean + ** no rows. + */ + if( pLimit ){ + assert( pLimit->op==TK_LIMIT ); + assert( pLimit->pLeft!=0 ); + p->iLimit = iLimit = ++pParse->nMem; + v = sqlite3GetVdbe(pParse); + assert( v!=0 ); + if( sqlite3ExprIsInteger(pLimit->pLeft, &n) ){ + sqlite3VdbeAddOp2(v, OP_Integer, n, iLimit); + VdbeComment((v, "LIMIT counter")); + if( n==0 ){ + sqlite3VdbeGoto(v, iBreak); + }else if( n>=0 && p->nSelectRow>sqlite3LogEst((u64)n) ){ + p->nSelectRow = sqlite3LogEst((u64)n); + p->selFlags |= SF_FixedLimit; + } + }else{ + sqlite3ExprCode(pParse, pLimit->pLeft, iLimit); + sqlite3VdbeAddOp1(v, OP_MustBeInt, iLimit); VdbeCoverage(v); + VdbeComment((v, "LIMIT counter")); + sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, iBreak); VdbeCoverage(v); + } + if( pLimit->pRight ){ + p->iOffset = iOffset = ++pParse->nMem; + pParse->nMem++; /* Allocate an extra register for limit+offset */ + sqlite3ExprCode(pParse, pLimit->pRight, iOffset); + sqlite3VdbeAddOp1(v, OP_MustBeInt, iOffset); VdbeCoverage(v); + VdbeComment((v, "OFFSET counter")); + sqlite3VdbeAddOp3(v, OP_OffsetLimit, iLimit, iOffset+1, iOffset); + VdbeComment((v, "LIMIT+OFFSET")); + } + } +} + +#ifndef SQLITE_OMIT_COMPOUND_SELECT +/* +** Return the appropriate collating sequence for the iCol-th column of +** the result set for the compound-select statement "p". Return NULL if +** the column has no default collating sequence. +** +** The collating sequence for the compound select is taken from the +** left-most term of the select that has a collating sequence. +*/ +static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){ + CollSeq *pRet; + if( p->pPrior ){ + pRet = multiSelectCollSeq(pParse, p->pPrior, iCol); + }else{ + pRet = 0; + } + assert( iCol>=0 ); + /* iCol must be less than p->pEList->nExpr. Otherwise an error would + ** have been thrown during name resolution and we would not have gotten + ** this far */ + if( pRet==0 && ALWAYS(iColpEList->nExpr) ){ + pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr); + } + return pRet; +} + +/* +** The select statement passed as the second parameter is a compound SELECT +** with an ORDER BY clause. This function allocates and returns a KeyInfo +** structure suitable for implementing the ORDER BY. +** +** Space to hold the KeyInfo structure is obtained from malloc. The calling +** function is responsible for ensuring that this structure is eventually +** freed. +*/ +static KeyInfo *multiSelectOrderByKeyInfo(Parse *pParse, Select *p, int nExtra){ + ExprList *pOrderBy = p->pOrderBy; + int nOrderBy = ALWAYS(pOrderBy!=0) ? pOrderBy->nExpr : 0; + sqlite3 *db = pParse->db; + KeyInfo *pRet = sqlite3KeyInfoAlloc(db, nOrderBy+nExtra, 1); + if( pRet ){ + int i; + for(i=0; ia[i]; + Expr *pTerm = pItem->pExpr; + CollSeq *pColl; + + if( pTerm->flags & EP_Collate ){ + pColl = sqlite3ExprCollSeq(pParse, pTerm); + }else{ + pColl = multiSelectCollSeq(pParse, p, pItem->u.x.iOrderByCol-1); + if( pColl==0 ) pColl = db->pDfltColl; + pOrderBy->a[i].pExpr = + sqlite3ExprAddCollateString(pParse, pTerm, pColl->zName); + } + assert( sqlite3KeyInfoIsWriteable(pRet) ); + pRet->aColl[i] = pColl; + pRet->aSortFlags[i] = pOrderBy->a[i].fg.sortFlags; + } + } + + return pRet; +} + +#ifndef SQLITE_OMIT_CTE +/* +** This routine generates VDBE code to compute the content of a WITH RECURSIVE +** query of the form: +** +** AS ( UNION [ALL] ) +** \___________/ \_______________/ +** p->pPrior p +** +** +** There is exactly one reference to the recursive-table in the FROM clause +** of recursive-query, marked with the SrcList->a[].fg.isRecursive flag. +** +** The setup-query runs once to generate an initial set of rows that go +** into a Queue table. Rows are extracted from the Queue table one by +** one. Each row extracted from Queue is output to pDest. Then the single +** extracted row (now in the iCurrent table) becomes the content of the +** recursive-table for a recursive-query run. The output of the recursive-query +** is added back into the Queue table. Then another row is extracted from Queue +** and the iteration continues until the Queue table is empty. +** +** If the compound query operator is UNION then no duplicate rows are ever +** inserted into the Queue table. The iDistinct table keeps a copy of all rows +** that have ever been inserted into Queue and causes duplicates to be +** discarded. If the operator is UNION ALL, then duplicates are allowed. +** +** If the query has an ORDER BY, then entries in the Queue table are kept in +** ORDER BY order and the first entry is extracted for each cycle. Without +** an ORDER BY, the Queue table is just a FIFO. +** +** If a LIMIT clause is provided, then the iteration stops after LIMIT rows +** have been output to pDest. A LIMIT of zero means to output no rows and a +** negative LIMIT means to output all rows. If there is also an OFFSET clause +** with a positive value, then the first OFFSET outputs are discarded rather +** than being sent to pDest. The LIMIT count does not begin until after OFFSET +** rows have been skipped. +*/ +static void generateWithRecursiveQuery( + Parse *pParse, /* Parsing context */ + Select *p, /* The recursive SELECT to be coded */ + SelectDest *pDest /* What to do with query results */ +){ + SrcList *pSrc = p->pSrc; /* The FROM clause of the recursive query */ + int nCol = p->pEList->nExpr; /* Number of columns in the recursive table */ + Vdbe *v = pParse->pVdbe; /* The prepared statement under construction */ + Select *pSetup; /* The setup query */ + Select *pFirstRec; /* Left-most recursive term */ + int addrTop; /* Top of the loop */ + int addrCont, addrBreak; /* CONTINUE and BREAK addresses */ + int iCurrent = 0; /* The Current table */ + int regCurrent; /* Register holding Current table */ + int iQueue; /* The Queue table */ + int iDistinct = 0; /* To ensure unique results if UNION */ + int eDest = SRT_Fifo; /* How to write to Queue */ + SelectDest destQueue; /* SelectDest targetting the Queue table */ + int i; /* Loop counter */ + int rc; /* Result code */ + ExprList *pOrderBy; /* The ORDER BY clause */ + Expr *pLimit; /* Saved LIMIT and OFFSET */ + int regLimit, regOffset; /* Registers used by LIMIT and OFFSET */ + +#ifndef SQLITE_OMIT_WINDOWFUNC + if( p->pWin ){ + sqlite3ErrorMsg(pParse, "cannot use window functions in recursive queries"); + return; + } +#endif + + /* Obtain authorization to do a recursive query */ + if( sqlite3AuthCheck(pParse, SQLITE_RECURSIVE, 0, 0, 0) ) return; + + /* Process the LIMIT and OFFSET clauses, if they exist */ + addrBreak = sqlite3VdbeMakeLabel(pParse); + p->nSelectRow = 320; /* 4 billion rows */ + computeLimitRegisters(pParse, p, addrBreak); + pLimit = p->pLimit; + regLimit = p->iLimit; + regOffset = p->iOffset; + p->pLimit = 0; + p->iLimit = p->iOffset = 0; + pOrderBy = p->pOrderBy; + + /* Locate the cursor number of the Current table */ + for(i=0; ALWAYS(inSrc); i++){ + if( pSrc->a[i].fg.isRecursive ){ + iCurrent = pSrc->a[i].iCursor; + break; + } + } + + /* Allocate cursors numbers for Queue and Distinct. The cursor number for + ** the Distinct table must be exactly one greater than Queue in order + ** for the SRT_DistFifo and SRT_DistQueue destinations to work. */ + iQueue = pParse->nTab++; + if( p->op==TK_UNION ){ + eDest = pOrderBy ? SRT_DistQueue : SRT_DistFifo; + iDistinct = pParse->nTab++; + }else{ + eDest = pOrderBy ? SRT_Queue : SRT_Fifo; + } + sqlite3SelectDestInit(&destQueue, eDest, iQueue); + + /* Allocate cursors for Current, Queue, and Distinct. */ + regCurrent = ++pParse->nMem; + sqlite3VdbeAddOp3(v, OP_OpenPseudo, iCurrent, regCurrent, nCol); + if( pOrderBy ){ + KeyInfo *pKeyInfo = multiSelectOrderByKeyInfo(pParse, p, 1); + sqlite3VdbeAddOp4(v, OP_OpenEphemeral, iQueue, pOrderBy->nExpr+2, 0, + (char*)pKeyInfo, P4_KEYINFO); + destQueue.pOrderBy = pOrderBy; + }else{ + sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iQueue, nCol); + } + VdbeComment((v, "Queue table")); + if( iDistinct ){ + p->addrOpenEphm[0] = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iDistinct, 0); + p->selFlags |= SF_UsesEphemeral; + } + + /* Detach the ORDER BY clause from the compound SELECT */ + p->pOrderBy = 0; + + /* Figure out how many elements of the compound SELECT are part of the + ** recursive query. Make sure no recursive elements use aggregate + ** functions. Mark the recursive elements as UNION ALL even if they + ** are really UNION because the distinctness will be enforced by the + ** iDistinct table. pFirstRec is left pointing to the left-most + ** recursive term of the CTE. + */ + for(pFirstRec=p; ALWAYS(pFirstRec!=0); pFirstRec=pFirstRec->pPrior){ + if( pFirstRec->selFlags & SF_Aggregate ){ + sqlite3ErrorMsg(pParse, "recursive aggregate queries not supported"); + goto end_of_recursive_query; + } + pFirstRec->op = TK_ALL; + if( (pFirstRec->pPrior->selFlags & SF_Recursive)==0 ) break; + } + + /* Store the results of the setup-query in Queue. */ + pSetup = pFirstRec->pPrior; + pSetup->pNext = 0; + ExplainQueryPlan((pParse, 1, "SETUP")); + rc = sqlite3Select(pParse, pSetup, &destQueue); + pSetup->pNext = p; + if( rc ) goto end_of_recursive_query; + + /* Find the next row in the Queue and output that row */ + addrTop = sqlite3VdbeAddOp2(v, OP_Rewind, iQueue, addrBreak); VdbeCoverage(v); + + /* Transfer the next row in Queue over to Current */ + sqlite3VdbeAddOp1(v, OP_NullRow, iCurrent); /* To reset column cache */ + if( pOrderBy ){ + sqlite3VdbeAddOp3(v, OP_Column, iQueue, pOrderBy->nExpr+1, regCurrent); + }else{ + sqlite3VdbeAddOp2(v, OP_RowData, iQueue, regCurrent); + } + sqlite3VdbeAddOp1(v, OP_Delete, iQueue); + + /* Output the single row in Current */ + addrCont = sqlite3VdbeMakeLabel(pParse); + codeOffset(v, regOffset, addrCont); + selectInnerLoop(pParse, p, iCurrent, + 0, 0, pDest, addrCont, addrBreak); + if( regLimit ){ + sqlite3VdbeAddOp2(v, OP_DecrJumpZero, regLimit, addrBreak); + VdbeCoverage(v); + } + sqlite3VdbeResolveLabel(v, addrCont); + + /* Execute the recursive SELECT taking the single row in Current as + ** the value for the recursive-table. Store the results in the Queue. + */ + pFirstRec->pPrior = 0; + ExplainQueryPlan((pParse, 1, "RECURSIVE STEP")); + sqlite3Select(pParse, p, &destQueue); + assert( pFirstRec->pPrior==0 ); + pFirstRec->pPrior = pSetup; + + /* Keep running the loop until the Queue is empty */ + sqlite3VdbeGoto(v, addrTop); + sqlite3VdbeResolveLabel(v, addrBreak); + +end_of_recursive_query: + sqlite3ExprListDelete(pParse->db, p->pOrderBy); + p->pOrderBy = pOrderBy; + p->pLimit = pLimit; + return; +} +#endif /* SQLITE_OMIT_CTE */ + +/* Forward references */ +static int multiSelectOrderBy( + Parse *pParse, /* Parsing context */ + Select *p, /* The right-most of SELECTs to be coded */ + SelectDest *pDest /* What to do with query results */ +); + +/* +** Handle the special case of a compound-select that originates from a +** VALUES clause. By handling this as a special case, we avoid deep +** recursion, and thus do not need to enforce the SQLITE_LIMIT_COMPOUND_SELECT +** on a VALUES clause. +** +** Because the Select object originates from a VALUES clause: +** (1) There is no LIMIT or OFFSET or else there is a LIMIT of exactly 1 +** (2) All terms are UNION ALL +** (3) There is no ORDER BY clause +** +** The "LIMIT of exactly 1" case of condition (1) comes about when a VALUES +** clause occurs within scalar expression (ex: "SELECT (VALUES(1),(2),(3))"). +** The sqlite3CodeSubselect will have added the LIMIT 1 clause in tht case. +** Since the limit is exactly 1, we only need to evaluate the left-most VALUES. +*/ +static int multiSelectValues( + Parse *pParse, /* Parsing context */ + Select *p, /* The right-most of SELECTs to be coded */ + SelectDest *pDest /* What to do with query results */ +){ + int nRow = 1; + int rc = 0; + int bShowAll = p->pLimit==0; + assert( p->selFlags & SF_MultiValue ); + do{ + assert( p->selFlags & SF_Values ); + assert( p->op==TK_ALL || (p->op==TK_SELECT && p->pPrior==0) ); + assert( p->pNext==0 || p->pEList->nExpr==p->pNext->pEList->nExpr ); +#ifndef SQLITE_OMIT_WINDOWFUNC + if( p->pWin ) return -1; +#endif + if( p->pPrior==0 ) break; + assert( p->pPrior->pNext==p ); + p = p->pPrior; + nRow += bShowAll; + }while(1); + ExplainQueryPlan((pParse, 0, "SCAN %d CONSTANT ROW%s", nRow, + nRow==1 ? "" : "S")); + while( p ){ + selectInnerLoop(pParse, p, -1, 0, 0, pDest, 1, 1); + if( !bShowAll ) break; + p->nSelectRow = nRow; + p = p->pNext; + } + return rc; +} + +/* +** Return true if the SELECT statement which is known to be the recursive +** part of a recursive CTE still has its anchor terms attached. If the +** anchor terms have already been removed, then return false. +*/ +static int hasAnchor(Select *p){ + while( p && (p->selFlags & SF_Recursive)!=0 ){ p = p->pPrior; } + return p!=0; +} + +/* +** This routine is called to process a compound query form from +** two or more separate queries using UNION, UNION ALL, EXCEPT, or +** INTERSECT +** +** "p" points to the right-most of the two queries. the query on the +** left is p->pPrior. The left query could also be a compound query +** in which case this routine will be called recursively. +** +** The results of the total query are to be written into a destination +** of type eDest with parameter iParm. +** +** Example 1: Consider a three-way compound SQL statement. +** +** SELECT a FROM t1 UNION SELECT b FROM t2 UNION SELECT c FROM t3 +** +** This statement is parsed up as follows: +** +** SELECT c FROM t3 +** | +** `-----> SELECT b FROM t2 +** | +** `------> SELECT a FROM t1 +** +** The arrows in the diagram above represent the Select.pPrior pointer. +** So if this routine is called with p equal to the t3 query, then +** pPrior will be the t2 query. p->op will be TK_UNION in this case. +** +** Notice that because of the way SQLite parses compound SELECTs, the +** individual selects always group from left to right. +*/ +static int multiSelect( + Parse *pParse, /* Parsing context */ + Select *p, /* The right-most of SELECTs to be coded */ + SelectDest *pDest /* What to do with query results */ +){ + int rc = SQLITE_OK; /* Success code from a subroutine */ + Select *pPrior; /* Another SELECT immediately to our left */ + Vdbe *v; /* Generate code to this VDBE */ + SelectDest dest; /* Alternative data destination */ + Select *pDelete = 0; /* Chain of simple selects to delete */ + sqlite3 *db; /* Database connection */ + + /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs. Only + ** the last (right-most) SELECT in the series may have an ORDER BY or LIMIT. + */ + assert( p && p->pPrior ); /* Calling function guarantees this much */ + assert( (p->selFlags & SF_Recursive)==0 || p->op==TK_ALL || p->op==TK_UNION ); + assert( p->selFlags & SF_Compound ); + db = pParse->db; + pPrior = p->pPrior; + dest = *pDest; + assert( pPrior->pOrderBy==0 ); + assert( pPrior->pLimit==0 ); + + v = sqlite3GetVdbe(pParse); + assert( v!=0 ); /* The VDBE already created by calling function */ + + /* Create the destination temporary table if necessary + */ + if( dest.eDest==SRT_EphemTab ){ + assert( p->pEList ); + sqlite3VdbeAddOp2(v, OP_OpenEphemeral, dest.iSDParm, p->pEList->nExpr); + dest.eDest = SRT_Table; + } + + /* Special handling for a compound-select that originates as a VALUES clause. + */ + if( p->selFlags & SF_MultiValue ){ + rc = multiSelectValues(pParse, p, &dest); + if( rc>=0 ) goto multi_select_end; + rc = SQLITE_OK; + } + + /* Make sure all SELECTs in the statement have the same number of elements + ** in their result sets. + */ + assert( p->pEList && pPrior->pEList ); + assert( p->pEList->nExpr==pPrior->pEList->nExpr ); + +#ifndef SQLITE_OMIT_CTE + if( (p->selFlags & SF_Recursive)!=0 && hasAnchor(p) ){ + generateWithRecursiveQuery(pParse, p, &dest); + }else +#endif + + /* Compound SELECTs that have an ORDER BY clause are handled separately. + */ + if( p->pOrderBy ){ + return multiSelectOrderBy(pParse, p, pDest); + }else{ + +#ifndef SQLITE_OMIT_EXPLAIN + if( pPrior->pPrior==0 ){ + ExplainQueryPlan((pParse, 1, "COMPOUND QUERY")); + ExplainQueryPlan((pParse, 1, "LEFT-MOST SUBQUERY")); + } +#endif + + /* Generate code for the left and right SELECT statements. + */ + switch( p->op ){ + case TK_ALL: { + int addr = 0; + int nLimit = 0; /* Initialize to suppress harmless compiler warning */ + assert( !pPrior->pLimit ); + pPrior->iLimit = p->iLimit; + pPrior->iOffset = p->iOffset; + pPrior->pLimit = p->pLimit; + TREETRACE(0x200, pParse, p, ("multiSelect UNION ALL left...\n")); + rc = sqlite3Select(pParse, pPrior, &dest); + pPrior->pLimit = 0; + if( rc ){ + goto multi_select_end; + } + p->pPrior = 0; + p->iLimit = pPrior->iLimit; + p->iOffset = pPrior->iOffset; + if( p->iLimit ){ + addr = sqlite3VdbeAddOp1(v, OP_IfNot, p->iLimit); VdbeCoverage(v); + VdbeComment((v, "Jump ahead if LIMIT reached")); + if( p->iOffset ){ + sqlite3VdbeAddOp3(v, OP_OffsetLimit, + p->iLimit, p->iOffset+1, p->iOffset); + } + } + ExplainQueryPlan((pParse, 1, "UNION ALL")); + TREETRACE(0x200, pParse, p, ("multiSelect UNION ALL right...\n")); + rc = sqlite3Select(pParse, p, &dest); + testcase( rc!=SQLITE_OK ); + pDelete = p->pPrior; + p->pPrior = pPrior; + p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow); + if( p->pLimit + && sqlite3ExprIsInteger(p->pLimit->pLeft, &nLimit) + && nLimit>0 && p->nSelectRow > sqlite3LogEst((u64)nLimit) + ){ + p->nSelectRow = sqlite3LogEst((u64)nLimit); + } + if( addr ){ + sqlite3VdbeJumpHere(v, addr); + } + break; + } + case TK_EXCEPT: + case TK_UNION: { + int unionTab; /* Cursor number of the temp table holding result */ + u8 op = 0; /* One of the SRT_ operations to apply to self */ + int priorOp; /* The SRT_ operation to apply to prior selects */ + Expr *pLimit; /* Saved values of p->nLimit */ + int addr; + SelectDest uniondest; + + testcase( p->op==TK_EXCEPT ); + testcase( p->op==TK_UNION ); + priorOp = SRT_Union; + if( dest.eDest==priorOp ){ + /* We can reuse a temporary table generated by a SELECT to our + ** right. + */ + assert( p->pLimit==0 ); /* Not allowed on leftward elements */ + unionTab = dest.iSDParm; + }else{ + /* We will need to create our own temporary table to hold the + ** intermediate results. + */ + unionTab = pParse->nTab++; + assert( p->pOrderBy==0 ); + addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, unionTab, 0); + assert( p->addrOpenEphm[0] == -1 ); + p->addrOpenEphm[0] = addr; + findRightmost(p)->selFlags |= SF_UsesEphemeral; + assert( p->pEList ); + } + + + /* Code the SELECT statements to our left + */ + assert( !pPrior->pOrderBy ); + sqlite3SelectDestInit(&uniondest, priorOp, unionTab); + TREETRACE(0x200, pParse, p, ("multiSelect EXCEPT/UNION left...\n")); + rc = sqlite3Select(pParse, pPrior, &uniondest); + if( rc ){ + goto multi_select_end; + } + + /* Code the current SELECT statement + */ + if( p->op==TK_EXCEPT ){ + op = SRT_Except; + }else{ + assert( p->op==TK_UNION ); + op = SRT_Union; + } + p->pPrior = 0; + pLimit = p->pLimit; + p->pLimit = 0; + uniondest.eDest = op; + ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE", + sqlite3SelectOpName(p->op))); + TREETRACE(0x200, pParse, p, ("multiSelect EXCEPT/UNION right...\n")); + rc = sqlite3Select(pParse, p, &uniondest); + testcase( rc!=SQLITE_OK ); + assert( p->pOrderBy==0 ); + pDelete = p->pPrior; + p->pPrior = pPrior; + p->pOrderBy = 0; + if( p->op==TK_UNION ){ + p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow); + } + sqlite3ExprDelete(db, p->pLimit); + p->pLimit = pLimit; + p->iLimit = 0; + p->iOffset = 0; + + /* Convert the data in the temporary table into whatever form + ** it is that we currently need. + */ + assert( unionTab==dest.iSDParm || dest.eDest!=priorOp ); + assert( p->pEList || db->mallocFailed ); + if( dest.eDest!=priorOp && db->mallocFailed==0 ){ + int iCont, iBreak, iStart; + iBreak = sqlite3VdbeMakeLabel(pParse); + iCont = sqlite3VdbeMakeLabel(pParse); + computeLimitRegisters(pParse, p, iBreak); + sqlite3VdbeAddOp2(v, OP_Rewind, unionTab, iBreak); VdbeCoverage(v); + iStart = sqlite3VdbeCurrentAddr(v); + selectInnerLoop(pParse, p, unionTab, + 0, 0, &dest, iCont, iBreak); + sqlite3VdbeResolveLabel(v, iCont); + sqlite3VdbeAddOp2(v, OP_Next, unionTab, iStart); VdbeCoverage(v); + sqlite3VdbeResolveLabel(v, iBreak); + sqlite3VdbeAddOp2(v, OP_Close, unionTab, 0); + } + break; + } + default: assert( p->op==TK_INTERSECT ); { + int tab1, tab2; + int iCont, iBreak, iStart; + Expr *pLimit; + int addr; + SelectDest intersectdest; + int r1; + + /* INTERSECT is different from the others since it requires + ** two temporary tables. Hence it has its own case. Begin + ** by allocating the tables we will need. + */ + tab1 = pParse->nTab++; + tab2 = pParse->nTab++; + assert( p->pOrderBy==0 ); + + addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab1, 0); + assert( p->addrOpenEphm[0] == -1 ); + p->addrOpenEphm[0] = addr; + findRightmost(p)->selFlags |= SF_UsesEphemeral; + assert( p->pEList ); + + /* Code the SELECTs to our left into temporary table "tab1". + */ + sqlite3SelectDestInit(&intersectdest, SRT_Union, tab1); + TREETRACE(0x400, pParse, p, ("multiSelect INTERSECT left...\n")); + rc = sqlite3Select(pParse, pPrior, &intersectdest); + if( rc ){ + goto multi_select_end; + } + + /* Code the current SELECT into temporary table "tab2" + */ + addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab2, 0); + assert( p->addrOpenEphm[1] == -1 ); + p->addrOpenEphm[1] = addr; + p->pPrior = 0; + pLimit = p->pLimit; + p->pLimit = 0; + intersectdest.iSDParm = tab2; + ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE", + sqlite3SelectOpName(p->op))); + TREETRACE(0x400, pParse, p, ("multiSelect INTERSECT right...\n")); + rc = sqlite3Select(pParse, p, &intersectdest); + testcase( rc!=SQLITE_OK ); + pDelete = p->pPrior; + p->pPrior = pPrior; + if( p->nSelectRow>pPrior->nSelectRow ){ + p->nSelectRow = pPrior->nSelectRow; + } + sqlite3ExprDelete(db, p->pLimit); + p->pLimit = pLimit; + + /* Generate code to take the intersection of the two temporary + ** tables. + */ + if( rc ) break; + assert( p->pEList ); + iBreak = sqlite3VdbeMakeLabel(pParse); + iCont = sqlite3VdbeMakeLabel(pParse); + computeLimitRegisters(pParse, p, iBreak); + sqlite3VdbeAddOp2(v, OP_Rewind, tab1, iBreak); VdbeCoverage(v); + r1 = sqlite3GetTempReg(pParse); + iStart = sqlite3VdbeAddOp2(v, OP_RowData, tab1, r1); + sqlite3VdbeAddOp4Int(v, OP_NotFound, tab2, iCont, r1, 0); + VdbeCoverage(v); + sqlite3ReleaseTempReg(pParse, r1); + selectInnerLoop(pParse, p, tab1, + 0, 0, &dest, iCont, iBreak); + sqlite3VdbeResolveLabel(v, iCont); + sqlite3VdbeAddOp2(v, OP_Next, tab1, iStart); VdbeCoverage(v); + sqlite3VdbeResolveLabel(v, iBreak); + sqlite3VdbeAddOp2(v, OP_Close, tab2, 0); + sqlite3VdbeAddOp2(v, OP_Close, tab1, 0); + break; + } + } + + #ifndef SQLITE_OMIT_EXPLAIN + if( p->pNext==0 ){ + ExplainQueryPlanPop(pParse); + } + #endif + } + if( pParse->nErr ) goto multi_select_end; + + /* Compute collating sequences used by + ** temporary tables needed to implement the compound select. + ** Attach the KeyInfo structure to all temporary tables. + ** + ** This section is run by the right-most SELECT statement only. + ** SELECT statements to the left always skip this part. The right-most + ** SELECT might also skip this part if it has no ORDER BY clause and + ** no temp tables are required. + */ + if( p->selFlags & SF_UsesEphemeral ){ + int i; /* Loop counter */ + KeyInfo *pKeyInfo; /* Collating sequence for the result set */ + Select *pLoop; /* For looping through SELECT statements */ + CollSeq **apColl; /* For looping through pKeyInfo->aColl[] */ + int nCol; /* Number of columns in result set */ + + assert( p->pNext==0 ); + assert( p->pEList!=0 ); + nCol = p->pEList->nExpr; + pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1); + if( !pKeyInfo ){ + rc = SQLITE_NOMEM_BKPT; + goto multi_select_end; + } + for(i=0, apColl=pKeyInfo->aColl; ipDfltColl; + } + } + + for(pLoop=p; pLoop; pLoop=pLoop->pPrior){ + for(i=0; i<2; i++){ + int addr = pLoop->addrOpenEphm[i]; + if( addr<0 ){ + /* If [0] is unused then [1] is also unused. So we can + ** always safely abort as soon as the first unused slot is found */ + assert( pLoop->addrOpenEphm[1]<0 ); + break; + } + sqlite3VdbeChangeP2(v, addr, nCol); + sqlite3VdbeChangeP4(v, addr, (char*)sqlite3KeyInfoRef(pKeyInfo), + P4_KEYINFO); + pLoop->addrOpenEphm[i] = -1; + } + } + sqlite3KeyInfoUnref(pKeyInfo); + } + +multi_select_end: + pDest->iSdst = dest.iSdst; + pDest->nSdst = dest.nSdst; + if( pDelete ){ + sqlite3ParserAddCleanup(pParse, + (void(*)(sqlite3*,void*))sqlite3SelectDelete, + pDelete); + } + return rc; +} +#endif /* SQLITE_OMIT_COMPOUND_SELECT */ + +/* +** Error message for when two or more terms of a compound select have different +** size result sets. +*/ +SQLITE_PRIVATE void sqlite3SelectWrongNumTermsError(Parse *pParse, Select *p){ + if( p->selFlags & SF_Values ){ + sqlite3ErrorMsg(pParse, "all VALUES must have the same number of terms"); + }else{ + sqlite3ErrorMsg(pParse, "SELECTs to the left and right of %s" + " do not have the same number of result columns", + sqlite3SelectOpName(p->op)); + } +} + +/* +** Code an output subroutine for a coroutine implementation of a +** SELECT statment. +** +** The data to be output is contained in pIn->iSdst. There are +** pIn->nSdst columns to be output. pDest is where the output should +** be sent. +** +** regReturn is the number of the register holding the subroutine +** return address. +** +** If regPrev>0 then it is the first register in a vector that +** records the previous output. mem[regPrev] is a flag that is false +** if there has been no previous output. If regPrev>0 then code is +** generated to suppress duplicates. pKeyInfo is used for comparing +** keys. +** +** If the LIMIT found in p->iLimit is reached, jump immediately to +** iBreak. +*/ +static int generateOutputSubroutine( + Parse *pParse, /* Parsing context */ + Select *p, /* The SELECT statement */ + SelectDest *pIn, /* Coroutine supplying data */ + SelectDest *pDest, /* Where to send the data */ + int regReturn, /* The return address register */ + int regPrev, /* Previous result register. No uniqueness if 0 */ + KeyInfo *pKeyInfo, /* For comparing with previous entry */ + int iBreak /* Jump here if we hit the LIMIT */ +){ + Vdbe *v = pParse->pVdbe; + int iContinue; + int addr; + + addr = sqlite3VdbeCurrentAddr(v); + iContinue = sqlite3VdbeMakeLabel(pParse); + + /* Suppress duplicates for UNION, EXCEPT, and INTERSECT + */ + if( regPrev ){ + int addr1, addr2; + addr1 = sqlite3VdbeAddOp1(v, OP_IfNot, regPrev); VdbeCoverage(v); + addr2 = sqlite3VdbeAddOp4(v, OP_Compare, pIn->iSdst, regPrev+1, pIn->nSdst, + (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO); + sqlite3VdbeAddOp3(v, OP_Jump, addr2+2, iContinue, addr2+2); VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addr1); + sqlite3VdbeAddOp3(v, OP_Copy, pIn->iSdst, regPrev+1, pIn->nSdst-1); + sqlite3VdbeAddOp2(v, OP_Integer, 1, regPrev); + } + if( pParse->db->mallocFailed ) return 0; + + /* Suppress the first OFFSET entries if there is an OFFSET clause + */ + codeOffset(v, p->iOffset, iContinue); + + assert( pDest->eDest!=SRT_Exists ); + assert( pDest->eDest!=SRT_Table ); + switch( pDest->eDest ){ + /* Store the result as data using a unique key. + */ + case SRT_EphemTab: { + int r1 = sqlite3GetTempReg(pParse); + int r2 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_MakeRecord, pIn->iSdst, pIn->nSdst, r1); + sqlite3VdbeAddOp2(v, OP_NewRowid, pDest->iSDParm, r2); + sqlite3VdbeAddOp3(v, OP_Insert, pDest->iSDParm, r1, r2); + sqlite3VdbeChangeP5(v, OPFLAG_APPEND); + sqlite3ReleaseTempReg(pParse, r2); + sqlite3ReleaseTempReg(pParse, r1); + break; + } + +#ifndef SQLITE_OMIT_SUBQUERY + /* If we are creating a set for an "expr IN (SELECT ...)". + */ + case SRT_Set: { + int r1; + testcase( pIn->nSdst>1 ); + r1 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp4(v, OP_MakeRecord, pIn->iSdst, pIn->nSdst, + r1, pDest->zAffSdst, pIn->nSdst); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, pDest->iSDParm, r1, + pIn->iSdst, pIn->nSdst); + sqlite3ReleaseTempReg(pParse, r1); + break; + } + + /* If this is a scalar select that is part of an expression, then + ** store the results in the appropriate memory cell and break out + ** of the scan loop. Note that the select might return multiple columns + ** if it is the RHS of a row-value IN operator. + */ + case SRT_Mem: { + testcase( pIn->nSdst>1 ); + sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSDParm, pIn->nSdst); + /* The LIMIT clause will jump out of the loop for us */ + break; + } +#endif /* #ifndef SQLITE_OMIT_SUBQUERY */ + + /* The results are stored in a sequence of registers + ** starting at pDest->iSdst. Then the co-routine yields. + */ + case SRT_Coroutine: { + if( pDest->iSdst==0 ){ + pDest->iSdst = sqlite3GetTempRange(pParse, pIn->nSdst); + pDest->nSdst = pIn->nSdst; + } + sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSdst, pIn->nSdst); + sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm); + break; + } + + /* If none of the above, then the result destination must be + ** SRT_Output. This routine is never called with any other + ** destination other than the ones handled above or SRT_Output. + ** + ** For SRT_Output, results are stored in a sequence of registers. + ** Then the OP_ResultRow opcode is used to cause sqlite3_step() to + ** return the next row of result. + */ + default: { + assert( pDest->eDest==SRT_Output ); + sqlite3VdbeAddOp2(v, OP_ResultRow, pIn->iSdst, pIn->nSdst); + break; + } + } + + /* Jump to the end of the loop if the LIMIT is reached. + */ + if( p->iLimit ){ + sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v); + } + + /* Generate the subroutine return + */ + sqlite3VdbeResolveLabel(v, iContinue); + sqlite3VdbeAddOp1(v, OP_Return, regReturn); + + return addr; +} + +/* +** Alternative compound select code generator for cases when there +** is an ORDER BY clause. +** +** We assume a query of the following form: +** +** ORDER BY +** +** is one of UNION ALL, UNION, EXCEPT, or INTERSECT. The idea +** is to code both and with the ORDER BY clause as +** co-routines. Then run the co-routines in parallel and merge the results +** into the output. In addition to the two coroutines (called selectA and +** selectB) there are 7 subroutines: +** +** outA: Move the output of the selectA coroutine into the output +** of the compound query. +** +** outB: Move the output of the selectB coroutine into the output +** of the compound query. (Only generated for UNION and +** UNION ALL. EXCEPT and INSERTSECT never output a row that +** appears only in B.) +** +** AltB: Called when there is data from both coroutines and AB. +** +** EofA: Called when data is exhausted from selectA. +** +** EofB: Called when data is exhausted from selectB. +** +** The implementation of the latter five subroutines depend on which +** is used: +** +** +** UNION ALL UNION EXCEPT INTERSECT +** ------------- ----------------- -------------- ----------------- +** AltB: outA, nextA outA, nextA outA, nextA nextA +** +** AeqB: outA, nextA nextA nextA outA, nextA +** +** AgtB: outB, nextB outB, nextB nextB nextB +** +** EofA: outB, nextB outB, nextB halt halt +** +** EofB: outA, nextA outA, nextA outA, nextA halt +** +** In the AltB, AeqB, and AgtB subroutines, an EOF on A following nextA +** causes an immediate jump to EofA and an EOF on B following nextB causes +** an immediate jump to EofB. Within EofA and EofB, and EOF on entry or +** following nextX causes a jump to the end of the select processing. +** +** Duplicate removal in the UNION, EXCEPT, and INTERSECT cases is handled +** within the output subroutine. The regPrev register set holds the previously +** output value. A comparison is made against this value and the output +** is skipped if the next results would be the same as the previous. +** +** The implementation plan is to implement the two coroutines and seven +** subroutines first, then put the control logic at the bottom. Like this: +** +** goto Init +** coA: coroutine for left query (A) +** coB: coroutine for right query (B) +** outA: output one row of A +** outB: output one row of B (UNION and UNION ALL only) +** EofA: ... +** EofB: ... +** AltB: ... +** AeqB: ... +** AgtB: ... +** Init: initialize coroutine registers +** yield coA +** if eof(A) goto EofA +** yield coB +** if eof(B) goto EofB +** Cmpr: Compare A, B +** Jump AltB, AeqB, AgtB +** End: ... +** +** We call AltB, AeqB, AgtB, EofA, and EofB "subroutines" but they are not +** actually called using Gosub and they do not Return. EofA and EofB loop +** until all data is exhausted then jump to the "end" labe. AltB, AeqB, +** and AgtB jump to either L2 or to one of EofA or EofB. +*/ +#ifndef SQLITE_OMIT_COMPOUND_SELECT +static int multiSelectOrderBy( + Parse *pParse, /* Parsing context */ + Select *p, /* The right-most of SELECTs to be coded */ + SelectDest *pDest /* What to do with query results */ +){ + int i, j; /* Loop counters */ + Select *pPrior; /* Another SELECT immediately to our left */ + Select *pSplit; /* Left-most SELECT in the right-hand group */ + int nSelect; /* Number of SELECT statements in the compound */ + Vdbe *v; /* Generate code to this VDBE */ + SelectDest destA; /* Destination for coroutine A */ + SelectDest destB; /* Destination for coroutine B */ + int regAddrA; /* Address register for select-A coroutine */ + int regAddrB; /* Address register for select-B coroutine */ + int addrSelectA; /* Address of the select-A coroutine */ + int addrSelectB; /* Address of the select-B coroutine */ + int regOutA; /* Address register for the output-A subroutine */ + int regOutB; /* Address register for the output-B subroutine */ + int addrOutA; /* Address of the output-A subroutine */ + int addrOutB = 0; /* Address of the output-B subroutine */ + int addrEofA; /* Address of the select-A-exhausted subroutine */ + int addrEofA_noB; /* Alternate addrEofA if B is uninitialized */ + int addrEofB; /* Address of the select-B-exhausted subroutine */ + int addrAltB; /* Address of the AB subroutine */ + int regLimitA; /* Limit register for select-A */ + int regLimitB; /* Limit register for select-A */ + int regPrev; /* A range of registers to hold previous output */ + int savedLimit; /* Saved value of p->iLimit */ + int savedOffset; /* Saved value of p->iOffset */ + int labelCmpr; /* Label for the start of the merge algorithm */ + int labelEnd; /* Label for the end of the overall SELECT stmt */ + int addr1; /* Jump instructions that get retargetted */ + int op; /* One of TK_ALL, TK_UNION, TK_EXCEPT, TK_INTERSECT */ + KeyInfo *pKeyDup = 0; /* Comparison information for duplicate removal */ + KeyInfo *pKeyMerge; /* Comparison information for merging rows */ + sqlite3 *db; /* Database connection */ + ExprList *pOrderBy; /* The ORDER BY clause */ + int nOrderBy; /* Number of terms in the ORDER BY clause */ + u32 *aPermute; /* Mapping from ORDER BY terms to result set columns */ + + assert( p->pOrderBy!=0 ); + assert( pKeyDup==0 ); /* "Managed" code needs this. Ticket #3382. */ + db = pParse->db; + v = pParse->pVdbe; + assert( v!=0 ); /* Already thrown the error if VDBE alloc failed */ + labelEnd = sqlite3VdbeMakeLabel(pParse); + labelCmpr = sqlite3VdbeMakeLabel(pParse); + + + /* Patch up the ORDER BY clause + */ + op = p->op; + assert( p->pPrior->pOrderBy==0 ); + pOrderBy = p->pOrderBy; + assert( pOrderBy ); + nOrderBy = pOrderBy->nExpr; + + /* For operators other than UNION ALL we have to make sure that + ** the ORDER BY clause covers every term of the result set. Add + ** terms to the ORDER BY clause as necessary. + */ + if( op!=TK_ALL ){ + for(i=1; db->mallocFailed==0 && i<=p->pEList->nExpr; i++){ + struct ExprList_item *pItem; + for(j=0, pItem=pOrderBy->a; ju.x.iOrderByCol>0 ); + if( pItem->u.x.iOrderByCol==i ) break; + } + if( j==nOrderBy ){ + Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0); + if( pNew==0 ) return SQLITE_NOMEM_BKPT; + pNew->flags |= EP_IntValue; + pNew->u.iValue = i; + p->pOrderBy = pOrderBy = sqlite3ExprListAppend(pParse, pOrderBy, pNew); + if( pOrderBy ) pOrderBy->a[nOrderBy++].u.x.iOrderByCol = (u16)i; + } + } + } + + /* Compute the comparison permutation and keyinfo that is used with + ** the permutation used to determine if the next + ** row of results comes from selectA or selectB. Also add explicit + ** collations to the ORDER BY clause terms so that when the subqueries + ** to the right and the left are evaluated, they use the correct + ** collation. + */ + aPermute = sqlite3DbMallocRawNN(db, sizeof(u32)*(nOrderBy + 1)); + if( aPermute ){ + struct ExprList_item *pItem; + aPermute[0] = nOrderBy; + for(i=1, pItem=pOrderBy->a; i<=nOrderBy; i++, pItem++){ + assert( pItem!=0 ); + assert( pItem->u.x.iOrderByCol>0 ); + assert( pItem->u.x.iOrderByCol<=p->pEList->nExpr ); + aPermute[i] = pItem->u.x.iOrderByCol - 1; + } + pKeyMerge = multiSelectOrderByKeyInfo(pParse, p, 1); + }else{ + pKeyMerge = 0; + } + + /* Allocate a range of temporary registers and the KeyInfo needed + ** for the logic that removes duplicate result rows when the + ** operator is UNION, EXCEPT, or INTERSECT (but not UNION ALL). + */ + if( op==TK_ALL ){ + regPrev = 0; + }else{ + int nExpr = p->pEList->nExpr; + assert( nOrderBy>=nExpr || db->mallocFailed ); + regPrev = pParse->nMem+1; + pParse->nMem += nExpr+1; + sqlite3VdbeAddOp2(v, OP_Integer, 0, regPrev); + pKeyDup = sqlite3KeyInfoAlloc(db, nExpr, 1); + if( pKeyDup ){ + assert( sqlite3KeyInfoIsWriteable(pKeyDup) ); + for(i=0; iaColl[i] = multiSelectCollSeq(pParse, p, i); + pKeyDup->aSortFlags[i] = 0; + } + } + } + + /* Separate the left and the right query from one another + */ + nSelect = 1; + if( (op==TK_ALL || op==TK_UNION) + && OptimizationEnabled(db, SQLITE_BalancedMerge) + ){ + for(pSplit=p; pSplit->pPrior!=0 && pSplit->op==op; pSplit=pSplit->pPrior){ + nSelect++; + assert( pSplit->pPrior->pNext==pSplit ); + } + } + if( nSelect<=3 ){ + pSplit = p; + }else{ + pSplit = p; + for(i=2; ipPrior; } + } + pPrior = pSplit->pPrior; + assert( pPrior!=0 ); + pSplit->pPrior = 0; + pPrior->pNext = 0; + assert( p->pOrderBy == pOrderBy ); + assert( pOrderBy!=0 || db->mallocFailed ); + pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy, 0); + sqlite3ResolveOrderGroupBy(pParse, p, p->pOrderBy, "ORDER"); + sqlite3ResolveOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, "ORDER"); + + /* Compute the limit registers */ + computeLimitRegisters(pParse, p, labelEnd); + if( p->iLimit && op==TK_ALL ){ + regLimitA = ++pParse->nMem; + regLimitB = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Copy, p->iOffset ? p->iOffset+1 : p->iLimit, + regLimitA); + sqlite3VdbeAddOp2(v, OP_Copy, regLimitA, regLimitB); + }else{ + regLimitA = regLimitB = 0; + } + sqlite3ExprDelete(db, p->pLimit); + p->pLimit = 0; + + regAddrA = ++pParse->nMem; + regAddrB = ++pParse->nMem; + regOutA = ++pParse->nMem; + regOutB = ++pParse->nMem; + sqlite3SelectDestInit(&destA, SRT_Coroutine, regAddrA); + sqlite3SelectDestInit(&destB, SRT_Coroutine, regAddrB); + + ExplainQueryPlan((pParse, 1, "MERGE (%s)", sqlite3SelectOpName(p->op))); + + /* Generate a coroutine to evaluate the SELECT statement to the + ** left of the compound operator - the "A" select. + */ + addrSelectA = sqlite3VdbeCurrentAddr(v) + 1; + addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrA, 0, addrSelectA); + VdbeComment((v, "left SELECT")); + pPrior->iLimit = regLimitA; + ExplainQueryPlan((pParse, 1, "LEFT")); + sqlite3Select(pParse, pPrior, &destA); + sqlite3VdbeEndCoroutine(v, regAddrA); + sqlite3VdbeJumpHere(v, addr1); + + /* Generate a coroutine to evaluate the SELECT statement on + ** the right - the "B" select + */ + addrSelectB = sqlite3VdbeCurrentAddr(v) + 1; + addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrB, 0, addrSelectB); + VdbeComment((v, "right SELECT")); + savedLimit = p->iLimit; + savedOffset = p->iOffset; + p->iLimit = regLimitB; + p->iOffset = 0; + ExplainQueryPlan((pParse, 1, "RIGHT")); + sqlite3Select(pParse, p, &destB); + p->iLimit = savedLimit; + p->iOffset = savedOffset; + sqlite3VdbeEndCoroutine(v, regAddrB); + + /* Generate a subroutine that outputs the current row of the A + ** select as the next output row of the compound select. + */ + VdbeNoopComment((v, "Output routine for A")); + addrOutA = generateOutputSubroutine(pParse, + p, &destA, pDest, regOutA, + regPrev, pKeyDup, labelEnd); + + /* Generate a subroutine that outputs the current row of the B + ** select as the next output row of the compound select. + */ + if( op==TK_ALL || op==TK_UNION ){ + VdbeNoopComment((v, "Output routine for B")); + addrOutB = generateOutputSubroutine(pParse, + p, &destB, pDest, regOutB, + regPrev, pKeyDup, labelEnd); + } + sqlite3KeyInfoUnref(pKeyDup); + + /* Generate a subroutine to run when the results from select A + ** are exhausted and only data in select B remains. + */ + if( op==TK_EXCEPT || op==TK_INTERSECT ){ + addrEofA_noB = addrEofA = labelEnd; + }else{ + VdbeNoopComment((v, "eof-A subroutine")); + addrEofA = sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB); + addrEofA_noB = sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, labelEnd); + VdbeCoverage(v); + sqlite3VdbeGoto(v, addrEofA); + p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow); + } + + /* Generate a subroutine to run when the results from select B + ** are exhausted and only data in select A remains. + */ + if( op==TK_INTERSECT ){ + addrEofB = addrEofA; + if( p->nSelectRow > pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow; + }else{ + VdbeNoopComment((v, "eof-B subroutine")); + addrEofB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA); + sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, labelEnd); VdbeCoverage(v); + sqlite3VdbeGoto(v, addrEofB); + } + + /* Generate code to handle the case of AB + */ + VdbeNoopComment((v, "A-gt-B subroutine")); + addrAgtB = sqlite3VdbeCurrentAddr(v); + if( op==TK_ALL || op==TK_UNION ){ + sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB); + } + sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v); + sqlite3VdbeGoto(v, labelCmpr); + + /* This code runs once to initialize everything. + */ + sqlite3VdbeJumpHere(v, addr1); + sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA_noB); VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v); + + /* Implement the main merge loop + */ + sqlite3VdbeResolveLabel(v, labelCmpr); + sqlite3VdbeAddOp4(v, OP_Permutation, 0, 0, 0, (char*)aPermute, P4_INTARRAY); + sqlite3VdbeAddOp4(v, OP_Compare, destA.iSdst, destB.iSdst, nOrderBy, + (char*)pKeyMerge, P4_KEYINFO); + sqlite3VdbeChangeP5(v, OPFLAG_PERMUTE); + sqlite3VdbeAddOp3(v, OP_Jump, addrAltB, addrAeqB, addrAgtB); VdbeCoverage(v); + + /* Jump to the this point in order to terminate the query. + */ + sqlite3VdbeResolveLabel(v, labelEnd); + + /* Make arrangements to free the 2nd and subsequent arms of the compound + ** after the parse has finished */ + if( pSplit->pPrior ){ + sqlite3ParserAddCleanup(pParse, + (void(*)(sqlite3*,void*))sqlite3SelectDelete, pSplit->pPrior); + } + pSplit->pPrior = pPrior; + pPrior->pNext = pSplit; + sqlite3ExprListDelete(db, pPrior->pOrderBy); + pPrior->pOrderBy = 0; + + /*** TBD: Insert subroutine calls to close cursors on incomplete + **** subqueries ****/ + ExplainQueryPlanPop(pParse); + return pParse->nErr!=0; +} +#endif + +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) + +/* An instance of the SubstContext object describes an substitution edit +** to be performed on a parse tree. +** +** All references to columns in table iTable are to be replaced by corresponding +** expressions in pEList. +** +** ## About "isOuterJoin": +** +** The isOuterJoin column indicates that the replacement will occur into a +** position in the parent that NULL-able due to an OUTER JOIN. Either the +** target slot in the parent is the right operand of a LEFT JOIN, or one of +** the left operands of a RIGHT JOIN. In either case, we need to potentially +** bypass the substituted expression with OP_IfNullRow. +** +** Suppose the original expression is an integer constant. Even though the table +** has the nullRow flag set, because the expression is an integer constant, +** it will not be NULLed out. So instead, we insert an OP_IfNullRow opcode +** that checks to see if the nullRow flag is set on the table. If the nullRow +** flag is set, then the value in the register is set to NULL and the original +** expression is bypassed. If the nullRow flag is not set, then the original +** expression runs to populate the register. +** +** Example where this is needed: +** +** CREATE TABLE t1(a INTEGER PRIMARY KEY, b INT); +** CREATE TABLE t2(x INT UNIQUE); +** +** SELECT a,b,m,x FROM t1 LEFT JOIN (SELECT 59 AS m,x FROM t2) ON b=x; +** +** When the subquery on the right side of the LEFT JOIN is flattened, we +** have to add OP_IfNullRow in front of the OP_Integer that implements the +** "m" value of the subquery so that a NULL will be loaded instead of 59 +** when processing a non-matched row of the left. +*/ +typedef struct SubstContext { + Parse *pParse; /* The parsing context */ + int iTable; /* Replace references to this table */ + int iNewTable; /* New table number */ + int isOuterJoin; /* Add TK_IF_NULL_ROW opcodes on each replacement */ + ExprList *pEList; /* Replacement expressions */ + ExprList *pCList; /* Collation sequences for replacement expr */ +} SubstContext; + +/* Forward Declarations */ +static void substExprList(SubstContext*, ExprList*); +static void substSelect(SubstContext*, Select*, int); + +/* +** Scan through the expression pExpr. Replace every reference to +** a column in table number iTable with a copy of the iColumn-th +** entry in pEList. (But leave references to the ROWID column +** unchanged.) +** +** This routine is part of the flattening procedure. A subquery +** whose result set is defined by pEList appears as entry in the +** FROM clause of a SELECT such that the VDBE cursor assigned to that +** FORM clause entry is iTable. This routine makes the necessary +** changes to pExpr so that it refers directly to the source table +** of the subquery rather the result set of the subquery. +*/ +static Expr *substExpr( + SubstContext *pSubst, /* Description of the substitution */ + Expr *pExpr /* Expr in which substitution occurs */ +){ + if( pExpr==0 ) return 0; + if( ExprHasProperty(pExpr, EP_OuterON|EP_InnerON) + && pExpr->w.iJoin==pSubst->iTable + ){ + testcase( ExprHasProperty(pExpr, EP_InnerON) ); + pExpr->w.iJoin = pSubst->iNewTable; + } + if( pExpr->op==TK_COLUMN + && pExpr->iTable==pSubst->iTable + && !ExprHasProperty(pExpr, EP_FixedCol) + ){ +#ifdef SQLITE_ALLOW_ROWID_IN_VIEW + if( pExpr->iColumn<0 ){ + pExpr->op = TK_NULL; + }else +#endif + { + Expr *pNew; + int iColumn = pExpr->iColumn; + Expr *pCopy = pSubst->pEList->a[iColumn].pExpr; + Expr ifNullRow; + assert( pSubst->pEList!=0 && iColumnpEList->nExpr ); + assert( pExpr->pRight==0 ); + if( sqlite3ExprIsVector(pCopy) ){ + sqlite3VectorErrorMsg(pSubst->pParse, pCopy); + }else{ + sqlite3 *db = pSubst->pParse->db; + if( pSubst->isOuterJoin + && (pCopy->op!=TK_COLUMN || pCopy->iTable!=pSubst->iNewTable) + ){ + memset(&ifNullRow, 0, sizeof(ifNullRow)); + ifNullRow.op = TK_IF_NULL_ROW; + ifNullRow.pLeft = pCopy; + ifNullRow.iTable = pSubst->iNewTable; + ifNullRow.iColumn = -99; + ifNullRow.flags = EP_IfNullRow; + pCopy = &ifNullRow; + } + testcase( ExprHasProperty(pCopy, EP_Subquery) ); + pNew = sqlite3ExprDup(db, pCopy, 0); + if( db->mallocFailed ){ + sqlite3ExprDelete(db, pNew); + return pExpr; + } + if( pSubst->isOuterJoin ){ + ExprSetProperty(pNew, EP_CanBeNull); + } + if( ExprHasProperty(pExpr,EP_OuterON|EP_InnerON) ){ + sqlite3SetJoinExpr(pNew, pExpr->w.iJoin, + pExpr->flags & (EP_OuterON|EP_InnerON)); + } + sqlite3ExprDelete(db, pExpr); + pExpr = pNew; + if( pExpr->op==TK_TRUEFALSE ){ + pExpr->u.iValue = sqlite3ExprTruthValue(pExpr); + pExpr->op = TK_INTEGER; + ExprSetProperty(pExpr, EP_IntValue); + } + + /* Ensure that the expression now has an implicit collation sequence, + ** just as it did when it was a column of a view or sub-query. */ + { + CollSeq *pNat = sqlite3ExprCollSeq(pSubst->pParse, pExpr); + CollSeq *pColl = sqlite3ExprCollSeq(pSubst->pParse, + pSubst->pCList->a[iColumn].pExpr + ); + if( pNat!=pColl || (pExpr->op!=TK_COLUMN && pExpr->op!=TK_COLLATE) ){ + pExpr = sqlite3ExprAddCollateString(pSubst->pParse, pExpr, + (pColl ? pColl->zName : "BINARY") + ); + } + } + ExprClearProperty(pExpr, EP_Collate); + } + } + }else{ + if( pExpr->op==TK_IF_NULL_ROW && pExpr->iTable==pSubst->iTable ){ + pExpr->iTable = pSubst->iNewTable; + } + pExpr->pLeft = substExpr(pSubst, pExpr->pLeft); + pExpr->pRight = substExpr(pSubst, pExpr->pRight); + if( ExprUseXSelect(pExpr) ){ + substSelect(pSubst, pExpr->x.pSelect, 1); + }else{ + substExprList(pSubst, pExpr->x.pList); + } +#ifndef SQLITE_OMIT_WINDOWFUNC + if( ExprHasProperty(pExpr, EP_WinFunc) ){ + Window *pWin = pExpr->y.pWin; + pWin->pFilter = substExpr(pSubst, pWin->pFilter); + substExprList(pSubst, pWin->pPartition); + substExprList(pSubst, pWin->pOrderBy); + } +#endif + } + return pExpr; +} +static void substExprList( + SubstContext *pSubst, /* Description of the substitution */ + ExprList *pList /* List to scan and in which to make substitutes */ +){ + int i; + if( pList==0 ) return; + for(i=0; inExpr; i++){ + pList->a[i].pExpr = substExpr(pSubst, pList->a[i].pExpr); + } +} +static void substSelect( + SubstContext *pSubst, /* Description of the substitution */ + Select *p, /* SELECT statement in which to make substitutions */ + int doPrior /* Do substitutes on p->pPrior too */ +){ + SrcList *pSrc; + SrcItem *pItem; + int i; + if( !p ) return; + do{ + substExprList(pSubst, p->pEList); + substExprList(pSubst, p->pGroupBy); + substExprList(pSubst, p->pOrderBy); + p->pHaving = substExpr(pSubst, p->pHaving); + p->pWhere = substExpr(pSubst, p->pWhere); + pSrc = p->pSrc; + assert( pSrc!=0 ); + for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){ + substSelect(pSubst, pItem->pSelect, 1); + if( pItem->fg.isTabFunc ){ + substExprList(pSubst, pItem->u1.pFuncArg); + } + } + }while( doPrior && (p = p->pPrior)!=0 ); +} +#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */ + +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) +/* +** pSelect is a SELECT statement and pSrcItem is one item in the FROM +** clause of that SELECT. +** +** This routine scans the entire SELECT statement and recomputes the +** pSrcItem->colUsed mask. +*/ +static int recomputeColumnsUsedExpr(Walker *pWalker, Expr *pExpr){ + SrcItem *pItem; + if( pExpr->op!=TK_COLUMN ) return WRC_Continue; + pItem = pWalker->u.pSrcItem; + if( pItem->iCursor!=pExpr->iTable ) return WRC_Continue; + if( pExpr->iColumn<0 ) return WRC_Continue; + pItem->colUsed |= sqlite3ExprColUsed(pExpr); + return WRC_Continue; +} +static void recomputeColumnsUsed( + Select *pSelect, /* The complete SELECT statement */ + SrcItem *pSrcItem /* Which FROM clause item to recompute */ +){ + Walker w; + if( NEVER(pSrcItem->pTab==0) ) return; + memset(&w, 0, sizeof(w)); + w.xExprCallback = recomputeColumnsUsedExpr; + w.xSelectCallback = sqlite3SelectWalkNoop; + w.u.pSrcItem = pSrcItem; + pSrcItem->colUsed = 0; + sqlite3WalkSelect(&w, pSelect); +} +#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */ + +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) +/* +** Assign new cursor numbers to each of the items in pSrc. For each +** new cursor number assigned, set an entry in the aCsrMap[] array +** to map the old cursor number to the new: +** +** aCsrMap[iOld+1] = iNew; +** +** The array is guaranteed by the caller to be large enough for all +** existing cursor numbers in pSrc. aCsrMap[0] is the array size. +** +** If pSrc contains any sub-selects, call this routine recursively +** on the FROM clause of each such sub-select, with iExcept set to -1. +*/ +static void srclistRenumberCursors( + Parse *pParse, /* Parse context */ + int *aCsrMap, /* Array to store cursor mappings in */ + SrcList *pSrc, /* FROM clause to renumber */ + int iExcept /* FROM clause item to skip */ +){ + int i; + SrcItem *pItem; + for(i=0, pItem=pSrc->a; inSrc; i++, pItem++){ + if( i!=iExcept ){ + Select *p; + assert( pItem->iCursor < aCsrMap[0] ); + if( !pItem->fg.isRecursive || aCsrMap[pItem->iCursor+1]==0 ){ + aCsrMap[pItem->iCursor+1] = pParse->nTab++; + } + pItem->iCursor = aCsrMap[pItem->iCursor+1]; + for(p=pItem->pSelect; p; p=p->pPrior){ + srclistRenumberCursors(pParse, aCsrMap, p->pSrc, -1); + } + } + } +} + +/* +** *piCursor is a cursor number. Change it if it needs to be mapped. +*/ +static void renumberCursorDoMapping(Walker *pWalker, int *piCursor){ + int *aCsrMap = pWalker->u.aiCol; + int iCsr = *piCursor; + if( iCsr < aCsrMap[0] && aCsrMap[iCsr+1]>0 ){ + *piCursor = aCsrMap[iCsr+1]; + } +} + +/* +** Expression walker callback used by renumberCursors() to update +** Expr objects to match newly assigned cursor numbers. +*/ +static int renumberCursorsCb(Walker *pWalker, Expr *pExpr){ + int op = pExpr->op; + if( op==TK_COLUMN || op==TK_IF_NULL_ROW ){ + renumberCursorDoMapping(pWalker, &pExpr->iTable); + } + if( ExprHasProperty(pExpr, EP_OuterON) ){ + renumberCursorDoMapping(pWalker, &pExpr->w.iJoin); + } + return WRC_Continue; +} + +/* +** Assign a new cursor number to each cursor in the FROM clause (Select.pSrc) +** of the SELECT statement passed as the second argument, and to each +** cursor in the FROM clause of any FROM clause sub-selects, recursively. +** Except, do not assign a new cursor number to the iExcept'th element in +** the FROM clause of (*p). Update all expressions and other references +** to refer to the new cursor numbers. +** +** Argument aCsrMap is an array that may be used for temporary working +** space. Two guarantees are made by the caller: +** +** * the array is larger than the largest cursor number used within the +** select statement passed as an argument, and +** +** * the array entries for all cursor numbers that do *not* appear in +** FROM clauses of the select statement as described above are +** initialized to zero. +*/ +static void renumberCursors( + Parse *pParse, /* Parse context */ + Select *p, /* Select to renumber cursors within */ + int iExcept, /* FROM clause item to skip */ + int *aCsrMap /* Working space */ +){ + Walker w; + srclistRenumberCursors(pParse, aCsrMap, p->pSrc, iExcept); + memset(&w, 0, sizeof(w)); + w.u.aiCol = aCsrMap; + w.xExprCallback = renumberCursorsCb; + w.xSelectCallback = sqlite3SelectWalkNoop; + sqlite3WalkSelect(&w, p); +} +#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */ + +/* +** If pSel is not part of a compound SELECT, return a pointer to its +** expression list. Otherwise, return a pointer to the expression list +** of the leftmost SELECT in the compound. +*/ +static ExprList *findLeftmostExprlist(Select *pSel){ + while( pSel->pPrior ){ + pSel = pSel->pPrior; + } + return pSel->pEList; +} + +/* +** Return true if any of the result-set columns in the compound query +** have incompatible affinities on one or more arms of the compound. +*/ +static int compoundHasDifferentAffinities(Select *p){ + int ii; + ExprList *pList; + assert( p!=0 ); + assert( p->pEList!=0 ); + assert( p->pPrior!=0 ); + pList = p->pEList; + for(ii=0; iinExpr; ii++){ + char aff; + Select *pSub1; + assert( pList->a[ii].pExpr!=0 ); + aff = sqlite3ExprAffinity(pList->a[ii].pExpr); + for(pSub1=p->pPrior; pSub1; pSub1=pSub1->pPrior){ + assert( pSub1->pEList!=0 ); + assert( pSub1->pEList->nExpr>ii ); + assert( pSub1->pEList->a[ii].pExpr!=0 ); + if( sqlite3ExprAffinity(pSub1->pEList->a[ii].pExpr)!=aff ){ + return 1; + } + } + } + return 0; +} + +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) +/* +** This routine attempts to flatten subqueries as a performance optimization. +** This routine returns 1 if it makes changes and 0 if no flattening occurs. +** +** To understand the concept of flattening, consider the following +** query: +** +** SELECT a FROM (SELECT x+y AS a FROM t1 WHERE z<100) WHERE a>5 +** +** The default way of implementing this query is to execute the +** subquery first and store the results in a temporary table, then +** run the outer query on that temporary table. This requires two +** passes over the data. Furthermore, because the temporary table +** has no indices, the WHERE clause on the outer query cannot be +** optimized. +** +** This routine attempts to rewrite queries such as the above into +** a single flat select, like this: +** +** SELECT x+y AS a FROM t1 WHERE z<100 AND a>5 +** +** The code generated for this simplification gives the same result +** but only has to scan the data once. And because indices might +** exist on the table t1, a complete scan of the data might be +** avoided. +** +** Flattening is subject to the following constraints: +** +** (**) We no longer attempt to flatten aggregate subqueries. Was: +** The subquery and the outer query cannot both be aggregates. +** +** (**) We no longer attempt to flatten aggregate subqueries. Was: +** (2) If the subquery is an aggregate then +** (2a) the outer query must not be a join and +** (2b) the outer query must not use subqueries +** other than the one FROM-clause subquery that is a candidate +** for flattening. (This is due to ticket [2f7170d73bf9abf80] +** from 2015-02-09.) +** +** (3) If the subquery is the right operand of a LEFT JOIN then +** (3a) the subquery may not be a join and +** (3b) the FROM clause of the subquery may not contain a virtual +** table and +** (**) Was: "The outer query may not have a GROUP BY." This case +** is now managed correctly +** (3d) the outer query may not be DISTINCT. +** See also (26) for restrictions on RIGHT JOIN. +** +** (4) The subquery can not be DISTINCT. +** +** (**) At one point restrictions (4) and (5) defined a subset of DISTINCT +** sub-queries that were excluded from this optimization. Restriction +** (4) has since been expanded to exclude all DISTINCT subqueries. +** +** (**) We no longer attempt to flatten aggregate subqueries. Was: +** If the subquery is aggregate, the outer query may not be DISTINCT. +** +** (7) The subquery must have a FROM clause. TODO: For subqueries without +** A FROM clause, consider adding a FROM clause with the special +** table sqlite_once that consists of a single row containing a +** single NULL. +** +** (8) If the subquery uses LIMIT then the outer query may not be a join. +** +** (9) If the subquery uses LIMIT then the outer query may not be aggregate. +** +** (**) Restriction (10) was removed from the code on 2005-02-05 but we +** accidently carried the comment forward until 2014-09-15. Original +** constraint: "If the subquery is aggregate then the outer query +** may not use LIMIT." +** +** (11) The subquery and the outer query may not both have ORDER BY clauses. +** +** (**) Not implemented. Subsumed into restriction (3). Was previously +** a separate restriction deriving from ticket #350. +** +** (13) The subquery and outer query may not both use LIMIT. +** +** (14) The subquery may not use OFFSET. +** +** (15) If the outer query is part of a compound select, then the +** subquery may not use LIMIT. +** (See ticket #2339 and ticket [02a8e81d44]). +** +** (16) If the outer query is aggregate, then the subquery may not +** use ORDER BY. (Ticket #2942) This used to not matter +** until we introduced the group_concat() function. +** +** (17) If the subquery is a compound select, then +** (17a) all compound operators must be a UNION ALL, and +** (17b) no terms within the subquery compound may be aggregate +** or DISTINCT, and +** (17c) every term within the subquery compound must have a FROM clause +** (17d) the outer query may not be +** (17d1) aggregate, or +** (17d2) DISTINCT +** (17e) the subquery may not contain window functions, and +** (17f) the subquery must not be the RHS of a LEFT JOIN. +** (17g) either the subquery is the first element of the outer +** query or there are no RIGHT or FULL JOINs in any arm +** of the subquery. (This is a duplicate of condition (27b).) +** (17h) The corresponding result set expressions in all arms of the +** compound must have the same affinity. +** +** The parent and sub-query may contain WHERE clauses. Subject to +** rules (11), (13) and (14), they may also contain ORDER BY, +** LIMIT and OFFSET clauses. The subquery cannot use any compound +** operator other than UNION ALL because all the other compound +** operators have an implied DISTINCT which is disallowed by +** restriction (4). +** +** Also, each component of the sub-query must return the same number +** of result columns. This is actually a requirement for any compound +** SELECT statement, but all the code here does is make sure that no +** such (illegal) sub-query is flattened. The caller will detect the +** syntax error and return a detailed message. +** +** (18) If the sub-query is a compound select, then all terms of the +** ORDER BY clause of the parent must be copies of a term returned +** by the parent query. +** +** (19) If the subquery uses LIMIT then the outer query may not +** have a WHERE clause. +** +** (20) If the sub-query is a compound select, then it must not use +** an ORDER BY clause. Ticket #3773. We could relax this constraint +** somewhat by saying that the terms of the ORDER BY clause must +** appear as unmodified result columns in the outer query. But we +** have other optimizations in mind to deal with that case. +** +** (21) If the subquery uses LIMIT then the outer query may not be +** DISTINCT. (See ticket [752e1646fc]). +** +** (22) The subquery may not be a recursive CTE. +** +** (23) If the outer query is a recursive CTE, then the sub-query may not be +** a compound query. This restriction is because transforming the +** parent to a compound query confuses the code that handles +** recursive queries in multiSelect(). +** +** (**) We no longer attempt to flatten aggregate subqueries. Was: +** The subquery may not be an aggregate that uses the built-in min() or +** or max() functions. (Without this restriction, a query like: +** "SELECT x FROM (SELECT max(y), x FROM t1)" would not necessarily +** return the value X for which Y was maximal.) +** +** (25) If either the subquery or the parent query contains a window +** function in the select list or ORDER BY clause, flattening +** is not attempted. +** +** (26) The subquery may not be the right operand of a RIGHT JOIN. +** See also (3) for restrictions on LEFT JOIN. +** +** (27) The subquery may not contain a FULL or RIGHT JOIN unless it +** is the first element of the parent query. Two subcases: +** (27a) the subquery is not a compound query. +** (27b) the subquery is a compound query and the RIGHT JOIN occurs +** in any arm of the compound query. (See also (17g).) +** +** (28) The subquery is not a MATERIALIZED CTE. +** +** +** In this routine, the "p" parameter is a pointer to the outer query. +** The subquery is p->pSrc->a[iFrom]. isAgg is true if the outer query +** uses aggregates. +** +** If flattening is not attempted, this routine is a no-op and returns 0. +** If flattening is attempted this routine returns 1. +** +** All of the expression analysis must occur on both the outer query and +** the subquery before this routine runs. +*/ +static int flattenSubquery( + Parse *pParse, /* Parsing context */ + Select *p, /* The parent or outer SELECT statement */ + int iFrom, /* Index in p->pSrc->a[] of the inner subquery */ + int isAgg /* True if outer SELECT uses aggregate functions */ +){ + const char *zSavedAuthContext = pParse->zAuthContext; + Select *pParent; /* Current UNION ALL term of the other query */ + Select *pSub; /* The inner query or "subquery" */ + Select *pSub1; /* Pointer to the rightmost select in sub-query */ + SrcList *pSrc; /* The FROM clause of the outer query */ + SrcList *pSubSrc; /* The FROM clause of the subquery */ + int iParent; /* VDBE cursor number of the pSub result set temp table */ + int iNewParent = -1;/* Replacement table for iParent */ + int isOuterJoin = 0; /* True if pSub is the right side of a LEFT JOIN */ + int i; /* Loop counter */ + Expr *pWhere; /* The WHERE clause */ + SrcItem *pSubitem; /* The subquery */ + sqlite3 *db = pParse->db; + Walker w; /* Walker to persist agginfo data */ + int *aCsrMap = 0; + + /* Check to see if flattening is permitted. Return 0 if not. + */ + assert( p!=0 ); + assert( p->pPrior==0 ); + if( OptimizationDisabled(db, SQLITE_QueryFlattener) ) return 0; + pSrc = p->pSrc; + assert( pSrc && iFrom>=0 && iFromnSrc ); + pSubitem = &pSrc->a[iFrom]; + iParent = pSubitem->iCursor; + pSub = pSubitem->pSelect; + assert( pSub!=0 ); + +#ifndef SQLITE_OMIT_WINDOWFUNC + if( p->pWin || pSub->pWin ) return 0; /* Restriction (25) */ +#endif + + pSubSrc = pSub->pSrc; + assert( pSubSrc ); + /* Prior to version 3.1.2, when LIMIT and OFFSET had to be simple constants, + ** not arbitrary expressions, we allowed some combining of LIMIT and OFFSET + ** because they could be computed at compile-time. But when LIMIT and OFFSET + ** became arbitrary expressions, we were forced to add restrictions (13) + ** and (14). */ + if( pSub->pLimit && p->pLimit ) return 0; /* Restriction (13) */ + if( pSub->pLimit && pSub->pLimit->pRight ) return 0; /* Restriction (14) */ + if( (p->selFlags & SF_Compound)!=0 && pSub->pLimit ){ + return 0; /* Restriction (15) */ + } + if( pSubSrc->nSrc==0 ) return 0; /* Restriction (7) */ + if( pSub->selFlags & SF_Distinct ) return 0; /* Restriction (4) */ + if( pSub->pLimit && (pSrc->nSrc>1 || isAgg) ){ + return 0; /* Restrictions (8)(9) */ + } + if( p->pOrderBy && pSub->pOrderBy ){ + return 0; /* Restriction (11) */ + } + if( isAgg && pSub->pOrderBy ) return 0; /* Restriction (16) */ + if( pSub->pLimit && p->pWhere ) return 0; /* Restriction (19) */ + if( pSub->pLimit && (p->selFlags & SF_Distinct)!=0 ){ + return 0; /* Restriction (21) */ + } + if( pSub->selFlags & (SF_Recursive) ){ + return 0; /* Restrictions (22) */ + } + + /* + ** If the subquery is the right operand of a LEFT JOIN, then the + ** subquery may not be a join itself (3a). Example of why this is not + ** allowed: + ** + ** t1 LEFT OUTER JOIN (t2 JOIN t3) + ** + ** If we flatten the above, we would get + ** + ** (t1 LEFT OUTER JOIN t2) JOIN t3 + ** + ** which is not at all the same thing. + ** + ** See also tickets #306, #350, and #3300. + */ + if( (pSubitem->fg.jointype & (JT_OUTER|JT_LTORJ))!=0 ){ + if( pSubSrc->nSrc>1 /* (3a) */ + || IsVirtual(pSubSrc->a[0].pTab) /* (3b) */ + || (p->selFlags & SF_Distinct)!=0 /* (3d) */ + || (pSubitem->fg.jointype & JT_RIGHT)!=0 /* (26) */ + ){ + return 0; + } + isOuterJoin = 1; + } + + assert( pSubSrc->nSrc>0 ); /* True by restriction (7) */ + if( iFrom>0 && (pSubSrc->a[0].fg.jointype & JT_LTORJ)!=0 ){ + return 0; /* Restriction (27a) */ + } + if( pSubitem->fg.isCte && pSubitem->u2.pCteUse->eM10d==M10d_Yes ){ + return 0; /* (28) */ + } + + /* Restriction (17): If the sub-query is a compound SELECT, then it must + ** use only the UNION ALL operator. And none of the simple select queries + ** that make up the compound SELECT are allowed to be aggregate or distinct + ** queries. + */ + if( pSub->pPrior ){ + int ii; + if( pSub->pOrderBy ){ + return 0; /* Restriction (20) */ + } + if( isAgg || (p->selFlags & SF_Distinct)!=0 || isOuterJoin>0 ){ + return 0; /* (17d1), (17d2), or (17f) */ + } + for(pSub1=pSub; pSub1; pSub1=pSub1->pPrior){ + testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct ); + testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate ); + assert( pSub->pSrc!=0 ); + assert( (pSub->selFlags & SF_Recursive)==0 ); + assert( pSub->pEList->nExpr==pSub1->pEList->nExpr ); + if( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))!=0 /* (17b) */ + || (pSub1->pPrior && pSub1->op!=TK_ALL) /* (17a) */ + || pSub1->pSrc->nSrc<1 /* (17c) */ +#ifndef SQLITE_OMIT_WINDOWFUNC + || pSub1->pWin /* (17e) */ +#endif + ){ + return 0; + } + if( iFrom>0 && (pSub1->pSrc->a[0].fg.jointype & JT_LTORJ)!=0 ){ + /* Without this restriction, the JT_LTORJ flag would end up being + ** omitted on left-hand tables of the right join that is being + ** flattened. */ + return 0; /* Restrictions (17g), (27b) */ + } + testcase( pSub1->pSrc->nSrc>1 ); + } + + /* Restriction (18). */ + if( p->pOrderBy ){ + for(ii=0; iipOrderBy->nExpr; ii++){ + if( p->pOrderBy->a[ii].u.x.iOrderByCol==0 ) return 0; + } + } + + /* Restriction (23) */ + if( (p->selFlags & SF_Recursive) ) return 0; + + /* Restriction (17h) */ + if( compoundHasDifferentAffinities(pSub) ) return 0; + + if( pSrc->nSrc>1 ){ + if( pParse->nSelect>500 ) return 0; + if( OptimizationDisabled(db, SQLITE_FlttnUnionAll) ) return 0; + aCsrMap = sqlite3DbMallocZero(db, ((i64)pParse->nTab+1)*sizeof(int)); + if( aCsrMap ) aCsrMap[0] = pParse->nTab; + } + } + + /***** If we reach this point, flattening is permitted. *****/ + TREETRACE(0x4,pParse,p,("flatten %u.%p from term %d\n", + pSub->selId, pSub, iFrom)); + + /* Authorize the subquery */ + pParse->zAuthContext = pSubitem->zName; + TESTONLY(i =) sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0); + testcase( i==SQLITE_DENY ); + pParse->zAuthContext = zSavedAuthContext; + + /* Delete the transient structures associated with thesubquery */ + pSub1 = pSubitem->pSelect; + sqlite3DbFree(db, pSubitem->zDatabase); + sqlite3DbFree(db, pSubitem->zName); + sqlite3DbFree(db, pSubitem->zAlias); + pSubitem->zDatabase = 0; + pSubitem->zName = 0; + pSubitem->zAlias = 0; + pSubitem->pSelect = 0; + assert( pSubitem->fg.isUsing!=0 || pSubitem->u3.pOn==0 ); + + /* If the sub-query is a compound SELECT statement, then (by restrictions + ** 17 and 18 above) it must be a UNION ALL and the parent query must + ** be of the form: + ** + ** SELECT FROM () + ** + ** followed by any ORDER BY, LIMIT and/or OFFSET clauses. This block + ** creates N-1 copies of the parent query without any ORDER BY, LIMIT or + ** OFFSET clauses and joins them to the left-hand-side of the original + ** using UNION ALL operators. In this case N is the number of simple + ** select statements in the compound sub-query. + ** + ** Example: + ** + ** SELECT a+1 FROM ( + ** SELECT x FROM tab + ** UNION ALL + ** SELECT y FROM tab + ** UNION ALL + ** SELECT abs(z*2) FROM tab2 + ** ) WHERE a!=5 ORDER BY 1 + ** + ** Transformed into: + ** + ** SELECT x+1 FROM tab WHERE x+1!=5 + ** UNION ALL + ** SELECT y+1 FROM tab WHERE y+1!=5 + ** UNION ALL + ** SELECT abs(z*2)+1 FROM tab2 WHERE abs(z*2)+1!=5 + ** ORDER BY 1 + ** + ** We call this the "compound-subquery flattening". + */ + for(pSub=pSub->pPrior; pSub; pSub=pSub->pPrior){ + Select *pNew; + ExprList *pOrderBy = p->pOrderBy; + Expr *pLimit = p->pLimit; + Select *pPrior = p->pPrior; + Table *pItemTab = pSubitem->pTab; + pSubitem->pTab = 0; + p->pOrderBy = 0; + p->pPrior = 0; + p->pLimit = 0; + pNew = sqlite3SelectDup(db, p, 0); + p->pLimit = pLimit; + p->pOrderBy = pOrderBy; + p->op = TK_ALL; + pSubitem->pTab = pItemTab; + if( pNew==0 ){ + p->pPrior = pPrior; + }else{ + pNew->selId = ++pParse->nSelect; + if( aCsrMap && ALWAYS(db->mallocFailed==0) ){ + renumberCursors(pParse, pNew, iFrom, aCsrMap); + } + pNew->pPrior = pPrior; + if( pPrior ) pPrior->pNext = pNew; + pNew->pNext = p; + p->pPrior = pNew; + TREETRACE(0x4,pParse,p,("compound-subquery flattener" + " creates %u as peer\n",pNew->selId)); + } + assert( pSubitem->pSelect==0 ); + } + sqlite3DbFree(db, aCsrMap); + if( db->mallocFailed ){ + pSubitem->pSelect = pSub1; + return 1; + } + + /* Defer deleting the Table object associated with the + ** subquery until code generation is + ** complete, since there may still exist Expr.pTab entries that + ** refer to the subquery even after flattening. Ticket #3346. + ** + ** pSubitem->pTab is always non-NULL by test restrictions and tests above. + */ + if( ALWAYS(pSubitem->pTab!=0) ){ + Table *pTabToDel = pSubitem->pTab; + if( pTabToDel->nTabRef==1 ){ + Parse *pToplevel = sqlite3ParseToplevel(pParse); + sqlite3ParserAddCleanup(pToplevel, + (void(*)(sqlite3*,void*))sqlite3DeleteTable, + pTabToDel); + testcase( pToplevel->earlyCleanup ); + }else{ + pTabToDel->nTabRef--; + } + pSubitem->pTab = 0; + } + + /* The following loop runs once for each term in a compound-subquery + ** flattening (as described above). If we are doing a different kind + ** of flattening - a flattening other than a compound-subquery flattening - + ** then this loop only runs once. + ** + ** This loop moves all of the FROM elements of the subquery into the + ** the FROM clause of the outer query. Before doing this, remember + ** the cursor number for the original outer query FROM element in + ** iParent. The iParent cursor will never be used. Subsequent code + ** will scan expressions looking for iParent references and replace + ** those references with expressions that resolve to the subquery FROM + ** elements we are now copying in. + */ + pSub = pSub1; + for(pParent=p; pParent; pParent=pParent->pPrior, pSub=pSub->pPrior){ + int nSubSrc; + u8 jointype = 0; + u8 ltorj = pSrc->a[iFrom].fg.jointype & JT_LTORJ; + assert( pSub!=0 ); + pSubSrc = pSub->pSrc; /* FROM clause of subquery */ + nSubSrc = pSubSrc->nSrc; /* Number of terms in subquery FROM clause */ + pSrc = pParent->pSrc; /* FROM clause of the outer query */ + + if( pParent==p ){ + jointype = pSubitem->fg.jointype; /* First time through the loop */ + } + + /* The subquery uses a single slot of the FROM clause of the outer + ** query. If the subquery has more than one element in its FROM clause, + ** then expand the outer query to make space for it to hold all elements + ** of the subquery. + ** + ** Example: + ** + ** SELECT * FROM tabA, (SELECT * FROM sub1, sub2), tabB; + ** + ** The outer query has 3 slots in its FROM clause. One slot of the + ** outer query (the middle slot) is used by the subquery. The next + ** block of code will expand the outer query FROM clause to 4 slots. + ** The middle slot is expanded to two slots in order to make space + ** for the two elements in the FROM clause of the subquery. + */ + if( nSubSrc>1 ){ + pSrc = sqlite3SrcListEnlarge(pParse, pSrc, nSubSrc-1,iFrom+1); + if( pSrc==0 ) break; + pParent->pSrc = pSrc; + } + + /* Transfer the FROM clause terms from the subquery into the + ** outer query. + */ + for(i=0; ia[i+iFrom]; + if( pItem->fg.isUsing ) sqlite3IdListDelete(db, pItem->u3.pUsing); + assert( pItem->fg.isTabFunc==0 ); + *pItem = pSubSrc->a[i]; + pItem->fg.jointype |= ltorj; + iNewParent = pSubSrc->a[i].iCursor; + memset(&pSubSrc->a[i], 0, sizeof(pSubSrc->a[i])); + } + pSrc->a[iFrom].fg.jointype &= JT_LTORJ; + pSrc->a[iFrom].fg.jointype |= jointype | ltorj; + + /* Now begin substituting subquery result set expressions for + ** references to the iParent in the outer query. + ** + ** Example: + ** + ** SELECT a+5, b*10 FROM (SELECT x*3 AS a, y+10 AS b FROM t1) WHERE a>b; + ** \ \_____________ subquery __________/ / + ** \_____________________ outer query ______________________________/ + ** + ** We look at every expression in the outer query and every place we see + ** "a" we substitute "x*3" and every place we see "b" we substitute "y+10". + */ + if( pSub->pOrderBy && (pParent->selFlags & SF_NoopOrderBy)==0 ){ + /* At this point, any non-zero iOrderByCol values indicate that the + ** ORDER BY column expression is identical to the iOrderByCol'th + ** expression returned by SELECT statement pSub. Since these values + ** do not necessarily correspond to columns in SELECT statement pParent, + ** zero them before transfering the ORDER BY clause. + ** + ** Not doing this may cause an error if a subsequent call to this + ** function attempts to flatten a compound sub-query into pParent + ** (the only way this can happen is if the compound sub-query is + ** currently part of pSub->pSrc). See ticket [d11a6e908f]. */ + ExprList *pOrderBy = pSub->pOrderBy; + for(i=0; inExpr; i++){ + pOrderBy->a[i].u.x.iOrderByCol = 0; + } + assert( pParent->pOrderBy==0 ); + pParent->pOrderBy = pOrderBy; + pSub->pOrderBy = 0; + } + pWhere = pSub->pWhere; + pSub->pWhere = 0; + if( isOuterJoin>0 ){ + sqlite3SetJoinExpr(pWhere, iNewParent, EP_OuterON); + } + if( pWhere ){ + if( pParent->pWhere ){ + pParent->pWhere = sqlite3PExpr(pParse, TK_AND, pWhere, pParent->pWhere); + }else{ + pParent->pWhere = pWhere; + } + } + if( db->mallocFailed==0 ){ + SubstContext x; + x.pParse = pParse; + x.iTable = iParent; + x.iNewTable = iNewParent; + x.isOuterJoin = isOuterJoin; + x.pEList = pSub->pEList; + x.pCList = findLeftmostExprlist(pSub); + substSelect(&x, pParent, 0); + } + + /* The flattened query is a compound if either the inner or the + ** outer query is a compound. */ + pParent->selFlags |= pSub->selFlags & SF_Compound; + assert( (pSub->selFlags & SF_Distinct)==0 ); /* restriction (17b) */ + + /* + ** SELECT ... FROM (SELECT ... LIMIT a OFFSET b) LIMIT x OFFSET y; + ** + ** One is tempted to try to add a and b to combine the limits. But this + ** does not work if either limit is negative. + */ + if( pSub->pLimit ){ + pParent->pLimit = pSub->pLimit; + pSub->pLimit = 0; + } + + /* Recompute the SrcItem.colUsed masks for the flattened + ** tables. */ + for(i=0; ia[i+iFrom]); + } + } + + /* Finially, delete what is left of the subquery and return + ** success. + */ + sqlite3AggInfoPersistWalkerInit(&w, pParse); + sqlite3WalkSelect(&w,pSub1); + sqlite3SelectDelete(db, pSub1); + +#if TREETRACE_ENABLED + if( sqlite3TreeTrace & 0x4 ){ + TREETRACE(0x4,pParse,p,("After flattening:\n")); + sqlite3TreeViewSelect(0, p, 0); + } +#endif + + return 1; +} +#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */ + +/* +** A structure to keep track of all of the column values that are fixed to +** a known value due to WHERE clause constraints of the form COLUMN=VALUE. +*/ +typedef struct WhereConst WhereConst; +struct WhereConst { + Parse *pParse; /* Parsing context */ + u8 *pOomFault; /* Pointer to pParse->db->mallocFailed */ + int nConst; /* Number for COLUMN=CONSTANT terms */ + int nChng; /* Number of times a constant is propagated */ + int bHasAffBlob; /* At least one column in apExpr[] as affinity BLOB */ + u32 mExcludeOn; /* Which ON expressions to exclude from considertion. + ** Either EP_OuterON or EP_InnerON|EP_OuterON */ + Expr **apExpr; /* [i*2] is COLUMN and [i*2+1] is VALUE */ +}; + +/* +** Add a new entry to the pConst object. Except, do not add duplicate +** pColumn entires. Also, do not add if doing so would not be appropriate. +** +** The caller guarantees the pColumn is a column and pValue is a constant. +** This routine has to do some additional checks before completing the +** insert. +*/ +static void constInsert( + WhereConst *pConst, /* The WhereConst into which we are inserting */ + Expr *pColumn, /* The COLUMN part of the constraint */ + Expr *pValue, /* The VALUE part of the constraint */ + Expr *pExpr /* Overall expression: COLUMN=VALUE or VALUE=COLUMN */ +){ + int i; + assert( pColumn->op==TK_COLUMN ); + assert( sqlite3ExprIsConstant(pValue) ); + + if( ExprHasProperty(pColumn, EP_FixedCol) ) return; + if( sqlite3ExprAffinity(pValue)!=0 ) return; + if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pConst->pParse,pExpr)) ){ + return; + } + + /* 2018-10-25 ticket [cf5ed20f] + ** Make sure the same pColumn is not inserted more than once */ + for(i=0; inConst; i++){ + const Expr *pE2 = pConst->apExpr[i*2]; + assert( pE2->op==TK_COLUMN ); + if( pE2->iTable==pColumn->iTable + && pE2->iColumn==pColumn->iColumn + ){ + return; /* Already present. Return without doing anything. */ + } + } + if( sqlite3ExprAffinity(pColumn)==SQLITE_AFF_BLOB ){ + pConst->bHasAffBlob = 1; + } + + pConst->nConst++; + pConst->apExpr = sqlite3DbReallocOrFree(pConst->pParse->db, pConst->apExpr, + pConst->nConst*2*sizeof(Expr*)); + if( pConst->apExpr==0 ){ + pConst->nConst = 0; + }else{ + pConst->apExpr[pConst->nConst*2-2] = pColumn; + pConst->apExpr[pConst->nConst*2-1] = pValue; + } +} + +/* +** Find all terms of COLUMN=VALUE or VALUE=COLUMN in pExpr where VALUE +** is a constant expression and where the term must be true because it +** is part of the AND-connected terms of the expression. For each term +** found, add it to the pConst structure. +*/ +static void findConstInWhere(WhereConst *pConst, Expr *pExpr){ + Expr *pRight, *pLeft; + if( NEVER(pExpr==0) ) return; + if( ExprHasProperty(pExpr, pConst->mExcludeOn) ){ + testcase( ExprHasProperty(pExpr, EP_OuterON) ); + testcase( ExprHasProperty(pExpr, EP_InnerON) ); + return; + } + if( pExpr->op==TK_AND ){ + findConstInWhere(pConst, pExpr->pRight); + findConstInWhere(pConst, pExpr->pLeft); + return; + } + if( pExpr->op!=TK_EQ ) return; + pRight = pExpr->pRight; + pLeft = pExpr->pLeft; + assert( pRight!=0 ); + assert( pLeft!=0 ); + if( pRight->op==TK_COLUMN && sqlite3ExprIsConstant(pLeft) ){ + constInsert(pConst,pRight,pLeft,pExpr); + } + if( pLeft->op==TK_COLUMN && sqlite3ExprIsConstant(pRight) ){ + constInsert(pConst,pLeft,pRight,pExpr); + } +} + +/* +** This is a helper function for Walker callback propagateConstantExprRewrite(). +** +** Argument pExpr is a candidate expression to be replaced by a value. If +** pExpr is equivalent to one of the columns named in pWalker->u.pConst, +** then overwrite it with the corresponding value. Except, do not do so +** if argument bIgnoreAffBlob is non-zero and the affinity of pExpr +** is SQLITE_AFF_BLOB. +*/ +static int propagateConstantExprRewriteOne( + WhereConst *pConst, + Expr *pExpr, + int bIgnoreAffBlob +){ + int i; + if( pConst->pOomFault[0] ) return WRC_Prune; + if( pExpr->op!=TK_COLUMN ) return WRC_Continue; + if( ExprHasProperty(pExpr, EP_FixedCol|pConst->mExcludeOn) ){ + testcase( ExprHasProperty(pExpr, EP_FixedCol) ); + testcase( ExprHasProperty(pExpr, EP_OuterON) ); + testcase( ExprHasProperty(pExpr, EP_InnerON) ); + return WRC_Continue; + } + for(i=0; inConst; i++){ + Expr *pColumn = pConst->apExpr[i*2]; + if( pColumn==pExpr ) continue; + if( pColumn->iTable!=pExpr->iTable ) continue; + if( pColumn->iColumn!=pExpr->iColumn ) continue; + if( bIgnoreAffBlob && sqlite3ExprAffinity(pColumn)==SQLITE_AFF_BLOB ){ + break; + } + /* A match is found. Add the EP_FixedCol property */ + pConst->nChng++; + ExprClearProperty(pExpr, EP_Leaf); + ExprSetProperty(pExpr, EP_FixedCol); + assert( pExpr->pLeft==0 ); + pExpr->pLeft = sqlite3ExprDup(pConst->pParse->db, pConst->apExpr[i*2+1], 0); + if( pConst->pParse->db->mallocFailed ) return WRC_Prune; + break; + } + return WRC_Prune; +} + +/* +** This is a Walker expression callback. pExpr is a node from the WHERE +** clause of a SELECT statement. This function examines pExpr to see if +** any substitutions based on the contents of pWalker->u.pConst should +** be made to pExpr or its immediate children. +** +** A substitution is made if: +** +** + pExpr is a column with an affinity other than BLOB that matches +** one of the columns in pWalker->u.pConst, or +** +** + pExpr is a binary comparison operator (=, <=, >=, <, >) that +** uses an affinity other than TEXT and one of its immediate +** children is a column that matches one of the columns in +** pWalker->u.pConst. +*/ +static int propagateConstantExprRewrite(Walker *pWalker, Expr *pExpr){ + WhereConst *pConst = pWalker->u.pConst; + assert( TK_GT==TK_EQ+1 ); + assert( TK_LE==TK_EQ+2 ); + assert( TK_LT==TK_EQ+3 ); + assert( TK_GE==TK_EQ+4 ); + if( pConst->bHasAffBlob ){ + if( (pExpr->op>=TK_EQ && pExpr->op<=TK_GE) + || pExpr->op==TK_IS + ){ + propagateConstantExprRewriteOne(pConst, pExpr->pLeft, 0); + if( pConst->pOomFault[0] ) return WRC_Prune; + if( sqlite3ExprAffinity(pExpr->pLeft)!=SQLITE_AFF_TEXT ){ + propagateConstantExprRewriteOne(pConst, pExpr->pRight, 0); + } + } + } + return propagateConstantExprRewriteOne(pConst, pExpr, pConst->bHasAffBlob); +} + +/* +** The WHERE-clause constant propagation optimization. +** +** If the WHERE clause contains terms of the form COLUMN=CONSTANT or +** CONSTANT=COLUMN that are top-level AND-connected terms that are not +** part of a ON clause from a LEFT JOIN, then throughout the query +** replace all other occurrences of COLUMN with CONSTANT. +** +** For example, the query: +** +** SELECT * FROM t1, t2, t3 WHERE t1.a=39 AND t2.b=t1.a AND t3.c=t2.b +** +** Is transformed into +** +** SELECT * FROM t1, t2, t3 WHERE t1.a=39 AND t2.b=39 AND t3.c=39 +** +** Return true if any transformations where made and false if not. +** +** Implementation note: Constant propagation is tricky due to affinity +** and collating sequence interactions. Consider this example: +** +** CREATE TABLE t1(a INT,b TEXT); +** INSERT INTO t1 VALUES(123,'0123'); +** SELECT * FROM t1 WHERE a=123 AND b=a; +** SELECT * FROM t1 WHERE a=123 AND b=123; +** +** The two SELECT statements above should return different answers. b=a +** is alway true because the comparison uses numeric affinity, but b=123 +** is false because it uses text affinity and '0123' is not the same as '123'. +** To work around this, the expression tree is not actually changed from +** "b=a" to "b=123" but rather the "a" in "b=a" is tagged with EP_FixedCol +** and the "123" value is hung off of the pLeft pointer. Code generator +** routines know to generate the constant "123" instead of looking up the +** column value. Also, to avoid collation problems, this optimization is +** only attempted if the "a=123" term uses the default BINARY collation. +** +** 2021-05-25 forum post 6a06202608: Another troublesome case is... +** +** CREATE TABLE t1(x); +** INSERT INTO t1 VALUES(10.0); +** SELECT 1 FROM t1 WHERE x=10 AND x LIKE 10; +** +** The query should return no rows, because the t1.x value is '10.0' not '10' +** and '10.0' is not LIKE '10'. But if we are not careful, the first WHERE +** term "x=10" will cause the second WHERE term to become "10 LIKE 10", +** resulting in a false positive. To avoid this, constant propagation for +** columns with BLOB affinity is only allowed if the constant is used with +** operators ==, <=, <, >=, >, or IS in a way that will cause the correct +** type conversions to occur. See logic associated with the bHasAffBlob flag +** for details. +*/ +static int propagateConstants( + Parse *pParse, /* The parsing context */ + Select *p /* The query in which to propagate constants */ +){ + WhereConst x; + Walker w; + int nChng = 0; + x.pParse = pParse; + x.pOomFault = &pParse->db->mallocFailed; + do{ + x.nConst = 0; + x.nChng = 0; + x.apExpr = 0; + x.bHasAffBlob = 0; + if( ALWAYS(p->pSrc!=0) + && p->pSrc->nSrc>0 + && (p->pSrc->a[0].fg.jointype & JT_LTORJ)!=0 + ){ + /* Do not propagate constants on any ON clause if there is a + ** RIGHT JOIN anywhere in the query */ + x.mExcludeOn = EP_InnerON | EP_OuterON; + }else{ + /* Do not propagate constants through the ON clause of a LEFT JOIN */ + x.mExcludeOn = EP_OuterON; + } + findConstInWhere(&x, p->pWhere); + if( x.nConst ){ + memset(&w, 0, sizeof(w)); + w.pParse = pParse; + w.xExprCallback = propagateConstantExprRewrite; + w.xSelectCallback = sqlite3SelectWalkNoop; + w.xSelectCallback2 = 0; + w.walkerDepth = 0; + w.u.pConst = &x; + sqlite3WalkExpr(&w, p->pWhere); + sqlite3DbFree(x.pParse->db, x.apExpr); + nChng += x.nChng; + } + }while( x.nChng ); + return nChng; +} + +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) +# if !defined(SQLITE_OMIT_WINDOWFUNC) +/* +** This function is called to determine whether or not it is safe to +** push WHERE clause expression pExpr down to FROM clause sub-query +** pSubq, which contains at least one window function. Return 1 +** if it is safe and the expression should be pushed down, or 0 +** otherwise. +** +** It is only safe to push the expression down if it consists only +** of constants and copies of expressions that appear in the PARTITION +** BY clause of all window function used by the sub-query. It is safe +** to filter out entire partitions, but not rows within partitions, as +** this may change the results of the window functions. +** +** At the time this function is called it is guaranteed that +** +** * the sub-query uses only one distinct window frame, and +** * that the window frame has a PARTITION BY clase. +*/ +static int pushDownWindowCheck(Parse *pParse, Select *pSubq, Expr *pExpr){ + assert( pSubq->pWin->pPartition ); + assert( (pSubq->selFlags & SF_MultiPart)==0 ); + assert( pSubq->pPrior==0 ); + return sqlite3ExprIsConstantOrGroupBy(pParse, pExpr, pSubq->pWin->pPartition); +} +# endif /* SQLITE_OMIT_WINDOWFUNC */ +#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */ + +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) +/* +** Make copies of relevant WHERE clause terms of the outer query into +** the WHERE clause of subquery. Example: +** +** SELECT * FROM (SELECT a AS x, c-d AS y FROM t1) WHERE x=5 AND y=10; +** +** Transformed into: +** +** SELECT * FROM (SELECT a AS x, c-d AS y FROM t1 WHERE a=5 AND c-d=10) +** WHERE x=5 AND y=10; +** +** The hope is that the terms added to the inner query will make it more +** efficient. +** +** Do not attempt this optimization if: +** +** (1) (** This restriction was removed on 2017-09-29. We used to +** disallow this optimization for aggregate subqueries, but now +** it is allowed by putting the extra terms on the HAVING clause. +** The added HAVING clause is pointless if the subquery lacks +** a GROUP BY clause. But such a HAVING clause is also harmless +** so there does not appear to be any reason to add extra logic +** to suppress it. **) +** +** (2) The inner query is the recursive part of a common table expression. +** +** (3) The inner query has a LIMIT clause (since the changes to the WHERE +** clause would change the meaning of the LIMIT). +** +** (4) The inner query is the right operand of a LEFT JOIN and the +** expression to be pushed down does not come from the ON clause +** on that LEFT JOIN. +** +** (5) The WHERE clause expression originates in the ON or USING clause +** of a LEFT JOIN where iCursor is not the right-hand table of that +** left join. An example: +** +** SELECT * +** FROM (SELECT 1 AS a1 UNION ALL SELECT 2) AS aa +** JOIN (SELECT 1 AS b2 UNION ALL SELECT 2) AS bb ON (a1=b2) +** LEFT JOIN (SELECT 8 AS c3 UNION ALL SELECT 9) AS cc ON (b2=2); +** +** The correct answer is three rows: (1,1,NULL),(2,2,8),(2,2,9). +** But if the (b2=2) term were to be pushed down into the bb subquery, +** then the (1,1,NULL) row would be suppressed. +** +** (6) Window functions make things tricky as changes to the WHERE clause +** of the inner query could change the window over which window +** functions are calculated. Therefore, do not attempt the optimization +** if: +** +** (6a) The inner query uses multiple incompatible window partitions. +** +** (6b) The inner query is a compound and uses window-functions. +** +** (6c) The WHERE clause does not consist entirely of constants and +** copies of expressions found in the PARTITION BY clause of +** all window-functions used by the sub-query. It is safe to +** filter out entire partitions, as this does not change the +** window over which any window-function is calculated. +** +** (7) The inner query is a Common Table Expression (CTE) that should +** be materialized. (This restriction is implemented in the calling +** routine.) +** +** (8) If the subquery is a compound that uses UNION, INTERSECT, +** or EXCEPT, then all of the result set columns for all arms of +** the compound must use the BINARY collating sequence. +** +** (9) All three of the following are true: +** +** (9a) The WHERE clause expression originates in the ON or USING clause +** of a join (either an INNER or an OUTER join), and +** +** (9b) The subquery is to the right of the ON/USING clause +** +** (9c) There is a RIGHT JOIN (or FULL JOIN) in between the ON/USING +** clause and the subquery. +** +** Without this restriction, the push-down optimization might move +** the ON/USING filter expression from the left side of a RIGHT JOIN +** over to the right side, which leads to incorrect answers. See +** also restriction (6) in sqlite3ExprIsSingleTableConstraint(). +** +** (10) The inner query is not the right-hand table of a RIGHT JOIN. +** +** (11) The subquery is not a VALUES clause +** +** Return 0 if no changes are made and non-zero if one or more WHERE clause +** terms are duplicated into the subquery. +*/ +static int pushDownWhereTerms( + Parse *pParse, /* Parse context (for malloc() and error reporting) */ + Select *pSubq, /* The subquery whose WHERE clause is to be augmented */ + Expr *pWhere, /* The WHERE clause of the outer query */ + SrcList *pSrcList, /* The complete from clause of the outer query */ + int iSrc /* Which FROM clause term to try to push into */ +){ + Expr *pNew; + SrcItem *pSrc; /* The subquery FROM term into which WHERE is pushed */ + int nChng = 0; + pSrc = &pSrcList->a[iSrc]; + if( pWhere==0 ) return 0; + if( pSubq->selFlags & (SF_Recursive|SF_MultiPart) ){ + return 0; /* restrictions (2) and (11) */ + } + if( pSrc->fg.jointype & (JT_LTORJ|JT_RIGHT) ){ + return 0; /* restrictions (10) */ + } + + if( pSubq->pPrior ){ + Select *pSel; + int notUnionAll = 0; + for(pSel=pSubq; pSel; pSel=pSel->pPrior){ + u8 op = pSel->op; + assert( op==TK_ALL || op==TK_SELECT + || op==TK_UNION || op==TK_INTERSECT || op==TK_EXCEPT ); + if( op!=TK_ALL && op!=TK_SELECT ){ + notUnionAll = 1; + } +#ifndef SQLITE_OMIT_WINDOWFUNC + if( pSel->pWin ) return 0; /* restriction (6b) */ +#endif + } + if( notUnionAll ){ + /* If any of the compound arms are connected using UNION, INTERSECT, + ** or EXCEPT, then we must ensure that none of the columns use a + ** non-BINARY collating sequence. */ + for(pSel=pSubq; pSel; pSel=pSel->pPrior){ + int ii; + const ExprList *pList = pSel->pEList; + assert( pList!=0 ); + for(ii=0; iinExpr; ii++){ + CollSeq *pColl = sqlite3ExprCollSeq(pParse, pList->a[ii].pExpr); + if( !sqlite3IsBinary(pColl) ){ + return 0; /* Restriction (8) */ + } + } + } + } + }else{ +#ifndef SQLITE_OMIT_WINDOWFUNC + if( pSubq->pWin && pSubq->pWin->pPartition==0 ) return 0; +#endif + } + +#ifdef SQLITE_DEBUG + /* Only the first term of a compound can have a WITH clause. But make + ** sure no other terms are marked SF_Recursive in case something changes + ** in the future. + */ + { + Select *pX; + for(pX=pSubq; pX; pX=pX->pPrior){ + assert( (pX->selFlags & (SF_Recursive))==0 ); + } + } +#endif + + if( pSubq->pLimit!=0 ){ + return 0; /* restriction (3) */ + } + while( pWhere->op==TK_AND ){ + nChng += pushDownWhereTerms(pParse, pSubq, pWhere->pRight, pSrcList, iSrc); + pWhere = pWhere->pLeft; + } + +#if 0 /* These checks now done by sqlite3ExprIsSingleTableConstraint() */ + if( ExprHasProperty(pWhere, EP_OuterON|EP_InnerON) /* (9a) */ + && (pSrcList->a[0].fg.jointype & JT_LTORJ)!=0 /* Fast pre-test of (9c) */ + ){ + int jj; + for(jj=0; jjw.iJoin==pSrcList->a[jj].iCursor ){ + /* If we reach this point, both (9a) and (9b) are satisfied. + ** The following loop checks (9c): + */ + for(jj++; jja[jj].fg.jointype & JT_RIGHT)!=0 ){ + return 0; /* restriction (9) */ + } + } + } + } + } + if( isLeftJoin + && (ExprHasProperty(pWhere,EP_OuterON)==0 + || pWhere->w.iJoin!=iCursor) + ){ + return 0; /* restriction (4) */ + } + if( ExprHasProperty(pWhere,EP_OuterON) + && pWhere->w.iJoin!=iCursor + ){ + return 0; /* restriction (5) */ + } +#endif + + if( sqlite3ExprIsSingleTableConstraint(pWhere, pSrcList, iSrc) ){ + nChng++; + pSubq->selFlags |= SF_PushDown; + while( pSubq ){ + SubstContext x; + pNew = sqlite3ExprDup(pParse->db, pWhere, 0); + unsetJoinExpr(pNew, -1, 1); + x.pParse = pParse; + x.iTable = pSrc->iCursor; + x.iNewTable = pSrc->iCursor; + x.isOuterJoin = 0; + x.pEList = pSubq->pEList; + x.pCList = findLeftmostExprlist(pSubq); + pNew = substExpr(&x, pNew); +#ifndef SQLITE_OMIT_WINDOWFUNC + if( pSubq->pWin && 0==pushDownWindowCheck(pParse, pSubq, pNew) ){ + /* Restriction 6c has prevented push-down in this case */ + sqlite3ExprDelete(pParse->db, pNew); + nChng--; + break; + } +#endif + if( pSubq->selFlags & SF_Aggregate ){ + pSubq->pHaving = sqlite3ExprAnd(pParse, pSubq->pHaving, pNew); + }else{ + pSubq->pWhere = sqlite3ExprAnd(pParse, pSubq->pWhere, pNew); + } + pSubq = pSubq->pPrior; + } + } + return nChng; +} +#endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */ + +/* +** Check to see if a subquery contains result-set columns that are +** never used. If it does, change the value of those result-set columns +** to NULL so that they do not cause unnecessary work to compute. +** +** Return the number of column that were changed to NULL. +*/ +static int disableUnusedSubqueryResultColumns(SrcItem *pItem){ + int nCol; + Select *pSub; /* The subquery to be simplified */ + Select *pX; /* For looping over compound elements of pSub */ + Table *pTab; /* The table that describes the subquery */ + int j; /* Column number */ + int nChng = 0; /* Number of columns converted to NULL */ + Bitmask colUsed; /* Columns that may not be NULLed out */ + + assert( pItem!=0 ); + if( pItem->fg.isCorrelated || pItem->fg.isCte ){ + return 0; + } + assert( pItem->pTab!=0 ); + pTab = pItem->pTab; + assert( pItem->pSelect!=0 ); + pSub = pItem->pSelect; + assert( pSub->pEList->nExpr==pTab->nCol ); + if( (pSub->selFlags & (SF_Distinct|SF_Aggregate))!=0 ){ + testcase( pSub->selFlags & SF_Distinct ); + testcase( pSub->selFlags & SF_Aggregate ); + return 0; + } + for(pX=pSub; pX; pX=pX->pPrior){ + if( pX->pPrior && pX->op!=TK_ALL ){ + /* This optimization does not work for compound subqueries that + ** use UNION, INTERSECT, or EXCEPT. Only UNION ALL is allowed. */ + return 0; + } +#ifndef SQLITE_OMIT_WINDOWFUNC + if( pX->pWin ){ + /* This optimization does not work for subqueries that use window + ** functions. */ + return 0; + } +#endif + } + colUsed = pItem->colUsed; + if( pSub->pOrderBy ){ + ExprList *pList = pSub->pOrderBy; + for(j=0; jnExpr; j++){ + u16 iCol = pList->a[j].u.x.iOrderByCol; + if( iCol>0 ){ + iCol--; + colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol); + } + } + } + nCol = pTab->nCol; + for(j=0; jpPrior) { + Expr *pY = pX->pEList->a[j].pExpr; + if( pY->op==TK_NULL ) continue; + pY->op = TK_NULL; + ExprClearProperty(pY, EP_Skip|EP_Unlikely); + pX->selFlags |= SF_PushDown; + nChng++; + } + } + return nChng; +} + + +/* +** The pFunc is the only aggregate function in the query. Check to see +** if the query is a candidate for the min/max optimization. +** +** If the query is a candidate for the min/max optimization, then set +** *ppMinMax to be an ORDER BY clause to be used for the optimization +** and return either WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX depending on +** whether pFunc is a min() or max() function. +** +** If the query is not a candidate for the min/max optimization, return +** WHERE_ORDERBY_NORMAL (which must be zero). +** +** This routine must be called after aggregate functions have been +** located but before their arguments have been subjected to aggregate +** analysis. +*/ +static u8 minMaxQuery(sqlite3 *db, Expr *pFunc, ExprList **ppMinMax){ + int eRet = WHERE_ORDERBY_NORMAL; /* Return value */ + ExprList *pEList; /* Arguments to agg function */ + const char *zFunc; /* Name of aggregate function pFunc */ + ExprList *pOrderBy; + u8 sortFlags = 0; + + assert( *ppMinMax==0 ); + assert( pFunc->op==TK_AGG_FUNCTION ); + assert( !IsWindowFunc(pFunc) ); + assert( ExprUseXList(pFunc) ); + pEList = pFunc->x.pList; + if( pEList==0 + || pEList->nExpr!=1 + || ExprHasProperty(pFunc, EP_WinFunc) + || OptimizationDisabled(db, SQLITE_MinMaxOpt) + ){ + return eRet; + } + assert( !ExprHasProperty(pFunc, EP_IntValue) ); + zFunc = pFunc->u.zToken; + if( sqlite3StrICmp(zFunc, "min")==0 ){ + eRet = WHERE_ORDERBY_MIN; + if( sqlite3ExprCanBeNull(pEList->a[0].pExpr) ){ + sortFlags = KEYINFO_ORDER_BIGNULL; + } + }else if( sqlite3StrICmp(zFunc, "max")==0 ){ + eRet = WHERE_ORDERBY_MAX; + sortFlags = KEYINFO_ORDER_DESC; + }else{ + return eRet; + } + *ppMinMax = pOrderBy = sqlite3ExprListDup(db, pEList, 0); + assert( pOrderBy!=0 || db->mallocFailed ); + if( pOrderBy ) pOrderBy->a[0].fg.sortFlags = sortFlags; + return eRet; +} + +/* +** The select statement passed as the first argument is an aggregate query. +** The second argument is the associated aggregate-info object. This +** function tests if the SELECT is of the form: +** +** SELECT count(*) FROM +** +** where table is a database table, not a sub-select or view. If the query +** does match this pattern, then a pointer to the Table object representing +** is returned. Otherwise, NULL is returned. +** +** This routine checks to see if it is safe to use the count optimization. +** A correct answer is still obtained (though perhaps more slowly) if +** this routine returns NULL when it could have returned a table pointer. +** But returning the pointer when NULL should have been returned can +** result in incorrect answers and/or crashes. So, when in doubt, return NULL. +*/ +static Table *isSimpleCount(Select *p, AggInfo *pAggInfo){ + Table *pTab; + Expr *pExpr; + + assert( !p->pGroupBy ); + + if( p->pWhere + || p->pEList->nExpr!=1 + || p->pSrc->nSrc!=1 + || p->pSrc->a[0].pSelect + || pAggInfo->nFunc!=1 + || p->pHaving + ){ + return 0; + } + pTab = p->pSrc->a[0].pTab; + assert( pTab!=0 ); + assert( !IsView(pTab) ); + if( !IsOrdinaryTable(pTab) ) return 0; + pExpr = p->pEList->a[0].pExpr; + assert( pExpr!=0 ); + if( pExpr->op!=TK_AGG_FUNCTION ) return 0; + if( pExpr->pAggInfo!=pAggInfo ) return 0; + if( (pAggInfo->aFunc[0].pFunc->funcFlags&SQLITE_FUNC_COUNT)==0 ) return 0; + assert( pAggInfo->aFunc[0].pFExpr==pExpr ); + testcase( ExprHasProperty(pExpr, EP_Distinct) ); + testcase( ExprHasProperty(pExpr, EP_WinFunc) ); + if( ExprHasProperty(pExpr, EP_Distinct|EP_WinFunc) ) return 0; + + return pTab; +} + +/* +** If the source-list item passed as an argument was augmented with an +** INDEXED BY clause, then try to locate the specified index. If there +** was such a clause and the named index cannot be found, return +** SQLITE_ERROR and leave an error in pParse. Otherwise, populate +** pFrom->pIndex and return SQLITE_OK. +*/ +SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *pParse, SrcItem *pFrom){ + Table *pTab = pFrom->pTab; + char *zIndexedBy = pFrom->u1.zIndexedBy; + Index *pIdx; + assert( pTab!=0 ); + assert( pFrom->fg.isIndexedBy!=0 ); + + for(pIdx=pTab->pIndex; + pIdx && sqlite3StrICmp(pIdx->zName, zIndexedBy); + pIdx=pIdx->pNext + ); + if( !pIdx ){ + sqlite3ErrorMsg(pParse, "no such index: %s", zIndexedBy, 0); + pParse->checkSchema = 1; + return SQLITE_ERROR; + } + assert( pFrom->fg.isCte==0 ); + pFrom->u2.pIBIndex = pIdx; + return SQLITE_OK; +} + +/* +** Detect compound SELECT statements that use an ORDER BY clause with +** an alternative collating sequence. +** +** SELECT ... FROM t1 EXCEPT SELECT ... FROM t2 ORDER BY .. COLLATE ... +** +** These are rewritten as a subquery: +** +** SELECT * FROM (SELECT ... FROM t1 EXCEPT SELECT ... FROM t2) +** ORDER BY ... COLLATE ... +** +** This transformation is necessary because the multiSelectOrderBy() routine +** above that generates the code for a compound SELECT with an ORDER BY clause +** uses a merge algorithm that requires the same collating sequence on the +** result columns as on the ORDER BY clause. See ticket +** http://www.sqlite.org/src/info/6709574d2a +** +** This transformation is only needed for EXCEPT, INTERSECT, and UNION. +** The UNION ALL operator works fine with multiSelectOrderBy() even when +** there are COLLATE terms in the ORDER BY. +*/ +static int convertCompoundSelectToSubquery(Walker *pWalker, Select *p){ + int i; + Select *pNew; + Select *pX; + sqlite3 *db; + struct ExprList_item *a; + SrcList *pNewSrc; + Parse *pParse; + Token dummy; + + if( p->pPrior==0 ) return WRC_Continue; + if( p->pOrderBy==0 ) return WRC_Continue; + for(pX=p; pX && (pX->op==TK_ALL || pX->op==TK_SELECT); pX=pX->pPrior){} + if( pX==0 ) return WRC_Continue; + a = p->pOrderBy->a; +#ifndef SQLITE_OMIT_WINDOWFUNC + /* If iOrderByCol is already non-zero, then it has already been matched + ** to a result column of the SELECT statement. This occurs when the + ** SELECT is rewritten for window-functions processing and then passed + ** to sqlite3SelectPrep() and similar a second time. The rewriting done + ** by this function is not required in this case. */ + if( a[0].u.x.iOrderByCol ) return WRC_Continue; +#endif + for(i=p->pOrderBy->nExpr-1; i>=0; i--){ + if( a[i].pExpr->flags & EP_Collate ) break; + } + if( i<0 ) return WRC_Continue; + + /* If we reach this point, that means the transformation is required. */ + + pParse = pWalker->pParse; + db = pParse->db; + pNew = sqlite3DbMallocZero(db, sizeof(*pNew) ); + if( pNew==0 ) return WRC_Abort; + memset(&dummy, 0, sizeof(dummy)); + pNewSrc = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&dummy,pNew,0); + if( pNewSrc==0 ) return WRC_Abort; + *pNew = *p; + p->pSrc = pNewSrc; + p->pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ASTERISK, 0)); + p->op = TK_SELECT; + p->pWhere = 0; + pNew->pGroupBy = 0; + pNew->pHaving = 0; + pNew->pOrderBy = 0; + p->pPrior = 0; + p->pNext = 0; + p->pWith = 0; +#ifndef SQLITE_OMIT_WINDOWFUNC + p->pWinDefn = 0; +#endif + p->selFlags &= ~SF_Compound; + assert( (p->selFlags & SF_Converted)==0 ); + p->selFlags |= SF_Converted; + assert( pNew->pPrior!=0 ); + pNew->pPrior->pNext = pNew; + pNew->pLimit = 0; + return WRC_Continue; +} + +/* +** Check to see if the FROM clause term pFrom has table-valued function +** arguments. If it does, leave an error message in pParse and return +** non-zero, since pFrom is not allowed to be a table-valued function. +*/ +static int cannotBeFunction(Parse *pParse, SrcItem *pFrom){ + if( pFrom->fg.isTabFunc ){ + sqlite3ErrorMsg(pParse, "'%s' is not a function", pFrom->zName); + return 1; + } + return 0; +} + +#ifndef SQLITE_OMIT_CTE +/* +** Argument pWith (which may be NULL) points to a linked list of nested +** WITH contexts, from inner to outermost. If the table identified by +** FROM clause element pItem is really a common-table-expression (CTE) +** then return a pointer to the CTE definition for that table. Otherwise +** return NULL. +** +** If a non-NULL value is returned, set *ppContext to point to the With +** object that the returned CTE belongs to. +*/ +static struct Cte *searchWith( + With *pWith, /* Current innermost WITH clause */ + SrcItem *pItem, /* FROM clause element to resolve */ + With **ppContext /* OUT: WITH clause return value belongs to */ +){ + const char *zName = pItem->zName; + With *p; + assert( pItem->zDatabase==0 ); + assert( zName!=0 ); + for(p=pWith; p; p=p->pOuter){ + int i; + for(i=0; inCte; i++){ + if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){ + *ppContext = p; + return &p->a[i]; + } + } + if( p->bView ) break; + } + return 0; +} + +/* The code generator maintains a stack of active WITH clauses +** with the inner-most WITH clause being at the top of the stack. +** +** This routine pushes the WITH clause passed as the second argument +** onto the top of the stack. If argument bFree is true, then this +** WITH clause will never be popped from the stack but should instead +** be freed along with the Parse object. In other cases, when +** bFree==0, the With object will be freed along with the SELECT +** statement with which it is associated. +** +** This routine returns a copy of pWith. Or, if bFree is true and +** the pWith object is destroyed immediately due to an OOM condition, +** then this routine return NULL. +** +** If bFree is true, do not continue to use the pWith pointer after +** calling this routine, Instead, use only the return value. +*/ +SQLITE_PRIVATE With *sqlite3WithPush(Parse *pParse, With *pWith, u8 bFree){ + if( pWith ){ + if( bFree ){ + pWith = (With*)sqlite3ParserAddCleanup(pParse, + (void(*)(sqlite3*,void*))sqlite3WithDelete, + pWith); + if( pWith==0 ) return 0; + } + if( pParse->nErr==0 ){ + assert( pParse->pWith!=pWith ); + pWith->pOuter = pParse->pWith; + pParse->pWith = pWith; + } + } + return pWith; +} + +/* +** This function checks if argument pFrom refers to a CTE declared by +** a WITH clause on the stack currently maintained by the parser (on the +** pParse->pWith linked list). And if currently processing a CTE +** CTE expression, through routine checks to see if the reference is +** a recursive reference to the CTE. +** +** If pFrom matches a CTE according to either of these two above, pFrom->pTab +** and other fields are populated accordingly. +** +** Return 0 if no match is found. +** Return 1 if a match is found. +** Return 2 if an error condition is detected. +*/ +static int resolveFromTermToCte( + Parse *pParse, /* The parsing context */ + Walker *pWalker, /* Current tree walker */ + SrcItem *pFrom /* The FROM clause term to check */ +){ + Cte *pCte; /* Matched CTE (or NULL if no match) */ + With *pWith; /* The matching WITH */ + + assert( pFrom->pTab==0 ); + if( pParse->pWith==0 ){ + /* There are no WITH clauses in the stack. No match is possible */ + return 0; + } + if( pParse->nErr ){ + /* Prior errors might have left pParse->pWith in a goofy state, so + ** go no further. */ + return 0; + } + if( pFrom->zDatabase!=0 ){ + /* The FROM term contains a schema qualifier (ex: main.t1) and so + ** it cannot possibly be a CTE reference. */ + return 0; + } + if( pFrom->fg.notCte ){ + /* The FROM term is specifically excluded from matching a CTE. + ** (1) It is part of a trigger that used to have zDatabase but had + ** zDatabase removed by sqlite3FixTriggerStep(). + ** (2) This is the first term in the FROM clause of an UPDATE. + */ + return 0; + } + pCte = searchWith(pParse->pWith, pFrom, &pWith); + if( pCte ){ + sqlite3 *db = pParse->db; + Table *pTab; + ExprList *pEList; + Select *pSel; + Select *pLeft; /* Left-most SELECT statement */ + Select *pRecTerm; /* Left-most recursive term */ + int bMayRecursive; /* True if compound joined by UNION [ALL] */ + With *pSavedWith; /* Initial value of pParse->pWith */ + int iRecTab = -1; /* Cursor for recursive table */ + CteUse *pCteUse; + + /* If pCte->zCteErr is non-NULL at this point, then this is an illegal + ** recursive reference to CTE pCte. Leave an error in pParse and return + ** early. If pCte->zCteErr is NULL, then this is not a recursive reference. + ** In this case, proceed. */ + if( pCte->zCteErr ){ + sqlite3ErrorMsg(pParse, pCte->zCteErr, pCte->zName); + return 2; + } + if( cannotBeFunction(pParse, pFrom) ) return 2; + + assert( pFrom->pTab==0 ); + pTab = sqlite3DbMallocZero(db, sizeof(Table)); + if( pTab==0 ) return 2; + pCteUse = pCte->pUse; + if( pCteUse==0 ){ + pCte->pUse = pCteUse = sqlite3DbMallocZero(db, sizeof(pCteUse[0])); + if( pCteUse==0 + || sqlite3ParserAddCleanup(pParse,sqlite3DbFree,pCteUse)==0 + ){ + sqlite3DbFree(db, pTab); + return 2; + } + pCteUse->eM10d = pCte->eM10d; + } + pFrom->pTab = pTab; + pTab->nTabRef = 1; + pTab->zName = sqlite3DbStrDup(db, pCte->zName); + pTab->iPKey = -1; + pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) ); + pTab->tabFlags |= TF_Ephemeral | TF_NoVisibleRowid; + pFrom->pSelect = sqlite3SelectDup(db, pCte->pSelect, 0); + if( db->mallocFailed ) return 2; + pFrom->pSelect->selFlags |= SF_CopyCte; + assert( pFrom->pSelect ); + if( pFrom->fg.isIndexedBy ){ + sqlite3ErrorMsg(pParse, "no such index: \"%s\"", pFrom->u1.zIndexedBy); + return 2; + } + pFrom->fg.isCte = 1; + pFrom->u2.pCteUse = pCteUse; + pCteUse->nUse++; + + /* Check if this is a recursive CTE. */ + pRecTerm = pSel = pFrom->pSelect; + bMayRecursive = ( pSel->op==TK_ALL || pSel->op==TK_UNION ); + while( bMayRecursive && pRecTerm->op==pSel->op ){ + int i; + SrcList *pSrc = pRecTerm->pSrc; + assert( pRecTerm->pPrior!=0 ); + for(i=0; inSrc; i++){ + SrcItem *pItem = &pSrc->a[i]; + if( pItem->zDatabase==0 + && pItem->zName!=0 + && 0==sqlite3StrICmp(pItem->zName, pCte->zName) + ){ + pItem->pTab = pTab; + pTab->nTabRef++; + pItem->fg.isRecursive = 1; + if( pRecTerm->selFlags & SF_Recursive ){ + sqlite3ErrorMsg(pParse, + "multiple references to recursive table: %s", pCte->zName + ); + return 2; + } + pRecTerm->selFlags |= SF_Recursive; + if( iRecTab<0 ) iRecTab = pParse->nTab++; + pItem->iCursor = iRecTab; + } + } + if( (pRecTerm->selFlags & SF_Recursive)==0 ) break; + pRecTerm = pRecTerm->pPrior; + } + + pCte->zCteErr = "circular reference: %s"; + pSavedWith = pParse->pWith; + pParse->pWith = pWith; + if( pSel->selFlags & SF_Recursive ){ + int rc; + assert( pRecTerm!=0 ); + assert( (pRecTerm->selFlags & SF_Recursive)==0 ); + assert( pRecTerm->pNext!=0 ); + assert( (pRecTerm->pNext->selFlags & SF_Recursive)!=0 ); + assert( pRecTerm->pWith==0 ); + pRecTerm->pWith = pSel->pWith; + rc = sqlite3WalkSelect(pWalker, pRecTerm); + pRecTerm->pWith = 0; + if( rc ){ + pParse->pWith = pSavedWith; + return 2; + } + }else{ + if( sqlite3WalkSelect(pWalker, pSel) ){ + pParse->pWith = pSavedWith; + return 2; + } + } + pParse->pWith = pWith; + + for(pLeft=pSel; pLeft->pPrior; pLeft=pLeft->pPrior); + pEList = pLeft->pEList; + if( pCte->pCols ){ + if( pEList && pEList->nExpr!=pCte->pCols->nExpr ){ + sqlite3ErrorMsg(pParse, "table %s has %d values for %d columns", + pCte->zName, pEList->nExpr, pCte->pCols->nExpr + ); + pParse->pWith = pSavedWith; + return 2; + } + pEList = pCte->pCols; + } + + sqlite3ColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol); + if( bMayRecursive ){ + if( pSel->selFlags & SF_Recursive ){ + pCte->zCteErr = "multiple recursive references: %s"; + }else{ + pCte->zCteErr = "recursive reference in a subquery: %s"; + } + sqlite3WalkSelect(pWalker, pSel); + } + pCte->zCteErr = 0; + pParse->pWith = pSavedWith; + return 1; /* Success */ + } + return 0; /* No match */ +} +#endif + +#ifndef SQLITE_OMIT_CTE +/* +** If the SELECT passed as the second argument has an associated WITH +** clause, pop it from the stack stored as part of the Parse object. +** +** This function is used as the xSelectCallback2() callback by +** sqlite3SelectExpand() when walking a SELECT tree to resolve table +** names and other FROM clause elements. +*/ +SQLITE_PRIVATE void sqlite3SelectPopWith(Walker *pWalker, Select *p){ + Parse *pParse = pWalker->pParse; + if( OK_IF_ALWAYS_TRUE(pParse->pWith) && p->pPrior==0 ){ + With *pWith = findRightmost(p)->pWith; + if( pWith!=0 ){ + assert( pParse->pWith==pWith || pParse->nErr ); + pParse->pWith = pWith->pOuter; + } + } +} +#endif + +/* +** The SrcItem structure passed as the second argument represents a +** sub-query in the FROM clause of a SELECT statement. This function +** allocates and populates the SrcItem.pTab object. If successful, +** SQLITE_OK is returned. Otherwise, if an OOM error is encountered, +** SQLITE_NOMEM. +*/ +SQLITE_PRIVATE int sqlite3ExpandSubquery(Parse *pParse, SrcItem *pFrom){ + Select *pSel = pFrom->pSelect; + Table *pTab; + + assert( pSel ); + pFrom->pTab = pTab = sqlite3DbMallocZero(pParse->db, sizeof(Table)); + if( pTab==0 ) return SQLITE_NOMEM; + pTab->nTabRef = 1; + if( pFrom->zAlias ){ + pTab->zName = sqlite3DbStrDup(pParse->db, pFrom->zAlias); + }else{ + pTab->zName = sqlite3MPrintf(pParse->db, "%!S", pFrom); + } + while( pSel->pPrior ){ pSel = pSel->pPrior; } + sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol); + pTab->iPKey = -1; + pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) ); +#ifndef SQLITE_ALLOW_ROWID_IN_VIEW + /* The usual case - do not allow ROWID on a subquery */ + pTab->tabFlags |= TF_Ephemeral | TF_NoVisibleRowid; +#else + pTab->tabFlags |= TF_Ephemeral; /* Legacy compatibility mode */ +#endif + return pParse->nErr ? SQLITE_ERROR : SQLITE_OK; +} + + +/* +** Check the N SrcItem objects to the right of pBase. (N might be zero!) +** If any of those SrcItem objects have a USING clause containing zName +** then return true. +** +** If N is zero, or none of the N SrcItem objects to the right of pBase +** contains a USING clause, or if none of the USING clauses contain zName, +** then return false. +*/ +static int inAnyUsingClause( + const char *zName, /* Name we are looking for */ + SrcItem *pBase, /* The base SrcItem. Looking at pBase[1] and following */ + int N /* How many SrcItems to check */ +){ + while( N>0 ){ + N--; + pBase++; + if( pBase->fg.isUsing==0 ) continue; + if( NEVER(pBase->u3.pUsing==0) ) continue; + if( sqlite3IdListIndex(pBase->u3.pUsing, zName)>=0 ) return 1; + } + return 0; +} + + +/* +** This routine is a Walker callback for "expanding" a SELECT statement. +** "Expanding" means to do the following: +** +** (1) Make sure VDBE cursor numbers have been assigned to every +** element of the FROM clause. +** +** (2) Fill in the pTabList->a[].pTab fields in the SrcList that +** defines FROM clause. When views appear in the FROM clause, +** fill pTabList->a[].pSelect with a copy of the SELECT statement +** that implements the view. A copy is made of the view's SELECT +** statement so that we can freely modify or delete that statement +** without worrying about messing up the persistent representation +** of the view. +** +** (3) Add terms to the WHERE clause to accommodate the NATURAL keyword +** on joins and the ON and USING clause of joins. +** +** (4) Scan the list of columns in the result set (pEList) looking +** for instances of the "*" operator or the TABLE.* operator. +** If found, expand each "*" to be every column in every table +** and TABLE.* to be every column in TABLE. +** +*/ +static int selectExpander(Walker *pWalker, Select *p){ + Parse *pParse = pWalker->pParse; + int i, j, k, rc; + SrcList *pTabList; + ExprList *pEList; + SrcItem *pFrom; + sqlite3 *db = pParse->db; + Expr *pE, *pRight, *pExpr; + u16 selFlags = p->selFlags; + u32 elistFlags = 0; + + p->selFlags |= SF_Expanded; + if( db->mallocFailed ){ + return WRC_Abort; + } + assert( p->pSrc!=0 ); + if( (selFlags & SF_Expanded)!=0 ){ + return WRC_Prune; + } + if( pWalker->eCode ){ + /* Renumber selId because it has been copied from a view */ + p->selId = ++pParse->nSelect; + } + pTabList = p->pSrc; + pEList = p->pEList; + if( pParse->pWith && (p->selFlags & SF_View) ){ + if( p->pWith==0 ){ + p->pWith = (With*)sqlite3DbMallocZero(db, sizeof(With)); + if( p->pWith==0 ){ + return WRC_Abort; + } + } + p->pWith->bView = 1; + } + sqlite3WithPush(pParse, p->pWith, 0); + + /* Make sure cursor numbers have been assigned to all entries in + ** the FROM clause of the SELECT statement. + */ + sqlite3SrcListAssignCursors(pParse, pTabList); + + /* Look up every table named in the FROM clause of the select. If + ** an entry of the FROM clause is a subquery instead of a table or view, + ** then create a transient table structure to describe the subquery. + */ + for(i=0, pFrom=pTabList->a; inSrc; i++, pFrom++){ + Table *pTab; + assert( pFrom->fg.isRecursive==0 || pFrom->pTab!=0 ); + if( pFrom->pTab ) continue; + assert( pFrom->fg.isRecursive==0 ); + if( pFrom->zName==0 ){ +#ifndef SQLITE_OMIT_SUBQUERY + Select *pSel = pFrom->pSelect; + /* A sub-query in the FROM clause of a SELECT */ + assert( pSel!=0 ); + assert( pFrom->pTab==0 ); + if( sqlite3WalkSelect(pWalker, pSel) ) return WRC_Abort; + if( sqlite3ExpandSubquery(pParse, pFrom) ) return WRC_Abort; +#endif +#ifndef SQLITE_OMIT_CTE + }else if( (rc = resolveFromTermToCte(pParse, pWalker, pFrom))!=0 ){ + if( rc>1 ) return WRC_Abort; + pTab = pFrom->pTab; + assert( pTab!=0 ); +#endif + }else{ + /* An ordinary table or view name in the FROM clause */ + assert( pFrom->pTab==0 ); + pFrom->pTab = pTab = sqlite3LocateTableItem(pParse, 0, pFrom); + if( pTab==0 ) return WRC_Abort; + if( pTab->nTabRef>=0xffff ){ + sqlite3ErrorMsg(pParse, "too many references to \"%s\": max 65535", + pTab->zName); + pFrom->pTab = 0; + return WRC_Abort; + } + pTab->nTabRef++; + if( !IsVirtual(pTab) && cannotBeFunction(pParse, pFrom) ){ + return WRC_Abort; + } +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) + if( !IsOrdinaryTable(pTab) ){ + i16 nCol; + u8 eCodeOrig = pWalker->eCode; + if( sqlite3ViewGetColumnNames(pParse, pTab) ) return WRC_Abort; + assert( pFrom->pSelect==0 ); + if( IsView(pTab) ){ + if( (db->flags & SQLITE_EnableView)==0 + && pTab->pSchema!=db->aDb[1].pSchema + ){ + sqlite3ErrorMsg(pParse, "access to view \"%s\" prohibited", + pTab->zName); + } + pFrom->pSelect = sqlite3SelectDup(db, pTab->u.view.pSelect, 0); + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + else if( ALWAYS(IsVirtual(pTab)) + && pFrom->fg.fromDDL + && ALWAYS(pTab->u.vtab.p!=0) + && pTab->u.vtab.p->eVtabRisk > ((db->flags & SQLITE_TrustedSchema)!=0) + ){ + sqlite3ErrorMsg(pParse, "unsafe use of virtual table \"%s\"", + pTab->zName); + } + assert( SQLITE_VTABRISK_Normal==1 && SQLITE_VTABRISK_High==2 ); +#endif + nCol = pTab->nCol; + pTab->nCol = -1; + pWalker->eCode = 1; /* Turn on Select.selId renumbering */ + sqlite3WalkSelect(pWalker, pFrom->pSelect); + pWalker->eCode = eCodeOrig; + pTab->nCol = nCol; + } +#endif + } + + /* Locate the index named by the INDEXED BY clause, if any. */ + if( pFrom->fg.isIndexedBy && sqlite3IndexedByLookup(pParse, pFrom) ){ + return WRC_Abort; + } + } + + /* Process NATURAL keywords, and ON and USING clauses of joins. + */ + assert( db->mallocFailed==0 || pParse->nErr!=0 ); + if( pParse->nErr || sqlite3ProcessJoin(pParse, p) ){ + return WRC_Abort; + } + + /* For every "*" that occurs in the column list, insert the names of + ** all columns in all tables. And for every TABLE.* insert the names + ** of all columns in TABLE. The parser inserted a special expression + ** with the TK_ASTERISK operator for each "*" that it found in the column + ** list. The following code just has to locate the TK_ASTERISK + ** expressions and expand each one to the list of all columns in + ** all tables. + ** + ** The first loop just checks to see if there are any "*" operators + ** that need expanding. + */ + for(k=0; knExpr; k++){ + pE = pEList->a[k].pExpr; + if( pE->op==TK_ASTERISK ) break; + assert( pE->op!=TK_DOT || pE->pRight!=0 ); + assert( pE->op!=TK_DOT || (pE->pLeft!=0 && pE->pLeft->op==TK_ID) ); + if( pE->op==TK_DOT && pE->pRight->op==TK_ASTERISK ) break; + elistFlags |= pE->flags; + } + if( knExpr ){ + /* + ** If we get here it means the result set contains one or more "*" + ** operators that need to be expanded. Loop through each expression + ** in the result set and expand them one by one. + */ + struct ExprList_item *a = pEList->a; + ExprList *pNew = 0; + int flags = pParse->db->flags; + int longNames = (flags & SQLITE_FullColNames)!=0 + && (flags & SQLITE_ShortColNames)==0; + + for(k=0; knExpr; k++){ + pE = a[k].pExpr; + elistFlags |= pE->flags; + pRight = pE->pRight; + assert( pE->op!=TK_DOT || pRight!=0 ); + if( pE->op!=TK_ASTERISK + && (pE->op!=TK_DOT || pRight->op!=TK_ASTERISK) + ){ + /* This particular expression does not need to be expanded. + */ + pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr); + if( pNew ){ + pNew->a[pNew->nExpr-1].zEName = a[k].zEName; + pNew->a[pNew->nExpr-1].fg.eEName = a[k].fg.eEName; + a[k].zEName = 0; + } + a[k].pExpr = 0; + }else{ + /* This expression is a "*" or a "TABLE.*" and needs to be + ** expanded. */ + int tableSeen = 0; /* Set to 1 when TABLE matches */ + char *zTName = 0; /* text of name of TABLE */ + if( pE->op==TK_DOT ){ + assert( pE->pLeft!=0 ); + assert( !ExprHasProperty(pE->pLeft, EP_IntValue) ); + zTName = pE->pLeft->u.zToken; + } + for(i=0, pFrom=pTabList->a; inSrc; i++, pFrom++){ + Table *pTab = pFrom->pTab; /* Table for this data source */ + ExprList *pNestedFrom; /* Result-set of a nested FROM clause */ + char *zTabName; /* AS name for this data source */ + const char *zSchemaName = 0; /* Schema name for this data source */ + int iDb; /* Schema index for this data src */ + IdList *pUsing; /* USING clause for pFrom[1] */ + + if( (zTabName = pFrom->zAlias)==0 ){ + zTabName = pTab->zName; + } + if( db->mallocFailed ) break; + assert( (int)pFrom->fg.isNestedFrom == IsNestedFrom(pFrom->pSelect) ); + if( pFrom->fg.isNestedFrom ){ + assert( pFrom->pSelect!=0 ); + pNestedFrom = pFrom->pSelect->pEList; + assert( pNestedFrom!=0 ); + assert( pNestedFrom->nExpr==pTab->nCol ); + }else{ + if( zTName && sqlite3StrICmp(zTName, zTabName)!=0 ){ + continue; + } + pNestedFrom = 0; + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + zSchemaName = iDb>=0 ? db->aDb[iDb].zDbSName : "*"; + } + if( i+1nSrc + && pFrom[1].fg.isUsing + && (selFlags & SF_NestedFrom)!=0 + ){ + int ii; + pUsing = pFrom[1].u3.pUsing; + for(ii=0; iinId; ii++){ + const char *zUName = pUsing->a[ii].zName; + pRight = sqlite3Expr(db, TK_ID, zUName); + pNew = sqlite3ExprListAppend(pParse, pNew, pRight); + if( pNew ){ + struct ExprList_item *pX = &pNew->a[pNew->nExpr-1]; + assert( pX->zEName==0 ); + pX->zEName = sqlite3MPrintf(db,"..%s", zUName); + pX->fg.eEName = ENAME_TAB; + pX->fg.bUsingTerm = 1; + } + } + }else{ + pUsing = 0; + } + for(j=0; jnCol; j++){ + char *zName = pTab->aCol[j].zCnName; + struct ExprList_item *pX; /* Newly added ExprList term */ + + assert( zName ); + if( zTName + && pNestedFrom + && sqlite3MatchEName(&pNestedFrom->a[j], 0, zTName, 0)==0 + ){ + continue; + } + + /* If a column is marked as 'hidden', omit it from the expanded + ** result-set list unless the SELECT has the SF_IncludeHidden + ** bit set. + */ + if( (p->selFlags & SF_IncludeHidden)==0 + && IsHiddenColumn(&pTab->aCol[j]) + ){ + continue; + } + if( (pTab->aCol[j].colFlags & COLFLAG_NOEXPAND)!=0 + && zTName==0 + && (selFlags & (SF_NestedFrom))==0 + ){ + continue; + } + tableSeen = 1; + + if( i>0 && zTName==0 && (selFlags & SF_NestedFrom)==0 ){ + if( pFrom->fg.isUsing + && sqlite3IdListIndex(pFrom->u3.pUsing, zName)>=0 + ){ + /* In a join with a USING clause, omit columns in the + ** using clause from the table on the right. */ + continue; + } + } + pRight = sqlite3Expr(db, TK_ID, zName); + if( (pTabList->nSrc>1 + && ( (pFrom->fg.jointype & JT_LTORJ)==0 + || (selFlags & SF_NestedFrom)!=0 + || !inAnyUsingClause(zName,pFrom,pTabList->nSrc-i-1) + ) + ) + || IN_RENAME_OBJECT + ){ + Expr *pLeft; + pLeft = sqlite3Expr(db, TK_ID, zTabName); + pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight); + if( IN_RENAME_OBJECT && pE->pLeft ){ + sqlite3RenameTokenRemap(pParse, pLeft, pE->pLeft); + } + if( zSchemaName ){ + pLeft = sqlite3Expr(db, TK_ID, zSchemaName); + pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pExpr); + } + }else{ + pExpr = pRight; + } + pNew = sqlite3ExprListAppend(pParse, pNew, pExpr); + if( pNew==0 ){ + break; /* OOM */ + } + pX = &pNew->a[pNew->nExpr-1]; + assert( pX->zEName==0 ); + if( (selFlags & SF_NestedFrom)!=0 && !IN_RENAME_OBJECT ){ + if( pNestedFrom ){ + pX->zEName = sqlite3DbStrDup(db, pNestedFrom->a[j].zEName); + testcase( pX->zEName==0 ); + }else{ + pX->zEName = sqlite3MPrintf(db, "%s.%s.%s", + zSchemaName, zTabName, zName); + testcase( pX->zEName==0 ); + } + pX->fg.eEName = ENAME_TAB; + if( (pFrom->fg.isUsing + && sqlite3IdListIndex(pFrom->u3.pUsing, zName)>=0) + || (pUsing && sqlite3IdListIndex(pUsing, zName)>=0) + || (pTab->aCol[j].colFlags & COLFLAG_NOEXPAND)!=0 + ){ + pX->fg.bNoExpand = 1; + } + }else if( longNames ){ + pX->zEName = sqlite3MPrintf(db, "%s.%s", zTabName, zName); + pX->fg.eEName = ENAME_NAME; + }else{ + pX->zEName = sqlite3DbStrDup(db, zName); + pX->fg.eEName = ENAME_NAME; + } + } + } + if( !tableSeen ){ + if( zTName ){ + sqlite3ErrorMsg(pParse, "no such table: %s", zTName); + }else{ + sqlite3ErrorMsg(pParse, "no tables specified"); + } + } + } + } + sqlite3ExprListDelete(db, pEList); + p->pEList = pNew; + } + if( p->pEList ){ + if( p->pEList->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){ + sqlite3ErrorMsg(pParse, "too many columns in result set"); + return WRC_Abort; + } + if( (elistFlags & (EP_HasFunc|EP_Subquery))!=0 ){ + p->selFlags |= SF_ComplexResult; + } + } +#if TREETRACE_ENABLED + if( sqlite3TreeTrace & 0x8 ){ + TREETRACE(0x8,pParse,p,("After result-set wildcard expansion:\n")); + sqlite3TreeViewSelect(0, p, 0); + } +#endif + return WRC_Continue; +} + +#if SQLITE_DEBUG +/* +** Always assert. This xSelectCallback2 implementation proves that the +** xSelectCallback2 is never invoked. +*/ +SQLITE_PRIVATE void sqlite3SelectWalkAssert2(Walker *NotUsed, Select *NotUsed2){ + UNUSED_PARAMETER2(NotUsed, NotUsed2); + assert( 0 ); +} +#endif +/* +** This routine "expands" a SELECT statement and all of its subqueries. +** For additional information on what it means to "expand" a SELECT +** statement, see the comment on the selectExpand worker callback above. +** +** Expanding a SELECT statement is the first step in processing a +** SELECT statement. The SELECT statement must be expanded before +** name resolution is performed. +** +** If anything goes wrong, an error message is written into pParse. +** The calling function can detect the problem by looking at pParse->nErr +** and/or pParse->db->mallocFailed. +*/ +static void sqlite3SelectExpand(Parse *pParse, Select *pSelect){ + Walker w; + w.xExprCallback = sqlite3ExprWalkNoop; + w.pParse = pParse; + if( OK_IF_ALWAYS_TRUE(pParse->hasCompound) ){ + w.xSelectCallback = convertCompoundSelectToSubquery; + w.xSelectCallback2 = 0; + sqlite3WalkSelect(&w, pSelect); + } + w.xSelectCallback = selectExpander; + w.xSelectCallback2 = sqlite3SelectPopWith; + w.eCode = 0; + sqlite3WalkSelect(&w, pSelect); +} + + +#ifndef SQLITE_OMIT_SUBQUERY +/* +** This is a Walker.xSelectCallback callback for the sqlite3SelectTypeInfo() +** interface. +** +** For each FROM-clause subquery, add Column.zType, Column.zColl, and +** Column.affinity information to the Table structure that represents +** the result set of that subquery. +** +** The Table structure that represents the result set was constructed +** by selectExpander() but the type and collation and affinity information +** was omitted at that point because identifiers had not yet been resolved. +** This routine is called after identifier resolution. +*/ +static void selectAddSubqueryTypeInfo(Walker *pWalker, Select *p){ + Parse *pParse; + int i; + SrcList *pTabList; + SrcItem *pFrom; + + assert( p->selFlags & SF_Resolved ); + if( p->selFlags & SF_HasTypeInfo ) return; + p->selFlags |= SF_HasTypeInfo; + pParse = pWalker->pParse; + pTabList = p->pSrc; + for(i=0, pFrom=pTabList->a; inSrc; i++, pFrom++){ + Table *pTab = pFrom->pTab; + assert( pTab!=0 ); + if( (pTab->tabFlags & TF_Ephemeral)!=0 ){ + /* A sub-query in the FROM clause of a SELECT */ + Select *pSel = pFrom->pSelect; + if( pSel ){ + sqlite3SubqueryColumnTypes(pParse, pTab, pSel, SQLITE_AFF_NONE); + } + } + } +} +#endif + + +/* +** This routine adds datatype and collating sequence information to +** the Table structures of all FROM-clause subqueries in a +** SELECT statement. +** +** Use this routine after name resolution. +*/ +static void sqlite3SelectAddTypeInfo(Parse *pParse, Select *pSelect){ +#ifndef SQLITE_OMIT_SUBQUERY + Walker w; + w.xSelectCallback = sqlite3SelectWalkNoop; + w.xSelectCallback2 = selectAddSubqueryTypeInfo; + w.xExprCallback = sqlite3ExprWalkNoop; + w.pParse = pParse; + sqlite3WalkSelect(&w, pSelect); +#endif +} + + +/* +** This routine sets up a SELECT statement for processing. The +** following is accomplished: +** +** * VDBE Cursor numbers are assigned to all FROM-clause terms. +** * Ephemeral Table objects are created for all FROM-clause subqueries. +** * ON and USING clauses are shifted into WHERE statements +** * Wildcards "*" and "TABLE.*" in result sets are expanded. +** * Identifiers in expression are matched to tables. +** +** This routine acts recursively on all subqueries within the SELECT. +*/ +SQLITE_PRIVATE void sqlite3SelectPrep( + Parse *pParse, /* The parser context */ + Select *p, /* The SELECT statement being coded. */ + NameContext *pOuterNC /* Name context for container */ +){ + assert( p!=0 || pParse->db->mallocFailed ); + assert( pParse->db->pParse==pParse ); + if( pParse->db->mallocFailed ) return; + if( p->selFlags & SF_HasTypeInfo ) return; + sqlite3SelectExpand(pParse, p); + if( pParse->nErr ) return; + sqlite3ResolveSelectNames(pParse, p, pOuterNC); + if( pParse->nErr ) return; + sqlite3SelectAddTypeInfo(pParse, p); +} + +#if TREETRACE_ENABLED +/* +** Display all information about an AggInfo object +*/ +static void printAggInfo(AggInfo *pAggInfo){ + int ii; + for(ii=0; iinColumn; ii++){ + struct AggInfo_col *pCol = &pAggInfo->aCol[ii]; + sqlite3DebugPrintf( + "agg-column[%d] pTab=%s iTable=%d iColumn=%d iMem=%d" + " iSorterColumn=%d %s\n", + ii, pCol->pTab ? pCol->pTab->zName : "NULL", + pCol->iTable, pCol->iColumn, pAggInfo->iFirstReg+ii, + pCol->iSorterColumn, + ii>=pAggInfo->nAccumulator ? "" : " Accumulator"); + sqlite3TreeViewExpr(0, pAggInfo->aCol[ii].pCExpr, 0); + } + for(ii=0; iinFunc; ii++){ + sqlite3DebugPrintf("agg-func[%d]: iMem=%d\n", + ii, pAggInfo->iFirstReg+pAggInfo->nColumn+ii); + sqlite3TreeViewExpr(0, pAggInfo->aFunc[ii].pFExpr, 0); + } +} +#endif /* TREETRACE_ENABLED */ + +/* +** Analyze the arguments to aggregate functions. Create new pAggInfo->aCol[] +** entries for columns that are arguments to aggregate functions but which +** are not otherwise used. +** +** The aCol[] entries in AggInfo prior to nAccumulator are columns that +** are referenced outside of aggregate functions. These might be columns +** that are part of the GROUP by clause, for example. Other database engines +** would throw an error if there is a column reference that is not in the +** GROUP BY clause and that is not part of an aggregate function argument. +** But SQLite allows this. +** +** The aCol[] entries beginning with the aCol[nAccumulator] and following +** are column references that are used exclusively as arguments to +** aggregate functions. This routine is responsible for computing +** (or recomputing) those aCol[] entries. +*/ +static void analyzeAggFuncArgs( + AggInfo *pAggInfo, + NameContext *pNC +){ + int i; + assert( pAggInfo!=0 ); + assert( pAggInfo->iFirstReg==0 ); + pNC->ncFlags |= NC_InAggFunc; + for(i=0; inFunc; i++){ + Expr *pExpr = pAggInfo->aFunc[i].pFExpr; + assert( ExprUseXList(pExpr) ); + sqlite3ExprAnalyzeAggList(pNC, pExpr->x.pList); +#ifndef SQLITE_OMIT_WINDOWFUNC + assert( !IsWindowFunc(pExpr) ); + if( ExprHasProperty(pExpr, EP_WinFunc) ){ + sqlite3ExprAnalyzeAggregates(pNC, pExpr->y.pWin->pFilter); + } +#endif + } + pNC->ncFlags &= ~NC_InAggFunc; +} + +/* +** An index on expressions is being used in the inner loop of an +** aggregate query with a GROUP BY clause. This routine attempts +** to adjust the AggInfo object to take advantage of index and to +** perhaps use the index as a covering index. +** +*/ +static void optimizeAggregateUseOfIndexedExpr( + Parse *pParse, /* Parsing context */ + Select *pSelect, /* The SELECT statement being processed */ + AggInfo *pAggInfo, /* The aggregate info */ + NameContext *pNC /* Name context used to resolve agg-func args */ +){ + assert( pAggInfo->iFirstReg==0 ); + assert( pSelect!=0 ); + assert( pSelect->pGroupBy!=0 ); + pAggInfo->nColumn = pAggInfo->nAccumulator; + if( ALWAYS(pAggInfo->nSortingColumn>0) ){ + int mx = pSelect->pGroupBy->nExpr - 1; + int j, k; + for(j=0; jnColumn; j++){ + k = pAggInfo->aCol[j].iSorterColumn; + if( k>mx ) mx = k; + } + pAggInfo->nSortingColumn = mx+1; + } + analyzeAggFuncArgs(pAggInfo, pNC); +#if TREETRACE_ENABLED + if( sqlite3TreeTrace & 0x20 ){ + IndexedExpr *pIEpr; + TREETRACE(0x20, pParse, pSelect, + ("AggInfo (possibly) adjusted for Indexed Exprs\n")); + sqlite3TreeViewSelect(0, pSelect, 0); + for(pIEpr=pParse->pIdxEpr; pIEpr; pIEpr=pIEpr->pIENext){ + printf("data-cursor=%d index={%d,%d}\n", + pIEpr->iDataCur, pIEpr->iIdxCur, pIEpr->iIdxCol); + sqlite3TreeViewExpr(0, pIEpr->pExpr, 0); + } + printAggInfo(pAggInfo); + } +#else + UNUSED_PARAMETER(pSelect); + UNUSED_PARAMETER(pParse); +#endif +} + +/* +** Walker callback for aggregateConvertIndexedExprRefToColumn(). +*/ +static int aggregateIdxEprRefToColCallback(Walker *pWalker, Expr *pExpr){ + AggInfo *pAggInfo; + struct AggInfo_col *pCol; + UNUSED_PARAMETER(pWalker); + if( pExpr->pAggInfo==0 ) return WRC_Continue; + if( pExpr->op==TK_AGG_COLUMN ) return WRC_Continue; + if( pExpr->op==TK_AGG_FUNCTION ) return WRC_Continue; + if( pExpr->op==TK_IF_NULL_ROW ) return WRC_Continue; + pAggInfo = pExpr->pAggInfo; + if( NEVER(pExpr->iAgg>=pAggInfo->nColumn) ) return WRC_Continue; + assert( pExpr->iAgg>=0 ); + pCol = &pAggInfo->aCol[pExpr->iAgg]; + pExpr->op = TK_AGG_COLUMN; + pExpr->iTable = pCol->iTable; + pExpr->iColumn = pCol->iColumn; + ExprClearProperty(pExpr, EP_Skip|EP_Collate); + return WRC_Prune; +} + +/* +** Convert every pAggInfo->aFunc[].pExpr such that any node within +** those expressions that has pAppInfo set is changed into a TK_AGG_COLUMN +** opcode. +*/ +static void aggregateConvertIndexedExprRefToColumn(AggInfo *pAggInfo){ + int i; + Walker w; + memset(&w, 0, sizeof(w)); + w.xExprCallback = aggregateIdxEprRefToColCallback; + for(i=0; inFunc; i++){ + sqlite3WalkExpr(&w, pAggInfo->aFunc[i].pFExpr); + } +} + + +/* +** Allocate a block of registers so that there is one register for each +** pAggInfo->aCol[] and pAggInfo->aFunc[] entry in pAggInfo. The first +** register in this block is stored in pAggInfo->iFirstReg. +** +** This routine may only be called once for each AggInfo object. Prior +** to calling this routine: +** +** * The aCol[] and aFunc[] arrays may be modified +** * The AggInfoColumnReg() and AggInfoFuncReg() macros may not be used +** +** After clling this routine: +** +** * The aCol[] and aFunc[] arrays are fixed +** * The AggInfoColumnReg() and AggInfoFuncReg() macros may be used +** +*/ +static void assignAggregateRegisters(Parse *pParse, AggInfo *pAggInfo){ + assert( pAggInfo!=0 ); + assert( pAggInfo->iFirstReg==0 ); + pAggInfo->iFirstReg = pParse->nMem + 1; + pParse->nMem += pAggInfo->nColumn + pAggInfo->nFunc; +} + +/* +** Reset the aggregate accumulator. +** +** The aggregate accumulator is a set of memory cells that hold +** intermediate results while calculating an aggregate. This +** routine generates code that stores NULLs in all of those memory +** cells. +*/ +static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){ + Vdbe *v = pParse->pVdbe; + int i; + struct AggInfo_func *pFunc; + int nReg = pAggInfo->nFunc + pAggInfo->nColumn; + assert( pAggInfo->iFirstReg>0 ); + assert( pParse->db->pParse==pParse ); + assert( pParse->db->mallocFailed==0 || pParse->nErr!=0 ); + if( nReg==0 ) return; + if( pParse->nErr ) return; + sqlite3VdbeAddOp3(v, OP_Null, 0, pAggInfo->iFirstReg, + pAggInfo->iFirstReg+nReg-1); + for(pFunc=pAggInfo->aFunc, i=0; inFunc; i++, pFunc++){ + if( pFunc->iDistinct>=0 ){ + Expr *pE = pFunc->pFExpr; + assert( ExprUseXList(pE) ); + if( pE->x.pList==0 || pE->x.pList->nExpr!=1 ){ + sqlite3ErrorMsg(pParse, "DISTINCT aggregates must have exactly one " + "argument"); + pFunc->iDistinct = -1; + }else{ + KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pE->x.pList,0,0); + pFunc->iDistAddr = sqlite3VdbeAddOp4(v, OP_OpenEphemeral, + pFunc->iDistinct, 0, 0, (char*)pKeyInfo, P4_KEYINFO); + ExplainQueryPlan((pParse, 0, "USE TEMP B-TREE FOR %s(DISTINCT)", + pFunc->pFunc->zName)); + } + } + } +} + +/* +** Invoke the OP_AggFinalize opcode for every aggregate function +** in the AggInfo structure. +*/ +static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){ + Vdbe *v = pParse->pVdbe; + int i; + struct AggInfo_func *pF; + for(i=0, pF=pAggInfo->aFunc; inFunc; i++, pF++){ + ExprList *pList; + assert( ExprUseXList(pF->pFExpr) ); + pList = pF->pFExpr->x.pList; + sqlite3VdbeAddOp2(v, OP_AggFinal, AggInfoFuncReg(pAggInfo,i), + pList ? pList->nExpr : 0); + sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF); + } +} + + +/* +** Generate code that will update the accumulator memory cells for an +** aggregate based on the current cursor position. +** +** If regAcc is non-zero and there are no min() or max() aggregates +** in pAggInfo, then only populate the pAggInfo->nAccumulator accumulator +** registers if register regAcc contains 0. The caller will take care +** of setting and clearing regAcc. +*/ +static void updateAccumulator( + Parse *pParse, + int regAcc, + AggInfo *pAggInfo, + int eDistinctType +){ + Vdbe *v = pParse->pVdbe; + int i; + int regHit = 0; + int addrHitTest = 0; + struct AggInfo_func *pF; + struct AggInfo_col *pC; + + assert( pAggInfo->iFirstReg>0 ); + if( pParse->nErr ) return; + pAggInfo->directMode = 1; + for(i=0, pF=pAggInfo->aFunc; inFunc; i++, pF++){ + int nArg; + int addrNext = 0; + int regAgg; + ExprList *pList; + assert( ExprUseXList(pF->pFExpr) ); + assert( !IsWindowFunc(pF->pFExpr) ); + pList = pF->pFExpr->x.pList; + if( ExprHasProperty(pF->pFExpr, EP_WinFunc) ){ + Expr *pFilter = pF->pFExpr->y.pWin->pFilter; + if( pAggInfo->nAccumulator + && (pF->pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL) + && regAcc + ){ + /* If regAcc==0, there there exists some min() or max() function + ** without a FILTER clause that will ensure the magnet registers + ** are populated. */ + if( regHit==0 ) regHit = ++pParse->nMem; + /* If this is the first row of the group (regAcc contains 0), clear the + ** "magnet" register regHit so that the accumulator registers + ** are populated if the FILTER clause jumps over the the + ** invocation of min() or max() altogether. Or, if this is not + ** the first row (regAcc contains 1), set the magnet register so that + ** the accumulators are not populated unless the min()/max() is invoked + ** and indicates that they should be. */ + sqlite3VdbeAddOp2(v, OP_Copy, regAcc, regHit); + } + addrNext = sqlite3VdbeMakeLabel(pParse); + sqlite3ExprIfFalse(pParse, pFilter, addrNext, SQLITE_JUMPIFNULL); + } + if( pList ){ + nArg = pList->nExpr; + regAgg = sqlite3GetTempRange(pParse, nArg); + sqlite3ExprCodeExprList(pParse, pList, regAgg, 0, SQLITE_ECEL_DUP); + }else{ + nArg = 0; + regAgg = 0; + } + if( pF->iDistinct>=0 && pList ){ + if( addrNext==0 ){ + addrNext = sqlite3VdbeMakeLabel(pParse); + } + pF->iDistinct = codeDistinct(pParse, eDistinctType, + pF->iDistinct, addrNext, pList, regAgg); + } + if( pF->pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL ){ + CollSeq *pColl = 0; + struct ExprList_item *pItem; + int j; + assert( pList!=0 ); /* pList!=0 if pF->pFunc has NEEDCOLL */ + for(j=0, pItem=pList->a; !pColl && jpExpr); + } + if( !pColl ){ + pColl = pParse->db->pDfltColl; + } + if( regHit==0 && pAggInfo->nAccumulator ) regHit = ++pParse->nMem; + sqlite3VdbeAddOp4(v, OP_CollSeq, regHit, 0, 0, (char *)pColl, P4_COLLSEQ); + } + sqlite3VdbeAddOp3(v, OP_AggStep, 0, regAgg, AggInfoFuncReg(pAggInfo,i)); + sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF); + sqlite3VdbeChangeP5(v, (u8)nArg); + sqlite3ReleaseTempRange(pParse, regAgg, nArg); + if( addrNext ){ + sqlite3VdbeResolveLabel(v, addrNext); + } + } + if( regHit==0 && pAggInfo->nAccumulator ){ + regHit = regAcc; + } + if( regHit ){ + addrHitTest = sqlite3VdbeAddOp1(v, OP_If, regHit); VdbeCoverage(v); + } + for(i=0, pC=pAggInfo->aCol; inAccumulator; i++, pC++){ + sqlite3ExprCode(pParse, pC->pCExpr, AggInfoColumnReg(pAggInfo,i)); + } + + pAggInfo->directMode = 0; + if( addrHitTest ){ + sqlite3VdbeJumpHereOrPopInst(v, addrHitTest); + } +} + +/* +** Add a single OP_Explain instruction to the VDBE to explain a simple +** count(*) query ("SELECT count(*) FROM pTab"). +*/ +#ifndef SQLITE_OMIT_EXPLAIN +static void explainSimpleCount( + Parse *pParse, /* Parse context */ + Table *pTab, /* Table being queried */ + Index *pIdx /* Index used to optimize scan, or NULL */ +){ + if( pParse->explain==2 ){ + int bCover = (pIdx!=0 && (HasRowid(pTab) || !IsPrimaryKeyIndex(pIdx))); + sqlite3VdbeExplain(pParse, 0, "SCAN %s%s%s", + pTab->zName, + bCover ? " USING COVERING INDEX " : "", + bCover ? pIdx->zName : "" + ); + } +} +#else +# define explainSimpleCount(a,b,c) +#endif + +/* +** sqlite3WalkExpr() callback used by havingToWhere(). +** +** If the node passed to the callback is a TK_AND node, return +** WRC_Continue to tell sqlite3WalkExpr() to iterate through child nodes. +** +** Otherwise, return WRC_Prune. In this case, also check if the +** sub-expression matches the criteria for being moved to the WHERE +** clause. If so, add it to the WHERE clause and replace the sub-expression +** within the HAVING expression with a constant "1". +*/ +static int havingToWhereExprCb(Walker *pWalker, Expr *pExpr){ + if( pExpr->op!=TK_AND ){ + Select *pS = pWalker->u.pSelect; + /* This routine is called before the HAVING clause of the current + ** SELECT is analyzed for aggregates. So if pExpr->pAggInfo is set + ** here, it indicates that the expression is a correlated reference to a + ** column from an outer aggregate query, or an aggregate function that + ** belongs to an outer query. Do not move the expression to the WHERE + ** clause in this obscure case, as doing so may corrupt the outer Select + ** statements AggInfo structure. */ + if( sqlite3ExprIsConstantOrGroupBy(pWalker->pParse, pExpr, pS->pGroupBy) + && ExprAlwaysFalse(pExpr)==0 + && pExpr->pAggInfo==0 + ){ + sqlite3 *db = pWalker->pParse->db; + Expr *pNew = sqlite3Expr(db, TK_INTEGER, "1"); + if( pNew ){ + Expr *pWhere = pS->pWhere; + SWAP(Expr, *pNew, *pExpr); + pNew = sqlite3ExprAnd(pWalker->pParse, pWhere, pNew); + pS->pWhere = pNew; + pWalker->eCode = 1; + } + } + return WRC_Prune; + } + return WRC_Continue; +} + +/* +** Transfer eligible terms from the HAVING clause of a query, which is +** processed after grouping, to the WHERE clause, which is processed before +** grouping. For example, the query: +** +** SELECT * FROM WHERE a=? GROUP BY b HAVING b=? AND c=? +** +** can be rewritten as: +** +** SELECT * FROM WHERE a=? AND b=? GROUP BY b HAVING c=? +** +** A term of the HAVING expression is eligible for transfer if it consists +** entirely of constants and expressions that are also GROUP BY terms that +** use the "BINARY" collation sequence. +*/ +static void havingToWhere(Parse *pParse, Select *p){ + Walker sWalker; + memset(&sWalker, 0, sizeof(sWalker)); + sWalker.pParse = pParse; + sWalker.xExprCallback = havingToWhereExprCb; + sWalker.u.pSelect = p; + sqlite3WalkExpr(&sWalker, p->pHaving); +#if TREETRACE_ENABLED + if( sWalker.eCode && (sqlite3TreeTrace & 0x100)!=0 ){ + TREETRACE(0x100,pParse,p,("Move HAVING terms into WHERE:\n")); + sqlite3TreeViewSelect(0, p, 0); + } +#endif +} + +/* +** Check to see if the pThis entry of pTabList is a self-join of another view. +** Search FROM-clause entries in the range of iFirst..iEnd, including iFirst +** but stopping before iEnd. +** +** If pThis is a self-join, then return the SrcItem for the first other +** instance of that view found. If pThis is not a self-join then return 0. +*/ +static SrcItem *isSelfJoinView( + SrcList *pTabList, /* Search for self-joins in this FROM clause */ + SrcItem *pThis, /* Search for prior reference to this subquery */ + int iFirst, int iEnd /* Range of FROM-clause entries to search. */ +){ + SrcItem *pItem; + assert( pThis->pSelect!=0 ); + if( pThis->pSelect->selFlags & SF_PushDown ) return 0; + while( iFirsta[iFirst++]; + if( pItem->pSelect==0 ) continue; + if( pItem->fg.viaCoroutine ) continue; + if( pItem->zName==0 ) continue; + assert( pItem->pTab!=0 ); + assert( pThis->pTab!=0 ); + if( pItem->pTab->pSchema!=pThis->pTab->pSchema ) continue; + if( sqlite3_stricmp(pItem->zName, pThis->zName)!=0 ) continue; + pS1 = pItem->pSelect; + if( pItem->pTab->pSchema==0 && pThis->pSelect->selId!=pS1->selId ){ + /* The query flattener left two different CTE tables with identical + ** names in the same FROM clause. */ + continue; + } + if( pItem->pSelect->selFlags & SF_PushDown ){ + /* The view was modified by some other optimization such as + ** pushDownWhereTerms() */ + continue; + } + return pItem; + } + return 0; +} + +/* +** Deallocate a single AggInfo object +*/ +static void agginfoFree(sqlite3 *db, AggInfo *p){ + sqlite3DbFree(db, p->aCol); + sqlite3DbFree(db, p->aFunc); + sqlite3DbFreeNN(db, p); +} + +/* +** Attempt to transform a query of the form +** +** SELECT count(*) FROM (SELECT x FROM t1 UNION ALL SELECT y FROM t2) +** +** Into this: +** +** SELECT (SELECT count(*) FROM t1)+(SELECT count(*) FROM t2) +** +** The transformation only works if all of the following are true: +** +** * The subquery is a UNION ALL of two or more terms +** * The subquery does not have a LIMIT clause +** * There is no WHERE or GROUP BY or HAVING clauses on the subqueries +** * The outer query is a simple count(*) with no WHERE clause or other +** extraneous syntax. +** +** Return TRUE if the optimization is undertaken. +*/ +static int countOfViewOptimization(Parse *pParse, Select *p){ + Select *pSub, *pPrior; + Expr *pExpr; + Expr *pCount; + sqlite3 *db; + if( (p->selFlags & SF_Aggregate)==0 ) return 0; /* This is an aggregate */ + if( p->pEList->nExpr!=1 ) return 0; /* Single result column */ + if( p->pWhere ) return 0; + if( p->pHaving ) return 0; + if( p->pGroupBy ) return 0; + if( p->pOrderBy ) return 0; + pExpr = p->pEList->a[0].pExpr; + if( pExpr->op!=TK_AGG_FUNCTION ) return 0; /* Result is an aggregate */ + assert( ExprUseUToken(pExpr) ); + if( sqlite3_stricmp(pExpr->u.zToken,"count") ) return 0; /* Is count() */ + assert( ExprUseXList(pExpr) ); + if( pExpr->x.pList!=0 ) return 0; /* Must be count(*) */ + if( p->pSrc->nSrc!=1 ) return 0; /* One table in FROM */ + if( ExprHasProperty(pExpr, EP_WinFunc) ) return 0;/* Not a window function */ + pSub = p->pSrc->a[0].pSelect; + if( pSub==0 ) return 0; /* The FROM is a subquery */ + if( pSub->pPrior==0 ) return 0; /* Must be a compound */ + if( pSub->selFlags & SF_CopyCte ) return 0; /* Not a CTE */ + do{ + if( pSub->op!=TK_ALL && pSub->pPrior ) return 0; /* Must be UNION ALL */ + if( pSub->pWhere ) return 0; /* No WHERE clause */ + if( pSub->pLimit ) return 0; /* No LIMIT clause */ + if( pSub->selFlags & SF_Aggregate ) return 0; /* Not an aggregate */ + assert( pSub->pHaving==0 ); /* Due to the previous */ + pSub = pSub->pPrior; /* Repeat over compound */ + }while( pSub ); + + /* If we reach this point then it is OK to perform the transformation */ + + db = pParse->db; + pCount = pExpr; + pExpr = 0; + pSub = p->pSrc->a[0].pSelect; + p->pSrc->a[0].pSelect = 0; + sqlite3SrcListDelete(db, p->pSrc); + p->pSrc = sqlite3DbMallocZero(pParse->db, sizeof(*p->pSrc)); + while( pSub ){ + Expr *pTerm; + pPrior = pSub->pPrior; + pSub->pPrior = 0; + pSub->pNext = 0; + pSub->selFlags |= SF_Aggregate; + pSub->selFlags &= ~SF_Compound; + pSub->nSelectRow = 0; + sqlite3ExprListDelete(db, pSub->pEList); + pTerm = pPrior ? sqlite3ExprDup(db, pCount, 0) : pCount; + pSub->pEList = sqlite3ExprListAppend(pParse, 0, pTerm); + pTerm = sqlite3PExpr(pParse, TK_SELECT, 0, 0); + sqlite3PExprAddSelect(pParse, pTerm, pSub); + if( pExpr==0 ){ + pExpr = pTerm; + }else{ + pExpr = sqlite3PExpr(pParse, TK_PLUS, pTerm, pExpr); + } + pSub = pPrior; + } + p->pEList->a[0].pExpr = pExpr; + p->selFlags &= ~SF_Aggregate; + +#if TREETRACE_ENABLED + if( sqlite3TreeTrace & 0x200 ){ + TREETRACE(0x200,pParse,p,("After count-of-view optimization:\n")); + sqlite3TreeViewSelect(0, p, 0); + } +#endif + return 1; +} + +/* +** If any term of pSrc, or any SF_NestedFrom sub-query, is not the same +** as pSrcItem but has the same alias as p0, then return true. +** Otherwise return false. +*/ +static int sameSrcAlias(SrcItem *p0, SrcList *pSrc){ + int i; + for(i=0; inSrc; i++){ + SrcItem *p1 = &pSrc->a[i]; + if( p1==p0 ) continue; + if( p0->pTab==p1->pTab && 0==sqlite3_stricmp(p0->zAlias, p1->zAlias) ){ + return 1; + } + if( p1->pSelect + && (p1->pSelect->selFlags & SF_NestedFrom)!=0 + && sameSrcAlias(p0, p1->pSelect->pSrc) + ){ + return 1; + } + } + return 0; +} + +/* +** Return TRUE (non-zero) if the i-th entry in the pTabList SrcList can +** be implemented as a co-routine. The i-th entry is guaranteed to be +** a subquery. +** +** The subquery is implemented as a co-routine if all of the following are +** true: +** +** (1) The subquery will likely be implemented in the outer loop of +** the query. This will be the case if any one of the following +** conditions hold: +** (a) The subquery is the only term in the FROM clause +** (b) The subquery is the left-most term and a CROSS JOIN or similar +** requires it to be the outer loop +** (c) All of the following are true: +** (i) The subquery is the left-most subquery in the FROM clause +** (ii) There is nothing that would prevent the subquery from +** being used as the outer loop if the sqlite3WhereBegin() +** routine nominates it to that position. +** (iii) The query is not a UPDATE ... FROM +** (2) The subquery is not a CTE that should be materialized because +** (a) the AS MATERIALIZED keyword is used, or +** (b) the CTE is used multiple times and does not have the +** NOT MATERIALIZED keyword +** (3) The subquery is not part of a left operand for a RIGHT JOIN +** (4) The SQLITE_Coroutine optimization disable flag is not set +** (5) The subquery is not self-joined +*/ +static int fromClauseTermCanBeCoroutine( + Parse *pParse, /* Parsing context */ + SrcList *pTabList, /* FROM clause */ + int i, /* Which term of the FROM clause holds the subquery */ + int selFlags /* Flags on the SELECT statement */ +){ + SrcItem *pItem = &pTabList->a[i]; + if( pItem->fg.isCte ){ + const CteUse *pCteUse = pItem->u2.pCteUse; + if( pCteUse->eM10d==M10d_Yes ) return 0; /* (2a) */ + if( pCteUse->nUse>=2 && pCteUse->eM10d!=M10d_No ) return 0; /* (2b) */ + } + if( pTabList->a[0].fg.jointype & JT_LTORJ ) return 0; /* (3) */ + if( OptimizationDisabled(pParse->db, SQLITE_Coroutines) ) return 0; /* (4) */ + if( isSelfJoinView(pTabList, pItem, i+1, pTabList->nSrc)!=0 ){ + return 0; /* (5) */ + } + if( i==0 ){ + if( pTabList->nSrc==1 ) return 1; /* (1a) */ + if( pTabList->a[1].fg.jointype & JT_CROSS ) return 1; /* (1b) */ + if( selFlags & SF_UpdateFrom ) return 0; /* (1c-iii) */ + return 1; + } + if( selFlags & SF_UpdateFrom ) return 0; /* (1c-iii) */ + while( 1 /*exit-by-break*/ ){ + if( pItem->fg.jointype & (JT_OUTER|JT_CROSS) ) return 0; /* (1c-ii) */ + if( i==0 ) break; + i--; + pItem--; + if( pItem->pSelect!=0 ) return 0; /* (1c-i) */ + } + return 1; +} + +/* +** Generate code for the SELECT statement given in the p argument. +** +** The results are returned according to the SelectDest structure. +** See comments in sqliteInt.h for further information. +** +** This routine returns the number of errors. If any errors are +** encountered, then an appropriate error message is left in +** pParse->zErrMsg. +** +** This routine does NOT free the Select structure passed in. The +** calling function needs to do that. +*/ +SQLITE_PRIVATE int sqlite3Select( + Parse *pParse, /* The parser context */ + Select *p, /* The SELECT statement being coded. */ + SelectDest *pDest /* What to do with the query results */ +){ + int i, j; /* Loop counters */ + WhereInfo *pWInfo; /* Return from sqlite3WhereBegin() */ + Vdbe *v; /* The virtual machine under construction */ + int isAgg; /* True for select lists like "count(*)" */ + ExprList *pEList = 0; /* List of columns to extract. */ + SrcList *pTabList; /* List of tables to select from */ + Expr *pWhere; /* The WHERE clause. May be NULL */ + ExprList *pGroupBy; /* The GROUP BY clause. May be NULL */ + Expr *pHaving; /* The HAVING clause. May be NULL */ + AggInfo *pAggInfo = 0; /* Aggregate information */ + int rc = 1; /* Value to return from this function */ + DistinctCtx sDistinct; /* Info on how to code the DISTINCT keyword */ + SortCtx sSort; /* Info on how to code the ORDER BY clause */ + int iEnd; /* Address of the end of the query */ + sqlite3 *db; /* The database connection */ + ExprList *pMinMaxOrderBy = 0; /* Added ORDER BY for min/max queries */ + u8 minMaxFlag; /* Flag for min/max queries */ + + db = pParse->db; + assert( pParse==db->pParse ); + v = sqlite3GetVdbe(pParse); + if( p==0 || pParse->nErr ){ + return 1; + } + assert( db->mallocFailed==0 ); + if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1; +#if TREETRACE_ENABLED + TREETRACE(0x1,pParse,p, ("begin processing:\n", pParse->addrExplain)); + if( sqlite3TreeTrace & 0x10000 ){ + if( (sqlite3TreeTrace & 0x10001)==0x10000 ){ + sqlite3TreeViewLine(0, "In sqlite3Select() at %s:%d", + __FILE__, __LINE__); + } + sqlite3ShowSelect(p); + } +#endif + + assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistFifo ); + assert( p->pOrderBy==0 || pDest->eDest!=SRT_Fifo ); + assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistQueue ); + assert( p->pOrderBy==0 || pDest->eDest!=SRT_Queue ); + if( IgnorableDistinct(pDest) ){ + assert(pDest->eDest==SRT_Exists || pDest->eDest==SRT_Union || + pDest->eDest==SRT_Except || pDest->eDest==SRT_Discard || + pDest->eDest==SRT_DistQueue || pDest->eDest==SRT_DistFifo ); + /* All of these destinations are also able to ignore the ORDER BY clause */ + if( p->pOrderBy ){ +#if TREETRACE_ENABLED + TREETRACE(0x800,pParse,p, ("dropping superfluous ORDER BY:\n")); + if( sqlite3TreeTrace & 0x800 ){ + sqlite3TreeViewExprList(0, p->pOrderBy, 0, "ORDERBY"); + } +#endif + sqlite3ParserAddCleanup(pParse, + (void(*)(sqlite3*,void*))sqlite3ExprListDelete, + p->pOrderBy); + testcase( pParse->earlyCleanup ); + p->pOrderBy = 0; + } + p->selFlags &= ~SF_Distinct; + p->selFlags |= SF_NoopOrderBy; + } + sqlite3SelectPrep(pParse, p, 0); + if( pParse->nErr ){ + goto select_end; + } + assert( db->mallocFailed==0 ); + assert( p->pEList!=0 ); +#if TREETRACE_ENABLED + if( sqlite3TreeTrace & 0x10 ){ + TREETRACE(0x10,pParse,p, ("after name resolution:\n")); + sqlite3TreeViewSelect(0, p, 0); + } +#endif + + /* If the SF_UFSrcCheck flag is set, then this function is being called + ** as part of populating the temp table for an UPDATE...FROM statement. + ** In this case, it is an error if the target object (pSrc->a[0]) name + ** or alias is duplicated within FROM clause (pSrc->a[1..n]). + ** + ** Postgres disallows this case too. The reason is that some other + ** systems handle this case differently, and not all the same way, + ** which is just confusing. To avoid this, we follow PG's lead and + ** disallow it altogether. */ + if( p->selFlags & SF_UFSrcCheck ){ + SrcItem *p0 = &p->pSrc->a[0]; + if( sameSrcAlias(p0, p->pSrc) ){ + sqlite3ErrorMsg(pParse, + "target object/alias may not appear in FROM clause: %s", + p0->zAlias ? p0->zAlias : p0->pTab->zName + ); + goto select_end; + } + + /* Clear the SF_UFSrcCheck flag. The check has already been performed, + ** and leaving this flag set can cause errors if a compound sub-query + ** in p->pSrc is flattened into this query and this function called + ** again as part of compound SELECT processing. */ + p->selFlags &= ~SF_UFSrcCheck; + } + + if( pDest->eDest==SRT_Output ){ + sqlite3GenerateColumnNames(pParse, p); + } + +#ifndef SQLITE_OMIT_WINDOWFUNC + if( sqlite3WindowRewrite(pParse, p) ){ + assert( pParse->nErr ); + goto select_end; + } +#if TREETRACE_ENABLED + if( p->pWin && (sqlite3TreeTrace & 0x40)!=0 ){ + TREETRACE(0x40,pParse,p, ("after window rewrite:\n")); + sqlite3TreeViewSelect(0, p, 0); + } +#endif +#endif /* SQLITE_OMIT_WINDOWFUNC */ + pTabList = p->pSrc; + isAgg = (p->selFlags & SF_Aggregate)!=0; + memset(&sSort, 0, sizeof(sSort)); + sSort.pOrderBy = p->pOrderBy; + + /* Try to do various optimizations (flattening subqueries, and strength + ** reduction of join operators) in the FROM clause up into the main query + */ +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) + for(i=0; !p->pPrior && inSrc; i++){ + SrcItem *pItem = &pTabList->a[i]; + Select *pSub = pItem->pSelect; + Table *pTab = pItem->pTab; + + /* The expander should have already created transient Table objects + ** even for FROM clause elements such as subqueries that do not correspond + ** to a real table */ + assert( pTab!=0 ); + + /* Convert LEFT JOIN into JOIN if there are terms of the right table + ** of the LEFT JOIN used in the WHERE clause. + */ + if( (pItem->fg.jointype & (JT_LEFT|JT_RIGHT))==JT_LEFT + && sqlite3ExprImpliesNonNullRow(p->pWhere, pItem->iCursor) + && OptimizationEnabled(db, SQLITE_SimplifyJoin) + ){ + TREETRACE(0x1000,pParse,p, + ("LEFT-JOIN simplifies to JOIN on term %d\n",i)); + pItem->fg.jointype &= ~(JT_LEFT|JT_OUTER); + assert( pItem->iCursor>=0 ); + unsetJoinExpr(p->pWhere, pItem->iCursor, + pTabList->a[0].fg.jointype & JT_LTORJ); + } + + /* No futher action if this term of the FROM clause is not a subquery */ + if( pSub==0 ) continue; + + /* Catch mismatch in the declared columns of a view and the number of + ** columns in the SELECT on the RHS */ + if( pTab->nCol!=pSub->pEList->nExpr ){ + sqlite3ErrorMsg(pParse, "expected %d columns for '%s' but got %d", + pTab->nCol, pTab->zName, pSub->pEList->nExpr); + goto select_end; + } + + /* Do not try to flatten an aggregate subquery. + ** + ** Flattening an aggregate subquery is only possible if the outer query + ** is not a join. But if the outer query is not a join, then the subquery + ** will be implemented as a co-routine and there is no advantage to + ** flattening in that case. + */ + if( (pSub->selFlags & SF_Aggregate)!=0 ) continue; + assert( pSub->pGroupBy==0 ); + + /* If a FROM-clause subquery has an ORDER BY clause that is not + ** really doing anything, then delete it now so that it does not + ** interfere with query flattening. See the discussion at + ** https://sqlite.org/forum/forumpost/2d76f2bcf65d256a + ** + ** Beware of these cases where the ORDER BY clause may not be safely + ** omitted: + ** + ** (1) There is also a LIMIT clause + ** (2) The subquery was added to help with window-function + ** processing + ** (3) The subquery is in the FROM clause of an UPDATE + ** (4) The outer query uses an aggregate function other than + ** the built-in count(), min(), or max(). + ** (5) The ORDER BY isn't going to accomplish anything because + ** one of: + ** (a) The outer query has a different ORDER BY clause + ** (b) The subquery is part of a join + ** See forum post 062d576715d277c8 + */ + if( pSub->pOrderBy!=0 + && (p->pOrderBy!=0 || pTabList->nSrc>1) /* Condition (5) */ + && pSub->pLimit==0 /* Condition (1) */ + && (pSub->selFlags & SF_OrderByReqd)==0 /* Condition (2) */ + && (p->selFlags & SF_OrderByReqd)==0 /* Condition (3) and (4) */ + && OptimizationEnabled(db, SQLITE_OmitOrderBy) + ){ + TREETRACE(0x800,pParse,p, + ("omit superfluous ORDER BY on %r FROM-clause subquery\n",i+1)); + sqlite3ParserAddCleanup(pParse, + (void(*)(sqlite3*,void*))sqlite3ExprListDelete, + pSub->pOrderBy); + pSub->pOrderBy = 0; + } + + /* If the outer query contains a "complex" result set (that is, + ** if the result set of the outer query uses functions or subqueries) + ** and if the subquery contains an ORDER BY clause and if + ** it will be implemented as a co-routine, then do not flatten. This + ** restriction allows SQL constructs like this: + ** + ** SELECT expensive_function(x) + ** FROM (SELECT x FROM tab ORDER BY y LIMIT 10); + ** + ** The expensive_function() is only computed on the 10 rows that + ** are output, rather than every row of the table. + ** + ** The requirement that the outer query have a complex result set + ** means that flattening does occur on simpler SQL constraints without + ** the expensive_function() like: + ** + ** SELECT x FROM (SELECT x FROM tab ORDER BY y LIMIT 10); + */ + if( pSub->pOrderBy!=0 + && i==0 + && (p->selFlags & SF_ComplexResult)!=0 + && (pTabList->nSrc==1 + || (pTabList->a[1].fg.jointype&(JT_OUTER|JT_CROSS))!=0) + ){ + continue; + } + + if( flattenSubquery(pParse, p, i, isAgg) ){ + if( pParse->nErr ) goto select_end; + /* This subquery can be absorbed into its parent. */ + i = -1; + } + pTabList = p->pSrc; + if( db->mallocFailed ) goto select_end; + if( !IgnorableOrderby(pDest) ){ + sSort.pOrderBy = p->pOrderBy; + } + } +#endif + +#ifndef SQLITE_OMIT_COMPOUND_SELECT + /* Handle compound SELECT statements using the separate multiSelect() + ** procedure. + */ + if( p->pPrior ){ + rc = multiSelect(pParse, p, pDest); +#if TREETRACE_ENABLED + TREETRACE(0x400,pParse,p,("end compound-select processing\n")); + if( (sqlite3TreeTrace & 0x400)!=0 && ExplainQueryPlanParent(pParse)==0 ){ + sqlite3TreeViewSelect(0, p, 0); + } +#endif + if( p->pNext==0 ) ExplainQueryPlanPop(pParse); + return rc; + } +#endif + + /* Do the WHERE-clause constant propagation optimization if this is + ** a join. No need to speed time on this operation for non-join queries + ** as the equivalent optimization will be handled by query planner in + ** sqlite3WhereBegin(). + */ + if( p->pWhere!=0 + && p->pWhere->op==TK_AND + && OptimizationEnabled(db, SQLITE_PropagateConst) + && propagateConstants(pParse, p) + ){ +#if TREETRACE_ENABLED + if( sqlite3TreeTrace & 0x2000 ){ + TREETRACE(0x2000,pParse,p,("After constant propagation:\n")); + sqlite3TreeViewSelect(0, p, 0); + } +#endif + }else{ + TREETRACE(0x2000,pParse,p,("Constant propagation not helpful\n")); + } + + if( OptimizationEnabled(db, SQLITE_QueryFlattener|SQLITE_CountOfView) + && countOfViewOptimization(pParse, p) + ){ + if( db->mallocFailed ) goto select_end; + pTabList = p->pSrc; + } + + /* For each term in the FROM clause, do two things: + ** (1) Authorized unreferenced tables + ** (2) Generate code for all sub-queries + */ + for(i=0; inSrc; i++){ + SrcItem *pItem = &pTabList->a[i]; + SrcItem *pPrior; + SelectDest dest; + Select *pSub; +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) + const char *zSavedAuthContext; +#endif + + /* Issue SQLITE_READ authorizations with a fake column name for any + ** tables that are referenced but from which no values are extracted. + ** Examples of where these kinds of null SQLITE_READ authorizations + ** would occur: + ** + ** SELECT count(*) FROM t1; -- SQLITE_READ t1."" + ** SELECT t1.* FROM t1, t2; -- SQLITE_READ t2."" + ** + ** The fake column name is an empty string. It is possible for a table to + ** have a column named by the empty string, in which case there is no way to + ** distinguish between an unreferenced table and an actual reference to the + ** "" column. The original design was for the fake column name to be a NULL, + ** which would be unambiguous. But legacy authorization callbacks might + ** assume the column name is non-NULL and segfault. The use of an empty + ** string for the fake column name seems safer. + */ + if( pItem->colUsed==0 && pItem->zName!=0 ){ + sqlite3AuthCheck(pParse, SQLITE_READ, pItem->zName, "", pItem->zDatabase); + } + +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) + /* Generate code for all sub-queries in the FROM clause + */ + pSub = pItem->pSelect; + if( pSub==0 ) continue; + + /* The code for a subquery should only be generated once. */ + assert( pItem->addrFillSub==0 ); + + /* Increment Parse.nHeight by the height of the largest expression + ** tree referred to by this, the parent select. The child select + ** may contain expression trees of at most + ** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit + ** more conservative than necessary, but much easier than enforcing + ** an exact limit. + */ + pParse->nHeight += sqlite3SelectExprHeight(p); + + /* Make copies of constant WHERE-clause terms in the outer query down + ** inside the subquery. This can help the subquery to run more efficiently. + */ + if( OptimizationEnabled(db, SQLITE_PushDown) + && (pItem->fg.isCte==0 + || (pItem->u2.pCteUse->eM10d!=M10d_Yes && pItem->u2.pCteUse->nUse<2)) + && pushDownWhereTerms(pParse, pSub, p->pWhere, pTabList, i) + ){ +#if TREETRACE_ENABLED + if( sqlite3TreeTrace & 0x4000 ){ + TREETRACE(0x4000,pParse,p, + ("After WHERE-clause push-down into subquery %d:\n", pSub->selId)); + sqlite3TreeViewSelect(0, p, 0); + } +#endif + assert( pItem->pSelect && (pItem->pSelect->selFlags & SF_PushDown)!=0 ); + }else{ + TREETRACE(0x4000,pParse,p,("Push-down not possible\n")); + } + + /* Convert unused result columns of the subquery into simple NULL + ** expressions, to avoid unneeded searching and computation. + */ + if( OptimizationEnabled(db, SQLITE_NullUnusedCols) + && disableUnusedSubqueryResultColumns(pItem) + ){ +#if TREETRACE_ENABLED + if( sqlite3TreeTrace & 0x4000 ){ + TREETRACE(0x4000,pParse,p, + ("Change unused result columns to NULL for subquery %d:\n", + pSub->selId)); + sqlite3TreeViewSelect(0, p, 0); + } +#endif + } + + zSavedAuthContext = pParse->zAuthContext; + pParse->zAuthContext = pItem->zName; + + /* Generate code to implement the subquery + */ + if( fromClauseTermCanBeCoroutine(pParse, pTabList, i, p->selFlags) ){ + /* Implement a co-routine that will return a single row of the result + ** set on each invocation. + */ + int addrTop = sqlite3VdbeCurrentAddr(v)+1; + + pItem->regReturn = ++pParse->nMem; + sqlite3VdbeAddOp3(v, OP_InitCoroutine, pItem->regReturn, 0, addrTop); + VdbeComment((v, "%!S", pItem)); + pItem->addrFillSub = addrTop; + sqlite3SelectDestInit(&dest, SRT_Coroutine, pItem->regReturn); + ExplainQueryPlan((pParse, 1, "CO-ROUTINE %!S", pItem)); + sqlite3Select(pParse, pSub, &dest); + pItem->pTab->nRowLogEst = pSub->nSelectRow; + pItem->fg.viaCoroutine = 1; + pItem->regResult = dest.iSdst; + sqlite3VdbeEndCoroutine(v, pItem->regReturn); + sqlite3VdbeJumpHere(v, addrTop-1); + sqlite3ClearTempRegCache(pParse); + }else if( pItem->fg.isCte && pItem->u2.pCteUse->addrM9e>0 ){ + /* This is a CTE for which materialization code has already been + ** generated. Invoke the subroutine to compute the materialization, + ** the make the pItem->iCursor be a copy of the ephemerial table that + ** holds the result of the materialization. */ + CteUse *pCteUse = pItem->u2.pCteUse; + sqlite3VdbeAddOp2(v, OP_Gosub, pCteUse->regRtn, pCteUse->addrM9e); + if( pItem->iCursor!=pCteUse->iCur ){ + sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pCteUse->iCur); + VdbeComment((v, "%!S", pItem)); + } + pSub->nSelectRow = pCteUse->nRowEst; + }else if( (pPrior = isSelfJoinView(pTabList, pItem, 0, i))!=0 ){ + /* This view has already been materialized by a prior entry in + ** this same FROM clause. Reuse it. */ + if( pPrior->addrFillSub ){ + sqlite3VdbeAddOp2(v, OP_Gosub, pPrior->regReturn, pPrior->addrFillSub); + } + sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pPrior->iCursor); + pSub->nSelectRow = pPrior->pSelect->nSelectRow; + }else{ + /* Materialize the view. If the view is not correlated, generate a + ** subroutine to do the materialization so that subsequent uses of + ** the same view can reuse the materialization. */ + int topAddr; + int onceAddr = 0; +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + int addrExplain; +#endif + + pItem->regReturn = ++pParse->nMem; + topAddr = sqlite3VdbeAddOp0(v, OP_Goto); + pItem->addrFillSub = topAddr+1; + pItem->fg.isMaterialized = 1; + if( pItem->fg.isCorrelated==0 ){ + /* If the subquery is not correlated and if we are not inside of + ** a trigger, then we only need to compute the value of the subquery + ** once. */ + onceAddr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); + VdbeComment((v, "materialize %!S", pItem)); + }else{ + VdbeNoopComment((v, "materialize %!S", pItem)); + } + sqlite3SelectDestInit(&dest, SRT_EphemTab, pItem->iCursor); + + ExplainQueryPlan2(addrExplain, (pParse, 1, "MATERIALIZE %!S", pItem)); + sqlite3Select(pParse, pSub, &dest); + pItem->pTab->nRowLogEst = pSub->nSelectRow; + if( onceAddr ) sqlite3VdbeJumpHere(v, onceAddr); + sqlite3VdbeAddOp2(v, OP_Return, pItem->regReturn, topAddr+1); + VdbeComment((v, "end %!S", pItem)); + sqlite3VdbeScanStatusRange(v, addrExplain, addrExplain, -1); + sqlite3VdbeJumpHere(v, topAddr); + sqlite3ClearTempRegCache(pParse); + if( pItem->fg.isCte && pItem->fg.isCorrelated==0 ){ + CteUse *pCteUse = pItem->u2.pCteUse; + pCteUse->addrM9e = pItem->addrFillSub; + pCteUse->regRtn = pItem->regReturn; + pCteUse->iCur = pItem->iCursor; + pCteUse->nRowEst = pSub->nSelectRow; + } + } + if( db->mallocFailed ) goto select_end; + pParse->nHeight -= sqlite3SelectExprHeight(p); + pParse->zAuthContext = zSavedAuthContext; +#endif + } + + /* Various elements of the SELECT copied into local variables for + ** convenience */ + pEList = p->pEList; + pWhere = p->pWhere; + pGroupBy = p->pGroupBy; + pHaving = p->pHaving; + sDistinct.isTnct = (p->selFlags & SF_Distinct)!=0; + +#if TREETRACE_ENABLED + if( sqlite3TreeTrace & 0x8000 ){ + TREETRACE(0x8000,pParse,p,("After all FROM-clause analysis:\n")); + sqlite3TreeViewSelect(0, p, 0); + } +#endif + + /* If the query is DISTINCT with an ORDER BY but is not an aggregate, and + ** if the select-list is the same as the ORDER BY list, then this query + ** can be rewritten as a GROUP BY. In other words, this: + ** + ** SELECT DISTINCT xyz FROM ... ORDER BY xyz + ** + ** is transformed to: + ** + ** SELECT xyz FROM ... GROUP BY xyz ORDER BY xyz + ** + ** The second form is preferred as a single index (or temp-table) may be + ** used for both the ORDER BY and DISTINCT processing. As originally + ** written the query must use a temp-table for at least one of the ORDER + ** BY and DISTINCT, and an index or separate temp-table for the other. + */ + if( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct + && sqlite3ExprListCompare(sSort.pOrderBy, pEList, -1)==0 +#ifndef SQLITE_OMIT_WINDOWFUNC + && p->pWin==0 +#endif + ){ + p->selFlags &= ~SF_Distinct; + pGroupBy = p->pGroupBy = sqlite3ExprListDup(db, pEList, 0); + p->selFlags |= SF_Aggregate; + /* Notice that even thought SF_Distinct has been cleared from p->selFlags, + ** the sDistinct.isTnct is still set. Hence, isTnct represents the + ** original setting of the SF_Distinct flag, not the current setting */ + assert( sDistinct.isTnct ); + sDistinct.isTnct = 2; + +#if TREETRACE_ENABLED + if( sqlite3TreeTrace & 0x20000 ){ + TREETRACE(0x20000,pParse,p,("Transform DISTINCT into GROUP BY:\n")); + sqlite3TreeViewSelect(0, p, 0); + } +#endif + } + + /* If there is an ORDER BY clause, then create an ephemeral index to + ** do the sorting. But this sorting ephemeral index might end up + ** being unused if the data can be extracted in pre-sorted order. + ** If that is the case, then the OP_OpenEphemeral instruction will be + ** changed to an OP_Noop once we figure out that the sorting index is + ** not needed. The sSort.addrSortIndex variable is used to facilitate + ** that change. + */ + if( sSort.pOrderBy ){ + KeyInfo *pKeyInfo; + pKeyInfo = sqlite3KeyInfoFromExprList( + pParse, sSort.pOrderBy, 0, pEList->nExpr); + sSort.iECursor = pParse->nTab++; + sSort.addrSortIndex = + sqlite3VdbeAddOp4(v, OP_OpenEphemeral, + sSort.iECursor, sSort.pOrderBy->nExpr+1+pEList->nExpr, 0, + (char*)pKeyInfo, P4_KEYINFO + ); + }else{ + sSort.addrSortIndex = -1; + } + + /* If the output is destined for a temporary table, open that table. + */ + if( pDest->eDest==SRT_EphemTab ){ + sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pDest->iSDParm, pEList->nExpr); + if( p->selFlags & SF_NestedFrom ){ + /* Delete or NULL-out result columns that will never be used */ + int ii; + for(ii=pEList->nExpr-1; ii>0 && pEList->a[ii].fg.bUsed==0; ii--){ + sqlite3ExprDelete(db, pEList->a[ii].pExpr); + sqlite3DbFree(db, pEList->a[ii].zEName); + pEList->nExpr--; + } + for(ii=0; iinExpr; ii++){ + if( pEList->a[ii].fg.bUsed==0 ) pEList->a[ii].pExpr->op = TK_NULL; + } + } + } + + /* Set the limiter. + */ + iEnd = sqlite3VdbeMakeLabel(pParse); + if( (p->selFlags & SF_FixedLimit)==0 ){ + p->nSelectRow = 320; /* 4 billion rows */ + } + if( p->pLimit ) computeLimitRegisters(pParse, p, iEnd); + if( p->iLimit==0 && sSort.addrSortIndex>=0 ){ + sqlite3VdbeChangeOpcode(v, sSort.addrSortIndex, OP_SorterOpen); + sSort.sortFlags |= SORTFLAG_UseSorter; + } + + /* Open an ephemeral index to use for the distinct set. + */ + if( p->selFlags & SF_Distinct ){ + sDistinct.tabTnct = pParse->nTab++; + sDistinct.addrTnct = sqlite3VdbeAddOp4(v, OP_OpenEphemeral, + sDistinct.tabTnct, 0, 0, + (char*)sqlite3KeyInfoFromExprList(pParse, p->pEList,0,0), + P4_KEYINFO); + sqlite3VdbeChangeP5(v, BTREE_UNORDERED); + sDistinct.eTnctType = WHERE_DISTINCT_UNORDERED; + }else{ + sDistinct.eTnctType = WHERE_DISTINCT_NOOP; + } + + if( !isAgg && pGroupBy==0 ){ + /* No aggregate functions and no GROUP BY clause */ + u16 wctrlFlags = (sDistinct.isTnct ? WHERE_WANT_DISTINCT : 0) + | (p->selFlags & SF_FixedLimit); +#ifndef SQLITE_OMIT_WINDOWFUNC + Window *pWin = p->pWin; /* Main window object (or NULL) */ + if( pWin ){ + sqlite3WindowCodeInit(pParse, p); + } +#endif + assert( WHERE_USE_LIMIT==SF_FixedLimit ); + + + /* Begin the database scan. */ + TREETRACE(0x2,pParse,p,("WhereBegin\n")); + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, sSort.pOrderBy, + p->pEList, p, wctrlFlags, p->nSelectRow); + if( pWInfo==0 ) goto select_end; + if( sqlite3WhereOutputRowCount(pWInfo) < p->nSelectRow ){ + p->nSelectRow = sqlite3WhereOutputRowCount(pWInfo); + } + if( sDistinct.isTnct && sqlite3WhereIsDistinct(pWInfo) ){ + sDistinct.eTnctType = sqlite3WhereIsDistinct(pWInfo); + } + if( sSort.pOrderBy ){ + sSort.nOBSat = sqlite3WhereIsOrdered(pWInfo); + sSort.labelOBLopt = sqlite3WhereOrderByLimitOptLabel(pWInfo); + if( sSort.nOBSat==sSort.pOrderBy->nExpr ){ + sSort.pOrderBy = 0; + } + } + TREETRACE(0x2,pParse,p,("WhereBegin returns\n")); + + /* If sorting index that was created by a prior OP_OpenEphemeral + ** instruction ended up not being needed, then change the OP_OpenEphemeral + ** into an OP_Noop. + */ + if( sSort.addrSortIndex>=0 && sSort.pOrderBy==0 ){ + sqlite3VdbeChangeToNoop(v, sSort.addrSortIndex); + } + + assert( p->pEList==pEList ); +#ifndef SQLITE_OMIT_WINDOWFUNC + if( pWin ){ + int addrGosub = sqlite3VdbeMakeLabel(pParse); + int iCont = sqlite3VdbeMakeLabel(pParse); + int iBreak = sqlite3VdbeMakeLabel(pParse); + int regGosub = ++pParse->nMem; + + sqlite3WindowCodeStep(pParse, p, pWInfo, regGosub, addrGosub); + + sqlite3VdbeAddOp2(v, OP_Goto, 0, iBreak); + sqlite3VdbeResolveLabel(v, addrGosub); + VdbeNoopComment((v, "inner-loop subroutine")); + sSort.labelOBLopt = 0; + selectInnerLoop(pParse, p, -1, &sSort, &sDistinct, pDest, iCont, iBreak); + sqlite3VdbeResolveLabel(v, iCont); + sqlite3VdbeAddOp1(v, OP_Return, regGosub); + VdbeComment((v, "end inner-loop subroutine")); + sqlite3VdbeResolveLabel(v, iBreak); + }else +#endif /* SQLITE_OMIT_WINDOWFUNC */ + { + /* Use the standard inner loop. */ + selectInnerLoop(pParse, p, -1, &sSort, &sDistinct, pDest, + sqlite3WhereContinueLabel(pWInfo), + sqlite3WhereBreakLabel(pWInfo)); + + /* End the database scan loop. + */ + TREETRACE(0x2,pParse,p,("WhereEnd\n")); + sqlite3WhereEnd(pWInfo); + } + }else{ + /* This case when there exist aggregate functions or a GROUP BY clause + ** or both */ + NameContext sNC; /* Name context for processing aggregate information */ + int iAMem; /* First Mem address for storing current GROUP BY */ + int iBMem; /* First Mem address for previous GROUP BY */ + int iUseFlag; /* Mem address holding flag indicating that at least + ** one row of the input to the aggregator has been + ** processed */ + int iAbortFlag; /* Mem address which causes query abort if positive */ + int groupBySort; /* Rows come from source in GROUP BY order */ + int addrEnd; /* End of processing for this SELECT */ + int sortPTab = 0; /* Pseudotable used to decode sorting results */ + int sortOut = 0; /* Output register from the sorter */ + int orderByGrp = 0; /* True if the GROUP BY and ORDER BY are the same */ + + /* Remove any and all aliases between the result set and the + ** GROUP BY clause. + */ + if( pGroupBy ){ + int k; /* Loop counter */ + struct ExprList_item *pItem; /* For looping over expression in a list */ + + for(k=p->pEList->nExpr, pItem=p->pEList->a; k>0; k--, pItem++){ + pItem->u.x.iAlias = 0; + } + for(k=pGroupBy->nExpr, pItem=pGroupBy->a; k>0; k--, pItem++){ + pItem->u.x.iAlias = 0; + } + assert( 66==sqlite3LogEst(100) ); + if( p->nSelectRow>66 ) p->nSelectRow = 66; + + /* If there is both a GROUP BY and an ORDER BY clause and they are + ** identical, then it may be possible to disable the ORDER BY clause + ** on the grounds that the GROUP BY will cause elements to come out + ** in the correct order. It also may not - the GROUP BY might use a + ** database index that causes rows to be grouped together as required + ** but not actually sorted. Either way, record the fact that the + ** ORDER BY and GROUP BY clauses are the same by setting the orderByGrp + ** variable. */ + if( sSort.pOrderBy && pGroupBy->nExpr==sSort.pOrderBy->nExpr ){ + int ii; + /* The GROUP BY processing doesn't care whether rows are delivered in + ** ASC or DESC order - only that each group is returned contiguously. + ** So set the ASC/DESC flags in the GROUP BY to match those in the + ** ORDER BY to maximize the chances of rows being delivered in an + ** order that makes the ORDER BY redundant. */ + for(ii=0; iinExpr; ii++){ + u8 sortFlags; + sortFlags = sSort.pOrderBy->a[ii].fg.sortFlags & KEYINFO_ORDER_DESC; + pGroupBy->a[ii].fg.sortFlags = sortFlags; + } + if( sqlite3ExprListCompare(pGroupBy, sSort.pOrderBy, -1)==0 ){ + orderByGrp = 1; + } + } + }else{ + assert( 0==sqlite3LogEst(1) ); + p->nSelectRow = 0; + } + + /* Create a label to jump to when we want to abort the query */ + addrEnd = sqlite3VdbeMakeLabel(pParse); + + /* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in + ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the + ** SELECT statement. + */ + pAggInfo = sqlite3DbMallocZero(db, sizeof(*pAggInfo) ); + if( pAggInfo ){ + sqlite3ParserAddCleanup(pParse, + (void(*)(sqlite3*,void*))agginfoFree, pAggInfo); + testcase( pParse->earlyCleanup ); + } + if( db->mallocFailed ){ + goto select_end; + } + pAggInfo->selId = p->selId; +#ifdef SQLITE_DEBUG + pAggInfo->pSelect = p; +#endif + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + sNC.pSrcList = pTabList; + sNC.uNC.pAggInfo = pAggInfo; + VVA_ONLY( sNC.ncFlags = NC_UAggInfo; ) + pAggInfo->nSortingColumn = pGroupBy ? pGroupBy->nExpr : 0; + pAggInfo->pGroupBy = pGroupBy; + sqlite3ExprAnalyzeAggList(&sNC, pEList); + sqlite3ExprAnalyzeAggList(&sNC, sSort.pOrderBy); + if( pHaving ){ + if( pGroupBy ){ + assert( pWhere==p->pWhere ); + assert( pHaving==p->pHaving ); + assert( pGroupBy==p->pGroupBy ); + havingToWhere(pParse, p); + pWhere = p->pWhere; + } + sqlite3ExprAnalyzeAggregates(&sNC, pHaving); + } + pAggInfo->nAccumulator = pAggInfo->nColumn; + if( p->pGroupBy==0 && p->pHaving==0 && pAggInfo->nFunc==1 ){ + minMaxFlag = minMaxQuery(db, pAggInfo->aFunc[0].pFExpr, &pMinMaxOrderBy); + }else{ + minMaxFlag = WHERE_ORDERBY_NORMAL; + } + analyzeAggFuncArgs(pAggInfo, &sNC); + if( db->mallocFailed ) goto select_end; +#if TREETRACE_ENABLED + if( sqlite3TreeTrace & 0x20 ){ + TREETRACE(0x20,pParse,p,("After aggregate analysis %p:\n", pAggInfo)); + sqlite3TreeViewSelect(0, p, 0); + if( minMaxFlag ){ + sqlite3DebugPrintf("MIN/MAX Optimization (0x%02x) adds:\n", minMaxFlag); + sqlite3TreeViewExprList(0, pMinMaxOrderBy, 0, "ORDERBY"); + } + printAggInfo(pAggInfo); + } +#endif + + + /* Processing for aggregates with GROUP BY is very different and + ** much more complex than aggregates without a GROUP BY. + */ + if( pGroupBy ){ + KeyInfo *pKeyInfo; /* Keying information for the group by clause */ + int addr1; /* A-vs-B comparision jump */ + int addrOutputRow; /* Start of subroutine that outputs a result row */ + int regOutputRow; /* Return address register for output subroutine */ + int addrSetAbort; /* Set the abort flag and return */ + int addrTopOfLoop; /* Top of the input loop */ + int addrSortingIdx; /* The OP_OpenEphemeral for the sorting index */ + int addrReset; /* Subroutine for resetting the accumulator */ + int regReset; /* Return address register for reset subroutine */ + ExprList *pDistinct = 0; + u16 distFlag = 0; + int eDist = WHERE_DISTINCT_NOOP; + + if( pAggInfo->nFunc==1 + && pAggInfo->aFunc[0].iDistinct>=0 + && ALWAYS(pAggInfo->aFunc[0].pFExpr!=0) + && ALWAYS(ExprUseXList(pAggInfo->aFunc[0].pFExpr)) + && pAggInfo->aFunc[0].pFExpr->x.pList!=0 + ){ + Expr *pExpr = pAggInfo->aFunc[0].pFExpr->x.pList->a[0].pExpr; + pExpr = sqlite3ExprDup(db, pExpr, 0); + pDistinct = sqlite3ExprListDup(db, pGroupBy, 0); + pDistinct = sqlite3ExprListAppend(pParse, pDistinct, pExpr); + distFlag = pDistinct ? (WHERE_WANT_DISTINCT|WHERE_AGG_DISTINCT) : 0; + } + + /* If there is a GROUP BY clause we might need a sorting index to + ** implement it. Allocate that sorting index now. If it turns out + ** that we do not need it after all, the OP_SorterOpen instruction + ** will be converted into a Noop. + */ + pAggInfo->sortingIdx = pParse->nTab++; + pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pGroupBy, + 0, pAggInfo->nColumn); + addrSortingIdx = sqlite3VdbeAddOp4(v, OP_SorterOpen, + pAggInfo->sortingIdx, pAggInfo->nSortingColumn, + 0, (char*)pKeyInfo, P4_KEYINFO); + + /* Initialize memory locations used by GROUP BY aggregate processing + */ + iUseFlag = ++pParse->nMem; + iAbortFlag = ++pParse->nMem; + regOutputRow = ++pParse->nMem; + addrOutputRow = sqlite3VdbeMakeLabel(pParse); + regReset = ++pParse->nMem; + addrReset = sqlite3VdbeMakeLabel(pParse); + iAMem = pParse->nMem + 1; + pParse->nMem += pGroupBy->nExpr; + iBMem = pParse->nMem + 1; + pParse->nMem += pGroupBy->nExpr; + sqlite3VdbeAddOp2(v, OP_Integer, 0, iAbortFlag); + VdbeComment((v, "clear abort flag")); + sqlite3VdbeAddOp3(v, OP_Null, 0, iAMem, iAMem+pGroupBy->nExpr-1); + + /* Begin a loop that will extract all source rows in GROUP BY order. + ** This might involve two separate loops with an OP_Sort in between, or + ** it might be a single loop that uses an index to extract information + ** in the right order to begin with. + */ + sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset); + TREETRACE(0x2,pParse,p,("WhereBegin\n")); + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pGroupBy, pDistinct, + p, (sDistinct.isTnct==2 ? WHERE_DISTINCTBY : WHERE_GROUPBY) + | (orderByGrp ? WHERE_SORTBYGROUP : 0) | distFlag, 0 + ); + if( pWInfo==0 ){ + sqlite3ExprListDelete(db, pDistinct); + goto select_end; + } + if( pParse->pIdxEpr ){ + optimizeAggregateUseOfIndexedExpr(pParse, p, pAggInfo, &sNC); + } + assignAggregateRegisters(pParse, pAggInfo); + eDist = sqlite3WhereIsDistinct(pWInfo); + TREETRACE(0x2,pParse,p,("WhereBegin returns\n")); + if( sqlite3WhereIsOrdered(pWInfo)==pGroupBy->nExpr ){ + /* The optimizer is able to deliver rows in group by order so + ** we do not have to sort. The OP_OpenEphemeral table will be + ** cancelled later because we still need to use the pKeyInfo + */ + groupBySort = 0; + }else{ + /* Rows are coming out in undetermined order. We have to push + ** each row into a sorting index, terminate the first loop, + ** then loop over the sorting index in order to get the output + ** in sorted order + */ + int regBase; + int regRecord; + int nCol; + int nGroupBy; + + explainTempTable(pParse, + (sDistinct.isTnct && (p->selFlags&SF_Distinct)==0) ? + "DISTINCT" : "GROUP BY"); + + groupBySort = 1; + nGroupBy = pGroupBy->nExpr; + nCol = nGroupBy; + j = nGroupBy; + for(i=0; inColumn; i++){ + if( pAggInfo->aCol[i].iSorterColumn>=j ){ + nCol++; + j++; + } + } + regBase = sqlite3GetTempRange(pParse, nCol); + sqlite3ExprCodeExprList(pParse, pGroupBy, regBase, 0, 0); + j = nGroupBy; + pAggInfo->directMode = 1; + for(i=0; inColumn; i++){ + struct AggInfo_col *pCol = &pAggInfo->aCol[i]; + if( pCol->iSorterColumn>=j ){ + sqlite3ExprCode(pParse, pCol->pCExpr, j + regBase); + j++; + } + } + pAggInfo->directMode = 0; + regRecord = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord); + sqlite3VdbeAddOp2(v, OP_SorterInsert, pAggInfo->sortingIdx, regRecord); + sqlite3ReleaseTempReg(pParse, regRecord); + sqlite3ReleaseTempRange(pParse, regBase, nCol); + TREETRACE(0x2,pParse,p,("WhereEnd\n")); + sqlite3WhereEnd(pWInfo); + pAggInfo->sortingIdxPTab = sortPTab = pParse->nTab++; + sortOut = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol); + sqlite3VdbeAddOp2(v, OP_SorterSort, pAggInfo->sortingIdx, addrEnd); + VdbeComment((v, "GROUP BY sort")); VdbeCoverage(v); + pAggInfo->useSortingIdx = 1; + } + + /* If there are entries in pAgggInfo->aFunc[] that contain subexpressions + ** that are indexed (and that were previously identified and tagged + ** in optimizeAggregateUseOfIndexedExpr()) then those subexpressions + ** must now be converted into a TK_AGG_COLUMN node so that the value + ** is correctly pulled from the index rather than being recomputed. */ + if( pParse->pIdxEpr ){ + aggregateConvertIndexedExprRefToColumn(pAggInfo); +#if TREETRACE_ENABLED + if( sqlite3TreeTrace & 0x20 ){ + TREETRACE(0x20, pParse, p, + ("AggInfo function expressions converted to reference index\n")); + sqlite3TreeViewSelect(0, p, 0); + printAggInfo(pAggInfo); + } +#endif + } + + /* If the index or temporary table used by the GROUP BY sort + ** will naturally deliver rows in the order required by the ORDER BY + ** clause, cancel the ephemeral table open coded earlier. + ** + ** This is an optimization - the correct answer should result regardless. + ** Use the SQLITE_GroupByOrder flag with SQLITE_TESTCTRL_OPTIMIZER to + ** disable this optimization for testing purposes. */ + if( orderByGrp && OptimizationEnabled(db, SQLITE_GroupByOrder) + && (groupBySort || sqlite3WhereIsSorted(pWInfo)) + ){ + sSort.pOrderBy = 0; + sqlite3VdbeChangeToNoop(v, sSort.addrSortIndex); + } + + /* Evaluate the current GROUP BY terms and store in b0, b1, b2... + ** (b0 is memory location iBMem+0, b1 is iBMem+1, and so forth) + ** Then compare the current GROUP BY terms against the GROUP BY terms + ** from the previous row currently stored in a0, a1, a2... + */ + addrTopOfLoop = sqlite3VdbeCurrentAddr(v); + if( groupBySort ){ + sqlite3VdbeAddOp3(v, OP_SorterData, pAggInfo->sortingIdx, + sortOut, sortPTab); + } + for(j=0; jnExpr; j++){ + if( groupBySort ){ + sqlite3VdbeAddOp3(v, OP_Column, sortPTab, j, iBMem+j); + }else{ + pAggInfo->directMode = 1; + sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j); + } + } + sqlite3VdbeAddOp4(v, OP_Compare, iAMem, iBMem, pGroupBy->nExpr, + (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO); + addr1 = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp3(v, OP_Jump, addr1+1, 0, addr1+1); VdbeCoverage(v); + + /* Generate code that runs whenever the GROUP BY changes. + ** Changes in the GROUP BY are detected by the previous code + ** block. If there were no changes, this block is skipped. + ** + ** This code copies current group by terms in b0,b1,b2,... + ** over to a0,a1,a2. It then calls the output subroutine + ** and resets the aggregate accumulator registers in preparation + ** for the next GROUP BY batch. + */ + sqlite3ExprCodeMove(pParse, iBMem, iAMem, pGroupBy->nExpr); + sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow); + VdbeComment((v, "output one row")); + sqlite3VdbeAddOp2(v, OP_IfPos, iAbortFlag, addrEnd); VdbeCoverage(v); + VdbeComment((v, "check abort flag")); + sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset); + VdbeComment((v, "reset accumulator")); + + /* Update the aggregate accumulators based on the content of + ** the current row + */ + sqlite3VdbeJumpHere(v, addr1); + updateAccumulator(pParse, iUseFlag, pAggInfo, eDist); + sqlite3VdbeAddOp2(v, OP_Integer, 1, iUseFlag); + VdbeComment((v, "indicate data in accumulator")); + + /* End of the loop + */ + if( groupBySort ){ + sqlite3VdbeAddOp2(v, OP_SorterNext, pAggInfo->sortingIdx,addrTopOfLoop); + VdbeCoverage(v); + }else{ + TREETRACE(0x2,pParse,p,("WhereEnd\n")); + sqlite3WhereEnd(pWInfo); + sqlite3VdbeChangeToNoop(v, addrSortingIdx); + } + sqlite3ExprListDelete(db, pDistinct); + + /* Output the final row of result + */ + sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow); + VdbeComment((v, "output final row")); + + /* Jump over the subroutines + */ + sqlite3VdbeGoto(v, addrEnd); + + /* Generate a subroutine that outputs a single row of the result + ** set. This subroutine first looks at the iUseFlag. If iUseFlag + ** is less than or equal to zero, the subroutine is a no-op. If + ** the processing calls for the query to abort, this subroutine + ** increments the iAbortFlag memory location before returning in + ** order to signal the caller to abort. + */ + addrSetAbort = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp2(v, OP_Integer, 1, iAbortFlag); + VdbeComment((v, "set abort flag")); + sqlite3VdbeAddOp1(v, OP_Return, regOutputRow); + sqlite3VdbeResolveLabel(v, addrOutputRow); + addrOutputRow = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp2(v, OP_IfPos, iUseFlag, addrOutputRow+2); + VdbeCoverage(v); + VdbeComment((v, "Groupby result generator entry point")); + sqlite3VdbeAddOp1(v, OP_Return, regOutputRow); + finalizeAggFunctions(pParse, pAggInfo); + sqlite3ExprIfFalse(pParse, pHaving, addrOutputRow+1, SQLITE_JUMPIFNULL); + selectInnerLoop(pParse, p, -1, &sSort, + &sDistinct, pDest, + addrOutputRow+1, addrSetAbort); + sqlite3VdbeAddOp1(v, OP_Return, regOutputRow); + VdbeComment((v, "end groupby result generator")); + + /* Generate a subroutine that will reset the group-by accumulator + */ + sqlite3VdbeResolveLabel(v, addrReset); + resetAccumulator(pParse, pAggInfo); + sqlite3VdbeAddOp2(v, OP_Integer, 0, iUseFlag); + VdbeComment((v, "indicate accumulator empty")); + sqlite3VdbeAddOp1(v, OP_Return, regReset); + + if( distFlag!=0 && eDist!=WHERE_DISTINCT_NOOP ){ + struct AggInfo_func *pF = &pAggInfo->aFunc[0]; + fixDistinctOpenEph(pParse, eDist, pF->iDistinct, pF->iDistAddr); + } + } /* endif pGroupBy. Begin aggregate queries without GROUP BY: */ + else { + Table *pTab; + if( (pTab = isSimpleCount(p, pAggInfo))!=0 ){ + /* If isSimpleCount() returns a pointer to a Table structure, then + ** the SQL statement is of the form: + ** + ** SELECT count(*) FROM + ** + ** where the Table structure returned represents table . + ** + ** This statement is so common that it is optimized specially. The + ** OP_Count instruction is executed either on the intkey table that + ** contains the data for table or on one of its indexes. It + ** is better to execute the op on an index, as indexes are almost + ** always spread across less pages than their corresponding tables. + */ + const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + const int iCsr = pParse->nTab++; /* Cursor to scan b-tree */ + Index *pIdx; /* Iterator variable */ + KeyInfo *pKeyInfo = 0; /* Keyinfo for scanned index */ + Index *pBest = 0; /* Best index found so far */ + Pgno iRoot = pTab->tnum; /* Root page of scanned b-tree */ + + sqlite3CodeVerifySchema(pParse, iDb); + sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName); + + /* Search for the index that has the lowest scan cost. + ** + ** (2011-04-15) Do not do a full scan of an unordered index. + ** + ** (2013-10-03) Do not count the entries in a partial index. + ** + ** In practice the KeyInfo structure will not be used. It is only + ** passed to keep OP_OpenRead happy. + */ + if( !HasRowid(pTab) ) pBest = sqlite3PrimaryKeyIndex(pTab); + if( !p->pSrc->a[0].fg.notIndexed ){ + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + if( pIdx->bUnordered==0 + && pIdx->szIdxRowszTabRow + && pIdx->pPartIdxWhere==0 + && (!pBest || pIdx->szIdxRowszIdxRow) + ){ + pBest = pIdx; + } + } + } + if( pBest ){ + iRoot = pBest->tnum; + pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pBest); + } + + /* Open a read-only cursor, execute the OP_Count, close the cursor. */ + sqlite3VdbeAddOp4Int(v, OP_OpenRead, iCsr, (int)iRoot, iDb, 1); + if( pKeyInfo ){ + sqlite3VdbeChangeP4(v, -1, (char *)pKeyInfo, P4_KEYINFO); + } + assignAggregateRegisters(pParse, pAggInfo); + sqlite3VdbeAddOp2(v, OP_Count, iCsr, AggInfoFuncReg(pAggInfo,0)); + sqlite3VdbeAddOp1(v, OP_Close, iCsr); + explainSimpleCount(pParse, pTab, pBest); + }else{ + int regAcc = 0; /* "populate accumulators" flag */ + ExprList *pDistinct = 0; + u16 distFlag = 0; + int eDist; + + /* If there are accumulator registers but no min() or max() functions + ** without FILTER clauses, allocate register regAcc. Register regAcc + ** will contain 0 the first time the inner loop runs, and 1 thereafter. + ** The code generated by updateAccumulator() uses this to ensure + ** that the accumulator registers are (a) updated only once if + ** there are no min() or max functions or (b) always updated for the + ** first row visited by the aggregate, so that they are updated at + ** least once even if the FILTER clause means the min() or max() + ** function visits zero rows. */ + if( pAggInfo->nAccumulator ){ + for(i=0; inFunc; i++){ + if( ExprHasProperty(pAggInfo->aFunc[i].pFExpr, EP_WinFunc) ){ + continue; + } + if( pAggInfo->aFunc[i].pFunc->funcFlags&SQLITE_FUNC_NEEDCOLL ){ + break; + } + } + if( i==pAggInfo->nFunc ){ + regAcc = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Integer, 0, regAcc); + } + }else if( pAggInfo->nFunc==1 && pAggInfo->aFunc[0].iDistinct>=0 ){ + assert( ExprUseXList(pAggInfo->aFunc[0].pFExpr) ); + pDistinct = pAggInfo->aFunc[0].pFExpr->x.pList; + distFlag = pDistinct ? (WHERE_WANT_DISTINCT|WHERE_AGG_DISTINCT) : 0; + } + assignAggregateRegisters(pParse, pAggInfo); + + /* This case runs if the aggregate has no GROUP BY clause. The + ** processing is much simpler since there is only a single row + ** of output. + */ + assert( p->pGroupBy==0 ); + resetAccumulator(pParse, pAggInfo); + + /* If this query is a candidate for the min/max optimization, then + ** minMaxFlag will have been previously set to either + ** WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX and pMinMaxOrderBy will + ** be an appropriate ORDER BY expression for the optimization. + */ + assert( minMaxFlag==WHERE_ORDERBY_NORMAL || pMinMaxOrderBy!=0 ); + assert( pMinMaxOrderBy==0 || pMinMaxOrderBy->nExpr==1 ); + + TREETRACE(0x2,pParse,p,("WhereBegin\n")); + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pMinMaxOrderBy, + pDistinct, p, minMaxFlag|distFlag, 0); + if( pWInfo==0 ){ + goto select_end; + } + TREETRACE(0x2,pParse,p,("WhereBegin returns\n")); + eDist = sqlite3WhereIsDistinct(pWInfo); + updateAccumulator(pParse, regAcc, pAggInfo, eDist); + if( eDist!=WHERE_DISTINCT_NOOP ){ + struct AggInfo_func *pF = pAggInfo->aFunc; + if( pF ){ + fixDistinctOpenEph(pParse, eDist, pF->iDistinct, pF->iDistAddr); + } + } + + if( regAcc ) sqlite3VdbeAddOp2(v, OP_Integer, 1, regAcc); + if( minMaxFlag ){ + sqlite3WhereMinMaxOptEarlyOut(v, pWInfo); + } + TREETRACE(0x2,pParse,p,("WhereEnd\n")); + sqlite3WhereEnd(pWInfo); + finalizeAggFunctions(pParse, pAggInfo); + } + + sSort.pOrderBy = 0; + sqlite3ExprIfFalse(pParse, pHaving, addrEnd, SQLITE_JUMPIFNULL); + selectInnerLoop(pParse, p, -1, 0, 0, + pDest, addrEnd, addrEnd); + } + sqlite3VdbeResolveLabel(v, addrEnd); + + } /* endif aggregate query */ + + if( sDistinct.eTnctType==WHERE_DISTINCT_UNORDERED ){ + explainTempTable(pParse, "DISTINCT"); + } + + /* If there is an ORDER BY clause, then we need to sort the results + ** and send them to the callback one by one. + */ + if( sSort.pOrderBy ){ + assert( p->pEList==pEList ); + generateSortTail(pParse, p, &sSort, pEList->nExpr, pDest); + } + + /* Jump here to skip this query + */ + sqlite3VdbeResolveLabel(v, iEnd); + + /* The SELECT has been coded. If there is an error in the Parse structure, + ** set the return code to 1. Otherwise 0. */ + rc = (pParse->nErr>0); + + /* Control jumps to here if an error is encountered above, or upon + ** successful coding of the SELECT. + */ +select_end: + assert( db->mallocFailed==0 || db->mallocFailed==1 ); + assert( db->mallocFailed==0 || pParse->nErr!=0 ); + sqlite3ExprListDelete(db, pMinMaxOrderBy); +#ifdef SQLITE_DEBUG + if( pAggInfo && !db->mallocFailed ){ + for(i=0; inColumn; i++){ + Expr *pExpr = pAggInfo->aCol[i].pCExpr; + if( pExpr==0 ) continue; + assert( pExpr->pAggInfo==pAggInfo ); + assert( pExpr->iAgg==i ); + } + for(i=0; inFunc; i++){ + Expr *pExpr = pAggInfo->aFunc[i].pFExpr; + assert( pExpr!=0 ); + assert( pExpr->pAggInfo==pAggInfo ); + assert( pExpr->iAgg==i ); + } + } +#endif + +#if TREETRACE_ENABLED + TREETRACE(0x1,pParse,p,("end processing\n")); + if( (sqlite3TreeTrace & 0x40000)!=0 && ExplainQueryPlanParent(pParse)==0 ){ + sqlite3TreeViewSelect(0, p, 0); + } +#endif + ExplainQueryPlanPop(pParse); + return rc; +} + +/************** End of select.c **********************************************/ +/************** Begin file table.c *******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the sqlite3_get_table() and sqlite3_free_table() +** interface routines. These are just wrappers around the main +** interface routine of sqlite3_exec(). +** +** These routines are in a separate files so that they will not be linked +** if they are not used. +*/ +/* #include "sqliteInt.h" */ + +#ifndef SQLITE_OMIT_GET_TABLE + +/* +** This structure is used to pass data from sqlite3_get_table() through +** to the callback function is uses to build the result. +*/ +typedef struct TabResult { + char **azResult; /* Accumulated output */ + char *zErrMsg; /* Error message text, if an error occurs */ + u32 nAlloc; /* Slots allocated for azResult[] */ + u32 nRow; /* Number of rows in the result */ + u32 nColumn; /* Number of columns in the result */ + u32 nData; /* Slots used in azResult[]. (nRow+1)*nColumn */ + int rc; /* Return code from sqlite3_exec() */ +} TabResult; + +/* +** This routine is called once for each row in the result table. Its job +** is to fill in the TabResult structure appropriately, allocating new +** memory as necessary. +*/ +static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){ + TabResult *p = (TabResult*)pArg; /* Result accumulator */ + int need; /* Slots needed in p->azResult[] */ + int i; /* Loop counter */ + char *z; /* A single column of result */ + + /* Make sure there is enough space in p->azResult to hold everything + ** we need to remember from this invocation of the callback. + */ + if( p->nRow==0 && argv!=0 ){ + need = nCol*2; + }else{ + need = nCol; + } + if( p->nData + need > p->nAlloc ){ + char **azNew; + p->nAlloc = p->nAlloc*2 + need; + azNew = sqlite3Realloc( p->azResult, sizeof(char*)*p->nAlloc ); + if( azNew==0 ) goto malloc_failed; + p->azResult = azNew; + } + + /* If this is the first row, then generate an extra row containing + ** the names of all columns. + */ + if( p->nRow==0 ){ + p->nColumn = nCol; + for(i=0; iazResult[p->nData++] = z; + } + }else if( (int)p->nColumn!=nCol ){ + sqlite3_free(p->zErrMsg); + p->zErrMsg = sqlite3_mprintf( + "sqlite3_get_table() called with two or more incompatible queries" + ); + p->rc = SQLITE_ERROR; + return 1; + } + + /* Copy over the row data + */ + if( argv!=0 ){ + for(i=0; iazResult[p->nData++] = z; + } + p->nRow++; + } + return 0; + +malloc_failed: + p->rc = SQLITE_NOMEM_BKPT; + return 1; +} + +/* +** Query the database. But instead of invoking a callback for each row, +** malloc() for space to hold the result and return the entire results +** at the conclusion of the call. +** +** The result that is written to ***pazResult is held in memory obtained +** from malloc(). But the caller cannot free this memory directly. +** Instead, the entire table should be passed to sqlite3_free_table() when +** the calling procedure is finished using it. +*/ +SQLITE_API int sqlite3_get_table( + sqlite3 *db, /* The database on which the SQL executes */ + const char *zSql, /* The SQL to be executed */ + char ***pazResult, /* Write the result table here */ + int *pnRow, /* Write the number of rows in the result here */ + int *pnColumn, /* Write the number of columns of result here */ + char **pzErrMsg /* Write error messages here */ +){ + int rc; + TabResult res; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || pazResult==0 ) return SQLITE_MISUSE_BKPT; +#endif + *pazResult = 0; + if( pnColumn ) *pnColumn = 0; + if( pnRow ) *pnRow = 0; + if( pzErrMsg ) *pzErrMsg = 0; + res.zErrMsg = 0; + res.nRow = 0; + res.nColumn = 0; + res.nData = 1; + res.nAlloc = 20; + res.rc = SQLITE_OK; + res.azResult = sqlite3_malloc64(sizeof(char*)*res.nAlloc ); + if( res.azResult==0 ){ + db->errCode = SQLITE_NOMEM; + return SQLITE_NOMEM_BKPT; + } + res.azResult[0] = 0; + rc = sqlite3_exec(db, zSql, sqlite3_get_table_cb, &res, pzErrMsg); + assert( sizeof(res.azResult[0])>= sizeof(res.nData) ); + res.azResult[0] = SQLITE_INT_TO_PTR(res.nData); + if( (rc&0xff)==SQLITE_ABORT ){ + sqlite3_free_table(&res.azResult[1]); + if( res.zErrMsg ){ + if( pzErrMsg ){ + sqlite3_free(*pzErrMsg); + *pzErrMsg = sqlite3_mprintf("%s",res.zErrMsg); + } + sqlite3_free(res.zErrMsg); + } + db->errCode = res.rc; /* Assume 32-bit assignment is atomic */ + return res.rc; + } + sqlite3_free(res.zErrMsg); + if( rc!=SQLITE_OK ){ + sqlite3_free_table(&res.azResult[1]); + return rc; + } + if( res.nAlloc>res.nData ){ + char **azNew; + azNew = sqlite3Realloc( res.azResult, sizeof(char*)*res.nData ); + if( azNew==0 ){ + sqlite3_free_table(&res.azResult[1]); + db->errCode = SQLITE_NOMEM; + return SQLITE_NOMEM_BKPT; + } + res.azResult = azNew; + } + *pazResult = &res.azResult[1]; + if( pnColumn ) *pnColumn = res.nColumn; + if( pnRow ) *pnRow = res.nRow; + return rc; +} + +/* +** This routine frees the space the sqlite3_get_table() malloced. +*/ +SQLITE_API void sqlite3_free_table( + char **azResult /* Result returned from sqlite3_get_table() */ +){ + if( azResult ){ + int i, n; + azResult--; + assert( azResult!=0 ); + n = SQLITE_PTR_TO_INT(azResult[0]); + for(i=1; ipNext; + + sqlite3ExprDelete(db, pTmp->pWhere); + sqlite3ExprListDelete(db, pTmp->pExprList); + sqlite3SelectDelete(db, pTmp->pSelect); + sqlite3IdListDelete(db, pTmp->pIdList); + sqlite3UpsertDelete(db, pTmp->pUpsert); + sqlite3SrcListDelete(db, pTmp->pFrom); + sqlite3DbFree(db, pTmp->zSpan); + + sqlite3DbFree(db, pTmp); + } +} + +/* +** Given table pTab, return a list of all the triggers attached to +** the table. The list is connected by Trigger.pNext pointers. +** +** All of the triggers on pTab that are in the same database as pTab +** are already attached to pTab->pTrigger. But there might be additional +** triggers on pTab in the TEMP schema. This routine prepends all +** TEMP triggers on pTab to the beginning of the pTab->pTrigger list +** and returns the combined list. +** +** To state it another way: This routine returns a list of all triggers +** that fire off of pTab. The list will include any TEMP triggers on +** pTab as well as the triggers lised in pTab->pTrigger. +*/ +SQLITE_PRIVATE Trigger *sqlite3TriggerList(Parse *pParse, Table *pTab){ + Schema *pTmpSchema; /* Schema of the pTab table */ + Trigger *pList; /* List of triggers to return */ + HashElem *p; /* Loop variable for TEMP triggers */ + + assert( pParse->disableTriggers==0 ); + pTmpSchema = pParse->db->aDb[1].pSchema; + p = sqliteHashFirst(&pTmpSchema->trigHash); + pList = pTab->pTrigger; + while( p ){ + Trigger *pTrig = (Trigger *)sqliteHashData(p); + if( pTrig->pTabSchema==pTab->pSchema + && pTrig->table + && 0==sqlite3StrICmp(pTrig->table, pTab->zName) + && (pTrig->pTabSchema!=pTmpSchema || pTrig->bReturning) + ){ + pTrig->pNext = pList; + pList = pTrig; + }else if( pTrig->op==TK_RETURNING ){ +#ifndef SQLITE_OMIT_VIRTUALTABLE + assert( pParse->db->pVtabCtx==0 ); +#endif + assert( pParse->bReturning ); + assert( &(pParse->u1.pReturning->retTrig) == pTrig ); + pTrig->table = pTab->zName; + pTrig->pTabSchema = pTab->pSchema; + pTrig->pNext = pList; + pList = pTrig; + } + p = sqliteHashNext(p); + } +#if 0 + if( pList ){ + Trigger *pX; + printf("Triggers for %s:", pTab->zName); + for(pX=pList; pX; pX=pX->pNext){ + printf(" %s", pX->zName); + } + printf("\n"); + fflush(stdout); + } +#endif + return pList; +} + +/* +** This is called by the parser when it sees a CREATE TRIGGER statement +** up to the point of the BEGIN before the trigger actions. A Trigger +** structure is generated based on the information available and stored +** in pParse->pNewTrigger. After the trigger actions have been parsed, the +** sqlite3FinishTrigger() function is called to complete the trigger +** construction process. +*/ +SQLITE_PRIVATE void sqlite3BeginTrigger( + Parse *pParse, /* The parse context of the CREATE TRIGGER statement */ + Token *pName1, /* The name of the trigger */ + Token *pName2, /* The name of the trigger */ + int tr_tm, /* One of TK_BEFORE, TK_AFTER, TK_INSTEAD */ + int op, /* One of TK_INSERT, TK_UPDATE, TK_DELETE */ + IdList *pColumns, /* column list if this is an UPDATE OF trigger */ + SrcList *pTableName,/* The name of the table/view the trigger applies to */ + Expr *pWhen, /* WHEN clause */ + int isTemp, /* True if the TEMPORARY keyword is present */ + int noErr /* Suppress errors if the trigger already exists */ +){ + Trigger *pTrigger = 0; /* The new trigger */ + Table *pTab; /* Table that the trigger fires off of */ + char *zName = 0; /* Name of the trigger */ + sqlite3 *db = pParse->db; /* The database connection */ + int iDb; /* The database to store the trigger in */ + Token *pName; /* The unqualified db name */ + DbFixer sFix; /* State vector for the DB fixer */ + + assert( pName1!=0 ); /* pName1->z might be NULL, but not pName1 itself */ + assert( pName2!=0 ); + assert( op==TK_INSERT || op==TK_UPDATE || op==TK_DELETE ); + assert( op>0 && op<0xff ); + if( isTemp ){ + /* If TEMP was specified, then the trigger name may not be qualified. */ + if( pName2->n>0 ){ + sqlite3ErrorMsg(pParse, "temporary trigger may not have qualified name"); + goto trigger_cleanup; + } + iDb = 1; + pName = pName1; + }else{ + /* Figure out the db that the trigger will be created in */ + iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName); + if( iDb<0 ){ + goto trigger_cleanup; + } + } + if( !pTableName || db->mallocFailed ){ + goto trigger_cleanup; + } + + /* A long-standing parser bug is that this syntax was allowed: + ** + ** CREATE TRIGGER attached.demo AFTER INSERT ON attached.tab .... + ** ^^^^^^^^ + ** + ** To maintain backwards compatibility, ignore the database + ** name on pTableName if we are reparsing out of the schema table + */ + if( db->init.busy && iDb!=1 ){ + sqlite3DbFree(db, pTableName->a[0].zDatabase); + pTableName->a[0].zDatabase = 0; + } + + /* If the trigger name was unqualified, and the table is a temp table, + ** then set iDb to 1 to create the trigger in the temporary database. + ** If sqlite3SrcListLookup() returns 0, indicating the table does not + ** exist, the error is caught by the block below. + */ + pTab = sqlite3SrcListLookup(pParse, pTableName); + if( db->init.busy==0 && pName2->n==0 && pTab + && pTab->pSchema==db->aDb[1].pSchema ){ + iDb = 1; + } + + /* Ensure the table name matches database name and that the table exists */ + if( db->mallocFailed ) goto trigger_cleanup; + assert( pTableName->nSrc==1 ); + sqlite3FixInit(&sFix, pParse, iDb, "trigger", pName); + if( sqlite3FixSrcList(&sFix, pTableName) ){ + goto trigger_cleanup; + } + pTab = sqlite3SrcListLookup(pParse, pTableName); + if( !pTab ){ + /* The table does not exist. */ + goto trigger_orphan_error; + } + if( IsVirtual(pTab) ){ + sqlite3ErrorMsg(pParse, "cannot create triggers on virtual tables"); + goto trigger_orphan_error; + } + + /* Check that the trigger name is not reserved and that no trigger of the + ** specified name exists */ + zName = sqlite3NameFromToken(db, pName); + if( zName==0 ){ + assert( db->mallocFailed ); + goto trigger_cleanup; + } + if( sqlite3CheckObjectName(pParse, zName, "trigger", pTab->zName) ){ + goto trigger_cleanup; + } + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + if( !IN_RENAME_OBJECT ){ + if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),zName) ){ + if( !noErr ){ + sqlite3ErrorMsg(pParse, "trigger %T already exists", pName); + }else{ + assert( !db->init.busy ); + sqlite3CodeVerifySchema(pParse, iDb); + VVA_ONLY( pParse->ifNotExists = 1; ) + } + goto trigger_cleanup; + } + } + + /* Do not create a trigger on a system table */ + if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){ + sqlite3ErrorMsg(pParse, "cannot create trigger on system table"); + goto trigger_cleanup; + } + + /* INSTEAD of triggers are only for views and views only support INSTEAD + ** of triggers. + */ + if( IsView(pTab) && tr_tm!=TK_INSTEAD ){ + sqlite3ErrorMsg(pParse, "cannot create %s trigger on view: %S", + (tr_tm == TK_BEFORE)?"BEFORE":"AFTER", pTableName->a); + goto trigger_orphan_error; + } + if( !IsView(pTab) && tr_tm==TK_INSTEAD ){ + sqlite3ErrorMsg(pParse, "cannot create INSTEAD OF" + " trigger on table: %S", pTableName->a); + goto trigger_orphan_error; + } + +#ifndef SQLITE_OMIT_AUTHORIZATION + if( !IN_RENAME_OBJECT ){ + int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema); + int code = SQLITE_CREATE_TRIGGER; + const char *zDb = db->aDb[iTabDb].zDbSName; + const char *zDbTrig = isTemp ? db->aDb[1].zDbSName : zDb; + if( iTabDb==1 || isTemp ) code = SQLITE_CREATE_TEMP_TRIGGER; + if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){ + goto trigger_cleanup; + } + if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iTabDb),0,zDb)){ + goto trigger_cleanup; + } + } +#endif + + /* INSTEAD OF triggers can only appear on views and BEFORE triggers + ** cannot appear on views. So we might as well translate every + ** INSTEAD OF trigger into a BEFORE trigger. It simplifies code + ** elsewhere. + */ + if (tr_tm == TK_INSTEAD){ + tr_tm = TK_BEFORE; + } + + /* Build the Trigger object */ + pTrigger = (Trigger*)sqlite3DbMallocZero(db, sizeof(Trigger)); + if( pTrigger==0 ) goto trigger_cleanup; + pTrigger->zName = zName; + zName = 0; + pTrigger->table = sqlite3DbStrDup(db, pTableName->a[0].zName); + pTrigger->pSchema = db->aDb[iDb].pSchema; + pTrigger->pTabSchema = pTab->pSchema; + pTrigger->op = (u8)op; + pTrigger->tr_tm = tr_tm==TK_BEFORE ? TRIGGER_BEFORE : TRIGGER_AFTER; + if( IN_RENAME_OBJECT ){ + sqlite3RenameTokenRemap(pParse, pTrigger->table, pTableName->a[0].zName); + pTrigger->pWhen = pWhen; + pWhen = 0; + }else{ + pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE); + } + pTrigger->pColumns = pColumns; + pColumns = 0; + assert( pParse->pNewTrigger==0 ); + pParse->pNewTrigger = pTrigger; + +trigger_cleanup: + sqlite3DbFree(db, zName); + sqlite3SrcListDelete(db, pTableName); + sqlite3IdListDelete(db, pColumns); + sqlite3ExprDelete(db, pWhen); + if( !pParse->pNewTrigger ){ + sqlite3DeleteTrigger(db, pTrigger); + }else{ + assert( pParse->pNewTrigger==pTrigger ); + } + return; + +trigger_orphan_error: + if( db->init.iDb==1 ){ + /* Ticket #3810. + ** Normally, whenever a table is dropped, all associated triggers are + ** dropped too. But if a TEMP trigger is created on a non-TEMP table + ** and the table is dropped by a different database connection, the + ** trigger is not visible to the database connection that does the + ** drop so the trigger cannot be dropped. This results in an + ** "orphaned trigger" - a trigger whose associated table is missing. + ** + ** 2020-11-05 see also https://sqlite.org/forum/forumpost/157dc791df + */ + db->init.orphanTrigger = 1; + } + goto trigger_cleanup; +} + +/* +** This routine is called after all of the trigger actions have been parsed +** in order to complete the process of building the trigger. +*/ +SQLITE_PRIVATE void sqlite3FinishTrigger( + Parse *pParse, /* Parser context */ + TriggerStep *pStepList, /* The triggered program */ + Token *pAll /* Token that describes the complete CREATE TRIGGER */ +){ + Trigger *pTrig = pParse->pNewTrigger; /* Trigger being finished */ + char *zName; /* Name of trigger */ + sqlite3 *db = pParse->db; /* The database */ + DbFixer sFix; /* Fixer object */ + int iDb; /* Database containing the trigger */ + Token nameToken; /* Trigger name for error reporting */ + + pParse->pNewTrigger = 0; + if( NEVER(pParse->nErr) || !pTrig ) goto triggerfinish_cleanup; + zName = pTrig->zName; + iDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema); + pTrig->step_list = pStepList; + while( pStepList ){ + pStepList->pTrig = pTrig; + pStepList = pStepList->pNext; + } + sqlite3TokenInit(&nameToken, pTrig->zName); + sqlite3FixInit(&sFix, pParse, iDb, "trigger", &nameToken); + if( sqlite3FixTriggerStep(&sFix, pTrig->step_list) + || sqlite3FixExpr(&sFix, pTrig->pWhen) + ){ + goto triggerfinish_cleanup; + } + +#ifndef SQLITE_OMIT_ALTERTABLE + if( IN_RENAME_OBJECT ){ + assert( !db->init.busy ); + pParse->pNewTrigger = pTrig; + pTrig = 0; + }else +#endif + + /* if we are not initializing, + ** build the sqlite_schema entry + */ + if( !db->init.busy ){ + Vdbe *v; + char *z; + + /* If this is a new CREATE TABLE statement, and if shadow tables + ** are read-only, and the trigger makes a change to a shadow table, + ** then raise an error - do not allow the trigger to be created. */ + if( sqlite3ReadOnlyShadowTables(db) ){ + TriggerStep *pStep; + for(pStep=pTrig->step_list; pStep; pStep=pStep->pNext){ + if( pStep->zTarget!=0 + && sqlite3ShadowTableName(db, pStep->zTarget) + ){ + sqlite3ErrorMsg(pParse, + "trigger \"%s\" may not write to shadow table \"%s\"", + pTrig->zName, pStep->zTarget); + goto triggerfinish_cleanup; + } + } + } + + /* Make an entry in the sqlite_schema table */ + v = sqlite3GetVdbe(pParse); + if( v==0 ) goto triggerfinish_cleanup; + sqlite3BeginWriteOperation(pParse, 0, iDb); + z = sqlite3DbStrNDup(db, (char*)pAll->z, pAll->n); + testcase( z==0 ); + sqlite3NestedParse(pParse, + "INSERT INTO %Q." LEGACY_SCHEMA_TABLE + " VALUES('trigger',%Q,%Q,0,'CREATE TRIGGER %q')", + db->aDb[iDb].zDbSName, zName, + pTrig->table, z); + sqlite3DbFree(db, z); + sqlite3ChangeCookie(pParse, iDb); + sqlite3VdbeAddParseSchemaOp(v, iDb, + sqlite3MPrintf(db, "type='trigger' AND name='%q'", zName), 0); + } + + if( db->init.busy ){ + Trigger *pLink = pTrig; + Hash *pHash = &db->aDb[iDb].pSchema->trigHash; + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + assert( pLink!=0 ); + pTrig = sqlite3HashInsert(pHash, zName, pTrig); + if( pTrig ){ + sqlite3OomFault(db); + }else if( pLink->pSchema==pLink->pTabSchema ){ + Table *pTab; + pTab = sqlite3HashFind(&pLink->pTabSchema->tblHash, pLink->table); + assert( pTab!=0 ); + pLink->pNext = pTab->pTrigger; + pTab->pTrigger = pLink; + } + } + +triggerfinish_cleanup: + sqlite3DeleteTrigger(db, pTrig); + assert( IN_RENAME_OBJECT || !pParse->pNewTrigger ); + sqlite3DeleteTriggerStep(db, pStepList); +} + +/* +** Duplicate a range of text from an SQL statement, then convert all +** whitespace characters into ordinary space characters. +*/ +static char *triggerSpanDup(sqlite3 *db, const char *zStart, const char *zEnd){ + char *z = sqlite3DbSpanDup(db, zStart, zEnd); + int i; + if( z ) for(i=0; z[i]; i++) if( sqlite3Isspace(z[i]) ) z[i] = ' '; + return z; +} + +/* +** Turn a SELECT statement (that the pSelect parameter points to) into +** a trigger step. Return a pointer to a TriggerStep structure. +** +** The parser calls this routine when it finds a SELECT statement in +** body of a TRIGGER. +*/ +SQLITE_PRIVATE TriggerStep *sqlite3TriggerSelectStep( + sqlite3 *db, /* Database connection */ + Select *pSelect, /* The SELECT statement */ + const char *zStart, /* Start of SQL text */ + const char *zEnd /* End of SQL text */ +){ + TriggerStep *pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep)); + if( pTriggerStep==0 ) { + sqlite3SelectDelete(db, pSelect); + return 0; + } + pTriggerStep->op = TK_SELECT; + pTriggerStep->pSelect = pSelect; + pTriggerStep->orconf = OE_Default; + pTriggerStep->zSpan = triggerSpanDup(db, zStart, zEnd); + return pTriggerStep; +} + +/* +** Allocate space to hold a new trigger step. The allocated space +** holds both the TriggerStep object and the TriggerStep.target.z string. +** +** If an OOM error occurs, NULL is returned and db->mallocFailed is set. +*/ +static TriggerStep *triggerStepAllocate( + Parse *pParse, /* Parser context */ + u8 op, /* Trigger opcode */ + Token *pName, /* The target name */ + const char *zStart, /* Start of SQL text */ + const char *zEnd /* End of SQL text */ +){ + sqlite3 *db = pParse->db; + TriggerStep *pTriggerStep; + + if( pParse->nErr ) return 0; + pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep) + pName->n + 1); + if( pTriggerStep ){ + char *z = (char*)&pTriggerStep[1]; + memcpy(z, pName->z, pName->n); + sqlite3Dequote(z); + pTriggerStep->zTarget = z; + pTriggerStep->op = op; + pTriggerStep->zSpan = triggerSpanDup(db, zStart, zEnd); + if( IN_RENAME_OBJECT ){ + sqlite3RenameTokenMap(pParse, pTriggerStep->zTarget, pName); + } + } + return pTriggerStep; +} + +/* +** Build a trigger step out of an INSERT statement. Return a pointer +** to the new trigger step. +** +** The parser calls this routine when it sees an INSERT inside the +** body of a trigger. +*/ +SQLITE_PRIVATE TriggerStep *sqlite3TriggerInsertStep( + Parse *pParse, /* Parser */ + Token *pTableName, /* Name of the table into which we insert */ + IdList *pColumn, /* List of columns in pTableName to insert into */ + Select *pSelect, /* A SELECT statement that supplies values */ + u8 orconf, /* The conflict algorithm (OE_Abort, OE_Replace, etc.) */ + Upsert *pUpsert, /* ON CONFLICT clauses for upsert */ + const char *zStart, /* Start of SQL text */ + const char *zEnd /* End of SQL text */ +){ + sqlite3 *db = pParse->db; + TriggerStep *pTriggerStep; + + assert(pSelect != 0 || db->mallocFailed); + + pTriggerStep = triggerStepAllocate(pParse, TK_INSERT, pTableName,zStart,zEnd); + if( pTriggerStep ){ + if( IN_RENAME_OBJECT ){ + pTriggerStep->pSelect = pSelect; + pSelect = 0; + }else{ + pTriggerStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE); + } + pTriggerStep->pIdList = pColumn; + pTriggerStep->pUpsert = pUpsert; + pTriggerStep->orconf = orconf; + if( pUpsert ){ + sqlite3HasExplicitNulls(pParse, pUpsert->pUpsertTarget); + } + }else{ + testcase( pColumn ); + sqlite3IdListDelete(db, pColumn); + testcase( pUpsert ); + sqlite3UpsertDelete(db, pUpsert); + } + sqlite3SelectDelete(db, pSelect); + + return pTriggerStep; +} + +/* +** Construct a trigger step that implements an UPDATE statement and return +** a pointer to that trigger step. The parser calls this routine when it +** sees an UPDATE statement inside the body of a CREATE TRIGGER. +*/ +SQLITE_PRIVATE TriggerStep *sqlite3TriggerUpdateStep( + Parse *pParse, /* Parser */ + Token *pTableName, /* Name of the table to be updated */ + SrcList *pFrom, /* FROM clause for an UPDATE-FROM, or NULL */ + ExprList *pEList, /* The SET clause: list of column and new values */ + Expr *pWhere, /* The WHERE clause */ + u8 orconf, /* The conflict algorithm. (OE_Abort, OE_Ignore, etc) */ + const char *zStart, /* Start of SQL text */ + const char *zEnd /* End of SQL text */ +){ + sqlite3 *db = pParse->db; + TriggerStep *pTriggerStep; + + pTriggerStep = triggerStepAllocate(pParse, TK_UPDATE, pTableName,zStart,zEnd); + if( pTriggerStep ){ + if( IN_RENAME_OBJECT ){ + pTriggerStep->pExprList = pEList; + pTriggerStep->pWhere = pWhere; + pTriggerStep->pFrom = pFrom; + pEList = 0; + pWhere = 0; + pFrom = 0; + }else{ + pTriggerStep->pExprList = sqlite3ExprListDup(db, pEList, EXPRDUP_REDUCE); + pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE); + pTriggerStep->pFrom = sqlite3SrcListDup(db, pFrom, EXPRDUP_REDUCE); + } + pTriggerStep->orconf = orconf; + } + sqlite3ExprListDelete(db, pEList); + sqlite3ExprDelete(db, pWhere); + sqlite3SrcListDelete(db, pFrom); + return pTriggerStep; +} + +/* +** Construct a trigger step that implements a DELETE statement and return +** a pointer to that trigger step. The parser calls this routine when it +** sees a DELETE statement inside the body of a CREATE TRIGGER. +*/ +SQLITE_PRIVATE TriggerStep *sqlite3TriggerDeleteStep( + Parse *pParse, /* Parser */ + Token *pTableName, /* The table from which rows are deleted */ + Expr *pWhere, /* The WHERE clause */ + const char *zStart, /* Start of SQL text */ + const char *zEnd /* End of SQL text */ +){ + sqlite3 *db = pParse->db; + TriggerStep *pTriggerStep; + + pTriggerStep = triggerStepAllocate(pParse, TK_DELETE, pTableName,zStart,zEnd); + if( pTriggerStep ){ + if( IN_RENAME_OBJECT ){ + pTriggerStep->pWhere = pWhere; + pWhere = 0; + }else{ + pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE); + } + pTriggerStep->orconf = OE_Default; + } + sqlite3ExprDelete(db, pWhere); + return pTriggerStep; +} + +/* +** Recursively delete a Trigger structure +*/ +SQLITE_PRIVATE void sqlite3DeleteTrigger(sqlite3 *db, Trigger *pTrigger){ + if( pTrigger==0 || pTrigger->bReturning ) return; + sqlite3DeleteTriggerStep(db, pTrigger->step_list); + sqlite3DbFree(db, pTrigger->zName); + sqlite3DbFree(db, pTrigger->table); + sqlite3ExprDelete(db, pTrigger->pWhen); + sqlite3IdListDelete(db, pTrigger->pColumns); + sqlite3DbFree(db, pTrigger); +} + +/* +** This function is called to drop a trigger from the database schema. +** +** This may be called directly from the parser and therefore identifies +** the trigger by name. The sqlite3DropTriggerPtr() routine does the +** same job as this routine except it takes a pointer to the trigger +** instead of the trigger name. +**/ +SQLITE_PRIVATE void sqlite3DropTrigger(Parse *pParse, SrcList *pName, int noErr){ + Trigger *pTrigger = 0; + int i; + const char *zDb; + const char *zName; + sqlite3 *db = pParse->db; + + if( db->mallocFailed ) goto drop_trigger_cleanup; + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + goto drop_trigger_cleanup; + } + + assert( pName->nSrc==1 ); + zDb = pName->a[0].zDatabase; + zName = pName->a[0].zName; + assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) ); + for(i=OMIT_TEMPDB; inDb; i++){ + int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */ + if( zDb && sqlite3DbIsNamed(db, j, zDb)==0 ) continue; + assert( sqlite3SchemaMutexHeld(db, j, 0) ); + pTrigger = sqlite3HashFind(&(db->aDb[j].pSchema->trigHash), zName); + if( pTrigger ) break; + } + if( !pTrigger ){ + if( !noErr ){ + sqlite3ErrorMsg(pParse, "no such trigger: %S", pName->a); + }else{ + sqlite3CodeVerifyNamedSchema(pParse, zDb); + } + pParse->checkSchema = 1; + goto drop_trigger_cleanup; + } + sqlite3DropTriggerPtr(pParse, pTrigger); + +drop_trigger_cleanup: + sqlite3SrcListDelete(db, pName); +} + +/* +** Return a pointer to the Table structure for the table that a trigger +** is set on. +*/ +static Table *tableOfTrigger(Trigger *pTrigger){ + return sqlite3HashFind(&pTrigger->pTabSchema->tblHash, pTrigger->table); +} + + +/* +** Drop a trigger given a pointer to that trigger. +*/ +SQLITE_PRIVATE void sqlite3DropTriggerPtr(Parse *pParse, Trigger *pTrigger){ + Table *pTable; + Vdbe *v; + sqlite3 *db = pParse->db; + int iDb; + + iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema); + assert( iDb>=0 && iDbnDb ); + pTable = tableOfTrigger(pTrigger); + assert( (pTable && pTable->pSchema==pTrigger->pSchema) || iDb==1 ); +#ifndef SQLITE_OMIT_AUTHORIZATION + if( pTable ){ + int code = SQLITE_DROP_TRIGGER; + const char *zDb = db->aDb[iDb].zDbSName; + const char *zTab = SCHEMA_TABLE(iDb); + if( iDb==1 ) code = SQLITE_DROP_TEMP_TRIGGER; + if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) || + sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){ + return; + } + } +#endif + + /* Generate code to destroy the database record of the trigger. + */ + if( (v = sqlite3GetVdbe(pParse))!=0 ){ + sqlite3NestedParse(pParse, + "DELETE FROM %Q." LEGACY_SCHEMA_TABLE " WHERE name=%Q AND type='trigger'", + db->aDb[iDb].zDbSName, pTrigger->zName + ); + sqlite3ChangeCookie(pParse, iDb); + sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0); + } +} + +/* +** Remove a trigger from the hash tables of the sqlite* pointer. +*/ +SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){ + Trigger *pTrigger; + Hash *pHash; + + assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); + pHash = &(db->aDb[iDb].pSchema->trigHash); + pTrigger = sqlite3HashInsert(pHash, zName, 0); + if( ALWAYS(pTrigger) ){ + if( pTrigger->pSchema==pTrigger->pTabSchema ){ + Table *pTab = tableOfTrigger(pTrigger); + if( pTab ){ + Trigger **pp; + for(pp=&pTab->pTrigger; *pp; pp=&((*pp)->pNext)){ + if( *pp==pTrigger ){ + *pp = (*pp)->pNext; + break; + } + } + } + } + sqlite3DeleteTrigger(db, pTrigger); + db->mDbFlags |= DBFLAG_SchemaChange; + } +} + +/* +** pEList is the SET clause of an UPDATE statement. Each entry +** in pEList is of the format =. If any of the entries +** in pEList have an which matches an identifier in pIdList, +** then return TRUE. If pIdList==NULL, then it is considered a +** wildcard that matches anything. Likewise if pEList==NULL then +** it matches anything so always return true. Return false only +** if there is no match. +*/ +static int checkColumnOverlap(IdList *pIdList, ExprList *pEList){ + int e; + if( pIdList==0 || NEVER(pEList==0) ) return 1; + for(e=0; enExpr; e++){ + if( sqlite3IdListIndex(pIdList, pEList->a[e].zEName)>=0 ) return 1; + } + return 0; +} + +/* +** Return true if any TEMP triggers exist +*/ +static int tempTriggersExist(sqlite3 *db){ + if( NEVER(db->aDb[1].pSchema==0) ) return 0; + if( sqliteHashFirst(&db->aDb[1].pSchema->trigHash)==0 ) return 0; + return 1; +} + +/* +** Return a list of all triggers on table pTab if there exists at least +** one trigger that must be fired when an operation of type 'op' is +** performed on the table, and, if that operation is an UPDATE, if at +** least one of the columns in pChanges is being modified. +*/ +static SQLITE_NOINLINE Trigger *triggersReallyExist( + Parse *pParse, /* Parse context */ + Table *pTab, /* The table the contains the triggers */ + int op, /* one of TK_DELETE, TK_INSERT, TK_UPDATE */ + ExprList *pChanges, /* Columns that change in an UPDATE statement */ + int *pMask /* OUT: Mask of TRIGGER_BEFORE|TRIGGER_AFTER */ +){ + int mask = 0; + Trigger *pList = 0; + Trigger *p; + + pList = sqlite3TriggerList(pParse, pTab); + assert( pList==0 || IsVirtual(pTab)==0 + || (pList->bReturning && pList->pNext==0) ); + if( pList!=0 ){ + p = pList; + if( (pParse->db->flags & SQLITE_EnableTrigger)==0 + && pTab->pTrigger!=0 + ){ + /* The SQLITE_DBCONFIG_ENABLE_TRIGGER setting is off. That means that + ** only TEMP triggers are allowed. Truncate the pList so that it + ** includes only TEMP triggers */ + if( pList==pTab->pTrigger ){ + pList = 0; + goto exit_triggers_exist; + } + while( ALWAYS(p->pNext) && p->pNext!=pTab->pTrigger ) p = p->pNext; + p->pNext = 0; + p = pList; + } + do{ + if( p->op==op && checkColumnOverlap(p->pColumns, pChanges) ){ + mask |= p->tr_tm; + }else if( p->op==TK_RETURNING ){ + /* The first time a RETURNING trigger is seen, the "op" value tells + ** us what time of trigger it should be. */ + assert( sqlite3IsToplevel(pParse) ); + p->op = op; + if( IsVirtual(pTab) ){ + if( op!=TK_INSERT ){ + sqlite3ErrorMsg(pParse, + "%s RETURNING is not available on virtual tables", + op==TK_DELETE ? "DELETE" : "UPDATE"); + } + p->tr_tm = TRIGGER_BEFORE; + }else{ + p->tr_tm = TRIGGER_AFTER; + } + mask |= p->tr_tm; + }else if( p->bReturning && p->op==TK_INSERT && op==TK_UPDATE + && sqlite3IsToplevel(pParse) ){ + /* Also fire a RETURNING trigger for an UPSERT */ + mask |= p->tr_tm; + } + p = p->pNext; + }while( p ); + } +exit_triggers_exist: + if( pMask ){ + *pMask = mask; + } + return (mask ? pList : 0); +} +SQLITE_PRIVATE Trigger *sqlite3TriggersExist( + Parse *pParse, /* Parse context */ + Table *pTab, /* The table the contains the triggers */ + int op, /* one of TK_DELETE, TK_INSERT, TK_UPDATE */ + ExprList *pChanges, /* Columns that change in an UPDATE statement */ + int *pMask /* OUT: Mask of TRIGGER_BEFORE|TRIGGER_AFTER */ +){ + assert( pTab!=0 ); + if( (pTab->pTrigger==0 && !tempTriggersExist(pParse->db)) + || pParse->disableTriggers + ){ + if( pMask ) *pMask = 0; + return 0; + } + return triggersReallyExist(pParse,pTab,op,pChanges,pMask); +} + +/* +** Convert the pStep->zTarget string into a SrcList and return a pointer +** to that SrcList. +** +** This routine adds a specific database name, if needed, to the target when +** forming the SrcList. This prevents a trigger in one database from +** referring to a target in another database. An exception is when the +** trigger is in TEMP in which case it can refer to any other database it +** wants. +*/ +SQLITE_PRIVATE SrcList *sqlite3TriggerStepSrc( + Parse *pParse, /* The parsing context */ + TriggerStep *pStep /* The trigger containing the target token */ +){ + sqlite3 *db = pParse->db; + SrcList *pSrc; /* SrcList to be returned */ + char *zName = sqlite3DbStrDup(db, pStep->zTarget); + pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0); + assert( pSrc==0 || pSrc->nSrc==1 ); + assert( zName || pSrc==0 ); + if( pSrc ){ + Schema *pSchema = pStep->pTrig->pSchema; + pSrc->a[0].zName = zName; + if( pSchema!=db->aDb[1].pSchema ){ + pSrc->a[0].pSchema = pSchema; + } + if( pStep->pFrom ){ + SrcList *pDup = sqlite3SrcListDup(db, pStep->pFrom, 0); + if( pDup && pDup->nSrc>1 && !IN_RENAME_OBJECT ){ + Select *pSubquery; + Token as; + pSubquery = sqlite3SelectNew(pParse,0,pDup,0,0,0,0,SF_NestedFrom,0); + as.n = 0; + as.z = 0; + pDup = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&as,pSubquery,0); + } + pSrc = sqlite3SrcListAppendList(pParse, pSrc, pDup); + } + }else{ + sqlite3DbFree(db, zName); + } + return pSrc; +} + +/* +** Return true if the pExpr term from the RETURNING clause argument +** list is of the form "*". Raise an error if the terms if of the +** form "table.*". +*/ +static int isAsteriskTerm( + Parse *pParse, /* Parsing context */ + Expr *pTerm /* A term in the RETURNING clause */ +){ + assert( pTerm!=0 ); + if( pTerm->op==TK_ASTERISK ) return 1; + if( pTerm->op!=TK_DOT ) return 0; + assert( pTerm->pRight!=0 ); + assert( pTerm->pLeft!=0 ); + if( pTerm->pRight->op!=TK_ASTERISK ) return 0; + sqlite3ErrorMsg(pParse, "RETURNING may not use \"TABLE.*\" wildcards"); + return 1; +} + +/* The input list pList is the list of result set terms from a RETURNING +** clause. The table that we are returning from is pTab. +** +** This routine makes a copy of the pList, and at the same time expands +** any "*" wildcards to be the complete set of columns from pTab. +*/ +static ExprList *sqlite3ExpandReturning( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* The arguments to RETURNING */ + Table *pTab /* The table being updated */ +){ + ExprList *pNew = 0; + sqlite3 *db = pParse->db; + int i; + + for(i=0; inExpr; i++){ + Expr *pOldExpr = pList->a[i].pExpr; + if( NEVER(pOldExpr==0) ) continue; + if( isAsteriskTerm(pParse, pOldExpr) ){ + int jj; + for(jj=0; jjnCol; jj++){ + Expr *pNewExpr; + if( IsHiddenColumn(pTab->aCol+jj) ) continue; + pNewExpr = sqlite3Expr(db, TK_ID, pTab->aCol[jj].zCnName); + pNew = sqlite3ExprListAppend(pParse, pNew, pNewExpr); + if( !db->mallocFailed ){ + struct ExprList_item *pItem = &pNew->a[pNew->nExpr-1]; + pItem->zEName = sqlite3DbStrDup(db, pTab->aCol[jj].zCnName); + pItem->fg.eEName = ENAME_NAME; + } + } + }else{ + Expr *pNewExpr = sqlite3ExprDup(db, pOldExpr, 0); + pNew = sqlite3ExprListAppend(pParse, pNew, pNewExpr); + if( !db->mallocFailed && ALWAYS(pList->a[i].zEName!=0) ){ + struct ExprList_item *pItem = &pNew->a[pNew->nExpr-1]; + pItem->zEName = sqlite3DbStrDup(db, pList->a[i].zEName); + pItem->fg.eEName = pList->a[i].fg.eEName; + } + } + } + return pNew; +} + +/* +** Generate code for the RETURNING trigger. Unlike other triggers +** that invoke a subprogram in the bytecode, the code for RETURNING +** is generated in-line. +*/ +static void codeReturningTrigger( + Parse *pParse, /* Parse context */ + Trigger *pTrigger, /* The trigger step that defines the RETURNING */ + Table *pTab, /* The table to code triggers from */ + int regIn /* The first in an array of registers */ +){ + Vdbe *v = pParse->pVdbe; + sqlite3 *db = pParse->db; + ExprList *pNew; + Returning *pReturning; + Select sSelect; + SrcList sFrom; + + assert( v!=0 ); + assert( pParse->bReturning ); + assert( db->pParse==pParse ); + pReturning = pParse->u1.pReturning; + assert( pTrigger == &(pReturning->retTrig) ); + memset(&sSelect, 0, sizeof(sSelect)); + memset(&sFrom, 0, sizeof(sFrom)); + sSelect.pEList = sqlite3ExprListDup(db, pReturning->pReturnEL, 0); + sSelect.pSrc = &sFrom; + sFrom.nSrc = 1; + sFrom.a[0].pTab = pTab; + sFrom.a[0].iCursor = -1; + sqlite3SelectPrep(pParse, &sSelect, 0); + if( pParse->nErr==0 ){ + assert( db->mallocFailed==0 ); + sqlite3GenerateColumnNames(pParse, &sSelect); + } + sqlite3ExprListDelete(db, sSelect.pEList); + pNew = sqlite3ExpandReturning(pParse, pReturning->pReturnEL, pTab); + if( pParse->nErr==0 ){ + NameContext sNC; + memset(&sNC, 0, sizeof(sNC)); + if( pReturning->nRetCol==0 ){ + pReturning->nRetCol = pNew->nExpr; + pReturning->iRetCur = pParse->nTab++; + } + sNC.pParse = pParse; + sNC.uNC.iBaseReg = regIn; + sNC.ncFlags = NC_UBaseReg; + pParse->eTriggerOp = pTrigger->op; + pParse->pTriggerTab = pTab; + if( sqlite3ResolveExprListNames(&sNC, pNew)==SQLITE_OK + && ALWAYS(!db->mallocFailed) + ){ + int i; + int nCol = pNew->nExpr; + int reg = pParse->nMem+1; + pParse->nMem += nCol+2; + pReturning->iRetReg = reg; + for(i=0; ia[i].pExpr; + assert( pCol!=0 ); /* Due to !db->mallocFailed ~9 lines above */ + sqlite3ExprCodeFactorable(pParse, pCol, reg+i); + if( sqlite3ExprAffinity(pCol)==SQLITE_AFF_REAL ){ + sqlite3VdbeAddOp1(v, OP_RealAffinity, reg+i); + } + } + sqlite3VdbeAddOp3(v, OP_MakeRecord, reg, i, reg+i); + sqlite3VdbeAddOp2(v, OP_NewRowid, pReturning->iRetCur, reg+i+1); + sqlite3VdbeAddOp3(v, OP_Insert, pReturning->iRetCur, reg+i, reg+i+1); + } + } + sqlite3ExprListDelete(db, pNew); + pParse->eTriggerOp = 0; + pParse->pTriggerTab = 0; +} + + + +/* +** Generate VDBE code for the statements inside the body of a single +** trigger. +*/ +static int codeTriggerProgram( + Parse *pParse, /* The parser context */ + TriggerStep *pStepList, /* List of statements inside the trigger body */ + int orconf /* Conflict algorithm. (OE_Abort, etc) */ +){ + TriggerStep *pStep; + Vdbe *v = pParse->pVdbe; + sqlite3 *db = pParse->db; + + assert( pParse->pTriggerTab && pParse->pToplevel ); + assert( pStepList ); + assert( v!=0 ); + for(pStep=pStepList; pStep; pStep=pStep->pNext){ + /* Figure out the ON CONFLICT policy that will be used for this step + ** of the trigger program. If the statement that caused this trigger + ** to fire had an explicit ON CONFLICT, then use it. Otherwise, use + ** the ON CONFLICT policy that was specified as part of the trigger + ** step statement. Example: + ** + ** CREATE TRIGGER AFTER INSERT ON t1 BEGIN; + ** INSERT OR REPLACE INTO t2 VALUES(new.a, new.b); + ** END; + ** + ** INSERT INTO t1 ... ; -- insert into t2 uses REPLACE policy + ** INSERT OR IGNORE INTO t1 ... ; -- insert into t2 uses IGNORE policy + */ + pParse->eOrconf = (orconf==OE_Default)?pStep->orconf:(u8)orconf; + assert( pParse->okConstFactor==0 ); + +#ifndef SQLITE_OMIT_TRACE + if( pStep->zSpan ){ + sqlite3VdbeAddOp4(v, OP_Trace, 0x7fffffff, 1, 0, + sqlite3MPrintf(db, "-- %s", pStep->zSpan), + P4_DYNAMIC); + } +#endif + + switch( pStep->op ){ + case TK_UPDATE: { + sqlite3Update(pParse, + sqlite3TriggerStepSrc(pParse, pStep), + sqlite3ExprListDup(db, pStep->pExprList, 0), + sqlite3ExprDup(db, pStep->pWhere, 0), + pParse->eOrconf, 0, 0, 0 + ); + sqlite3VdbeAddOp0(v, OP_ResetCount); + break; + } + case TK_INSERT: { + sqlite3Insert(pParse, + sqlite3TriggerStepSrc(pParse, pStep), + sqlite3SelectDup(db, pStep->pSelect, 0), + sqlite3IdListDup(db, pStep->pIdList), + pParse->eOrconf, + sqlite3UpsertDup(db, pStep->pUpsert) + ); + sqlite3VdbeAddOp0(v, OP_ResetCount); + break; + } + case TK_DELETE: { + sqlite3DeleteFrom(pParse, + sqlite3TriggerStepSrc(pParse, pStep), + sqlite3ExprDup(db, pStep->pWhere, 0), 0, 0 + ); + sqlite3VdbeAddOp0(v, OP_ResetCount); + break; + } + default: assert( pStep->op==TK_SELECT ); { + SelectDest sDest; + Select *pSelect = sqlite3SelectDup(db, pStep->pSelect, 0); + sqlite3SelectDestInit(&sDest, SRT_Discard, 0); + sqlite3Select(pParse, pSelect, &sDest); + sqlite3SelectDelete(db, pSelect); + break; + } + } + } + + return 0; +} + +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS +/* +** This function is used to add VdbeComment() annotations to a VDBE +** program. It is not used in production code, only for debugging. +*/ +static const char *onErrorText(int onError){ + switch( onError ){ + case OE_Abort: return "abort"; + case OE_Rollback: return "rollback"; + case OE_Fail: return "fail"; + case OE_Replace: return "replace"; + case OE_Ignore: return "ignore"; + case OE_Default: return "default"; + } + return "n/a"; +} +#endif + +/* +** Parse context structure pFrom has just been used to create a sub-vdbe +** (trigger program). If an error has occurred, transfer error information +** from pFrom to pTo. +*/ +static void transferParseError(Parse *pTo, Parse *pFrom){ + assert( pFrom->zErrMsg==0 || pFrom->nErr ); + assert( pTo->zErrMsg==0 || pTo->nErr ); + if( pTo->nErr==0 ){ + pTo->zErrMsg = pFrom->zErrMsg; + pTo->nErr = pFrom->nErr; + pTo->rc = pFrom->rc; + }else{ + sqlite3DbFree(pFrom->db, pFrom->zErrMsg); + } +} + +/* +** Create and populate a new TriggerPrg object with a sub-program +** implementing trigger pTrigger with ON CONFLICT policy orconf. +*/ +static TriggerPrg *codeRowTrigger( + Parse *pParse, /* Current parse context */ + Trigger *pTrigger, /* Trigger to code */ + Table *pTab, /* The table pTrigger is attached to */ + int orconf /* ON CONFLICT policy to code trigger program with */ +){ + Parse *pTop = sqlite3ParseToplevel(pParse); + sqlite3 *db = pParse->db; /* Database handle */ + TriggerPrg *pPrg; /* Value to return */ + Expr *pWhen = 0; /* Duplicate of trigger WHEN expression */ + Vdbe *v; /* Temporary VM */ + NameContext sNC; /* Name context for sub-vdbe */ + SubProgram *pProgram = 0; /* Sub-vdbe for trigger program */ + int iEndTrigger = 0; /* Label to jump to if WHEN is false */ + Parse sSubParse; /* Parse context for sub-vdbe */ + + assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) ); + assert( pTop->pVdbe ); + + /* Allocate the TriggerPrg and SubProgram objects. To ensure that they + ** are freed if an error occurs, link them into the Parse.pTriggerPrg + ** list of the top-level Parse object sooner rather than later. */ + pPrg = sqlite3DbMallocZero(db, sizeof(TriggerPrg)); + if( !pPrg ) return 0; + pPrg->pNext = pTop->pTriggerPrg; + pTop->pTriggerPrg = pPrg; + pPrg->pProgram = pProgram = sqlite3DbMallocZero(db, sizeof(SubProgram)); + if( !pProgram ) return 0; + sqlite3VdbeLinkSubProgram(pTop->pVdbe, pProgram); + pPrg->pTrigger = pTrigger; + pPrg->orconf = orconf; + pPrg->aColmask[0] = 0xffffffff; + pPrg->aColmask[1] = 0xffffffff; + + /* Allocate and populate a new Parse context to use for coding the + ** trigger sub-program. */ + sqlite3ParseObjectInit(&sSubParse, db); + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = &sSubParse; + sSubParse.pTriggerTab = pTab; + sSubParse.pToplevel = pTop; + sSubParse.zAuthContext = pTrigger->zName; + sSubParse.eTriggerOp = pTrigger->op; + sSubParse.nQueryLoop = pParse->nQueryLoop; + sSubParse.prepFlags = pParse->prepFlags; + + v = sqlite3GetVdbe(&sSubParse); + if( v ){ + VdbeComment((v, "Start: %s.%s (%s %s%s%s ON %s)", + pTrigger->zName, onErrorText(orconf), + (pTrigger->tr_tm==TRIGGER_BEFORE ? "BEFORE" : "AFTER"), + (pTrigger->op==TK_UPDATE ? "UPDATE" : ""), + (pTrigger->op==TK_INSERT ? "INSERT" : ""), + (pTrigger->op==TK_DELETE ? "DELETE" : ""), + pTab->zName + )); +#ifndef SQLITE_OMIT_TRACE + if( pTrigger->zName ){ + sqlite3VdbeChangeP4(v, -1, + sqlite3MPrintf(db, "-- TRIGGER %s", pTrigger->zName), P4_DYNAMIC + ); + } +#endif + + /* If one was specified, code the WHEN clause. If it evaluates to false + ** (or NULL) the sub-vdbe is immediately halted by jumping to the + ** OP_Halt inserted at the end of the program. */ + if( pTrigger->pWhen ){ + pWhen = sqlite3ExprDup(db, pTrigger->pWhen, 0); + if( db->mallocFailed==0 + && SQLITE_OK==sqlite3ResolveExprNames(&sNC, pWhen) + ){ + iEndTrigger = sqlite3VdbeMakeLabel(&sSubParse); + sqlite3ExprIfFalse(&sSubParse, pWhen, iEndTrigger, SQLITE_JUMPIFNULL); + } + sqlite3ExprDelete(db, pWhen); + } + + /* Code the trigger program into the sub-vdbe. */ + codeTriggerProgram(&sSubParse, pTrigger->step_list, orconf); + + /* Insert an OP_Halt at the end of the sub-program. */ + if( iEndTrigger ){ + sqlite3VdbeResolveLabel(v, iEndTrigger); + } + sqlite3VdbeAddOp0(v, OP_Halt); + VdbeComment((v, "End: %s.%s", pTrigger->zName, onErrorText(orconf))); + transferParseError(pParse, &sSubParse); + + if( pParse->nErr==0 ){ + assert( db->mallocFailed==0 ); + pProgram->aOp = sqlite3VdbeTakeOpArray(v, &pProgram->nOp, &pTop->nMaxArg); + } + pProgram->nMem = sSubParse.nMem; + pProgram->nCsr = sSubParse.nTab; + pProgram->token = (void *)pTrigger; + pPrg->aColmask[0] = sSubParse.oldmask; + pPrg->aColmask[1] = sSubParse.newmask; + sqlite3VdbeDelete(v); + }else{ + transferParseError(pParse, &sSubParse); + } + + assert( !sSubParse.pTriggerPrg && !sSubParse.nMaxArg ); + sqlite3ParseObjectReset(&sSubParse); + return pPrg; +} + +/* +** Return a pointer to a TriggerPrg object containing the sub-program for +** trigger pTrigger with default ON CONFLICT algorithm orconf. If no such +** TriggerPrg object exists, a new object is allocated and populated before +** being returned. +*/ +static TriggerPrg *getRowTrigger( + Parse *pParse, /* Current parse context */ + Trigger *pTrigger, /* Trigger to code */ + Table *pTab, /* The table trigger pTrigger is attached to */ + int orconf /* ON CONFLICT algorithm. */ +){ + Parse *pRoot = sqlite3ParseToplevel(pParse); + TriggerPrg *pPrg; + + assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) ); + + /* It may be that this trigger has already been coded (or is in the + ** process of being coded). If this is the case, then an entry with + ** a matching TriggerPrg.pTrigger field will be present somewhere + ** in the Parse.pTriggerPrg list. Search for such an entry. */ + for(pPrg=pRoot->pTriggerPrg; + pPrg && (pPrg->pTrigger!=pTrigger || pPrg->orconf!=orconf); + pPrg=pPrg->pNext + ); + + /* If an existing TriggerPrg could not be located, create a new one. */ + if( !pPrg ){ + pPrg = codeRowTrigger(pParse, pTrigger, pTab, orconf); + pParse->db->errByteOffset = -1; + } + + return pPrg; +} + +/* +** Generate code for the trigger program associated with trigger p on +** table pTab. The reg, orconf and ignoreJump parameters passed to this +** function are the same as those described in the header function for +** sqlite3CodeRowTrigger() +*/ +SQLITE_PRIVATE void sqlite3CodeRowTriggerDirect( + Parse *pParse, /* Parse context */ + Trigger *p, /* Trigger to code */ + Table *pTab, /* The table to code triggers from */ + int reg, /* Reg array containing OLD.* and NEW.* values */ + int orconf, /* ON CONFLICT policy */ + int ignoreJump /* Instruction to jump to for RAISE(IGNORE) */ +){ + Vdbe *v = sqlite3GetVdbe(pParse); /* Main VM */ + TriggerPrg *pPrg; + pPrg = getRowTrigger(pParse, p, pTab, orconf); + assert( pPrg || pParse->nErr ); + + /* Code the OP_Program opcode in the parent VDBE. P4 of the OP_Program + ** is a pointer to the sub-vdbe containing the trigger program. */ + if( pPrg ){ + int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers)); + + sqlite3VdbeAddOp4(v, OP_Program, reg, ignoreJump, ++pParse->nMem, + (const char *)pPrg->pProgram, P4_SUBPROGRAM); + VdbeComment( + (v, "Call: %s.%s", (p->zName?p->zName:"fkey"), onErrorText(orconf))); + + /* Set the P5 operand of the OP_Program instruction to non-zero if + ** recursive invocation of this trigger program is disallowed. Recursive + ** invocation is disallowed if (a) the sub-program is really a trigger, + ** not a foreign key action, and (b) the flag to enable recursive triggers + ** is clear. */ + sqlite3VdbeChangeP5(v, (u8)bRecursive); + } +} + +/* +** This is called to code the required FOR EACH ROW triggers for an operation +** on table pTab. The operation to code triggers for (INSERT, UPDATE or DELETE) +** is given by the op parameter. The tr_tm parameter determines whether the +** BEFORE or AFTER triggers are coded. If the operation is an UPDATE, then +** parameter pChanges is passed the list of columns being modified. +** +** If there are no triggers that fire at the specified time for the specified +** operation on pTab, this function is a no-op. +** +** The reg argument is the address of the first in an array of registers +** that contain the values substituted for the new.* and old.* references +** in the trigger program. If N is the number of columns in table pTab +** (a copy of pTab->nCol), then registers are populated as follows: +** +** Register Contains +** ------------------------------------------------------ +** reg+0 OLD.rowid +** reg+1 OLD.* value of left-most column of pTab +** ... ... +** reg+N OLD.* value of right-most column of pTab +** reg+N+1 NEW.rowid +** reg+N+2 NEW.* value of left-most column of pTab +** ... ... +** reg+N+N+1 NEW.* value of right-most column of pTab +** +** For ON DELETE triggers, the registers containing the NEW.* values will +** never be accessed by the trigger program, so they are not allocated or +** populated by the caller (there is no data to populate them with anyway). +** Similarly, for ON INSERT triggers the values stored in the OLD.* registers +** are never accessed, and so are not allocated by the caller. So, for an +** ON INSERT trigger, the value passed to this function as parameter reg +** is not a readable register, although registers (reg+N) through +** (reg+N+N+1) are. +** +** Parameter orconf is the default conflict resolution algorithm for the +** trigger program to use (REPLACE, IGNORE etc.). Parameter ignoreJump +** is the instruction that control should jump to if a trigger program +** raises an IGNORE exception. +*/ +SQLITE_PRIVATE void sqlite3CodeRowTrigger( + Parse *pParse, /* Parse context */ + Trigger *pTrigger, /* List of triggers on table pTab */ + int op, /* One of TK_UPDATE, TK_INSERT, TK_DELETE */ + ExprList *pChanges, /* Changes list for any UPDATE OF triggers */ + int tr_tm, /* One of TRIGGER_BEFORE, TRIGGER_AFTER */ + Table *pTab, /* The table to code triggers from */ + int reg, /* The first in an array of registers (see above) */ + int orconf, /* ON CONFLICT policy */ + int ignoreJump /* Instruction to jump to for RAISE(IGNORE) */ +){ + Trigger *p; /* Used to iterate through pTrigger list */ + + assert( op==TK_UPDATE || op==TK_INSERT || op==TK_DELETE ); + assert( tr_tm==TRIGGER_BEFORE || tr_tm==TRIGGER_AFTER ); + assert( (op==TK_UPDATE)==(pChanges!=0) ); + + for(p=pTrigger; p; p=p->pNext){ + + /* Sanity checking: The schema for the trigger and for the table are + ** always defined. The trigger must be in the same schema as the table + ** or else it must be a TEMP trigger. */ + assert( p->pSchema!=0 ); + assert( p->pTabSchema!=0 ); + assert( p->pSchema==p->pTabSchema + || p->pSchema==pParse->db->aDb[1].pSchema ); + + /* Determine whether we should code this trigger. One of two choices: + ** 1. The trigger is an exact match to the current DML statement + ** 2. This is a RETURNING trigger for INSERT but we are currently + ** doing the UPDATE part of an UPSERT. + */ + if( (p->op==op || (p->bReturning && p->op==TK_INSERT && op==TK_UPDATE)) + && p->tr_tm==tr_tm + && checkColumnOverlap(p->pColumns, pChanges) + ){ + if( !p->bReturning ){ + sqlite3CodeRowTriggerDirect(pParse, p, pTab, reg, orconf, ignoreJump); + }else if( sqlite3IsToplevel(pParse) ){ + codeReturningTrigger(pParse, p, pTab, reg); + } + } + } +} + +/* +** Triggers may access values stored in the old.* or new.* pseudo-table. +** This function returns a 32-bit bitmask indicating which columns of the +** old.* or new.* tables actually are used by triggers. This information +** may be used by the caller, for example, to avoid having to load the entire +** old.* record into memory when executing an UPDATE or DELETE command. +** +** Bit 0 of the returned mask is set if the left-most column of the +** table may be accessed using an [old|new].reference. Bit 1 is set if +** the second leftmost column value is required, and so on. If there +** are more than 32 columns in the table, and at least one of the columns +** with an index greater than 32 may be accessed, 0xffffffff is returned. +** +** It is not possible to determine if the old.rowid or new.rowid column is +** accessed by triggers. The caller must always assume that it is. +** +** Parameter isNew must be either 1 or 0. If it is 0, then the mask returned +** applies to the old.* table. If 1, the new.* table. +** +** Parameter tr_tm must be a mask with one or both of the TRIGGER_BEFORE +** and TRIGGER_AFTER bits set. Values accessed by BEFORE triggers are only +** included in the returned mask if the TRIGGER_BEFORE bit is set in the +** tr_tm parameter. Similarly, values accessed by AFTER triggers are only +** included in the returned mask if the TRIGGER_AFTER bit is set in tr_tm. +*/ +SQLITE_PRIVATE u32 sqlite3TriggerColmask( + Parse *pParse, /* Parse context */ + Trigger *pTrigger, /* List of triggers on table pTab */ + ExprList *pChanges, /* Changes list for any UPDATE OF triggers */ + int isNew, /* 1 for new.* ref mask, 0 for old.* ref mask */ + int tr_tm, /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */ + Table *pTab, /* The table to code triggers from */ + int orconf /* Default ON CONFLICT policy for trigger steps */ +){ + const int op = pChanges ? TK_UPDATE : TK_DELETE; + u32 mask = 0; + Trigger *p; + + assert( isNew==1 || isNew==0 ); + if( IsView(pTab) ){ + return 0xffffffff; + } + for(p=pTrigger; p; p=p->pNext){ + if( p->op==op + && (tr_tm&p->tr_tm) + && checkColumnOverlap(p->pColumns,pChanges) + ){ + if( p->bReturning ){ + mask = 0xffffffff; + }else{ + TriggerPrg *pPrg; + pPrg = getRowTrigger(pParse, p, pTab, orconf); + if( pPrg ){ + mask |= pPrg->aColmask[isNew]; + } + } + } + } + + return mask; +} + +#endif /* !defined(SQLITE_OMIT_TRIGGER) */ + +/************** End of trigger.c *********************************************/ +/************** Begin file update.c ******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that are called by the parser +** to handle UPDATE statements. +*/ +/* #include "sqliteInt.h" */ + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* Forward declaration */ +static void updateVirtualTable( + Parse *pParse, /* The parsing context */ + SrcList *pSrc, /* The virtual table to be modified */ + Table *pTab, /* The virtual table */ + ExprList *pChanges, /* The columns to change in the UPDATE statement */ + Expr *pRowidExpr, /* Expression used to recompute the rowid */ + int *aXRef, /* Mapping from columns of pTab to entries in pChanges */ + Expr *pWhere, /* WHERE clause of the UPDATE statement */ + int onError /* ON CONFLICT strategy */ +); +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +/* +** The most recently coded instruction was an OP_Column to retrieve the +** i-th column of table pTab. This routine sets the P4 parameter of the +** OP_Column to the default value, if any. +** +** The default value of a column is specified by a DEFAULT clause in the +** column definition. This was either supplied by the user when the table +** was created, or added later to the table definition by an ALTER TABLE +** command. If the latter, then the row-records in the table btree on disk +** may not contain a value for the column and the default value, taken +** from the P4 parameter of the OP_Column instruction, is returned instead. +** If the former, then all row-records are guaranteed to include a value +** for the column and the P4 value is not required. +** +** Column definitions created by an ALTER TABLE command may only have +** literal default values specified: a number, null or a string. (If a more +** complicated default expression value was provided, it is evaluated +** when the ALTER TABLE is executed and one of the literal values written +** into the sqlite_schema table.) +** +** Therefore, the P4 parameter is only required if the default value for +** the column is a literal number, string or null. The sqlite3ValueFromExpr() +** function is capable of transforming these types of expressions into +** sqlite3_value objects. +** +** If column as REAL affinity and the table is an ordinary b-tree table +** (not a virtual table) then the value might have been stored as an +** integer. In that case, add an OP_RealAffinity opcode to make sure +** it has been converted into REAL. +*/ +SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){ + Column *pCol; + assert( pTab!=0 ); + assert( pTab->nCol>i ); + pCol = &pTab->aCol[i]; + if( pCol->iDflt ){ + sqlite3_value *pValue = 0; + u8 enc = ENC(sqlite3VdbeDb(v)); + assert( !IsView(pTab) ); + VdbeComment((v, "%s.%s", pTab->zName, pCol->zCnName)); + assert( inCol ); + sqlite3ValueFromExpr(sqlite3VdbeDb(v), + sqlite3ColumnExpr(pTab,pCol), enc, + pCol->affinity, &pValue); + if( pValue ){ + sqlite3VdbeAppendP4(v, pValue, P4_MEM); + } + } +#ifndef SQLITE_OMIT_FLOATING_POINT + if( pCol->affinity==SQLITE_AFF_REAL && !IsVirtual(pTab) ){ + sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg); + } +#endif +} + +/* +** Check to see if column iCol of index pIdx references any of the +** columns defined by aXRef and chngRowid. Return true if it does +** and false if not. This is an optimization. False-positives are a +** performance degradation, but false-negatives can result in a corrupt +** index and incorrect answers. +** +** aXRef[j] will be non-negative if column j of the original table is +** being updated. chngRowid will be true if the rowid of the table is +** being updated. +*/ +static int indexColumnIsBeingUpdated( + Index *pIdx, /* The index to check */ + int iCol, /* Which column of the index to check */ + int *aXRef, /* aXRef[j]>=0 if column j is being updated */ + int chngRowid /* true if the rowid is being updated */ +){ + i16 iIdxCol = pIdx->aiColumn[iCol]; + assert( iIdxCol!=XN_ROWID ); /* Cannot index rowid */ + if( iIdxCol>=0 ){ + return aXRef[iIdxCol]>=0; + } + assert( iIdxCol==XN_EXPR ); + assert( pIdx->aColExpr!=0 ); + assert( pIdx->aColExpr->a[iCol].pExpr!=0 ); + return sqlite3ExprReferencesUpdatedColumn(pIdx->aColExpr->a[iCol].pExpr, + aXRef,chngRowid); +} + +/* +** Check to see if index pIdx is a partial index whose conditional +** expression might change values due to an UPDATE. Return true if +** the index is subject to change and false if the index is guaranteed +** to be unchanged. This is an optimization. False-positives are a +** performance degradation, but false-negatives can result in a corrupt +** index and incorrect answers. +** +** aXRef[j] will be non-negative if column j of the original table is +** being updated. chngRowid will be true if the rowid of the table is +** being updated. +*/ +static int indexWhereClauseMightChange( + Index *pIdx, /* The index to check */ + int *aXRef, /* aXRef[j]>=0 if column j is being updated */ + int chngRowid /* true if the rowid is being updated */ +){ + if( pIdx->pPartIdxWhere==0 ) return 0; + return sqlite3ExprReferencesUpdatedColumn(pIdx->pPartIdxWhere, + aXRef, chngRowid); +} + +/* +** Allocate and return a pointer to an expression of type TK_ROW with +** Expr.iColumn set to value (iCol+1). The resolver will modify the +** expression to be a TK_COLUMN reading column iCol of the first +** table in the source-list (pSrc->a[0]). +*/ +static Expr *exprRowColumn(Parse *pParse, int iCol){ + Expr *pRet = sqlite3PExpr(pParse, TK_ROW, 0, 0); + if( pRet ) pRet->iColumn = iCol+1; + return pRet; +} + +/* +** Assuming both the pLimit and pOrderBy parameters are NULL, this function +** generates VM code to run the query: +** +** SELECT , pChanges FROM pTabList WHERE pWhere +** +** and write the results to the ephemeral table already opened as cursor +** iEph. None of pChanges, pTabList or pWhere are modified or consumed by +** this function, they must be deleted by the caller. +** +** Or, if pLimit and pOrderBy are not NULL, and pTab is not a view: +** +** SELECT , pChanges FROM pTabList +** WHERE pWhere +** GROUP BY +** ORDER BY pOrderBy LIMIT pLimit +** +** If pTab is a view, the GROUP BY clause is omitted. +** +** Exactly how results are written to table iEph, and exactly what +** the in the query above are is determined by the type +** of table pTabList->a[0].pTab. +** +** If the table is a WITHOUT ROWID table, then argument pPk must be its +** PRIMARY KEY. In this case are the primary key columns +** of the table, in order. The results of the query are written to ephemeral +** table iEph as index keys, using OP_IdxInsert. +** +** If the table is actually a view, then are all columns of +** the view. The results are written to the ephemeral table iEph as records +** with automatically assigned integer keys. +** +** If the table is a virtual or ordinary intkey table, then +** is its rowid. For a virtual table, the results are written to iEph as +** records with automatically assigned integer keys For intkey tables, the +** rowid value in is used as the integer key, and the +** remaining fields make up the table record. +*/ +static void updateFromSelect( + Parse *pParse, /* Parse context */ + int iEph, /* Cursor for open eph. table */ + Index *pPk, /* PK if table 0 is WITHOUT ROWID */ + ExprList *pChanges, /* List of expressions to return */ + SrcList *pTabList, /* List of tables to select from */ + Expr *pWhere, /* WHERE clause for query */ + ExprList *pOrderBy, /* ORDER BY clause */ + Expr *pLimit /* LIMIT clause */ +){ + int i; + SelectDest dest; + Select *pSelect = 0; + ExprList *pList = 0; + ExprList *pGrp = 0; + Expr *pLimit2 = 0; + ExprList *pOrderBy2 = 0; + sqlite3 *db = pParse->db; + Table *pTab = pTabList->a[0].pTab; + SrcList *pSrc; + Expr *pWhere2; + int eDest; + +#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT + if( pOrderBy && pLimit==0 ) { + sqlite3ErrorMsg(pParse, "ORDER BY without LIMIT on UPDATE"); + return; + } + pOrderBy2 = sqlite3ExprListDup(db, pOrderBy, 0); + pLimit2 = sqlite3ExprDup(db, pLimit, 0); +#else + UNUSED_PARAMETER(pOrderBy); + UNUSED_PARAMETER(pLimit); +#endif + + pSrc = sqlite3SrcListDup(db, pTabList, 0); + pWhere2 = sqlite3ExprDup(db, pWhere, 0); + + assert( pTabList->nSrc>1 ); + if( pSrc ){ + pSrc->a[0].fg.notCte = 1; + pSrc->a[0].iCursor = -1; + pSrc->a[0].pTab->nTabRef--; + pSrc->a[0].pTab = 0; + } + if( pPk ){ + for(i=0; inKeyCol; i++){ + Expr *pNew = exprRowColumn(pParse, pPk->aiColumn[i]); +#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT + if( pLimit ){ + pGrp = sqlite3ExprListAppend(pParse, pGrp, sqlite3ExprDup(db, pNew, 0)); + } +#endif + pList = sqlite3ExprListAppend(pParse, pList, pNew); + } + eDest = IsVirtual(pTab) ? SRT_Table : SRT_Upfrom; + }else if( IsView(pTab) ){ + for(i=0; inCol; i++){ + pList = sqlite3ExprListAppend(pParse, pList, exprRowColumn(pParse, i)); + } + eDest = SRT_Table; + }else{ + eDest = IsVirtual(pTab) ? SRT_Table : SRT_Upfrom; + pList = sqlite3ExprListAppend(pParse, 0, sqlite3PExpr(pParse,TK_ROW,0,0)); +#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT + if( pLimit ){ + pGrp = sqlite3ExprListAppend(pParse, 0, sqlite3PExpr(pParse,TK_ROW,0,0)); + } +#endif + } + assert( pChanges!=0 || pParse->db->mallocFailed ); + if( pChanges ){ + for(i=0; inExpr; i++){ + pList = sqlite3ExprListAppend(pParse, pList, + sqlite3ExprDup(db, pChanges->a[i].pExpr, 0) + ); + } + } + pSelect = sqlite3SelectNew(pParse, pList, + pSrc, pWhere2, pGrp, 0, pOrderBy2, + SF_UFSrcCheck|SF_IncludeHidden|SF_UpdateFrom, pLimit2 + ); + if( pSelect ) pSelect->selFlags |= SF_OrderByReqd; + sqlite3SelectDestInit(&dest, eDest, iEph); + dest.iSDParm2 = (pPk ? pPk->nKeyCol : -1); + sqlite3Select(pParse, pSelect, &dest); + sqlite3SelectDelete(db, pSelect); +} + +/* +** Process an UPDATE statement. +** +** UPDATE OR IGNORE tbl SET a=b, c=d FROM tbl2... WHERE e<5 AND f NOT NULL; +** \_______/ \_/ \______/ \_____/ \________________/ +** onError | pChanges | pWhere +** \_______________________/ +** pTabList +*/ +SQLITE_PRIVATE void sqlite3Update( + Parse *pParse, /* The parser context */ + SrcList *pTabList, /* The table in which we should change things */ + ExprList *pChanges, /* Things to be changed */ + Expr *pWhere, /* The WHERE clause. May be null */ + int onError, /* How to handle constraint errors */ + ExprList *pOrderBy, /* ORDER BY clause. May be null */ + Expr *pLimit, /* LIMIT clause. May be null */ + Upsert *pUpsert /* ON CONFLICT clause, or null */ +){ + int i, j, k; /* Loop counters */ + Table *pTab; /* The table to be updated */ + int addrTop = 0; /* VDBE instruction address of the start of the loop */ + WhereInfo *pWInfo = 0; /* Information about the WHERE clause */ + Vdbe *v; /* The virtual database engine */ + Index *pIdx; /* For looping over indices */ + Index *pPk; /* The PRIMARY KEY index for WITHOUT ROWID tables */ + int nIdx; /* Number of indices that need updating */ + int nAllIdx; /* Total number of indexes */ + int iBaseCur; /* Base cursor number */ + int iDataCur; /* Cursor for the canonical data btree */ + int iIdxCur; /* Cursor for the first index */ + sqlite3 *db; /* The database structure */ + int *aRegIdx = 0; /* Registers for to each index and the main table */ + int *aXRef = 0; /* aXRef[i] is the index in pChanges->a[] of the + ** an expression for the i-th column of the table. + ** aXRef[i]==-1 if the i-th column is not changed. */ + u8 *aToOpen; /* 1 for tables and indices to be opened */ + u8 chngPk; /* PRIMARY KEY changed in a WITHOUT ROWID table */ + u8 chngRowid; /* Rowid changed in a normal table */ + u8 chngKey; /* Either chngPk or chngRowid */ + Expr *pRowidExpr = 0; /* Expression defining the new record number */ + int iRowidExpr = -1; /* Index of "rowid=" (or IPK) assignment in pChanges */ + AuthContext sContext; /* The authorization context */ + NameContext sNC; /* The name-context to resolve expressions in */ + int iDb; /* Database containing the table being updated */ + int eOnePass; /* ONEPASS_XXX value from where.c */ + int hasFK; /* True if foreign key processing is required */ + int labelBreak; /* Jump here to break out of UPDATE loop */ + int labelContinue; /* Jump here to continue next step of UPDATE loop */ + int flags; /* Flags for sqlite3WhereBegin() */ + +#ifndef SQLITE_OMIT_TRIGGER + int isView; /* True when updating a view (INSTEAD OF trigger) */ + Trigger *pTrigger; /* List of triggers on pTab, if required */ + int tmask; /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */ +#endif + int newmask; /* Mask of NEW.* columns accessed by BEFORE triggers */ + int iEph = 0; /* Ephemeral table holding all primary key values */ + int nKey = 0; /* Number of elements in regKey for WITHOUT ROWID */ + int aiCurOnePass[2]; /* The write cursors opened by WHERE_ONEPASS */ + int addrOpen = 0; /* Address of OP_OpenEphemeral */ + int iPk = 0; /* First of nPk cells holding PRIMARY KEY value */ + i16 nPk = 0; /* Number of components of the PRIMARY KEY */ + int bReplace = 0; /* True if REPLACE conflict resolution might happen */ + int bFinishSeek = 1; /* The OP_FinishSeek opcode is needed */ + int nChangeFrom = 0; /* If there is a FROM, pChanges->nExpr, else 0 */ + + /* Register Allocations */ + int regRowCount = 0; /* A count of rows changed */ + int regOldRowid = 0; /* The old rowid */ + int regNewRowid = 0; /* The new rowid */ + int regNew = 0; /* Content of the NEW.* table in triggers */ + int regOld = 0; /* Content of OLD.* table in triggers */ + int regRowSet = 0; /* Rowset of rows to be updated */ + int regKey = 0; /* composite PRIMARY KEY value */ + + memset(&sContext, 0, sizeof(sContext)); + db = pParse->db; + assert( db->pParse==pParse ); + if( pParse->nErr ){ + goto update_cleanup; + } + assert( db->mallocFailed==0 ); + + /* Locate the table which we want to update. + */ + pTab = sqlite3SrcListLookup(pParse, pTabList); + if( pTab==0 ) goto update_cleanup; + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + + /* Figure out if we have any triggers and if the table being + ** updated is a view. + */ +#ifndef SQLITE_OMIT_TRIGGER + pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask); + isView = IsView(pTab); + assert( pTrigger || tmask==0 ); +#else +# define pTrigger 0 +# define isView 0 +# define tmask 0 +#endif +#ifdef SQLITE_OMIT_VIEW +# undef isView +# define isView 0 +#endif + +#if TREETRACE_ENABLED + if( sqlite3TreeTrace & 0x10000 ){ + sqlite3TreeViewLine(0, "In sqlite3Update() at %s:%d", __FILE__, __LINE__); + sqlite3TreeViewUpdate(pParse->pWith, pTabList, pChanges, pWhere, + onError, pOrderBy, pLimit, pUpsert, pTrigger); + } +#endif + + /* If there was a FROM clause, set nChangeFrom to the number of expressions + ** in the change-list. Otherwise, set it to 0. There cannot be a FROM + ** clause if this function is being called to generate code for part of + ** an UPSERT statement. */ + nChangeFrom = (pTabList->nSrc>1) ? pChanges->nExpr : 0; + assert( nChangeFrom==0 || pUpsert==0 ); + +#ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT + if( !isView && nChangeFrom==0 ){ + pWhere = sqlite3LimitWhere( + pParse, pTabList, pWhere, pOrderBy, pLimit, "UPDATE" + ); + pOrderBy = 0; + pLimit = 0; + } +#endif + + if( sqlite3ViewGetColumnNames(pParse, pTab) ){ + goto update_cleanup; + } + if( sqlite3IsReadOnly(pParse, pTab, pTrigger) ){ + goto update_cleanup; + } + + /* Allocate a cursors for the main database table and for all indices. + ** The index cursors might not be used, but if they are used they + ** need to occur right after the database cursor. So go ahead and + ** allocate enough space, just in case. + */ + iBaseCur = iDataCur = pParse->nTab++; + iIdxCur = iDataCur+1; + pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab); + testcase( pPk!=0 && pPk!=pTab->pIndex ); + for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){ + if( pPk==pIdx ){ + iDataCur = pParse->nTab; + } + pParse->nTab++; + } + if( pUpsert ){ + /* On an UPSERT, reuse the same cursors already opened by INSERT */ + iDataCur = pUpsert->iDataCur; + iIdxCur = pUpsert->iIdxCur; + pParse->nTab = iBaseCur; + } + pTabList->a[0].iCursor = iDataCur; + + /* Allocate space for aXRef[], aRegIdx[], and aToOpen[]. + ** Initialize aXRef[] and aToOpen[] to their default values. + */ + aXRef = sqlite3DbMallocRawNN(db, sizeof(int) * (pTab->nCol+nIdx+1) + nIdx+2 ); + if( aXRef==0 ) goto update_cleanup; + aRegIdx = aXRef+pTab->nCol; + aToOpen = (u8*)(aRegIdx+nIdx+1); + memset(aToOpen, 1, nIdx+1); + aToOpen[nIdx+1] = 0; + for(i=0; inCol; i++) aXRef[i] = -1; + + /* Initialize the name-context */ + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + sNC.pSrcList = pTabList; + sNC.uNC.pUpsert = pUpsert; + sNC.ncFlags = NC_UUpsert; + + /* Begin generating code. */ + v = sqlite3GetVdbe(pParse); + if( v==0 ) goto update_cleanup; + + /* Resolve the column names in all the expressions of the + ** of the UPDATE statement. Also find the column index + ** for each column to be updated in the pChanges array. For each + ** column to be updated, make sure we have authorization to change + ** that column. + */ + chngRowid = chngPk = 0; + for(i=0; inExpr; i++){ + u8 hCol = sqlite3StrIHash(pChanges->a[i].zEName); + /* If this is an UPDATE with a FROM clause, do not resolve expressions + ** here. The call to sqlite3Select() below will do that. */ + if( nChangeFrom==0 && sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){ + goto update_cleanup; + } + for(j=0; jnCol; j++){ + if( pTab->aCol[j].hName==hCol + && sqlite3StrICmp(pTab->aCol[j].zCnName, pChanges->a[i].zEName)==0 + ){ + if( j==pTab->iPKey ){ + chngRowid = 1; + pRowidExpr = pChanges->a[i].pExpr; + iRowidExpr = i; + }else if( pPk && (pTab->aCol[j].colFlags & COLFLAG_PRIMKEY)!=0 ){ + chngPk = 1; + } +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + else if( pTab->aCol[j].colFlags & COLFLAG_GENERATED ){ + testcase( pTab->aCol[j].colFlags & COLFLAG_VIRTUAL ); + testcase( pTab->aCol[j].colFlags & COLFLAG_STORED ); + sqlite3ErrorMsg(pParse, + "cannot UPDATE generated column \"%s\"", + pTab->aCol[j].zCnName); + goto update_cleanup; + } +#endif + aXRef[j] = i; + break; + } + } + if( j>=pTab->nCol ){ + if( pPk==0 && sqlite3IsRowid(pChanges->a[i].zEName) ){ + j = -1; + chngRowid = 1; + pRowidExpr = pChanges->a[i].pExpr; + iRowidExpr = i; + }else{ + sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zEName); + pParse->checkSchema = 1; + goto update_cleanup; + } + } +#ifndef SQLITE_OMIT_AUTHORIZATION + { + int rc; + rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName, + j<0 ? "ROWID" : pTab->aCol[j].zCnName, + db->aDb[iDb].zDbSName); + if( rc==SQLITE_DENY ){ + goto update_cleanup; + }else if( rc==SQLITE_IGNORE ){ + aXRef[j] = -1; + } + } +#endif + } + assert( (chngRowid & chngPk)==0 ); + assert( chngRowid==0 || chngRowid==1 ); + assert( chngPk==0 || chngPk==1 ); + chngKey = chngRowid + chngPk; + +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + /* Mark generated columns as changing if their generator expressions + ** reference any changing column. The actual aXRef[] value for + ** generated expressions is not used, other than to check to see that it + ** is non-negative, so the value of aXRef[] for generated columns can be + ** set to any non-negative number. We use 99999 so that the value is + ** obvious when looking at aXRef[] in a symbolic debugger. + */ + if( pTab->tabFlags & TF_HasGenerated ){ + int bProgress; + testcase( pTab->tabFlags & TF_HasVirtual ); + testcase( pTab->tabFlags & TF_HasStored ); + do{ + bProgress = 0; + for(i=0; inCol; i++){ + if( aXRef[i]>=0 ) continue; + if( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)==0 ) continue; + if( sqlite3ExprReferencesUpdatedColumn( + sqlite3ColumnExpr(pTab, &pTab->aCol[i]), + aXRef, chngRowid) + ){ + aXRef[i] = 99999; + bProgress = 1; + } + } + }while( bProgress ); + } +#endif + + /* The SET expressions are not actually used inside the WHERE loop. + ** So reset the colUsed mask. Unless this is a virtual table. In that + ** case, set all bits of the colUsed mask (to ensure that the virtual + ** table implementation makes all columns available). + */ + pTabList->a[0].colUsed = IsVirtual(pTab) ? ALLBITS : 0; + + hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngKey); + + /* There is one entry in the aRegIdx[] array for each index on the table + ** being updated. Fill in aRegIdx[] with a register number that will hold + ** the key for accessing each index. + */ + if( onError==OE_Replace ) bReplace = 1; + for(nAllIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nAllIdx++){ + int reg; + if( chngKey || hasFK>1 || pIdx==pPk + || indexWhereClauseMightChange(pIdx,aXRef,chngRowid) + ){ + reg = ++pParse->nMem; + pParse->nMem += pIdx->nColumn; + }else{ + reg = 0; + for(i=0; inKeyCol; i++){ + if( indexColumnIsBeingUpdated(pIdx, i, aXRef, chngRowid) ){ + reg = ++pParse->nMem; + pParse->nMem += pIdx->nColumn; + if( onError==OE_Default && pIdx->onError==OE_Replace ){ + bReplace = 1; + } + break; + } + } + } + if( reg==0 ) aToOpen[nAllIdx+1] = 0; + aRegIdx[nAllIdx] = reg; + } + aRegIdx[nAllIdx] = ++pParse->nMem; /* Register storing the table record */ + if( bReplace ){ + /* If REPLACE conflict resolution might be invoked, open cursors on all + ** indexes in case they are needed to delete records. */ + memset(aToOpen, 1, nIdx+1); + } + + if( pParse->nested==0 ) sqlite3VdbeCountChanges(v); + sqlite3BeginWriteOperation(pParse, pTrigger || hasFK, iDb); + + /* Allocate required registers. */ + if( !IsVirtual(pTab) ){ + /* For now, regRowSet and aRegIdx[nAllIdx] share the same register. + ** If regRowSet turns out to be needed, then aRegIdx[nAllIdx] will be + ** reallocated. aRegIdx[nAllIdx] is the register in which the main + ** table record is written. regRowSet holds the RowSet for the + ** two-pass update algorithm. */ + assert( aRegIdx[nAllIdx]==pParse->nMem ); + regRowSet = aRegIdx[nAllIdx]; + regOldRowid = regNewRowid = ++pParse->nMem; + if( chngPk || pTrigger || hasFK ){ + regOld = pParse->nMem + 1; + pParse->nMem += pTab->nCol; + } + if( chngKey || pTrigger || hasFK ){ + regNewRowid = ++pParse->nMem; + } + regNew = pParse->nMem + 1; + pParse->nMem += pTab->nCol; + } + + /* Start the view context. */ + if( isView ){ + sqlite3AuthContextPush(pParse, &sContext, pTab->zName); + } + + /* If we are trying to update a view, realize that view into + ** an ephemeral table. + */ +#if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) + if( nChangeFrom==0 && isView ){ + sqlite3MaterializeView(pParse, pTab, + pWhere, pOrderBy, pLimit, iDataCur + ); + pOrderBy = 0; + pLimit = 0; + } +#endif + + /* Resolve the column names in all the expressions in the + ** WHERE clause. + */ + if( nChangeFrom==0 && sqlite3ResolveExprNames(&sNC, pWhere) ){ + goto update_cleanup; + } + +#ifndef SQLITE_OMIT_VIRTUALTABLE + /* Virtual tables must be handled separately */ + if( IsVirtual(pTab) ){ + updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef, + pWhere, onError); + goto update_cleanup; + } +#endif + + /* Jump to labelBreak to abandon further processing of this UPDATE */ + labelContinue = labelBreak = sqlite3VdbeMakeLabel(pParse); + + /* Not an UPSERT. Normal processing. Begin by + ** initialize the count of updated rows */ + if( (db->flags&SQLITE_CountRows)!=0 + && !pParse->pTriggerTab + && !pParse->nested + && !pParse->bReturning + && pUpsert==0 + ){ + regRowCount = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount); + } + + if( nChangeFrom==0 && HasRowid(pTab) ){ + sqlite3VdbeAddOp3(v, OP_Null, 0, regRowSet, regOldRowid); + iEph = pParse->nTab++; + addrOpen = sqlite3VdbeAddOp3(v, OP_OpenEphemeral, iEph, 0, regRowSet); + }else{ + assert( pPk!=0 || HasRowid(pTab) ); + nPk = pPk ? pPk->nKeyCol : 0; + iPk = pParse->nMem+1; + pParse->nMem += nPk; + pParse->nMem += nChangeFrom; + regKey = ++pParse->nMem; + if( pUpsert==0 ){ + int nEphCol = nPk + nChangeFrom + (isView ? pTab->nCol : 0); + iEph = pParse->nTab++; + if( pPk ) sqlite3VdbeAddOp3(v, OP_Null, 0, iPk, iPk+nPk-1); + addrOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEph, nEphCol); + if( pPk ){ + KeyInfo *pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pPk); + if( pKeyInfo ){ + pKeyInfo->nAllField = nEphCol; + sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO); + } + } + if( nChangeFrom ){ + updateFromSelect( + pParse, iEph, pPk, pChanges, pTabList, pWhere, pOrderBy, pLimit + ); +#ifndef SQLITE_OMIT_SUBQUERY + if( isView ) iDataCur = iEph; +#endif + } + } + } + + if( nChangeFrom ){ + sqlite3MultiWrite(pParse); + eOnePass = ONEPASS_OFF; + nKey = nPk; + regKey = iPk; + }else{ + if( pUpsert ){ + /* If this is an UPSERT, then all cursors have already been opened by + ** the outer INSERT and the data cursor should be pointing at the row + ** that is to be updated. So bypass the code that searches for the + ** row(s) to be updated. + */ + pWInfo = 0; + eOnePass = ONEPASS_SINGLE; + sqlite3ExprIfFalse(pParse, pWhere, labelBreak, SQLITE_JUMPIFNULL); + bFinishSeek = 0; + }else{ + /* Begin the database scan. + ** + ** Do not consider a single-pass strategy for a multi-row update if + ** there is anything that might disrupt the cursor being used to do + ** the UPDATE: + ** (1) This is a nested UPDATE + ** (2) There are triggers + ** (3) There are FOREIGN KEY constraints + ** (4) There are REPLACE conflict handlers + ** (5) There are subqueries in the WHERE clause + */ + flags = WHERE_ONEPASS_DESIRED; + if( !pParse->nested + && !pTrigger + && !hasFK + && !chngKey + && !bReplace + && (sNC.ncFlags & NC_Subquery)==0 + ){ + flags |= WHERE_ONEPASS_MULTIROW; + } + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere,0,0,0,flags,iIdxCur); + if( pWInfo==0 ) goto update_cleanup; + + /* A one-pass strategy that might update more than one row may not + ** be used if any column of the index used for the scan is being + ** updated. Otherwise, if there is an index on "b", statements like + ** the following could create an infinite loop: + ** + ** UPDATE t1 SET b=b+1 WHERE b>? + ** + ** Fall back to ONEPASS_OFF if where.c has selected a ONEPASS_MULTI + ** strategy that uses an index for which one or more columns are being + ** updated. */ + eOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass); + bFinishSeek = sqlite3WhereUsesDeferredSeek(pWInfo); + if( eOnePass!=ONEPASS_SINGLE ){ + sqlite3MultiWrite(pParse); + if( eOnePass==ONEPASS_MULTI ){ + int iCur = aiCurOnePass[1]; + if( iCur>=0 && iCur!=iDataCur && aToOpen[iCur-iBaseCur] ){ + eOnePass = ONEPASS_OFF; + } + assert( iCur!=iDataCur || !HasRowid(pTab) ); + } + } + } + + if( HasRowid(pTab) ){ + /* Read the rowid of the current row of the WHERE scan. In ONEPASS_OFF + ** mode, write the rowid into the FIFO. In either of the one-pass modes, + ** leave it in register regOldRowid. */ + sqlite3VdbeAddOp2(v, OP_Rowid, iDataCur, regOldRowid); + if( eOnePass==ONEPASS_OFF ){ + aRegIdx[nAllIdx] = ++pParse->nMem; + sqlite3VdbeAddOp3(v, OP_Insert, iEph, regRowSet, regOldRowid); + }else{ + if( ALWAYS(addrOpen) ) sqlite3VdbeChangeToNoop(v, addrOpen); + } + }else{ + /* Read the PK of the current row into an array of registers. In + ** ONEPASS_OFF mode, serialize the array into a record and store it in + ** the ephemeral table. Or, in ONEPASS_SINGLE or MULTI mode, change + ** the OP_OpenEphemeral instruction to a Noop (the ephemeral table + ** is not required) and leave the PK fields in the array of registers. */ + for(i=0; iaiColumn[i]>=0 ); + sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, + pPk->aiColumn[i], iPk+i); + } + if( eOnePass ){ + if( addrOpen ) sqlite3VdbeChangeToNoop(v, addrOpen); + nKey = nPk; + regKey = iPk; + }else{ + sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, regKey, + sqlite3IndexAffinityStr(db, pPk), nPk); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iEph, regKey, iPk, nPk); + } + } + } + + if( pUpsert==0 ){ + if( nChangeFrom==0 && eOnePass!=ONEPASS_MULTI ){ + sqlite3WhereEnd(pWInfo); + } + + if( !isView ){ + int addrOnce = 0; + + /* Open every index that needs updating. */ + if( eOnePass!=ONEPASS_OFF ){ + if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iBaseCur] = 0; + if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iBaseCur] = 0; + } + + if( eOnePass==ONEPASS_MULTI && (nIdx-(aiCurOnePass[1]>=0))>0 ){ + addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); + } + sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, iBaseCur, + aToOpen, 0, 0); + if( addrOnce ){ + sqlite3VdbeJumpHereOrPopInst(v, addrOnce); + } + } + + /* Top of the update loop */ + if( eOnePass!=ONEPASS_OFF ){ + if( aiCurOnePass[0]!=iDataCur + && aiCurOnePass[1]!=iDataCur +#ifdef SQLITE_ALLOW_ROWID_IN_VIEW + && !isView +#endif + ){ + assert( pPk ); + sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelBreak, regKey,nKey); + VdbeCoverage(v); + } + if( eOnePass!=ONEPASS_SINGLE ){ + labelContinue = sqlite3VdbeMakeLabel(pParse); + } + sqlite3VdbeAddOp2(v, OP_IsNull, pPk ? regKey : regOldRowid, labelBreak); + VdbeCoverageIf(v, pPk==0); + VdbeCoverageIf(v, pPk!=0); + }else if( pPk || nChangeFrom ){ + labelContinue = sqlite3VdbeMakeLabel(pParse); + sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v); + addrTop = sqlite3VdbeCurrentAddr(v); + if( nChangeFrom ){ + if( !isView ){ + if( pPk ){ + for(i=0; i=0 ); + if( nChangeFrom==0 ){ + sqlite3ExprCode(pParse, pRowidExpr, regNewRowid); + }else{ + sqlite3VdbeAddOp3(v, OP_Column, iEph, iRowidExpr, regNewRowid); + } + sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid); VdbeCoverage(v); + } + + /* Compute the old pre-UPDATE content of the row being changed, if that + ** information is needed */ + if( chngPk || hasFK || pTrigger ){ + u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0); + oldmask |= sqlite3TriggerColmask(pParse, + pTrigger, pChanges, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onError + ); + for(i=0; inCol; i++){ + u32 colFlags = pTab->aCol[i].colFlags; + k = sqlite3TableColumnToStorage(pTab, i) + regOld; + if( oldmask==0xffffffff + || (i<32 && (oldmask & MASKBIT32(i))!=0) + || (colFlags & COLFLAG_PRIMKEY)!=0 + ){ + testcase( oldmask!=0xffffffff && i==31 ); + sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k); + }else{ + sqlite3VdbeAddOp2(v, OP_Null, 0, k); + } + } + if( chngRowid==0 && pPk==0 ){ + sqlite3VdbeAddOp2(v, OP_Copy, regOldRowid, regNewRowid); + } + } + + /* Populate the array of registers beginning at regNew with the new + ** row data. This array is used to check constants, create the new + ** table and index records, and as the values for any new.* references + ** made by triggers. + ** + ** If there are one or more BEFORE triggers, then do not populate the + ** registers associated with columns that are (a) not modified by + ** this UPDATE statement and (b) not accessed by new.* references. The + ** values for registers not modified by the UPDATE must be reloaded from + ** the database after the BEFORE triggers are fired anyway (as the trigger + ** may have modified them). So not loading those that are not going to + ** be used eliminates some redundant opcodes. + */ + newmask = sqlite3TriggerColmask( + pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError + ); + for(i=0, k=regNew; inCol; i++, k++){ + if( i==pTab->iPKey ){ + sqlite3VdbeAddOp2(v, OP_Null, 0, k); + }else if( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)!=0 ){ + if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) k--; + }else{ + j = aXRef[i]; + if( j>=0 ){ + if( nChangeFrom ){ + int nOff = (isView ? pTab->nCol : nPk); + assert( eOnePass==ONEPASS_OFF ); + sqlite3VdbeAddOp3(v, OP_Column, iEph, nOff+j, k); + }else{ + sqlite3ExprCode(pParse, pChanges->a[j].pExpr, k); + } + }else if( 0==(tmask&TRIGGER_BEFORE) || i>31 || (newmask & MASKBIT32(i)) ){ + /* This branch loads the value of a column that will not be changed + ** into a register. This is done if there are no BEFORE triggers, or + ** if there are one or more BEFORE triggers that use this value via + ** a new.* reference in a trigger program. + */ + testcase( i==31 ); + testcase( i==32 ); + sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k); + bFinishSeek = 0; + }else{ + sqlite3VdbeAddOp2(v, OP_Null, 0, k); + } + } + } +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + if( pTab->tabFlags & TF_HasGenerated ){ + testcase( pTab->tabFlags & TF_HasVirtual ); + testcase( pTab->tabFlags & TF_HasStored ); + sqlite3ComputeGeneratedColumns(pParse, regNew, pTab); + } +#endif + + /* Fire any BEFORE UPDATE triggers. This happens before constraints are + ** verified. One could argue that this is wrong. + */ + if( tmask&TRIGGER_BEFORE ){ + sqlite3TableAffinity(v, pTab, regNew); + sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges, + TRIGGER_BEFORE, pTab, regOldRowid, onError, labelContinue); + + if( !isView ){ + /* The row-trigger may have deleted the row being updated. In this + ** case, jump to the next row. No updates or AFTER triggers are + ** required. This behavior - what happens when the row being updated + ** is deleted or renamed by a BEFORE trigger - is left undefined in the + ** documentation. + */ + if( pPk ){ + sqlite3VdbeAddOp4Int(v, OP_NotFound,iDataCur,labelContinue,regKey,nKey); + VdbeCoverage(v); + }else{ + sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue,regOldRowid); + VdbeCoverage(v); + } + + /* After-BEFORE-trigger-reload-loop: + ** If it did not delete it, the BEFORE trigger may still have modified + ** some of the columns of the row being updated. Load the values for + ** all columns not modified by the update statement into their registers + ** in case this has happened. Only unmodified columns are reloaded. + ** The values computed for modified columns use the values before the + ** BEFORE trigger runs. See test case trigger1-18.0 (added 2018-04-26) + ** for an example. + */ + for(i=0, k=regNew; inCol; i++, k++){ + if( pTab->aCol[i].colFlags & COLFLAG_GENERATED ){ + if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ) k--; + }else if( aXRef[i]<0 && i!=pTab->iPKey ){ + sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k); + } + } +#ifndef SQLITE_OMIT_GENERATED_COLUMNS + if( pTab->tabFlags & TF_HasGenerated ){ + testcase( pTab->tabFlags & TF_HasVirtual ); + testcase( pTab->tabFlags & TF_HasStored ); + sqlite3ComputeGeneratedColumns(pParse, regNew, pTab); + } +#endif + } + } + + if( !isView ){ + /* Do constraint checks. */ + assert( regOldRowid>0 ); + sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur, + regNewRowid, regOldRowid, chngKey, onError, labelContinue, &bReplace, + aXRef, 0); + + /* If REPLACE conflict handling may have been used, or if the PK of the + ** row is changing, then the GenerateConstraintChecks() above may have + ** moved cursor iDataCur. Reseek it. */ + if( bReplace || chngKey ){ + if( pPk ){ + sqlite3VdbeAddOp4Int(v, OP_NotFound,iDataCur,labelContinue,regKey,nKey); + }else{ + sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue,regOldRowid); + } + VdbeCoverage(v); + } + + /* Do FK constraint checks. */ + if( hasFK ){ + sqlite3FkCheck(pParse, pTab, regOldRowid, 0, aXRef, chngKey); + } + + /* Delete the index entries associated with the current record. */ + sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, aRegIdx, -1); + + /* We must run the OP_FinishSeek opcode to resolve a prior + ** OP_DeferredSeek if there is any possibility that there have been + ** no OP_Column opcodes since the OP_DeferredSeek was issued. But + ** we want to avoid the OP_FinishSeek if possible, as running it + ** costs CPU cycles. */ + if( bFinishSeek ){ + sqlite3VdbeAddOp1(v, OP_FinishSeek, iDataCur); + } + + /* If changing the rowid value, or if there are foreign key constraints + ** to process, delete the old record. Otherwise, add a noop OP_Delete + ** to invoke the pre-update hook. + ** + ** That (regNew==regnewRowid+1) is true is also important for the + ** pre-update hook. If the caller invokes preupdate_new(), the returned + ** value is copied from memory cell (regNewRowid+1+iCol), where iCol + ** is the column index supplied by the user. + */ + assert( regNew==regNewRowid+1 ); +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK + sqlite3VdbeAddOp3(v, OP_Delete, iDataCur, + OPFLAG_ISUPDATE | ((hasFK>1 || chngKey) ? 0 : OPFLAG_ISNOOP), + regNewRowid + ); + if( eOnePass==ONEPASS_MULTI ){ + assert( hasFK==0 && chngKey==0 ); + sqlite3VdbeChangeP5(v, OPFLAG_SAVEPOSITION); + } + if( !pParse->nested ){ + sqlite3VdbeAppendP4(v, pTab, P4_TABLE); + } +#else + if( hasFK>1 || chngKey ){ + sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, 0); + } +#endif + + if( hasFK ){ + sqlite3FkCheck(pParse, pTab, 0, regNewRowid, aXRef, chngKey); + } + + /* Insert the new index entries and the new record. */ + sqlite3CompleteInsertion( + pParse, pTab, iDataCur, iIdxCur, regNewRowid, aRegIdx, + OPFLAG_ISUPDATE | (eOnePass==ONEPASS_MULTI ? OPFLAG_SAVEPOSITION : 0), + 0, 0 + ); + + /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to + ** handle rows (possibly in other tables) that refer via a foreign key + ** to the row just updated. */ + if( hasFK ){ + sqlite3FkActions(pParse, pTab, pChanges, regOldRowid, aXRef, chngKey); + } + } + + /* Increment the row counter + */ + if( regRowCount ){ + sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1); + } + + sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges, + TRIGGER_AFTER, pTab, regOldRowid, onError, labelContinue); + + /* Repeat the above with the next record to be updated, until + ** all record selected by the WHERE clause have been updated. + */ + if( eOnePass==ONEPASS_SINGLE ){ + /* Nothing to do at end-of-loop for a single-pass */ + }else if( eOnePass==ONEPASS_MULTI ){ + sqlite3VdbeResolveLabel(v, labelContinue); + sqlite3WhereEnd(pWInfo); + }else{ + sqlite3VdbeResolveLabel(v, labelContinue); + sqlite3VdbeAddOp2(v, OP_Next, iEph, addrTop); VdbeCoverage(v); + } + sqlite3VdbeResolveLabel(v, labelBreak); + + /* Update the sqlite_sequence table by storing the content of the + ** maximum rowid counter values recorded while inserting into + ** autoincrement tables. + */ + if( pParse->nested==0 && pParse->pTriggerTab==0 && pUpsert==0 ){ + sqlite3AutoincrementEnd(pParse); + } + + /* + ** Return the number of rows that were changed, if we are tracking + ** that information. + */ + if( regRowCount ){ + sqlite3CodeChangeCount(v, regRowCount, "rows updated"); + } + +update_cleanup: + sqlite3AuthContextPop(&sContext); + sqlite3DbFree(db, aXRef); /* Also frees aRegIdx[] and aToOpen[] */ + sqlite3SrcListDelete(db, pTabList); + sqlite3ExprListDelete(db, pChanges); + sqlite3ExprDelete(db, pWhere); +#if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) + sqlite3ExprListDelete(db, pOrderBy); + sqlite3ExprDelete(db, pLimit); +#endif + return; +} +/* Make sure "isView" and other macros defined above are undefined. Otherwise +** they may interfere with compilation of other functions in this file +** (or in another file, if this file becomes part of the amalgamation). */ +#ifdef isView + #undef isView +#endif +#ifdef pTrigger + #undef pTrigger +#endif + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* +** Generate code for an UPDATE of a virtual table. +** +** There are two possible strategies - the default and the special +** "onepass" strategy. Onepass is only used if the virtual table +** implementation indicates that pWhere may match at most one row. +** +** The default strategy is to create an ephemeral table that contains +** for each row to be changed: +** +** (A) The original rowid of that row. +** (B) The revised rowid for the row. +** (C) The content of every column in the row. +** +** Then loop through the contents of this ephemeral table executing a +** VUpdate for each row. When finished, drop the ephemeral table. +** +** The "onepass" strategy does not use an ephemeral table. Instead, it +** stores the same values (A, B and C above) in a register array and +** makes a single invocation of VUpdate. +*/ +static void updateVirtualTable( + Parse *pParse, /* The parsing context */ + SrcList *pSrc, /* The virtual table to be modified */ + Table *pTab, /* The virtual table */ + ExprList *pChanges, /* The columns to change in the UPDATE statement */ + Expr *pRowid, /* Expression used to recompute the rowid */ + int *aXRef, /* Mapping from columns of pTab to entries in pChanges */ + Expr *pWhere, /* WHERE clause of the UPDATE statement */ + int onError /* ON CONFLICT strategy */ +){ + Vdbe *v = pParse->pVdbe; /* Virtual machine under construction */ + int ephemTab; /* Table holding the result of the SELECT */ + int i; /* Loop counter */ + sqlite3 *db = pParse->db; /* Database connection */ + const char *pVTab = (const char*)sqlite3GetVTable(db, pTab); + WhereInfo *pWInfo = 0; + int nArg = 2 + pTab->nCol; /* Number of arguments to VUpdate */ + int regArg; /* First register in VUpdate arg array */ + int regRec; /* Register in which to assemble record */ + int regRowid; /* Register for ephem table rowid */ + int iCsr = pSrc->a[0].iCursor; /* Cursor used for virtual table scan */ + int aDummy[2]; /* Unused arg for sqlite3WhereOkOnePass() */ + int eOnePass; /* True to use onepass strategy */ + int addr; /* Address of OP_OpenEphemeral */ + + /* Allocate nArg registers in which to gather the arguments for VUpdate. Then + ** create and open the ephemeral table in which the records created from + ** these arguments will be temporarily stored. */ + assert( v ); + ephemTab = pParse->nTab++; + addr= sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, nArg); + regArg = pParse->nMem + 1; + pParse->nMem += nArg; + if( pSrc->nSrc>1 ){ + Index *pPk = 0; + Expr *pRow; + ExprList *pList; + if( HasRowid(pTab) ){ + if( pRowid ){ + pRow = sqlite3ExprDup(db, pRowid, 0); + }else{ + pRow = sqlite3PExpr(pParse, TK_ROW, 0, 0); + } + }else{ + i16 iPk; /* PRIMARY KEY column */ + pPk = sqlite3PrimaryKeyIndex(pTab); + assert( pPk!=0 ); + assert( pPk->nKeyCol==1 ); + iPk = pPk->aiColumn[0]; + if( aXRef[iPk]>=0 ){ + pRow = sqlite3ExprDup(db, pChanges->a[aXRef[iPk]].pExpr, 0); + }else{ + pRow = exprRowColumn(pParse, iPk); + } + } + pList = sqlite3ExprListAppend(pParse, 0, pRow); + + for(i=0; inCol; i++){ + if( aXRef[i]>=0 ){ + pList = sqlite3ExprListAppend(pParse, pList, + sqlite3ExprDup(db, pChanges->a[aXRef[i]].pExpr, 0) + ); + }else{ + pList = sqlite3ExprListAppend(pParse, pList, exprRowColumn(pParse, i)); + } + } + + updateFromSelect(pParse, ephemTab, pPk, pList, pSrc, pWhere, 0, 0); + sqlite3ExprListDelete(db, pList); + eOnePass = ONEPASS_OFF; + }else{ + regRec = ++pParse->nMem; + regRowid = ++pParse->nMem; + + /* Start scanning the virtual table */ + pWInfo = sqlite3WhereBegin( + pParse, pSrc, pWhere, 0, 0, 0, WHERE_ONEPASS_DESIRED, 0 + ); + if( pWInfo==0 ) return; + + /* Populate the argument registers. */ + for(i=0; inCol; i++){ + assert( (pTab->aCol[i].colFlags & COLFLAG_GENERATED)==0 ); + if( aXRef[i]>=0 ){ + sqlite3ExprCode(pParse, pChanges->a[aXRef[i]].pExpr, regArg+2+i); + }else{ + sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, i, regArg+2+i); + sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG);/* For sqlite3_vtab_nochange() */ + } + } + if( HasRowid(pTab) ){ + sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg); + if( pRowid ){ + sqlite3ExprCode(pParse, pRowid, regArg+1); + }else{ + sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg+1); + } + }else{ + Index *pPk; /* PRIMARY KEY index */ + i16 iPk; /* PRIMARY KEY column */ + pPk = sqlite3PrimaryKeyIndex(pTab); + assert( pPk!=0 ); + assert( pPk->nKeyCol==1 ); + iPk = pPk->aiColumn[0]; + sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, iPk, regArg); + sqlite3VdbeAddOp2(v, OP_SCopy, regArg+2+iPk, regArg+1); + } + + eOnePass = sqlite3WhereOkOnePass(pWInfo, aDummy); + + /* There is no ONEPASS_MULTI on virtual tables */ + assert( eOnePass==ONEPASS_OFF || eOnePass==ONEPASS_SINGLE ); + + if( eOnePass ){ + /* If using the onepass strategy, no-op out the OP_OpenEphemeral coded + ** above. */ + sqlite3VdbeChangeToNoop(v, addr); + sqlite3VdbeAddOp1(v, OP_Close, iCsr); + }else{ + /* Create a record from the argument register contents and insert it into + ** the ephemeral table. */ + sqlite3MultiWrite(pParse); + sqlite3VdbeAddOp3(v, OP_MakeRecord, regArg, nArg, regRec); +#if defined(SQLITE_DEBUG) && !defined(SQLITE_ENABLE_NULL_TRIM) + /* Signal an assert() within OP_MakeRecord that it is allowed to + ** accept no-change records with serial_type 10 */ + sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG_MAGIC); +#endif + sqlite3VdbeAddOp2(v, OP_NewRowid, ephemTab, regRowid); + sqlite3VdbeAddOp3(v, OP_Insert, ephemTab, regRec, regRowid); + } + } + + + if( eOnePass==ONEPASS_OFF ){ + /* End the virtual table scan */ + if( pSrc->nSrc==1 ){ + sqlite3WhereEnd(pWInfo); + } + + /* Begin scannning through the ephemeral table. */ + addr = sqlite3VdbeAddOp1(v, OP_Rewind, ephemTab); VdbeCoverage(v); + + /* Extract arguments from the current row of the ephemeral table and + ** invoke the VUpdate method. */ + for(i=0; ipNextUpsert; + sqlite3ExprListDelete(db, p->pUpsertTarget); + sqlite3ExprDelete(db, p->pUpsertTargetWhere); + sqlite3ExprListDelete(db, p->pUpsertSet); + sqlite3ExprDelete(db, p->pUpsertWhere); + sqlite3DbFree(db, p->pToFree); + sqlite3DbFree(db, p); + p = pNext; + }while( p ); +} +SQLITE_PRIVATE void sqlite3UpsertDelete(sqlite3 *db, Upsert *p){ + if( p ) upsertDelete(db, p); +} + + +/* +** Duplicate an Upsert object. +*/ +SQLITE_PRIVATE Upsert *sqlite3UpsertDup(sqlite3 *db, Upsert *p){ + if( p==0 ) return 0; + return sqlite3UpsertNew(db, + sqlite3ExprListDup(db, p->pUpsertTarget, 0), + sqlite3ExprDup(db, p->pUpsertTargetWhere, 0), + sqlite3ExprListDup(db, p->pUpsertSet, 0), + sqlite3ExprDup(db, p->pUpsertWhere, 0), + sqlite3UpsertDup(db, p->pNextUpsert) + ); +} + +/* +** Create a new Upsert object. +*/ +SQLITE_PRIVATE Upsert *sqlite3UpsertNew( + sqlite3 *db, /* Determines which memory allocator to use */ + ExprList *pTarget, /* Target argument to ON CONFLICT, or NULL */ + Expr *pTargetWhere, /* Optional WHERE clause on the target */ + ExprList *pSet, /* UPDATE columns, or NULL for a DO NOTHING */ + Expr *pWhere, /* WHERE clause for the ON CONFLICT UPDATE */ + Upsert *pNext /* Next ON CONFLICT clause in the list */ +){ + Upsert *pNew; + pNew = sqlite3DbMallocZero(db, sizeof(Upsert)); + if( pNew==0 ){ + sqlite3ExprListDelete(db, pTarget); + sqlite3ExprDelete(db, pTargetWhere); + sqlite3ExprListDelete(db, pSet); + sqlite3ExprDelete(db, pWhere); + sqlite3UpsertDelete(db, pNext); + return 0; + }else{ + pNew->pUpsertTarget = pTarget; + pNew->pUpsertTargetWhere = pTargetWhere; + pNew->pUpsertSet = pSet; + pNew->pUpsertWhere = pWhere; + pNew->isDoUpdate = pSet!=0; + pNew->pNextUpsert = pNext; + } + return pNew; +} + +/* +** Analyze the ON CONFLICT clause described by pUpsert. Resolve all +** symbols in the conflict-target. +** +** Return SQLITE_OK if everything works, or an error code is something +** is wrong. +*/ +SQLITE_PRIVATE int sqlite3UpsertAnalyzeTarget( + Parse *pParse, /* The parsing context */ + SrcList *pTabList, /* Table into which we are inserting */ + Upsert *pUpsert /* The ON CONFLICT clauses */ +){ + Table *pTab; /* That table into which we are inserting */ + int rc; /* Result code */ + int iCursor; /* Cursor used by pTab */ + Index *pIdx; /* One of the indexes of pTab */ + ExprList *pTarget; /* The conflict-target clause */ + Expr *pTerm; /* One term of the conflict-target clause */ + NameContext sNC; /* Context for resolving symbolic names */ + Expr sCol[2]; /* Index column converted into an Expr */ + int nClause = 0; /* Counter of ON CONFLICT clauses */ + + assert( pTabList->nSrc==1 ); + assert( pTabList->a[0].pTab!=0 ); + assert( pUpsert!=0 ); + assert( pUpsert->pUpsertTarget!=0 ); + + /* Resolve all symbolic names in the conflict-target clause, which + ** includes both the list of columns and the optional partial-index + ** WHERE clause. + */ + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + sNC.pSrcList = pTabList; + for(; pUpsert && pUpsert->pUpsertTarget; + pUpsert=pUpsert->pNextUpsert, nClause++){ + rc = sqlite3ResolveExprListNames(&sNC, pUpsert->pUpsertTarget); + if( rc ) return rc; + rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertTargetWhere); + if( rc ) return rc; + + /* Check to see if the conflict target matches the rowid. */ + pTab = pTabList->a[0].pTab; + pTarget = pUpsert->pUpsertTarget; + iCursor = pTabList->a[0].iCursor; + if( HasRowid(pTab) + && pTarget->nExpr==1 + && (pTerm = pTarget->a[0].pExpr)->op==TK_COLUMN + && pTerm->iColumn==XN_ROWID + ){ + /* The conflict-target is the rowid of the primary table */ + assert( pUpsert->pUpsertIdx==0 ); + continue; + } + + /* Initialize sCol[0..1] to be an expression parse tree for a + ** single column of an index. The sCol[0] node will be the TK_COLLATE + ** operator and sCol[1] will be the TK_COLUMN operator. Code below + ** will populate the specific collation and column number values + ** prior to comparing against the conflict-target expression. + */ + memset(sCol, 0, sizeof(sCol)); + sCol[0].op = TK_COLLATE; + sCol[0].pLeft = &sCol[1]; + sCol[1].op = TK_COLUMN; + sCol[1].iTable = pTabList->a[0].iCursor; + + /* Check for matches against other indexes */ + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + int ii, jj, nn; + if( !IsUniqueIndex(pIdx) ) continue; + if( pTarget->nExpr!=pIdx->nKeyCol ) continue; + if( pIdx->pPartIdxWhere ){ + if( pUpsert->pUpsertTargetWhere==0 ) continue; + if( sqlite3ExprCompare(pParse, pUpsert->pUpsertTargetWhere, + pIdx->pPartIdxWhere, iCursor)!=0 ){ + continue; + } + } + nn = pIdx->nKeyCol; + for(ii=0; iiazColl[ii]; + if( pIdx->aiColumn[ii]==XN_EXPR ){ + assert( pIdx->aColExpr!=0 ); + assert( pIdx->aColExpr->nExpr>ii ); + assert( pIdx->bHasExpr ); + pExpr = pIdx->aColExpr->a[ii].pExpr; + if( pExpr->op!=TK_COLLATE ){ + sCol[0].pLeft = pExpr; + pExpr = &sCol[0]; + } + }else{ + sCol[0].pLeft = &sCol[1]; + sCol[1].iColumn = pIdx->aiColumn[ii]; + pExpr = &sCol[0]; + } + for(jj=0; jja[jj].pExpr,pExpr,iCursor)<2 ){ + break; /* Column ii of the index matches column jj of target */ + } + } + if( jj>=nn ){ + /* The target contains no match for column jj of the index */ + break; + } + } + if( iipUpsertIdx = pIdx; + break; + } + if( pUpsert->pUpsertIdx==0 ){ + char zWhich[16]; + if( nClause==0 && pUpsert->pNextUpsert==0 ){ + zWhich[0] = 0; + }else{ + sqlite3_snprintf(sizeof(zWhich),zWhich,"%r ", nClause+1); + } + sqlite3ErrorMsg(pParse, "%sON CONFLICT clause does not match any " + "PRIMARY KEY or UNIQUE constraint", zWhich); + return SQLITE_ERROR; + } + } + return SQLITE_OK; +} + +/* +** Return true if pUpsert is the last ON CONFLICT clause with a +** conflict target, or if pUpsert is followed by another ON CONFLICT +** clause that targets the INTEGER PRIMARY KEY. +*/ +SQLITE_PRIVATE int sqlite3UpsertNextIsIPK(Upsert *pUpsert){ + Upsert *pNext; + if( NEVER(pUpsert==0) ) return 0; + pNext = pUpsert->pNextUpsert; + if( pNext==0 ) return 1; + if( pNext->pUpsertTarget==0 ) return 1; + if( pNext->pUpsertIdx==0 ) return 1; + return 0; +} + +/* +** Given the list of ON CONFLICT clauses described by pUpsert, and +** a particular index pIdx, return a pointer to the particular ON CONFLICT +** clause that applies to the index. Or, if the index is not subject to +** any ON CONFLICT clause, return NULL. +*/ +SQLITE_PRIVATE Upsert *sqlite3UpsertOfIndex(Upsert *pUpsert, Index *pIdx){ + while( + pUpsert + && pUpsert->pUpsertTarget!=0 + && pUpsert->pUpsertIdx!=pIdx + ){ + pUpsert = pUpsert->pNextUpsert; + } + return pUpsert; +} + +/* +** Generate bytecode that does an UPDATE as part of an upsert. +** +** If pIdx is NULL, then the UNIQUE constraint that failed was the IPK. +** In this case parameter iCur is a cursor open on the table b-tree that +** currently points to the conflicting table row. Otherwise, if pIdx +** is not NULL, then pIdx is the constraint that failed and iCur is a +** cursor points to the conflicting row. +*/ +SQLITE_PRIVATE void sqlite3UpsertDoUpdate( + Parse *pParse, /* The parsing and code-generating context */ + Upsert *pUpsert, /* The ON CONFLICT clause for the upsert */ + Table *pTab, /* The table being updated */ + Index *pIdx, /* The UNIQUE constraint that failed */ + int iCur /* Cursor for pIdx (or pTab if pIdx==NULL) */ +){ + Vdbe *v = pParse->pVdbe; + sqlite3 *db = pParse->db; + SrcList *pSrc; /* FROM clause for the UPDATE */ + int iDataCur; + int i; + Upsert *pTop = pUpsert; + + assert( v!=0 ); + assert( pUpsert!=0 ); + iDataCur = pUpsert->iDataCur; + pUpsert = sqlite3UpsertOfIndex(pTop, pIdx); + VdbeNoopComment((v, "Begin DO UPDATE of UPSERT")); + if( pIdx && iCur!=iDataCur ){ + if( HasRowid(pTab) ){ + int regRowid = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp2(v, OP_IdxRowid, iCur, regRowid); + sqlite3VdbeAddOp3(v, OP_SeekRowid, iDataCur, 0, regRowid); + VdbeCoverage(v); + sqlite3ReleaseTempReg(pParse, regRowid); + }else{ + Index *pPk = sqlite3PrimaryKeyIndex(pTab); + int nPk = pPk->nKeyCol; + int iPk = pParse->nMem+1; + pParse->nMem += nPk; + for(i=0; iaiColumn[i]>=0 ); + k = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[i]); + sqlite3VdbeAddOp3(v, OP_Column, iCur, k, iPk+i); + VdbeComment((v, "%s.%s", pIdx->zName, + pTab->aCol[pPk->aiColumn[i]].zCnName)); + } + sqlite3VdbeVerifyAbortable(v, OE_Abort); + i = sqlite3VdbeAddOp4Int(v, OP_Found, iDataCur, 0, iPk, nPk); + VdbeCoverage(v); + sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_CORRUPT, OE_Abort, 0, + "corrupt database", P4_STATIC); + sqlite3MayAbort(pParse); + sqlite3VdbeJumpHere(v, i); + } + } + /* pUpsert does not own pTop->pUpsertSrc - the outer INSERT statement does. + ** So we have to make a copy before passing it down into sqlite3Update() */ + pSrc = sqlite3SrcListDup(db, pTop->pUpsertSrc, 0); + /* excluded.* columns of type REAL need to be converted to a hard real */ + for(i=0; inCol; i++){ + if( pTab->aCol[i].affinity==SQLITE_AFF_REAL ){ + sqlite3VdbeAddOp1(v, OP_RealAffinity, pTop->regData+i); + } + } + sqlite3Update(pParse, pSrc, sqlite3ExprListDup(db,pUpsert->pUpsertSet,0), + sqlite3ExprDup(db,pUpsert->pUpsertWhere,0), OE_Abort, 0, 0, pUpsert); + VdbeNoopComment((v, "End DO UPDATE of UPSERT")); +} + +#endif /* SQLITE_OMIT_UPSERT */ + +/************** End of upsert.c **********************************************/ +/************** Begin file vacuum.c ******************************************/ +/* +** 2003 April 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to implement the VACUUM command. +** +** Most of the code in this file may be omitted by defining the +** SQLITE_OMIT_VACUUM macro. +*/ +/* #include "sqliteInt.h" */ +/* #include "vdbeInt.h" */ + +#if !defined(SQLITE_OMIT_VACUUM) && !defined(SQLITE_OMIT_ATTACH) + +/* +** Execute zSql on database db. +** +** If zSql returns rows, then each row will have exactly one +** column. (This will only happen if zSql begins with "SELECT".) +** Take each row of result and call execSql() again recursively. +** +** The execSqlF() routine does the same thing, except it accepts +** a format string as its third argument +*/ +static int execSql(sqlite3 *db, char **pzErrMsg, const char *zSql){ + sqlite3_stmt *pStmt; + int rc; + + /* printf("SQL: [%s]\n", zSql); fflush(stdout); */ + rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); + if( rc!=SQLITE_OK ) return rc; + while( SQLITE_ROW==(rc = sqlite3_step(pStmt)) ){ + const char *zSubSql = (const char*)sqlite3_column_text(pStmt,0); + assert( sqlite3_strnicmp(zSql,"SELECT",6)==0 ); + /* The secondary SQL must be one of CREATE TABLE, CREATE INDEX, + ** or INSERT. Historically there have been attacks that first + ** corrupt the sqlite_schema.sql field with other kinds of statements + ** then run VACUUM to get those statements to execute at inappropriate + ** times. */ + if( zSubSql + && (strncmp(zSubSql,"CRE",3)==0 || strncmp(zSubSql,"INS",3)==0) + ){ + rc = execSql(db, pzErrMsg, zSubSql); + if( rc!=SQLITE_OK ) break; + } + } + assert( rc!=SQLITE_ROW ); + if( rc==SQLITE_DONE ) rc = SQLITE_OK; + if( rc ){ + sqlite3SetString(pzErrMsg, db, sqlite3_errmsg(db)); + } + (void)sqlite3_finalize(pStmt); + return rc; +} +static int execSqlF(sqlite3 *db, char **pzErrMsg, const char *zSql, ...){ + char *z; + va_list ap; + int rc; + va_start(ap, zSql); + z = sqlite3VMPrintf(db, zSql, ap); + va_end(ap); + if( z==0 ) return SQLITE_NOMEM; + rc = execSql(db, pzErrMsg, z); + sqlite3DbFree(db, z); + return rc; +} + +/* +** The VACUUM command is used to clean up the database, +** collapse free space, etc. It is modelled after the VACUUM command +** in PostgreSQL. The VACUUM command works as follows: +** +** (1) Create a new transient database file +** (2) Copy all content from the database being vacuumed into +** the new transient database file +** (3) Copy content from the transient database back into the +** original database. +** +** The transient database requires temporary disk space approximately +** equal to the size of the original database. The copy operation of +** step (3) requires additional temporary disk space approximately equal +** to the size of the original database for the rollback journal. +** Hence, temporary disk space that is approximately 2x the size of the +** original database is required. Every page of the database is written +** approximately 3 times: Once for step (2) and twice for step (3). +** Two writes per page are required in step (3) because the original +** database content must be written into the rollback journal prior to +** overwriting the database with the vacuumed content. +** +** Only 1x temporary space and only 1x writes would be required if +** the copy of step (3) were replaced by deleting the original database +** and renaming the transient database as the original. But that will +** not work if other processes are attached to the original database. +** And a power loss in between deleting the original and renaming the +** transient would cause the database file to appear to be deleted +** following reboot. +*/ +SQLITE_PRIVATE void sqlite3Vacuum(Parse *pParse, Token *pNm, Expr *pInto){ + Vdbe *v = sqlite3GetVdbe(pParse); + int iDb = 0; + if( v==0 ) goto build_vacuum_end; + if( pParse->nErr ) goto build_vacuum_end; + if( pNm ){ +#ifndef SQLITE_BUG_COMPATIBLE_20160819 + /* Default behavior: Report an error if the argument to VACUUM is + ** not recognized */ + iDb = sqlite3TwoPartName(pParse, pNm, pNm, &pNm); + if( iDb<0 ) goto build_vacuum_end; +#else + /* When SQLITE_BUG_COMPATIBLE_20160819 is defined, unrecognized arguments + ** to VACUUM are silently ignored. This is a back-out of a bug fix that + ** occurred on 2016-08-19 (https://www.sqlite.org/src/info/083f9e6270). + ** The buggy behavior is required for binary compatibility with some + ** legacy applications. */ + iDb = sqlite3FindDb(pParse->db, pNm); + if( iDb<0 ) iDb = 0; +#endif + } + if( iDb!=1 ){ + int iIntoReg = 0; + if( pInto && sqlite3ResolveSelfReference(pParse,0,0,pInto,0)==0 ){ + iIntoReg = ++pParse->nMem; + sqlite3ExprCode(pParse, pInto, iIntoReg); + } + sqlite3VdbeAddOp2(v, OP_Vacuum, iDb, iIntoReg); + sqlite3VdbeUsesBtree(v, iDb); + } +build_vacuum_end: + sqlite3ExprDelete(pParse->db, pInto); + return; +} + +/* +** This routine implements the OP_Vacuum opcode of the VDBE. +*/ +SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3RunVacuum( + char **pzErrMsg, /* Write error message here */ + sqlite3 *db, /* Database connection */ + int iDb, /* Which attached DB to vacuum */ + sqlite3_value *pOut /* Write results here, if not NULL. VACUUM INTO */ +){ + int rc = SQLITE_OK; /* Return code from service routines */ + Btree *pMain; /* The database being vacuumed */ + Btree *pTemp; /* The temporary database we vacuum into */ + u32 saved_mDbFlags; /* Saved value of db->mDbFlags */ + u64 saved_flags; /* Saved value of db->flags */ + i64 saved_nChange; /* Saved value of db->nChange */ + i64 saved_nTotalChange; /* Saved value of db->nTotalChange */ + u32 saved_openFlags; /* Saved value of db->openFlags */ + u8 saved_mTrace; /* Saved trace settings */ + Db *pDb = 0; /* Database to detach at end of vacuum */ + int isMemDb; /* True if vacuuming a :memory: database */ + int nRes; /* Bytes of reserved space at the end of each page */ + int nDb; /* Number of attached databases */ + const char *zDbMain; /* Schema name of database to vacuum */ + const char *zOut; /* Name of output file */ + u32 pgflags = PAGER_SYNCHRONOUS_OFF; /* sync flags for output db */ + + if( !db->autoCommit ){ + sqlite3SetString(pzErrMsg, db, "cannot VACUUM from within a transaction"); + return SQLITE_ERROR; /* IMP: R-12218-18073 */ + } + if( db->nVdbeActive>1 ){ + sqlite3SetString(pzErrMsg, db,"cannot VACUUM - SQL statements in progress"); + return SQLITE_ERROR; /* IMP: R-15610-35227 */ + } + saved_openFlags = db->openFlags; + if( pOut ){ + if( sqlite3_value_type(pOut)!=SQLITE_TEXT ){ + sqlite3SetString(pzErrMsg, db, "non-text filename"); + return SQLITE_ERROR; + } + zOut = (const char*)sqlite3_value_text(pOut); + db->openFlags &= ~SQLITE_OPEN_READONLY; + db->openFlags |= SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE; + }else{ + zOut = ""; + } + + /* Save the current value of the database flags so that it can be + ** restored before returning. Then set the writable-schema flag, and + ** disable CHECK and foreign key constraints. */ + saved_flags = db->flags; + saved_mDbFlags = db->mDbFlags; + saved_nChange = db->nChange; + saved_nTotalChange = db->nTotalChange; + saved_mTrace = db->mTrace; + db->flags |= SQLITE_WriteSchema | SQLITE_IgnoreChecks; + db->mDbFlags |= DBFLAG_PreferBuiltin | DBFLAG_Vacuum; + db->flags &= ~(u64)(SQLITE_ForeignKeys | SQLITE_ReverseOrder + | SQLITE_Defensive | SQLITE_CountRows); + db->mTrace = 0; + + zDbMain = db->aDb[iDb].zDbSName; + pMain = db->aDb[iDb].pBt; + isMemDb = sqlite3PagerIsMemdb(sqlite3BtreePager(pMain)); + + /* Attach the temporary database as 'vacuum_db'. The synchronous pragma + ** can be set to 'off' for this file, as it is not recovered if a crash + ** occurs anyway. The integrity of the database is maintained by a + ** (possibly synchronous) transaction opened on the main database before + ** sqlite3BtreeCopyFile() is called. + ** + ** An optimisation would be to use a non-journaled pager. + ** (Later:) I tried setting "PRAGMA vacuum_db.journal_mode=OFF" but + ** that actually made the VACUUM run slower. Very little journalling + ** actually occurs when doing a vacuum since the vacuum_db is initially + ** empty. Only the journal header is written. Apparently it takes more + ** time to parse and run the PRAGMA to turn journalling off than it does + ** to write the journal header file. + */ + nDb = db->nDb; + rc = execSqlF(db, pzErrMsg, "ATTACH %Q AS vacuum_db", zOut); + db->openFlags = saved_openFlags; + if( rc!=SQLITE_OK ) goto end_of_vacuum; + assert( (db->nDb-1)==nDb ); + pDb = &db->aDb[nDb]; + assert( strcmp(pDb->zDbSName,"vacuum_db")==0 ); + pTemp = pDb->pBt; + if( pOut ){ + sqlite3_file *id = sqlite3PagerFile(sqlite3BtreePager(pTemp)); + i64 sz = 0; + if( id->pMethods!=0 && (sqlite3OsFileSize(id, &sz)!=SQLITE_OK || sz>0) ){ + rc = SQLITE_ERROR; + sqlite3SetString(pzErrMsg, db, "output file already exists"); + goto end_of_vacuum; + } + db->mDbFlags |= DBFLAG_VacuumInto; + + /* For a VACUUM INTO, the pager-flags are set to the same values as + ** they are for the database being vacuumed, except that PAGER_CACHESPILL + ** is always set. */ + pgflags = db->aDb[iDb].safety_level | (db->flags & PAGER_FLAGS_MASK); + } + nRes = sqlite3BtreeGetRequestedReserve(pMain); + + /* A VACUUM cannot change the pagesize of an encrypted database. */ +/* BEGIN SQLCIPHER */ +#ifdef SQLITE_HAS_CODEC + if( db->nextPagesize ){ + extern void sqlcipherCodecGetKey(sqlite3*, int, void**, int*); + int nKey; + char *zKey; + sqlcipherCodecGetKey(db, iDb, (void**)&zKey, &nKey); + if( nKey ) db->nextPagesize = 0; + } +#endif +/* END SQLCIPHER */ + + sqlite3BtreeSetCacheSize(pTemp, db->aDb[iDb].pSchema->cache_size); + sqlite3BtreeSetSpillSize(pTemp, sqlite3BtreeSetSpillSize(pMain,0)); + sqlite3BtreeSetPagerFlags(pTemp, pgflags|PAGER_CACHESPILL); + + /* Begin a transaction and take an exclusive lock on the main database + ** file. This is done before the sqlite3BtreeGetPageSize(pMain) call below, + ** to ensure that we do not try to change the page-size on a WAL database. + */ + rc = execSql(db, pzErrMsg, "BEGIN"); + if( rc!=SQLITE_OK ) goto end_of_vacuum; + rc = sqlite3BtreeBeginTrans(pMain, pOut==0 ? 2 : 0, 0); + if( rc!=SQLITE_OK ) goto end_of_vacuum; + + /* Do not attempt to change the page size for a WAL database */ + if( sqlite3PagerGetJournalMode(sqlite3BtreePager(pMain)) + ==PAGER_JOURNALMODE_WAL + && pOut==0 + ){ + db->nextPagesize = 0; + } + + if( sqlite3BtreeSetPageSize(pTemp, sqlite3BtreeGetPageSize(pMain), nRes, 0) + || (!isMemDb && sqlite3BtreeSetPageSize(pTemp, db->nextPagesize, nRes, 0)) + || NEVER(db->mallocFailed) + ){ + rc = SQLITE_NOMEM_BKPT; + goto end_of_vacuum; + } + +#ifndef SQLITE_OMIT_AUTOVACUUM + sqlite3BtreeSetAutoVacuum(pTemp, db->nextAutovac>=0 ? db->nextAutovac : + sqlite3BtreeGetAutoVacuum(pMain)); +#endif + + /* Query the schema of the main database. Create a mirror schema + ** in the temporary database. + */ + db->init.iDb = nDb; /* force new CREATE statements into vacuum_db */ + rc = execSqlF(db, pzErrMsg, + "SELECT sql FROM \"%w\".sqlite_schema" + " WHERE type='table'AND name<>'sqlite_sequence'" + " AND coalesce(rootpage,1)>0", + zDbMain + ); + if( rc!=SQLITE_OK ) goto end_of_vacuum; + rc = execSqlF(db, pzErrMsg, + "SELECT sql FROM \"%w\".sqlite_schema" + " WHERE type='index'", + zDbMain + ); + if( rc!=SQLITE_OK ) goto end_of_vacuum; + db->init.iDb = 0; + + /* Loop through the tables in the main database. For each, do + ** an "INSERT INTO vacuum_db.xxx SELECT * FROM main.xxx;" to copy + ** the contents to the temporary database. + */ + rc = execSqlF(db, pzErrMsg, + "SELECT'INSERT INTO vacuum_db.'||quote(name)" + "||' SELECT*FROM\"%w\".'||quote(name)" + "FROM vacuum_db.sqlite_schema " + "WHERE type='table'AND coalesce(rootpage,1)>0", + zDbMain + ); + assert( (db->mDbFlags & DBFLAG_Vacuum)!=0 ); + db->mDbFlags &= ~DBFLAG_Vacuum; + if( rc!=SQLITE_OK ) goto end_of_vacuum; + + /* Copy the triggers, views, and virtual tables from the main database + ** over to the temporary database. None of these objects has any + ** associated storage, so all we have to do is copy their entries + ** from the schema table. + */ + rc = execSqlF(db, pzErrMsg, + "INSERT INTO vacuum_db.sqlite_schema" + " SELECT*FROM \"%w\".sqlite_schema" + " WHERE type IN('view','trigger')" + " OR(type='table'AND rootpage=0)", + zDbMain + ); + if( rc ) goto end_of_vacuum; + + /* At this point, there is a write transaction open on both the + ** vacuum database and the main database. Assuming no error occurs, + ** both transactions are closed by this block - the main database + ** transaction by sqlite3BtreeCopyFile() and the other by an explicit + ** call to sqlite3BtreeCommit(). + */ + { + u32 meta; + int i; + + /* This array determines which meta meta values are preserved in the + ** vacuum. Even entries are the meta value number and odd entries + ** are an increment to apply to the meta value after the vacuum. + ** The increment is used to increase the schema cookie so that other + ** connections to the same database will know to reread the schema. + */ + static const unsigned char aCopy[] = { + BTREE_SCHEMA_VERSION, 1, /* Add one to the old schema cookie */ + BTREE_DEFAULT_CACHE_SIZE, 0, /* Preserve the default page cache size */ + BTREE_TEXT_ENCODING, 0, /* Preserve the text encoding */ + BTREE_USER_VERSION, 0, /* Preserve the user version */ + BTREE_APPLICATION_ID, 0, /* Preserve the application id */ + }; + + assert( SQLITE_TXN_WRITE==sqlite3BtreeTxnState(pTemp) ); + assert( pOut!=0 || SQLITE_TXN_WRITE==sqlite3BtreeTxnState(pMain) ); + + /* Copy Btree meta values */ + for(i=0; iflags */ + db->init.iDb = 0; + db->mDbFlags = saved_mDbFlags; + db->flags = saved_flags; + db->nChange = saved_nChange; + db->nTotalChange = saved_nTotalChange; + db->mTrace = saved_mTrace; + sqlite3BtreeSetPageSize(pMain, -1, 0, 1); + + /* Currently there is an SQL level transaction open on the vacuum + ** database. No locks are held on any other files (since the main file + ** was committed at the btree level). So it safe to end the transaction + ** by manually setting the autoCommit flag to true and detaching the + ** vacuum database. The vacuum_db journal file is deleted when the pager + ** is closed by the DETACH. + */ + db->autoCommit = 1; + + if( pDb ){ + sqlite3BtreeClose(pDb->pBt); + pDb->pBt = 0; + pDb->pSchema = 0; + } + + /* This both clears the schemas and reduces the size of the db->aDb[] + ** array. */ + sqlite3ResetAllSchemasOfConnection(db); + + return rc; +} + +#endif /* SQLITE_OMIT_VACUUM && SQLITE_OMIT_ATTACH */ + +/************** End of vacuum.c **********************************************/ +/************** Begin file vtab.c ********************************************/ +/* +** 2006 June 10 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to help implement virtual tables. +*/ +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* #include "sqliteInt.h" */ + +/* +** Before a virtual table xCreate() or xConnect() method is invoked, the +** sqlite3.pVtabCtx member variable is set to point to an instance of +** this struct allocated on the stack. It is used by the implementation of +** the sqlite3_declare_vtab() and sqlite3_vtab_config() APIs, both of which +** are invoked only from within xCreate and xConnect methods. +*/ +struct VtabCtx { + VTable *pVTable; /* The virtual table being constructed */ + Table *pTab; /* The Table object to which the virtual table belongs */ + VtabCtx *pPrior; /* Parent context (if any) */ + int bDeclared; /* True after sqlite3_declare_vtab() is called */ +}; + +/* +** Construct and install a Module object for a virtual table. When this +** routine is called, it is guaranteed that all appropriate locks are held +** and the module is not already part of the connection. +** +** If there already exists a module with zName, replace it with the new one. +** If pModule==0, then delete the module zName if it exists. +*/ +SQLITE_PRIVATE Module *sqlite3VtabCreateModule( + sqlite3 *db, /* Database in which module is registered */ + const char *zName, /* Name assigned to this module */ + const sqlite3_module *pModule, /* The definition of the module */ + void *pAux, /* Context pointer for xCreate/xConnect */ + void (*xDestroy)(void *) /* Module destructor function */ +){ + Module *pMod; + Module *pDel; + char *zCopy; + if( pModule==0 ){ + zCopy = (char*)zName; + pMod = 0; + }else{ + int nName = sqlite3Strlen30(zName); + pMod = (Module *)sqlite3Malloc(sizeof(Module) + nName + 1); + if( pMod==0 ){ + sqlite3OomFault(db); + return 0; + } + zCopy = (char *)(&pMod[1]); + memcpy(zCopy, zName, nName+1); + pMod->zName = zCopy; + pMod->pModule = pModule; + pMod->pAux = pAux; + pMod->xDestroy = xDestroy; + pMod->pEpoTab = 0; + pMod->nRefModule = 1; + } + pDel = (Module *)sqlite3HashInsert(&db->aModule,zCopy,(void*)pMod); + if( pDel ){ + if( pDel==pMod ){ + sqlite3OomFault(db); + sqlite3DbFree(db, pDel); + pMod = 0; + }else{ + sqlite3VtabEponymousTableClear(db, pDel); + sqlite3VtabModuleUnref(db, pDel); + } + } + return pMod; +} + +/* +** The actual function that does the work of creating a new module. +** This function implements the sqlite3_create_module() and +** sqlite3_create_module_v2() interfaces. +*/ +static int createModule( + sqlite3 *db, /* Database in which module is registered */ + const char *zName, /* Name assigned to this module */ + const sqlite3_module *pModule, /* The definition of the module */ + void *pAux, /* Context pointer for xCreate/xConnect */ + void (*xDestroy)(void *) /* Module destructor function */ +){ + int rc = SQLITE_OK; + + sqlite3_mutex_enter(db->mutex); + (void)sqlite3VtabCreateModule(db, zName, pModule, pAux, xDestroy); + rc = sqlite3ApiExit(db, rc); + if( rc!=SQLITE_OK && xDestroy ) xDestroy(pAux); + sqlite3_mutex_leave(db->mutex); + return rc; +} + + +/* +** External API function used to create a new virtual-table module. +*/ +SQLITE_API int sqlite3_create_module( + sqlite3 *db, /* Database in which module is registered */ + const char *zName, /* Name assigned to this module */ + const sqlite3_module *pModule, /* The definition of the module */ + void *pAux /* Context pointer for xCreate/xConnect */ +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT; +#endif + return createModule(db, zName, pModule, pAux, 0); +} + +/* +** External API function used to create a new virtual-table module. +*/ +SQLITE_API int sqlite3_create_module_v2( + sqlite3 *db, /* Database in which module is registered */ + const char *zName, /* Name assigned to this module */ + const sqlite3_module *pModule, /* The definition of the module */ + void *pAux, /* Context pointer for xCreate/xConnect */ + void (*xDestroy)(void *) /* Module destructor function */ +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT; +#endif + return createModule(db, zName, pModule, pAux, xDestroy); +} + +/* +** External API to drop all virtual-table modules, except those named +** on the azNames list. +*/ +SQLITE_API int sqlite3_drop_modules(sqlite3 *db, const char** azNames){ + HashElem *pThis, *pNext; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + for(pThis=sqliteHashFirst(&db->aModule); pThis; pThis=pNext){ + Module *pMod = (Module*)sqliteHashData(pThis); + pNext = sqliteHashNext(pThis); + if( azNames ){ + int ii; + for(ii=0; azNames[ii]!=0 && strcmp(azNames[ii],pMod->zName)!=0; ii++){} + if( azNames[ii]!=0 ) continue; + } + createModule(db, pMod->zName, 0, 0, 0); + } + return SQLITE_OK; +} + +/* +** Decrement the reference count on a Module object. Destroy the +** module when the reference count reaches zero. +*/ +SQLITE_PRIVATE void sqlite3VtabModuleUnref(sqlite3 *db, Module *pMod){ + assert( pMod->nRefModule>0 ); + pMod->nRefModule--; + if( pMod->nRefModule==0 ){ + if( pMod->xDestroy ){ + pMod->xDestroy(pMod->pAux); + } + assert( pMod->pEpoTab==0 ); + sqlite3DbFree(db, pMod); + } +} + +/* +** Lock the virtual table so that it cannot be disconnected. +** Locks nest. Every lock should have a corresponding unlock. +** If an unlock is omitted, resources leaks will occur. +** +** If a disconnect is attempted while a virtual table is locked, +** the disconnect is deferred until all locks have been removed. +*/ +SQLITE_PRIVATE void sqlite3VtabLock(VTable *pVTab){ + pVTab->nRef++; +} + + +/* +** pTab is a pointer to a Table structure representing a virtual-table. +** Return a pointer to the VTable object used by connection db to access +** this virtual-table, if one has been created, or NULL otherwise. +*/ +SQLITE_PRIVATE VTable *sqlite3GetVTable(sqlite3 *db, Table *pTab){ + VTable *pVtab; + assert( IsVirtual(pTab) ); + for(pVtab=pTab->u.vtab.p; pVtab && pVtab->db!=db; pVtab=pVtab->pNext); + return pVtab; +} + +/* +** Decrement the ref-count on a virtual table object. When the ref-count +** reaches zero, call the xDisconnect() method to delete the object. +*/ +SQLITE_PRIVATE void sqlite3VtabUnlock(VTable *pVTab){ + sqlite3 *db = pVTab->db; + + assert( db ); + assert( pVTab->nRef>0 ); + assert( db->eOpenState==SQLITE_STATE_OPEN + || db->eOpenState==SQLITE_STATE_ZOMBIE ); + + pVTab->nRef--; + if( pVTab->nRef==0 ){ + sqlite3_vtab *p = pVTab->pVtab; + if( p ){ + p->pModule->xDisconnect(p); + } + sqlite3VtabModuleUnref(pVTab->db, pVTab->pMod); + sqlite3DbFree(db, pVTab); + } +} + +/* +** Table p is a virtual table. This function moves all elements in the +** p->u.vtab.p list to the sqlite3.pDisconnect lists of their associated +** database connections to be disconnected at the next opportunity. +** Except, if argument db is not NULL, then the entry associated with +** connection db is left in the p->u.vtab.p list. +*/ +static VTable *vtabDisconnectAll(sqlite3 *db, Table *p){ + VTable *pRet = 0; + VTable *pVTable; + + assert( IsVirtual(p) ); + pVTable = p->u.vtab.p; + p->u.vtab.p = 0; + + /* Assert that the mutex (if any) associated with the BtShared database + ** that contains table p is held by the caller. See header comments + ** above function sqlite3VtabUnlockList() for an explanation of why + ** this makes it safe to access the sqlite3.pDisconnect list of any + ** database connection that may have an entry in the p->u.vtab.p list. + */ + assert( db==0 || sqlite3SchemaMutexHeld(db, 0, p->pSchema) ); + + while( pVTable ){ + sqlite3 *db2 = pVTable->db; + VTable *pNext = pVTable->pNext; + assert( db2 ); + if( db2==db ){ + pRet = pVTable; + p->u.vtab.p = pRet; + pRet->pNext = 0; + }else{ + pVTable->pNext = db2->pDisconnect; + db2->pDisconnect = pVTable; + } + pVTable = pNext; + } + + assert( !db || pRet ); + return pRet; +} + +/* +** Table *p is a virtual table. This function removes the VTable object +** for table *p associated with database connection db from the linked +** list in p->pVTab. It also decrements the VTable ref count. This is +** used when closing database connection db to free all of its VTable +** objects without disturbing the rest of the Schema object (which may +** be being used by other shared-cache connections). +*/ +SQLITE_PRIVATE void sqlite3VtabDisconnect(sqlite3 *db, Table *p){ + VTable **ppVTab; + + assert( IsVirtual(p) ); + assert( sqlite3BtreeHoldsAllMutexes(db) ); + assert( sqlite3_mutex_held(db->mutex) ); + + for(ppVTab=&p->u.vtab.p; *ppVTab; ppVTab=&(*ppVTab)->pNext){ + if( (*ppVTab)->db==db ){ + VTable *pVTab = *ppVTab; + *ppVTab = pVTab->pNext; + sqlite3VtabUnlock(pVTab); + break; + } + } +} + + +/* +** Disconnect all the virtual table objects in the sqlite3.pDisconnect list. +** +** This function may only be called when the mutexes associated with all +** shared b-tree databases opened using connection db are held by the +** caller. This is done to protect the sqlite3.pDisconnect list. The +** sqlite3.pDisconnect list is accessed only as follows: +** +** 1) By this function. In this case, all BtShared mutexes and the mutex +** associated with the database handle itself must be held. +** +** 2) By function vtabDisconnectAll(), when it adds a VTable entry to +** the sqlite3.pDisconnect list. In this case either the BtShared mutex +** associated with the database the virtual table is stored in is held +** or, if the virtual table is stored in a non-sharable database, then +** the database handle mutex is held. +** +** As a result, a sqlite3.pDisconnect cannot be accessed simultaneously +** by multiple threads. It is thread-safe. +*/ +SQLITE_PRIVATE void sqlite3VtabUnlockList(sqlite3 *db){ + VTable *p = db->pDisconnect; + + assert( sqlite3BtreeHoldsAllMutexes(db) ); + assert( sqlite3_mutex_held(db->mutex) ); + + if( p ){ + db->pDisconnect = 0; + sqlite3ExpirePreparedStatements(db, 0); + do { + VTable *pNext = p->pNext; + sqlite3VtabUnlock(p); + p = pNext; + }while( p ); + } +} + +/* +** Clear any and all virtual-table information from the Table record. +** This routine is called, for example, just before deleting the Table +** record. +** +** Since it is a virtual-table, the Table structure contains a pointer +** to the head of a linked list of VTable structures. Each VTable +** structure is associated with a single sqlite3* user of the schema. +** The reference count of the VTable structure associated with database +** connection db is decremented immediately (which may lead to the +** structure being xDisconnected and free). Any other VTable structures +** in the list are moved to the sqlite3.pDisconnect list of the associated +** database connection. +*/ +SQLITE_PRIVATE void sqlite3VtabClear(sqlite3 *db, Table *p){ + assert( IsVirtual(p) ); + assert( db!=0 ); + if( db->pnBytesFreed==0 ) vtabDisconnectAll(0, p); + if( p->u.vtab.azArg ){ + int i; + for(i=0; iu.vtab.nArg; i++){ + if( i!=1 ) sqlite3DbFree(db, p->u.vtab.azArg[i]); + } + sqlite3DbFree(db, p->u.vtab.azArg); + } +} + +/* +** Add a new module argument to pTable->u.vtab.azArg[]. +** The string is not copied - the pointer is stored. The +** string will be freed automatically when the table is +** deleted. +*/ +static void addModuleArgument(Parse *pParse, Table *pTable, char *zArg){ + sqlite3_int64 nBytes; + char **azModuleArg; + sqlite3 *db = pParse->db; + + assert( IsVirtual(pTable) ); + nBytes = sizeof(char *)*(2+pTable->u.vtab.nArg); + if( pTable->u.vtab.nArg+3>=db->aLimit[SQLITE_LIMIT_COLUMN] ){ + sqlite3ErrorMsg(pParse, "too many columns on %s", pTable->zName); + } + azModuleArg = sqlite3DbRealloc(db, pTable->u.vtab.azArg, nBytes); + if( azModuleArg==0 ){ + sqlite3DbFree(db, zArg); + }else{ + int i = pTable->u.vtab.nArg++; + azModuleArg[i] = zArg; + azModuleArg[i+1] = 0; + pTable->u.vtab.azArg = azModuleArg; + } +} + +/* +** The parser calls this routine when it first sees a CREATE VIRTUAL TABLE +** statement. The module name has been parsed, but the optional list +** of parameters that follow the module name are still pending. +*/ +SQLITE_PRIVATE void sqlite3VtabBeginParse( + Parse *pParse, /* Parsing context */ + Token *pName1, /* Name of new table, or database name */ + Token *pName2, /* Name of new table or NULL */ + Token *pModuleName, /* Name of the module for the virtual table */ + int ifNotExists /* No error if the table already exists */ +){ + Table *pTable; /* The new virtual table */ + sqlite3 *db; /* Database connection */ + + sqlite3StartTable(pParse, pName1, pName2, 0, 0, 1, ifNotExists); + pTable = pParse->pNewTable; + if( pTable==0 ) return; + assert( 0==pTable->pIndex ); + pTable->eTabType = TABTYP_VTAB; + + db = pParse->db; + + assert( pTable->u.vtab.nArg==0 ); + addModuleArgument(pParse, pTable, sqlite3NameFromToken(db, pModuleName)); + addModuleArgument(pParse, pTable, 0); + addModuleArgument(pParse, pTable, sqlite3DbStrDup(db, pTable->zName)); + assert( (pParse->sNameToken.z==pName2->z && pName2->z!=0) + || (pParse->sNameToken.z==pName1->z && pName2->z==0) + ); + pParse->sNameToken.n = (int)( + &pModuleName->z[pModuleName->n] - pParse->sNameToken.z + ); + +#ifndef SQLITE_OMIT_AUTHORIZATION + /* Creating a virtual table invokes the authorization callback twice. + ** The first invocation, to obtain permission to INSERT a row into the + ** sqlite_schema table, has already been made by sqlite3StartTable(). + ** The second call, to obtain permission to create the table, is made now. + */ + if( pTable->u.vtab.azArg ){ + int iDb = sqlite3SchemaToIndex(db, pTable->pSchema); + assert( iDb>=0 ); /* The database the table is being created in */ + sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName, + pTable->u.vtab.azArg[0], pParse->db->aDb[iDb].zDbSName); + } +#endif +} + +/* +** This routine takes the module argument that has been accumulating +** in pParse->zArg[] and appends it to the list of arguments on the +** virtual table currently under construction in pParse->pTable. +*/ +static void addArgumentToVtab(Parse *pParse){ + if( pParse->sArg.z && pParse->pNewTable ){ + const char *z = (const char*)pParse->sArg.z; + int n = pParse->sArg.n; + sqlite3 *db = pParse->db; + addModuleArgument(pParse, pParse->pNewTable, sqlite3DbStrNDup(db, z, n)); + } +} + +/* +** The parser calls this routine after the CREATE VIRTUAL TABLE statement +** has been completely parsed. +*/ +SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){ + Table *pTab = pParse->pNewTable; /* The table being constructed */ + sqlite3 *db = pParse->db; /* The database connection */ + + if( pTab==0 ) return; + assert( IsVirtual(pTab) ); + addArgumentToVtab(pParse); + pParse->sArg.z = 0; + if( pTab->u.vtab.nArg<1 ) return; + + /* If the CREATE VIRTUAL TABLE statement is being entered for the + ** first time (in other words if the virtual table is actually being + ** created now instead of just being read out of sqlite_schema) then + ** do additional initialization work and store the statement text + ** in the sqlite_schema table. + */ + if( !db->init.busy ){ + char *zStmt; + char *zWhere; + int iDb; + int iReg; + Vdbe *v; + + sqlite3MayAbort(pParse); + + /* Compute the complete text of the CREATE VIRTUAL TABLE statement */ + if( pEnd ){ + pParse->sNameToken.n = (int)(pEnd->z - pParse->sNameToken.z) + pEnd->n; + } + zStmt = sqlite3MPrintf(db, "CREATE VIRTUAL TABLE %T", &pParse->sNameToken); + + /* A slot for the record has already been allocated in the + ** schema table. We just need to update that slot with all + ** the information we've collected. + ** + ** The VM register number pParse->regRowid holds the rowid of an + ** entry in the sqlite_schema table tht was created for this vtab + ** by sqlite3StartTable(). + */ + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + sqlite3NestedParse(pParse, + "UPDATE %Q." LEGACY_SCHEMA_TABLE " " + "SET type='table', name=%Q, tbl_name=%Q, rootpage=0, sql=%Q " + "WHERE rowid=#%d", + db->aDb[iDb].zDbSName, + pTab->zName, + pTab->zName, + zStmt, + pParse->regRowid + ); + v = sqlite3GetVdbe(pParse); + sqlite3ChangeCookie(pParse, iDb); + + sqlite3VdbeAddOp0(v, OP_Expire); + zWhere = sqlite3MPrintf(db, "name=%Q AND sql=%Q", pTab->zName, zStmt); + sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere, 0); + sqlite3DbFree(db, zStmt); + + iReg = ++pParse->nMem; + sqlite3VdbeLoadString(v, iReg, pTab->zName); + sqlite3VdbeAddOp2(v, OP_VCreate, iDb, iReg); + }else{ + /* If we are rereading the sqlite_schema table create the in-memory + ** record of the table. */ + Table *pOld; + Schema *pSchema = pTab->pSchema; + const char *zName = pTab->zName; + assert( zName!=0 ); + sqlite3MarkAllShadowTablesOf(db, pTab); + pOld = sqlite3HashInsert(&pSchema->tblHash, zName, pTab); + if( pOld ){ + sqlite3OomFault(db); + assert( pTab==pOld ); /* Malloc must have failed inside HashInsert() */ + return; + } + pParse->pNewTable = 0; + } +} + +/* +** The parser calls this routine when it sees the first token +** of an argument to the module name in a CREATE VIRTUAL TABLE statement. +*/ +SQLITE_PRIVATE void sqlite3VtabArgInit(Parse *pParse){ + addArgumentToVtab(pParse); + pParse->sArg.z = 0; + pParse->sArg.n = 0; +} + +/* +** The parser calls this routine for each token after the first token +** in an argument to the module name in a CREATE VIRTUAL TABLE statement. +*/ +SQLITE_PRIVATE void sqlite3VtabArgExtend(Parse *pParse, Token *p){ + Token *pArg = &pParse->sArg; + if( pArg->z==0 ){ + pArg->z = p->z; + pArg->n = p->n; + }else{ + assert(pArg->z <= p->z); + pArg->n = (int)(&p->z[p->n] - pArg->z); + } +} + +/* +** Invoke a virtual table constructor (either xCreate or xConnect). The +** pointer to the function to invoke is passed as the fourth parameter +** to this procedure. +*/ +static int vtabCallConstructor( + sqlite3 *db, + Table *pTab, + Module *pMod, + int (*xConstruct)(sqlite3*,void*,int,const char*const*,sqlite3_vtab**,char**), + char **pzErr +){ + VtabCtx sCtx; + VTable *pVTable; + int rc; + const char *const*azArg; + int nArg = pTab->u.vtab.nArg; + char *zErr = 0; + char *zModuleName; + int iDb; + VtabCtx *pCtx; + + assert( IsVirtual(pTab) ); + azArg = (const char *const*)pTab->u.vtab.azArg; + + /* Check that the virtual-table is not already being initialized */ + for(pCtx=db->pVtabCtx; pCtx; pCtx=pCtx->pPrior){ + if( pCtx->pTab==pTab ){ + *pzErr = sqlite3MPrintf(db, + "vtable constructor called recursively: %s", pTab->zName + ); + return SQLITE_LOCKED; + } + } + + zModuleName = sqlite3DbStrDup(db, pTab->zName); + if( !zModuleName ){ + return SQLITE_NOMEM_BKPT; + } + + pVTable = sqlite3MallocZero(sizeof(VTable)); + if( !pVTable ){ + sqlite3OomFault(db); + sqlite3DbFree(db, zModuleName); + return SQLITE_NOMEM_BKPT; + } + pVTable->db = db; + pVTable->pMod = pMod; + pVTable->eVtabRisk = SQLITE_VTABRISK_Normal; + + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + pTab->u.vtab.azArg[1] = db->aDb[iDb].zDbSName; + + /* Invoke the virtual table constructor */ + assert( &db->pVtabCtx ); + assert( xConstruct ); + sCtx.pTab = pTab; + sCtx.pVTable = pVTable; + sCtx.pPrior = db->pVtabCtx; + sCtx.bDeclared = 0; + db->pVtabCtx = &sCtx; + pTab->nTabRef++; + rc = xConstruct(db, pMod->pAux, nArg, azArg, &pVTable->pVtab, &zErr); + sqlite3DeleteTable(db, pTab); + db->pVtabCtx = sCtx.pPrior; + if( rc==SQLITE_NOMEM ) sqlite3OomFault(db); + assert( sCtx.pTab==pTab ); + + if( SQLITE_OK!=rc ){ + if( zErr==0 ){ + *pzErr = sqlite3MPrintf(db, "vtable constructor failed: %s", zModuleName); + }else { + *pzErr = sqlite3MPrintf(db, "%s", zErr); + sqlite3_free(zErr); + } + sqlite3DbFree(db, pVTable); + }else if( ALWAYS(pVTable->pVtab) ){ + /* Justification of ALWAYS(): A correct vtab constructor must allocate + ** the sqlite3_vtab object if successful. */ + memset(pVTable->pVtab, 0, sizeof(pVTable->pVtab[0])); + pVTable->pVtab->pModule = pMod->pModule; + pMod->nRefModule++; + pVTable->nRef = 1; + if( sCtx.bDeclared==0 ){ + const char *zFormat = "vtable constructor did not declare schema: %s"; + *pzErr = sqlite3MPrintf(db, zFormat, pTab->zName); + sqlite3VtabUnlock(pVTable); + rc = SQLITE_ERROR; + }else{ + int iCol; + u16 oooHidden = 0; + /* If everything went according to plan, link the new VTable structure + ** into the linked list headed by pTab->u.vtab.p. Then loop through the + ** columns of the table to see if any of them contain the token "hidden". + ** If so, set the Column COLFLAG_HIDDEN flag and remove the token from + ** the type string. */ + pVTable->pNext = pTab->u.vtab.p; + pTab->u.vtab.p = pVTable; + + for(iCol=0; iColnCol; iCol++){ + char *zType = sqlite3ColumnType(&pTab->aCol[iCol], ""); + int nType; + int i = 0; + nType = sqlite3Strlen30(zType); + for(i=0; i0 ){ + assert(zType[i-1]==' '); + zType[i-1] = '\0'; + } + pTab->aCol[iCol].colFlags |= COLFLAG_HIDDEN; + pTab->tabFlags |= TF_HasHidden; + oooHidden = TF_OOOHidden; + }else{ + pTab->tabFlags |= oooHidden; + } + } + } + } + + sqlite3DbFree(db, zModuleName); + return rc; +} + +/* +** This function is invoked by the parser to call the xConnect() method +** of the virtual table pTab. If an error occurs, an error code is returned +** and an error left in pParse. +** +** This call is a no-op if table pTab is not a virtual table. +*/ +SQLITE_PRIVATE int sqlite3VtabCallConnect(Parse *pParse, Table *pTab){ + sqlite3 *db = pParse->db; + const char *zMod; + Module *pMod; + int rc; + + assert( pTab ); + assert( IsVirtual(pTab) ); + if( sqlite3GetVTable(db, pTab) ){ + return SQLITE_OK; + } + + /* Locate the required virtual table module */ + zMod = pTab->u.vtab.azArg[0]; + pMod = (Module*)sqlite3HashFind(&db->aModule, zMod); + + if( !pMod ){ + const char *zModule = pTab->u.vtab.azArg[0]; + sqlite3ErrorMsg(pParse, "no such module: %s", zModule); + rc = SQLITE_ERROR; + }else{ + char *zErr = 0; + rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xConnect, &zErr); + if( rc!=SQLITE_OK ){ + sqlite3ErrorMsg(pParse, "%s", zErr); + pParse->rc = rc; + } + sqlite3DbFree(db, zErr); + } + + return rc; +} +/* +** Grow the db->aVTrans[] array so that there is room for at least one +** more v-table. Return SQLITE_NOMEM if a malloc fails, or SQLITE_OK otherwise. +*/ +static int growVTrans(sqlite3 *db){ + const int ARRAY_INCR = 5; + + /* Grow the sqlite3.aVTrans array if required */ + if( (db->nVTrans%ARRAY_INCR)==0 ){ + VTable **aVTrans; + sqlite3_int64 nBytes = sizeof(sqlite3_vtab*)* + ((sqlite3_int64)db->nVTrans + ARRAY_INCR); + aVTrans = sqlite3DbRealloc(db, (void *)db->aVTrans, nBytes); + if( !aVTrans ){ + return SQLITE_NOMEM_BKPT; + } + memset(&aVTrans[db->nVTrans], 0, sizeof(sqlite3_vtab *)*ARRAY_INCR); + db->aVTrans = aVTrans; + } + + return SQLITE_OK; +} + +/* +** Add the virtual table pVTab to the array sqlite3.aVTrans[]. Space should +** have already been reserved using growVTrans(). +*/ +static void addToVTrans(sqlite3 *db, VTable *pVTab){ + /* Add pVtab to the end of sqlite3.aVTrans */ + db->aVTrans[db->nVTrans++] = pVTab; + sqlite3VtabLock(pVTab); +} + +/* +** This function is invoked by the vdbe to call the xCreate method +** of the virtual table named zTab in database iDb. +** +** If an error occurs, *pzErr is set to point to an English language +** description of the error and an SQLITE_XXX error code is returned. +** In this case the caller must call sqlite3DbFree(db, ) on *pzErr. +*/ +SQLITE_PRIVATE int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab, char **pzErr){ + int rc = SQLITE_OK; + Table *pTab; + Module *pMod; + const char *zMod; + + pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName); + assert( pTab && IsVirtual(pTab) && !pTab->u.vtab.p ); + + /* Locate the required virtual table module */ + zMod = pTab->u.vtab.azArg[0]; + pMod = (Module*)sqlite3HashFind(&db->aModule, zMod); + + /* If the module has been registered and includes a Create method, + ** invoke it now. If the module has not been registered, return an + ** error. Otherwise, do nothing. + */ + if( pMod==0 || pMod->pModule->xCreate==0 || pMod->pModule->xDestroy==0 ){ + *pzErr = sqlite3MPrintf(db, "no such module: %s", zMod); + rc = SQLITE_ERROR; + }else{ + rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xCreate, pzErr); + } + + /* Justification of ALWAYS(): The xConstructor method is required to + ** create a valid sqlite3_vtab if it returns SQLITE_OK. */ + if( rc==SQLITE_OK && ALWAYS(sqlite3GetVTable(db, pTab)) ){ + rc = growVTrans(db); + if( rc==SQLITE_OK ){ + addToVTrans(db, sqlite3GetVTable(db, pTab)); + } + } + + return rc; +} + +/* +** This function is used to set the schema of a virtual table. It is only +** valid to call this function from within the xCreate() or xConnect() of a +** virtual table module. +*/ +SQLITE_API int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){ + VtabCtx *pCtx; + int rc = SQLITE_OK; + Table *pTab; + Parse sParse; + int initBusy; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zCreateTable==0 ){ + return SQLITE_MISUSE_BKPT; + } +#endif + sqlite3_mutex_enter(db->mutex); + pCtx = db->pVtabCtx; + if( !pCtx || pCtx->bDeclared ){ + sqlite3Error(db, SQLITE_MISUSE); + sqlite3_mutex_leave(db->mutex); + return SQLITE_MISUSE_BKPT; + } + pTab = pCtx->pTab; + assert( IsVirtual(pTab) ); + + sqlite3ParseObjectInit(&sParse, db); + sParse.eParseMode = PARSE_MODE_DECLARE_VTAB; + sParse.disableTriggers = 1; + /* We should never be able to reach this point while loading the + ** schema. Nevertheless, defend against that (turn off db->init.busy) + ** in case a bug arises. */ + assert( db->init.busy==0 ); + initBusy = db->init.busy; + db->init.busy = 0; + sParse.nQueryLoop = 1; + if( SQLITE_OK==sqlite3RunParser(&sParse, zCreateTable) + && ALWAYS(sParse.pNewTable!=0) + && ALWAYS(!db->mallocFailed) + && IsOrdinaryTable(sParse.pNewTable) + ){ + assert( sParse.zErrMsg==0 ); + if( !pTab->aCol ){ + Table *pNew = sParse.pNewTable; + Index *pIdx; + pTab->aCol = pNew->aCol; + sqlite3ExprListDelete(db, pNew->u.tab.pDfltList); + pTab->nNVCol = pTab->nCol = pNew->nCol; + pTab->tabFlags |= pNew->tabFlags & (TF_WithoutRowid|TF_NoVisibleRowid); + pNew->nCol = 0; + pNew->aCol = 0; + assert( pTab->pIndex==0 ); + assert( HasRowid(pNew) || sqlite3PrimaryKeyIndex(pNew)!=0 ); + if( !HasRowid(pNew) + && pCtx->pVTable->pMod->pModule->xUpdate!=0 + && sqlite3PrimaryKeyIndex(pNew)->nKeyCol!=1 + ){ + /* WITHOUT ROWID virtual tables must either be read-only (xUpdate==0) + ** or else must have a single-column PRIMARY KEY */ + rc = SQLITE_ERROR; + } + pIdx = pNew->pIndex; + if( pIdx ){ + assert( pIdx->pNext==0 ); + pTab->pIndex = pIdx; + pNew->pIndex = 0; + pIdx->pTable = pTab; + } + } + pCtx->bDeclared = 1; + }else{ + sqlite3ErrorWithMsg(db, SQLITE_ERROR, + (sParse.zErrMsg ? "%s" : 0), sParse.zErrMsg); + sqlite3DbFree(db, sParse.zErrMsg); + rc = SQLITE_ERROR; + } + sParse.eParseMode = PARSE_MODE_NORMAL; + + if( sParse.pVdbe ){ + sqlite3VdbeFinalize(sParse.pVdbe); + } + sqlite3DeleteTable(db, sParse.pNewTable); + sqlite3ParseObjectReset(&sParse); + db->init.busy = initBusy; + + assert( (rc&0xff)==rc ); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** This function is invoked by the vdbe to call the xDestroy method +** of the virtual table named zTab in database iDb. This occurs +** when a DROP TABLE is mentioned. +** +** This call is a no-op if zTab is not a virtual table. +*/ +SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab){ + int rc = SQLITE_OK; + Table *pTab; + + pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName); + if( ALWAYS(pTab!=0) + && ALWAYS(IsVirtual(pTab)) + && ALWAYS(pTab->u.vtab.p!=0) + ){ + VTable *p; + int (*xDestroy)(sqlite3_vtab *); + for(p=pTab->u.vtab.p; p; p=p->pNext){ + assert( p->pVtab ); + if( p->pVtab->nRef>0 ){ + return SQLITE_LOCKED; + } + } + p = vtabDisconnectAll(db, pTab); + xDestroy = p->pMod->pModule->xDestroy; + if( xDestroy==0 ) xDestroy = p->pMod->pModule->xDisconnect; + assert( xDestroy!=0 ); + pTab->nTabRef++; + rc = xDestroy(p->pVtab); + /* Remove the sqlite3_vtab* from the aVTrans[] array, if applicable */ + if( rc==SQLITE_OK ){ + assert( pTab->u.vtab.p==p && p->pNext==0 ); + p->pVtab = 0; + pTab->u.vtab.p = 0; + sqlite3VtabUnlock(p); + } + sqlite3DeleteTable(db, pTab); + } + + return rc; +} + +/* +** This function invokes either the xRollback or xCommit method +** of each of the virtual tables in the sqlite3.aVTrans array. The method +** called is identified by the second argument, "offset", which is +** the offset of the method to call in the sqlite3_module structure. +** +** The array is cleared after invoking the callbacks. +*/ +static void callFinaliser(sqlite3 *db, int offset){ + int i; + if( db->aVTrans ){ + VTable **aVTrans = db->aVTrans; + db->aVTrans = 0; + for(i=0; inVTrans; i++){ + VTable *pVTab = aVTrans[i]; + sqlite3_vtab *p = pVTab->pVtab; + if( p ){ + int (*x)(sqlite3_vtab *); + x = *(int (**)(sqlite3_vtab *))((char *)p->pModule + offset); + if( x ) x(p); + } + pVTab->iSavepoint = 0; + sqlite3VtabUnlock(pVTab); + } + sqlite3DbFree(db, aVTrans); + db->nVTrans = 0; + } +} + +/* +** Invoke the xSync method of all virtual tables in the sqlite3.aVTrans +** array. Return the error code for the first error that occurs, or +** SQLITE_OK if all xSync operations are successful. +** +** If an error message is available, leave it in p->zErrMsg. +*/ +SQLITE_PRIVATE int sqlite3VtabSync(sqlite3 *db, Vdbe *p){ + int i; + int rc = SQLITE_OK; + VTable **aVTrans = db->aVTrans; + + db->aVTrans = 0; + for(i=0; rc==SQLITE_OK && inVTrans; i++){ + int (*x)(sqlite3_vtab *); + sqlite3_vtab *pVtab = aVTrans[i]->pVtab; + if( pVtab && (x = pVtab->pModule->xSync)!=0 ){ + rc = x(pVtab); + sqlite3VtabImportErrmsg(p, pVtab); + } + } + db->aVTrans = aVTrans; + return rc; +} + +/* +** Invoke the xRollback method of all virtual tables in the +** sqlite3.aVTrans array. Then clear the array itself. +*/ +SQLITE_PRIVATE int sqlite3VtabRollback(sqlite3 *db){ + callFinaliser(db, offsetof(sqlite3_module,xRollback)); + return SQLITE_OK; +} + +/* +** Invoke the xCommit method of all virtual tables in the +** sqlite3.aVTrans array. Then clear the array itself. +*/ +SQLITE_PRIVATE int sqlite3VtabCommit(sqlite3 *db){ + callFinaliser(db, offsetof(sqlite3_module,xCommit)); + return SQLITE_OK; +} + +/* +** If the virtual table pVtab supports the transaction interface +** (xBegin/xRollback/xCommit and optionally xSync) and a transaction is +** not currently open, invoke the xBegin method now. +** +** If the xBegin call is successful, place the sqlite3_vtab pointer +** in the sqlite3.aVTrans array. +*/ +SQLITE_PRIVATE int sqlite3VtabBegin(sqlite3 *db, VTable *pVTab){ + int rc = SQLITE_OK; + const sqlite3_module *pModule; + + /* Special case: If db->aVTrans is NULL and db->nVTrans is greater + ** than zero, then this function is being called from within a + ** virtual module xSync() callback. It is illegal to write to + ** virtual module tables in this case, so return SQLITE_LOCKED. + */ + if( sqlite3VtabInSync(db) ){ + return SQLITE_LOCKED; + } + if( !pVTab ){ + return SQLITE_OK; + } + pModule = pVTab->pVtab->pModule; + + if( pModule->xBegin ){ + int i; + + /* If pVtab is already in the aVTrans array, return early */ + for(i=0; inVTrans; i++){ + if( db->aVTrans[i]==pVTab ){ + return SQLITE_OK; + } + } + + /* Invoke the xBegin method. If successful, add the vtab to the + ** sqlite3.aVTrans[] array. */ + rc = growVTrans(db); + if( rc==SQLITE_OK ){ + rc = pModule->xBegin(pVTab->pVtab); + if( rc==SQLITE_OK ){ + int iSvpt = db->nStatement + db->nSavepoint; + addToVTrans(db, pVTab); + if( iSvpt && pModule->xSavepoint ){ + pVTab->iSavepoint = iSvpt; + rc = pModule->xSavepoint(pVTab->pVtab, iSvpt-1); + } + } + } + } + return rc; +} + +/* +** Invoke either the xSavepoint, xRollbackTo or xRelease method of all +** virtual tables that currently have an open transaction. Pass iSavepoint +** as the second argument to the virtual table method invoked. +** +** If op is SAVEPOINT_BEGIN, the xSavepoint method is invoked. If it is +** SAVEPOINT_ROLLBACK, the xRollbackTo method. Otherwise, if op is +** SAVEPOINT_RELEASE, then the xRelease method of each virtual table with +** an open transaction is invoked. +** +** If any virtual table method returns an error code other than SQLITE_OK, +** processing is abandoned and the error returned to the caller of this +** function immediately. If all calls to virtual table methods are successful, +** SQLITE_OK is returned. +*/ +SQLITE_PRIVATE int sqlite3VtabSavepoint(sqlite3 *db, int op, int iSavepoint){ + int rc = SQLITE_OK; + + assert( op==SAVEPOINT_RELEASE||op==SAVEPOINT_ROLLBACK||op==SAVEPOINT_BEGIN ); + assert( iSavepoint>=-1 ); + if( db->aVTrans ){ + int i; + for(i=0; rc==SQLITE_OK && inVTrans; i++){ + VTable *pVTab = db->aVTrans[i]; + const sqlite3_module *pMod = pVTab->pMod->pModule; + if( pVTab->pVtab && pMod->iVersion>=2 ){ + int (*xMethod)(sqlite3_vtab *, int); + sqlite3VtabLock(pVTab); + switch( op ){ + case SAVEPOINT_BEGIN: + xMethod = pMod->xSavepoint; + pVTab->iSavepoint = iSavepoint+1; + break; + case SAVEPOINT_ROLLBACK: + xMethod = pMod->xRollbackTo; + break; + default: + xMethod = pMod->xRelease; + break; + } + if( xMethod && pVTab->iSavepoint>iSavepoint ){ + u64 savedFlags = (db->flags & SQLITE_Defensive); + db->flags &= ~(u64)SQLITE_Defensive; + rc = xMethod(pVTab->pVtab, iSavepoint); + db->flags |= savedFlags; + } + sqlite3VtabUnlock(pVTab); + } + } + } + return rc; +} + +/* +** The first parameter (pDef) is a function implementation. The +** second parameter (pExpr) is the first argument to this function. +** If pExpr is a column in a virtual table, then let the virtual +** table implementation have an opportunity to overload the function. +** +** This routine is used to allow virtual table implementations to +** overload MATCH, LIKE, GLOB, and REGEXP operators. +** +** Return either the pDef argument (indicating no change) or a +** new FuncDef structure that is marked as ephemeral using the +** SQLITE_FUNC_EPHEM flag. +*/ +SQLITE_PRIVATE FuncDef *sqlite3VtabOverloadFunction( + sqlite3 *db, /* Database connection for reporting malloc problems */ + FuncDef *pDef, /* Function to possibly overload */ + int nArg, /* Number of arguments to the function */ + Expr *pExpr /* First argument to the function */ +){ + Table *pTab; + sqlite3_vtab *pVtab; + sqlite3_module *pMod; + void (*xSFunc)(sqlite3_context*,int,sqlite3_value**) = 0; + void *pArg = 0; + FuncDef *pNew; + int rc = 0; + + /* Check to see the left operand is a column in a virtual table */ + if( NEVER(pExpr==0) ) return pDef; + if( pExpr->op!=TK_COLUMN ) return pDef; + assert( ExprUseYTab(pExpr) ); + pTab = pExpr->y.pTab; + if( NEVER(pTab==0) ) return pDef; + if( !IsVirtual(pTab) ) return pDef; + pVtab = sqlite3GetVTable(db, pTab)->pVtab; + assert( pVtab!=0 ); + assert( pVtab->pModule!=0 ); + pMod = (sqlite3_module *)pVtab->pModule; + if( pMod->xFindFunction==0 ) return pDef; + + /* Call the xFindFunction method on the virtual table implementation + ** to see if the implementation wants to overload this function. + ** + ** Though undocumented, we have historically always invoked xFindFunction + ** with an all lower-case function name. Continue in this tradition to + ** avoid any chance of an incompatibility. + */ +#ifdef SQLITE_DEBUG + { + int i; + for(i=0; pDef->zName[i]; i++){ + unsigned char x = (unsigned char)pDef->zName[i]; + assert( x==sqlite3UpperToLower[x] ); + } + } +#endif + rc = pMod->xFindFunction(pVtab, nArg, pDef->zName, &xSFunc, &pArg); + if( rc==0 ){ + return pDef; + } + + /* Create a new ephemeral function definition for the overloaded + ** function */ + pNew = sqlite3DbMallocZero(db, sizeof(*pNew) + + sqlite3Strlen30(pDef->zName) + 1); + if( pNew==0 ){ + return pDef; + } + *pNew = *pDef; + pNew->zName = (const char*)&pNew[1]; + memcpy((char*)&pNew[1], pDef->zName, sqlite3Strlen30(pDef->zName)+1); + pNew->xSFunc = xSFunc; + pNew->pUserData = pArg; + pNew->funcFlags |= SQLITE_FUNC_EPHEM; + return pNew; +} + +/* +** Make sure virtual table pTab is contained in the pParse->apVirtualLock[] +** array so that an OP_VBegin will get generated for it. Add pTab to the +** array if it is missing. If pTab is already in the array, this routine +** is a no-op. +*/ +SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){ + Parse *pToplevel = sqlite3ParseToplevel(pParse); + int i, n; + Table **apVtabLock; + + assert( IsVirtual(pTab) ); + for(i=0; inVtabLock; i++){ + if( pTab==pToplevel->apVtabLock[i] ) return; + } + n = (pToplevel->nVtabLock+1)*sizeof(pToplevel->apVtabLock[0]); + apVtabLock = sqlite3Realloc(pToplevel->apVtabLock, n); + if( apVtabLock ){ + pToplevel->apVtabLock = apVtabLock; + pToplevel->apVtabLock[pToplevel->nVtabLock++] = pTab; + }else{ + sqlite3OomFault(pToplevel->db); + } +} + +/* +** Check to see if virtual table module pMod can be have an eponymous +** virtual table instance. If it can, create one if one does not already +** exist. Return non-zero if either the eponymous virtual table instance +** exists when this routine returns or if an attempt to create it failed +** and an error message was left in pParse. +** +** An eponymous virtual table instance is one that is named after its +** module, and more importantly, does not require a CREATE VIRTUAL TABLE +** statement in order to come into existance. Eponymous virtual table +** instances always exist. They cannot be DROP-ed. +** +** Any virtual table module for which xConnect and xCreate are the same +** method can have an eponymous virtual table instance. +*/ +SQLITE_PRIVATE int sqlite3VtabEponymousTableInit(Parse *pParse, Module *pMod){ + const sqlite3_module *pModule = pMod->pModule; + Table *pTab; + char *zErr = 0; + int rc; + sqlite3 *db = pParse->db; + if( pMod->pEpoTab ) return 1; + if( pModule->xCreate!=0 && pModule->xCreate!=pModule->xConnect ) return 0; + pTab = sqlite3DbMallocZero(db, sizeof(Table)); + if( pTab==0 ) return 0; + pTab->zName = sqlite3DbStrDup(db, pMod->zName); + if( pTab->zName==0 ){ + sqlite3DbFree(db, pTab); + return 0; + } + pMod->pEpoTab = pTab; + pTab->nTabRef = 1; + pTab->eTabType = TABTYP_VTAB; + pTab->pSchema = db->aDb[0].pSchema; + assert( pTab->u.vtab.nArg==0 ); + pTab->iPKey = -1; + pTab->tabFlags |= TF_Eponymous; + addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName)); + addModuleArgument(pParse, pTab, 0); + addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName)); + rc = vtabCallConstructor(db, pTab, pMod, pModule->xConnect, &zErr); + if( rc ){ + sqlite3ErrorMsg(pParse, "%s", zErr); + sqlite3DbFree(db, zErr); + sqlite3VtabEponymousTableClear(db, pMod); + } + return 1; +} + +/* +** Erase the eponymous virtual table instance associated with +** virtual table module pMod, if it exists. +*/ +SQLITE_PRIVATE void sqlite3VtabEponymousTableClear(sqlite3 *db, Module *pMod){ + Table *pTab = pMod->pEpoTab; + if( pTab!=0 ){ + /* Mark the table as Ephemeral prior to deleting it, so that the + ** sqlite3DeleteTable() routine will know that it is not stored in + ** the schema. */ + pTab->tabFlags |= TF_Ephemeral; + sqlite3DeleteTable(db, pTab); + pMod->pEpoTab = 0; + } +} + +/* +** Return the ON CONFLICT resolution mode in effect for the virtual +** table update operation currently in progress. +** +** The results of this routine are undefined unless it is called from +** within an xUpdate method. +*/ +SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *db){ + static const unsigned char aMap[] = { + SQLITE_ROLLBACK, SQLITE_ABORT, SQLITE_FAIL, SQLITE_IGNORE, SQLITE_REPLACE + }; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + assert( OE_Rollback==1 && OE_Abort==2 && OE_Fail==3 ); + assert( OE_Ignore==4 && OE_Replace==5 ); + assert( db->vtabOnConflict>=1 && db->vtabOnConflict<=5 ); + return (int)aMap[db->vtabOnConflict-1]; +} + +/* +** Call from within the xCreate() or xConnect() methods to provide +** the SQLite core with additional information about the behavior +** of the virtual table being implemented. +*/ +SQLITE_API int sqlite3_vtab_config(sqlite3 *db, int op, ...){ + va_list ap; + int rc = SQLITE_OK; + VtabCtx *p; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + p = db->pVtabCtx; + if( !p ){ + rc = SQLITE_MISUSE_BKPT; + }else{ + assert( p->pTab==0 || IsVirtual(p->pTab) ); + va_start(ap, op); + switch( op ){ + case SQLITE_VTAB_CONSTRAINT_SUPPORT: { + p->pVTable->bConstraint = (u8)va_arg(ap, int); + break; + } + case SQLITE_VTAB_INNOCUOUS: { + p->pVTable->eVtabRisk = SQLITE_VTABRISK_Low; + break; + } + case SQLITE_VTAB_DIRECTONLY: { + p->pVTable->eVtabRisk = SQLITE_VTABRISK_High; + break; + } + case SQLITE_VTAB_USES_ALL_SCHEMAS: { + p->pVTable->bAllSchemas = 1; + break; + } + default: { + rc = SQLITE_MISUSE_BKPT; + break; + } + } + va_end(ap); + } + + if( rc!=SQLITE_OK ) sqlite3Error(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +/************** End of vtab.c ************************************************/ +/************** Begin file wherecode.c ***************************************/ +/* +** 2015-06-06 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This module contains C code that generates VDBE code used to process +** the WHERE clause of SQL statements. +** +** This file was split off from where.c on 2015-06-06 in order to reduce the +** size of where.c and make it easier to edit. This file contains the routines +** that actually generate the bulk of the WHERE loop code. The original where.c +** file retains the code that does query planning and analysis. +*/ +/* #include "sqliteInt.h" */ +/************** Include whereInt.h in the middle of wherecode.c **************/ +/************** Begin file whereInt.h ****************************************/ +/* +** 2013-11-12 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains structure and macro definitions for the query +** planner logic in "where.c". These definitions are broken out into +** a separate source file for easier editing. +*/ +#ifndef SQLITE_WHEREINT_H +#define SQLITE_WHEREINT_H + + +/* Forward references +*/ +typedef struct WhereClause WhereClause; +typedef struct WhereMaskSet WhereMaskSet; +typedef struct WhereOrInfo WhereOrInfo; +typedef struct WhereAndInfo WhereAndInfo; +typedef struct WhereLevel WhereLevel; +typedef struct WhereLoop WhereLoop; +typedef struct WherePath WherePath; +typedef struct WhereTerm WhereTerm; +typedef struct WhereLoopBuilder WhereLoopBuilder; +typedef struct WhereScan WhereScan; +typedef struct WhereOrCost WhereOrCost; +typedef struct WhereOrSet WhereOrSet; +typedef struct WhereMemBlock WhereMemBlock; +typedef struct WhereRightJoin WhereRightJoin; + +/* +** This object is a header on a block of allocated memory that will be +** automatically freed when its WInfo oject is destructed. +*/ +struct WhereMemBlock { + WhereMemBlock *pNext; /* Next block in the chain */ + u64 sz; /* Bytes of space */ +}; + +/* +** Extra information attached to a WhereLevel that is a RIGHT JOIN. +*/ +struct WhereRightJoin { + int iMatch; /* Cursor used to determine prior matched rows */ + int regBloom; /* Bloom filter for iRJMatch */ + int regReturn; /* Return register for the interior subroutine */ + int addrSubrtn; /* Starting address for the interior subroutine */ + int endSubrtn; /* The last opcode in the interior subroutine */ +}; + +/* +** This object contains information needed to implement a single nested +** loop in WHERE clause. +** +** Contrast this object with WhereLoop. This object describes the +** implementation of the loop. WhereLoop describes the algorithm. +** This object contains a pointer to the WhereLoop algorithm as one of +** its elements. +** +** The WhereInfo object contains a single instance of this object for +** each term in the FROM clause (which is to say, for each of the +** nested loops as implemented). The order of WhereLevel objects determines +** the loop nested order, with WhereInfo.a[0] being the outer loop and +** WhereInfo.a[WhereInfo.nLevel-1] being the inner loop. +*/ +struct WhereLevel { + int iLeftJoin; /* Memory cell used to implement LEFT OUTER JOIN */ + int iTabCur; /* The VDBE cursor used to access the table */ + int iIdxCur; /* The VDBE cursor used to access pIdx */ + int addrBrk; /* Jump here to break out of the loop */ + int addrNxt; /* Jump here to start the next IN combination */ + int addrSkip; /* Jump here for next iteration of skip-scan */ + int addrCont; /* Jump here to continue with the next loop cycle */ + int addrFirst; /* First instruction of interior of the loop */ + int addrBody; /* Beginning of the body of this loop */ + int regBignull; /* big-null flag reg. True if a NULL-scan is needed */ + int addrBignull; /* Jump here for next part of big-null scan */ +#ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS + u32 iLikeRepCntr; /* LIKE range processing counter register (times 2) */ + int addrLikeRep; /* LIKE range processing address */ +#endif + int regFilter; /* Bloom filter */ + WhereRightJoin *pRJ; /* Extra information for RIGHT JOIN */ + u8 iFrom; /* Which entry in the FROM clause */ + u8 op, p3, p5; /* Opcode, P3 & P5 of the opcode that ends the loop */ + int p1, p2; /* Operands of the opcode used to end the loop */ + union { /* Information that depends on pWLoop->wsFlags */ + struct { + int nIn; /* Number of entries in aInLoop[] */ + struct InLoop { + int iCur; /* The VDBE cursor used by this IN operator */ + int addrInTop; /* Top of the IN loop */ + int iBase; /* Base register of multi-key index record */ + int nPrefix; /* Number of prior entires in the key */ + u8 eEndLoopOp; /* IN Loop terminator. OP_Next or OP_Prev */ + } *aInLoop; /* Information about each nested IN operator */ + } in; /* Used when pWLoop->wsFlags&WHERE_IN_ABLE */ + Index *pCoveringIdx; /* Possible covering index for WHERE_MULTI_OR */ + } u; + struct WhereLoop *pWLoop; /* The selected WhereLoop object */ + Bitmask notReady; /* FROM entries not usable at this level */ +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + int addrVisit; /* Address at which row is visited */ +#endif +}; + +/* +** Each instance of this object represents an algorithm for evaluating one +** term of a join. Every term of the FROM clause will have at least +** one corresponding WhereLoop object (unless INDEXED BY constraints +** prevent a query solution - which is an error) and many terms of the +** FROM clause will have multiple WhereLoop objects, each describing a +** potential way of implementing that FROM-clause term, together with +** dependencies and cost estimates for using the chosen algorithm. +** +** Query planning consists of building up a collection of these WhereLoop +** objects, then computing a particular sequence of WhereLoop objects, with +** one WhereLoop object per FROM clause term, that satisfy all dependencies +** and that minimize the overall cost. +*/ +struct WhereLoop { + Bitmask prereq; /* Bitmask of other loops that must run first */ + Bitmask maskSelf; /* Bitmask identifying table iTab */ +#ifdef SQLITE_DEBUG + char cId; /* Symbolic ID of this loop for debugging use */ +#endif + u8 iTab; /* Position in FROM clause of table for this loop */ + u8 iSortIdx; /* Sorting index number. 0==None */ + LogEst rSetup; /* One-time setup cost (ex: create transient index) */ + LogEst rRun; /* Cost of running each loop */ + LogEst nOut; /* Estimated number of output rows */ + union { + struct { /* Information for internal btree tables */ + u16 nEq; /* Number of equality constraints */ + u16 nBtm; /* Size of BTM vector */ + u16 nTop; /* Size of TOP vector */ + u16 nDistinctCol; /* Index columns used to sort for DISTINCT */ + Index *pIndex; /* Index used, or NULL */ + } btree; + struct { /* Information for virtual tables */ + int idxNum; /* Index number */ + u32 needFree : 1; /* True if sqlite3_free(idxStr) is needed */ + u32 bOmitOffset : 1; /* True to let virtual table handle offset */ + i8 isOrdered; /* True if satisfies ORDER BY */ + u16 omitMask; /* Terms that may be omitted */ + char *idxStr; /* Index identifier string */ + u32 mHandleIn; /* Terms to handle as IN(...) instead of == */ + } vtab; + } u; + u32 wsFlags; /* WHERE_* flags describing the plan */ + u16 nLTerm; /* Number of entries in aLTerm[] */ + u16 nSkip; /* Number of NULL aLTerm[] entries */ + /**** whereLoopXfer() copies fields above ***********************/ +# define WHERE_LOOP_XFER_SZ offsetof(WhereLoop,nLSlot) + u16 nLSlot; /* Number of slots allocated for aLTerm[] */ + WhereTerm **aLTerm; /* WhereTerms used */ + WhereLoop *pNextLoop; /* Next WhereLoop object in the WhereClause */ + WhereTerm *aLTermSpace[3]; /* Initial aLTerm[] space */ +}; + +/* This object holds the prerequisites and the cost of running a +** subquery on one operand of an OR operator in the WHERE clause. +** See WhereOrSet for additional information +*/ +struct WhereOrCost { + Bitmask prereq; /* Prerequisites */ + LogEst rRun; /* Cost of running this subquery */ + LogEst nOut; /* Number of outputs for this subquery */ +}; + +/* The WhereOrSet object holds a set of possible WhereOrCosts that +** correspond to the subquery(s) of OR-clause processing. Only the +** best N_OR_COST elements are retained. +*/ +#define N_OR_COST 3 +struct WhereOrSet { + u16 n; /* Number of valid a[] entries */ + WhereOrCost a[N_OR_COST]; /* Set of best costs */ +}; + +/* +** Each instance of this object holds a sequence of WhereLoop objects +** that implement some or all of a query plan. +** +** Think of each WhereLoop object as a node in a graph with arcs +** showing dependencies and costs for travelling between nodes. (That is +** not a completely accurate description because WhereLoop costs are a +** vector, not a scalar, and because dependencies are many-to-one, not +** one-to-one as are graph nodes. But it is a useful visualization aid.) +** Then a WherePath object is a path through the graph that visits some +** or all of the WhereLoop objects once. +** +** The "solver" works by creating the N best WherePath objects of length +** 1. Then using those as a basis to compute the N best WherePath objects +** of length 2. And so forth until the length of WherePaths equals the +** number of nodes in the FROM clause. The best (lowest cost) WherePath +** at the end is the chosen query plan. +*/ +struct WherePath { + Bitmask maskLoop; /* Bitmask of all WhereLoop objects in this path */ + Bitmask revLoop; /* aLoop[]s that should be reversed for ORDER BY */ + LogEst nRow; /* Estimated number of rows generated by this path */ + LogEst rCost; /* Total cost of this path */ + LogEst rUnsorted; /* Total cost of this path ignoring sorting costs */ + i8 isOrdered; /* No. of ORDER BY terms satisfied. -1 for unknown */ + WhereLoop **aLoop; /* Array of WhereLoop objects implementing this path */ +}; + +/* +** The query generator uses an array of instances of this structure to +** help it analyze the subexpressions of the WHERE clause. Each WHERE +** clause subexpression is separated from the others by AND operators, +** usually, or sometimes subexpressions separated by OR. +** +** All WhereTerms are collected into a single WhereClause structure. +** The following identity holds: +** +** WhereTerm.pWC->a[WhereTerm.idx] == WhereTerm +** +** When a term is of the form: +** +** X +** +** where X is a column name and is one of certain operators, +** then WhereTerm.leftCursor and WhereTerm.u.leftColumn record the +** cursor number and column number for X. WhereTerm.eOperator records +** the using a bitmask encoding defined by WO_xxx below. The +** use of a bitmask encoding for the operator allows us to search +** quickly for terms that match any of several different operators. +** +** A WhereTerm might also be two or more subterms connected by OR: +** +** (t1.X ) OR (t1.Y ) OR .... +** +** In this second case, wtFlag has the TERM_ORINFO bit set and eOperator==WO_OR +** and the WhereTerm.u.pOrInfo field points to auxiliary information that +** is collected about the OR clause. +** +** If a term in the WHERE clause does not match either of the two previous +** categories, then eOperator==0. The WhereTerm.pExpr field is still set +** to the original subexpression content and wtFlags is set up appropriately +** but no other fields in the WhereTerm object are meaningful. +** +** When eOperator!=0, prereqRight and prereqAll record sets of cursor numbers, +** but they do so indirectly. A single WhereMaskSet structure translates +** cursor number into bits and the translated bit is stored in the prereq +** fields. The translation is used in order to maximize the number of +** bits that will fit in a Bitmask. The VDBE cursor numbers might be +** spread out over the non-negative integers. For example, the cursor +** numbers might be 3, 8, 9, 10, 20, 23, 41, and 45. The WhereMaskSet +** translates these sparse cursor numbers into consecutive integers +** beginning with 0 in order to make the best possible use of the available +** bits in the Bitmask. So, in the example above, the cursor numbers +** would be mapped into integers 0 through 7. +** +** The number of terms in a join is limited by the number of bits +** in prereqRight and prereqAll. The default is 64 bits, hence SQLite +** is only able to process joins with 64 or fewer tables. +*/ +struct WhereTerm { + Expr *pExpr; /* Pointer to the subexpression that is this term */ + WhereClause *pWC; /* The clause this term is part of */ + LogEst truthProb; /* Probability of truth for this expression */ + u16 wtFlags; /* TERM_xxx bit flags. See below */ + u16 eOperator; /* A WO_xx value describing */ + u8 nChild; /* Number of children that must disable us */ + u8 eMatchOp; /* Op for vtab MATCH/LIKE/GLOB/REGEXP terms */ + int iParent; /* Disable pWC->a[iParent] when this term disabled */ + int leftCursor; /* Cursor number of X in "X " */ + union { + struct { + int leftColumn; /* Column number of X in "X " */ + int iField; /* Field in (?,?,?) IN (SELECT...) vector */ + } x; /* Opcode other than OP_OR or OP_AND */ + WhereOrInfo *pOrInfo; /* Extra information if (eOperator & WO_OR)!=0 */ + WhereAndInfo *pAndInfo; /* Extra information if (eOperator& WO_AND)!=0 */ + } u; + Bitmask prereqRight; /* Bitmask of tables used by pExpr->pRight */ + Bitmask prereqAll; /* Bitmask of tables referenced by pExpr */ +}; + +/* +** Allowed values of WhereTerm.wtFlags +*/ +#define TERM_DYNAMIC 0x0001 /* Need to call sqlite3ExprDelete(db, pExpr) */ +#define TERM_VIRTUAL 0x0002 /* Added by the optimizer. Do not code */ +#define TERM_CODED 0x0004 /* This term is already coded */ +#define TERM_COPIED 0x0008 /* Has a child */ +#define TERM_ORINFO 0x0010 /* Need to free the WhereTerm.u.pOrInfo object */ +#define TERM_ANDINFO 0x0020 /* Need to free the WhereTerm.u.pAndInfo obj */ +#define TERM_OK 0x0040 /* Used during OR-clause processing */ +#define TERM_VNULL 0x0080 /* Manufactured x>NULL or x<=NULL term */ +#define TERM_LIKEOPT 0x0100 /* Virtual terms from the LIKE optimization */ +#define TERM_LIKECOND 0x0200 /* Conditionally this LIKE operator term */ +#define TERM_LIKE 0x0400 /* The original LIKE operator */ +#define TERM_IS 0x0800 /* Term.pExpr is an IS operator */ +#define TERM_VARSELECT 0x1000 /* Term.pExpr contains a correlated sub-query */ +#define TERM_HEURTRUTH 0x2000 /* Heuristic truthProb used */ +#ifdef SQLITE_ENABLE_STAT4 +# define TERM_HIGHTRUTH 0x4000 /* Term excludes few rows */ +#else +# define TERM_HIGHTRUTH 0 /* Only used with STAT4 */ +#endif +#define TERM_SLICE 0x8000 /* One slice of a row-value/vector comparison */ + +/* +** An instance of the WhereScan object is used as an iterator for locating +** terms in the WHERE clause that are useful to the query planner. +*/ +struct WhereScan { + WhereClause *pOrigWC; /* Original, innermost WhereClause */ + WhereClause *pWC; /* WhereClause currently being scanned */ + const char *zCollName; /* Required collating sequence, if not NULL */ + Expr *pIdxExpr; /* Search for this index expression */ + int k; /* Resume scanning at this->pWC->a[this->k] */ + u32 opMask; /* Acceptable operators */ + char idxaff; /* Must match this affinity, if zCollName!=NULL */ + unsigned char iEquiv; /* Current slot in aiCur[] and aiColumn[] */ + unsigned char nEquiv; /* Number of entries in aiCur[] and aiColumn[] */ + int aiCur[11]; /* Cursors in the equivalence class */ + i16 aiColumn[11]; /* Corresponding column number in the eq-class */ +}; + +/* +** An instance of the following structure holds all information about a +** WHERE clause. Mostly this is a container for one or more WhereTerms. +** +** Explanation of pOuter: For a WHERE clause of the form +** +** a AND ((b AND c) OR (d AND e)) AND f +** +** There are separate WhereClause objects for the whole clause and for +** the subclauses "(b AND c)" and "(d AND e)". The pOuter field of the +** subclauses points to the WhereClause object for the whole clause. +*/ +struct WhereClause { + WhereInfo *pWInfo; /* WHERE clause processing context */ + WhereClause *pOuter; /* Outer conjunction */ + u8 op; /* Split operator. TK_AND or TK_OR */ + u8 hasOr; /* True if any a[].eOperator is WO_OR */ + int nTerm; /* Number of terms */ + int nSlot; /* Number of entries in a[] */ + int nBase; /* Number of terms through the last non-Virtual */ + WhereTerm *a; /* Each a[] describes a term of the WHERE cluase */ +#if defined(SQLITE_SMALL_STACK) + WhereTerm aStatic[1]; /* Initial static space for a[] */ +#else + WhereTerm aStatic[8]; /* Initial static space for a[] */ +#endif +}; + +/* +** A WhereTerm with eOperator==WO_OR has its u.pOrInfo pointer set to +** a dynamically allocated instance of the following structure. +*/ +struct WhereOrInfo { + WhereClause wc; /* Decomposition into subterms */ + Bitmask indexable; /* Bitmask of all indexable tables in the clause */ +}; + +/* +** A WhereTerm with eOperator==WO_AND has its u.pAndInfo pointer set to +** a dynamically allocated instance of the following structure. +*/ +struct WhereAndInfo { + WhereClause wc; /* The subexpression broken out */ +}; + +/* +** An instance of the following structure keeps track of a mapping +** between VDBE cursor numbers and bits of the bitmasks in WhereTerm. +** +** The VDBE cursor numbers are small integers contained in +** SrcItem.iCursor and Expr.iTable fields. For any given WHERE +** clause, the cursor numbers might not begin with 0 and they might +** contain gaps in the numbering sequence. But we want to make maximum +** use of the bits in our bitmasks. This structure provides a mapping +** from the sparse cursor numbers into consecutive integers beginning +** with 0. +** +** If WhereMaskSet.ix[A]==B it means that The A-th bit of a Bitmask +** corresponds VDBE cursor number B. The A-th bit of a bitmask is 1<3, 5->1, 8->2, 29->0, +** 57->5, 73->4. Or one of 719 other combinations might be used. It +** does not really matter. What is important is that sparse cursor +** numbers all get mapped into bit numbers that begin with 0 and contain +** no gaps. +*/ +struct WhereMaskSet { + int bVarSelect; /* Used by sqlite3WhereExprUsage() */ + int n; /* Number of assigned cursor values */ + int ix[BMS]; /* Cursor assigned to each bit */ +}; + +/* +** This object is a convenience wrapper holding all information needed +** to construct WhereLoop objects for a particular query. +*/ +struct WhereLoopBuilder { + WhereInfo *pWInfo; /* Information about this WHERE */ + WhereClause *pWC; /* WHERE clause terms */ + WhereLoop *pNew; /* Template WhereLoop */ + WhereOrSet *pOrSet; /* Record best loops here, if not NULL */ +#ifdef SQLITE_ENABLE_STAT4 + UnpackedRecord *pRec; /* Probe for stat4 (if required) */ + int nRecValid; /* Number of valid fields currently in pRec */ +#endif + unsigned char bldFlags1; /* First set of SQLITE_BLDF_* flags */ + unsigned char bldFlags2; /* Second set of SQLITE_BLDF_* flags */ + unsigned int iPlanLimit; /* Search limiter */ +}; + +/* Allowed values for WhereLoopBuider.bldFlags */ +#define SQLITE_BLDF1_INDEXED 0x0001 /* An index is used */ +#define SQLITE_BLDF1_UNIQUE 0x0002 /* All keys of a UNIQUE index used */ + +#define SQLITE_BLDF2_2NDPASS 0x0004 /* Second builder pass needed */ + +/* The WhereLoopBuilder.iPlanLimit is used to limit the number of +** index+constraint combinations the query planner will consider for a +** particular query. If this parameter is unlimited, then certain +** pathological queries can spend excess time in the sqlite3WhereBegin() +** routine. The limit is high enough that is should not impact real-world +** queries. +** +** SQLITE_QUERY_PLANNER_LIMIT is the baseline limit. The limit is +** increased by SQLITE_QUERY_PLANNER_LIMIT_INCR before each term of the FROM +** clause is processed, so that every table in a join is guaranteed to be +** able to propose a some index+constraint combinations even if the initial +** baseline limit was exhausted by prior tables of the join. +*/ +#ifndef SQLITE_QUERY_PLANNER_LIMIT +# define SQLITE_QUERY_PLANNER_LIMIT 20000 +#endif +#ifndef SQLITE_QUERY_PLANNER_LIMIT_INCR +# define SQLITE_QUERY_PLANNER_LIMIT_INCR 1000 +#endif + +/* +** The WHERE clause processing routine has two halves. The +** first part does the start of the WHERE loop and the second +** half does the tail of the WHERE loop. An instance of +** this structure is returned by the first half and passed +** into the second half to give some continuity. +** +** An instance of this object holds the complete state of the query +** planner. +*/ +struct WhereInfo { + Parse *pParse; /* Parsing and code generating context */ + SrcList *pTabList; /* List of tables in the join */ + ExprList *pOrderBy; /* The ORDER BY clause or NULL */ + ExprList *pResultSet; /* Result set of the query */ +#if WHERETRACE_ENABLED + Expr *pWhere; /* The complete WHERE clause */ +#endif + Select *pSelect; /* The entire SELECT statement containing WHERE */ + int aiCurOnePass[2]; /* OP_OpenWrite cursors for the ONEPASS opt */ + int iContinue; /* Jump here to continue with next record */ + int iBreak; /* Jump here to break out of the loop */ + int savedNQueryLoop; /* pParse->nQueryLoop outside the WHERE loop */ + u16 wctrlFlags; /* Flags originally passed to sqlite3WhereBegin() */ + LogEst iLimit; /* LIMIT if wctrlFlags has WHERE_USE_LIMIT */ + u8 nLevel; /* Number of nested loop */ + i8 nOBSat; /* Number of ORDER BY terms satisfied by indices */ + u8 eOnePass; /* ONEPASS_OFF, or _SINGLE, or _MULTI */ + u8 eDistinct; /* One of the WHERE_DISTINCT_* values */ + unsigned bDeferredSeek :1; /* Uses OP_DeferredSeek */ + unsigned untestedTerms :1; /* Not all WHERE terms resolved by outer loop */ + unsigned bOrderedInnerLoop:1;/* True if only the inner-most loop is ordered */ + unsigned sorted :1; /* True if really sorted (not just grouped) */ + LogEst nRowOut; /* Estimated number of output rows */ + int iTop; /* The very beginning of the WHERE loop */ + int iEndWhere; /* End of the WHERE clause itself */ + WhereLoop *pLoops; /* List of all WhereLoop objects */ + WhereMemBlock *pMemToFree;/* Memory to free when this object destroyed */ + Bitmask revMask; /* Mask of ORDER BY terms that need reversing */ + WhereClause sWC; /* Decomposition of the WHERE clause */ + WhereMaskSet sMaskSet; /* Map cursor numbers to bitmasks */ + WhereLevel a[1]; /* Information about each nest loop in WHERE */ +}; + +/* +** Private interfaces - callable only by other where.c routines. +** +** where.c: +*/ +SQLITE_PRIVATE Bitmask sqlite3WhereGetMask(WhereMaskSet*,int); +#ifdef WHERETRACE_ENABLED +SQLITE_PRIVATE void sqlite3WhereClausePrint(WhereClause *pWC); +SQLITE_PRIVATE void sqlite3WhereTermPrint(WhereTerm *pTerm, int iTerm); +SQLITE_PRIVATE void sqlite3WhereLoopPrint(WhereLoop *p, WhereClause *pWC); +#endif +SQLITE_PRIVATE WhereTerm *sqlite3WhereFindTerm( + WhereClause *pWC, /* The WHERE clause to be searched */ + int iCur, /* Cursor number of LHS */ + int iColumn, /* Column number of LHS */ + Bitmask notReady, /* RHS must not overlap with this mask */ + u32 op, /* Mask of WO_xx values describing operator */ + Index *pIdx /* Must be compatible with this index, if not NULL */ +); +SQLITE_PRIVATE void *sqlite3WhereMalloc(WhereInfo *pWInfo, u64 nByte); +SQLITE_PRIVATE void *sqlite3WhereRealloc(WhereInfo *pWInfo, void *pOld, u64 nByte); + +/* wherecode.c: */ +#ifndef SQLITE_OMIT_EXPLAIN +SQLITE_PRIVATE int sqlite3WhereExplainOneScan( + Parse *pParse, /* Parse context */ + SrcList *pTabList, /* Table list this loop refers to */ + WhereLevel *pLevel, /* Scan to write OP_Explain opcode for */ + u16 wctrlFlags /* Flags passed to sqlite3WhereBegin() */ +); +SQLITE_PRIVATE int sqlite3WhereExplainBloomFilter( + const Parse *pParse, /* Parse context */ + const WhereInfo *pWInfo, /* WHERE clause */ + const WhereLevel *pLevel /* Bloom filter on this level */ +); +#else +# define sqlite3WhereExplainOneScan(u,v,w,x) 0 +# define sqlite3WhereExplainBloomFilter(u,v,w) 0 +#endif /* SQLITE_OMIT_EXPLAIN */ +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS +SQLITE_PRIVATE void sqlite3WhereAddScanStatus( + Vdbe *v, /* Vdbe to add scanstatus entry to */ + SrcList *pSrclist, /* FROM clause pLvl reads data from */ + WhereLevel *pLvl, /* Level to add scanstatus() entry for */ + int addrExplain /* Address of OP_Explain (or 0) */ +); +#else +# define sqlite3WhereAddScanStatus(a, b, c, d) ((void)d) +#endif +SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart( + Parse *pParse, /* Parsing context */ + Vdbe *v, /* Prepared statement under construction */ + WhereInfo *pWInfo, /* Complete information about the WHERE clause */ + int iLevel, /* Which level of pWInfo->a[] should be coded */ + WhereLevel *pLevel, /* The current level pointer */ + Bitmask notReady /* Which tables are currently available */ +); +SQLITE_PRIVATE SQLITE_NOINLINE void sqlite3WhereRightJoinLoop( + WhereInfo *pWInfo, + int iLevel, + WhereLevel *pLevel +); + +/* whereexpr.c: */ +SQLITE_PRIVATE void sqlite3WhereClauseInit(WhereClause*,WhereInfo*); +SQLITE_PRIVATE void sqlite3WhereClauseClear(WhereClause*); +SQLITE_PRIVATE void sqlite3WhereSplit(WhereClause*,Expr*,u8); +SQLITE_PRIVATE void sqlite3WhereAddLimit(WhereClause*, Select*); +SQLITE_PRIVATE Bitmask sqlite3WhereExprUsage(WhereMaskSet*, Expr*); +SQLITE_PRIVATE Bitmask sqlite3WhereExprUsageNN(WhereMaskSet*, Expr*); +SQLITE_PRIVATE Bitmask sqlite3WhereExprListUsage(WhereMaskSet*, ExprList*); +SQLITE_PRIVATE void sqlite3WhereExprAnalyze(SrcList*, WhereClause*); +SQLITE_PRIVATE void sqlite3WhereTabFuncArgs(Parse*, SrcItem*, WhereClause*); + + + + + +/* +** Bitmasks for the operators on WhereTerm objects. These are all +** operators that are of interest to the query planner. An +** OR-ed combination of these values can be used when searching for +** particular WhereTerms within a WhereClause. +** +** Value constraints: +** WO_EQ == SQLITE_INDEX_CONSTRAINT_EQ +** WO_LT == SQLITE_INDEX_CONSTRAINT_LT +** WO_LE == SQLITE_INDEX_CONSTRAINT_LE +** WO_GT == SQLITE_INDEX_CONSTRAINT_GT +** WO_GE == SQLITE_INDEX_CONSTRAINT_GE +*/ +#define WO_IN 0x0001 +#define WO_EQ 0x0002 +#define WO_LT (WO_EQ<<(TK_LT-TK_EQ)) +#define WO_LE (WO_EQ<<(TK_LE-TK_EQ)) +#define WO_GT (WO_EQ<<(TK_GT-TK_EQ)) +#define WO_GE (WO_EQ<<(TK_GE-TK_EQ)) +#define WO_AUX 0x0040 /* Op useful to virtual tables only */ +#define WO_IS 0x0080 +#define WO_ISNULL 0x0100 +#define WO_OR 0x0200 /* Two or more OR-connected terms */ +#define WO_AND 0x0400 /* Two or more AND-connected terms */ +#define WO_EQUIV 0x0800 /* Of the form A==B, both columns */ +#define WO_NOOP 0x1000 /* This term does not restrict search space */ +#define WO_ROWVAL 0x2000 /* A row-value term */ + +#define WO_ALL 0x3fff /* Mask of all possible WO_* values */ +#define WO_SINGLE 0x01ff /* Mask of all non-compound WO_* values */ + +/* +** These are definitions of bits in the WhereLoop.wsFlags field. +** The particular combination of bits in each WhereLoop help to +** determine the algorithm that WhereLoop represents. +*/ +#define WHERE_COLUMN_EQ 0x00000001 /* x=EXPR */ +#define WHERE_COLUMN_RANGE 0x00000002 /* xEXPR */ +#define WHERE_COLUMN_IN 0x00000004 /* x IN (...) */ +#define WHERE_COLUMN_NULL 0x00000008 /* x IS NULL */ +#define WHERE_CONSTRAINT 0x0000000f /* Any of the WHERE_COLUMN_xxx values */ +#define WHERE_TOP_LIMIT 0x00000010 /* xEXPR or x>=EXPR constraint */ +#define WHERE_BOTH_LIMIT 0x00000030 /* Both x>EXPR and xaiColumn[i]; + if( i==XN_EXPR ) return ""; + if( i==XN_ROWID ) return "rowid"; + return pIdx->pTable->aCol[i].zCnName; +} + +/* +** This routine is a helper for explainIndexRange() below +** +** pStr holds the text of an expression that we are building up one term +** at a time. This routine adds a new term to the end of the expression. +** Terms are separated by AND so add the "AND" text for second and subsequent +** terms only. +*/ +static void explainAppendTerm( + StrAccum *pStr, /* The text expression being built */ + Index *pIdx, /* Index to read column names from */ + int nTerm, /* Number of terms */ + int iTerm, /* Zero-based index of first term. */ + int bAnd, /* Non-zero to append " AND " */ + const char *zOp /* Name of the operator */ +){ + int i; + + assert( nTerm>=1 ); + if( bAnd ) sqlite3_str_append(pStr, " AND ", 5); + + if( nTerm>1 ) sqlite3_str_append(pStr, "(", 1); + for(i=0; i1 ) sqlite3_str_append(pStr, ")", 1); + + sqlite3_str_append(pStr, zOp, 1); + + if( nTerm>1 ) sqlite3_str_append(pStr, "(", 1); + for(i=0; i1 ) sqlite3_str_append(pStr, ")", 1); +} + +/* +** Argument pLevel describes a strategy for scanning table pTab. This +** function appends text to pStr that describes the subset of table +** rows scanned by the strategy in the form of an SQL expression. +** +** For example, if the query: +** +** SELECT * FROM t1 WHERE a=1 AND b>2; +** +** is run and there is an index on (a, b), then this function returns a +** string similar to: +** +** "a=? AND b>?" +*/ +static void explainIndexRange(StrAccum *pStr, WhereLoop *pLoop){ + Index *pIndex = pLoop->u.btree.pIndex; + u16 nEq = pLoop->u.btree.nEq; + u16 nSkip = pLoop->nSkip; + int i, j; + + if( nEq==0 && (pLoop->wsFlags&(WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))==0 ) return; + sqlite3_str_append(pStr, " (", 2); + for(i=0; i=nSkip ? "%s=?" : "ANY(%s)", z); + } + + j = i; + if( pLoop->wsFlags&WHERE_BTM_LIMIT ){ + explainAppendTerm(pStr, pIndex, pLoop->u.btree.nBtm, j, i, ">"); + i = 1; + } + if( pLoop->wsFlags&WHERE_TOP_LIMIT ){ + explainAppendTerm(pStr, pIndex, pLoop->u.btree.nTop, j, i, "<"); + } + sqlite3_str_append(pStr, ")", 1); +} + +/* +** This function is a no-op unless currently processing an EXPLAIN QUERY PLAN +** command, or if stmt_scanstatus_v2() stats are enabled, or if SQLITE_DEBUG +** was defined at compile-time. If it is not a no-op, a single OP_Explain +** opcode is added to the output to describe the table scan strategy in pLevel. +** +** If an OP_Explain opcode is added to the VM, its address is returned. +** Otherwise, if no OP_Explain is coded, zero is returned. +*/ +SQLITE_PRIVATE int sqlite3WhereExplainOneScan( + Parse *pParse, /* Parse context */ + SrcList *pTabList, /* Table list this loop refers to */ + WhereLevel *pLevel, /* Scan to write OP_Explain opcode for */ + u16 wctrlFlags /* Flags passed to sqlite3WhereBegin() */ +){ + int ret = 0; +#if !defined(SQLITE_DEBUG) + if( sqlite3ParseToplevel(pParse)->explain==2 || IS_STMT_SCANSTATUS(pParse->db) ) +#endif + { + SrcItem *pItem = &pTabList->a[pLevel->iFrom]; + Vdbe *v = pParse->pVdbe; /* VM being constructed */ + sqlite3 *db = pParse->db; /* Database handle */ + int isSearch; /* True for a SEARCH. False for SCAN. */ + WhereLoop *pLoop; /* The controlling WhereLoop object */ + u32 flags; /* Flags that describe this loop */ + char *zMsg; /* Text to add to EQP output */ + StrAccum str; /* EQP output string */ + char zBuf[100]; /* Initial space for EQP output string */ + + pLoop = pLevel->pWLoop; + flags = pLoop->wsFlags; + if( (flags&WHERE_MULTI_OR) || (wctrlFlags&WHERE_OR_SUBCLAUSE) ) return 0; + + isSearch = (flags&(WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))!=0 + || ((flags&WHERE_VIRTUALTABLE)==0 && (pLoop->u.btree.nEq>0)) + || (wctrlFlags&(WHERE_ORDERBY_MIN|WHERE_ORDERBY_MAX)); + + sqlite3StrAccumInit(&str, db, zBuf, sizeof(zBuf), SQLITE_MAX_LENGTH); + str.printfFlags = SQLITE_PRINTF_INTERNAL; + sqlite3_str_appendf(&str, "%s %S", isSearch ? "SEARCH" : "SCAN", pItem); + if( (flags & (WHERE_IPK|WHERE_VIRTUALTABLE))==0 ){ + const char *zFmt = 0; + Index *pIdx; + + assert( pLoop->u.btree.pIndex!=0 ); + pIdx = pLoop->u.btree.pIndex; + assert( !(flags&WHERE_AUTO_INDEX) || (flags&WHERE_IDX_ONLY) ); + if( !HasRowid(pItem->pTab) && IsPrimaryKeyIndex(pIdx) ){ + if( isSearch ){ + zFmt = "PRIMARY KEY"; + } + }else if( flags & WHERE_PARTIALIDX ){ + zFmt = "AUTOMATIC PARTIAL COVERING INDEX"; + }else if( flags & WHERE_AUTO_INDEX ){ + zFmt = "AUTOMATIC COVERING INDEX"; + }else if( flags & WHERE_IDX_ONLY ){ + zFmt = "COVERING INDEX %s"; + }else{ + zFmt = "INDEX %s"; + } + if( zFmt ){ + sqlite3_str_append(&str, " USING ", 7); + sqlite3_str_appendf(&str, zFmt, pIdx->zName); + explainIndexRange(&str, pLoop); + } + }else if( (flags & WHERE_IPK)!=0 && (flags & WHERE_CONSTRAINT)!=0 ){ + char cRangeOp; +#if 0 /* Better output, but breaks many tests */ + const Table *pTab = pItem->pTab; + const char *zRowid = pTab->iPKey>=0 ? pTab->aCol[pTab->iPKey].zCnName: + "rowid"; +#else + const char *zRowid = "rowid"; +#endif + sqlite3_str_appendf(&str, " USING INTEGER PRIMARY KEY (%s", zRowid); + if( flags&(WHERE_COLUMN_EQ|WHERE_COLUMN_IN) ){ + cRangeOp = '='; + }else if( (flags&WHERE_BOTH_LIMIT)==WHERE_BOTH_LIMIT ){ + sqlite3_str_appendf(&str, ">? AND %s", zRowid); + cRangeOp = '<'; + }else if( flags&WHERE_BTM_LIMIT ){ + cRangeOp = '>'; + }else{ + assert( flags&WHERE_TOP_LIMIT); + cRangeOp = '<'; + } + sqlite3_str_appendf(&str, "%c?)", cRangeOp); + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + else if( (flags & WHERE_VIRTUALTABLE)!=0 ){ + sqlite3_str_appendf(&str, " VIRTUAL TABLE INDEX %d:%s", + pLoop->u.vtab.idxNum, pLoop->u.vtab.idxStr); + } +#endif + if( pItem->fg.jointype & JT_LEFT ){ + sqlite3_str_appendf(&str, " LEFT-JOIN"); + } +#ifdef SQLITE_EXPLAIN_ESTIMATED_ROWS + if( pLoop->nOut>=10 ){ + sqlite3_str_appendf(&str, " (~%llu rows)", + sqlite3LogEstToInt(pLoop->nOut)); + }else{ + sqlite3_str_append(&str, " (~1 row)", 9); + } +#endif + zMsg = sqlite3StrAccumFinish(&str); + sqlite3ExplainBreakpoint("",zMsg); + ret = sqlite3VdbeAddOp4(v, OP_Explain, sqlite3VdbeCurrentAddr(v), + pParse->addrExplain, 0, zMsg,P4_DYNAMIC); + } + return ret; +} + +/* +** Add a single OP_Explain opcode that describes a Bloom filter. +** +** Or if not processing EXPLAIN QUERY PLAN and not in a SQLITE_DEBUG and/or +** SQLITE_ENABLE_STMT_SCANSTATUS build, then OP_Explain opcodes are not +** required and this routine is a no-op. +** +** If an OP_Explain opcode is added to the VM, its address is returned. +** Otherwise, if no OP_Explain is coded, zero is returned. +*/ +SQLITE_PRIVATE int sqlite3WhereExplainBloomFilter( + const Parse *pParse, /* Parse context */ + const WhereInfo *pWInfo, /* WHERE clause */ + const WhereLevel *pLevel /* Bloom filter on this level */ +){ + int ret = 0; + SrcItem *pItem = &pWInfo->pTabList->a[pLevel->iFrom]; + Vdbe *v = pParse->pVdbe; /* VM being constructed */ + sqlite3 *db = pParse->db; /* Database handle */ + char *zMsg; /* Text to add to EQP output */ + int i; /* Loop counter */ + WhereLoop *pLoop; /* The where loop */ + StrAccum str; /* EQP output string */ + char zBuf[100]; /* Initial space for EQP output string */ + + sqlite3StrAccumInit(&str, db, zBuf, sizeof(zBuf), SQLITE_MAX_LENGTH); + str.printfFlags = SQLITE_PRINTF_INTERNAL; + sqlite3_str_appendf(&str, "BLOOM FILTER ON %S (", pItem); + pLoop = pLevel->pWLoop; + if( pLoop->wsFlags & WHERE_IPK ){ + const Table *pTab = pItem->pTab; + if( pTab->iPKey>=0 ){ + sqlite3_str_appendf(&str, "%s=?", pTab->aCol[pTab->iPKey].zCnName); + }else{ + sqlite3_str_appendf(&str, "rowid=?"); + } + }else{ + for(i=pLoop->nSkip; iu.btree.nEq; i++){ + const char *z = explainIndexColumnName(pLoop->u.btree.pIndex, i); + if( i>pLoop->nSkip ) sqlite3_str_append(&str, " AND ", 5); + sqlite3_str_appendf(&str, "%s=?", z); + } + } + sqlite3_str_append(&str, ")", 1); + zMsg = sqlite3StrAccumFinish(&str); + ret = sqlite3VdbeAddOp4(v, OP_Explain, sqlite3VdbeCurrentAddr(v), + pParse->addrExplain, 0, zMsg,P4_DYNAMIC); + + sqlite3VdbeScanStatus(v, sqlite3VdbeCurrentAddr(v)-1, 0, 0, 0, 0); + return ret; +} +#endif /* SQLITE_OMIT_EXPLAIN */ + +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS +/* +** Configure the VM passed as the first argument with an +** sqlite3_stmt_scanstatus() entry corresponding to the scan used to +** implement level pLvl. Argument pSrclist is a pointer to the FROM +** clause that the scan reads data from. +** +** If argument addrExplain is not 0, it must be the address of an +** OP_Explain instruction that describes the same loop. +*/ +SQLITE_PRIVATE void sqlite3WhereAddScanStatus( + Vdbe *v, /* Vdbe to add scanstatus entry to */ + SrcList *pSrclist, /* FROM clause pLvl reads data from */ + WhereLevel *pLvl, /* Level to add scanstatus() entry for */ + int addrExplain /* Address of OP_Explain (or 0) */ +){ + if( IS_STMT_SCANSTATUS( sqlite3VdbeDb(v) ) ){ + const char *zObj = 0; + WhereLoop *pLoop = pLvl->pWLoop; + int wsFlags = pLoop->wsFlags; + int viaCoroutine = 0; + + if( (wsFlags & WHERE_VIRTUALTABLE)==0 && pLoop->u.btree.pIndex!=0 ){ + zObj = pLoop->u.btree.pIndex->zName; + }else{ + zObj = pSrclist->a[pLvl->iFrom].zName; + viaCoroutine = pSrclist->a[pLvl->iFrom].fg.viaCoroutine; + } + sqlite3VdbeScanStatus( + v, addrExplain, pLvl->addrBody, pLvl->addrVisit, pLoop->nOut, zObj + ); + + if( viaCoroutine==0 ){ + if( (wsFlags & (WHERE_MULTI_OR|WHERE_AUTO_INDEX))==0 ){ + sqlite3VdbeScanStatusRange(v, addrExplain, -1, pLvl->iTabCur); + } + if( wsFlags & WHERE_INDEXED ){ + sqlite3VdbeScanStatusRange(v, addrExplain, -1, pLvl->iIdxCur); + } + } + } +} +#endif + + +/* +** Disable a term in the WHERE clause. Except, do not disable the term +** if it controls a LEFT OUTER JOIN and it did not originate in the ON +** or USING clause of that join. +** +** Consider the term t2.z='ok' in the following queries: +** +** (1) SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.x WHERE t2.z='ok' +** (2) SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.x AND t2.z='ok' +** (3) SELECT * FROM t1, t2 WHERE t1.a=t2.x AND t2.z='ok' +** +** The t2.z='ok' is disabled in the in (2) because it originates +** in the ON clause. The term is disabled in (3) because it is not part +** of a LEFT OUTER JOIN. In (1), the term is not disabled. +** +** Disabling a term causes that term to not be tested in the inner loop +** of the join. Disabling is an optimization. When terms are satisfied +** by indices, we disable them to prevent redundant tests in the inner +** loop. We would get the correct results if nothing were ever disabled, +** but joins might run a little slower. The trick is to disable as much +** as we can without disabling too much. If we disabled in (1), we'd get +** the wrong answer. See ticket #813. +** +** If all the children of a term are disabled, then that term is also +** automatically disabled. In this way, terms get disabled if derived +** virtual terms are tested first. For example: +** +** x GLOB 'abc*' AND x>='abc' AND x<'acd' +** \___________/ \______/ \_____/ +** parent child1 child2 +** +** Only the parent term was in the original WHERE clause. The child1 +** and child2 terms were added by the LIKE optimization. If both of +** the virtual child terms are valid, then testing of the parent can be +** skipped. +** +** Usually the parent term is marked as TERM_CODED. But if the parent +** term was originally TERM_LIKE, then the parent gets TERM_LIKECOND instead. +** The TERM_LIKECOND marking indicates that the term should be coded inside +** a conditional such that is only evaluated on the second pass of a +** LIKE-optimization loop, when scanning BLOBs instead of strings. +*/ +static void disableTerm(WhereLevel *pLevel, WhereTerm *pTerm){ + int nLoop = 0; + assert( pTerm!=0 ); + while( (pTerm->wtFlags & TERM_CODED)==0 + && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_OuterON)) + && (pLevel->notReady & pTerm->prereqAll)==0 + ){ + if( nLoop && (pTerm->wtFlags & TERM_LIKE)!=0 ){ + pTerm->wtFlags |= TERM_LIKECOND; + }else{ + pTerm->wtFlags |= TERM_CODED; + } +#ifdef WHERETRACE_ENABLED + if( (sqlite3WhereTrace & 0x4001)==0x4001 ){ + sqlite3DebugPrintf("DISABLE-"); + sqlite3WhereTermPrint(pTerm, (int)(pTerm - (pTerm->pWC->a))); + } +#endif + if( pTerm->iParent<0 ) break; + pTerm = &pTerm->pWC->a[pTerm->iParent]; + assert( pTerm!=0 ); + pTerm->nChild--; + if( pTerm->nChild!=0 ) break; + nLoop++; + } +} + +/* +** Code an OP_Affinity opcode to apply the column affinity string zAff +** to the n registers starting at base. +** +** As an optimization, SQLITE_AFF_BLOB and SQLITE_AFF_NONE entries (which +** are no-ops) at the beginning and end of zAff are ignored. If all entries +** in zAff are SQLITE_AFF_BLOB or SQLITE_AFF_NONE, then no code gets generated. +** +** This routine makes its own copy of zAff so that the caller is free +** to modify zAff after this routine returns. +*/ +static void codeApplyAffinity(Parse *pParse, int base, int n, char *zAff){ + Vdbe *v = pParse->pVdbe; + if( zAff==0 ){ + assert( pParse->db->mallocFailed ); + return; + } + assert( v!=0 ); + + /* Adjust base and n to skip over SQLITE_AFF_BLOB and SQLITE_AFF_NONE + ** entries at the beginning and end of the affinity string. + */ + assert( SQLITE_AFF_NONE0 && zAff[0]<=SQLITE_AFF_BLOB ){ + n--; + base++; + zAff++; + } + while( n>1 && zAff[n-1]<=SQLITE_AFF_BLOB ){ + n--; + } + + /* Code the OP_Affinity opcode if there is anything left to do. */ + if( n>0 ){ + sqlite3VdbeAddOp4(v, OP_Affinity, base, n, 0, zAff, n); + } +} + +/* +** Expression pRight, which is the RHS of a comparison operation, is +** either a vector of n elements or, if n==1, a scalar expression. +** Before the comparison operation, affinity zAff is to be applied +** to the pRight values. This function modifies characters within the +** affinity string to SQLITE_AFF_BLOB if either: +** +** * the comparison will be performed with no affinity, or +** * the affinity change in zAff is guaranteed not to change the value. +*/ +static void updateRangeAffinityStr( + Expr *pRight, /* RHS of comparison */ + int n, /* Number of vector elements in comparison */ + char *zAff /* Affinity string to modify */ +){ + int i; + for(i=0; idb; + Select *pSelect; /* Pointer to the SELECT on the RHS */ + Expr *pNew; + pNew = sqlite3ExprDup(db, pX, 0); + if( db->mallocFailed==0 ){ + for(pSelect=pNew->x.pSelect; pSelect; pSelect=pSelect->pPrior){ + ExprList *pOrigRhs; /* Original unmodified RHS */ + ExprList *pOrigLhs = 0; /* Original unmodified LHS */ + ExprList *pRhs = 0; /* New RHS after modifications */ + ExprList *pLhs = 0; /* New LHS after mods */ + int i; /* Loop counter */ + + assert( ExprUseXSelect(pNew) ); + pOrigRhs = pSelect->pEList; + assert( pNew->pLeft!=0 ); + assert( ExprUseXList(pNew->pLeft) ); + if( pSelect==pNew->x.pSelect ){ + pOrigLhs = pNew->pLeft->x.pList; + } + for(i=iEq; inLTerm; i++){ + if( pLoop->aLTerm[i]->pExpr==pX ){ + int iField; + assert( (pLoop->aLTerm[i]->eOperator & (WO_OR|WO_AND))==0 ); + iField = pLoop->aLTerm[i]->u.x.iField - 1; + if( pOrigRhs->a[iField].pExpr==0 ) continue; /* Duplicate PK column */ + pRhs = sqlite3ExprListAppend(pParse, pRhs, pOrigRhs->a[iField].pExpr); + pOrigRhs->a[iField].pExpr = 0; + if( pOrigLhs ){ + assert( pOrigLhs->a[iField].pExpr!=0 ); + pLhs = sqlite3ExprListAppend(pParse,pLhs,pOrigLhs->a[iField].pExpr); + pOrigLhs->a[iField].pExpr = 0; + } + } + } + sqlite3ExprListDelete(db, pOrigRhs); + if( pOrigLhs ){ + sqlite3ExprListDelete(db, pOrigLhs); + pNew->pLeft->x.pList = pLhs; + } + pSelect->pEList = pRhs; + if( pLhs && pLhs->nExpr==1 ){ + /* Take care here not to generate a TK_VECTOR containing only a + ** single value. Since the parser never creates such a vector, some + ** of the subroutines do not handle this case. */ + Expr *p = pLhs->a[0].pExpr; + pLhs->a[0].pExpr = 0; + sqlite3ExprDelete(db, pNew->pLeft); + pNew->pLeft = p; + } + if( pSelect->pOrderBy ){ + /* If the SELECT statement has an ORDER BY clause, zero the + ** iOrderByCol variables. These are set to non-zero when an + ** ORDER BY term exactly matches one of the terms of the + ** result-set. Since the result-set of the SELECT statement may + ** have been modified or reordered, these variables are no longer + ** set correctly. Since setting them is just an optimization, + ** it's easiest just to zero them here. */ + ExprList *pOrderBy = pSelect->pOrderBy; + for(i=0; inExpr; i++){ + pOrderBy->a[i].u.x.iOrderByCol = 0; + } + } + +#if 0 + printf("For indexing, change the IN expr:\n"); + sqlite3TreeViewExpr(0, pX, 0); + printf("Into:\n"); + sqlite3TreeViewExpr(0, pNew, 0); +#endif + } + } + return pNew; +} + + +/* +** Generate code for a single equality term of the WHERE clause. An equality +** term can be either X=expr or X IN (...). pTerm is the term to be +** coded. +** +** The current value for the constraint is left in a register, the index +** of which is returned. An attempt is made store the result in iTarget but +** this is only guaranteed for TK_ISNULL and TK_IN constraints. If the +** constraint is a TK_EQ or TK_IS, then the current value might be left in +** some other register and it is the caller's responsibility to compensate. +** +** For a constraint of the form X=expr, the expression is evaluated in +** straight-line code. For constraints of the form X IN (...) +** this routine sets up a loop that will iterate over all values of X. +*/ +static int codeEqualityTerm( + Parse *pParse, /* The parsing context */ + WhereTerm *pTerm, /* The term of the WHERE clause to be coded */ + WhereLevel *pLevel, /* The level of the FROM clause we are working on */ + int iEq, /* Index of the equality term within this level */ + int bRev, /* True for reverse-order IN operations */ + int iTarget /* Attempt to leave results in this register */ +){ + Expr *pX = pTerm->pExpr; + Vdbe *v = pParse->pVdbe; + int iReg; /* Register holding results */ + + assert( pLevel->pWLoop->aLTerm[iEq]==pTerm ); + assert( iTarget>0 ); + if( pX->op==TK_EQ || pX->op==TK_IS ){ + iReg = sqlite3ExprCodeTarget(pParse, pX->pRight, iTarget); + }else if( pX->op==TK_ISNULL ){ + iReg = iTarget; + sqlite3VdbeAddOp2(v, OP_Null, 0, iReg); +#ifndef SQLITE_OMIT_SUBQUERY + }else{ + int eType = IN_INDEX_NOOP; + int iTab; + struct InLoop *pIn; + WhereLoop *pLoop = pLevel->pWLoop; + int i; + int nEq = 0; + int *aiMap = 0; + + if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0 + && pLoop->u.btree.pIndex!=0 + && pLoop->u.btree.pIndex->aSortOrder[iEq] + ){ + testcase( iEq==0 ); + testcase( bRev ); + bRev = !bRev; + } + assert( pX->op==TK_IN ); + iReg = iTarget; + + for(i=0; iaLTerm[i] && pLoop->aLTerm[i]->pExpr==pX ){ + disableTerm(pLevel, pTerm); + return iTarget; + } + } + for(i=iEq;inLTerm; i++){ + assert( pLoop->aLTerm[i]!=0 ); + if( pLoop->aLTerm[i]->pExpr==pX ) nEq++; + } + + iTab = 0; + if( !ExprUseXSelect(pX) || pX->x.pSelect->pEList->nExpr==1 ){ + eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, 0, &iTab); + }else{ + Expr *pExpr = pTerm->pExpr; + if( pExpr->iTable==0 || !ExprHasProperty(pExpr, EP_Subrtn) ){ + sqlite3 *db = pParse->db; + pX = removeUnindexableInClauseTerms(pParse, iEq, pLoop, pX); + if( !db->mallocFailed ){ + aiMap = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int)*nEq); + eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, aiMap,&iTab); + pExpr->iTable = iTab; + } + sqlite3ExprDelete(db, pX); + }else{ + int n = sqlite3ExprVectorSize(pX->pLeft); + aiMap = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int)*MAX(nEq,n)); + eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, aiMap, &iTab); + } + pX = pExpr; + } + + if( eType==IN_INDEX_INDEX_DESC ){ + testcase( bRev ); + bRev = !bRev; + } + sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iTab, 0); + VdbeCoverageIf(v, bRev); + VdbeCoverageIf(v, !bRev); + + assert( (pLoop->wsFlags & WHERE_MULTI_OR)==0 ); + pLoop->wsFlags |= WHERE_IN_ABLE; + if( pLevel->u.in.nIn==0 ){ + pLevel->addrNxt = sqlite3VdbeMakeLabel(pParse); + } + if( iEq>0 && (pLoop->wsFlags & WHERE_IN_SEEKSCAN)==0 ){ + pLoop->wsFlags |= WHERE_IN_EARLYOUT; + } + + i = pLevel->u.in.nIn; + pLevel->u.in.nIn += nEq; + pLevel->u.in.aInLoop = + sqlite3WhereRealloc(pTerm->pWC->pWInfo, + pLevel->u.in.aInLoop, + sizeof(pLevel->u.in.aInLoop[0])*pLevel->u.in.nIn); + pIn = pLevel->u.in.aInLoop; + if( pIn ){ + int iMap = 0; /* Index in aiMap[] */ + pIn += i; + for(i=iEq;inLTerm; i++){ + if( pLoop->aLTerm[i]->pExpr==pX ){ + int iOut = iReg + i - iEq; + if( eType==IN_INDEX_ROWID ){ + pIn->addrInTop = sqlite3VdbeAddOp2(v, OP_Rowid, iTab, iOut); + }else{ + int iCol = aiMap ? aiMap[iMap++] : 0; + pIn->addrInTop = sqlite3VdbeAddOp3(v,OP_Column,iTab, iCol, iOut); + } + sqlite3VdbeAddOp1(v, OP_IsNull, iOut); VdbeCoverage(v); + if( i==iEq ){ + pIn->iCur = iTab; + pIn->eEndLoopOp = bRev ? OP_Prev : OP_Next; + if( iEq>0 ){ + pIn->iBase = iReg - i; + pIn->nPrefix = i; + }else{ + pIn->nPrefix = 0; + } + }else{ + pIn->eEndLoopOp = OP_Noop; + } + pIn++; + } + } + testcase( iEq>0 + && (pLoop->wsFlags & WHERE_IN_SEEKSCAN)==0 + && (pLoop->wsFlags & WHERE_VIRTUALTABLE)!=0 ); + if( iEq>0 + && (pLoop->wsFlags & (WHERE_IN_SEEKSCAN|WHERE_VIRTUALTABLE))==0 + ){ + sqlite3VdbeAddOp3(v, OP_SeekHit, pLevel->iIdxCur, 0, iEq); + } + }else{ + pLevel->u.in.nIn = 0; + } + sqlite3DbFree(pParse->db, aiMap); +#endif + } + + /* As an optimization, try to disable the WHERE clause term that is + ** driving the index as it will always be true. The correct answer is + ** obtained regardless, but we might get the answer with fewer CPU cycles + ** by omitting the term. + ** + ** But do not disable the term unless we are certain that the term is + ** not a transitive constraint. For an example of where that does not + ** work, see https://sqlite.org/forum/forumpost/eb8613976a (2021-05-04) + */ + if( (pLevel->pWLoop->wsFlags & WHERE_TRANSCONS)==0 + || (pTerm->eOperator & WO_EQUIV)==0 + ){ + disableTerm(pLevel, pTerm); + } + + return iReg; +} + +/* +** Generate code that will evaluate all == and IN constraints for an +** index scan. +** +** For example, consider table t1(a,b,c,d,e,f) with index i1(a,b,c). +** Suppose the WHERE clause is this: a==5 AND b IN (1,2,3) AND c>5 AND c<10 +** The index has as many as three equality constraints, but in this +** example, the third "c" value is an inequality. So only two +** constraints are coded. This routine will generate code to evaluate +** a==5 and b IN (1,2,3). The current values for a and b will be stored +** in consecutive registers and the index of the first register is returned. +** +** In the example above nEq==2. But this subroutine works for any value +** of nEq including 0. If nEq==0, this routine is nearly a no-op. +** The only thing it does is allocate the pLevel->iMem memory cell and +** compute the affinity string. +** +** The nExtraReg parameter is 0 or 1. It is 0 if all WHERE clause constraints +** are == or IN and are covered by the nEq. nExtraReg is 1 if there is +** an inequality constraint (such as the "c>=5 AND c<10" in the example) that +** occurs after the nEq quality constraints. +** +** This routine allocates a range of nEq+nExtraReg memory cells and returns +** the index of the first memory cell in that range. The code that +** calls this routine will use that memory range to store keys for +** start and termination conditions of the loop. +** key value of the loop. If one or more IN operators appear, then +** this routine allocates an additional nEq memory cells for internal +** use. +** +** Before returning, *pzAff is set to point to a buffer containing a +** copy of the column affinity string of the index allocated using +** sqlite3DbMalloc(). Except, entries in the copy of the string associated +** with equality constraints that use BLOB or NONE affinity are set to +** SQLITE_AFF_BLOB. This is to deal with SQL such as the following: +** +** CREATE TABLE t1(a TEXT PRIMARY KEY, b); +** SELECT ... FROM t1 AS t2, t1 WHERE t1.a = t2.b; +** +** In the example above, the index on t1(a) has TEXT affinity. But since +** the right hand side of the equality constraint (t2.b) has BLOB/NONE affinity, +** no conversion should be attempted before using a t2.b value as part of +** a key to search the index. Hence the first byte in the returned affinity +** string in this example would be set to SQLITE_AFF_BLOB. +*/ +static int codeAllEqualityTerms( + Parse *pParse, /* Parsing context */ + WhereLevel *pLevel, /* Which nested loop of the FROM we are coding */ + int bRev, /* Reverse the order of IN operators */ + int nExtraReg, /* Number of extra registers to allocate */ + char **pzAff /* OUT: Set to point to affinity string */ +){ + u16 nEq; /* The number of == or IN constraints to code */ + u16 nSkip; /* Number of left-most columns to skip */ + Vdbe *v = pParse->pVdbe; /* The vm under construction */ + Index *pIdx; /* The index being used for this loop */ + WhereTerm *pTerm; /* A single constraint term */ + WhereLoop *pLoop; /* The WhereLoop object */ + int j; /* Loop counter */ + int regBase; /* Base register */ + int nReg; /* Number of registers to allocate */ + char *zAff; /* Affinity string to return */ + + /* This module is only called on query plans that use an index. */ + pLoop = pLevel->pWLoop; + assert( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0 ); + nEq = pLoop->u.btree.nEq; + nSkip = pLoop->nSkip; + pIdx = pLoop->u.btree.pIndex; + assert( pIdx!=0 ); + + /* Figure out how many memory cells we will need then allocate them. + */ + regBase = pParse->nMem + 1; + nReg = pLoop->u.btree.nEq + nExtraReg; + pParse->nMem += nReg; + + zAff = sqlite3DbStrDup(pParse->db,sqlite3IndexAffinityStr(pParse->db,pIdx)); + assert( zAff!=0 || pParse->db->mallocFailed ); + + if( nSkip ){ + int iIdxCur = pLevel->iIdxCur; + sqlite3VdbeAddOp3(v, OP_Null, 0, regBase, regBase+nSkip-1); + sqlite3VdbeAddOp1(v, (bRev?OP_Last:OP_Rewind), iIdxCur); + VdbeCoverageIf(v, bRev==0); + VdbeCoverageIf(v, bRev!=0); + VdbeComment((v, "begin skip-scan on %s", pIdx->zName)); + j = sqlite3VdbeAddOp0(v, OP_Goto); + assert( pLevel->addrSkip==0 ); + pLevel->addrSkip = sqlite3VdbeAddOp4Int(v, (bRev?OP_SeekLT:OP_SeekGT), + iIdxCur, 0, regBase, nSkip); + VdbeCoverageIf(v, bRev==0); + VdbeCoverageIf(v, bRev!=0); + sqlite3VdbeJumpHere(v, j); + for(j=0; jaiColumn[j]==XN_EXPR ); + VdbeComment((v, "%s", explainIndexColumnName(pIdx, j))); + } + } + + /* Evaluate the equality constraints + */ + assert( zAff==0 || (int)strlen(zAff)>=nEq ); + for(j=nSkip; jaLTerm[j]; + assert( pTerm!=0 ); + /* The following testcase is true for indices with redundant columns. + ** Ex: CREATE INDEX i1 ON t1(a,b,a); SELECT * FROM t1 WHERE a=0 AND b=0; */ + testcase( (pTerm->wtFlags & TERM_CODED)!=0 ); + testcase( pTerm->wtFlags & TERM_VIRTUAL ); + r1 = codeEqualityTerm(pParse, pTerm, pLevel, j, bRev, regBase+j); + if( r1!=regBase+j ){ + if( nReg==1 ){ + sqlite3ReleaseTempReg(pParse, regBase); + regBase = r1; + }else{ + sqlite3VdbeAddOp2(v, OP_Copy, r1, regBase+j); + } + } + } + for(j=nSkip; jaLTerm[j]; + if( pTerm->eOperator & WO_IN ){ + if( pTerm->pExpr->flags & EP_xIsSelect ){ + /* No affinity ever needs to be (or should be) applied to a value + ** from the RHS of an "? IN (SELECT ...)" expression. The + ** sqlite3FindInIndex() routine has already ensured that the + ** affinity of the comparison has been applied to the value. */ + if( zAff ) zAff[j] = SQLITE_AFF_BLOB; + } + }else if( (pTerm->eOperator & WO_ISNULL)==0 ){ + Expr *pRight = pTerm->pExpr->pRight; + if( (pTerm->wtFlags & TERM_IS)==0 && sqlite3ExprCanBeNull(pRight) ){ + sqlite3VdbeAddOp2(v, OP_IsNull, regBase+j, pLevel->addrBrk); + VdbeCoverage(v); + } + if( pParse->nErr==0 ){ + assert( pParse->db->mallocFailed==0 ); + if( sqlite3CompareAffinity(pRight, zAff[j])==SQLITE_AFF_BLOB ){ + zAff[j] = SQLITE_AFF_BLOB; + } + if( sqlite3ExprNeedsNoAffinityChange(pRight, zAff[j]) ){ + zAff[j] = SQLITE_AFF_BLOB; + } + } + } + } + *pzAff = zAff; + return regBase; +} + +#ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS +/* +** If the most recently coded instruction is a constant range constraint +** (a string literal) that originated from the LIKE optimization, then +** set P3 and P5 on the OP_String opcode so that the string will be cast +** to a BLOB at appropriate times. +** +** The LIKE optimization trys to evaluate "x LIKE 'abc%'" as a range +** expression: "x>='ABC' AND x<'abd'". But this requires that the range +** scan loop run twice, once for strings and a second time for BLOBs. +** The OP_String opcodes on the second pass convert the upper and lower +** bound string constants to blobs. This routine makes the necessary changes +** to the OP_String opcodes for that to happen. +** +** Except, of course, if SQLITE_LIKE_DOESNT_MATCH_BLOBS is defined, then +** only the one pass through the string space is required, so this routine +** becomes a no-op. +*/ +static void whereLikeOptimizationStringFixup( + Vdbe *v, /* prepared statement under construction */ + WhereLevel *pLevel, /* The loop that contains the LIKE operator */ + WhereTerm *pTerm /* The upper or lower bound just coded */ +){ + if( pTerm->wtFlags & TERM_LIKEOPT ){ + VdbeOp *pOp; + assert( pLevel->iLikeRepCntr>0 ); + pOp = sqlite3VdbeGetLastOp(v); + assert( pOp!=0 ); + assert( pOp->opcode==OP_String8 + || pTerm->pWC->pWInfo->pParse->db->mallocFailed ); + pOp->p3 = (int)(pLevel->iLikeRepCntr>>1); /* Register holding counter */ + pOp->p5 = (u8)(pLevel->iLikeRepCntr&1); /* ASC or DESC */ + } +} +#else +# define whereLikeOptimizationStringFixup(A,B,C) +#endif + +#ifdef SQLITE_ENABLE_CURSOR_HINTS +/* +** Information is passed from codeCursorHint() down to individual nodes of +** the expression tree (by sqlite3WalkExpr()) using an instance of this +** structure. +*/ +struct CCurHint { + int iTabCur; /* Cursor for the main table */ + int iIdxCur; /* Cursor for the index, if pIdx!=0. Unused otherwise */ + Index *pIdx; /* The index used to access the table */ +}; + +/* +** This function is called for every node of an expression that is a candidate +** for a cursor hint on an index cursor. For TK_COLUMN nodes that reference +** the table CCurHint.iTabCur, verify that the same column can be +** accessed through the index. If it cannot, then set pWalker->eCode to 1. +*/ +static int codeCursorHintCheckExpr(Walker *pWalker, Expr *pExpr){ + struct CCurHint *pHint = pWalker->u.pCCurHint; + assert( pHint->pIdx!=0 ); + if( pExpr->op==TK_COLUMN + && pExpr->iTable==pHint->iTabCur + && sqlite3TableColumnToIndex(pHint->pIdx, pExpr->iColumn)<0 + ){ + pWalker->eCode = 1; + } + return WRC_Continue; +} + +/* +** Test whether or not expression pExpr, which was part of a WHERE clause, +** should be included in the cursor-hint for a table that is on the rhs +** of a LEFT JOIN. Set Walker.eCode to non-zero before returning if the +** expression is not suitable. +** +** An expression is unsuitable if it might evaluate to non NULL even if +** a TK_COLUMN node that does affect the value of the expression is set +** to NULL. For example: +** +** col IS NULL +** col IS NOT NULL +** coalesce(col, 1) +** CASE WHEN col THEN 0 ELSE 1 END +*/ +static int codeCursorHintIsOrFunction(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_IS + || pExpr->op==TK_ISNULL || pExpr->op==TK_ISNOT + || pExpr->op==TK_NOTNULL || pExpr->op==TK_CASE + ){ + pWalker->eCode = 1; + }else if( pExpr->op==TK_FUNCTION ){ + int d1; + char d2[4]; + if( 0==sqlite3IsLikeFunction(pWalker->pParse->db, pExpr, &d1, d2) ){ + pWalker->eCode = 1; + } + } + + return WRC_Continue; +} + + +/* +** This function is called on every node of an expression tree used as an +** argument to the OP_CursorHint instruction. If the node is a TK_COLUMN +** that accesses any table other than the one identified by +** CCurHint.iTabCur, then do the following: +** +** 1) allocate a register and code an OP_Column instruction to read +** the specified column into the new register, and +** +** 2) transform the expression node to a TK_REGISTER node that reads +** from the newly populated register. +** +** Also, if the node is a TK_COLUMN that does access the table idenified +** by pCCurHint.iTabCur, and an index is being used (which we will +** know because CCurHint.pIdx!=0) then transform the TK_COLUMN into +** an access of the index rather than the original table. +*/ +static int codeCursorHintFixExpr(Walker *pWalker, Expr *pExpr){ + int rc = WRC_Continue; + int reg; + struct CCurHint *pHint = pWalker->u.pCCurHint; + if( pExpr->op==TK_COLUMN ){ + if( pExpr->iTable!=pHint->iTabCur ){ + reg = ++pWalker->pParse->nMem; /* Register for column value */ + reg = sqlite3ExprCodeTarget(pWalker->pParse, pExpr, reg); + pExpr->op = TK_REGISTER; + pExpr->iTable = reg; + }else if( pHint->pIdx!=0 ){ + pExpr->iTable = pHint->iIdxCur; + pExpr->iColumn = sqlite3TableColumnToIndex(pHint->pIdx, pExpr->iColumn); + assert( pExpr->iColumn>=0 ); + } + }else if( pExpr->pAggInfo ){ + rc = WRC_Prune; + reg = ++pWalker->pParse->nMem; /* Register for column value */ + reg = sqlite3ExprCodeTarget(pWalker->pParse, pExpr, reg); + pExpr->op = TK_REGISTER; + pExpr->iTable = reg; + }else if( pExpr->op==TK_TRUEFALSE ){ + /* Do not walk disabled expressions. tag-20230504-1 */ + return WRC_Prune; + } + return rc; +} + +/* +** Insert an OP_CursorHint instruction if it is appropriate to do so. +*/ +static void codeCursorHint( + SrcItem *pTabItem, /* FROM clause item */ + WhereInfo *pWInfo, /* The where clause */ + WhereLevel *pLevel, /* Which loop to provide hints for */ + WhereTerm *pEndRange /* Hint this end-of-scan boundary term if not NULL */ +){ + Parse *pParse = pWInfo->pParse; + sqlite3 *db = pParse->db; + Vdbe *v = pParse->pVdbe; + Expr *pExpr = 0; + WhereLoop *pLoop = pLevel->pWLoop; + int iCur; + WhereClause *pWC; + WhereTerm *pTerm; + int i, j; + struct CCurHint sHint; + Walker sWalker; + + if( OptimizationDisabled(db, SQLITE_CursorHints) ) return; + iCur = pLevel->iTabCur; + assert( iCur==pWInfo->pTabList->a[pLevel->iFrom].iCursor ); + sHint.iTabCur = iCur; + sHint.iIdxCur = pLevel->iIdxCur; + sHint.pIdx = pLoop->u.btree.pIndex; + memset(&sWalker, 0, sizeof(sWalker)); + sWalker.pParse = pParse; + sWalker.u.pCCurHint = &sHint; + pWC = &pWInfo->sWC; + for(i=0; inBase; i++){ + pTerm = &pWC->a[i]; + if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue; + if( pTerm->prereqAll & pLevel->notReady ) continue; + + /* Any terms specified as part of the ON(...) clause for any LEFT + ** JOIN for which the current table is not the rhs are omitted + ** from the cursor-hint. + ** + ** If this table is the rhs of a LEFT JOIN, "IS" or "IS NULL" terms + ** that were specified as part of the WHERE clause must be excluded. + ** This is to address the following: + ** + ** SELECT ... t1 LEFT JOIN t2 ON (t1.a=t2.b) WHERE t2.c IS NULL; + ** + ** Say there is a single row in t2 that matches (t1.a=t2.b), but its + ** t2.c values is not NULL. If the (t2.c IS NULL) constraint is + ** pushed down to the cursor, this row is filtered out, causing + ** SQLite to synthesize a row of NULL values. Which does match the + ** WHERE clause, and so the query returns a row. Which is incorrect. + ** + ** For the same reason, WHERE terms such as: + ** + ** WHERE 1 = (t2.c IS NULL) + ** + ** are also excluded. See codeCursorHintIsOrFunction() for details. + */ + if( pTabItem->fg.jointype & JT_LEFT ){ + Expr *pExpr = pTerm->pExpr; + if( !ExprHasProperty(pExpr, EP_OuterON) + || pExpr->w.iJoin!=pTabItem->iCursor + ){ + sWalker.eCode = 0; + sWalker.xExprCallback = codeCursorHintIsOrFunction; + sqlite3WalkExpr(&sWalker, pTerm->pExpr); + if( sWalker.eCode ) continue; + } + }else{ + if( ExprHasProperty(pTerm->pExpr, EP_OuterON) ) continue; + } + + /* All terms in pWLoop->aLTerm[] except pEndRange are used to initialize + ** the cursor. These terms are not needed as hints for a pure range + ** scan (that has no == terms) so omit them. */ + if( pLoop->u.btree.nEq==0 && pTerm!=pEndRange ){ + for(j=0; jnLTerm && pLoop->aLTerm[j]!=pTerm; j++){} + if( jnLTerm ) continue; + } + + /* No subqueries or non-deterministic functions allowed */ + if( sqlite3ExprContainsSubquery(pTerm->pExpr) ) continue; + + /* For an index scan, make sure referenced columns are actually in + ** the index. */ + if( sHint.pIdx!=0 ){ + sWalker.eCode = 0; + sWalker.xExprCallback = codeCursorHintCheckExpr; + sqlite3WalkExpr(&sWalker, pTerm->pExpr); + if( sWalker.eCode ) continue; + } + + /* If we survive all prior tests, that means this term is worth hinting */ + pExpr = sqlite3ExprAnd(pParse, pExpr, sqlite3ExprDup(db, pTerm->pExpr, 0)); + } + if( pExpr!=0 ){ + sWalker.xExprCallback = codeCursorHintFixExpr; + if( pParse->nErr==0 ) sqlite3WalkExpr(&sWalker, pExpr); + sqlite3VdbeAddOp4(v, OP_CursorHint, + (sHint.pIdx ? sHint.iIdxCur : sHint.iTabCur), 0, 0, + (const char*)pExpr, P4_EXPR); + } +} +#else +# define codeCursorHint(A,B,C,D) /* No-op */ +#endif /* SQLITE_ENABLE_CURSOR_HINTS */ + +/* +** Cursor iCur is open on an intkey b-tree (a table). Register iRowid contains +** a rowid value just read from cursor iIdxCur, open on index pIdx. This +** function generates code to do a deferred seek of cursor iCur to the +** rowid stored in register iRowid. +** +** Normally, this is just: +** +** OP_DeferredSeek $iCur $iRowid +** +** Which causes a seek on $iCur to the row with rowid $iRowid. +** +** However, if the scan currently being coded is a branch of an OR-loop and +** the statement currently being coded is a SELECT, then additional information +** is added that might allow OP_Column to omit the seek and instead do its +** lookup on the index, thus avoiding an expensive seek operation. To +** enable this optimization, the P3 of OP_DeferredSeek is set to iIdxCur +** and P4 is set to an array of integers containing one entry for each column +** in the table. For each table column, if the column is the i'th +** column of the index, then the corresponding array entry is set to (i+1). +** If the column does not appear in the index at all, the array entry is set +** to 0. The OP_Column opcode can check this array to see if the column it +** wants is in the index and if it is, it will substitute the index cursor +** and column number and continue with those new values, rather than seeking +** the table cursor. +*/ +static void codeDeferredSeek( + WhereInfo *pWInfo, /* Where clause context */ + Index *pIdx, /* Index scan is using */ + int iCur, /* Cursor for IPK b-tree */ + int iIdxCur /* Index cursor */ +){ + Parse *pParse = pWInfo->pParse; /* Parse context */ + Vdbe *v = pParse->pVdbe; /* Vdbe to generate code within */ + + assert( iIdxCur>0 ); + assert( pIdx->aiColumn[pIdx->nColumn-1]==-1 ); + + pWInfo->bDeferredSeek = 1; + sqlite3VdbeAddOp3(v, OP_DeferredSeek, iIdxCur, 0, iCur); + if( (pWInfo->wctrlFlags & (WHERE_OR_SUBCLAUSE|WHERE_RIGHT_JOIN)) + && DbMaskAllZero(sqlite3ParseToplevel(pParse)->writeMask) + ){ + int i; + Table *pTab = pIdx->pTable; + u32 *ai = (u32*)sqlite3DbMallocZero(pParse->db, sizeof(u32)*(pTab->nCol+1)); + if( ai ){ + ai[0] = pTab->nCol; + for(i=0; inColumn-1; i++){ + int x1, x2; + assert( pIdx->aiColumn[i]nCol ); + x1 = pIdx->aiColumn[i]; + x2 = sqlite3TableColumnToStorage(pTab, x1); + testcase( x1!=x2 ); + if( x1>=0 ) ai[x2+1] = i+1; + } + sqlite3VdbeChangeP4(v, -1, (char*)ai, P4_INTARRAY); + } + } +} + +/* +** If the expression passed as the second argument is a vector, generate +** code to write the first nReg elements of the vector into an array +** of registers starting with iReg. +** +** If the expression is not a vector, then nReg must be passed 1. In +** this case, generate code to evaluate the expression and leave the +** result in register iReg. +*/ +static void codeExprOrVector(Parse *pParse, Expr *p, int iReg, int nReg){ + assert( nReg>0 ); + if( p && sqlite3ExprIsVector(p) ){ +#ifndef SQLITE_OMIT_SUBQUERY + if( ExprUseXSelect(p) ){ + Vdbe *v = pParse->pVdbe; + int iSelect; + assert( p->op==TK_SELECT ); + iSelect = sqlite3CodeSubselect(pParse, p); + sqlite3VdbeAddOp3(v, OP_Copy, iSelect, iReg, nReg-1); + }else +#endif + { + int i; + const ExprList *pList; + assert( ExprUseXList(p) ); + pList = p->x.pList; + assert( nReg<=pList->nExpr ); + for(i=0; ia[i].pExpr, iReg+i); + } + } + }else{ + assert( nReg==1 || pParse->nErr ); + sqlite3ExprCode(pParse, p, iReg); + } +} + +/* +** The pTruth expression is always true because it is the WHERE clause +** a partial index that is driving a query loop. Look through all of the +** WHERE clause terms on the query, and if any of those terms must be +** true because pTruth is true, then mark those WHERE clause terms as +** coded. +*/ +static void whereApplyPartialIndexConstraints( + Expr *pTruth, + int iTabCur, + WhereClause *pWC +){ + int i; + WhereTerm *pTerm; + while( pTruth->op==TK_AND ){ + whereApplyPartialIndexConstraints(pTruth->pLeft, iTabCur, pWC); + pTruth = pTruth->pRight; + } + for(i=0, pTerm=pWC->a; inTerm; i++, pTerm++){ + Expr *pExpr; + if( pTerm->wtFlags & TERM_CODED ) continue; + pExpr = pTerm->pExpr; + if( sqlite3ExprCompare(0, pExpr, pTruth, iTabCur)==0 ){ + pTerm->wtFlags |= TERM_CODED; + } + } +} + +/* +** This routine is called right after An OP_Filter has been generated and +** before the corresponding index search has been performed. This routine +** checks to see if there are additional Bloom filters in inner loops that +** can be checked prior to doing the index lookup. If there are available +** inner-loop Bloom filters, then evaluate those filters now, before the +** index lookup. The idea is that a Bloom filter check is way faster than +** an index lookup, and the Bloom filter might return false, meaning that +** the index lookup can be skipped. +** +** We know that an inner loop uses a Bloom filter because it has the +** WhereLevel.regFilter set. If an inner-loop Bloom filter is checked, +** then clear the WhereLevel.regFilter value to prevent the Bloom filter +** from being checked a second time when the inner loop is evaluated. +*/ +static SQLITE_NOINLINE void filterPullDown( + Parse *pParse, /* Parsing context */ + WhereInfo *pWInfo, /* Complete information about the WHERE clause */ + int iLevel, /* Which level of pWInfo->a[] should be coded */ + int addrNxt, /* Jump here to bypass inner loops */ + Bitmask notReady /* Loops that are not ready */ +){ + while( ++iLevel < pWInfo->nLevel ){ + WhereLevel *pLevel = &pWInfo->a[iLevel]; + WhereLoop *pLoop = pLevel->pWLoop; + if( pLevel->regFilter==0 ) continue; + if( pLevel->pWLoop->nSkip ) continue; + /* ,--- Because sqlite3ConstructBloomFilter() has will not have set + ** vvvvv--' pLevel->regFilter if this were true. */ + if( NEVER(pLoop->prereq & notReady) ) continue; + assert( pLevel->addrBrk==0 ); + pLevel->addrBrk = addrNxt; + if( pLoop->wsFlags & WHERE_IPK ){ + WhereTerm *pTerm = pLoop->aLTerm[0]; + int regRowid; + assert( pTerm!=0 ); + assert( pTerm->pExpr!=0 ); + testcase( pTerm->wtFlags & TERM_VIRTUAL ); + regRowid = sqlite3GetTempReg(pParse); + regRowid = codeEqualityTerm(pParse, pTerm, pLevel, 0, 0, regRowid); + sqlite3VdbeAddOp2(pParse->pVdbe, OP_MustBeInt, regRowid, addrNxt); + VdbeCoverage(pParse->pVdbe); + sqlite3VdbeAddOp4Int(pParse->pVdbe, OP_Filter, pLevel->regFilter, + addrNxt, regRowid, 1); + VdbeCoverage(pParse->pVdbe); + }else{ + u16 nEq = pLoop->u.btree.nEq; + int r1; + char *zStartAff; + + assert( pLoop->wsFlags & WHERE_INDEXED ); + assert( (pLoop->wsFlags & WHERE_COLUMN_IN)==0 ); + r1 = codeAllEqualityTerms(pParse,pLevel,0,0,&zStartAff); + codeApplyAffinity(pParse, r1, nEq, zStartAff); + sqlite3DbFree(pParse->db, zStartAff); + sqlite3VdbeAddOp4Int(pParse->pVdbe, OP_Filter, pLevel->regFilter, + addrNxt, r1, nEq); + VdbeCoverage(pParse->pVdbe); + } + pLevel->regFilter = 0; + pLevel->addrBrk = 0; + } +} + +/* +** Generate code for the start of the iLevel-th loop in the WHERE clause +** implementation described by pWInfo. +*/ +SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart( + Parse *pParse, /* Parsing context */ + Vdbe *v, /* Prepared statement under construction */ + WhereInfo *pWInfo, /* Complete information about the WHERE clause */ + int iLevel, /* Which level of pWInfo->a[] should be coded */ + WhereLevel *pLevel, /* The current level pointer */ + Bitmask notReady /* Which tables are currently available */ +){ + int j, k; /* Loop counters */ + int iCur; /* The VDBE cursor for the table */ + int addrNxt; /* Where to jump to continue with the next IN case */ + int bRev; /* True if we need to scan in reverse order */ + WhereLoop *pLoop; /* The WhereLoop object being coded */ + WhereClause *pWC; /* Decomposition of the entire WHERE clause */ + WhereTerm *pTerm; /* A WHERE clause term */ + sqlite3 *db; /* Database connection */ + SrcItem *pTabItem; /* FROM clause term being coded */ + int addrBrk; /* Jump here to break out of the loop */ + int addrHalt; /* addrBrk for the outermost loop */ + int addrCont; /* Jump here to continue with next cycle */ + int iRowidReg = 0; /* Rowid is stored in this register, if not zero */ + int iReleaseReg = 0; /* Temp register to free before returning */ + Index *pIdx = 0; /* Index used by loop (if any) */ + int iLoop; /* Iteration of constraint generator loop */ + + pWC = &pWInfo->sWC; + db = pParse->db; + pLoop = pLevel->pWLoop; + pTabItem = &pWInfo->pTabList->a[pLevel->iFrom]; + iCur = pTabItem->iCursor; + pLevel->notReady = notReady & ~sqlite3WhereGetMask(&pWInfo->sMaskSet, iCur); + bRev = (pWInfo->revMask>>iLevel)&1; + VdbeModuleComment((v, "Begin WHERE-loop%d: %s",iLevel,pTabItem->pTab->zName)); +#if WHERETRACE_ENABLED /* 0x4001 */ + if( sqlite3WhereTrace & 0x1 ){ + sqlite3DebugPrintf("Coding level %d of %d: notReady=%llx iFrom=%d\n", + iLevel, pWInfo->nLevel, (u64)notReady, pLevel->iFrom); + if( sqlite3WhereTrace & 0x1000 ){ + sqlite3WhereLoopPrint(pLoop, pWC); + } + } + if( (sqlite3WhereTrace & 0x4001)==0x4001 ){ + if( iLevel==0 ){ + sqlite3DebugPrintf("WHERE clause being coded:\n"); + sqlite3TreeViewExpr(0, pWInfo->pWhere, 0); + } + sqlite3DebugPrintf("All WHERE-clause terms before coding:\n"); + sqlite3WhereClausePrint(pWC); + } +#endif + + /* Create labels for the "break" and "continue" instructions + ** for the current loop. Jump to addrBrk to break out of a loop. + ** Jump to cont to go immediately to the next iteration of the + ** loop. + ** + ** When there is an IN operator, we also have a "addrNxt" label that + ** means to continue with the next IN value combination. When + ** there are no IN operators in the constraints, the "addrNxt" label + ** is the same as "addrBrk". + */ + addrBrk = pLevel->addrBrk = pLevel->addrNxt = sqlite3VdbeMakeLabel(pParse); + addrCont = pLevel->addrCont = sqlite3VdbeMakeLabel(pParse); + + /* If this is the right table of a LEFT OUTER JOIN, allocate and + ** initialize a memory cell that records if this table matches any + ** row of the left table of the join. + */ + assert( (pWInfo->wctrlFlags & (WHERE_OR_SUBCLAUSE|WHERE_RIGHT_JOIN)) + || pLevel->iFrom>0 || (pTabItem[0].fg.jointype & JT_LEFT)==0 + ); + if( pLevel->iFrom>0 && (pTabItem[0].fg.jointype & JT_LEFT)!=0 ){ + pLevel->iLeftJoin = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Integer, 0, pLevel->iLeftJoin); + VdbeComment((v, "init LEFT JOIN no-match flag")); + } + + /* Compute a safe address to jump to if we discover that the table for + ** this loop is empty and can never contribute content. */ + for(j=iLevel; j>0; j--){ + if( pWInfo->a[j].iLeftJoin ) break; + if( pWInfo->a[j].pRJ ) break; + } + addrHalt = pWInfo->a[j].addrBrk; + + /* Special case of a FROM clause subquery implemented as a co-routine */ + if( pTabItem->fg.viaCoroutine ){ + int regYield = pTabItem->regReturn; + sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pTabItem->addrFillSub); + pLevel->p2 = sqlite3VdbeAddOp2(v, OP_Yield, regYield, addrBrk); + VdbeCoverage(v); + VdbeComment((v, "next row of %s", pTabItem->pTab->zName)); + pLevel->op = OP_Goto; + }else + +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)!=0 ){ + /* Case 1: The table is a virtual-table. Use the VFilter and VNext + ** to access the data. + */ + int iReg; /* P3 Value for OP_VFilter */ + int addrNotFound; + int nConstraint = pLoop->nLTerm; + + iReg = sqlite3GetTempRange(pParse, nConstraint+2); + addrNotFound = pLevel->addrBrk; + for(j=0; jaLTerm[j]; + if( NEVER(pTerm==0) ) continue; + if( pTerm->eOperator & WO_IN ){ + if( SMASKBIT32(j) & pLoop->u.vtab.mHandleIn ){ + int iTab = pParse->nTab++; + int iCache = ++pParse->nMem; + sqlite3CodeRhsOfIN(pParse, pTerm->pExpr, iTab); + sqlite3VdbeAddOp3(v, OP_VInitIn, iTab, iTarget, iCache); + }else{ + codeEqualityTerm(pParse, pTerm, pLevel, j, bRev, iTarget); + addrNotFound = pLevel->addrNxt; + } + }else{ + Expr *pRight = pTerm->pExpr->pRight; + codeExprOrVector(pParse, pRight, iTarget, 1); + if( pTerm->eMatchOp==SQLITE_INDEX_CONSTRAINT_OFFSET + && pLoop->u.vtab.bOmitOffset + ){ + assert( pTerm->eOperator==WO_AUX ); + assert( pWInfo->pSelect!=0 ); + assert( pWInfo->pSelect->iOffset>0 ); + sqlite3VdbeAddOp2(v, OP_Integer, 0, pWInfo->pSelect->iOffset); + VdbeComment((v,"Zero OFFSET counter")); + } + } + } + sqlite3VdbeAddOp2(v, OP_Integer, pLoop->u.vtab.idxNum, iReg); + sqlite3VdbeAddOp2(v, OP_Integer, nConstraint, iReg+1); + sqlite3VdbeAddOp4(v, OP_VFilter, iCur, addrNotFound, iReg, + pLoop->u.vtab.idxStr, + pLoop->u.vtab.needFree ? P4_DYNAMIC : P4_STATIC); + VdbeCoverage(v); + pLoop->u.vtab.needFree = 0; + /* An OOM inside of AddOp4(OP_VFilter) instruction above might have freed + ** the u.vtab.idxStr. NULL it out to prevent a use-after-free */ + if( db->mallocFailed ) pLoop->u.vtab.idxStr = 0; + pLevel->p1 = iCur; + pLevel->op = pWInfo->eOnePass ? OP_Noop : OP_VNext; + pLevel->p2 = sqlite3VdbeCurrentAddr(v); + assert( (pLoop->wsFlags & WHERE_MULTI_OR)==0 ); + + for(j=0; jaLTerm[j]; + if( j<16 && (pLoop->u.vtab.omitMask>>j)&1 ){ + disableTerm(pLevel, pTerm); + continue; + } + if( (pTerm->eOperator & WO_IN)!=0 + && (SMASKBIT32(j) & pLoop->u.vtab.mHandleIn)==0 + && !db->mallocFailed + ){ + Expr *pCompare; /* The comparison operator */ + Expr *pRight; /* RHS of the comparison */ + VdbeOp *pOp; /* Opcode to access the value of the IN constraint */ + int iIn; /* IN loop corresponding to the j-th constraint */ + + /* Reload the constraint value into reg[iReg+j+2]. The same value + ** was loaded into the same register prior to the OP_VFilter, but + ** the xFilter implementation might have changed the datatype or + ** encoding of the value in the register, so it *must* be reloaded. + */ + for(iIn=0; ALWAYS(iInu.in.nIn); iIn++){ + pOp = sqlite3VdbeGetOp(v, pLevel->u.in.aInLoop[iIn].addrInTop); + if( (pOp->opcode==OP_Column && pOp->p3==iReg+j+2) + || (pOp->opcode==OP_Rowid && pOp->p2==iReg+j+2) + ){ + testcase( pOp->opcode==OP_Rowid ); + sqlite3VdbeAddOp3(v, pOp->opcode, pOp->p1, pOp->p2, pOp->p3); + break; + } + } + + /* Generate code that will continue to the next row if + ** the IN constraint is not satisfied + */ + pCompare = sqlite3PExpr(pParse, TK_EQ, 0, 0); + if( !db->mallocFailed ){ + int iFld = pTerm->u.x.iField; + Expr *pLeft = pTerm->pExpr->pLeft; + assert( pLeft!=0 ); + if( iFld>0 ){ + assert( pLeft->op==TK_VECTOR ); + assert( ExprUseXList(pLeft) ); + assert( iFld<=pLeft->x.pList->nExpr ); + pCompare->pLeft = pLeft->x.pList->a[iFld-1].pExpr; + }else{ + pCompare->pLeft = pLeft; + } + pCompare->pRight = pRight = sqlite3Expr(db, TK_REGISTER, 0); + if( pRight ){ + pRight->iTable = iReg+j+2; + sqlite3ExprIfFalse( + pParse, pCompare, pLevel->addrCont, SQLITE_JUMPIFNULL + ); + } + pCompare->pLeft = 0; + } + sqlite3ExprDelete(db, pCompare); + } + } + + /* These registers need to be preserved in case there is an IN operator + ** loop. So we could deallocate the registers here (and potentially + ** reuse them later) if (pLoop->wsFlags & WHERE_IN_ABLE)==0. But it seems + ** simpler and safer to simply not reuse the registers. + ** + ** sqlite3ReleaseTempRange(pParse, iReg, nConstraint+2); + */ + }else +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + + if( (pLoop->wsFlags & WHERE_IPK)!=0 + && (pLoop->wsFlags & (WHERE_COLUMN_IN|WHERE_COLUMN_EQ))!=0 + ){ + /* Case 2: We can directly reference a single row using an + ** equality comparison against the ROWID field. Or + ** we reference multiple rows using a "rowid IN (...)" + ** construct. + */ + assert( pLoop->u.btree.nEq==1 ); + pTerm = pLoop->aLTerm[0]; + assert( pTerm!=0 ); + assert( pTerm->pExpr!=0 ); + testcase( pTerm->wtFlags & TERM_VIRTUAL ); + iReleaseReg = ++pParse->nMem; + iRowidReg = codeEqualityTerm(pParse, pTerm, pLevel, 0, bRev, iReleaseReg); + if( iRowidReg!=iReleaseReg ) sqlite3ReleaseTempReg(pParse, iReleaseReg); + addrNxt = pLevel->addrNxt; + if( pLevel->regFilter ){ + sqlite3VdbeAddOp2(v, OP_MustBeInt, iRowidReg, addrNxt); + VdbeCoverage(v); + sqlite3VdbeAddOp4Int(v, OP_Filter, pLevel->regFilter, addrNxt, + iRowidReg, 1); + VdbeCoverage(v); + filterPullDown(pParse, pWInfo, iLevel, addrNxt, notReady); + } + sqlite3VdbeAddOp3(v, OP_SeekRowid, iCur, addrNxt, iRowidReg); + VdbeCoverage(v); + pLevel->op = OP_Noop; + }else if( (pLoop->wsFlags & WHERE_IPK)!=0 + && (pLoop->wsFlags & WHERE_COLUMN_RANGE)!=0 + ){ + /* Case 3: We have an inequality comparison against the ROWID field. + */ + int testOp = OP_Noop; + int start; + int memEndValue = 0; + WhereTerm *pStart, *pEnd; + + j = 0; + pStart = pEnd = 0; + if( pLoop->wsFlags & WHERE_BTM_LIMIT ) pStart = pLoop->aLTerm[j++]; + if( pLoop->wsFlags & WHERE_TOP_LIMIT ) pEnd = pLoop->aLTerm[j++]; + assert( pStart!=0 || pEnd!=0 ); + if( bRev ){ + pTerm = pStart; + pStart = pEnd; + pEnd = pTerm; + } + codeCursorHint(pTabItem, pWInfo, pLevel, pEnd); + if( pStart ){ + Expr *pX; /* The expression that defines the start bound */ + int r1, rTemp; /* Registers for holding the start boundary */ + int op; /* Cursor seek operation */ + + /* The following constant maps TK_xx codes into corresponding + ** seek opcodes. It depends on a particular ordering of TK_xx + */ + const u8 aMoveOp[] = { + /* TK_GT */ OP_SeekGT, + /* TK_LE */ OP_SeekLE, + /* TK_LT */ OP_SeekLT, + /* TK_GE */ OP_SeekGE + }; + assert( TK_LE==TK_GT+1 ); /* Make sure the ordering.. */ + assert( TK_LT==TK_GT+2 ); /* ... of the TK_xx values... */ + assert( TK_GE==TK_GT+3 ); /* ... is correcct. */ + + assert( (pStart->wtFlags & TERM_VNULL)==0 ); + testcase( pStart->wtFlags & TERM_VIRTUAL ); + pX = pStart->pExpr; + assert( pX!=0 ); + testcase( pStart->leftCursor!=iCur ); /* transitive constraints */ + if( sqlite3ExprIsVector(pX->pRight) ){ + r1 = rTemp = sqlite3GetTempReg(pParse); + codeExprOrVector(pParse, pX->pRight, r1, 1); + testcase( pX->op==TK_GT ); + testcase( pX->op==TK_GE ); + testcase( pX->op==TK_LT ); + testcase( pX->op==TK_LE ); + op = aMoveOp[((pX->op - TK_GT - 1) & 0x3) | 0x1]; + assert( pX->op!=TK_GT || op==OP_SeekGE ); + assert( pX->op!=TK_GE || op==OP_SeekGE ); + assert( pX->op!=TK_LT || op==OP_SeekLE ); + assert( pX->op!=TK_LE || op==OP_SeekLE ); + }else{ + r1 = sqlite3ExprCodeTemp(pParse, pX->pRight, &rTemp); + disableTerm(pLevel, pStart); + op = aMoveOp[(pX->op - TK_GT)]; + } + sqlite3VdbeAddOp3(v, op, iCur, addrBrk, r1); + VdbeComment((v, "pk")); + VdbeCoverageIf(v, pX->op==TK_GT); + VdbeCoverageIf(v, pX->op==TK_LE); + VdbeCoverageIf(v, pX->op==TK_LT); + VdbeCoverageIf(v, pX->op==TK_GE); + sqlite3ReleaseTempReg(pParse, rTemp); + }else{ + sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iCur, addrHalt); + VdbeCoverageIf(v, bRev==0); + VdbeCoverageIf(v, bRev!=0); + } + if( pEnd ){ + Expr *pX; + pX = pEnd->pExpr; + assert( pX!=0 ); + assert( (pEnd->wtFlags & TERM_VNULL)==0 ); + testcase( pEnd->leftCursor!=iCur ); /* Transitive constraints */ + testcase( pEnd->wtFlags & TERM_VIRTUAL ); + memEndValue = ++pParse->nMem; + codeExprOrVector(pParse, pX->pRight, memEndValue, 1); + if( 0==sqlite3ExprIsVector(pX->pRight) + && (pX->op==TK_LT || pX->op==TK_GT) + ){ + testOp = bRev ? OP_Le : OP_Ge; + }else{ + testOp = bRev ? OP_Lt : OP_Gt; + } + if( 0==sqlite3ExprIsVector(pX->pRight) ){ + disableTerm(pLevel, pEnd); + } + } + start = sqlite3VdbeCurrentAddr(v); + pLevel->op = bRev ? OP_Prev : OP_Next; + pLevel->p1 = iCur; + pLevel->p2 = start; + assert( pLevel->p5==0 ); + if( testOp!=OP_Noop ){ + iRowidReg = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Rowid, iCur, iRowidReg); + sqlite3VdbeAddOp3(v, testOp, memEndValue, addrBrk, iRowidReg); + VdbeCoverageIf(v, testOp==OP_Le); + VdbeCoverageIf(v, testOp==OP_Lt); + VdbeCoverageIf(v, testOp==OP_Ge); + VdbeCoverageIf(v, testOp==OP_Gt); + sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC | SQLITE_JUMPIFNULL); + } + }else if( pLoop->wsFlags & WHERE_INDEXED ){ + /* Case 4: A scan using an index. + ** + ** The WHERE clause may contain zero or more equality + ** terms ("==" or "IN" operators) that refer to the N + ** left-most columns of the index. It may also contain + ** inequality constraints (>, <, >= or <=) on the indexed + ** column that immediately follows the N equalities. Only + ** the right-most column can be an inequality - the rest must + ** use the "==" and "IN" operators. For example, if the + ** index is on (x,y,z), then the following clauses are all + ** optimized: + ** + ** x=5 + ** x=5 AND y=10 + ** x=5 AND y<10 + ** x=5 AND y>5 AND y<10 + ** x=5 AND y=5 AND z<=10 + ** + ** The z<10 term of the following cannot be used, only + ** the x=5 term: + ** + ** x=5 AND z<10 + ** + ** N may be zero if there are inequality constraints. + ** If there are no inequality constraints, then N is at + ** least one. + ** + ** This case is also used when there are no WHERE clause + ** constraints but an index is selected anyway, in order + ** to force the output order to conform to an ORDER BY. + */ + static const u8 aStartOp[] = { + 0, + 0, + OP_Rewind, /* 2: (!start_constraints && startEq && !bRev) */ + OP_Last, /* 3: (!start_constraints && startEq && bRev) */ + OP_SeekGT, /* 4: (start_constraints && !startEq && !bRev) */ + OP_SeekLT, /* 5: (start_constraints && !startEq && bRev) */ + OP_SeekGE, /* 6: (start_constraints && startEq && !bRev) */ + OP_SeekLE /* 7: (start_constraints && startEq && bRev) */ + }; + static const u8 aEndOp[] = { + OP_IdxGE, /* 0: (end_constraints && !bRev && !endEq) */ + OP_IdxGT, /* 1: (end_constraints && !bRev && endEq) */ + OP_IdxLE, /* 2: (end_constraints && bRev && !endEq) */ + OP_IdxLT, /* 3: (end_constraints && bRev && endEq) */ + }; + u16 nEq = pLoop->u.btree.nEq; /* Number of == or IN terms */ + u16 nBtm = pLoop->u.btree.nBtm; /* Length of BTM vector */ + u16 nTop = pLoop->u.btree.nTop; /* Length of TOP vector */ + int regBase; /* Base register holding constraint values */ + WhereTerm *pRangeStart = 0; /* Inequality constraint at range start */ + WhereTerm *pRangeEnd = 0; /* Inequality constraint at range end */ + int startEq; /* True if range start uses ==, >= or <= */ + int endEq; /* True if range end uses ==, >= or <= */ + int start_constraints; /* Start of range is constrained */ + int nConstraint; /* Number of constraint terms */ + int iIdxCur; /* The VDBE cursor for the index */ + int nExtraReg = 0; /* Number of extra registers needed */ + int op; /* Instruction opcode */ + char *zStartAff; /* Affinity for start of range constraint */ + char *zEndAff = 0; /* Affinity for end of range constraint */ + u8 bSeekPastNull = 0; /* True to seek past initial nulls */ + u8 bStopAtNull = 0; /* Add condition to terminate at NULLs */ + int omitTable; /* True if we use the index only */ + int regBignull = 0; /* big-null flag register */ + int addrSeekScan = 0; /* Opcode of the OP_SeekScan, if any */ + + pIdx = pLoop->u.btree.pIndex; + iIdxCur = pLevel->iIdxCur; + assert( nEq>=pLoop->nSkip ); + + /* Find any inequality constraint terms for the start and end + ** of the range. + */ + j = nEq; + if( pLoop->wsFlags & WHERE_BTM_LIMIT ){ + pRangeStart = pLoop->aLTerm[j++]; + nExtraReg = MAX(nExtraReg, pLoop->u.btree.nBtm); + /* Like optimization range constraints always occur in pairs */ + assert( (pRangeStart->wtFlags & TERM_LIKEOPT)==0 || + (pLoop->wsFlags & WHERE_TOP_LIMIT)!=0 ); + } + if( pLoop->wsFlags & WHERE_TOP_LIMIT ){ + pRangeEnd = pLoop->aLTerm[j++]; + nExtraReg = MAX(nExtraReg, pLoop->u.btree.nTop); +#ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS + if( (pRangeEnd->wtFlags & TERM_LIKEOPT)!=0 ){ + assert( pRangeStart!=0 ); /* LIKE opt constraints */ + assert( pRangeStart->wtFlags & TERM_LIKEOPT ); /* occur in pairs */ + pLevel->iLikeRepCntr = (u32)++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Integer, 1, (int)pLevel->iLikeRepCntr); + VdbeComment((v, "LIKE loop counter")); + pLevel->addrLikeRep = sqlite3VdbeCurrentAddr(v); + /* iLikeRepCntr actually stores 2x the counter register number. The + ** bottom bit indicates whether the search order is ASC or DESC. */ + testcase( bRev ); + testcase( pIdx->aSortOrder[nEq]==SQLITE_SO_DESC ); + assert( (bRev & ~1)==0 ); + pLevel->iLikeRepCntr <<=1; + pLevel->iLikeRepCntr |= bRev ^ (pIdx->aSortOrder[nEq]==SQLITE_SO_DESC); + } +#endif + if( pRangeStart==0 ){ + j = pIdx->aiColumn[nEq]; + if( (j>=0 && pIdx->pTable->aCol[j].notNull==0) || j==XN_EXPR ){ + bSeekPastNull = 1; + } + } + } + assert( pRangeEnd==0 || (pRangeEnd->wtFlags & TERM_VNULL)==0 ); + + /* If the WHERE_BIGNULL_SORT flag is set, then index column nEq uses + ** a non-default "big-null" sort (either ASC NULLS LAST or DESC NULLS + ** FIRST). In both cases separate ordered scans are made of those + ** index entries for which the column is null and for those for which + ** it is not. For an ASC sort, the non-NULL entries are scanned first. + ** For DESC, NULL entries are scanned first. + */ + if( (pLoop->wsFlags & (WHERE_TOP_LIMIT|WHERE_BTM_LIMIT))==0 + && (pLoop->wsFlags & WHERE_BIGNULL_SORT)!=0 + ){ + assert( bSeekPastNull==0 && nExtraReg==0 && nBtm==0 && nTop==0 ); + assert( pRangeEnd==0 && pRangeStart==0 ); + testcase( pLoop->nSkip>0 ); + nExtraReg = 1; + bSeekPastNull = 1; + pLevel->regBignull = regBignull = ++pParse->nMem; + if( pLevel->iLeftJoin ){ + sqlite3VdbeAddOp2(v, OP_Integer, 0, regBignull); + } + pLevel->addrBignull = sqlite3VdbeMakeLabel(pParse); + } + + /* If we are doing a reverse order scan on an ascending index, or + ** a forward order scan on a descending index, interchange the + ** start and end terms (pRangeStart and pRangeEnd). + */ + if( (nEqnColumn && bRev==(pIdx->aSortOrder[nEq]==SQLITE_SO_ASC)) ){ + SWAP(WhereTerm *, pRangeEnd, pRangeStart); + SWAP(u8, bSeekPastNull, bStopAtNull); + SWAP(u8, nBtm, nTop); + } + + if( iLevel>0 && (pLoop->wsFlags & WHERE_IN_SEEKSCAN)!=0 ){ + /* In case OP_SeekScan is used, ensure that the index cursor does not + ** point to a valid row for the first iteration of this loop. */ + sqlite3VdbeAddOp1(v, OP_NullRow, iIdxCur); + } + + /* Generate code to evaluate all constraint terms using == or IN + ** and store the values of those terms in an array of registers + ** starting at regBase. + */ + codeCursorHint(pTabItem, pWInfo, pLevel, pRangeEnd); + regBase = codeAllEqualityTerms(pParse,pLevel,bRev,nExtraReg,&zStartAff); + assert( zStartAff==0 || sqlite3Strlen30(zStartAff)>=nEq ); + if( zStartAff && nTop ){ + zEndAff = sqlite3DbStrDup(db, &zStartAff[nEq]); + } + addrNxt = (regBignull ? pLevel->addrBignull : pLevel->addrNxt); + + testcase( pRangeStart && (pRangeStart->eOperator & WO_LE)!=0 ); + testcase( pRangeStart && (pRangeStart->eOperator & WO_GE)!=0 ); + testcase( pRangeEnd && (pRangeEnd->eOperator & WO_LE)!=0 ); + testcase( pRangeEnd && (pRangeEnd->eOperator & WO_GE)!=0 ); + startEq = !pRangeStart || pRangeStart->eOperator & (WO_LE|WO_GE); + endEq = !pRangeEnd || pRangeEnd->eOperator & (WO_LE|WO_GE); + start_constraints = pRangeStart || nEq>0; + + /* Seek the index cursor to the start of the range. */ + nConstraint = nEq; + if( pRangeStart ){ + Expr *pRight = pRangeStart->pExpr->pRight; + codeExprOrVector(pParse, pRight, regBase+nEq, nBtm); + whereLikeOptimizationStringFixup(v, pLevel, pRangeStart); + if( (pRangeStart->wtFlags & TERM_VNULL)==0 + && sqlite3ExprCanBeNull(pRight) + ){ + sqlite3VdbeAddOp2(v, OP_IsNull, regBase+nEq, addrNxt); + VdbeCoverage(v); + } + if( zStartAff ){ + updateRangeAffinityStr(pRight, nBtm, &zStartAff[nEq]); + } + nConstraint += nBtm; + testcase( pRangeStart->wtFlags & TERM_VIRTUAL ); + if( sqlite3ExprIsVector(pRight)==0 ){ + disableTerm(pLevel, pRangeStart); + }else{ + startEq = 1; + } + bSeekPastNull = 0; + }else if( bSeekPastNull ){ + startEq = 0; + sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq); + start_constraints = 1; + nConstraint++; + }else if( regBignull ){ + sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq); + start_constraints = 1; + nConstraint++; + } + codeApplyAffinity(pParse, regBase, nConstraint - bSeekPastNull, zStartAff); + if( pLoop->nSkip>0 && nConstraint==pLoop->nSkip ){ + /* The skip-scan logic inside the call to codeAllEqualityConstraints() + ** above has already left the cursor sitting on the correct row, + ** so no further seeking is needed */ + }else{ + if( regBignull ){ + sqlite3VdbeAddOp2(v, OP_Integer, 1, regBignull); + VdbeComment((v, "NULL-scan pass ctr")); + } + if( pLevel->regFilter ){ + sqlite3VdbeAddOp4Int(v, OP_Filter, pLevel->regFilter, addrNxt, + regBase, nEq); + VdbeCoverage(v); + filterPullDown(pParse, pWInfo, iLevel, addrNxt, notReady); + } + + op = aStartOp[(start_constraints<<2) + (startEq<<1) + bRev]; + assert( op!=0 ); + if( (pLoop->wsFlags & WHERE_IN_SEEKSCAN)!=0 && op==OP_SeekGE ){ + assert( regBignull==0 ); + /* TUNING: The OP_SeekScan opcode seeks to reduce the number + ** of expensive seek operations by replacing a single seek with + ** 1 or more step operations. The question is, how many steps + ** should we try before giving up and going with a seek. The cost + ** of a seek is proportional to the logarithm of the of the number + ** of entries in the tree, so basing the number of steps to try + ** on the estimated number of rows in the btree seems like a good + ** guess. */ + addrSeekScan = sqlite3VdbeAddOp1(v, OP_SeekScan, + (pIdx->aiRowLogEst[0]+9)/10); + if( pRangeStart || pRangeEnd ){ + sqlite3VdbeChangeP5(v, 1); + sqlite3VdbeChangeP2(v, addrSeekScan, sqlite3VdbeCurrentAddr(v)+1); + addrSeekScan = 0; + } + VdbeCoverage(v); + } + sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint); + VdbeCoverage(v); + VdbeCoverageIf(v, op==OP_Rewind); testcase( op==OP_Rewind ); + VdbeCoverageIf(v, op==OP_Last); testcase( op==OP_Last ); + VdbeCoverageIf(v, op==OP_SeekGT); testcase( op==OP_SeekGT ); + VdbeCoverageIf(v, op==OP_SeekGE); testcase( op==OP_SeekGE ); + VdbeCoverageIf(v, op==OP_SeekLE); testcase( op==OP_SeekLE ); + VdbeCoverageIf(v, op==OP_SeekLT); testcase( op==OP_SeekLT ); + + assert( bSeekPastNull==0 || bStopAtNull==0 ); + if( regBignull ){ + assert( bSeekPastNull==1 || bStopAtNull==1 ); + assert( bSeekPastNull==!bStopAtNull ); + assert( bStopAtNull==startEq ); + sqlite3VdbeAddOp2(v, OP_Goto, 0, sqlite3VdbeCurrentAddr(v)+2); + op = aStartOp[(nConstraint>1)*4 + 2 + bRev]; + sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, + nConstraint-startEq); + VdbeCoverage(v); + VdbeCoverageIf(v, op==OP_Rewind); testcase( op==OP_Rewind ); + VdbeCoverageIf(v, op==OP_Last); testcase( op==OP_Last ); + VdbeCoverageIf(v, op==OP_SeekGE); testcase( op==OP_SeekGE ); + VdbeCoverageIf(v, op==OP_SeekLE); testcase( op==OP_SeekLE ); + assert( op==OP_Rewind || op==OP_Last || op==OP_SeekGE || op==OP_SeekLE); + } + } + + /* Load the value for the inequality constraint at the end of the + ** range (if any). + */ + nConstraint = nEq; + assert( pLevel->p2==0 ); + if( pRangeEnd ){ + Expr *pRight = pRangeEnd->pExpr->pRight; + assert( addrSeekScan==0 ); + codeExprOrVector(pParse, pRight, regBase+nEq, nTop); + whereLikeOptimizationStringFixup(v, pLevel, pRangeEnd); + if( (pRangeEnd->wtFlags & TERM_VNULL)==0 + && sqlite3ExprCanBeNull(pRight) + ){ + sqlite3VdbeAddOp2(v, OP_IsNull, regBase+nEq, addrNxt); + VdbeCoverage(v); + } + if( zEndAff ){ + updateRangeAffinityStr(pRight, nTop, zEndAff); + codeApplyAffinity(pParse, regBase+nEq, nTop, zEndAff); + }else{ + assert( pParse->db->mallocFailed ); + } + nConstraint += nTop; + testcase( pRangeEnd->wtFlags & TERM_VIRTUAL ); + + if( sqlite3ExprIsVector(pRight)==0 ){ + disableTerm(pLevel, pRangeEnd); + }else{ + endEq = 1; + } + }else if( bStopAtNull ){ + if( regBignull==0 ){ + sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq); + endEq = 0; + } + nConstraint++; + } + if( zStartAff ) sqlite3DbNNFreeNN(db, zStartAff); + if( zEndAff ) sqlite3DbNNFreeNN(db, zEndAff); + + /* Top of the loop body */ + pLevel->p2 = sqlite3VdbeCurrentAddr(v); + + /* Check if the index cursor is past the end of the range. */ + if( nConstraint ){ + if( regBignull ){ + /* Except, skip the end-of-range check while doing the NULL-scan */ + sqlite3VdbeAddOp2(v, OP_IfNot, regBignull, sqlite3VdbeCurrentAddr(v)+3); + VdbeComment((v, "If NULL-scan 2nd pass")); + VdbeCoverage(v); + } + op = aEndOp[bRev*2 + endEq]; + sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint); + testcase( op==OP_IdxGT ); VdbeCoverageIf(v, op==OP_IdxGT ); + testcase( op==OP_IdxGE ); VdbeCoverageIf(v, op==OP_IdxGE ); + testcase( op==OP_IdxLT ); VdbeCoverageIf(v, op==OP_IdxLT ); + testcase( op==OP_IdxLE ); VdbeCoverageIf(v, op==OP_IdxLE ); + if( addrSeekScan ) sqlite3VdbeJumpHere(v, addrSeekScan); + } + if( regBignull ){ + /* During a NULL-scan, check to see if we have reached the end of + ** the NULLs */ + assert( bSeekPastNull==!bStopAtNull ); + assert( bSeekPastNull+bStopAtNull==1 ); + assert( nConstraint+bSeekPastNull>0 ); + sqlite3VdbeAddOp2(v, OP_If, regBignull, sqlite3VdbeCurrentAddr(v)+2); + VdbeComment((v, "If NULL-scan 1st pass")); + VdbeCoverage(v); + op = aEndOp[bRev*2 + bSeekPastNull]; + sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, + nConstraint+bSeekPastNull); + testcase( op==OP_IdxGT ); VdbeCoverageIf(v, op==OP_IdxGT ); + testcase( op==OP_IdxGE ); VdbeCoverageIf(v, op==OP_IdxGE ); + testcase( op==OP_IdxLT ); VdbeCoverageIf(v, op==OP_IdxLT ); + testcase( op==OP_IdxLE ); VdbeCoverageIf(v, op==OP_IdxLE ); + } + + if( (pLoop->wsFlags & WHERE_IN_EARLYOUT)!=0 ){ + sqlite3VdbeAddOp3(v, OP_SeekHit, iIdxCur, nEq, nEq); + } + + /* Seek the table cursor, if required */ + omitTable = (pLoop->wsFlags & WHERE_IDX_ONLY)!=0 + && (pWInfo->wctrlFlags & (WHERE_OR_SUBCLAUSE|WHERE_RIGHT_JOIN))==0; + if( omitTable ){ + /* pIdx is a covering index. No need to access the main table. */ + }else if( HasRowid(pIdx->pTable) ){ + codeDeferredSeek(pWInfo, pIdx, iCur, iIdxCur); + }else if( iCur!=iIdxCur ){ + Index *pPk = sqlite3PrimaryKeyIndex(pIdx->pTable); + iRowidReg = sqlite3GetTempRange(pParse, pPk->nKeyCol); + for(j=0; jnKeyCol; j++){ + k = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[j]); + sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, k, iRowidReg+j); + } + sqlite3VdbeAddOp4Int(v, OP_NotFound, iCur, addrCont, + iRowidReg, pPk->nKeyCol); VdbeCoverage(v); + } + + if( pLevel->iLeftJoin==0 ){ + /* If a partial index is driving the loop, try to eliminate WHERE clause + ** terms from the query that must be true due to the WHERE clause of + ** the partial index. + ** + ** 2019-11-02 ticket 623eff57e76d45f6: This optimization does not work + ** for a LEFT JOIN. + */ + if( pIdx->pPartIdxWhere ){ + whereApplyPartialIndexConstraints(pIdx->pPartIdxWhere, iCur, pWC); + } + }else{ + testcase( pIdx->pPartIdxWhere ); + /* The following assert() is not a requirement, merely an observation: + ** The OR-optimization doesn't work for the right hand table of + ** a LEFT JOIN: */ + assert( (pWInfo->wctrlFlags & (WHERE_OR_SUBCLAUSE|WHERE_RIGHT_JOIN))==0 ); + } + + /* Record the instruction used to terminate the loop. */ + if( pLoop->wsFlags & WHERE_ONEROW ){ + pLevel->op = OP_Noop; + }else if( bRev ){ + pLevel->op = OP_Prev; + }else{ + pLevel->op = OP_Next; + } + pLevel->p1 = iIdxCur; + pLevel->p3 = (pLoop->wsFlags&WHERE_UNQ_WANTED)!=0 ? 1:0; + if( (pLoop->wsFlags & WHERE_CONSTRAINT)==0 ){ + pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP; + }else{ + assert( pLevel->p5==0 ); + } + if( omitTable ) pIdx = 0; + }else + +#ifndef SQLITE_OMIT_OR_OPTIMIZATION + if( pLoop->wsFlags & WHERE_MULTI_OR ){ + /* Case 5: Two or more separately indexed terms connected by OR + ** + ** Example: + ** + ** CREATE TABLE t1(a,b,c,d); + ** CREATE INDEX i1 ON t1(a); + ** CREATE INDEX i2 ON t1(b); + ** CREATE INDEX i3 ON t1(c); + ** + ** SELECT * FROM t1 WHERE a=5 OR b=7 OR (c=11 AND d=13) + ** + ** In the example, there are three indexed terms connected by OR. + ** The top of the loop looks like this: + ** + ** Null 1 # Zero the rowset in reg 1 + ** + ** Then, for each indexed term, the following. The arguments to + ** RowSetTest are such that the rowid of the current row is inserted + ** into the RowSet. If it is already present, control skips the + ** Gosub opcode and jumps straight to the code generated by WhereEnd(). + ** + ** sqlite3WhereBegin() + ** RowSetTest # Insert rowid into rowset + ** Gosub 2 A + ** sqlite3WhereEnd() + ** + ** Following the above, code to terminate the loop. Label A, the target + ** of the Gosub above, jumps to the instruction right after the Goto. + ** + ** Null 1 # Zero the rowset in reg 1 + ** Goto B # The loop is finished. + ** + ** A: # Return data, whatever. + ** + ** Return 2 # Jump back to the Gosub + ** + ** B: + ** + ** Added 2014-05-26: If the table is a WITHOUT ROWID table, then + ** use an ephemeral index instead of a RowSet to record the primary + ** keys of the rows we have already seen. + ** + */ + WhereClause *pOrWc; /* The OR-clause broken out into subterms */ + SrcList *pOrTab; /* Shortened table list or OR-clause generation */ + Index *pCov = 0; /* Potential covering index (or NULL) */ + int iCovCur = pParse->nTab++; /* Cursor used for index scans (if any) */ + + int regReturn = ++pParse->nMem; /* Register used with OP_Gosub */ + int regRowset = 0; /* Register for RowSet object */ + int regRowid = 0; /* Register holding rowid */ + int iLoopBody = sqlite3VdbeMakeLabel(pParse);/* Start of loop body */ + int iRetInit; /* Address of regReturn init */ + int untestedTerms = 0; /* Some terms not completely tested */ + int ii; /* Loop counter */ + Expr *pAndExpr = 0; /* An ".. AND (...)" expression */ + Table *pTab = pTabItem->pTab; + + pTerm = pLoop->aLTerm[0]; + assert( pTerm!=0 ); + assert( pTerm->eOperator & WO_OR ); + assert( (pTerm->wtFlags & TERM_ORINFO)!=0 ); + pOrWc = &pTerm->u.pOrInfo->wc; + pLevel->op = OP_Return; + pLevel->p1 = regReturn; + + /* Set up a new SrcList in pOrTab containing the table being scanned + ** by this loop in the a[0] slot and all notReady tables in a[1..] slots. + ** This becomes the SrcList in the recursive call to sqlite3WhereBegin(). + */ + if( pWInfo->nLevel>1 ){ + int nNotReady; /* The number of notReady tables */ + SrcItem *origSrc; /* Original list of tables */ + nNotReady = pWInfo->nLevel - iLevel - 1; + pOrTab = sqlite3DbMallocRawNN(db, + sizeof(*pOrTab)+ nNotReady*sizeof(pOrTab->a[0])); + if( pOrTab==0 ) return notReady; + pOrTab->nAlloc = (u8)(nNotReady + 1); + pOrTab->nSrc = pOrTab->nAlloc; + memcpy(pOrTab->a, pTabItem, sizeof(*pTabItem)); + origSrc = pWInfo->pTabList->a; + for(k=1; k<=nNotReady; k++){ + memcpy(&pOrTab->a[k], &origSrc[pLevel[k].iFrom], sizeof(pOrTab->a[k])); + } + }else{ + pOrTab = pWInfo->pTabList; + } + + /* Initialize the rowset register to contain NULL. An SQL NULL is + ** equivalent to an empty rowset. Or, create an ephemeral index + ** capable of holding primary keys in the case of a WITHOUT ROWID. + ** + ** Also initialize regReturn to contain the address of the instruction + ** immediately following the OP_Return at the bottom of the loop. This + ** is required in a few obscure LEFT JOIN cases where control jumps + ** over the top of the loop into the body of it. In this case the + ** correct response for the end-of-loop code (the OP_Return) is to + ** fall through to the next instruction, just as an OP_Next does if + ** called on an uninitialized cursor. + */ + if( (pWInfo->wctrlFlags & WHERE_DUPLICATES_OK)==0 ){ + if( HasRowid(pTab) ){ + regRowset = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Null, 0, regRowset); + }else{ + Index *pPk = sqlite3PrimaryKeyIndex(pTab); + regRowset = pParse->nTab++; + sqlite3VdbeAddOp2(v, OP_OpenEphemeral, regRowset, pPk->nKeyCol); + sqlite3VdbeSetP4KeyInfo(pParse, pPk); + } + regRowid = ++pParse->nMem; + } + iRetInit = sqlite3VdbeAddOp2(v, OP_Integer, 0, regReturn); + + /* If the original WHERE clause is z of the form: (x1 OR x2 OR ...) AND y + ** Then for every term xN, evaluate as the subexpression: xN AND y + ** That way, terms in y that are factored into the disjunction will + ** be picked up by the recursive calls to sqlite3WhereBegin() below. + ** + ** Actually, each subexpression is converted to "xN AND w" where w is + ** the "interesting" terms of z - terms that did not originate in the + ** ON or USING clause of a LEFT JOIN, and terms that are usable as + ** indices. + ** + ** This optimization also only applies if the (x1 OR x2 OR ...) term + ** is not contained in the ON clause of a LEFT JOIN. + ** See ticket http://www.sqlite.org/src/info/f2369304e4 + ** + ** 2022-02-04: Do not push down slices of a row-value comparison. + ** In other words, "w" or "y" may not be a slice of a vector. Otherwise, + ** the initialization of the right-hand operand of the vector comparison + ** might not occur, or might occur only in an OR branch that is not + ** taken. dbsqlfuzz 80a9fade844b4fb43564efc972bcb2c68270f5d1. + ** + ** 2022-03-03: Do not push down expressions that involve subqueries. + ** The subquery might get coded as a subroutine. Any table-references + ** in the subquery might be resolved to index-references for the index on + ** the OR branch in which the subroutine is coded. But if the subroutine + ** is invoked from a different OR branch that uses a different index, such + ** index-references will not work. tag-20220303a + ** https://sqlite.org/forum/forumpost/36937b197273d403 + */ + if( pWC->nTerm>1 ){ + int iTerm; + for(iTerm=0; iTermnTerm; iTerm++){ + Expr *pExpr = pWC->a[iTerm].pExpr; + if( &pWC->a[iTerm] == pTerm ) continue; + testcase( pWC->a[iTerm].wtFlags & TERM_VIRTUAL ); + testcase( pWC->a[iTerm].wtFlags & TERM_CODED ); + testcase( pWC->a[iTerm].wtFlags & TERM_SLICE ); + if( (pWC->a[iTerm].wtFlags & (TERM_VIRTUAL|TERM_CODED|TERM_SLICE))!=0 ){ + continue; + } + if( (pWC->a[iTerm].eOperator & WO_ALL)==0 ) continue; + if( ExprHasProperty(pExpr, EP_Subquery) ) continue; /* tag-20220303a */ + pExpr = sqlite3ExprDup(db, pExpr, 0); + pAndExpr = sqlite3ExprAnd(pParse, pAndExpr, pExpr); + } + if( pAndExpr ){ + /* The extra 0x10000 bit on the opcode is masked off and does not + ** become part of the new Expr.op. However, it does make the + ** op==TK_AND comparison inside of sqlite3PExpr() false, and this + ** prevents sqlite3PExpr() from applying the AND short-circuit + ** optimization, which we do not want here. */ + pAndExpr = sqlite3PExpr(pParse, TK_AND|0x10000, 0, pAndExpr); + } + } + + /* Run a separate WHERE clause for each term of the OR clause. After + ** eliminating duplicates from other WHERE clauses, the action for each + ** sub-WHERE clause is to to invoke the main loop body as a subroutine. + */ + ExplainQueryPlan((pParse, 1, "MULTI-INDEX OR")); + for(ii=0; iinTerm; ii++){ + WhereTerm *pOrTerm = &pOrWc->a[ii]; + if( pOrTerm->leftCursor==iCur || (pOrTerm->eOperator & WO_AND)!=0 ){ + WhereInfo *pSubWInfo; /* Info for single OR-term scan */ + Expr *pOrExpr = pOrTerm->pExpr; /* Current OR clause term */ + Expr *pDelete; /* Local copy of OR clause term */ + int jmp1 = 0; /* Address of jump operation */ + testcase( (pTabItem[0].fg.jointype & JT_LEFT)!=0 + && !ExprHasProperty(pOrExpr, EP_OuterON) + ); /* See TH3 vtab25.400 and ticket 614b25314c766238 */ + pDelete = pOrExpr = sqlite3ExprDup(db, pOrExpr, 0); + if( db->mallocFailed ){ + sqlite3ExprDelete(db, pDelete); + continue; + } + if( pAndExpr ){ + pAndExpr->pLeft = pOrExpr; + pOrExpr = pAndExpr; + } + /* Loop through table entries that match term pOrTerm. */ + ExplainQueryPlan((pParse, 1, "INDEX %d", ii+1)); + WHERETRACE(0xffffffff, ("Subplan for OR-clause:\n")); + pSubWInfo = sqlite3WhereBegin(pParse, pOrTab, pOrExpr, 0, 0, 0, + WHERE_OR_SUBCLAUSE, iCovCur); + assert( pSubWInfo || pParse->nErr ); + if( pSubWInfo ){ + WhereLoop *pSubLoop; + int addrExplain = sqlite3WhereExplainOneScan( + pParse, pOrTab, &pSubWInfo->a[0], 0 + ); + sqlite3WhereAddScanStatus(v, pOrTab, &pSubWInfo->a[0], addrExplain); + + /* This is the sub-WHERE clause body. First skip over + ** duplicate rows from prior sub-WHERE clauses, and record the + ** rowid (or PRIMARY KEY) for the current row so that the same + ** row will be skipped in subsequent sub-WHERE clauses. + */ + if( (pWInfo->wctrlFlags & WHERE_DUPLICATES_OK)==0 ){ + int iSet = ((ii==pOrWc->nTerm-1)?-1:ii); + if( HasRowid(pTab) ){ + sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, -1, regRowid); + jmp1 = sqlite3VdbeAddOp4Int(v, OP_RowSetTest, regRowset, 0, + regRowid, iSet); + VdbeCoverage(v); + }else{ + Index *pPk = sqlite3PrimaryKeyIndex(pTab); + int nPk = pPk->nKeyCol; + int iPk; + int r; + + /* Read the PK into an array of temp registers. */ + r = sqlite3GetTempRange(pParse, nPk); + for(iPk=0; iPkaiColumn[iPk]; + sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk); + } + + /* Check if the temp table already contains this key. If so, + ** the row has already been included in the result set and + ** can be ignored (by jumping past the Gosub below). Otherwise, + ** insert the key into the temp table and proceed with processing + ** the row. + ** + ** Use some of the same optimizations as OP_RowSetTest: If iSet + ** is zero, assume that the key cannot already be present in + ** the temp table. And if iSet is -1, assume that there is no + ** need to insert the key into the temp table, as it will never + ** be tested for. */ + if( iSet ){ + jmp1 = sqlite3VdbeAddOp4Int(v, OP_Found, regRowset, 0, r, nPk); + VdbeCoverage(v); + } + if( iSet>=0 ){ + sqlite3VdbeAddOp3(v, OP_MakeRecord, r, nPk, regRowid); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, regRowset, regRowid, + r, nPk); + if( iSet ) sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT); + } + + /* Release the array of temp registers */ + sqlite3ReleaseTempRange(pParse, r, nPk); + } + } + + /* Invoke the main loop body as a subroutine */ + sqlite3VdbeAddOp2(v, OP_Gosub, regReturn, iLoopBody); + + /* Jump here (skipping the main loop body subroutine) if the + ** current sub-WHERE row is a duplicate from prior sub-WHEREs. */ + if( jmp1 ) sqlite3VdbeJumpHere(v, jmp1); + + /* The pSubWInfo->untestedTerms flag means that this OR term + ** contained one or more AND term from a notReady table. The + ** terms from the notReady table could not be tested and will + ** need to be tested later. + */ + if( pSubWInfo->untestedTerms ) untestedTerms = 1; + + /* If all of the OR-connected terms are optimized using the same + ** index, and the index is opened using the same cursor number + ** by each call to sqlite3WhereBegin() made by this loop, it may + ** be possible to use that index as a covering index. + ** + ** If the call to sqlite3WhereBegin() above resulted in a scan that + ** uses an index, and this is either the first OR-connected term + ** processed or the index is the same as that used by all previous + ** terms, set pCov to the candidate covering index. Otherwise, set + ** pCov to NULL to indicate that no candidate covering index will + ** be available. + */ + pSubLoop = pSubWInfo->a[0].pWLoop; + assert( (pSubLoop->wsFlags & WHERE_AUTO_INDEX)==0 ); + if( (pSubLoop->wsFlags & WHERE_INDEXED)!=0 + && (ii==0 || pSubLoop->u.btree.pIndex==pCov) + && (HasRowid(pTab) || !IsPrimaryKeyIndex(pSubLoop->u.btree.pIndex)) + ){ + assert( pSubWInfo->a[0].iIdxCur==iCovCur ); + pCov = pSubLoop->u.btree.pIndex; + }else{ + pCov = 0; + } + if( sqlite3WhereUsesDeferredSeek(pSubWInfo) ){ + pWInfo->bDeferredSeek = 1; + } + + /* Finish the loop through table entries that match term pOrTerm. */ + sqlite3WhereEnd(pSubWInfo); + ExplainQueryPlanPop(pParse); + } + sqlite3ExprDelete(db, pDelete); + } + } + ExplainQueryPlanPop(pParse); + assert( pLevel->pWLoop==pLoop ); + assert( (pLoop->wsFlags & WHERE_MULTI_OR)!=0 ); + assert( (pLoop->wsFlags & WHERE_IN_ABLE)==0 ); + pLevel->u.pCoveringIdx = pCov; + if( pCov ) pLevel->iIdxCur = iCovCur; + if( pAndExpr ){ + pAndExpr->pLeft = 0; + sqlite3ExprDelete(db, pAndExpr); + } + sqlite3VdbeChangeP1(v, iRetInit, sqlite3VdbeCurrentAddr(v)); + sqlite3VdbeGoto(v, pLevel->addrBrk); + sqlite3VdbeResolveLabel(v, iLoopBody); + + /* Set the P2 operand of the OP_Return opcode that will end the current + ** loop to point to this spot, which is the top of the next containing + ** loop. The byte-code formatter will use that P2 value as a hint to + ** indent everything in between the this point and the final OP_Return. + ** See tag-20220407a in vdbe.c and shell.c */ + assert( pLevel->op==OP_Return ); + pLevel->p2 = sqlite3VdbeCurrentAddr(v); + + if( pWInfo->nLevel>1 ){ sqlite3DbFreeNN(db, pOrTab); } + if( !untestedTerms ) disableTerm(pLevel, pTerm); + }else +#endif /* SQLITE_OMIT_OR_OPTIMIZATION */ + + { + /* Case 6: There is no usable index. We must do a complete + ** scan of the entire table. + */ + static const u8 aStep[] = { OP_Next, OP_Prev }; + static const u8 aStart[] = { OP_Rewind, OP_Last }; + assert( bRev==0 || bRev==1 ); + if( pTabItem->fg.isRecursive ){ + /* Tables marked isRecursive have only a single row that is stored in + ** a pseudo-cursor. No need to Rewind or Next such cursors. */ + pLevel->op = OP_Noop; + }else{ + codeCursorHint(pTabItem, pWInfo, pLevel, 0); + pLevel->op = aStep[bRev]; + pLevel->p1 = iCur; + pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, aStart[bRev], iCur, addrHalt); + VdbeCoverageIf(v, bRev==0); + VdbeCoverageIf(v, bRev!=0); + pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP; + } + } + +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + pLevel->addrVisit = sqlite3VdbeCurrentAddr(v); +#endif + + /* Insert code to test every subexpression that can be completely + ** computed using the current set of tables. + ** + ** This loop may run between one and three times, depending on the + ** constraints to be generated. The value of stack variable iLoop + ** determines the constraints coded by each iteration, as follows: + ** + ** iLoop==1: Code only expressions that are entirely covered by pIdx. + ** iLoop==2: Code remaining expressions that do not contain correlated + ** sub-queries. + ** iLoop==3: Code all remaining expressions. + ** + ** An effort is made to skip unnecessary iterations of the loop. + */ + iLoop = (pIdx ? 1 : 2); + do{ + int iNext = 0; /* Next value for iLoop */ + for(pTerm=pWC->a, j=pWC->nTerm; j>0; j--, pTerm++){ + Expr *pE; + int skipLikeAddr = 0; + testcase( pTerm->wtFlags & TERM_VIRTUAL ); + testcase( pTerm->wtFlags & TERM_CODED ); + if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue; + if( (pTerm->prereqAll & pLevel->notReady)!=0 ){ + testcase( pWInfo->untestedTerms==0 + && (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)!=0 ); + pWInfo->untestedTerms = 1; + continue; + } + pE = pTerm->pExpr; + assert( pE!=0 ); + if( pTabItem->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT) ){ + if( !ExprHasProperty(pE,EP_OuterON|EP_InnerON) ){ + /* Defer processing WHERE clause constraints until after outer + ** join processing. tag-20220513a */ + continue; + }else if( (pTabItem->fg.jointype & JT_LEFT)==JT_LEFT + && !ExprHasProperty(pE,EP_OuterON) ){ + continue; + }else{ + Bitmask m = sqlite3WhereGetMask(&pWInfo->sMaskSet, pE->w.iJoin); + if( m & pLevel->notReady ){ + /* An ON clause that is not ripe */ + continue; + } + } + } + if( iLoop==1 && !sqlite3ExprCoveredByIndex(pE, pLevel->iTabCur, pIdx) ){ + iNext = 2; + continue; + } + if( iLoop<3 && (pTerm->wtFlags & TERM_VARSELECT) ){ + if( iNext==0 ) iNext = 3; + continue; + } + + if( (pTerm->wtFlags & TERM_LIKECOND)!=0 ){ + /* If the TERM_LIKECOND flag is set, that means that the range search + ** is sufficient to guarantee that the LIKE operator is true, so we + ** can skip the call to the like(A,B) function. But this only works + ** for strings. So do not skip the call to the function on the pass + ** that compares BLOBs. */ +#ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS + continue; +#else + u32 x = pLevel->iLikeRepCntr; + if( x>0 ){ + skipLikeAddr = sqlite3VdbeAddOp1(v, (x&1)?OP_IfNot:OP_If,(int)(x>>1)); + VdbeCoverageIf(v, (x&1)==1); + VdbeCoverageIf(v, (x&1)==0); + } +#endif + } +#ifdef WHERETRACE_ENABLED /* 0xffffffff */ + if( sqlite3WhereTrace ){ + VdbeNoopComment((v, "WhereTerm[%d] (%p) priority=%d", + pWC->nTerm-j, pTerm, iLoop)); + } + if( sqlite3WhereTrace & 0x4000 ){ + sqlite3DebugPrintf("Coding auxiliary constraint:\n"); + sqlite3WhereTermPrint(pTerm, pWC->nTerm-j); + } +#endif + sqlite3ExprIfFalse(pParse, pE, addrCont, SQLITE_JUMPIFNULL); + if( skipLikeAddr ) sqlite3VdbeJumpHere(v, skipLikeAddr); + pTerm->wtFlags |= TERM_CODED; + } + iLoop = iNext; + }while( iLoop>0 ); + + /* Insert code to test for implied constraints based on transitivity + ** of the "==" operator. + ** + ** Example: If the WHERE clause contains "t1.a=t2.b" and "t2.b=123" + ** and we are coding the t1 loop and the t2 loop has not yet coded, + ** then we cannot use the "t1.a=t2.b" constraint, but we can code + ** the implied "t1.a=123" constraint. + */ + for(pTerm=pWC->a, j=pWC->nBase; j>0; j--, pTerm++){ + Expr *pE, sEAlt; + WhereTerm *pAlt; + if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue; + if( (pTerm->eOperator & (WO_EQ|WO_IS))==0 ) continue; + if( (pTerm->eOperator & WO_EQUIV)==0 ) continue; + if( pTerm->leftCursor!=iCur ) continue; + if( pTabItem->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT) ) continue; + pE = pTerm->pExpr; +#ifdef WHERETRACE_ENABLED /* 0x4001 */ + if( (sqlite3WhereTrace & 0x4001)==0x4001 ){ + sqlite3DebugPrintf("Coding transitive constraint:\n"); + sqlite3WhereTermPrint(pTerm, pWC->nTerm-j); + } +#endif + assert( !ExprHasProperty(pE, EP_OuterON) ); + assert( (pTerm->prereqRight & pLevel->notReady)!=0 ); + assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 ); + pAlt = sqlite3WhereFindTerm(pWC, iCur, pTerm->u.x.leftColumn, notReady, + WO_EQ|WO_IN|WO_IS, 0); + if( pAlt==0 ) continue; + if( pAlt->wtFlags & (TERM_CODED) ) continue; + if( (pAlt->eOperator & WO_IN) + && ExprUseXSelect(pAlt->pExpr) + && (pAlt->pExpr->x.pSelect->pEList->nExpr>1) + ){ + continue; + } + testcase( pAlt->eOperator & WO_EQ ); + testcase( pAlt->eOperator & WO_IS ); + testcase( pAlt->eOperator & WO_IN ); + VdbeModuleComment((v, "begin transitive constraint")); + sEAlt = *pAlt->pExpr; + sEAlt.pLeft = pE->pLeft; + sqlite3ExprIfFalse(pParse, &sEAlt, addrCont, SQLITE_JUMPIFNULL); + pAlt->wtFlags |= TERM_CODED; + } + + /* For a RIGHT OUTER JOIN, record the fact that the current row has + ** been matched at least once. + */ + if( pLevel->pRJ ){ + Table *pTab; + int nPk; + int r; + int jmp1 = 0; + WhereRightJoin *pRJ = pLevel->pRJ; + + /* pTab is the right-hand table of the RIGHT JOIN. Generate code that + ** will record that the current row of that table has been matched at + ** least once. This is accomplished by storing the PK for the row in + ** both the iMatch index and the regBloom Bloom filter. + */ + pTab = pWInfo->pTabList->a[pLevel->iFrom].pTab; + if( HasRowid(pTab) ){ + r = sqlite3GetTempRange(pParse, 2); + sqlite3ExprCodeGetColumnOfTable(v, pTab, pLevel->iTabCur, -1, r+1); + nPk = 1; + }else{ + int iPk; + Index *pPk = sqlite3PrimaryKeyIndex(pTab); + nPk = pPk->nKeyCol; + r = sqlite3GetTempRange(pParse, nPk+1); + for(iPk=0; iPkaiColumn[iPk]; + sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+1+iPk); + } + } + jmp1 = sqlite3VdbeAddOp4Int(v, OP_Found, pRJ->iMatch, 0, r+1, nPk); + VdbeCoverage(v); + VdbeComment((v, "match against %s", pTab->zName)); + sqlite3VdbeAddOp3(v, OP_MakeRecord, r+1, nPk, r); + sqlite3VdbeAddOp4Int(v, OP_IdxInsert, pRJ->iMatch, r, r+1, nPk); + sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pRJ->regBloom, 0, r+1, nPk); + sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT); + sqlite3VdbeJumpHere(v, jmp1); + sqlite3ReleaseTempRange(pParse, r, nPk+1); + } + + /* For a LEFT OUTER JOIN, generate code that will record the fact that + ** at least one row of the right table has matched the left table. + */ + if( pLevel->iLeftJoin ){ + pLevel->addrFirst = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp2(v, OP_Integer, 1, pLevel->iLeftJoin); + VdbeComment((v, "record LEFT JOIN hit")); + if( pLevel->pRJ==0 ){ + goto code_outer_join_constraints; /* WHERE clause constraints */ + } + } + + if( pLevel->pRJ ){ + /* Create a subroutine used to process all interior loops and code + ** of the RIGHT JOIN. During normal operation, the subroutine will + ** be in-line with the rest of the code. But at the end, a separate + ** loop will run that invokes this subroutine for unmatched rows + ** of pTab, with all tables to left begin set to NULL. + */ + WhereRightJoin *pRJ = pLevel->pRJ; + sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pRJ->regReturn); + pRJ->addrSubrtn = sqlite3VdbeCurrentAddr(v); + assert( pParse->withinRJSubrtn < 255 ); + pParse->withinRJSubrtn++; + + /* WHERE clause constraints must be deferred until after outer join + ** row elimination has completed, since WHERE clause constraints apply + ** to the results of the OUTER JOIN. The following loop generates the + ** appropriate WHERE clause constraint checks. tag-20220513a. + */ + code_outer_join_constraints: + for(pTerm=pWC->a, j=0; jnBase; j++, pTerm++){ + testcase( pTerm->wtFlags & TERM_VIRTUAL ); + testcase( pTerm->wtFlags & TERM_CODED ); + if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue; + if( (pTerm->prereqAll & pLevel->notReady)!=0 ){ + assert( pWInfo->untestedTerms ); + continue; + } + if( pTabItem->fg.jointype & JT_LTORJ ) continue; + assert( pTerm->pExpr ); + sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL); + pTerm->wtFlags |= TERM_CODED; + } + } + +#if WHERETRACE_ENABLED /* 0x4001 */ + if( sqlite3WhereTrace & 0x4000 ){ + sqlite3DebugPrintf("All WHERE-clause terms after coding level %d:\n", + iLevel); + sqlite3WhereClausePrint(pWC); + } + if( sqlite3WhereTrace & 0x1 ){ + sqlite3DebugPrintf("End Coding level %d: notReady=%llx\n", + iLevel, (u64)pLevel->notReady); + } +#endif + return pLevel->notReady; +} + +/* +** Generate the code for the loop that finds all non-matched terms +** for a RIGHT JOIN. +*/ +SQLITE_PRIVATE SQLITE_NOINLINE void sqlite3WhereRightJoinLoop( + WhereInfo *pWInfo, + int iLevel, + WhereLevel *pLevel +){ + Parse *pParse = pWInfo->pParse; + Vdbe *v = pParse->pVdbe; + WhereRightJoin *pRJ = pLevel->pRJ; + Expr *pSubWhere = 0; + WhereClause *pWC = &pWInfo->sWC; + WhereInfo *pSubWInfo; + WhereLoop *pLoop = pLevel->pWLoop; + SrcItem *pTabItem = &pWInfo->pTabList->a[pLevel->iFrom]; + SrcList sFrom; + Bitmask mAll = 0; + int k; + + ExplainQueryPlan((pParse, 1, "RIGHT-JOIN %s", pTabItem->pTab->zName)); + sqlite3VdbeNoJumpsOutsideSubrtn(v, pRJ->addrSubrtn, pRJ->endSubrtn, + pRJ->regReturn); + for(k=0; ka[k].pWLoop->maskSelf; + sqlite3VdbeAddOp1(v, OP_NullRow, pWInfo->a[k].iTabCur); + iIdxCur = pWInfo->a[k].iIdxCur; + if( iIdxCur ){ + sqlite3VdbeAddOp1(v, OP_NullRow, iIdxCur); + } + } + if( (pTabItem->fg.jointype & JT_LTORJ)==0 ){ + mAll |= pLoop->maskSelf; + for(k=0; knTerm; k++){ + WhereTerm *pTerm = &pWC->a[k]; + if( (pTerm->wtFlags & (TERM_VIRTUAL|TERM_SLICE))!=0 + && pTerm->eOperator!=WO_ROWVAL + ){ + break; + } + if( pTerm->prereqAll & ~mAll ) continue; + if( ExprHasProperty(pTerm->pExpr, EP_OuterON|EP_InnerON) ) continue; + pSubWhere = sqlite3ExprAnd(pParse, pSubWhere, + sqlite3ExprDup(pParse->db, pTerm->pExpr, 0)); + } + } + sFrom.nSrc = 1; + sFrom.nAlloc = 1; + memcpy(&sFrom.a[0], pTabItem, sizeof(SrcItem)); + sFrom.a[0].fg.jointype = 0; + assert( pParse->withinRJSubrtn < 100 ); + pParse->withinRJSubrtn++; + pSubWInfo = sqlite3WhereBegin(pParse, &sFrom, pSubWhere, 0, 0, 0, + WHERE_RIGHT_JOIN, 0); + if( pSubWInfo ){ + int iCur = pLevel->iTabCur; + int r = ++pParse->nMem; + int nPk; + int jmp; + int addrCont = sqlite3WhereContinueLabel(pSubWInfo); + Table *pTab = pTabItem->pTab; + if( HasRowid(pTab) ){ + sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, -1, r); + nPk = 1; + }else{ + int iPk; + Index *pPk = sqlite3PrimaryKeyIndex(pTab); + nPk = pPk->nKeyCol; + pParse->nMem += nPk - 1; + for(iPk=0; iPkaiColumn[iPk]; + sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk); + } + } + jmp = sqlite3VdbeAddOp4Int(v, OP_Filter, pRJ->regBloom, 0, r, nPk); + VdbeCoverage(v); + sqlite3VdbeAddOp4Int(v, OP_Found, pRJ->iMatch, addrCont, r, nPk); + VdbeCoverage(v); + sqlite3VdbeJumpHere(v, jmp); + sqlite3VdbeAddOp2(v, OP_Gosub, pRJ->regReturn, pRJ->addrSubrtn); + sqlite3WhereEnd(pSubWInfo); + } + sqlite3ExprDelete(pParse->db, pSubWhere); + ExplainQueryPlanPop(pParse); + assert( pParse->withinRJSubrtn>0 ); + pParse->withinRJSubrtn--; +} + +/************** End of wherecode.c *******************************************/ +/************** Begin file whereexpr.c ***************************************/ +/* +** 2015-06-08 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This module contains C code that generates VDBE code used to process +** the WHERE clause of SQL statements. +** +** This file was originally part of where.c but was split out to improve +** readability and editabiliity. This file contains utility routines for +** analyzing Expr objects in the WHERE clause. +*/ +/* #include "sqliteInt.h" */ +/* #include "whereInt.h" */ + +/* Forward declarations */ +static void exprAnalyze(SrcList*, WhereClause*, int); + +/* +** Deallocate all memory associated with a WhereOrInfo object. +*/ +static void whereOrInfoDelete(sqlite3 *db, WhereOrInfo *p){ + sqlite3WhereClauseClear(&p->wc); + sqlite3DbFree(db, p); +} + +/* +** Deallocate all memory associated with a WhereAndInfo object. +*/ +static void whereAndInfoDelete(sqlite3 *db, WhereAndInfo *p){ + sqlite3WhereClauseClear(&p->wc); + sqlite3DbFree(db, p); +} + +/* +** Add a single new WhereTerm entry to the WhereClause object pWC. +** The new WhereTerm object is constructed from Expr p and with wtFlags. +** The index in pWC->a[] of the new WhereTerm is returned on success. +** 0 is returned if the new WhereTerm could not be added due to a memory +** allocation error. The memory allocation failure will be recorded in +** the db->mallocFailed flag so that higher-level functions can detect it. +** +** This routine will increase the size of the pWC->a[] array as necessary. +** +** If the wtFlags argument includes TERM_DYNAMIC, then responsibility +** for freeing the expression p is assumed by the WhereClause object pWC. +** This is true even if this routine fails to allocate a new WhereTerm. +** +** WARNING: This routine might reallocate the space used to store +** WhereTerms. All pointers to WhereTerms should be invalidated after +** calling this routine. Such pointers may be reinitialized by referencing +** the pWC->a[] array. +*/ +static int whereClauseInsert(WhereClause *pWC, Expr *p, u16 wtFlags){ + WhereTerm *pTerm; + int idx; + testcase( wtFlags & TERM_VIRTUAL ); + if( pWC->nTerm>=pWC->nSlot ){ + WhereTerm *pOld = pWC->a; + sqlite3 *db = pWC->pWInfo->pParse->db; + pWC->a = sqlite3WhereMalloc(pWC->pWInfo, sizeof(pWC->a[0])*pWC->nSlot*2 ); + if( pWC->a==0 ){ + if( wtFlags & TERM_DYNAMIC ){ + sqlite3ExprDelete(db, p); + } + pWC->a = pOld; + return 0; + } + memcpy(pWC->a, pOld, sizeof(pWC->a[0])*pWC->nTerm); + pWC->nSlot = pWC->nSlot*2; + } + pTerm = &pWC->a[idx = pWC->nTerm++]; + if( (wtFlags & TERM_VIRTUAL)==0 ) pWC->nBase = pWC->nTerm; + if( p && ExprHasProperty(p, EP_Unlikely) ){ + pTerm->truthProb = sqlite3LogEst(p->iTable) - 270; + }else{ + pTerm->truthProb = 1; + } + pTerm->pExpr = sqlite3ExprSkipCollateAndLikely(p); + pTerm->wtFlags = wtFlags; + pTerm->pWC = pWC; + pTerm->iParent = -1; + memset(&pTerm->eOperator, 0, + sizeof(WhereTerm) - offsetof(WhereTerm,eOperator)); + return idx; +} + +/* +** Return TRUE if the given operator is one of the operators that is +** allowed for an indexable WHERE clause term. The allowed operators are +** "=", "<", ">", "<=", ">=", "IN", "IS", and "IS NULL" +*/ +static int allowedOp(int op){ + assert( TK_GT>TK_EQ && TK_GTTK_EQ && TK_LTTK_EQ && TK_LE=TK_EQ && op<=TK_GE) || op==TK_ISNULL || op==TK_IS; +} + +/* +** Commute a comparison operator. Expressions of the form "X op Y" +** are converted into "Y op X". +*/ +static u16 exprCommute(Parse *pParse, Expr *pExpr){ + if( pExpr->pLeft->op==TK_VECTOR + || pExpr->pRight->op==TK_VECTOR + || sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft, pExpr->pRight) != + sqlite3BinaryCompareCollSeq(pParse, pExpr->pRight, pExpr->pLeft) + ){ + pExpr->flags ^= EP_Commuted; + } + SWAP(Expr*,pExpr->pRight,pExpr->pLeft); + if( pExpr->op>=TK_GT ){ + assert( TK_LT==TK_GT+2 ); + assert( TK_GE==TK_LE+2 ); + assert( TK_GT>TK_EQ ); + assert( TK_GTop>=TK_GT && pExpr->op<=TK_GE ); + pExpr->op = ((pExpr->op-TK_GT)^2)+TK_GT; + } + return 0; +} + +/* +** Translate from TK_xx operator to WO_xx bitmask. +*/ +static u16 operatorMask(int op){ + u16 c; + assert( allowedOp(op) ); + if( op==TK_IN ){ + c = WO_IN; + }else if( op==TK_ISNULL ){ + c = WO_ISNULL; + }else if( op==TK_IS ){ + c = WO_IS; + }else{ + assert( (WO_EQ<<(op-TK_EQ)) < 0x7fff ); + c = (u16)(WO_EQ<<(op-TK_EQ)); + } + assert( op!=TK_ISNULL || c==WO_ISNULL ); + assert( op!=TK_IN || c==WO_IN ); + assert( op!=TK_EQ || c==WO_EQ ); + assert( op!=TK_LT || c==WO_LT ); + assert( op!=TK_LE || c==WO_LE ); + assert( op!=TK_GT || c==WO_GT ); + assert( op!=TK_GE || c==WO_GE ); + assert( op!=TK_IS || c==WO_IS ); + return c; +} + + +#ifndef SQLITE_OMIT_LIKE_OPTIMIZATION +/* +** Check to see if the given expression is a LIKE or GLOB operator that +** can be optimized using inequality constraints. Return TRUE if it is +** so and false if not. +** +** In order for the operator to be optimizible, the RHS must be a string +** literal that does not begin with a wildcard. The LHS must be a column +** that may only be NULL, a string, or a BLOB, never a number. (This means +** that virtual tables cannot participate in the LIKE optimization.) The +** collating sequence for the column on the LHS must be appropriate for +** the operator. +*/ +static int isLikeOrGlob( + Parse *pParse, /* Parsing and code generating context */ + Expr *pExpr, /* Test this expression */ + Expr **ppPrefix, /* Pointer to TK_STRING expression with pattern prefix */ + int *pisComplete, /* True if the only wildcard is % in the last character */ + int *pnoCase /* True if uppercase is equivalent to lowercase */ +){ + const u8 *z = 0; /* String on RHS of LIKE operator */ + Expr *pRight, *pLeft; /* Right and left size of LIKE operator */ + ExprList *pList; /* List of operands to the LIKE operator */ + u8 c; /* One character in z[] */ + int cnt; /* Number of non-wildcard prefix characters */ + u8 wc[4]; /* Wildcard characters */ + sqlite3 *db = pParse->db; /* Database connection */ + sqlite3_value *pVal = 0; + int op; /* Opcode of pRight */ + int rc; /* Result code to return */ + + if( !sqlite3IsLikeFunction(db, pExpr, pnoCase, (char*)wc) ){ + return 0; + } +#ifdef SQLITE_EBCDIC + if( *pnoCase ) return 0; +#endif + assert( ExprUseXList(pExpr) ); + pList = pExpr->x.pList; + pLeft = pList->a[1].pExpr; + + pRight = sqlite3ExprSkipCollate(pList->a[0].pExpr); + op = pRight->op; + if( op==TK_VARIABLE && (db->flags & SQLITE_EnableQPSG)==0 ){ + Vdbe *pReprepare = pParse->pReprepare; + int iCol = pRight->iColumn; + pVal = sqlite3VdbeGetBoundValue(pReprepare, iCol, SQLITE_AFF_BLOB); + if( pVal && sqlite3_value_type(pVal)==SQLITE_TEXT ){ + z = sqlite3_value_text(pVal); + } + sqlite3VdbeSetVarmask(pParse->pVdbe, iCol); + assert( pRight->op==TK_VARIABLE || pRight->op==TK_REGISTER ); + }else if( op==TK_STRING ){ + assert( !ExprHasProperty(pRight, EP_IntValue) ); + z = (u8*)pRight->u.zToken; + } + if( z ){ + + /* Count the number of prefix characters prior to the first wildcard */ + cnt = 0; + while( (c=z[cnt])!=0 && c!=wc[0] && c!=wc[1] && c!=wc[2] ){ + cnt++; + if( c==wc[3] && z[cnt]!=0 ) cnt++; + } + + /* The optimization is possible only if (1) the pattern does not begin + ** with a wildcard and if (2) the non-wildcard prefix does not end with + ** an (illegal 0xff) character, or (3) the pattern does not consist of + ** a single escape character. The second condition is necessary so + ** that we can increment the prefix key to find an upper bound for the + ** range search. The third is because the caller assumes that the pattern + ** consists of at least one character after all escapes have been + ** removed. */ + if( cnt!=0 && 255!=(u8)z[cnt-1] && (cnt>1 || z[0]!=wc[3]) ){ + Expr *pPrefix; + + /* A "complete" match if the pattern ends with "*" or "%" */ + *pisComplete = c==wc[0] && z[cnt+1]==0; + + /* Get the pattern prefix. Remove all escapes from the prefix. */ + pPrefix = sqlite3Expr(db, TK_STRING, (char*)z); + if( pPrefix ){ + int iFrom, iTo; + char *zNew; + assert( !ExprHasProperty(pPrefix, EP_IntValue) ); + zNew = pPrefix->u.zToken; + zNew[cnt] = 0; + for(iFrom=iTo=0; iFrom0 ); + + /* If the LHS is not an ordinary column with TEXT affinity, then the + ** pattern prefix boundaries (both the start and end boundaries) must + ** not look like a number. Otherwise the pattern might be treated as + ** a number, which will invalidate the LIKE optimization. + ** + ** Getting this right has been a persistent source of bugs in the + ** LIKE optimization. See, for example: + ** 2018-09-10 https://sqlite.org/src/info/c94369cae9b561b1 + ** 2019-05-02 https://sqlite.org/src/info/b043a54c3de54b28 + ** 2019-06-10 https://sqlite.org/src/info/fd76310a5e843e07 + ** 2019-06-14 https://sqlite.org/src/info/ce8717f0885af975 + ** 2019-09-03 https://sqlite.org/src/info/0f0428096f17252a + */ + if( pLeft->op!=TK_COLUMN + || sqlite3ExprAffinity(pLeft)!=SQLITE_AFF_TEXT + || (ALWAYS( ExprUseYTab(pLeft) ) + && ALWAYS(pLeft->y.pTab) + && IsVirtual(pLeft->y.pTab)) /* Might be numeric */ + ){ + int isNum; + double rDummy; + isNum = sqlite3AtoF(zNew, &rDummy, iTo, SQLITE_UTF8); + if( isNum<=0 ){ + if( iTo==1 && zNew[0]=='-' ){ + isNum = +1; + }else{ + zNew[iTo-1]++; + isNum = sqlite3AtoF(zNew, &rDummy, iTo, SQLITE_UTF8); + zNew[iTo-1]--; + } + } + if( isNum>0 ){ + sqlite3ExprDelete(db, pPrefix); + sqlite3ValueFree(pVal); + return 0; + } + } + } + *ppPrefix = pPrefix; + + /* If the RHS pattern is a bound parameter, make arrangements to + ** reprepare the statement when that parameter is rebound */ + if( op==TK_VARIABLE ){ + Vdbe *v = pParse->pVdbe; + sqlite3VdbeSetVarmask(v, pRight->iColumn); + assert( !ExprHasProperty(pRight, EP_IntValue) ); + if( *pisComplete && pRight->u.zToken[1] ){ + /* If the rhs of the LIKE expression is a variable, and the current + ** value of the variable means there is no need to invoke the LIKE + ** function, then no OP_Variable will be added to the program. + ** This causes problems for the sqlite3_bind_parameter_name() + ** API. To work around them, add a dummy OP_Variable here. + */ + int r1 = sqlite3GetTempReg(pParse); + sqlite3ExprCodeTarget(pParse, pRight, r1); + sqlite3VdbeChangeP3(v, sqlite3VdbeCurrentAddr(v)-1, 0); + sqlite3ReleaseTempReg(pParse, r1); + } + } + }else{ + z = 0; + } + } + + rc = (z!=0); + sqlite3ValueFree(pVal); + return rc; +} +#endif /* SQLITE_OMIT_LIKE_OPTIMIZATION */ + + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* +** Check to see if the pExpr expression is a form that needs to be passed +** to the xBestIndex method of virtual tables. Forms of interest include: +** +** Expression Virtual Table Operator +** ----------------------- --------------------------------- +** 1. column MATCH expr SQLITE_INDEX_CONSTRAINT_MATCH +** 2. column GLOB expr SQLITE_INDEX_CONSTRAINT_GLOB +** 3. column LIKE expr SQLITE_INDEX_CONSTRAINT_LIKE +** 4. column REGEXP expr SQLITE_INDEX_CONSTRAINT_REGEXP +** 5. column != expr SQLITE_INDEX_CONSTRAINT_NE +** 6. expr != column SQLITE_INDEX_CONSTRAINT_NE +** 7. column IS NOT expr SQLITE_INDEX_CONSTRAINT_ISNOT +** 8. expr IS NOT column SQLITE_INDEX_CONSTRAINT_ISNOT +** 9. column IS NOT NULL SQLITE_INDEX_CONSTRAINT_ISNOTNULL +** +** In every case, "column" must be a column of a virtual table. If there +** is a match, set *ppLeft to the "column" expression, set *ppRight to the +** "expr" expression (even though in forms (6) and (8) the column is on the +** right and the expression is on the left). Also set *peOp2 to the +** appropriate virtual table operator. The return value is 1 or 2 if there +** is a match. The usual return is 1, but if the RHS is also a column +** of virtual table in forms (5) or (7) then return 2. +** +** If the expression matches none of the patterns above, return 0. +*/ +static int isAuxiliaryVtabOperator( + sqlite3 *db, /* Parsing context */ + Expr *pExpr, /* Test this expression */ + unsigned char *peOp2, /* OUT: 0 for MATCH, or else an op2 value */ + Expr **ppLeft, /* Column expression to left of MATCH/op2 */ + Expr **ppRight /* Expression to left of MATCH/op2 */ +){ + if( pExpr->op==TK_FUNCTION ){ + static const struct Op2 { + const char *zOp; + unsigned char eOp2; + } aOp[] = { + { "match", SQLITE_INDEX_CONSTRAINT_MATCH }, + { "glob", SQLITE_INDEX_CONSTRAINT_GLOB }, + { "like", SQLITE_INDEX_CONSTRAINT_LIKE }, + { "regexp", SQLITE_INDEX_CONSTRAINT_REGEXP } + }; + ExprList *pList; + Expr *pCol; /* Column reference */ + int i; + + assert( ExprUseXList(pExpr) ); + pList = pExpr->x.pList; + if( pList==0 || pList->nExpr!=2 ){ + return 0; + } + + /* Built-in operators MATCH, GLOB, LIKE, and REGEXP attach to a + ** virtual table on their second argument, which is the same as + ** the left-hand side operand in their in-fix form. + ** + ** vtab_column MATCH expression + ** MATCH(expression,vtab_column) + */ + pCol = pList->a[1].pExpr; + assert( pCol->op!=TK_COLUMN || (ExprUseYTab(pCol) && pCol->y.pTab!=0) ); + if( ExprIsVtab(pCol) ){ + for(i=0; iu.zToken, aOp[i].zOp)==0 ){ + *peOp2 = aOp[i].eOp2; + *ppRight = pList->a[0].pExpr; + *ppLeft = pCol; + return 1; + } + } + } + + /* We can also match against the first column of overloaded + ** functions where xFindFunction returns a value of at least + ** SQLITE_INDEX_CONSTRAINT_FUNCTION. + ** + ** OVERLOADED(vtab_column,expression) + ** + ** Historically, xFindFunction expected to see lower-case function + ** names. But for this use case, xFindFunction is expected to deal + ** with function names in an arbitrary case. + */ + pCol = pList->a[0].pExpr; + assert( pCol->op!=TK_COLUMN || ExprUseYTab(pCol) ); + assert( pCol->op!=TK_COLUMN || (ExprUseYTab(pCol) && pCol->y.pTab!=0) ); + if( ExprIsVtab(pCol) ){ + sqlite3_vtab *pVtab; + sqlite3_module *pMod; + void (*xNotUsed)(sqlite3_context*,int,sqlite3_value**); + void *pNotUsed; + pVtab = sqlite3GetVTable(db, pCol->y.pTab)->pVtab; + assert( pVtab!=0 ); + assert( pVtab->pModule!=0 ); + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + pMod = (sqlite3_module *)pVtab->pModule; + if( pMod->xFindFunction!=0 ){ + i = pMod->xFindFunction(pVtab,2, pExpr->u.zToken, &xNotUsed, &pNotUsed); + if( i>=SQLITE_INDEX_CONSTRAINT_FUNCTION ){ + *peOp2 = i; + *ppRight = pList->a[1].pExpr; + *ppLeft = pCol; + return 1; + } + } + } + }else if( pExpr->op==TK_NE || pExpr->op==TK_ISNOT || pExpr->op==TK_NOTNULL ){ + int res = 0; + Expr *pLeft = pExpr->pLeft; + Expr *pRight = pExpr->pRight; + assert( pLeft->op!=TK_COLUMN || (ExprUseYTab(pLeft) && pLeft->y.pTab!=0) ); + if( ExprIsVtab(pLeft) ){ + res++; + } + assert( pRight==0 || pRight->op!=TK_COLUMN + || (ExprUseYTab(pRight) && pRight->y.pTab!=0) ); + if( pRight && ExprIsVtab(pRight) ){ + res++; + SWAP(Expr*, pLeft, pRight); + } + *ppLeft = pLeft; + *ppRight = pRight; + if( pExpr->op==TK_NE ) *peOp2 = SQLITE_INDEX_CONSTRAINT_NE; + if( pExpr->op==TK_ISNOT ) *peOp2 = SQLITE_INDEX_CONSTRAINT_ISNOT; + if( pExpr->op==TK_NOTNULL ) *peOp2 = SQLITE_INDEX_CONSTRAINT_ISNOTNULL; + return res; + } + return 0; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +/* +** If the pBase expression originated in the ON or USING clause of +** a join, then transfer the appropriate markings over to derived. +*/ +static void transferJoinMarkings(Expr *pDerived, Expr *pBase){ + if( pDerived && ExprHasProperty(pBase, EP_OuterON|EP_InnerON) ){ + pDerived->flags |= pBase->flags & (EP_OuterON|EP_InnerON); + pDerived->w.iJoin = pBase->w.iJoin; + } +} + +/* +** Mark term iChild as being a child of term iParent +*/ +static void markTermAsChild(WhereClause *pWC, int iChild, int iParent){ + pWC->a[iChild].iParent = iParent; + pWC->a[iChild].truthProb = pWC->a[iParent].truthProb; + pWC->a[iParent].nChild++; +} + +/* +** Return the N-th AND-connected subterm of pTerm. Or if pTerm is not +** a conjunction, then return just pTerm when N==0. If N is exceeds +** the number of available subterms, return NULL. +*/ +static WhereTerm *whereNthSubterm(WhereTerm *pTerm, int N){ + if( pTerm->eOperator!=WO_AND ){ + return N==0 ? pTerm : 0; + } + if( Nu.pAndInfo->wc.nTerm ){ + return &pTerm->u.pAndInfo->wc.a[N]; + } + return 0; +} + +/* +** Subterms pOne and pTwo are contained within WHERE clause pWC. The +** two subterms are in disjunction - they are OR-ed together. +** +** If these two terms are both of the form: "A op B" with the same +** A and B values but different operators and if the operators are +** compatible (if one is = and the other is <, for example) then +** add a new virtual AND term to pWC that is the combination of the +** two. +** +** Some examples: +** +** x x<=y +** x=y OR x=y --> x=y +** x<=y OR x x<=y +** +** The following is NOT generated: +** +** xy --> x!=y +*/ +static void whereCombineDisjuncts( + SrcList *pSrc, /* the FROM clause */ + WhereClause *pWC, /* The complete WHERE clause */ + WhereTerm *pOne, /* First disjunct */ + WhereTerm *pTwo /* Second disjunct */ +){ + u16 eOp = pOne->eOperator | pTwo->eOperator; + sqlite3 *db; /* Database connection (for malloc) */ + Expr *pNew; /* New virtual expression */ + int op; /* Operator for the combined expression */ + int idxNew; /* Index in pWC of the next virtual term */ + + if( (pOne->wtFlags | pTwo->wtFlags) & TERM_VNULL ) return; + if( (pOne->eOperator & (WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE))==0 ) return; + if( (pTwo->eOperator & (WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE))==0 ) return; + if( (eOp & (WO_EQ|WO_LT|WO_LE))!=eOp + && (eOp & (WO_EQ|WO_GT|WO_GE))!=eOp ) return; + assert( pOne->pExpr->pLeft!=0 && pOne->pExpr->pRight!=0 ); + assert( pTwo->pExpr->pLeft!=0 && pTwo->pExpr->pRight!=0 ); + if( sqlite3ExprCompare(0,pOne->pExpr->pLeft, pTwo->pExpr->pLeft, -1) ) return; + if( sqlite3ExprCompare(0,pOne->pExpr->pRight, pTwo->pExpr->pRight,-1) )return; + /* If we reach this point, it means the two subterms can be combined */ + if( (eOp & (eOp-1))!=0 ){ + if( eOp & (WO_LT|WO_LE) ){ + eOp = WO_LE; + }else{ + assert( eOp & (WO_GT|WO_GE) ); + eOp = WO_GE; + } + } + db = pWC->pWInfo->pParse->db; + pNew = sqlite3ExprDup(db, pOne->pExpr, 0); + if( pNew==0 ) return; + for(op=TK_EQ; eOp!=(WO_EQ<<(op-TK_EQ)); op++){ assert( opop = op; + idxNew = whereClauseInsert(pWC, pNew, TERM_VIRTUAL|TERM_DYNAMIC); + exprAnalyze(pSrc, pWC, idxNew); +} + +#if !defined(SQLITE_OMIT_OR_OPTIMIZATION) && !defined(SQLITE_OMIT_SUBQUERY) +/* +** Analyze a term that consists of two or more OR-connected +** subterms. So in: +** +** ... WHERE (a=5) AND (b=7 OR c=9 OR d=13) AND (d=13) +** ^^^^^^^^^^^^^^^^^^^^ +** +** This routine analyzes terms such as the middle term in the above example. +** A WhereOrTerm object is computed and attached to the term under +** analysis, regardless of the outcome of the analysis. Hence: +** +** WhereTerm.wtFlags |= TERM_ORINFO +** WhereTerm.u.pOrInfo = a dynamically allocated WhereOrTerm object +** +** The term being analyzed must have two or more of OR-connected subterms. +** A single subterm might be a set of AND-connected sub-subterms. +** Examples of terms under analysis: +** +** (A) t1.x=t2.y OR t1.x=t2.z OR t1.y=15 OR t1.z=t3.a+5 +** (B) x=expr1 OR expr2=x OR x=expr3 +** (C) t1.x=t2.y OR (t1.x=t2.z AND t1.y=15) +** (D) x=expr1 OR (y>11 AND y<22 AND z LIKE '*hello*') +** (E) (p.a=1 AND q.b=2 AND r.c=3) OR (p.x=4 AND q.y=5 AND r.z=6) +** (F) x>A OR (x=A AND y>=B) +** +** CASE 1: +** +** If all subterms are of the form T.C=expr for some single column of C and +** a single table T (as shown in example B above) then create a new virtual +** term that is an equivalent IN expression. In other words, if the term +** being analyzed is: +** +** x = expr1 OR expr2 = x OR x = expr3 +** +** then create a new virtual term like this: +** +** x IN (expr1,expr2,expr3) +** +** CASE 2: +** +** If there are exactly two disjuncts and one side has x>A and the other side +** has x=A (for the same x and A) then add a new virtual conjunct term to the +** WHERE clause of the form "x>=A". Example: +** +** x>A OR (x=A AND y>B) adds: x>=A +** +** The added conjunct can sometimes be helpful in query planning. +** +** CASE 3: +** +** If all subterms are indexable by a single table T, then set +** +** WhereTerm.eOperator = WO_OR +** WhereTerm.u.pOrInfo->indexable |= the cursor number for table T +** +** A subterm is "indexable" if it is of the form +** "T.C " where C is any column of table T and +** is one of "=", "<", "<=", ">", ">=", "IS NULL", or "IN". +** A subterm is also indexable if it is an AND of two or more +** subsubterms at least one of which is indexable. Indexable AND +** subterms have their eOperator set to WO_AND and they have +** u.pAndInfo set to a dynamically allocated WhereAndTerm object. +** +** From another point of view, "indexable" means that the subterm could +** potentially be used with an index if an appropriate index exists. +** This analysis does not consider whether or not the index exists; that +** is decided elsewhere. This analysis only looks at whether subterms +** appropriate for indexing exist. +** +** All examples A through E above satisfy case 3. But if a term +** also satisfies case 1 (such as B) we know that the optimizer will +** always prefer case 1, so in that case we pretend that case 3 is not +** satisfied. +** +** It might be the case that multiple tables are indexable. For example, +** (E) above is indexable on tables P, Q, and R. +** +** Terms that satisfy case 3 are candidates for lookup by using +** separate indices to find rowids for each subterm and composing +** the union of all rowids using a RowSet object. This is similar +** to "bitmap indices" in other database engines. +** +** OTHERWISE: +** +** If none of cases 1, 2, or 3 apply, then leave the eOperator set to +** zero. This term is not useful for search. +*/ +static void exprAnalyzeOrTerm( + SrcList *pSrc, /* the FROM clause */ + WhereClause *pWC, /* the complete WHERE clause */ + int idxTerm /* Index of the OR-term to be analyzed */ +){ + WhereInfo *pWInfo = pWC->pWInfo; /* WHERE clause processing context */ + Parse *pParse = pWInfo->pParse; /* Parser context */ + sqlite3 *db = pParse->db; /* Database connection */ + WhereTerm *pTerm = &pWC->a[idxTerm]; /* The term to be analyzed */ + Expr *pExpr = pTerm->pExpr; /* The expression of the term */ + int i; /* Loop counters */ + WhereClause *pOrWc; /* Breakup of pTerm into subterms */ + WhereTerm *pOrTerm; /* A Sub-term within the pOrWc */ + WhereOrInfo *pOrInfo; /* Additional information associated with pTerm */ + Bitmask chngToIN; /* Tables that might satisfy case 1 */ + Bitmask indexable; /* Tables that are indexable, satisfying case 2 */ + + /* + ** Break the OR clause into its separate subterms. The subterms are + ** stored in a WhereClause structure containing within the WhereOrInfo + ** object that is attached to the original OR clause term. + */ + assert( (pTerm->wtFlags & (TERM_DYNAMIC|TERM_ORINFO|TERM_ANDINFO))==0 ); + assert( pExpr->op==TK_OR ); + pTerm->u.pOrInfo = pOrInfo = sqlite3DbMallocZero(db, sizeof(*pOrInfo)); + if( pOrInfo==0 ) return; + pTerm->wtFlags |= TERM_ORINFO; + pOrWc = &pOrInfo->wc; + memset(pOrWc->aStatic, 0, sizeof(pOrWc->aStatic)); + sqlite3WhereClauseInit(pOrWc, pWInfo); + sqlite3WhereSplit(pOrWc, pExpr, TK_OR); + sqlite3WhereExprAnalyze(pSrc, pOrWc); + if( db->mallocFailed ) return; + assert( pOrWc->nTerm>=2 ); + + /* + ** Compute the set of tables that might satisfy cases 1 or 3. + */ + indexable = ~(Bitmask)0; + chngToIN = ~(Bitmask)0; + for(i=pOrWc->nTerm-1, pOrTerm=pOrWc->a; i>=0 && indexable; i--, pOrTerm++){ + if( (pOrTerm->eOperator & WO_SINGLE)==0 ){ + WhereAndInfo *pAndInfo; + assert( (pOrTerm->wtFlags & (TERM_ANDINFO|TERM_ORINFO))==0 ); + chngToIN = 0; + pAndInfo = sqlite3DbMallocRawNN(db, sizeof(*pAndInfo)); + if( pAndInfo ){ + WhereClause *pAndWC; + WhereTerm *pAndTerm; + int j; + Bitmask b = 0; + pOrTerm->u.pAndInfo = pAndInfo; + pOrTerm->wtFlags |= TERM_ANDINFO; + pOrTerm->eOperator = WO_AND; + pOrTerm->leftCursor = -1; + pAndWC = &pAndInfo->wc; + memset(pAndWC->aStatic, 0, sizeof(pAndWC->aStatic)); + sqlite3WhereClauseInit(pAndWC, pWC->pWInfo); + sqlite3WhereSplit(pAndWC, pOrTerm->pExpr, TK_AND); + sqlite3WhereExprAnalyze(pSrc, pAndWC); + pAndWC->pOuter = pWC; + if( !db->mallocFailed ){ + for(j=0, pAndTerm=pAndWC->a; jnTerm; j++, pAndTerm++){ + assert( pAndTerm->pExpr ); + if( allowedOp(pAndTerm->pExpr->op) + || pAndTerm->eOperator==WO_AUX + ){ + b |= sqlite3WhereGetMask(&pWInfo->sMaskSet, pAndTerm->leftCursor); + } + } + } + indexable &= b; + } + }else if( pOrTerm->wtFlags & TERM_COPIED ){ + /* Skip this term for now. We revisit it when we process the + ** corresponding TERM_VIRTUAL term */ + }else{ + Bitmask b; + b = sqlite3WhereGetMask(&pWInfo->sMaskSet, pOrTerm->leftCursor); + if( pOrTerm->wtFlags & TERM_VIRTUAL ){ + WhereTerm *pOther = &pOrWc->a[pOrTerm->iParent]; + b |= sqlite3WhereGetMask(&pWInfo->sMaskSet, pOther->leftCursor); + } + indexable &= b; + if( (pOrTerm->eOperator & WO_EQ)==0 ){ + chngToIN = 0; + }else{ + chngToIN &= b; + } + } + } + + /* + ** Record the set of tables that satisfy case 3. The set might be + ** empty. + */ + pOrInfo->indexable = indexable; + pTerm->eOperator = WO_OR; + pTerm->leftCursor = -1; + if( indexable ){ + pWC->hasOr = 1; + } + + /* For a two-way OR, attempt to implementation case 2. + */ + if( indexable && pOrWc->nTerm==2 ){ + int iOne = 0; + WhereTerm *pOne; + while( (pOne = whereNthSubterm(&pOrWc->a[0],iOne++))!=0 ){ + int iTwo = 0; + WhereTerm *pTwo; + while( (pTwo = whereNthSubterm(&pOrWc->a[1],iTwo++))!=0 ){ + whereCombineDisjuncts(pSrc, pWC, pOne, pTwo); + } + } + } + + /* + ** chngToIN holds a set of tables that *might* satisfy case 1. But + ** we have to do some additional checking to see if case 1 really + ** is satisfied. + ** + ** chngToIN will hold either 0, 1, or 2 bits. The 0-bit case means + ** that there is no possibility of transforming the OR clause into an + ** IN operator because one or more terms in the OR clause contain + ** something other than == on a column in the single table. The 1-bit + ** case means that every term of the OR clause is of the form + ** "table.column=expr" for some single table. The one bit that is set + ** will correspond to the common table. We still need to check to make + ** sure the same column is used on all terms. The 2-bit case is when + ** the all terms are of the form "table1.column=table2.column". It + ** might be possible to form an IN operator with either table1.column + ** or table2.column as the LHS if either is common to every term of + ** the OR clause. + ** + ** Note that terms of the form "table.column1=table.column2" (the + ** same table on both sizes of the ==) cannot be optimized. + */ + if( chngToIN ){ + int okToChngToIN = 0; /* True if the conversion to IN is valid */ + int iColumn = -1; /* Column index on lhs of IN operator */ + int iCursor = -1; /* Table cursor common to all terms */ + int j = 0; /* Loop counter */ + + /* Search for a table and column that appears on one side or the + ** other of the == operator in every subterm. That table and column + ** will be recorded in iCursor and iColumn. There might not be any + ** such table and column. Set okToChngToIN if an appropriate table + ** and column is found but leave okToChngToIN false if not found. + */ + for(j=0; j<2 && !okToChngToIN; j++){ + Expr *pLeft = 0; + pOrTerm = pOrWc->a; + for(i=pOrWc->nTerm-1; i>=0; i--, pOrTerm++){ + assert( pOrTerm->eOperator & WO_EQ ); + pOrTerm->wtFlags &= ~TERM_OK; + if( pOrTerm->leftCursor==iCursor ){ + /* This is the 2-bit case and we are on the second iteration and + ** current term is from the first iteration. So skip this term. */ + assert( j==1 ); + continue; + } + if( (chngToIN & sqlite3WhereGetMask(&pWInfo->sMaskSet, + pOrTerm->leftCursor))==0 ){ + /* This term must be of the form t1.a==t2.b where t2 is in the + ** chngToIN set but t1 is not. This term will be either preceded + ** or follwed by an inverted copy (t2.b==t1.a). Skip this term + ** and use its inversion. */ + testcase( pOrTerm->wtFlags & TERM_COPIED ); + testcase( pOrTerm->wtFlags & TERM_VIRTUAL ); + assert( pOrTerm->wtFlags & (TERM_COPIED|TERM_VIRTUAL) ); + continue; + } + assert( (pOrTerm->eOperator & (WO_OR|WO_AND))==0 ); + iColumn = pOrTerm->u.x.leftColumn; + iCursor = pOrTerm->leftCursor; + pLeft = pOrTerm->pExpr->pLeft; + break; + } + if( i<0 ){ + /* No candidate table+column was found. This can only occur + ** on the second iteration */ + assert( j==1 ); + assert( IsPowerOfTwo(chngToIN) ); + assert( chngToIN==sqlite3WhereGetMask(&pWInfo->sMaskSet, iCursor) ); + break; + } + testcase( j==1 ); + + /* We have found a candidate table and column. Check to see if that + ** table and column is common to every term in the OR clause */ + okToChngToIN = 1; + for(; i>=0 && okToChngToIN; i--, pOrTerm++){ + assert( pOrTerm->eOperator & WO_EQ ); + assert( (pOrTerm->eOperator & (WO_OR|WO_AND))==0 ); + if( pOrTerm->leftCursor!=iCursor ){ + pOrTerm->wtFlags &= ~TERM_OK; + }else if( pOrTerm->u.x.leftColumn!=iColumn || (iColumn==XN_EXPR + && sqlite3ExprCompare(pParse, pOrTerm->pExpr->pLeft, pLeft, -1) + )){ + okToChngToIN = 0; + }else{ + int affLeft, affRight; + /* If the right-hand side is also a column, then the affinities + ** of both right and left sides must be such that no type + ** conversions are required on the right. (Ticket #2249) + */ + affRight = sqlite3ExprAffinity(pOrTerm->pExpr->pRight); + affLeft = sqlite3ExprAffinity(pOrTerm->pExpr->pLeft); + if( affRight!=0 && affRight!=affLeft ){ + okToChngToIN = 0; + }else{ + pOrTerm->wtFlags |= TERM_OK; + } + } + } + } + + /* At this point, okToChngToIN is true if original pTerm satisfies + ** case 1. In that case, construct a new virtual term that is + ** pTerm converted into an IN operator. + */ + if( okToChngToIN ){ + Expr *pDup; /* A transient duplicate expression */ + ExprList *pList = 0; /* The RHS of the IN operator */ + Expr *pLeft = 0; /* The LHS of the IN operator */ + Expr *pNew; /* The complete IN operator */ + + for(i=pOrWc->nTerm-1, pOrTerm=pOrWc->a; i>=0; i--, pOrTerm++){ + if( (pOrTerm->wtFlags & TERM_OK)==0 ) continue; + assert( pOrTerm->eOperator & WO_EQ ); + assert( (pOrTerm->eOperator & (WO_OR|WO_AND))==0 ); + assert( pOrTerm->leftCursor==iCursor ); + assert( pOrTerm->u.x.leftColumn==iColumn ); + pDup = sqlite3ExprDup(db, pOrTerm->pExpr->pRight, 0); + pList = sqlite3ExprListAppend(pWInfo->pParse, pList, pDup); + pLeft = pOrTerm->pExpr->pLeft; + } + assert( pLeft!=0 ); + pDup = sqlite3ExprDup(db, pLeft, 0); + pNew = sqlite3PExpr(pParse, TK_IN, pDup, 0); + if( pNew ){ + int idxNew; + transferJoinMarkings(pNew, pExpr); + assert( ExprUseXList(pNew) ); + pNew->x.pList = pList; + idxNew = whereClauseInsert(pWC, pNew, TERM_VIRTUAL|TERM_DYNAMIC); + testcase( idxNew==0 ); + exprAnalyze(pSrc, pWC, idxNew); + /* pTerm = &pWC->a[idxTerm]; // would be needed if pTerm where reused */ + markTermAsChild(pWC, idxNew, idxTerm); + }else{ + sqlite3ExprListDelete(db, pList); + } + } + } +} +#endif /* !SQLITE_OMIT_OR_OPTIMIZATION && !SQLITE_OMIT_SUBQUERY */ + +/* +** We already know that pExpr is a binary operator where both operands are +** column references. This routine checks to see if pExpr is an equivalence +** relation: +** 1. The SQLITE_Transitive optimization must be enabled +** 2. Must be either an == or an IS operator +** 3. Not originating in the ON clause of an OUTER JOIN +** 4. The affinities of A and B must be compatible +** 5a. Both operands use the same collating sequence OR +** 5b. The overall collating sequence is BINARY +** If this routine returns TRUE, that means that the RHS can be substituted +** for the LHS anyplace else in the WHERE clause where the LHS column occurs. +** This is an optimization. No harm comes from returning 0. But if 1 is +** returned when it should not be, then incorrect answers might result. +*/ +static int termIsEquivalence(Parse *pParse, Expr *pExpr){ + char aff1, aff2; + CollSeq *pColl; + if( !OptimizationEnabled(pParse->db, SQLITE_Transitive) ) return 0; + if( pExpr->op!=TK_EQ && pExpr->op!=TK_IS ) return 0; + if( ExprHasProperty(pExpr, EP_OuterON) ) return 0; + aff1 = sqlite3ExprAffinity(pExpr->pLeft); + aff2 = sqlite3ExprAffinity(pExpr->pRight); + if( aff1!=aff2 + && (!sqlite3IsNumericAffinity(aff1) || !sqlite3IsNumericAffinity(aff2)) + ){ + return 0; + } + pColl = sqlite3ExprCompareCollSeq(pParse, pExpr); + if( sqlite3IsBinary(pColl) ) return 1; + return sqlite3ExprCollSeqMatch(pParse, pExpr->pLeft, pExpr->pRight); +} + +/* +** Recursively walk the expressions of a SELECT statement and generate +** a bitmask indicating which tables are used in that expression +** tree. +*/ +static Bitmask exprSelectUsage(WhereMaskSet *pMaskSet, Select *pS){ + Bitmask mask = 0; + while( pS ){ + SrcList *pSrc = pS->pSrc; + mask |= sqlite3WhereExprListUsage(pMaskSet, pS->pEList); + mask |= sqlite3WhereExprListUsage(pMaskSet, pS->pGroupBy); + mask |= sqlite3WhereExprListUsage(pMaskSet, pS->pOrderBy); + mask |= sqlite3WhereExprUsage(pMaskSet, pS->pWhere); + mask |= sqlite3WhereExprUsage(pMaskSet, pS->pHaving); + if( ALWAYS(pSrc!=0) ){ + int i; + for(i=0; inSrc; i++){ + mask |= exprSelectUsage(pMaskSet, pSrc->a[i].pSelect); + if( pSrc->a[i].fg.isUsing==0 ){ + mask |= sqlite3WhereExprUsage(pMaskSet, pSrc->a[i].u3.pOn); + } + if( pSrc->a[i].fg.isTabFunc ){ + mask |= sqlite3WhereExprListUsage(pMaskSet, pSrc->a[i].u1.pFuncArg); + } + } + } + pS = pS->pPrior; + } + return mask; +} + +/* +** Expression pExpr is one operand of a comparison operator that might +** be useful for indexing. This routine checks to see if pExpr appears +** in any index. Return TRUE (1) if pExpr is an indexed term and return +** FALSE (0) if not. If TRUE is returned, also set aiCurCol[0] to the cursor +** number of the table that is indexed and aiCurCol[1] to the column number +** of the column that is indexed, or XN_EXPR (-2) if an expression is being +** indexed. +** +** If pExpr is a TK_COLUMN column reference, then this routine always returns +** true even if that particular column is not indexed, because the column +** might be added to an automatic index later. +*/ +static SQLITE_NOINLINE int exprMightBeIndexed2( + SrcList *pFrom, /* The FROM clause */ + int *aiCurCol, /* Write the referenced table cursor and column here */ + Expr *pExpr, /* An operand of a comparison operator */ + int j /* Start looking with the j-th pFrom entry */ +){ + Index *pIdx; + int i; + int iCur; + do{ + iCur = pFrom->a[j].iCursor; + for(pIdx=pFrom->a[j].pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + if( pIdx->aColExpr==0 ) continue; + for(i=0; inKeyCol; i++){ + if( pIdx->aiColumn[i]!=XN_EXPR ) continue; + assert( pIdx->bHasExpr ); + if( sqlite3ExprCompareSkip(pExpr,pIdx->aColExpr->a[i].pExpr,iCur)==0 + && pExpr->op!=TK_STRING + ){ + aiCurCol[0] = iCur; + aiCurCol[1] = XN_EXPR; + return 1; + } + } + } + }while( ++j < pFrom->nSrc ); + return 0; +} +static int exprMightBeIndexed( + SrcList *pFrom, /* The FROM clause */ + int *aiCurCol, /* Write the referenced table cursor & column here */ + Expr *pExpr, /* An operand of a comparison operator */ + int op /* The specific comparison operator */ +){ + int i; + + /* If this expression is a vector to the left or right of a + ** inequality constraint (>, <, >= or <=), perform the processing + ** on the first element of the vector. */ + assert( TK_GT+1==TK_LE && TK_GT+2==TK_LT && TK_GT+3==TK_GE ); + assert( TK_ISop==TK_VECTOR && (op>=TK_GT && ALWAYS(op<=TK_GE)) ){ + assert( ExprUseXList(pExpr) ); + pExpr = pExpr->x.pList->a[0].pExpr; + } + + if( pExpr->op==TK_COLUMN ){ + aiCurCol[0] = pExpr->iTable; + aiCurCol[1] = pExpr->iColumn; + return 1; + } + + for(i=0; inSrc; i++){ + Index *pIdx; + for(pIdx=pFrom->a[i].pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + if( pIdx->aColExpr ){ + return exprMightBeIndexed2(pFrom,aiCurCol,pExpr,i); + } + } + } + return 0; +} + + +/* +** The input to this routine is an WhereTerm structure with only the +** "pExpr" field filled in. The job of this routine is to analyze the +** subexpression and populate all the other fields of the WhereTerm +** structure. +** +** If the expression is of the form " X" it gets commuted +** to the standard form of "X ". +** +** If the expression is of the form "X Y" where both X and Y are +** columns, then the original expression is unchanged and a new virtual +** term of the form "Y X" is added to the WHERE clause and +** analyzed separately. The original term is marked with TERM_COPIED +** and the new term is marked with TERM_DYNAMIC (because it's pExpr +** needs to be freed with the WhereClause) and TERM_VIRTUAL (because it +** is a commuted copy of a prior term.) The original term has nChild=1 +** and the copy has idxParent set to the index of the original term. +*/ +static void exprAnalyze( + SrcList *pSrc, /* the FROM clause */ + WhereClause *pWC, /* the WHERE clause */ + int idxTerm /* Index of the term to be analyzed */ +){ + WhereInfo *pWInfo = pWC->pWInfo; /* WHERE clause processing context */ + WhereTerm *pTerm; /* The term to be analyzed */ + WhereMaskSet *pMaskSet; /* Set of table index masks */ + Expr *pExpr; /* The expression to be analyzed */ + Bitmask prereqLeft; /* Prerequesites of the pExpr->pLeft */ + Bitmask prereqAll; /* Prerequesites of pExpr */ + Bitmask extraRight = 0; /* Extra dependencies on LEFT JOIN */ + Expr *pStr1 = 0; /* RHS of LIKE/GLOB operator */ + int isComplete = 0; /* RHS of LIKE/GLOB ends with wildcard */ + int noCase = 0; /* uppercase equivalent to lowercase */ + int op; /* Top-level operator. pExpr->op */ + Parse *pParse = pWInfo->pParse; /* Parsing context */ + sqlite3 *db = pParse->db; /* Database connection */ + unsigned char eOp2 = 0; /* op2 value for LIKE/REGEXP/GLOB */ + int nLeft; /* Number of elements on left side vector */ + + if( db->mallocFailed ){ + return; + } + assert( pWC->nTerm > idxTerm ); + pTerm = &pWC->a[idxTerm]; + pMaskSet = &pWInfo->sMaskSet; + pExpr = pTerm->pExpr; + assert( pExpr!=0 ); /* Because malloc() has not failed */ + assert( pExpr->op!=TK_AS && pExpr->op!=TK_COLLATE ); + pMaskSet->bVarSelect = 0; + prereqLeft = sqlite3WhereExprUsage(pMaskSet, pExpr->pLeft); + op = pExpr->op; + if( op==TK_IN ){ + assert( pExpr->pRight==0 ); + if( sqlite3ExprCheckIN(pParse, pExpr) ) return; + if( ExprUseXSelect(pExpr) ){ + pTerm->prereqRight = exprSelectUsage(pMaskSet, pExpr->x.pSelect); + }else{ + pTerm->prereqRight = sqlite3WhereExprListUsage(pMaskSet, pExpr->x.pList); + } + prereqAll = prereqLeft | pTerm->prereqRight; + }else{ + pTerm->prereqRight = sqlite3WhereExprUsage(pMaskSet, pExpr->pRight); + if( pExpr->pLeft==0 + || ExprHasProperty(pExpr, EP_xIsSelect|EP_IfNullRow) + || pExpr->x.pList!=0 + ){ + prereqAll = sqlite3WhereExprUsageNN(pMaskSet, pExpr); + }else{ + prereqAll = prereqLeft | pTerm->prereqRight; + } + } + if( pMaskSet->bVarSelect ) pTerm->wtFlags |= TERM_VARSELECT; + +#ifdef SQLITE_DEBUG + if( prereqAll!=sqlite3WhereExprUsageNN(pMaskSet, pExpr) ){ + printf("\n*** Incorrect prereqAll computed for:\n"); + sqlite3TreeViewExpr(0,pExpr,0); + assert( 0 ); + } +#endif + + if( ExprHasProperty(pExpr, EP_OuterON|EP_InnerON) ){ + Bitmask x = sqlite3WhereGetMask(pMaskSet, pExpr->w.iJoin); + if( ExprHasProperty(pExpr, EP_OuterON) ){ + prereqAll |= x; + extraRight = x-1; /* ON clause terms may not be used with an index + ** on left table of a LEFT JOIN. Ticket #3015 */ + if( (prereqAll>>1)>=x ){ + sqlite3ErrorMsg(pParse, "ON clause references tables to its right"); + return; + } + }else if( (prereqAll>>1)>=x ){ + /* The ON clause of an INNER JOIN references a table to its right. + ** Most other SQL database engines raise an error. But SQLite versions + ** 3.0 through 3.38 just put the ON clause constraint into the WHERE + ** clause and carried on. Beginning with 3.39, raise an error only + ** if there is a RIGHT or FULL JOIN in the query. This makes SQLite + ** more like other systems, and also preserves legacy. */ + if( ALWAYS(pSrc->nSrc>0) && (pSrc->a[0].fg.jointype & JT_LTORJ)!=0 ){ + sqlite3ErrorMsg(pParse, "ON clause references tables to its right"); + return; + } + ExprClearProperty(pExpr, EP_InnerON); + } + } + pTerm->prereqAll = prereqAll; + pTerm->leftCursor = -1; + pTerm->iParent = -1; + pTerm->eOperator = 0; + if( allowedOp(op) ){ + int aiCurCol[2]; + Expr *pLeft = sqlite3ExprSkipCollate(pExpr->pLeft); + Expr *pRight = sqlite3ExprSkipCollate(pExpr->pRight); + u16 opMask = (pTerm->prereqRight & prereqLeft)==0 ? WO_ALL : WO_EQUIV; + + if( pTerm->u.x.iField>0 ){ + assert( op==TK_IN ); + assert( pLeft->op==TK_VECTOR ); + assert( ExprUseXList(pLeft) ); + pLeft = pLeft->x.pList->a[pTerm->u.x.iField-1].pExpr; + } + + if( exprMightBeIndexed(pSrc, aiCurCol, pLeft, op) ){ + pTerm->leftCursor = aiCurCol[0]; + assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 ); + pTerm->u.x.leftColumn = aiCurCol[1]; + pTerm->eOperator = operatorMask(op) & opMask; + } + if( op==TK_IS ) pTerm->wtFlags |= TERM_IS; + if( pRight + && exprMightBeIndexed(pSrc, aiCurCol, pRight, op) + && !ExprHasProperty(pRight, EP_FixedCol) + ){ + WhereTerm *pNew; + Expr *pDup; + u16 eExtraOp = 0; /* Extra bits for pNew->eOperator */ + assert( pTerm->u.x.iField==0 ); + if( pTerm->leftCursor>=0 ){ + int idxNew; + pDup = sqlite3ExprDup(db, pExpr, 0); + if( db->mallocFailed ){ + sqlite3ExprDelete(db, pDup); + return; + } + idxNew = whereClauseInsert(pWC, pDup, TERM_VIRTUAL|TERM_DYNAMIC); + if( idxNew==0 ) return; + pNew = &pWC->a[idxNew]; + markTermAsChild(pWC, idxNew, idxTerm); + if( op==TK_IS ) pNew->wtFlags |= TERM_IS; + pTerm = &pWC->a[idxTerm]; + pTerm->wtFlags |= TERM_COPIED; + + if( termIsEquivalence(pParse, pDup) ){ + pTerm->eOperator |= WO_EQUIV; + eExtraOp = WO_EQUIV; + } + }else{ + pDup = pExpr; + pNew = pTerm; + } + pNew->wtFlags |= exprCommute(pParse, pDup); + pNew->leftCursor = aiCurCol[0]; + assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 ); + pNew->u.x.leftColumn = aiCurCol[1]; + testcase( (prereqLeft | extraRight) != prereqLeft ); + pNew->prereqRight = prereqLeft | extraRight; + pNew->prereqAll = prereqAll; + pNew->eOperator = (operatorMask(pDup->op) + eExtraOp) & opMask; + }else + if( op==TK_ISNULL + && !ExprHasProperty(pExpr,EP_OuterON) + && 0==sqlite3ExprCanBeNull(pLeft) + ){ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + pExpr->op = TK_TRUEFALSE; /* See tag-20230504-1 */ + pExpr->u.zToken = "false"; + ExprSetProperty(pExpr, EP_IsFalse); + pTerm->prereqAll = 0; + pTerm->eOperator = 0; + } + } + +#ifndef SQLITE_OMIT_BETWEEN_OPTIMIZATION + /* If a term is the BETWEEN operator, create two new virtual terms + ** that define the range that the BETWEEN implements. For example: + ** + ** a BETWEEN b AND c + ** + ** is converted into: + ** + ** (a BETWEEN b AND c) AND (a>=b) AND (a<=c) + ** + ** The two new terms are added onto the end of the WhereClause object. + ** The new terms are "dynamic" and are children of the original BETWEEN + ** term. That means that if the BETWEEN term is coded, the children are + ** skipped. Or, if the children are satisfied by an index, the original + ** BETWEEN term is skipped. + */ + else if( pExpr->op==TK_BETWEEN && pWC->op==TK_AND ){ + ExprList *pList; + int i; + static const u8 ops[] = {TK_GE, TK_LE}; + assert( ExprUseXList(pExpr) ); + pList = pExpr->x.pList; + assert( pList!=0 ); + assert( pList->nExpr==2 ); + for(i=0; i<2; i++){ + Expr *pNewExpr; + int idxNew; + pNewExpr = sqlite3PExpr(pParse, ops[i], + sqlite3ExprDup(db, pExpr->pLeft, 0), + sqlite3ExprDup(db, pList->a[i].pExpr, 0)); + transferJoinMarkings(pNewExpr, pExpr); + idxNew = whereClauseInsert(pWC, pNewExpr, TERM_VIRTUAL|TERM_DYNAMIC); + testcase( idxNew==0 ); + exprAnalyze(pSrc, pWC, idxNew); + pTerm = &pWC->a[idxTerm]; + markTermAsChild(pWC, idxNew, idxTerm); + } + } +#endif /* SQLITE_OMIT_BETWEEN_OPTIMIZATION */ + +#if !defined(SQLITE_OMIT_OR_OPTIMIZATION) && !defined(SQLITE_OMIT_SUBQUERY) + /* Analyze a term that is composed of two or more subterms connected by + ** an OR operator. + */ + else if( pExpr->op==TK_OR ){ + assert( pWC->op==TK_AND ); + exprAnalyzeOrTerm(pSrc, pWC, idxTerm); + pTerm = &pWC->a[idxTerm]; + } +#endif /* SQLITE_OMIT_OR_OPTIMIZATION */ + /* The form "x IS NOT NULL" can sometimes be evaluated more efficiently + ** as "x>NULL" if x is not an INTEGER PRIMARY KEY. So construct a + ** virtual term of that form. + ** + ** The virtual term must be tagged with TERM_VNULL. + */ + else if( pExpr->op==TK_NOTNULL ){ + if( pExpr->pLeft->op==TK_COLUMN + && pExpr->pLeft->iColumn>=0 + && !ExprHasProperty(pExpr, EP_OuterON) + ){ + Expr *pNewExpr; + Expr *pLeft = pExpr->pLeft; + int idxNew; + WhereTerm *pNewTerm; + + pNewExpr = sqlite3PExpr(pParse, TK_GT, + sqlite3ExprDup(db, pLeft, 0), + sqlite3ExprAlloc(db, TK_NULL, 0, 0)); + + idxNew = whereClauseInsert(pWC, pNewExpr, + TERM_VIRTUAL|TERM_DYNAMIC|TERM_VNULL); + if( idxNew ){ + pNewTerm = &pWC->a[idxNew]; + pNewTerm->prereqRight = 0; + pNewTerm->leftCursor = pLeft->iTable; + pNewTerm->u.x.leftColumn = pLeft->iColumn; + pNewTerm->eOperator = WO_GT; + markTermAsChild(pWC, idxNew, idxTerm); + pTerm = &pWC->a[idxTerm]; + pTerm->wtFlags |= TERM_COPIED; + pNewTerm->prereqAll = pTerm->prereqAll; + } + } + } + + +#ifndef SQLITE_OMIT_LIKE_OPTIMIZATION + /* Add constraints to reduce the search space on a LIKE or GLOB + ** operator. + ** + ** A like pattern of the form "x LIKE 'aBc%'" is changed into constraints + ** + ** x>='ABC' AND x<'abd' AND x LIKE 'aBc%' + ** + ** The last character of the prefix "abc" is incremented to form the + ** termination condition "abd". If case is not significant (the default + ** for LIKE) then the lower-bound is made all uppercase and the upper- + ** bound is made all lowercase so that the bounds also work when comparing + ** BLOBs. + */ + else if( pExpr->op==TK_FUNCTION + && pWC->op==TK_AND + && isLikeOrGlob(pParse, pExpr, &pStr1, &isComplete, &noCase) + ){ + Expr *pLeft; /* LHS of LIKE/GLOB operator */ + Expr *pStr2; /* Copy of pStr1 - RHS of LIKE/GLOB operator */ + Expr *pNewExpr1; + Expr *pNewExpr2; + int idxNew1; + int idxNew2; + const char *zCollSeqName; /* Name of collating sequence */ + const u16 wtFlags = TERM_LIKEOPT | TERM_VIRTUAL | TERM_DYNAMIC; + + assert( ExprUseXList(pExpr) ); + pLeft = pExpr->x.pList->a[1].pExpr; + pStr2 = sqlite3ExprDup(db, pStr1, 0); + assert( pStr1==0 || !ExprHasProperty(pStr1, EP_IntValue) ); + assert( pStr2==0 || !ExprHasProperty(pStr2, EP_IntValue) ); + + + /* Convert the lower bound to upper-case and the upper bound to + ** lower-case (upper-case is less than lower-case in ASCII) so that + ** the range constraints also work for BLOBs + */ + if( noCase && !pParse->db->mallocFailed ){ + int i; + char c; + pTerm->wtFlags |= TERM_LIKE; + for(i=0; (c = pStr1->u.zToken[i])!=0; i++){ + pStr1->u.zToken[i] = sqlite3Toupper(c); + pStr2->u.zToken[i] = sqlite3Tolower(c); + } + } + + if( !db->mallocFailed ){ + u8 c, *pC; /* Last character before the first wildcard */ + pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1]; + c = *pC; + if( noCase ){ + /* The point is to increment the last character before the first + ** wildcard. But if we increment '@', that will push it into the + ** alphabetic range where case conversions will mess up the + ** inequality. To avoid this, make sure to also run the full + ** LIKE on all candidate expressions by clearing the isComplete flag + */ + if( c=='A'-1 ) isComplete = 0; + c = sqlite3UpperToLower[c]; + } + *pC = c + 1; + } + zCollSeqName = noCase ? "NOCASE" : sqlite3StrBINARY; + pNewExpr1 = sqlite3ExprDup(db, pLeft, 0); + pNewExpr1 = sqlite3PExpr(pParse, TK_GE, + sqlite3ExprAddCollateString(pParse,pNewExpr1,zCollSeqName), + pStr1); + transferJoinMarkings(pNewExpr1, pExpr); + idxNew1 = whereClauseInsert(pWC, pNewExpr1, wtFlags); + testcase( idxNew1==0 ); + pNewExpr2 = sqlite3ExprDup(db, pLeft, 0); + pNewExpr2 = sqlite3PExpr(pParse, TK_LT, + sqlite3ExprAddCollateString(pParse,pNewExpr2,zCollSeqName), + pStr2); + transferJoinMarkings(pNewExpr2, pExpr); + idxNew2 = whereClauseInsert(pWC, pNewExpr2, wtFlags); + testcase( idxNew2==0 ); + exprAnalyze(pSrc, pWC, idxNew1); + exprAnalyze(pSrc, pWC, idxNew2); + pTerm = &pWC->a[idxTerm]; + if( isComplete ){ + markTermAsChild(pWC, idxNew1, idxTerm); + markTermAsChild(pWC, idxNew2, idxTerm); + } + } +#endif /* SQLITE_OMIT_LIKE_OPTIMIZATION */ + + /* If there is a vector == or IS term - e.g. "(a, b) == (?, ?)" - create + ** new terms for each component comparison - "a = ?" and "b = ?". The + ** new terms completely replace the original vector comparison, which is + ** no longer used. + ** + ** This is only required if at least one side of the comparison operation + ** is not a sub-select. + ** + ** tag-20220128a + */ + if( (pExpr->op==TK_EQ || pExpr->op==TK_IS) + && (nLeft = sqlite3ExprVectorSize(pExpr->pLeft))>1 + && sqlite3ExprVectorSize(pExpr->pRight)==nLeft + && ( (pExpr->pLeft->flags & EP_xIsSelect)==0 + || (pExpr->pRight->flags & EP_xIsSelect)==0) + && pWC->op==TK_AND + ){ + int i; + for(i=0; ipLeft, i, nLeft); + Expr *pRight = sqlite3ExprForVectorField(pParse, pExpr->pRight, i, nLeft); + + pNew = sqlite3PExpr(pParse, pExpr->op, pLeft, pRight); + transferJoinMarkings(pNew, pExpr); + idxNew = whereClauseInsert(pWC, pNew, TERM_DYNAMIC|TERM_SLICE); + exprAnalyze(pSrc, pWC, idxNew); + } + pTerm = &pWC->a[idxTerm]; + pTerm->wtFlags |= TERM_CODED|TERM_VIRTUAL; /* Disable the original */ + pTerm->eOperator = WO_ROWVAL; + } + + /* If there is a vector IN term - e.g. "(a, b) IN (SELECT ...)" - create + ** a virtual term for each vector component. The expression object + ** used by each such virtual term is pExpr (the full vector IN(...) + ** expression). The WhereTerm.u.x.iField variable identifies the index within + ** the vector on the LHS that the virtual term represents. + ** + ** This only works if the RHS is a simple SELECT (not a compound) that does + ** not use window functions. + */ + else if( pExpr->op==TK_IN + && pTerm->u.x.iField==0 + && pExpr->pLeft->op==TK_VECTOR + && ALWAYS( ExprUseXSelect(pExpr) ) + && (pExpr->x.pSelect->pPrior==0 || (pExpr->x.pSelect->selFlags & SF_Values)) +#ifndef SQLITE_OMIT_WINDOWFUNC + && pExpr->x.pSelect->pWin==0 +#endif + && pWC->op==TK_AND + ){ + int i; + for(i=0; ipLeft); i++){ + int idxNew; + idxNew = whereClauseInsert(pWC, pExpr, TERM_VIRTUAL|TERM_SLICE); + pWC->a[idxNew].u.x.iField = i+1; + exprAnalyze(pSrc, pWC, idxNew); + markTermAsChild(pWC, idxNew, idxTerm); + } + } + +#ifndef SQLITE_OMIT_VIRTUALTABLE + /* Add a WO_AUX auxiliary term to the constraint set if the + ** current expression is of the form "column OP expr" where OP + ** is an operator that gets passed into virtual tables but which is + ** not normally optimized for ordinary tables. In other words, OP + ** is one of MATCH, LIKE, GLOB, REGEXP, !=, IS, IS NOT, or NOT NULL. + ** This information is used by the xBestIndex methods of + ** virtual tables. The native query optimizer does not attempt + ** to do anything with MATCH functions. + */ + else if( pWC->op==TK_AND ){ + Expr *pRight = 0, *pLeft = 0; + int res = isAuxiliaryVtabOperator(db, pExpr, &eOp2, &pLeft, &pRight); + while( res-- > 0 ){ + int idxNew; + WhereTerm *pNewTerm; + Bitmask prereqColumn, prereqExpr; + + prereqExpr = sqlite3WhereExprUsage(pMaskSet, pRight); + prereqColumn = sqlite3WhereExprUsage(pMaskSet, pLeft); + if( (prereqExpr & prereqColumn)==0 ){ + Expr *pNewExpr; + pNewExpr = sqlite3PExpr(pParse, TK_MATCH, + 0, sqlite3ExprDup(db, pRight, 0)); + if( ExprHasProperty(pExpr, EP_OuterON) && pNewExpr ){ + ExprSetProperty(pNewExpr, EP_OuterON); + pNewExpr->w.iJoin = pExpr->w.iJoin; + } + idxNew = whereClauseInsert(pWC, pNewExpr, TERM_VIRTUAL|TERM_DYNAMIC); + testcase( idxNew==0 ); + pNewTerm = &pWC->a[idxNew]; + pNewTerm->prereqRight = prereqExpr; + pNewTerm->leftCursor = pLeft->iTable; + pNewTerm->u.x.leftColumn = pLeft->iColumn; + pNewTerm->eOperator = WO_AUX; + pNewTerm->eMatchOp = eOp2; + markTermAsChild(pWC, idxNew, idxTerm); + pTerm = &pWC->a[idxTerm]; + pTerm->wtFlags |= TERM_COPIED; + pNewTerm->prereqAll = pTerm->prereqAll; + } + SWAP(Expr*, pLeft, pRight); + } + } +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + + /* Prevent ON clause terms of a LEFT JOIN from being used to drive + ** an index for tables to the left of the join. + */ + testcase( pTerm!=&pWC->a[idxTerm] ); + pTerm = &pWC->a[idxTerm]; + pTerm->prereqRight |= extraRight; +} + +/*************************************************************************** +** Routines with file scope above. Interface to the rest of the where.c +** subsystem follows. +***************************************************************************/ + +/* +** This routine identifies subexpressions in the WHERE clause where +** each subexpression is separated by the AND operator or some other +** operator specified in the op parameter. The WhereClause structure +** is filled with pointers to subexpressions. For example: +** +** WHERE a=='hello' AND coalesce(b,11)<10 AND (c+12!=d OR c==22) +** \________/ \_______________/ \________________/ +** slot[0] slot[1] slot[2] +** +** The original WHERE clause in pExpr is unaltered. All this routine +** does is make slot[] entries point to substructure within pExpr. +** +** In the previous sentence and in the diagram, "slot[]" refers to +** the WhereClause.a[] array. The slot[] array grows as needed to contain +** all terms of the WHERE clause. +*/ +SQLITE_PRIVATE void sqlite3WhereSplit(WhereClause *pWC, Expr *pExpr, u8 op){ + Expr *pE2 = sqlite3ExprSkipCollateAndLikely(pExpr); + pWC->op = op; + assert( pE2!=0 || pExpr==0 ); + if( pE2==0 ) return; + if( pE2->op!=op ){ + whereClauseInsert(pWC, pExpr, 0); + }else{ + sqlite3WhereSplit(pWC, pE2->pLeft, op); + sqlite3WhereSplit(pWC, pE2->pRight, op); + } +} + +/* +** Add either a LIMIT (if eMatchOp==SQLITE_INDEX_CONSTRAINT_LIMIT) or +** OFFSET (if eMatchOp==SQLITE_INDEX_CONSTRAINT_OFFSET) term to the +** where-clause passed as the first argument. The value for the term +** is found in register iReg. +** +** In the common case where the value is a simple integer +** (example: "LIMIT 5 OFFSET 10") then the expression codes as a +** TK_INTEGER so that it will be available to sqlite3_vtab_rhs_value(). +** If not, then it codes as a TK_REGISTER expression. +*/ +static void whereAddLimitExpr( + WhereClause *pWC, /* Add the constraint to this WHERE clause */ + int iReg, /* Register that will hold value of the limit/offset */ + Expr *pExpr, /* Expression that defines the limit/offset */ + int iCsr, /* Cursor to which the constraint applies */ + int eMatchOp /* SQLITE_INDEX_CONSTRAINT_LIMIT or _OFFSET */ +){ + Parse *pParse = pWC->pWInfo->pParse; + sqlite3 *db = pParse->db; + Expr *pNew; + int iVal = 0; + + if( sqlite3ExprIsInteger(pExpr, &iVal) && iVal>=0 ){ + Expr *pVal = sqlite3Expr(db, TK_INTEGER, 0); + if( pVal==0 ) return; + ExprSetProperty(pVal, EP_IntValue); + pVal->u.iValue = iVal; + pNew = sqlite3PExpr(pParse, TK_MATCH, 0, pVal); + }else{ + Expr *pVal = sqlite3Expr(db, TK_REGISTER, 0); + if( pVal==0 ) return; + pVal->iTable = iReg; + pNew = sqlite3PExpr(pParse, TK_MATCH, 0, pVal); + } + if( pNew ){ + WhereTerm *pTerm; + int idx; + idx = whereClauseInsert(pWC, pNew, TERM_DYNAMIC|TERM_VIRTUAL); + pTerm = &pWC->a[idx]; + pTerm->leftCursor = iCsr; + pTerm->eOperator = WO_AUX; + pTerm->eMatchOp = eMatchOp; + } +} + +/* +** Possibly add terms corresponding to the LIMIT and OFFSET clauses of the +** SELECT statement passed as the second argument. These terms are only +** added if: +** +** 1. The SELECT statement has a LIMIT clause, and +** 2. The SELECT statement is not an aggregate or DISTINCT query, and +** 3. The SELECT statement has exactly one object in its from clause, and +** that object is a virtual table, and +** 4. There are no terms in the WHERE clause that will not be passed +** to the virtual table xBestIndex method. +** 5. The ORDER BY clause, if any, will be made available to the xBestIndex +** method. +** +** LIMIT and OFFSET terms are ignored by most of the planner code. They +** exist only so that they may be passed to the xBestIndex method of the +** single virtual table in the FROM clause of the SELECT. +*/ +SQLITE_PRIVATE void SQLITE_NOINLINE sqlite3WhereAddLimit(WhereClause *pWC, Select *p){ + assert( p!=0 && p->pLimit!=0 ); /* 1 -- checked by caller */ + if( p->pGroupBy==0 + && (p->selFlags & (SF_Distinct|SF_Aggregate))==0 /* 2 */ + && (p->pSrc->nSrc==1 && IsVirtual(p->pSrc->a[0].pTab)) /* 3 */ + ){ + ExprList *pOrderBy = p->pOrderBy; + int iCsr = p->pSrc->a[0].iCursor; + int ii; + + /* Check condition (4). Return early if it is not met. */ + for(ii=0; iinTerm; ii++){ + if( pWC->a[ii].wtFlags & TERM_CODED ){ + /* This term is a vector operation that has been decomposed into + ** other, subsequent terms. It can be ignored. See tag-20220128a */ + assert( pWC->a[ii].wtFlags & TERM_VIRTUAL ); + assert( pWC->a[ii].eOperator==WO_ROWVAL ); + continue; + } + if( pWC->a[ii].nChild ){ + /* If this term has child terms, then they are also part of the + ** pWC->a[] array. So this term can be ignored, as a LIMIT clause + ** will only be added if each of the child terms passes the + ** (leftCursor==iCsr) test below. */ + continue; + } + if( pWC->a[ii].leftCursor!=iCsr ) return; + } + + /* Check condition (5). Return early if it is not met. */ + if( pOrderBy ){ + for(ii=0; iinExpr; ii++){ + Expr *pExpr = pOrderBy->a[ii].pExpr; + if( pExpr->op!=TK_COLUMN ) return; + if( pExpr->iTable!=iCsr ) return; + if( pOrderBy->a[ii].fg.sortFlags & KEYINFO_ORDER_BIGNULL ) return; + } + } + + /* All conditions are met. Add the terms to the where-clause object. */ + assert( p->pLimit->op==TK_LIMIT ); + whereAddLimitExpr(pWC, p->iLimit, p->pLimit->pLeft, + iCsr, SQLITE_INDEX_CONSTRAINT_LIMIT); + if( p->iOffset>0 ){ + whereAddLimitExpr(pWC, p->iOffset, p->pLimit->pRight, + iCsr, SQLITE_INDEX_CONSTRAINT_OFFSET); + } + } +} + +/* +** Initialize a preallocated WhereClause structure. +*/ +SQLITE_PRIVATE void sqlite3WhereClauseInit( + WhereClause *pWC, /* The WhereClause to be initialized */ + WhereInfo *pWInfo /* The WHERE processing context */ +){ + pWC->pWInfo = pWInfo; + pWC->hasOr = 0; + pWC->pOuter = 0; + pWC->nTerm = 0; + pWC->nBase = 0; + pWC->nSlot = ArraySize(pWC->aStatic); + pWC->a = pWC->aStatic; +} + +/* +** Deallocate a WhereClause structure. The WhereClause structure +** itself is not freed. This routine is the inverse of +** sqlite3WhereClauseInit(). +*/ +SQLITE_PRIVATE void sqlite3WhereClauseClear(WhereClause *pWC){ + sqlite3 *db = pWC->pWInfo->pParse->db; + assert( pWC->nTerm>=pWC->nBase ); + if( pWC->nTerm>0 ){ + WhereTerm *a = pWC->a; + WhereTerm *aLast = &pWC->a[pWC->nTerm-1]; +#ifdef SQLITE_DEBUG + int i; + /* Verify that every term past pWC->nBase is virtual */ + for(i=pWC->nBase; inTerm; i++){ + assert( (pWC->a[i].wtFlags & TERM_VIRTUAL)!=0 ); + } +#endif + while(1){ + assert( a->eMatchOp==0 || a->eOperator==WO_AUX ); + if( a->wtFlags & TERM_DYNAMIC ){ + sqlite3ExprDelete(db, a->pExpr); + } + if( a->wtFlags & (TERM_ORINFO|TERM_ANDINFO) ){ + if( a->wtFlags & TERM_ORINFO ){ + assert( (a->wtFlags & TERM_ANDINFO)==0 ); + whereOrInfoDelete(db, a->u.pOrInfo); + }else{ + assert( (a->wtFlags & TERM_ANDINFO)!=0 ); + whereAndInfoDelete(db, a->u.pAndInfo); + } + } + if( a==aLast ) break; + a++; + } + } +} + + +/* +** These routines walk (recursively) an expression tree and generate +** a bitmask indicating which tables are used in that expression +** tree. +** +** sqlite3WhereExprUsage(MaskSet, Expr) -> +** +** Return a Bitmask of all tables referenced by Expr. Expr can be +** be NULL, in which case 0 is returned. +** +** sqlite3WhereExprUsageNN(MaskSet, Expr) -> +** +** Same as sqlite3WhereExprUsage() except that Expr must not be +** NULL. The "NN" suffix on the name stands for "Not Null". +** +** sqlite3WhereExprListUsage(MaskSet, ExprList) -> +** +** Return a Bitmask of all tables referenced by every expression +** in the expression list ExprList. ExprList can be NULL, in which +** case 0 is returned. +** +** sqlite3WhereExprUsageFull(MaskSet, ExprList) -> +** +** Internal use only. Called only by sqlite3WhereExprUsageNN() for +** complex expressions that require pushing register values onto +** the stack. Many calls to sqlite3WhereExprUsageNN() do not need +** the more complex analysis done by this routine. Hence, the +** computations done by this routine are broken out into a separate +** "no-inline" function to avoid the stack push overhead in the +** common case where it is not needed. +*/ +static SQLITE_NOINLINE Bitmask sqlite3WhereExprUsageFull( + WhereMaskSet *pMaskSet, + Expr *p +){ + Bitmask mask; + mask = (p->op==TK_IF_NULL_ROW) ? sqlite3WhereGetMask(pMaskSet, p->iTable) : 0; + if( p->pLeft ) mask |= sqlite3WhereExprUsageNN(pMaskSet, p->pLeft); + if( p->pRight ){ + mask |= sqlite3WhereExprUsageNN(pMaskSet, p->pRight); + assert( p->x.pList==0 ); + }else if( ExprUseXSelect(p) ){ + if( ExprHasProperty(p, EP_VarSelect) ) pMaskSet->bVarSelect = 1; + mask |= exprSelectUsage(pMaskSet, p->x.pSelect); + }else if( p->x.pList ){ + mask |= sqlite3WhereExprListUsage(pMaskSet, p->x.pList); + } +#ifndef SQLITE_OMIT_WINDOWFUNC + if( (p->op==TK_FUNCTION || p->op==TK_AGG_FUNCTION) && ExprUseYWin(p) ){ + assert( p->y.pWin!=0 ); + mask |= sqlite3WhereExprListUsage(pMaskSet, p->y.pWin->pPartition); + mask |= sqlite3WhereExprListUsage(pMaskSet, p->y.pWin->pOrderBy); + mask |= sqlite3WhereExprUsage(pMaskSet, p->y.pWin->pFilter); + } +#endif + return mask; +} +SQLITE_PRIVATE Bitmask sqlite3WhereExprUsageNN(WhereMaskSet *pMaskSet, Expr *p){ + if( p->op==TK_COLUMN && !ExprHasProperty(p, EP_FixedCol) ){ + return sqlite3WhereGetMask(pMaskSet, p->iTable); + }else if( ExprHasProperty(p, EP_TokenOnly|EP_Leaf) ){ + assert( p->op!=TK_IF_NULL_ROW ); + return 0; + } + return sqlite3WhereExprUsageFull(pMaskSet, p); +} +SQLITE_PRIVATE Bitmask sqlite3WhereExprUsage(WhereMaskSet *pMaskSet, Expr *p){ + return p ? sqlite3WhereExprUsageNN(pMaskSet,p) : 0; +} +SQLITE_PRIVATE Bitmask sqlite3WhereExprListUsage(WhereMaskSet *pMaskSet, ExprList *pList){ + int i; + Bitmask mask = 0; + if( pList ){ + for(i=0; inExpr; i++){ + mask |= sqlite3WhereExprUsage(pMaskSet, pList->a[i].pExpr); + } + } + return mask; +} + + +/* +** Call exprAnalyze on all terms in a WHERE clause. +** +** Note that exprAnalyze() might add new virtual terms onto the +** end of the WHERE clause. We do not want to analyze these new +** virtual terms, so start analyzing at the end and work forward +** so that the added virtual terms are never processed. +*/ +SQLITE_PRIVATE void sqlite3WhereExprAnalyze( + SrcList *pTabList, /* the FROM clause */ + WhereClause *pWC /* the WHERE clause to be analyzed */ +){ + int i; + for(i=pWC->nTerm-1; i>=0; i--){ + exprAnalyze(pTabList, pWC, i); + } +} + +/* +** For table-valued-functions, transform the function arguments into +** new WHERE clause terms. +** +** Each function argument translates into an equality constraint against +** a HIDDEN column in the table. +*/ +SQLITE_PRIVATE void sqlite3WhereTabFuncArgs( + Parse *pParse, /* Parsing context */ + SrcItem *pItem, /* The FROM clause term to process */ + WhereClause *pWC /* Xfer function arguments to here */ +){ + Table *pTab; + int j, k; + ExprList *pArgs; + Expr *pColRef; + Expr *pTerm; + if( pItem->fg.isTabFunc==0 ) return; + pTab = pItem->pTab; + assert( pTab!=0 ); + pArgs = pItem->u1.pFuncArg; + if( pArgs==0 ) return; + for(j=k=0; jnExpr; j++){ + Expr *pRhs; + u32 joinType; + while( knCol && (pTab->aCol[k].colFlags & COLFLAG_HIDDEN)==0 ){k++;} + if( k>=pTab->nCol ){ + sqlite3ErrorMsg(pParse, "too many arguments on %s() - max %d", + pTab->zName, j); + return; + } + pColRef = sqlite3ExprAlloc(pParse->db, TK_COLUMN, 0, 0); + if( pColRef==0 ) return; + pColRef->iTable = pItem->iCursor; + pColRef->iColumn = k++; + assert( ExprUseYTab(pColRef) ); + pColRef->y.pTab = pTab; + pItem->colUsed |= sqlite3ExprColUsed(pColRef); + pRhs = sqlite3PExpr(pParse, TK_UPLUS, + sqlite3ExprDup(pParse->db, pArgs->a[j].pExpr, 0), 0); + pTerm = sqlite3PExpr(pParse, TK_EQ, pColRef, pRhs); + if( pItem->fg.jointype & (JT_LEFT|JT_RIGHT) ){ + testcase( pItem->fg.jointype & JT_LEFT ); /* testtag-20230227a */ + testcase( pItem->fg.jointype & JT_RIGHT ); /* testtag-20230227b */ + joinType = EP_OuterON; + }else{ + testcase( pItem->fg.jointype & JT_LTORJ ); /* testtag-20230227c */ + joinType = EP_InnerON; + } + sqlite3SetJoinExpr(pTerm, pItem->iCursor, joinType); + whereClauseInsert(pWC, pTerm, TERM_DYNAMIC); + } +} + +/************** End of whereexpr.c *******************************************/ +/************** Begin file where.c *******************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This module contains C code that generates VDBE code used to process +** the WHERE clause of SQL statements. This module is responsible for +** generating the code that loops through a table looking for applicable +** rows. Indices are selected and used to speed the search when doing +** so is applicable. Because this module is responsible for selecting +** indices, you might also think of this module as the "query optimizer". +*/ +/* #include "sqliteInt.h" */ +/* #include "whereInt.h" */ + +/* +** Extra information appended to the end of sqlite3_index_info but not +** visible to the xBestIndex function, at least not directly. The +** sqlite3_vtab_collation() interface knows how to reach it, however. +** +** This object is not an API and can be changed from one release to the +** next. As long as allocateIndexInfo() and sqlite3_vtab_collation() +** agree on the structure, all will be well. +*/ +typedef struct HiddenIndexInfo HiddenIndexInfo; +struct HiddenIndexInfo { + WhereClause *pWC; /* The Where clause being analyzed */ + Parse *pParse; /* The parsing context */ + int eDistinct; /* Value to return from sqlite3_vtab_distinct() */ + u32 mIn; /* Mask of terms that are IN (...) */ + u32 mHandleIn; /* Terms that vtab will handle as IN (...) */ + sqlite3_value *aRhs[1]; /* RHS values for constraints. MUST BE LAST + ** because extra space is allocated to hold up + ** to nTerm such values */ +}; + +/* Forward declaration of methods */ +static int whereLoopResize(sqlite3*, WhereLoop*, int); + +/* +** Return the estimated number of output rows from a WHERE clause +*/ +SQLITE_PRIVATE LogEst sqlite3WhereOutputRowCount(WhereInfo *pWInfo){ + return pWInfo->nRowOut; +} + +/* +** Return one of the WHERE_DISTINCT_xxxxx values to indicate how this +** WHERE clause returns outputs for DISTINCT processing. +*/ +SQLITE_PRIVATE int sqlite3WhereIsDistinct(WhereInfo *pWInfo){ + return pWInfo->eDistinct; +} + +/* +** Return the number of ORDER BY terms that are satisfied by the +** WHERE clause. A return of 0 means that the output must be +** completely sorted. A return equal to the number of ORDER BY +** terms means that no sorting is needed at all. A return that +** is positive but less than the number of ORDER BY terms means that +** block sorting is required. +*/ +SQLITE_PRIVATE int sqlite3WhereIsOrdered(WhereInfo *pWInfo){ + return pWInfo->nOBSat<0 ? 0 : pWInfo->nOBSat; +} + +/* +** In the ORDER BY LIMIT optimization, if the inner-most loop is known +** to emit rows in increasing order, and if the last row emitted by the +** inner-most loop did not fit within the sorter, then we can skip all +** subsequent rows for the current iteration of the inner loop (because they +** will not fit in the sorter either) and continue with the second inner +** loop - the loop immediately outside the inner-most. +** +** When a row does not fit in the sorter (because the sorter already +** holds LIMIT+OFFSET rows that are smaller), then a jump is made to the +** label returned by this function. +** +** If the ORDER BY LIMIT optimization applies, the jump destination should +** be the continuation for the second-inner-most loop. If the ORDER BY +** LIMIT optimization does not apply, then the jump destination should +** be the continuation for the inner-most loop. +** +** It is always safe for this routine to return the continuation of the +** inner-most loop, in the sense that a correct answer will result. +** Returning the continuation the second inner loop is an optimization +** that might make the code run a little faster, but should not change +** the final answer. +*/ +SQLITE_PRIVATE int sqlite3WhereOrderByLimitOptLabel(WhereInfo *pWInfo){ + WhereLevel *pInner; + if( !pWInfo->bOrderedInnerLoop ){ + /* The ORDER BY LIMIT optimization does not apply. Jump to the + ** continuation of the inner-most loop. */ + return pWInfo->iContinue; + } + pInner = &pWInfo->a[pWInfo->nLevel-1]; + assert( pInner->addrNxt!=0 ); + return pInner->pRJ ? pWInfo->iContinue : pInner->addrNxt; +} + +/* +** While generating code for the min/max optimization, after handling +** the aggregate-step call to min() or max(), check to see if any +** additional looping is required. If the output order is such that +** we are certain that the correct answer has already been found, then +** code an OP_Goto to by pass subsequent processing. +** +** Any extra OP_Goto that is coded here is an optimization. The +** correct answer should be obtained regardless. This OP_Goto just +** makes the answer appear faster. +*/ +SQLITE_PRIVATE void sqlite3WhereMinMaxOptEarlyOut(Vdbe *v, WhereInfo *pWInfo){ + WhereLevel *pInner; + int i; + if( !pWInfo->bOrderedInnerLoop ) return; + if( pWInfo->nOBSat==0 ) return; + for(i=pWInfo->nLevel-1; i>=0; i--){ + pInner = &pWInfo->a[i]; + if( (pInner->pWLoop->wsFlags & WHERE_COLUMN_IN)!=0 ){ + sqlite3VdbeGoto(v, pInner->addrNxt); + return; + } + } + sqlite3VdbeGoto(v, pWInfo->iBreak); +} + +/* +** Return the VDBE address or label to jump to in order to continue +** immediately with the next row of a WHERE clause. +*/ +SQLITE_PRIVATE int sqlite3WhereContinueLabel(WhereInfo *pWInfo){ + assert( pWInfo->iContinue!=0 ); + return pWInfo->iContinue; +} + +/* +** Return the VDBE address or label to jump to in order to break +** out of a WHERE loop. +*/ +SQLITE_PRIVATE int sqlite3WhereBreakLabel(WhereInfo *pWInfo){ + return pWInfo->iBreak; +} + +/* +** Return ONEPASS_OFF (0) if an UPDATE or DELETE statement is unable to +** operate directly on the rowids returned by a WHERE clause. Return +** ONEPASS_SINGLE (1) if the statement can operation directly because only +** a single row is to be changed. Return ONEPASS_MULTI (2) if the one-pass +** optimization can be used on multiple +** +** If the ONEPASS optimization is used (if this routine returns true) +** then also write the indices of open cursors used by ONEPASS +** into aiCur[0] and aiCur[1]. iaCur[0] gets the cursor of the data +** table and iaCur[1] gets the cursor used by an auxiliary index. +** Either value may be -1, indicating that cursor is not used. +** Any cursors returned will have been opened for writing. +** +** aiCur[0] and aiCur[1] both get -1 if the where-clause logic is +** unable to use the ONEPASS optimization. +*/ +SQLITE_PRIVATE int sqlite3WhereOkOnePass(WhereInfo *pWInfo, int *aiCur){ + memcpy(aiCur, pWInfo->aiCurOnePass, sizeof(int)*2); +#ifdef WHERETRACE_ENABLED + if( sqlite3WhereTrace && pWInfo->eOnePass!=ONEPASS_OFF ){ + sqlite3DebugPrintf("%s cursors: %d %d\n", + pWInfo->eOnePass==ONEPASS_SINGLE ? "ONEPASS_SINGLE" : "ONEPASS_MULTI", + aiCur[0], aiCur[1]); + } +#endif + return pWInfo->eOnePass; +} + +/* +** Return TRUE if the WHERE loop uses the OP_DeferredSeek opcode to move +** the data cursor to the row selected by the index cursor. +*/ +SQLITE_PRIVATE int sqlite3WhereUsesDeferredSeek(WhereInfo *pWInfo){ + return pWInfo->bDeferredSeek; +} + +/* +** Move the content of pSrc into pDest +*/ +static void whereOrMove(WhereOrSet *pDest, WhereOrSet *pSrc){ + pDest->n = pSrc->n; + memcpy(pDest->a, pSrc->a, pDest->n*sizeof(pDest->a[0])); +} + +/* +** Try to insert a new prerequisite/cost entry into the WhereOrSet pSet. +** +** The new entry might overwrite an existing entry, or it might be +** appended, or it might be discarded. Do whatever is the right thing +** so that pSet keeps the N_OR_COST best entries seen so far. +*/ +static int whereOrInsert( + WhereOrSet *pSet, /* The WhereOrSet to be updated */ + Bitmask prereq, /* Prerequisites of the new entry */ + LogEst rRun, /* Run-cost of the new entry */ + LogEst nOut /* Number of outputs for the new entry */ +){ + u16 i; + WhereOrCost *p; + for(i=pSet->n, p=pSet->a; i>0; i--, p++){ + if( rRun<=p->rRun && (prereq & p->prereq)==prereq ){ + goto whereOrInsert_done; + } + if( p->rRun<=rRun && (p->prereq & prereq)==p->prereq ){ + return 0; + } + } + if( pSet->na[pSet->n++]; + p->nOut = nOut; + }else{ + p = pSet->a; + for(i=1; in; i++){ + if( p->rRun>pSet->a[i].rRun ) p = pSet->a + i; + } + if( p->rRun<=rRun ) return 0; + } +whereOrInsert_done: + p->prereq = prereq; + p->rRun = rRun; + if( p->nOut>nOut ) p->nOut = nOut; + return 1; +} + +/* +** Return the bitmask for the given cursor number. Return 0 if +** iCursor is not in the set. +*/ +SQLITE_PRIVATE Bitmask sqlite3WhereGetMask(WhereMaskSet *pMaskSet, int iCursor){ + int i; + assert( pMaskSet->n<=(int)sizeof(Bitmask)*8 ); + assert( pMaskSet->n>0 || pMaskSet->ix[0]<0 ); + assert( iCursor>=-1 ); + if( pMaskSet->ix[0]==iCursor ){ + return 1; + } + for(i=1; in; i++){ + if( pMaskSet->ix[i]==iCursor ){ + return MASKBIT(i); + } + } + return 0; +} + +/* Allocate memory that is automatically freed when pWInfo is freed. +*/ +SQLITE_PRIVATE void *sqlite3WhereMalloc(WhereInfo *pWInfo, u64 nByte){ + WhereMemBlock *pBlock; + pBlock = sqlite3DbMallocRawNN(pWInfo->pParse->db, nByte+sizeof(*pBlock)); + if( pBlock ){ + pBlock->pNext = pWInfo->pMemToFree; + pBlock->sz = nByte; + pWInfo->pMemToFree = pBlock; + pBlock++; + } + return (void*)pBlock; +} +SQLITE_PRIVATE void *sqlite3WhereRealloc(WhereInfo *pWInfo, void *pOld, u64 nByte){ + void *pNew = sqlite3WhereMalloc(pWInfo, nByte); + if( pNew && pOld ){ + WhereMemBlock *pOldBlk = (WhereMemBlock*)pOld; + pOldBlk--; + assert( pOldBlk->szsz); + } + return pNew; +} + +/* +** Create a new mask for cursor iCursor. +** +** There is one cursor per table in the FROM clause. The number of +** tables in the FROM clause is limited by a test early in the +** sqlite3WhereBegin() routine. So we know that the pMaskSet->ix[] +** array will never overflow. +*/ +static void createMask(WhereMaskSet *pMaskSet, int iCursor){ + assert( pMaskSet->n < ArraySize(pMaskSet->ix) ); + pMaskSet->ix[pMaskSet->n++] = iCursor; +} + +/* +** If the right-hand branch of the expression is a TK_COLUMN, then return +** a pointer to the right-hand branch. Otherwise, return NULL. +*/ +static Expr *whereRightSubexprIsColumn(Expr *p){ + p = sqlite3ExprSkipCollateAndLikely(p->pRight); + if( ALWAYS(p!=0) && p->op==TK_COLUMN && !ExprHasProperty(p, EP_FixedCol) ){ + return p; + } + return 0; +} + +/* +** Advance to the next WhereTerm that matches according to the criteria +** established when the pScan object was initialized by whereScanInit(). +** Return NULL if there are no more matching WhereTerms. +*/ +static WhereTerm *whereScanNext(WhereScan *pScan){ + int iCur; /* The cursor on the LHS of the term */ + i16 iColumn; /* The column on the LHS of the term. -1 for IPK */ + Expr *pX; /* An expression being tested */ + WhereClause *pWC; /* Shorthand for pScan->pWC */ + WhereTerm *pTerm; /* The term being tested */ + int k = pScan->k; /* Where to start scanning */ + + assert( pScan->iEquiv<=pScan->nEquiv ); + pWC = pScan->pWC; + while(1){ + iColumn = pScan->aiColumn[pScan->iEquiv-1]; + iCur = pScan->aiCur[pScan->iEquiv-1]; + assert( pWC!=0 ); + assert( iCur>=0 ); + do{ + for(pTerm=pWC->a+k; knTerm; k++, pTerm++){ + assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 || pTerm->leftCursor<0 ); + if( pTerm->leftCursor==iCur + && pTerm->u.x.leftColumn==iColumn + && (iColumn!=XN_EXPR + || sqlite3ExprCompareSkip(pTerm->pExpr->pLeft, + pScan->pIdxExpr,iCur)==0) + && (pScan->iEquiv<=1 || !ExprHasProperty(pTerm->pExpr, EP_OuterON)) + ){ + if( (pTerm->eOperator & WO_EQUIV)!=0 + && pScan->nEquivaiCur) + && (pX = whereRightSubexprIsColumn(pTerm->pExpr))!=0 + ){ + int j; + for(j=0; jnEquiv; j++){ + if( pScan->aiCur[j]==pX->iTable + && pScan->aiColumn[j]==pX->iColumn ){ + break; + } + } + if( j==pScan->nEquiv ){ + pScan->aiCur[j] = pX->iTable; + pScan->aiColumn[j] = pX->iColumn; + pScan->nEquiv++; + } + } + if( (pTerm->eOperator & pScan->opMask)!=0 ){ + /* Verify the affinity and collating sequence match */ + if( pScan->zCollName && (pTerm->eOperator & WO_ISNULL)==0 ){ + CollSeq *pColl; + Parse *pParse = pWC->pWInfo->pParse; + pX = pTerm->pExpr; + if( !sqlite3IndexAffinityOk(pX, pScan->idxaff) ){ + continue; + } + assert(pX->pLeft); + pColl = sqlite3ExprCompareCollSeq(pParse, pX); + if( pColl==0 ) pColl = pParse->db->pDfltColl; + if( sqlite3StrICmp(pColl->zName, pScan->zCollName) ){ + continue; + } + } + if( (pTerm->eOperator & (WO_EQ|WO_IS))!=0 + && (pX = pTerm->pExpr->pRight, ALWAYS(pX!=0)) + && pX->op==TK_COLUMN + && pX->iTable==pScan->aiCur[0] + && pX->iColumn==pScan->aiColumn[0] + ){ + testcase( pTerm->eOperator & WO_IS ); + continue; + } + pScan->pWC = pWC; + pScan->k = k+1; +#ifdef WHERETRACE_ENABLED + if( sqlite3WhereTrace & 0x20000 ){ + int ii; + sqlite3DebugPrintf("SCAN-TERM %p: nEquiv=%d", + pTerm, pScan->nEquiv); + for(ii=0; iinEquiv; ii++){ + sqlite3DebugPrintf(" {%d:%d}", + pScan->aiCur[ii], pScan->aiColumn[ii]); + } + sqlite3DebugPrintf("\n"); + } +#endif + return pTerm; + } + } + } + pWC = pWC->pOuter; + k = 0; + }while( pWC!=0 ); + if( pScan->iEquiv>=pScan->nEquiv ) break; + pWC = pScan->pOrigWC; + k = 0; + pScan->iEquiv++; + } + return 0; +} + +/* +** This is whereScanInit() for the case of an index on an expression. +** It is factored out into a separate tail-recursion subroutine so that +** the normal whereScanInit() routine, which is a high-runner, does not +** need to push registers onto the stack as part of its prologue. +*/ +static SQLITE_NOINLINE WhereTerm *whereScanInitIndexExpr(WhereScan *pScan){ + pScan->idxaff = sqlite3ExprAffinity(pScan->pIdxExpr); + return whereScanNext(pScan); +} + +/* +** Initialize a WHERE clause scanner object. Return a pointer to the +** first match. Return NULL if there are no matches. +** +** The scanner will be searching the WHERE clause pWC. It will look +** for terms of the form "X " where X is column iColumn of table +** iCur. Or if pIdx!=0 then X is column iColumn of index pIdx. pIdx +** must be one of the indexes of table iCur. +** +** The must be one of the operators described by opMask. +** +** If the search is for X and the WHERE clause contains terms of the +** form X=Y then this routine might also return terms of the form +** "Y ". The number of levels of transitivity is limited, +** but is enough to handle most commonly occurring SQL statements. +** +** If X is not the INTEGER PRIMARY KEY then X must be compatible with +** index pIdx. +*/ +static WhereTerm *whereScanInit( + WhereScan *pScan, /* The WhereScan object being initialized */ + WhereClause *pWC, /* The WHERE clause to be scanned */ + int iCur, /* Cursor to scan for */ + int iColumn, /* Column to scan for */ + u32 opMask, /* Operator(s) to scan for */ + Index *pIdx /* Must be compatible with this index */ +){ + pScan->pOrigWC = pWC; + pScan->pWC = pWC; + pScan->pIdxExpr = 0; + pScan->idxaff = 0; + pScan->zCollName = 0; + pScan->opMask = opMask; + pScan->k = 0; + pScan->aiCur[0] = iCur; + pScan->nEquiv = 1; + pScan->iEquiv = 1; + if( pIdx ){ + int j = iColumn; + iColumn = pIdx->aiColumn[j]; + if( iColumn==pIdx->pTable->iPKey ){ + iColumn = XN_ROWID; + }else if( iColumn>=0 ){ + pScan->idxaff = pIdx->pTable->aCol[iColumn].affinity; + pScan->zCollName = pIdx->azColl[j]; + }else if( iColumn==XN_EXPR ){ + pScan->pIdxExpr = pIdx->aColExpr->a[j].pExpr; + pScan->zCollName = pIdx->azColl[j]; + pScan->aiColumn[0] = XN_EXPR; + return whereScanInitIndexExpr(pScan); + } + }else if( iColumn==XN_EXPR ){ + return 0; + } + pScan->aiColumn[0] = iColumn; + return whereScanNext(pScan); +} + +/* +** Search for a term in the WHERE clause that is of the form "X " +** where X is a reference to the iColumn of table iCur or of index pIdx +** if pIdx!=0 and is one of the WO_xx operator codes specified by +** the op parameter. Return a pointer to the term. Return 0 if not found. +** +** If pIdx!=0 then it must be one of the indexes of table iCur. +** Search for terms matching the iColumn-th column of pIdx +** rather than the iColumn-th column of table iCur. +** +** The term returned might by Y= if there is another constraint in +** the WHERE clause that specifies that X=Y. Any such constraints will be +** identified by the WO_EQUIV bit in the pTerm->eOperator field. The +** aiCur[]/iaColumn[] arrays hold X and all its equivalents. There are 11 +** slots in aiCur[]/aiColumn[] so that means we can look for X plus up to 10 +** other equivalent values. Hence a search for X will return if X=A1 +** and A1=A2 and A2=A3 and ... and A9=A10 and A10=. +** +** If there are multiple terms in the WHERE clause of the form "X " +** then try for the one with no dependencies on - in other words where +** is a constant expression of some kind. Only return entries of +** the form "X Y" where Y is a column in another table if no terms of +** the form "X " exist. If no terms with a constant RHS +** exist, try to return a term that does not use WO_EQUIV. +*/ +SQLITE_PRIVATE WhereTerm *sqlite3WhereFindTerm( + WhereClause *pWC, /* The WHERE clause to be searched */ + int iCur, /* Cursor number of LHS */ + int iColumn, /* Column number of LHS */ + Bitmask notReady, /* RHS must not overlap with this mask */ + u32 op, /* Mask of WO_xx values describing operator */ + Index *pIdx /* Must be compatible with this index, if not NULL */ +){ + WhereTerm *pResult = 0; + WhereTerm *p; + WhereScan scan; + + p = whereScanInit(&scan, pWC, iCur, iColumn, op, pIdx); + op &= WO_EQ|WO_IS; + while( p ){ + if( (p->prereqRight & notReady)==0 ){ + if( p->prereqRight==0 && (p->eOperator&op)!=0 ){ + testcase( p->eOperator & WO_IS ); + return p; + } + if( pResult==0 ) pResult = p; + } + p = whereScanNext(&scan); + } + return pResult; +} + +/* +** This function searches pList for an entry that matches the iCol-th column +** of index pIdx. +** +** If such an expression is found, its index in pList->a[] is returned. If +** no expression is found, -1 is returned. +*/ +static int findIndexCol( + Parse *pParse, /* Parse context */ + ExprList *pList, /* Expression list to search */ + int iBase, /* Cursor for table associated with pIdx */ + Index *pIdx, /* Index to match column of */ + int iCol /* Column of index to match */ +){ + int i; + const char *zColl = pIdx->azColl[iCol]; + + for(i=0; inExpr; i++){ + Expr *p = sqlite3ExprSkipCollateAndLikely(pList->a[i].pExpr); + if( ALWAYS(p!=0) + && (p->op==TK_COLUMN || p->op==TK_AGG_COLUMN) + && p->iColumn==pIdx->aiColumn[iCol] + && p->iTable==iBase + ){ + CollSeq *pColl = sqlite3ExprNNCollSeq(pParse, pList->a[i].pExpr); + if( 0==sqlite3StrICmp(pColl->zName, zColl) ){ + return i; + } + } + } + + return -1; +} + +/* +** Return TRUE if the iCol-th column of index pIdx is NOT NULL +*/ +static int indexColumnNotNull(Index *pIdx, int iCol){ + int j; + assert( pIdx!=0 ); + assert( iCol>=0 && iColnColumn ); + j = pIdx->aiColumn[iCol]; + if( j>=0 ){ + return pIdx->pTable->aCol[j].notNull; + }else if( j==(-1) ){ + return 1; + }else{ + assert( j==(-2) ); + return 0; /* Assume an indexed expression can always yield a NULL */ + + } +} + +/* +** Return true if the DISTINCT expression-list passed as the third argument +** is redundant. +** +** A DISTINCT list is redundant if any subset of the columns in the +** DISTINCT list are collectively unique and individually non-null. +*/ +static int isDistinctRedundant( + Parse *pParse, /* Parsing context */ + SrcList *pTabList, /* The FROM clause */ + WhereClause *pWC, /* The WHERE clause */ + ExprList *pDistinct /* The result set that needs to be DISTINCT */ +){ + Table *pTab; + Index *pIdx; + int i; + int iBase; + + /* If there is more than one table or sub-select in the FROM clause of + ** this query, then it will not be possible to show that the DISTINCT + ** clause is redundant. */ + if( pTabList->nSrc!=1 ) return 0; + iBase = pTabList->a[0].iCursor; + pTab = pTabList->a[0].pTab; + + /* If any of the expressions is an IPK column on table iBase, then return + ** true. Note: The (p->iTable==iBase) part of this test may be false if the + ** current SELECT is a correlated sub-query. + */ + for(i=0; inExpr; i++){ + Expr *p = sqlite3ExprSkipCollateAndLikely(pDistinct->a[i].pExpr); + if( NEVER(p==0) ) continue; + if( p->op!=TK_COLUMN && p->op!=TK_AGG_COLUMN ) continue; + if( p->iTable==iBase && p->iColumn<0 ) return 1; + } + + /* Loop through all indices on the table, checking each to see if it makes + ** the DISTINCT qualifier redundant. It does so if: + ** + ** 1. The index is itself UNIQUE, and + ** + ** 2. All of the columns in the index are either part of the pDistinct + ** list, or else the WHERE clause contains a term of the form "col=X", + ** where X is a constant value. The collation sequences of the + ** comparison and select-list expressions must match those of the index. + ** + ** 3. All of those index columns for which the WHERE clause does not + ** contain a "col=X" term are subject to a NOT NULL constraint. + */ + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + if( !IsUniqueIndex(pIdx) ) continue; + if( pIdx->pPartIdxWhere ) continue; + for(i=0; inKeyCol; i++){ + if( 0==sqlite3WhereFindTerm(pWC, iBase, i, ~(Bitmask)0, WO_EQ, pIdx) ){ + if( findIndexCol(pParse, pDistinct, iBase, pIdx, i)<0 ) break; + if( indexColumnNotNull(pIdx, i)==0 ) break; + } + } + if( i==pIdx->nKeyCol ){ + /* This index implies that the DISTINCT qualifier is redundant. */ + return 1; + } + } + + return 0; +} + + +/* +** Estimate the logarithm of the input value to base 2. +*/ +static LogEst estLog(LogEst N){ + return N<=10 ? 0 : sqlite3LogEst(N) - 33; +} + +/* +** Convert OP_Column opcodes to OP_Copy in previously generated code. +** +** This routine runs over generated VDBE code and translates OP_Column +** opcodes into OP_Copy when the table is being accessed via co-routine +** instead of via table lookup. +** +** If the iAutoidxCur is not zero, then any OP_Rowid instructions on +** cursor iTabCur are transformed into OP_Sequence opcode for the +** iAutoidxCur cursor, in order to generate unique rowids for the +** automatic index being generated. +*/ +static void translateColumnToCopy( + Parse *pParse, /* Parsing context */ + int iStart, /* Translate from this opcode to the end */ + int iTabCur, /* OP_Column/OP_Rowid references to this table */ + int iRegister, /* The first column is in this register */ + int iAutoidxCur /* If non-zero, cursor of autoindex being generated */ +){ + Vdbe *v = pParse->pVdbe; + VdbeOp *pOp = sqlite3VdbeGetOp(v, iStart); + int iEnd = sqlite3VdbeCurrentAddr(v); + if( pParse->db->mallocFailed ) return; + for(; iStartp1!=iTabCur ) continue; + if( pOp->opcode==OP_Column ){ + pOp->opcode = OP_Copy; + pOp->p1 = pOp->p2 + iRegister; + pOp->p2 = pOp->p3; + pOp->p3 = 0; + pOp->p5 = 2; /* Cause the MEM_Subtype flag to be cleared */ + }else if( pOp->opcode==OP_Rowid ){ + pOp->opcode = OP_Sequence; + pOp->p1 = iAutoidxCur; +#ifdef SQLITE_ALLOW_ROWID_IN_VIEW + if( iAutoidxCur==0 ){ + pOp->opcode = OP_Null; + pOp->p3 = 0; + } +#endif + } + } +} + +/* +** Two routines for printing the content of an sqlite3_index_info +** structure. Used for testing and debugging only. If neither +** SQLITE_TEST or SQLITE_DEBUG are defined, then these routines +** are no-ops. +*/ +#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(WHERETRACE_ENABLED) +static void whereTraceIndexInfoInputs(sqlite3_index_info *p){ + int i; + if( (sqlite3WhereTrace & 0x10)==0 ) return; + for(i=0; inConstraint; i++){ + sqlite3DebugPrintf( + " constraint[%d]: col=%d termid=%d op=%d usabled=%d collseq=%s\n", + i, + p->aConstraint[i].iColumn, + p->aConstraint[i].iTermOffset, + p->aConstraint[i].op, + p->aConstraint[i].usable, + sqlite3_vtab_collation(p,i)); + } + for(i=0; inOrderBy; i++){ + sqlite3DebugPrintf(" orderby[%d]: col=%d desc=%d\n", + i, + p->aOrderBy[i].iColumn, + p->aOrderBy[i].desc); + } +} +static void whereTraceIndexInfoOutputs(sqlite3_index_info *p){ + int i; + if( (sqlite3WhereTrace & 0x10)==0 ) return; + for(i=0; inConstraint; i++){ + sqlite3DebugPrintf(" usage[%d]: argvIdx=%d omit=%d\n", + i, + p->aConstraintUsage[i].argvIndex, + p->aConstraintUsage[i].omit); + } + sqlite3DebugPrintf(" idxNum=%d\n", p->idxNum); + sqlite3DebugPrintf(" idxStr=%s\n", p->idxStr); + sqlite3DebugPrintf(" orderByConsumed=%d\n", p->orderByConsumed); + sqlite3DebugPrintf(" estimatedCost=%g\n", p->estimatedCost); + sqlite3DebugPrintf(" estimatedRows=%lld\n", p->estimatedRows); +} +#else +#define whereTraceIndexInfoInputs(A) +#define whereTraceIndexInfoOutputs(A) +#endif + +/* +** We know that pSrc is an operand of an outer join. Return true if +** pTerm is a constraint that is compatible with that join. +** +** pTerm must be EP_OuterON if pSrc is the right operand of an +** outer join. pTerm can be either EP_OuterON or EP_InnerON if pSrc +** is the left operand of a RIGHT join. +** +** See https://sqlite.org/forum/forumpost/206d99a16dd9212f +** for an example of a WHERE clause constraints that may not be used on +** the right table of a RIGHT JOIN because the constraint implies a +** not-NULL condition on the left table of the RIGHT JOIN. +*/ +static int constraintCompatibleWithOuterJoin( + const WhereTerm *pTerm, /* WHERE clause term to check */ + const SrcItem *pSrc /* Table we are trying to access */ +){ + assert( (pSrc->fg.jointype&(JT_LEFT|JT_LTORJ|JT_RIGHT))!=0 ); /* By caller */ + testcase( (pSrc->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT))==JT_LEFT ); + testcase( (pSrc->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT))==JT_LTORJ ); + testcase( ExprHasProperty(pTerm->pExpr, EP_OuterON) ) + testcase( ExprHasProperty(pTerm->pExpr, EP_InnerON) ); + if( !ExprHasProperty(pTerm->pExpr, EP_OuterON|EP_InnerON) + || pTerm->pExpr->w.iJoin != pSrc->iCursor + ){ + return 0; + } + if( (pSrc->fg.jointype & (JT_LEFT|JT_RIGHT))!=0 + && ExprHasProperty(pTerm->pExpr, EP_InnerON) + ){ + return 0; + } + return 1; +} + + + +#ifndef SQLITE_OMIT_AUTOMATIC_INDEX +/* +** Return TRUE if the WHERE clause term pTerm is of a form where it +** could be used with an index to access pSrc, assuming an appropriate +** index existed. +*/ +static int termCanDriveIndex( + const WhereTerm *pTerm, /* WHERE clause term to check */ + const SrcItem *pSrc, /* Table we are trying to access */ + const Bitmask notReady /* Tables in outer loops of the join */ +){ + char aff; + if( pTerm->leftCursor!=pSrc->iCursor ) return 0; + if( (pTerm->eOperator & (WO_EQ|WO_IS))==0 ) return 0; + assert( (pSrc->fg.jointype & JT_RIGHT)==0 ); + if( (pSrc->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT))!=0 + && !constraintCompatibleWithOuterJoin(pTerm,pSrc) + ){ + return 0; /* See https://sqlite.org/forum/forumpost/51e6959f61 */ + } + if( (pTerm->prereqRight & notReady)!=0 ) return 0; + assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 ); + if( pTerm->u.x.leftColumn<0 ) return 0; + aff = pSrc->pTab->aCol[pTerm->u.x.leftColumn].affinity; + if( !sqlite3IndexAffinityOk(pTerm->pExpr, aff) ) return 0; + testcase( pTerm->pExpr->op==TK_IS ); + return 1; +} +#endif + + +#ifndef SQLITE_OMIT_AUTOMATIC_INDEX + +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS +/* +** Argument pIdx represents an automatic index that the current statement +** will create and populate. Add an OP_Explain with text of the form: +** +** CREATE AUTOMATIC INDEX ON
() [WHERE ] +** +** This is only required if sqlite3_stmt_scanstatus() is enabled, to +** associate an SQLITE_SCANSTAT_NCYCLE and SQLITE_SCANSTAT_NLOOP +** values with. In order to avoid breaking legacy code and test cases, +** the OP_Explain is not added if this is an EXPLAIN QUERY PLAN command. +*/ +static void explainAutomaticIndex( + Parse *pParse, + Index *pIdx, /* Automatic index to explain */ + int bPartial, /* True if pIdx is a partial index */ + int *pAddrExplain /* OUT: Address of OP_Explain */ +){ + if( IS_STMT_SCANSTATUS(pParse->db) && pParse->explain!=2 ){ + Table *pTab = pIdx->pTable; + const char *zSep = ""; + char *zText = 0; + int ii = 0; + sqlite3_str *pStr = sqlite3_str_new(pParse->db); + sqlite3_str_appendf(pStr,"CREATE AUTOMATIC INDEX ON %s(", pTab->zName); + assert( pIdx->nColumn>1 ); + assert( pIdx->aiColumn[pIdx->nColumn-1]==XN_ROWID ); + for(ii=0; ii<(pIdx->nColumn-1); ii++){ + const char *zName = 0; + int iCol = pIdx->aiColumn[ii]; + + zName = pTab->aCol[iCol].zCnName; + sqlite3_str_appendf(pStr, "%s%s", zSep, zName); + zSep = ", "; + } + zText = sqlite3_str_finish(pStr); + if( zText==0 ){ + sqlite3OomFault(pParse->db); + }else{ + *pAddrExplain = sqlite3VdbeExplain( + pParse, 0, "%s)%s", zText, (bPartial ? " WHERE " : "") + ); + sqlite3_free(zText); + } + } +} +#else +# define explainAutomaticIndex(a,b,c,d) +#endif + +/* +** Generate code to construct the Index object for an automatic index +** and to set up the WhereLevel object pLevel so that the code generator +** makes use of the automatic index. +*/ +static SQLITE_NOINLINE void constructAutomaticIndex( + Parse *pParse, /* The parsing context */ + WhereClause *pWC, /* The WHERE clause */ + const Bitmask notReady, /* Mask of cursors that are not available */ + WhereLevel *pLevel /* Write new index here */ +){ + int nKeyCol; /* Number of columns in the constructed index */ + WhereTerm *pTerm; /* A single term of the WHERE clause */ + WhereTerm *pWCEnd; /* End of pWC->a[] */ + Index *pIdx; /* Object describing the transient index */ + Vdbe *v; /* Prepared statement under construction */ + int addrInit; /* Address of the initialization bypass jump */ + Table *pTable; /* The table being indexed */ + int addrTop; /* Top of the index fill loop */ + int regRecord; /* Register holding an index record */ + int n; /* Column counter */ + int i; /* Loop counter */ + int mxBitCol; /* Maximum column in pSrc->colUsed */ + CollSeq *pColl; /* Collating sequence to on a column */ + WhereLoop *pLoop; /* The Loop object */ + char *zNotUsed; /* Extra space on the end of pIdx */ + Bitmask idxCols; /* Bitmap of columns used for indexing */ + Bitmask extraCols; /* Bitmap of additional columns */ + u8 sentWarning = 0; /* True if a warning has been issued */ + u8 useBloomFilter = 0; /* True to also add a Bloom filter */ + Expr *pPartial = 0; /* Partial Index Expression */ + int iContinue = 0; /* Jump here to skip excluded rows */ + SrcList *pTabList; /* The complete FROM clause */ + SrcItem *pSrc; /* The FROM clause term to get the next index */ + int addrCounter = 0; /* Address where integer counter is initialized */ + int regBase; /* Array of registers where record is assembled */ +#ifdef SQLITE_ENABLE_STMT_SCANSTATUS + int addrExp = 0; /* Address of OP_Explain */ +#endif + + /* Generate code to skip over the creation and initialization of the + ** transient index on 2nd and subsequent iterations of the loop. */ + v = pParse->pVdbe; + assert( v!=0 ); + addrInit = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); + + /* Count the number of columns that will be added to the index + ** and used to match WHERE clause constraints */ + nKeyCol = 0; + pTabList = pWC->pWInfo->pTabList; + pSrc = &pTabList->a[pLevel->iFrom]; + pTable = pSrc->pTab; + pWCEnd = &pWC->a[pWC->nTerm]; + pLoop = pLevel->pWLoop; + idxCols = 0; + for(pTerm=pWC->a; pTermpExpr; + /* Make the automatic index a partial index if there are terms in the + ** WHERE clause (or the ON clause of a LEFT join) that constrain which + ** rows of the target table (pSrc) that can be used. */ + if( (pTerm->wtFlags & TERM_VIRTUAL)==0 + && sqlite3ExprIsSingleTableConstraint(pExpr, pTabList, pLevel->iFrom) + ){ + pPartial = sqlite3ExprAnd(pParse, pPartial, + sqlite3ExprDup(pParse->db, pExpr, 0)); + } + if( termCanDriveIndex(pTerm, pSrc, notReady) ){ + int iCol; + Bitmask cMask; + assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 ); + iCol = pTerm->u.x.leftColumn; + cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol); + testcase( iCol==BMS ); + testcase( iCol==BMS-1 ); + if( !sentWarning ){ + sqlite3_log(SQLITE_WARNING_AUTOINDEX, + "automatic index on %s(%s)", pTable->zName, + pTable->aCol[iCol].zCnName); + sentWarning = 1; + } + if( (idxCols & cMask)==0 ){ + if( whereLoopResize(pParse->db, pLoop, nKeyCol+1) ){ + goto end_auto_index_create; + } + pLoop->aLTerm[nKeyCol++] = pTerm; + idxCols |= cMask; + } + } + } + assert( nKeyCol>0 || pParse->db->mallocFailed ); + pLoop->u.btree.nEq = pLoop->nLTerm = nKeyCol; + pLoop->wsFlags = WHERE_COLUMN_EQ | WHERE_IDX_ONLY | WHERE_INDEXED + | WHERE_AUTO_INDEX; + + /* Count the number of additional columns needed to create a + ** covering index. A "covering index" is an index that contains all + ** columns that are needed by the query. With a covering index, the + ** original table never needs to be accessed. Automatic indices must + ** be a covering index because the index will not be updated if the + ** original table changes and the index and table cannot both be used + ** if they go out of sync. + */ + if( IsView(pTable) ){ + extraCols = ALLBITS; + }else{ + extraCols = pSrc->colUsed & (~idxCols | MASKBIT(BMS-1)); + } + mxBitCol = MIN(BMS-1,pTable->nCol); + testcase( pTable->nCol==BMS-1 ); + testcase( pTable->nCol==BMS-2 ); + for(i=0; icolUsed & MASKBIT(BMS-1) ){ + nKeyCol += pTable->nCol - BMS + 1; + } + + /* Construct the Index object to describe this index */ + pIdx = sqlite3AllocateIndexObject(pParse->db, nKeyCol+1, 0, &zNotUsed); + if( pIdx==0 ) goto end_auto_index_create; + pLoop->u.btree.pIndex = pIdx; + pIdx->zName = "auto-index"; + pIdx->pTable = pTable; + n = 0; + idxCols = 0; + for(pTerm=pWC->a; pTermeOperator & (WO_OR|WO_AND))==0 ); + iCol = pTerm->u.x.leftColumn; + cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol); + testcase( iCol==BMS-1 ); + testcase( iCol==BMS ); + if( (idxCols & cMask)==0 ){ + Expr *pX = pTerm->pExpr; + idxCols |= cMask; + pIdx->aiColumn[n] = pTerm->u.x.leftColumn; + pColl = sqlite3ExprCompareCollSeq(pParse, pX); + assert( pColl!=0 || pParse->nErr>0 ); /* TH3 collate01.800 */ + pIdx->azColl[n] = pColl ? pColl->zName : sqlite3StrBINARY; + n++; + if( ALWAYS(pX->pLeft!=0) + && sqlite3ExprAffinity(pX->pLeft)!=SQLITE_AFF_TEXT + ){ + /* TUNING: only use a Bloom filter on an automatic index + ** if one or more key columns has the ability to hold numeric + ** values, since strings all have the same hash in the Bloom + ** filter implementation and hence a Bloom filter on a text column + ** is not usually helpful. */ + useBloomFilter = 1; + } + } + } + } + assert( (u32)n==pLoop->u.btree.nEq ); + + /* Add additional columns needed to make the automatic index into + ** a covering index */ + for(i=0; iaiColumn[n] = i; + pIdx->azColl[n] = sqlite3StrBINARY; + n++; + } + } + if( pSrc->colUsed & MASKBIT(BMS-1) ){ + for(i=BMS-1; inCol; i++){ + pIdx->aiColumn[n] = i; + pIdx->azColl[n] = sqlite3StrBINARY; + n++; + } + } + assert( n==nKeyCol ); + pIdx->aiColumn[n] = XN_ROWID; + pIdx->azColl[n] = sqlite3StrBINARY; + + /* Create the automatic index */ + explainAutomaticIndex(pParse, pIdx, pPartial!=0, &addrExp); + assert( pLevel->iIdxCur>=0 ); + pLevel->iIdxCur = pParse->nTab++; + sqlite3VdbeAddOp2(v, OP_OpenAutoindex, pLevel->iIdxCur, nKeyCol+1); + sqlite3VdbeSetP4KeyInfo(pParse, pIdx); + VdbeComment((v, "for %s", pTable->zName)); + if( OptimizationEnabled(pParse->db, SQLITE_BloomFilter) && useBloomFilter ){ + sqlite3WhereExplainBloomFilter(pParse, pWC->pWInfo, pLevel); + pLevel->regFilter = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Blob, 10000, pLevel->regFilter); + } + + /* Fill the automatic index with content */ + assert( pSrc == &pWC->pWInfo->pTabList->a[pLevel->iFrom] ); + if( pSrc->fg.viaCoroutine ){ + int regYield = pSrc->regReturn; + addrCounter = sqlite3VdbeAddOp2(v, OP_Integer, 0, 0); + sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pSrc->addrFillSub); + addrTop = sqlite3VdbeAddOp1(v, OP_Yield, regYield); + VdbeCoverage(v); + VdbeComment((v, "next row of %s", pSrc->pTab->zName)); + }else{ + addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, pLevel->iTabCur); VdbeCoverage(v); + } + if( pPartial ){ + iContinue = sqlite3VdbeMakeLabel(pParse); + sqlite3ExprIfFalse(pParse, pPartial, iContinue, SQLITE_JUMPIFNULL); + pLoop->wsFlags |= WHERE_PARTIALIDX; + } + regRecord = sqlite3GetTempReg(pParse); + regBase = sqlite3GenerateIndexKey( + pParse, pIdx, pLevel->iTabCur, regRecord, 0, 0, 0, 0 + ); + if( pLevel->regFilter ){ + sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pLevel->regFilter, 0, + regBase, pLoop->u.btree.nEq); + } + sqlite3VdbeScanStatusCounters(v, addrExp, addrExp, sqlite3VdbeCurrentAddr(v)); + sqlite3VdbeAddOp2(v, OP_IdxInsert, pLevel->iIdxCur, regRecord); + sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT); + if( pPartial ) sqlite3VdbeResolveLabel(v, iContinue); + if( pSrc->fg.viaCoroutine ){ + sqlite3VdbeChangeP2(v, addrCounter, regBase+n); + testcase( pParse->db->mallocFailed ); + assert( pLevel->iIdxCur>0 ); + translateColumnToCopy(pParse, addrTop, pLevel->iTabCur, + pSrc->regResult, pLevel->iIdxCur); + sqlite3VdbeGoto(v, addrTop); + pSrc->fg.viaCoroutine = 0; + }else{ + sqlite3VdbeAddOp2(v, OP_Next, pLevel->iTabCur, addrTop+1); VdbeCoverage(v); + sqlite3VdbeChangeP5(v, SQLITE_STMTSTATUS_AUTOINDEX); + } + sqlite3VdbeJumpHere(v, addrTop); + sqlite3ReleaseTempReg(pParse, regRecord); + + /* Jump here when skipping the initialization */ + sqlite3VdbeJumpHere(v, addrInit); + sqlite3VdbeScanStatusRange(v, addrExp, addrExp, -1); + +end_auto_index_create: + sqlite3ExprDelete(pParse->db, pPartial); +} +#endif /* SQLITE_OMIT_AUTOMATIC_INDEX */ + +/* +** Generate bytecode that will initialize a Bloom filter that is appropriate +** for pLevel. +** +** If there are inner loops within pLevel that have the WHERE_BLOOMFILTER +** flag set, initialize a Bloomfilter for them as well. Except don't do +** this recursive initialization if the SQLITE_BloomPulldown optimization has +** been turned off. +** +** When the Bloom filter is initialized, the WHERE_BLOOMFILTER flag is cleared +** from the loop, but the regFilter value is set to a register that implements +** the Bloom filter. When regFilter is positive, the +** sqlite3WhereCodeOneLoopStart() will generate code to test the Bloom filter +** and skip the subsequence B-Tree seek if the Bloom filter indicates that +** no matching rows exist. +** +** This routine may only be called if it has previously been determined that +** the loop would benefit from a Bloom filter, and the WHERE_BLOOMFILTER bit +** is set. +*/ +static SQLITE_NOINLINE void sqlite3ConstructBloomFilter( + WhereInfo *pWInfo, /* The WHERE clause */ + int iLevel, /* Index in pWInfo->a[] that is pLevel */ + WhereLevel *pLevel, /* Make a Bloom filter for this FROM term */ + Bitmask notReady /* Loops that are not ready */ +){ + int addrOnce; /* Address of opening OP_Once */ + int addrTop; /* Address of OP_Rewind */ + int addrCont; /* Jump here to skip a row */ + const WhereTerm *pTerm; /* For looping over WHERE clause terms */ + const WhereTerm *pWCEnd; /* Last WHERE clause term */ + Parse *pParse = pWInfo->pParse; /* Parsing context */ + Vdbe *v = pParse->pVdbe; /* VDBE under construction */ + WhereLoop *pLoop = pLevel->pWLoop; /* The loop being coded */ + int iCur; /* Cursor for table getting the filter */ + IndexedExpr *saved_pIdxEpr; /* saved copy of Parse.pIdxEpr */ + + saved_pIdxEpr = pParse->pIdxEpr; + pParse->pIdxEpr = 0; + + assert( pLoop!=0 ); + assert( v!=0 ); + assert( pLoop->wsFlags & WHERE_BLOOMFILTER ); + + addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); + do{ + const SrcList *pTabList; + const SrcItem *pItem; + const Table *pTab; + u64 sz; + int iSrc; + sqlite3WhereExplainBloomFilter(pParse, pWInfo, pLevel); + addrCont = sqlite3VdbeMakeLabel(pParse); + iCur = pLevel->iTabCur; + pLevel->regFilter = ++pParse->nMem; + + /* The Bloom filter is a Blob held in a register. Initialize it + ** to zero-filled blob of at least 80K bits, but maybe more if the + ** estimated size of the table is larger. We could actually + ** measure the size of the table at run-time using OP_Count with + ** P3==1 and use that value to initialize the blob. But that makes + ** testing complicated. By basing the blob size on the value in the + ** sqlite_stat1 table, testing is much easier. + */ + pTabList = pWInfo->pTabList; + iSrc = pLevel->iFrom; + pItem = &pTabList->a[iSrc]; + assert( pItem!=0 ); + pTab = pItem->pTab; + assert( pTab!=0 ); + sz = sqlite3LogEstToInt(pTab->nRowLogEst); + if( sz<10000 ){ + sz = 10000; + }else if( sz>10000000 ){ + sz = 10000000; + } + sqlite3VdbeAddOp2(v, OP_Blob, (int)sz, pLevel->regFilter); + + addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, iCur); VdbeCoverage(v); + pWCEnd = &pWInfo->sWC.a[pWInfo->sWC.nTerm]; + for(pTerm=pWInfo->sWC.a; pTermpExpr; + if( (pTerm->wtFlags & TERM_VIRTUAL)==0 + && sqlite3ExprIsSingleTableConstraint(pExpr, pTabList, iSrc) + ){ + sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL); + } + } + if( pLoop->wsFlags & WHERE_IPK ){ + int r1 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp2(v, OP_Rowid, iCur, r1); + sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pLevel->regFilter, 0, r1, 1); + sqlite3ReleaseTempReg(pParse, r1); + }else{ + Index *pIdx = pLoop->u.btree.pIndex; + int n = pLoop->u.btree.nEq; + int r1 = sqlite3GetTempRange(pParse, n); + int jj; + for(jj=0; jjpTable==pItem->pTab ); + sqlite3ExprCodeLoadIndexColumn(pParse, pIdx, iCur, jj, r1+jj); + } + sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pLevel->regFilter, 0, r1, n); + sqlite3ReleaseTempRange(pParse, r1, n); + } + sqlite3VdbeResolveLabel(v, addrCont); + sqlite3VdbeAddOp2(v, OP_Next, pLevel->iTabCur, addrTop+1); + VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addrTop); + pLoop->wsFlags &= ~WHERE_BLOOMFILTER; + if( OptimizationDisabled(pParse->db, SQLITE_BloomPulldown) ) break; + while( ++iLevel < pWInfo->nLevel ){ + const SrcItem *pTabItem; + pLevel = &pWInfo->a[iLevel]; + pTabItem = &pWInfo->pTabList->a[pLevel->iFrom]; + if( pTabItem->fg.jointype & (JT_LEFT|JT_LTORJ) ) continue; + pLoop = pLevel->pWLoop; + if( NEVER(pLoop==0) ) continue; + if( pLoop->prereq & notReady ) continue; + if( (pLoop->wsFlags & (WHERE_BLOOMFILTER|WHERE_COLUMN_IN)) + ==WHERE_BLOOMFILTER + ){ + /* This is a candidate for bloom-filter pull-down (early evaluation). + ** The test that WHERE_COLUMN_IN is omitted is important, as we are + ** not able to do early evaluation of bloom filters that make use of + ** the IN operator */ + break; + } + } + }while( iLevel < pWInfo->nLevel ); + sqlite3VdbeJumpHere(v, addrOnce); + pParse->pIdxEpr = saved_pIdxEpr; +} + + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/* +** Allocate and populate an sqlite3_index_info structure. It is the +** responsibility of the caller to eventually release the structure +** by passing the pointer returned by this function to freeIndexInfo(). +*/ +static sqlite3_index_info *allocateIndexInfo( + WhereInfo *pWInfo, /* The WHERE clause */ + WhereClause *pWC, /* The WHERE clause being analyzed */ + Bitmask mUnusable, /* Ignore terms with these prereqs */ + SrcItem *pSrc, /* The FROM clause term that is the vtab */ + u16 *pmNoOmit /* Mask of terms not to omit */ +){ + int i, j; + int nTerm; + Parse *pParse = pWInfo->pParse; + struct sqlite3_index_constraint *pIdxCons; + struct sqlite3_index_orderby *pIdxOrderBy; + struct sqlite3_index_constraint_usage *pUsage; + struct HiddenIndexInfo *pHidden; + WhereTerm *pTerm; + int nOrderBy; + sqlite3_index_info *pIdxInfo; + u16 mNoOmit = 0; + const Table *pTab; + int eDistinct = 0; + ExprList *pOrderBy = pWInfo->pOrderBy; + + assert( pSrc!=0 ); + pTab = pSrc->pTab; + assert( pTab!=0 ); + assert( IsVirtual(pTab) ); + + /* Find all WHERE clause constraints referring to this virtual table. + ** Mark each term with the TERM_OK flag. Set nTerm to the number of + ** terms found. + */ + for(i=nTerm=0, pTerm=pWC->a; inTerm; i++, pTerm++){ + pTerm->wtFlags &= ~TERM_OK; + if( pTerm->leftCursor != pSrc->iCursor ) continue; + if( pTerm->prereqRight & mUnusable ) continue; + assert( IsPowerOfTwo(pTerm->eOperator & ~WO_EQUIV) ); + testcase( pTerm->eOperator & WO_IN ); + testcase( pTerm->eOperator & WO_ISNULL ); + testcase( pTerm->eOperator & WO_IS ); + testcase( pTerm->eOperator & WO_ALL ); + if( (pTerm->eOperator & ~(WO_EQUIV))==0 ) continue; + if( pTerm->wtFlags & TERM_VNULL ) continue; + + assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 ); + assert( pTerm->u.x.leftColumn>=XN_ROWID ); + assert( pTerm->u.x.leftColumnnCol ); + if( (pSrc->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT))!=0 + && !constraintCompatibleWithOuterJoin(pTerm,pSrc) + ){ + continue; + } + nTerm++; + pTerm->wtFlags |= TERM_OK; + } + + /* If the ORDER BY clause contains only columns in the current + ** virtual table then allocate space for the aOrderBy part of + ** the sqlite3_index_info structure. + */ + nOrderBy = 0; + if( pOrderBy ){ + int n = pOrderBy->nExpr; + for(i=0; ia[i].pExpr; + Expr *pE2; + + /* Skip over constant terms in the ORDER BY clause */ + if( sqlite3ExprIsConstant(pExpr) ){ + continue; + } + + /* Virtual tables are unable to deal with NULLS FIRST */ + if( pOrderBy->a[i].fg.sortFlags & KEYINFO_ORDER_BIGNULL ) break; + + /* First case - a direct column references without a COLLATE operator */ + if( pExpr->op==TK_COLUMN && pExpr->iTable==pSrc->iCursor ){ + assert( pExpr->iColumn>=XN_ROWID && pExpr->iColumnnCol ); + continue; + } + + /* 2nd case - a column reference with a COLLATE operator. Only match + ** of the COLLATE operator matches the collation of the column. */ + if( pExpr->op==TK_COLLATE + && (pE2 = pExpr->pLeft)->op==TK_COLUMN + && pE2->iTable==pSrc->iCursor + ){ + const char *zColl; /* The collating sequence name */ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + assert( pExpr->u.zToken!=0 ); + assert( pE2->iColumn>=XN_ROWID && pE2->iColumnnCol ); + pExpr->iColumn = pE2->iColumn; + if( pE2->iColumn<0 ) continue; /* Collseq does not matter for rowid */ + zColl = sqlite3ColumnColl(&pTab->aCol[pE2->iColumn]); + if( zColl==0 ) zColl = sqlite3StrBINARY; + if( sqlite3_stricmp(pExpr->u.zToken, zColl)==0 ) continue; + } + + /* No matches cause a break out of the loop */ + break; + } + if( i==n ){ + nOrderBy = n; + if( (pWInfo->wctrlFlags & WHERE_DISTINCTBY) ){ + eDistinct = 2 + ((pWInfo->wctrlFlags & WHERE_SORTBYGROUP)!=0); + }else if( pWInfo->wctrlFlags & WHERE_GROUPBY ){ + eDistinct = 1; + } + } + } + + /* Allocate the sqlite3_index_info structure + */ + pIdxInfo = sqlite3DbMallocZero(pParse->db, sizeof(*pIdxInfo) + + (sizeof(*pIdxCons) + sizeof(*pUsage))*nTerm + + sizeof(*pIdxOrderBy)*nOrderBy + sizeof(*pHidden) + + sizeof(sqlite3_value*)*nTerm ); + if( pIdxInfo==0 ){ + sqlite3ErrorMsg(pParse, "out of memory"); + return 0; + } + pHidden = (struct HiddenIndexInfo*)&pIdxInfo[1]; + pIdxCons = (struct sqlite3_index_constraint*)&pHidden->aRhs[nTerm]; + pIdxOrderBy = (struct sqlite3_index_orderby*)&pIdxCons[nTerm]; + pUsage = (struct sqlite3_index_constraint_usage*)&pIdxOrderBy[nOrderBy]; + pIdxInfo->aConstraint = pIdxCons; + pIdxInfo->aOrderBy = pIdxOrderBy; + pIdxInfo->aConstraintUsage = pUsage; + pHidden->pWC = pWC; + pHidden->pParse = pParse; + pHidden->eDistinct = eDistinct; + pHidden->mIn = 0; + for(i=j=0, pTerm=pWC->a; inTerm; i++, pTerm++){ + u16 op; + if( (pTerm->wtFlags & TERM_OK)==0 ) continue; + pIdxCons[j].iColumn = pTerm->u.x.leftColumn; + pIdxCons[j].iTermOffset = i; + op = pTerm->eOperator & WO_ALL; + if( op==WO_IN ){ + if( (pTerm->wtFlags & TERM_SLICE)==0 ){ + pHidden->mIn |= SMASKBIT32(j); + } + op = WO_EQ; + } + if( op==WO_AUX ){ + pIdxCons[j].op = pTerm->eMatchOp; + }else if( op & (WO_ISNULL|WO_IS) ){ + if( op==WO_ISNULL ){ + pIdxCons[j].op = SQLITE_INDEX_CONSTRAINT_ISNULL; + }else{ + pIdxCons[j].op = SQLITE_INDEX_CONSTRAINT_IS; + } + }else{ + pIdxCons[j].op = (u8)op; + /* The direct assignment in the previous line is possible only because + ** the WO_ and SQLITE_INDEX_CONSTRAINT_ codes are identical. The + ** following asserts verify this fact. */ + assert( WO_EQ==SQLITE_INDEX_CONSTRAINT_EQ ); + assert( WO_LT==SQLITE_INDEX_CONSTRAINT_LT ); + assert( WO_LE==SQLITE_INDEX_CONSTRAINT_LE ); + assert( WO_GT==SQLITE_INDEX_CONSTRAINT_GT ); + assert( WO_GE==SQLITE_INDEX_CONSTRAINT_GE ); + assert( pTerm->eOperator&(WO_IN|WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE|WO_AUX) ); + + if( op & (WO_LT|WO_LE|WO_GT|WO_GE) + && sqlite3ExprIsVector(pTerm->pExpr->pRight) + ){ + testcase( j!=i ); + if( j<16 ) mNoOmit |= (1 << j); + if( op==WO_LT ) pIdxCons[j].op = WO_LE; + if( op==WO_GT ) pIdxCons[j].op = WO_GE; + } + } + + j++; + } + assert( j==nTerm ); + pIdxInfo->nConstraint = j; + for(i=j=0; ia[i].pExpr; + if( sqlite3ExprIsConstant(pExpr) ) continue; + assert( pExpr->op==TK_COLUMN + || (pExpr->op==TK_COLLATE && pExpr->pLeft->op==TK_COLUMN + && pExpr->iColumn==pExpr->pLeft->iColumn) ); + pIdxOrderBy[j].iColumn = pExpr->iColumn; + pIdxOrderBy[j].desc = pOrderBy->a[i].fg.sortFlags & KEYINFO_ORDER_DESC; + j++; + } + pIdxInfo->nOrderBy = j; + + *pmNoOmit = mNoOmit; + return pIdxInfo; +} + +/* +** Free an sqlite3_index_info structure allocated by allocateIndexInfo() +** and possibly modified by xBestIndex methods. +*/ +static void freeIndexInfo(sqlite3 *db, sqlite3_index_info *pIdxInfo){ + HiddenIndexInfo *pHidden; + int i; + assert( pIdxInfo!=0 ); + pHidden = (HiddenIndexInfo*)&pIdxInfo[1]; + assert( pHidden->pParse!=0 ); + assert( pHidden->pParse->db==db ); + for(i=0; inConstraint; i++){ + sqlite3ValueFree(pHidden->aRhs[i]); /* IMP: R-14553-25174 */ + pHidden->aRhs[i] = 0; + } + sqlite3DbFree(db, pIdxInfo); +} + +/* +** The table object reference passed as the second argument to this function +** must represent a virtual table. This function invokes the xBestIndex() +** method of the virtual table with the sqlite3_index_info object that +** comes in as the 3rd argument to this function. +** +** If an error occurs, pParse is populated with an error message and an +** appropriate error code is returned. A return of SQLITE_CONSTRAINT from +** xBestIndex is not considered an error. SQLITE_CONSTRAINT indicates that +** the current configuration of "unusable" flags in sqlite3_index_info can +** not result in a valid plan. +** +** Whether or not an error is returned, it is the responsibility of the +** caller to eventually free p->idxStr if p->needToFreeIdxStr indicates +** that this is required. +*/ +static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){ + sqlite3_vtab *pVtab = sqlite3GetVTable(pParse->db, pTab)->pVtab; + int rc; + + whereTraceIndexInfoInputs(p); + pParse->db->nSchemaLock++; + rc = pVtab->pModule->xBestIndex(pVtab, p); + pParse->db->nSchemaLock--; + whereTraceIndexInfoOutputs(p); + + if( rc!=SQLITE_OK && rc!=SQLITE_CONSTRAINT ){ + if( rc==SQLITE_NOMEM ){ + sqlite3OomFault(pParse->db); + }else if( !pVtab->zErrMsg ){ + sqlite3ErrorMsg(pParse, "%s", sqlite3ErrStr(rc)); + }else{ + sqlite3ErrorMsg(pParse, "%s", pVtab->zErrMsg); + } + } + if( pTab->u.vtab.p->bAllSchemas ){ + sqlite3VtabUsesAllSchemas(pParse); + } + sqlite3_free(pVtab->zErrMsg); + pVtab->zErrMsg = 0; + return rc; +} +#endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) */ + +#ifdef SQLITE_ENABLE_STAT4 +/* +** Estimate the location of a particular key among all keys in an +** index. Store the results in aStat as follows: +** +** aStat[0] Est. number of rows less than pRec +** aStat[1] Est. number of rows equal to pRec +** +** Return the index of the sample that is the smallest sample that +** is greater than or equal to pRec. Note that this index is not an index +** into the aSample[] array - it is an index into a virtual set of samples +** based on the contents of aSample[] and the number of fields in record +** pRec. +*/ +static int whereKeyStats( + Parse *pParse, /* Database connection */ + Index *pIdx, /* Index to consider domain of */ + UnpackedRecord *pRec, /* Vector of values to consider */ + int roundUp, /* Round up if true. Round down if false */ + tRowcnt *aStat /* OUT: stats written here */ +){ + IndexSample *aSample = pIdx->aSample; + int iCol; /* Index of required stats in anEq[] etc. */ + int i; /* Index of first sample >= pRec */ + int iSample; /* Smallest sample larger than or equal to pRec */ + int iMin = 0; /* Smallest sample not yet tested */ + int iTest; /* Next sample to test */ + int res; /* Result of comparison operation */ + int nField; /* Number of fields in pRec */ + tRowcnt iLower = 0; /* anLt[] + anEq[] of largest sample pRec is > */ + +#ifndef SQLITE_DEBUG + UNUSED_PARAMETER( pParse ); +#endif + assert( pRec!=0 ); + assert( pIdx->nSample>0 ); + assert( pRec->nField>0 ); + + + /* Do a binary search to find the first sample greater than or equal + ** to pRec. If pRec contains a single field, the set of samples to search + ** is simply the aSample[] array. If the samples in aSample[] contain more + ** than one fields, all fields following the first are ignored. + ** + ** If pRec contains N fields, where N is more than one, then as well as the + ** samples in aSample[] (truncated to N fields), the search also has to + ** consider prefixes of those samples. For example, if the set of samples + ** in aSample is: + ** + ** aSample[0] = (a, 5) + ** aSample[1] = (a, 10) + ** aSample[2] = (b, 5) + ** aSample[3] = (c, 100) + ** aSample[4] = (c, 105) + ** + ** Then the search space should ideally be the samples above and the + ** unique prefixes [a], [b] and [c]. But since that is hard to organize, + ** the code actually searches this set: + ** + ** 0: (a) + ** 1: (a, 5) + ** 2: (a, 10) + ** 3: (a, 10) + ** 4: (b) + ** 5: (b, 5) + ** 6: (c) + ** 7: (c, 100) + ** 8: (c, 105) + ** 9: (c, 105) + ** + ** For each sample in the aSample[] array, N samples are present in the + ** effective sample array. In the above, samples 0 and 1 are based on + ** sample aSample[0]. Samples 2 and 3 on aSample[1] etc. + ** + ** Often, sample i of each block of N effective samples has (i+1) fields. + ** Except, each sample may be extended to ensure that it is greater than or + ** equal to the previous sample in the array. For example, in the above, + ** sample 2 is the first sample of a block of N samples, so at first it + ** appears that it should be 1 field in size. However, that would make it + ** smaller than sample 1, so the binary search would not work. As a result, + ** it is extended to two fields. The duplicates that this creates do not + ** cause any problems. + */ + if( !HasRowid(pIdx->pTable) && IsPrimaryKeyIndex(pIdx) ){ + nField = pIdx->nKeyCol; + }else{ + nField = pIdx->nColumn; + } + nField = MIN(pRec->nField, nField); + iCol = 0; + iSample = pIdx->nSample * nField; + do{ + int iSamp; /* Index in aSample[] of test sample */ + int n; /* Number of fields in test sample */ + + iTest = (iMin+iSample)/2; + iSamp = iTest / nField; + if( iSamp>0 ){ + /* The proposed effective sample is a prefix of sample aSample[iSamp]. + ** Specifically, the shortest prefix of at least (1 + iTest%nField) + ** fields that is greater than the previous effective sample. */ + for(n=(iTest % nField) + 1; nnField = n; + res = sqlite3VdbeRecordCompare(aSample[iSamp].n, aSample[iSamp].p, pRec); + if( res<0 ){ + iLower = aSample[iSamp].anLt[n-1] + aSample[iSamp].anEq[n-1]; + iMin = iTest+1; + }else if( res==0 && ndb->mallocFailed==0 ){ + if( res==0 ){ + /* If (res==0) is true, then pRec must be equal to sample i. */ + assert( inSample ); + assert( iCol==nField-1 ); + pRec->nField = nField; + assert( 0==sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec) + || pParse->db->mallocFailed + ); + }else{ + /* Unless i==pIdx->nSample, indicating that pRec is larger than + ** all samples in the aSample[] array, pRec must be smaller than the + ** (iCol+1) field prefix of sample i. */ + assert( i<=pIdx->nSample && i>=0 ); + pRec->nField = iCol+1; + assert( i==pIdx->nSample + || sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec)>0 + || pParse->db->mallocFailed ); + + /* if i==0 and iCol==0, then record pRec is smaller than all samples + ** in the aSample[] array. Otherwise, if (iCol>0) then pRec must + ** be greater than or equal to the (iCol) field prefix of sample i. + ** If (i>0), then pRec must also be greater than sample (i-1). */ + if( iCol>0 ){ + pRec->nField = iCol; + assert( sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec)<=0 + || pParse->db->mallocFailed || CORRUPT_DB ); + } + if( i>0 ){ + pRec->nField = nField; + assert( sqlite3VdbeRecordCompare(aSample[i-1].n, aSample[i-1].p, pRec)<0 + || pParse->db->mallocFailed || CORRUPT_DB ); + } + } + } +#endif /* ifdef SQLITE_DEBUG */ + + if( res==0 ){ + /* Record pRec is equal to sample i */ + assert( iCol==nField-1 ); + aStat[0] = aSample[i].anLt[iCol]; + aStat[1] = aSample[i].anEq[iCol]; + }else{ + /* At this point, the (iCol+1) field prefix of aSample[i] is the first + ** sample that is greater than pRec. Or, if i==pIdx->nSample then pRec + ** is larger than all samples in the array. */ + tRowcnt iUpper, iGap; + if( i>=pIdx->nSample ){ + iUpper = pIdx->nRowEst0; + }else{ + iUpper = aSample[i].anLt[iCol]; + } + + if( iLower>=iUpper ){ + iGap = 0; + }else{ + iGap = iUpper - iLower; + } + if( roundUp ){ + iGap = (iGap*2)/3; + }else{ + iGap = iGap/3; + } + aStat[0] = iLower + iGap; + aStat[1] = pIdx->aAvgEq[nField-1]; + } + + /* Restore the pRec->nField value before returning. */ + pRec->nField = nField; + return i; +} +#endif /* SQLITE_ENABLE_STAT4 */ + +/* +** If it is not NULL, pTerm is a term that provides an upper or lower +** bound on a range scan. Without considering pTerm, it is estimated +** that the scan will visit nNew rows. This function returns the number +** estimated to be visited after taking pTerm into account. +** +** If the user explicitly specified a likelihood() value for this term, +** then the return value is the likelihood multiplied by the number of +** input rows. Otherwise, this function assumes that an "IS NOT NULL" term +** has a likelihood of 0.50, and any other term a likelihood of 0.25. +*/ +static LogEst whereRangeAdjust(WhereTerm *pTerm, LogEst nNew){ + LogEst nRet = nNew; + if( pTerm ){ + if( pTerm->truthProb<=0 ){ + nRet += pTerm->truthProb; + }else if( (pTerm->wtFlags & TERM_VNULL)==0 ){ + nRet -= 20; assert( 20==sqlite3LogEst(4) ); + } + } + return nRet; +} + + +#ifdef SQLITE_ENABLE_STAT4 +/* +** Return the affinity for a single column of an index. +*/ +SQLITE_PRIVATE char sqlite3IndexColumnAffinity(sqlite3 *db, Index *pIdx, int iCol){ + assert( iCol>=0 && iColnColumn ); + if( !pIdx->zColAff ){ + if( sqlite3IndexAffinityStr(db, pIdx)==0 ) return SQLITE_AFF_BLOB; + } + assert( pIdx->zColAff[iCol]!=0 ); + return pIdx->zColAff[iCol]; +} +#endif + + +#ifdef SQLITE_ENABLE_STAT4 +/* +** This function is called to estimate the number of rows visited by a +** range-scan on a skip-scan index. For example: +** +** CREATE INDEX i1 ON t1(a, b, c); +** SELECT * FROM t1 WHERE a=? AND c BETWEEN ? AND ?; +** +** Value pLoop->nOut is currently set to the estimated number of rows +** visited for scanning (a=? AND b=?). This function reduces that estimate +** by some factor to account for the (c BETWEEN ? AND ?) expression based +** on the stat4 data for the index. this scan will be peformed multiple +** times (once for each (a,b) combination that matches a=?) is dealt with +** by the caller. +** +** It does this by scanning through all stat4 samples, comparing values +** extracted from pLower and pUpper with the corresponding column in each +** sample. If L and U are the number of samples found to be less than or +** equal to the values extracted from pLower and pUpper respectively, and +** N is the total number of samples, the pLoop->nOut value is adjusted +** as follows: +** +** nOut = nOut * ( min(U - L, 1) / N ) +** +** If pLower is NULL, or a value cannot be extracted from the term, L is +** set to zero. If pUpper is NULL, or a value cannot be extracted from it, +** U is set to N. +** +** Normally, this function sets *pbDone to 1 before returning. However, +** if no value can be extracted from either pLower or pUpper (and so the +** estimate of the number of rows delivered remains unchanged), *pbDone +** is left as is. +** +** If an error occurs, an SQLite error code is returned. Otherwise, +** SQLITE_OK. +*/ +static int whereRangeSkipScanEst( + Parse *pParse, /* Parsing & code generating context */ + WhereTerm *pLower, /* Lower bound on the range. ex: "x>123" Might be NULL */ + WhereTerm *pUpper, /* Upper bound on the range. ex: "x<455" Might be NULL */ + WhereLoop *pLoop, /* Update the .nOut value of this loop */ + int *pbDone /* Set to true if at least one expr. value extracted */ +){ + Index *p = pLoop->u.btree.pIndex; + int nEq = pLoop->u.btree.nEq; + sqlite3 *db = pParse->db; + int nLower = -1; + int nUpper = p->nSample+1; + int rc = SQLITE_OK; + u8 aff = sqlite3IndexColumnAffinity(db, p, nEq); + CollSeq *pColl; + + sqlite3_value *p1 = 0; /* Value extracted from pLower */ + sqlite3_value *p2 = 0; /* Value extracted from pUpper */ + sqlite3_value *pVal = 0; /* Value extracted from record */ + + pColl = sqlite3LocateCollSeq(pParse, p->azColl[nEq]); + if( pLower ){ + rc = sqlite3Stat4ValueFromExpr(pParse, pLower->pExpr->pRight, aff, &p1); + nLower = 0; + } + if( pUpper && rc==SQLITE_OK ){ + rc = sqlite3Stat4ValueFromExpr(pParse, pUpper->pExpr->pRight, aff, &p2); + nUpper = p2 ? 0 : p->nSample; + } + + if( p1 || p2 ){ + int i; + int nDiff; + for(i=0; rc==SQLITE_OK && inSample; i++){ + rc = sqlite3Stat4Column(db, p->aSample[i].p, p->aSample[i].n, nEq, &pVal); + if( rc==SQLITE_OK && p1 ){ + int res = sqlite3MemCompare(p1, pVal, pColl); + if( res>=0 ) nLower++; + } + if( rc==SQLITE_OK && p2 ){ + int res = sqlite3MemCompare(p2, pVal, pColl); + if( res>=0 ) nUpper++; + } + } + nDiff = (nUpper - nLower); + if( nDiff<=0 ) nDiff = 1; + + /* If there is both an upper and lower bound specified, and the + ** comparisons indicate that they are close together, use the fallback + ** method (assume that the scan visits 1/64 of the rows) for estimating + ** the number of rows visited. Otherwise, estimate the number of rows + ** using the method described in the header comment for this function. */ + if( nDiff!=1 || pUpper==0 || pLower==0 ){ + int nAdjust = (sqlite3LogEst(p->nSample) - sqlite3LogEst(nDiff)); + pLoop->nOut -= nAdjust; + *pbDone = 1; + WHERETRACE(0x20, ("range skip-scan regions: %u..%u adjust=%d est=%d\n", + nLower, nUpper, nAdjust*-1, pLoop->nOut)); + } + + }else{ + assert( *pbDone==0 ); + } + + sqlite3ValueFree(p1); + sqlite3ValueFree(p2); + sqlite3ValueFree(pVal); + + return rc; +} +#endif /* SQLITE_ENABLE_STAT4 */ + +/* +** This function is used to estimate the number of rows that will be visited +** by scanning an index for a range of values. The range may have an upper +** bound, a lower bound, or both. The WHERE clause terms that set the upper +** and lower bounds are represented by pLower and pUpper respectively. For +** example, assuming that index p is on t1(a): +** +** ... FROM t1 WHERE a > ? AND a < ? ... +** |_____| |_____| +** | | +** pLower pUpper +** +** If either of the upper or lower bound is not present, then NULL is passed in +** place of the corresponding WhereTerm. +** +** The value in (pBuilder->pNew->u.btree.nEq) is the number of the index +** column subject to the range constraint. Or, equivalently, the number of +** equality constraints optimized by the proposed index scan. For example, +** assuming index p is on t1(a, b), and the SQL query is: +** +** ... FROM t1 WHERE a = ? AND b > ? AND b < ? ... +** +** then nEq is set to 1 (as the range restricted column, b, is the second +** left-most column of the index). Or, if the query is: +** +** ... FROM t1 WHERE a > ? AND a < ? ... +** +** then nEq is set to 0. +** +** When this function is called, *pnOut is set to the sqlite3LogEst() of the +** number of rows that the index scan is expected to visit without +** considering the range constraints. If nEq is 0, then *pnOut is the number of +** rows in the index. Assuming no error occurs, *pnOut is adjusted (reduced) +** to account for the range constraints pLower and pUpper. +** +** In the absence of sqlite_stat4 ANALYZE data, or if such data cannot be +** used, a single range inequality reduces the search space by a factor of 4. +** and a pair of constraints (x>? AND x123" Might be NULL */ + WhereTerm *pUpper, /* Upper bound on the range. ex: "x<455" Might be NULL */ + WhereLoop *pLoop /* Modify the .nOut and maybe .rRun fields */ +){ + int rc = SQLITE_OK; + int nOut = pLoop->nOut; + LogEst nNew; + +#ifdef SQLITE_ENABLE_STAT4 + Index *p = pLoop->u.btree.pIndex; + int nEq = pLoop->u.btree.nEq; + + if( p->nSample>0 && ALWAYS(nEqnSampleCol) + && OptimizationEnabled(pParse->db, SQLITE_Stat4) + ){ + if( nEq==pBuilder->nRecValid ){ + UnpackedRecord *pRec = pBuilder->pRec; + tRowcnt a[2]; + int nBtm = pLoop->u.btree.nBtm; + int nTop = pLoop->u.btree.nTop; + + /* Variable iLower will be set to the estimate of the number of rows in + ** the index that are less than the lower bound of the range query. The + ** lower bound being the concatenation of $P and $L, where $P is the + ** key-prefix formed by the nEq values matched against the nEq left-most + ** columns of the index, and $L is the value in pLower. + ** + ** Or, if pLower is NULL or $L cannot be extracted from it (because it + ** is not a simple variable or literal value), the lower bound of the + ** range is $P. Due to a quirk in the way whereKeyStats() works, even + ** if $L is available, whereKeyStats() is called for both ($P) and + ** ($P:$L) and the larger of the two returned values is used. + ** + ** Similarly, iUpper is to be set to the estimate of the number of rows + ** less than the upper bound of the range query. Where the upper bound + ** is either ($P) or ($P:$U). Again, even if $U is available, both values + ** of iUpper are requested of whereKeyStats() and the smaller used. + ** + ** The number of rows between the two bounds is then just iUpper-iLower. + */ + tRowcnt iLower; /* Rows less than the lower bound */ + tRowcnt iUpper; /* Rows less than the upper bound */ + int iLwrIdx = -2; /* aSample[] for the lower bound */ + int iUprIdx = -1; /* aSample[] for the upper bound */ + + if( pRec ){ + testcase( pRec->nField!=pBuilder->nRecValid ); + pRec->nField = pBuilder->nRecValid; + } + /* Determine iLower and iUpper using ($P) only. */ + if( nEq==0 ){ + iLower = 0; + iUpper = p->nRowEst0; + }else{ + /* Note: this call could be optimized away - since the same values must + ** have been requested when testing key $P in whereEqualScanEst(). */ + whereKeyStats(pParse, p, pRec, 0, a); + iLower = a[0]; + iUpper = a[0] + a[1]; + } + + assert( pLower==0 || (pLower->eOperator & (WO_GT|WO_GE))!=0 ); + assert( pUpper==0 || (pUpper->eOperator & (WO_LT|WO_LE))!=0 ); + assert( p->aSortOrder!=0 ); + if( p->aSortOrder[nEq] ){ + /* The roles of pLower and pUpper are swapped for a DESC index */ + SWAP(WhereTerm*, pLower, pUpper); + SWAP(int, nBtm, nTop); + } + + /* If possible, improve on the iLower estimate using ($P:$L). */ + if( pLower ){ + int n; /* Values extracted from pExpr */ + Expr *pExpr = pLower->pExpr->pRight; + rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, nBtm, nEq, &n); + if( rc==SQLITE_OK && n ){ + tRowcnt iNew; + u16 mask = WO_GT|WO_LE; + if( sqlite3ExprVectorSize(pExpr)>n ) mask = (WO_LE|WO_LT); + iLwrIdx = whereKeyStats(pParse, p, pRec, 0, a); + iNew = a[0] + ((pLower->eOperator & mask) ? a[1] : 0); + if( iNew>iLower ) iLower = iNew; + nOut--; + pLower = 0; + } + } + + /* If possible, improve on the iUpper estimate using ($P:$U). */ + if( pUpper ){ + int n; /* Values extracted from pExpr */ + Expr *pExpr = pUpper->pExpr->pRight; + rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, nTop, nEq, &n); + if( rc==SQLITE_OK && n ){ + tRowcnt iNew; + u16 mask = WO_GT|WO_LE; + if( sqlite3ExprVectorSize(pExpr)>n ) mask = (WO_LE|WO_LT); + iUprIdx = whereKeyStats(pParse, p, pRec, 1, a); + iNew = a[0] + ((pUpper->eOperator & mask) ? a[1] : 0); + if( iNewpRec = pRec; + if( rc==SQLITE_OK ){ + if( iUpper>iLower ){ + nNew = sqlite3LogEst(iUpper - iLower); + /* TUNING: If both iUpper and iLower are derived from the same + ** sample, then assume they are 4x more selective. This brings + ** the estimated selectivity more in line with what it would be + ** if estimated without the use of STAT4 tables. */ + if( iLwrIdx==iUprIdx ) nNew -= 20; assert( 20==sqlite3LogEst(4) ); + }else{ + nNew = 10; assert( 10==sqlite3LogEst(2) ); + } + if( nNewwtFlags & TERM_VNULL)==0 || pParse->nErr>0 ); + nNew = whereRangeAdjust(pLower, nOut); + nNew = whereRangeAdjust(pUpper, nNew); + + /* TUNING: If there is both an upper and lower limit and neither limit + ** has an application-defined likelihood(), assume the range is + ** reduced by an additional 75%. This means that, by default, an open-ended + ** range query (e.g. col > ?) is assumed to match 1/4 of the rows in the + ** index. While a closed range (e.g. col BETWEEN ? AND ?) is estimated to + ** match 1/64 of the index. */ + if( pLower && pLower->truthProb>0 && pUpper && pUpper->truthProb>0 ){ + nNew -= 20; + } + + nOut -= (pLower!=0) + (pUpper!=0); + if( nNew<10 ) nNew = 10; + if( nNewnOut>nOut ){ + WHERETRACE(0x20,("Range scan lowers nOut from %d to %d\n", + pLoop->nOut, nOut)); + } +#endif + pLoop->nOut = (LogEst)nOut; + return rc; +} + +#ifdef SQLITE_ENABLE_STAT4 +/* +** Estimate the number of rows that will be returned based on +** an equality constraint x=VALUE and where that VALUE occurs in +** the histogram data. This only works when x is the left-most +** column of an index and sqlite_stat4 histogram data is available +** for that index. When pExpr==NULL that means the constraint is +** "x IS NULL" instead of "x=VALUE". +** +** Write the estimated row count into *pnRow and return SQLITE_OK. +** If unable to make an estimate, leave *pnRow unchanged and return +** non-zero. +** +** This routine can fail if it is unable to load a collating sequence +** required for string comparison, or if unable to allocate memory +** for a UTF conversion required for comparison. The error is stored +** in the pParse structure. +*/ +static int whereEqualScanEst( + Parse *pParse, /* Parsing & code generating context */ + WhereLoopBuilder *pBuilder, + Expr *pExpr, /* Expression for VALUE in the x=VALUE constraint */ + tRowcnt *pnRow /* Write the revised row estimate here */ +){ + Index *p = pBuilder->pNew->u.btree.pIndex; + int nEq = pBuilder->pNew->u.btree.nEq; + UnpackedRecord *pRec = pBuilder->pRec; + int rc; /* Subfunction return code */ + tRowcnt a[2]; /* Statistics */ + int bOk; + + assert( nEq>=1 ); + assert( nEq<=p->nColumn ); + assert( p->aSample!=0 ); + assert( p->nSample>0 ); + assert( pBuilder->nRecValidnRecValid<(nEq-1) ){ + return SQLITE_NOTFOUND; + } + + /* This is an optimization only. The call to sqlite3Stat4ProbeSetValue() + ** below would return the same value. */ + if( nEq>=p->nColumn ){ + *pnRow = 1; + return SQLITE_OK; + } + + rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, 1, nEq-1, &bOk); + pBuilder->pRec = pRec; + if( rc!=SQLITE_OK ) return rc; + if( bOk==0 ) return SQLITE_NOTFOUND; + pBuilder->nRecValid = nEq; + + whereKeyStats(pParse, p, pRec, 0, a); + WHERETRACE(0x20,("equality scan regions %s(%d): %d\n", + p->zName, nEq-1, (int)a[1])); + *pnRow = a[1]; + + return rc; +} +#endif /* SQLITE_ENABLE_STAT4 */ + +#ifdef SQLITE_ENABLE_STAT4 +/* +** Estimate the number of rows that will be returned based on +** an IN constraint where the right-hand side of the IN operator +** is a list of values. Example: +** +** WHERE x IN (1,2,3,4) +** +** Write the estimated row count into *pnRow and return SQLITE_OK. +** If unable to make an estimate, leave *pnRow unchanged and return +** non-zero. +** +** This routine can fail if it is unable to load a collating sequence +** required for string comparison, or if unable to allocate memory +** for a UTF conversion required for comparison. The error is stored +** in the pParse structure. +*/ +static int whereInScanEst( + Parse *pParse, /* Parsing & code generating context */ + WhereLoopBuilder *pBuilder, + ExprList *pList, /* The value list on the RHS of "x IN (v1,v2,v3,...)" */ + tRowcnt *pnRow /* Write the revised row estimate here */ +){ + Index *p = pBuilder->pNew->u.btree.pIndex; + i64 nRow0 = sqlite3LogEstToInt(p->aiRowLogEst[0]); + int nRecValid = pBuilder->nRecValid; + int rc = SQLITE_OK; /* Subfunction return code */ + tRowcnt nEst; /* Number of rows for a single term */ + tRowcnt nRowEst = 0; /* New estimate of the number of rows */ + int i; /* Loop counter */ + + assert( p->aSample!=0 ); + for(i=0; rc==SQLITE_OK && inExpr; i++){ + nEst = nRow0; + rc = whereEqualScanEst(pParse, pBuilder, pList->a[i].pExpr, &nEst); + nRowEst += nEst; + pBuilder->nRecValid = nRecValid; + } + + if( rc==SQLITE_OK ){ + if( nRowEst > (tRowcnt)nRow0 ) nRowEst = nRow0; + *pnRow = nRowEst; + WHERETRACE(0x20,("IN row estimate: est=%d\n", nRowEst)); + } + assert( pBuilder->nRecValid==nRecValid ); + return rc; +} +#endif /* SQLITE_ENABLE_STAT4 */ + + +#ifdef WHERETRACE_ENABLED +/* +** Print the content of a WhereTerm object +*/ +SQLITE_PRIVATE void sqlite3WhereTermPrint(WhereTerm *pTerm, int iTerm){ + if( pTerm==0 ){ + sqlite3DebugPrintf("TERM-%-3d NULL\n", iTerm); + }else{ + char zType[8]; + char zLeft[50]; + memcpy(zType, "....", 5); + if( pTerm->wtFlags & TERM_VIRTUAL ) zType[0] = 'V'; + if( pTerm->eOperator & WO_EQUIV ) zType[1] = 'E'; + if( ExprHasProperty(pTerm->pExpr, EP_OuterON) ) zType[2] = 'L'; + if( pTerm->wtFlags & TERM_CODED ) zType[3] = 'C'; + if( pTerm->eOperator & WO_SINGLE ){ + assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 ); + sqlite3_snprintf(sizeof(zLeft),zLeft,"left={%d:%d}", + pTerm->leftCursor, pTerm->u.x.leftColumn); + }else if( (pTerm->eOperator & WO_OR)!=0 && pTerm->u.pOrInfo!=0 ){ + sqlite3_snprintf(sizeof(zLeft),zLeft,"indexable=0x%llx", + pTerm->u.pOrInfo->indexable); + }else{ + sqlite3_snprintf(sizeof(zLeft),zLeft,"left=%d", pTerm->leftCursor); + } + sqlite3DebugPrintf( + "TERM-%-3d %p %s %-12s op=%03x wtFlags=%04x", + iTerm, pTerm, zType, zLeft, pTerm->eOperator, pTerm->wtFlags); + /* The 0x10000 .wheretrace flag causes extra information to be + ** shown about each Term */ + if( sqlite3WhereTrace & 0x10000 ){ + sqlite3DebugPrintf(" prob=%-3d prereq=%llx,%llx", + pTerm->truthProb, (u64)pTerm->prereqAll, (u64)pTerm->prereqRight); + } + if( (pTerm->eOperator & (WO_OR|WO_AND))==0 && pTerm->u.x.iField ){ + sqlite3DebugPrintf(" iField=%d", pTerm->u.x.iField); + } + if( pTerm->iParent>=0 ){ + sqlite3DebugPrintf(" iParent=%d", pTerm->iParent); + } + sqlite3DebugPrintf("\n"); + sqlite3TreeViewExpr(0, pTerm->pExpr, 0); + } +} +#endif + +#ifdef WHERETRACE_ENABLED +/* +** Show the complete content of a WhereClause +*/ +SQLITE_PRIVATE void sqlite3WhereClausePrint(WhereClause *pWC){ + int i; + for(i=0; inTerm; i++){ + sqlite3WhereTermPrint(&pWC->a[i], i); + } +} +#endif + +#ifdef WHERETRACE_ENABLED +/* +** Print a WhereLoop object for debugging purposes +*/ +SQLITE_PRIVATE void sqlite3WhereLoopPrint(WhereLoop *p, WhereClause *pWC){ + WhereInfo *pWInfo = pWC->pWInfo; + int nb = 1+(pWInfo->pTabList->nSrc+3)/4; + SrcItem *pItem = pWInfo->pTabList->a + p->iTab; + Table *pTab = pItem->pTab; + Bitmask mAll = (((Bitmask)1)<<(nb*4)) - 1; + sqlite3DebugPrintf("%c%2d.%0*llx.%0*llx", p->cId, + p->iTab, nb, p->maskSelf, nb, p->prereq & mAll); + sqlite3DebugPrintf(" %12s", + pItem->zAlias ? pItem->zAlias : pTab->zName); + if( (p->wsFlags & WHERE_VIRTUALTABLE)==0 ){ + const char *zName; + if( p->u.btree.pIndex && (zName = p->u.btree.pIndex->zName)!=0 ){ + if( strncmp(zName, "sqlite_autoindex_", 17)==0 ){ + int i = sqlite3Strlen30(zName) - 1; + while( zName[i]!='_' ) i--; + zName += i; + } + sqlite3DebugPrintf(".%-16s %2d", zName, p->u.btree.nEq); + }else{ + sqlite3DebugPrintf("%20s",""); + } + }else{ + char *z; + if( p->u.vtab.idxStr ){ + z = sqlite3_mprintf("(%d,\"%s\",%#x)", + p->u.vtab.idxNum, p->u.vtab.idxStr, p->u.vtab.omitMask); + }else{ + z = sqlite3_mprintf("(%d,%x)", p->u.vtab.idxNum, p->u.vtab.omitMask); + } + sqlite3DebugPrintf(" %-19s", z); + sqlite3_free(z); + } + if( p->wsFlags & WHERE_SKIPSCAN ){ + sqlite3DebugPrintf(" f %06x %d-%d", p->wsFlags, p->nLTerm,p->nSkip); + }else{ + sqlite3DebugPrintf(" f %06x N %d", p->wsFlags, p->nLTerm); + } + sqlite3DebugPrintf(" cost %d,%d,%d\n", p->rSetup, p->rRun, p->nOut); + if( p->nLTerm && (sqlite3WhereTrace & 0x4000)!=0 ){ + int i; + for(i=0; inLTerm; i++){ + sqlite3WhereTermPrint(p->aLTerm[i], i); + } + } +} +#endif + +/* +** Convert bulk memory into a valid WhereLoop that can be passed +** to whereLoopClear harmlessly. +*/ +static void whereLoopInit(WhereLoop *p){ + p->aLTerm = p->aLTermSpace; + p->nLTerm = 0; + p->nLSlot = ArraySize(p->aLTermSpace); + p->wsFlags = 0; +} + +/* +** Clear the WhereLoop.u union. Leave WhereLoop.pLTerm intact. +*/ +static void whereLoopClearUnion(sqlite3 *db, WhereLoop *p){ + if( p->wsFlags & (WHERE_VIRTUALTABLE|WHERE_AUTO_INDEX) ){ + if( (p->wsFlags & WHERE_VIRTUALTABLE)!=0 && p->u.vtab.needFree ){ + sqlite3_free(p->u.vtab.idxStr); + p->u.vtab.needFree = 0; + p->u.vtab.idxStr = 0; + }else if( (p->wsFlags & WHERE_AUTO_INDEX)!=0 && p->u.btree.pIndex!=0 ){ + sqlite3DbFree(db, p->u.btree.pIndex->zColAff); + sqlite3DbFreeNN(db, p->u.btree.pIndex); + p->u.btree.pIndex = 0; + } + } +} + +/* +** Deallocate internal memory used by a WhereLoop object. Leave the +** object in an initialized state, as if it had been newly allocated. +*/ +static void whereLoopClear(sqlite3 *db, WhereLoop *p){ + if( p->aLTerm!=p->aLTermSpace ){ + sqlite3DbFreeNN(db, p->aLTerm); + p->aLTerm = p->aLTermSpace; + p->nLSlot = ArraySize(p->aLTermSpace); + } + whereLoopClearUnion(db, p); + p->nLTerm = 0; + p->wsFlags = 0; +} + +/* +** Increase the memory allocation for pLoop->aLTerm[] to be at least n. +*/ +static int whereLoopResize(sqlite3 *db, WhereLoop *p, int n){ + WhereTerm **paNew; + if( p->nLSlot>=n ) return SQLITE_OK; + n = (n+7)&~7; + paNew = sqlite3DbMallocRawNN(db, sizeof(p->aLTerm[0])*n); + if( paNew==0 ) return SQLITE_NOMEM_BKPT; + memcpy(paNew, p->aLTerm, sizeof(p->aLTerm[0])*p->nLSlot); + if( p->aLTerm!=p->aLTermSpace ) sqlite3DbFreeNN(db, p->aLTerm); + p->aLTerm = paNew; + p->nLSlot = n; + return SQLITE_OK; +} + +/* +** Transfer content from the second pLoop into the first. +*/ +static int whereLoopXfer(sqlite3 *db, WhereLoop *pTo, WhereLoop *pFrom){ + whereLoopClearUnion(db, pTo); + if( pFrom->nLTerm > pTo->nLSlot + && whereLoopResize(db, pTo, pFrom->nLTerm) + ){ + memset(pTo, 0, WHERE_LOOP_XFER_SZ); + return SQLITE_NOMEM_BKPT; + } + memcpy(pTo, pFrom, WHERE_LOOP_XFER_SZ); + memcpy(pTo->aLTerm, pFrom->aLTerm, pTo->nLTerm*sizeof(pTo->aLTerm[0])); + if( pFrom->wsFlags & WHERE_VIRTUALTABLE ){ + pFrom->u.vtab.needFree = 0; + }else if( (pFrom->wsFlags & WHERE_AUTO_INDEX)!=0 ){ + pFrom->u.btree.pIndex = 0; + } + return SQLITE_OK; +} + +/* +** Delete a WhereLoop object +*/ +static void whereLoopDelete(sqlite3 *db, WhereLoop *p){ + assert( db!=0 ); + whereLoopClear(db, p); + sqlite3DbNNFreeNN(db, p); +} + +/* +** Free a WhereInfo structure +*/ +static void whereInfoFree(sqlite3 *db, WhereInfo *pWInfo){ + assert( pWInfo!=0 ); + assert( db!=0 ); + sqlite3WhereClauseClear(&pWInfo->sWC); + while( pWInfo->pLoops ){ + WhereLoop *p = pWInfo->pLoops; + pWInfo->pLoops = p->pNextLoop; + whereLoopDelete(db, p); + } + while( pWInfo->pMemToFree ){ + WhereMemBlock *pNext = pWInfo->pMemToFree->pNext; + sqlite3DbNNFreeNN(db, pWInfo->pMemToFree); + pWInfo->pMemToFree = pNext; + } + sqlite3DbNNFreeNN(db, pWInfo); +} + +/* +** Return TRUE if all of the following are true: +** +** (1) X has the same or lower cost, or returns the same or fewer rows, +** than Y. +** (2) X uses fewer WHERE clause terms than Y +** (3) Every WHERE clause term used by X is also used by Y +** (4) X skips at least as many columns as Y +** (5) If X is a covering index, than Y is too +** +** Conditions (2) and (3) mean that X is a "proper subset" of Y. +** If X is a proper subset of Y then Y is a better choice and ought +** to have a lower cost. This routine returns TRUE when that cost +** relationship is inverted and needs to be adjusted. Constraint (4) +** was added because if X uses skip-scan less than Y it still might +** deserve a lower cost even if it is a proper subset of Y. Constraint (5) +** was added because a covering index probably deserves to have a lower cost +** than a non-covering index even if it is a proper subset. +*/ +static int whereLoopCheaperProperSubset( + const WhereLoop *pX, /* First WhereLoop to compare */ + const WhereLoop *pY /* Compare against this WhereLoop */ +){ + int i, j; + if( pX->nLTerm-pX->nSkip >= pY->nLTerm-pY->nSkip ){ + return 0; /* X is not a subset of Y */ + } + if( pX->rRun>pY->rRun && pX->nOut>pY->nOut ) return 0; + if( pY->nSkip > pX->nSkip ) return 0; + for(i=pX->nLTerm-1; i>=0; i--){ + if( pX->aLTerm[i]==0 ) continue; + for(j=pY->nLTerm-1; j>=0; j--){ + if( pY->aLTerm[j]==pX->aLTerm[i] ) break; + } + if( j<0 ) return 0; /* X not a subset of Y since term X[i] not used by Y */ + } + if( (pX->wsFlags&WHERE_IDX_ONLY)!=0 + && (pY->wsFlags&WHERE_IDX_ONLY)==0 ){ + return 0; /* Constraint (5) */ + } + return 1; /* All conditions meet */ +} + +/* +** Try to adjust the cost and number of output rows of WhereLoop pTemplate +** upwards or downwards so that: +** +** (1) pTemplate costs less than any other WhereLoops that are a proper +** subset of pTemplate +** +** (2) pTemplate costs more than any other WhereLoops for which pTemplate +** is a proper subset. +** +** To say "WhereLoop X is a proper subset of Y" means that X uses fewer +** WHERE clause terms than Y and that every WHERE clause term used by X is +** also used by Y. +*/ +static void whereLoopAdjustCost(const WhereLoop *p, WhereLoop *pTemplate){ + if( (pTemplate->wsFlags & WHERE_INDEXED)==0 ) return; + for(; p; p=p->pNextLoop){ + if( p->iTab!=pTemplate->iTab ) continue; + if( (p->wsFlags & WHERE_INDEXED)==0 ) continue; + if( whereLoopCheaperProperSubset(p, pTemplate) ){ + /* Adjust pTemplate cost downward so that it is cheaper than its + ** subset p. */ + WHERETRACE(0x80,("subset cost adjustment %d,%d to %d,%d\n", + pTemplate->rRun, pTemplate->nOut, + MIN(p->rRun, pTemplate->rRun), + MIN(p->nOut - 1, pTemplate->nOut))); + pTemplate->rRun = MIN(p->rRun, pTemplate->rRun); + pTemplate->nOut = MIN(p->nOut - 1, pTemplate->nOut); + }else if( whereLoopCheaperProperSubset(pTemplate, p) ){ + /* Adjust pTemplate cost upward so that it is costlier than p since + ** pTemplate is a proper subset of p */ + WHERETRACE(0x80,("subset cost adjustment %d,%d to %d,%d\n", + pTemplate->rRun, pTemplate->nOut, + MAX(p->rRun, pTemplate->rRun), + MAX(p->nOut + 1, pTemplate->nOut))); + pTemplate->rRun = MAX(p->rRun, pTemplate->rRun); + pTemplate->nOut = MAX(p->nOut + 1, pTemplate->nOut); + } + } +} + +/* +** Search the list of WhereLoops in *ppPrev looking for one that can be +** replaced by pTemplate. +** +** Return NULL if pTemplate does not belong on the WhereLoop list. +** In other words if pTemplate ought to be dropped from further consideration. +** +** If pX is a WhereLoop that pTemplate can replace, then return the +** link that points to pX. +** +** If pTemplate cannot replace any existing element of the list but needs +** to be added to the list as a new entry, then return a pointer to the +** tail of the list. +*/ +static WhereLoop **whereLoopFindLesser( + WhereLoop **ppPrev, + const WhereLoop *pTemplate +){ + WhereLoop *p; + for(p=(*ppPrev); p; ppPrev=&p->pNextLoop, p=*ppPrev){ + if( p->iTab!=pTemplate->iTab || p->iSortIdx!=pTemplate->iSortIdx ){ + /* If either the iTab or iSortIdx values for two WhereLoop are different + ** then those WhereLoops need to be considered separately. Neither is + ** a candidate to replace the other. */ + continue; + } + /* In the current implementation, the rSetup value is either zero + ** or the cost of building an automatic index (NlogN) and the NlogN + ** is the same for compatible WhereLoops. */ + assert( p->rSetup==0 || pTemplate->rSetup==0 + || p->rSetup==pTemplate->rSetup ); + + /* whereLoopAddBtree() always generates and inserts the automatic index + ** case first. Hence compatible candidate WhereLoops never have a larger + ** rSetup. Call this SETUP-INVARIANT */ + assert( p->rSetup>=pTemplate->rSetup ); + + /* Any loop using an appliation-defined index (or PRIMARY KEY or + ** UNIQUE constraint) with one or more == constraints is better + ** than an automatic index. Unless it is a skip-scan. */ + if( (p->wsFlags & WHERE_AUTO_INDEX)!=0 + && (pTemplate->nSkip)==0 + && (pTemplate->wsFlags & WHERE_INDEXED)!=0 + && (pTemplate->wsFlags & WHERE_COLUMN_EQ)!=0 + && (p->prereq & pTemplate->prereq)==pTemplate->prereq + ){ + break; + } + + /* If existing WhereLoop p is better than pTemplate, pTemplate can be + ** discarded. WhereLoop p is better if: + ** (1) p has no more dependencies than pTemplate, and + ** (2) p has an equal or lower cost than pTemplate + */ + if( (p->prereq & pTemplate->prereq)==p->prereq /* (1) */ + && p->rSetup<=pTemplate->rSetup /* (2a) */ + && p->rRun<=pTemplate->rRun /* (2b) */ + && p->nOut<=pTemplate->nOut /* (2c) */ + ){ + return 0; /* Discard pTemplate */ + } + + /* If pTemplate is always better than p, then cause p to be overwritten + ** with pTemplate. pTemplate is better than p if: + ** (1) pTemplate has no more dependences than p, and + ** (2) pTemplate has an equal or lower cost than p. + */ + if( (p->prereq & pTemplate->prereq)==pTemplate->prereq /* (1) */ + && p->rRun>=pTemplate->rRun /* (2a) */ + && p->nOut>=pTemplate->nOut /* (2b) */ + ){ + assert( p->rSetup>=pTemplate->rSetup ); /* SETUP-INVARIANT above */ + break; /* Cause p to be overwritten by pTemplate */ + } + } + return ppPrev; +} + +/* +** Insert or replace a WhereLoop entry using the template supplied. +** +** An existing WhereLoop entry might be overwritten if the new template +** is better and has fewer dependencies. Or the template will be ignored +** and no insert will occur if an existing WhereLoop is faster and has +** fewer dependencies than the template. Otherwise a new WhereLoop is +** added based on the template. +** +** If pBuilder->pOrSet is not NULL then we care about only the +** prerequisites and rRun and nOut costs of the N best loops. That +** information is gathered in the pBuilder->pOrSet object. This special +** processing mode is used only for OR clause processing. +** +** When accumulating multiple loops (when pBuilder->pOrSet is NULL) we +** still might overwrite similar loops with the new template if the +** new template is better. Loops may be overwritten if the following +** conditions are met: +** +** (1) They have the same iTab. +** (2) They have the same iSortIdx. +** (3) The template has same or fewer dependencies than the current loop +** (4) The template has the same or lower cost than the current loop +*/ +static int whereLoopInsert(WhereLoopBuilder *pBuilder, WhereLoop *pTemplate){ + WhereLoop **ppPrev, *p; + WhereInfo *pWInfo = pBuilder->pWInfo; + sqlite3 *db = pWInfo->pParse->db; + int rc; + + /* Stop the search once we hit the query planner search limit */ + if( pBuilder->iPlanLimit==0 ){ + WHERETRACE(0xffffffff,("=== query planner search limit reached ===\n")); + if( pBuilder->pOrSet ) pBuilder->pOrSet->n = 0; + return SQLITE_DONE; + } + pBuilder->iPlanLimit--; + + whereLoopAdjustCost(pWInfo->pLoops, pTemplate); + + /* If pBuilder->pOrSet is defined, then only keep track of the costs + ** and prereqs. + */ + if( pBuilder->pOrSet!=0 ){ + if( pTemplate->nLTerm ){ +#if WHERETRACE_ENABLED + u16 n = pBuilder->pOrSet->n; + int x = +#endif + whereOrInsert(pBuilder->pOrSet, pTemplate->prereq, pTemplate->rRun, + pTemplate->nOut); +#if WHERETRACE_ENABLED /* 0x8 */ + if( sqlite3WhereTrace & 0x8 ){ + sqlite3DebugPrintf(x?" or-%d: ":" or-X: ", n); + sqlite3WhereLoopPrint(pTemplate, pBuilder->pWC); + } +#endif + } + return SQLITE_OK; + } + + /* Look for an existing WhereLoop to replace with pTemplate + */ + ppPrev = whereLoopFindLesser(&pWInfo->pLoops, pTemplate); + + if( ppPrev==0 ){ + /* There already exists a WhereLoop on the list that is better + ** than pTemplate, so just ignore pTemplate */ +#if WHERETRACE_ENABLED /* 0x8 */ + if( sqlite3WhereTrace & 0x8 ){ + sqlite3DebugPrintf(" skip: "); + sqlite3WhereLoopPrint(pTemplate, pBuilder->pWC); + } +#endif + return SQLITE_OK; + }else{ + p = *ppPrev; + } + + /* If we reach this point it means that either p[] should be overwritten + ** with pTemplate[] if p[] exists, or if p==NULL then allocate a new + ** WhereLoop and insert it. + */ +#if WHERETRACE_ENABLED /* 0x8 */ + if( sqlite3WhereTrace & 0x8 ){ + if( p!=0 ){ + sqlite3DebugPrintf("replace: "); + sqlite3WhereLoopPrint(p, pBuilder->pWC); + sqlite3DebugPrintf(" with: "); + }else{ + sqlite3DebugPrintf(" add: "); + } + sqlite3WhereLoopPrint(pTemplate, pBuilder->pWC); + } +#endif + if( p==0 ){ + /* Allocate a new WhereLoop to add to the end of the list */ + *ppPrev = p = sqlite3DbMallocRawNN(db, sizeof(WhereLoop)); + if( p==0 ) return SQLITE_NOMEM_BKPT; + whereLoopInit(p); + p->pNextLoop = 0; + }else{ + /* We will be overwriting WhereLoop p[]. But before we do, first + ** go through the rest of the list and delete any other entries besides + ** p[] that are also supplated by pTemplate */ + WhereLoop **ppTail = &p->pNextLoop; + WhereLoop *pToDel; + while( *ppTail ){ + ppTail = whereLoopFindLesser(ppTail, pTemplate); + if( ppTail==0 ) break; + pToDel = *ppTail; + if( pToDel==0 ) break; + *ppTail = pToDel->pNextLoop; +#if WHERETRACE_ENABLED /* 0x8 */ + if( sqlite3WhereTrace & 0x8 ){ + sqlite3DebugPrintf(" delete: "); + sqlite3WhereLoopPrint(pToDel, pBuilder->pWC); + } +#endif + whereLoopDelete(db, pToDel); + } + } + rc = whereLoopXfer(db, p, pTemplate); + if( (p->wsFlags & WHERE_VIRTUALTABLE)==0 ){ + Index *pIndex = p->u.btree.pIndex; + if( pIndex && pIndex->idxType==SQLITE_IDXTYPE_IPK ){ + p->u.btree.pIndex = 0; + } + } + return rc; +} + +/* +** Adjust the WhereLoop.nOut value downward to account for terms of the +** WHERE clause that reference the loop but which are not used by an +** index. +* +** For every WHERE clause term that is not used by the index +** and which has a truth probability assigned by one of the likelihood(), +** likely(), or unlikely() SQL functions, reduce the estimated number +** of output rows by the probability specified. +** +** TUNING: For every WHERE clause term that is not used by the index +** and which does not have an assigned truth probability, heuristics +** described below are used to try to estimate the truth probability. +** TODO --> Perhaps this is something that could be improved by better +** table statistics. +** +** Heuristic 1: Estimate the truth probability as 93.75%. The 93.75% +** value corresponds to -1 in LogEst notation, so this means decrement +** the WhereLoop.nOut field for every such WHERE clause term. +** +** Heuristic 2: If there exists one or more WHERE clause terms of the +** form "x==EXPR" and EXPR is not a constant 0 or 1, then make sure the +** final output row estimate is no greater than 1/4 of the total number +** of rows in the table. In other words, assume that x==EXPR will filter +** out at least 3 out of 4 rows. If EXPR is -1 or 0 or 1, then maybe the +** "x" column is boolean or else -1 or 0 or 1 is a common default value +** on the "x" column and so in that case only cap the output row estimate +** at 1/2 instead of 1/4. +*/ +static void whereLoopOutputAdjust( + WhereClause *pWC, /* The WHERE clause */ + WhereLoop *pLoop, /* The loop to adjust downward */ + LogEst nRow /* Number of rows in the entire table */ +){ + WhereTerm *pTerm, *pX; + Bitmask notAllowed = ~(pLoop->prereq|pLoop->maskSelf); + int i, j; + LogEst iReduce = 0; /* pLoop->nOut should not exceed nRow-iReduce */ + + assert( (pLoop->wsFlags & WHERE_AUTO_INDEX)==0 ); + for(i=pWC->nBase, pTerm=pWC->a; i>0; i--, pTerm++){ + assert( pTerm!=0 ); + if( (pTerm->prereqAll & notAllowed)!=0 ) continue; + if( (pTerm->prereqAll & pLoop->maskSelf)==0 ) continue; + if( (pTerm->wtFlags & TERM_VIRTUAL)!=0 ) continue; + for(j=pLoop->nLTerm-1; j>=0; j--){ + pX = pLoop->aLTerm[j]; + if( pX==0 ) continue; + if( pX==pTerm ) break; + if( pX->iParent>=0 && (&pWC->a[pX->iParent])==pTerm ) break; + } + if( j<0 ){ + sqlite3ProgressCheck(pWC->pWInfo->pParse); + if( pLoop->maskSelf==pTerm->prereqAll ){ + /* If there are extra terms in the WHERE clause not used by an index + ** that depend only on the table being scanned, and that will tend to + ** cause many rows to be omitted, then mark that table as + ** "self-culling". + ** + ** 2022-03-24: Self-culling only applies if either the extra terms + ** are straight comparison operators that are non-true with NULL + ** operand, or if the loop is not an OUTER JOIN. + */ + if( (pTerm->eOperator & 0x3f)!=0 + || (pWC->pWInfo->pTabList->a[pLoop->iTab].fg.jointype + & (JT_LEFT|JT_LTORJ))==0 + ){ + pLoop->wsFlags |= WHERE_SELFCULL; + } + } + if( pTerm->truthProb<=0 ){ + /* If a truth probability is specified using the likelihood() hints, + ** then use the probability provided by the application. */ + pLoop->nOut += pTerm->truthProb; + }else{ + /* In the absence of explicit truth probabilities, use heuristics to + ** guess a reasonable truth probability. */ + pLoop->nOut--; + if( (pTerm->eOperator&(WO_EQ|WO_IS))!=0 + && (pTerm->wtFlags & TERM_HIGHTRUTH)==0 /* tag-20200224-1 */ + ){ + Expr *pRight = pTerm->pExpr->pRight; + int k = 0; + testcase( pTerm->pExpr->op==TK_IS ); + if( sqlite3ExprIsInteger(pRight, &k) && k>=(-1) && k<=1 ){ + k = 10; + }else{ + k = 20; + } + if( iReducewtFlags |= TERM_HEURTRUTH; + iReduce = k; + } + } + } + } + } + if( pLoop->nOut > nRow-iReduce ){ + pLoop->nOut = nRow - iReduce; + } +} + +/* +** Term pTerm is a vector range comparison operation. The first comparison +** in the vector can be optimized using column nEq of the index. This +** function returns the total number of vector elements that can be used +** as part of the range comparison. +** +** For example, if the query is: +** +** WHERE a = ? AND (b, c, d) > (?, ?, ?) +** +** and the index: +** +** CREATE INDEX ... ON (a, b, c, d, e) +** +** then this function would be invoked with nEq=1. The value returned in +** this case is 3. +*/ +static int whereRangeVectorLen( + Parse *pParse, /* Parsing context */ + int iCur, /* Cursor open on pIdx */ + Index *pIdx, /* The index to be used for a inequality constraint */ + int nEq, /* Number of prior equality constraints on same index */ + WhereTerm *pTerm /* The vector inequality constraint */ +){ + int nCmp = sqlite3ExprVectorSize(pTerm->pExpr->pLeft); + int i; + + nCmp = MIN(nCmp, (pIdx->nColumn - nEq)); + for(i=1; ipExpr->pLeft) ); + pLhs = pTerm->pExpr->pLeft->x.pList->a[i].pExpr; + pRhs = pTerm->pExpr->pRight; + if( ExprUseXSelect(pRhs) ){ + pRhs = pRhs->x.pSelect->pEList->a[i].pExpr; + }else{ + pRhs = pRhs->x.pList->a[i].pExpr; + } + + /* Check that the LHS of the comparison is a column reference to + ** the right column of the right source table. And that the sort + ** order of the index column is the same as the sort order of the + ** leftmost index column. */ + if( pLhs->op!=TK_COLUMN + || pLhs->iTable!=iCur + || pLhs->iColumn!=pIdx->aiColumn[i+nEq] + || pIdx->aSortOrder[i+nEq]!=pIdx->aSortOrder[nEq] + ){ + break; + } + + testcase( pLhs->iColumn==XN_ROWID ); + aff = sqlite3CompareAffinity(pRhs, sqlite3ExprAffinity(pLhs)); + idxaff = sqlite3TableColumnAffinity(pIdx->pTable, pLhs->iColumn); + if( aff!=idxaff ) break; + + pColl = sqlite3BinaryCompareCollSeq(pParse, pLhs, pRhs); + if( pColl==0 ) break; + if( sqlite3StrICmp(pColl->zName, pIdx->azColl[i+nEq]) ) break; + } + return i; +} + +/* +** Adjust the cost C by the costMult facter T. This only occurs if +** compiled with -DSQLITE_ENABLE_COSTMULT +*/ +#ifdef SQLITE_ENABLE_COSTMULT +# define ApplyCostMultiplier(C,T) C += T +#else +# define ApplyCostMultiplier(C,T) +#endif + +/* +** We have so far matched pBuilder->pNew->u.btree.nEq terms of the +** index pIndex. Try to match one more. +** +** When this function is called, pBuilder->pNew->nOut contains the +** number of rows expected to be visited by filtering using the nEq +** terms only. If it is modified, this value is restored before this +** function returns. +** +** If pProbe->idxType==SQLITE_IDXTYPE_IPK, that means pIndex is +** a fake index used for the INTEGER PRIMARY KEY. +*/ +static int whereLoopAddBtreeIndex( + WhereLoopBuilder *pBuilder, /* The WhereLoop factory */ + SrcItem *pSrc, /* FROM clause term being analyzed */ + Index *pProbe, /* An index on pSrc */ + LogEst nInMul /* log(Number of iterations due to IN) */ +){ + WhereInfo *pWInfo = pBuilder->pWInfo; /* WHERE analyse context */ + Parse *pParse = pWInfo->pParse; /* Parsing context */ + sqlite3 *db = pParse->db; /* Database connection malloc context */ + WhereLoop *pNew; /* Template WhereLoop under construction */ + WhereTerm *pTerm; /* A WhereTerm under consideration */ + int opMask; /* Valid operators for constraints */ + WhereScan scan; /* Iterator for WHERE terms */ + Bitmask saved_prereq; /* Original value of pNew->prereq */ + u16 saved_nLTerm; /* Original value of pNew->nLTerm */ + u16 saved_nEq; /* Original value of pNew->u.btree.nEq */ + u16 saved_nBtm; /* Original value of pNew->u.btree.nBtm */ + u16 saved_nTop; /* Original value of pNew->u.btree.nTop */ + u16 saved_nSkip; /* Original value of pNew->nSkip */ + u32 saved_wsFlags; /* Original value of pNew->wsFlags */ + LogEst saved_nOut; /* Original value of pNew->nOut */ + int rc = SQLITE_OK; /* Return code */ + LogEst rSize; /* Number of rows in the table */ + LogEst rLogSize; /* Logarithm of table size */ + WhereTerm *pTop = 0, *pBtm = 0; /* Top and bottom range constraints */ + + pNew = pBuilder->pNew; + assert( db->mallocFailed==0 || pParse->nErr>0 ); + if( pParse->nErr ){ + return pParse->rc; + } + WHERETRACE(0x800, ("BEGIN %s.addBtreeIdx(%s), nEq=%d, nSkip=%d, rRun=%d\n", + pProbe->pTable->zName,pProbe->zName, + pNew->u.btree.nEq, pNew->nSkip, pNew->rRun)); + + assert( (pNew->wsFlags & WHERE_VIRTUALTABLE)==0 ); + assert( (pNew->wsFlags & WHERE_TOP_LIMIT)==0 ); + if( pNew->wsFlags & WHERE_BTM_LIMIT ){ + opMask = WO_LT|WO_LE; + }else{ + assert( pNew->u.btree.nBtm==0 ); + opMask = WO_EQ|WO_IN|WO_GT|WO_GE|WO_LT|WO_LE|WO_ISNULL|WO_IS; + } + if( pProbe->bUnordered ) opMask &= ~(WO_GT|WO_GE|WO_LT|WO_LE); + + assert( pNew->u.btree.nEqnColumn ); + assert( pNew->u.btree.nEqnKeyCol + || pProbe->idxType!=SQLITE_IDXTYPE_PRIMARYKEY ); + + saved_nEq = pNew->u.btree.nEq; + saved_nBtm = pNew->u.btree.nBtm; + saved_nTop = pNew->u.btree.nTop; + saved_nSkip = pNew->nSkip; + saved_nLTerm = pNew->nLTerm; + saved_wsFlags = pNew->wsFlags; + saved_prereq = pNew->prereq; + saved_nOut = pNew->nOut; + pTerm = whereScanInit(&scan, pBuilder->pWC, pSrc->iCursor, saved_nEq, + opMask, pProbe); + pNew->rSetup = 0; + rSize = pProbe->aiRowLogEst[0]; + rLogSize = estLog(rSize); + for(; rc==SQLITE_OK && pTerm!=0; pTerm = whereScanNext(&scan)){ + u16 eOp = pTerm->eOperator; /* Shorthand for pTerm->eOperator */ + LogEst rCostIdx; + LogEst nOutUnadjusted; /* nOut before IN() and WHERE adjustments */ + int nIn = 0; +#ifdef SQLITE_ENABLE_STAT4 + int nRecValid = pBuilder->nRecValid; +#endif + if( (eOp==WO_ISNULL || (pTerm->wtFlags&TERM_VNULL)!=0) + && indexColumnNotNull(pProbe, saved_nEq) + ){ + continue; /* ignore IS [NOT] NULL constraints on NOT NULL columns */ + } + if( pTerm->prereqRight & pNew->maskSelf ) continue; + + /* Do not allow the upper bound of a LIKE optimization range constraint + ** to mix with a lower range bound from some other source */ + if( pTerm->wtFlags & TERM_LIKEOPT && pTerm->eOperator==WO_LT ) continue; + + if( (pSrc->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT))!=0 + && !constraintCompatibleWithOuterJoin(pTerm,pSrc) + ){ + continue; + } + if( IsUniqueIndex(pProbe) && saved_nEq==pProbe->nKeyCol-1 ){ + pBuilder->bldFlags1 |= SQLITE_BLDF1_UNIQUE; + }else{ + pBuilder->bldFlags1 |= SQLITE_BLDF1_INDEXED; + } + pNew->wsFlags = saved_wsFlags; + pNew->u.btree.nEq = saved_nEq; + pNew->u.btree.nBtm = saved_nBtm; + pNew->u.btree.nTop = saved_nTop; + pNew->nLTerm = saved_nLTerm; + if( pNew->nLTerm>=pNew->nLSlot + && whereLoopResize(db, pNew, pNew->nLTerm+1) + ){ + break; /* OOM while trying to enlarge the pNew->aLTerm array */ + } + pNew->aLTerm[pNew->nLTerm++] = pTerm; + pNew->prereq = (saved_prereq | pTerm->prereqRight) & ~pNew->maskSelf; + + assert( nInMul==0 + || (pNew->wsFlags & WHERE_COLUMN_NULL)!=0 + || (pNew->wsFlags & WHERE_COLUMN_IN)!=0 + || (pNew->wsFlags & WHERE_SKIPSCAN)!=0 + ); + + if( eOp & WO_IN ){ + Expr *pExpr = pTerm->pExpr; + if( ExprUseXSelect(pExpr) ){ + /* "x IN (SELECT ...)": TUNING: the SELECT returns 25 rows */ + int i; + nIn = 46; assert( 46==sqlite3LogEst(25) ); + + /* The expression may actually be of the form (x, y) IN (SELECT...). + ** In this case there is a separate term for each of (x) and (y). + ** However, the nIn multiplier should only be applied once, not once + ** for each such term. The following loop checks that pTerm is the + ** first such term in use, and sets nIn back to 0 if it is not. */ + for(i=0; inLTerm-1; i++){ + if( pNew->aLTerm[i] && pNew->aLTerm[i]->pExpr==pExpr ) nIn = 0; + } + }else if( ALWAYS(pExpr->x.pList && pExpr->x.pList->nExpr) ){ + /* "x IN (value, value, ...)" */ + nIn = sqlite3LogEst(pExpr->x.pList->nExpr); + } + if( pProbe->hasStat1 && rLogSize>=10 ){ + LogEst M, logK, x; + /* Let: + ** N = the total number of rows in the table + ** K = the number of entries on the RHS of the IN operator + ** M = the number of rows in the table that match terms to the + ** to the left in the same index. If the IN operator is on + ** the left-most index column, M==N. + ** + ** Given the definitions above, it is better to omit the IN operator + ** from the index lookup and instead do a scan of the M elements, + ** testing each scanned row against the IN operator separately, if: + ** + ** M*log(K) < K*log(N) + ** + ** Our estimates for M, K, and N might be inaccurate, so we build in + ** a safety margin of 2 (LogEst: 10) that favors using the IN operator + ** with the index, as using an index has better worst-case behavior. + ** If we do not have real sqlite_stat1 data, always prefer to use + ** the index. Do not bother with this optimization on very small + ** tables (less than 2 rows) as it is pointless in that case. + */ + M = pProbe->aiRowLogEst[saved_nEq]; + logK = estLog(nIn); + /* TUNING v----- 10 to bias toward indexed IN */ + x = M + logK + 10 - (nIn + rLogSize); + if( x>=0 ){ + WHERETRACE(0x40, + ("IN operator (N=%d M=%d logK=%d nIn=%d rLogSize=%d x=%d) " + "prefers indexed lookup\n", + saved_nEq, M, logK, nIn, rLogSize, x)); + }else if( nInMul<2 && OptimizationEnabled(db, SQLITE_SeekScan) ){ + WHERETRACE(0x40, + ("IN operator (N=%d M=%d logK=%d nIn=%d rLogSize=%d x=%d" + " nInMul=%d) prefers skip-scan\n", + saved_nEq, M, logK, nIn, rLogSize, x, nInMul)); + pNew->wsFlags |= WHERE_IN_SEEKSCAN; + }else{ + WHERETRACE(0x40, + ("IN operator (N=%d M=%d logK=%d nIn=%d rLogSize=%d x=%d" + " nInMul=%d) prefers normal scan\n", + saved_nEq, M, logK, nIn, rLogSize, x, nInMul)); + continue; + } + } + pNew->wsFlags |= WHERE_COLUMN_IN; + }else if( eOp & (WO_EQ|WO_IS) ){ + int iCol = pProbe->aiColumn[saved_nEq]; + pNew->wsFlags |= WHERE_COLUMN_EQ; + assert( saved_nEq==pNew->u.btree.nEq ); + if( iCol==XN_ROWID + || (iCol>=0 && nInMul==0 && saved_nEq==pProbe->nKeyCol-1) + ){ + if( iCol==XN_ROWID || pProbe->uniqNotNull + || (pProbe->nKeyCol==1 && pProbe->onError && eOp==WO_EQ) + ){ + pNew->wsFlags |= WHERE_ONEROW; + }else{ + pNew->wsFlags |= WHERE_UNQ_WANTED; + } + } + if( scan.iEquiv>1 ) pNew->wsFlags |= WHERE_TRANSCONS; + }else if( eOp & WO_ISNULL ){ + pNew->wsFlags |= WHERE_COLUMN_NULL; + }else{ + int nVecLen = whereRangeVectorLen( + pParse, pSrc->iCursor, pProbe, saved_nEq, pTerm + ); + if( eOp & (WO_GT|WO_GE) ){ + testcase( eOp & WO_GT ); + testcase( eOp & WO_GE ); + pNew->wsFlags |= WHERE_COLUMN_RANGE|WHERE_BTM_LIMIT; + pNew->u.btree.nBtm = nVecLen; + pBtm = pTerm; + pTop = 0; + if( pTerm->wtFlags & TERM_LIKEOPT ){ + /* Range constraints that come from the LIKE optimization are + ** always used in pairs. */ + pTop = &pTerm[1]; + assert( (pTop-(pTerm->pWC->a))pWC->nTerm ); + assert( pTop->wtFlags & TERM_LIKEOPT ); + assert( pTop->eOperator==WO_LT ); + if( whereLoopResize(db, pNew, pNew->nLTerm+1) ) break; /* OOM */ + pNew->aLTerm[pNew->nLTerm++] = pTop; + pNew->wsFlags |= WHERE_TOP_LIMIT; + pNew->u.btree.nTop = 1; + } + }else{ + assert( eOp & (WO_LT|WO_LE) ); + testcase( eOp & WO_LT ); + testcase( eOp & WO_LE ); + pNew->wsFlags |= WHERE_COLUMN_RANGE|WHERE_TOP_LIMIT; + pNew->u.btree.nTop = nVecLen; + pTop = pTerm; + pBtm = (pNew->wsFlags & WHERE_BTM_LIMIT)!=0 ? + pNew->aLTerm[pNew->nLTerm-2] : 0; + } + } + + /* At this point pNew->nOut is set to the number of rows expected to + ** be visited by the index scan before considering term pTerm, or the + ** values of nIn and nInMul. In other words, assuming that all + ** "x IN(...)" terms are replaced with "x = ?". This block updates + ** the value of pNew->nOut to account for pTerm (but not nIn/nInMul). */ + assert( pNew->nOut==saved_nOut ); + if( pNew->wsFlags & WHERE_COLUMN_RANGE ){ + /* Adjust nOut using stat4 data. Or, if there is no stat4 + ** data, using some other estimate. */ + whereRangeScanEst(pParse, pBuilder, pBtm, pTop, pNew); + }else{ + int nEq = ++pNew->u.btree.nEq; + assert( eOp & (WO_ISNULL|WO_EQ|WO_IN|WO_IS) ); + + assert( pNew->nOut==saved_nOut ); + if( pTerm->truthProb<=0 && pProbe->aiColumn[saved_nEq]>=0 ){ + assert( (eOp & WO_IN) || nIn==0 ); + testcase( eOp & WO_IN ); + pNew->nOut += pTerm->truthProb; + pNew->nOut -= nIn; + }else{ +#ifdef SQLITE_ENABLE_STAT4 + tRowcnt nOut = 0; + if( nInMul==0 + && pProbe->nSample + && ALWAYS(pNew->u.btree.nEq<=pProbe->nSampleCol) + && ((eOp & WO_IN)==0 || ExprUseXList(pTerm->pExpr)) + && OptimizationEnabled(db, SQLITE_Stat4) + ){ + Expr *pExpr = pTerm->pExpr; + if( (eOp & (WO_EQ|WO_ISNULL|WO_IS))!=0 ){ + testcase( eOp & WO_EQ ); + testcase( eOp & WO_IS ); + testcase( eOp & WO_ISNULL ); + rc = whereEqualScanEst(pParse, pBuilder, pExpr->pRight, &nOut); + }else{ + rc = whereInScanEst(pParse, pBuilder, pExpr->x.pList, &nOut); + } + if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK; + if( rc!=SQLITE_OK ) break; /* Jump out of the pTerm loop */ + if( nOut ){ + pNew->nOut = sqlite3LogEst(nOut); + if( nEq==1 + /* TUNING: Mark terms as "low selectivity" if they seem likely + ** to be true for half or more of the rows in the table. + ** See tag-202002240-1 */ + && pNew->nOut+10 > pProbe->aiRowLogEst[0] + ){ +#if WHERETRACE_ENABLED /* 0x01 */ + if( sqlite3WhereTrace & 0x20 ){ + sqlite3DebugPrintf( + "STAT4 determines term has low selectivity:\n"); + sqlite3WhereTermPrint(pTerm, 999); + } +#endif + pTerm->wtFlags |= TERM_HIGHTRUTH; + if( pTerm->wtFlags & TERM_HEURTRUTH ){ + /* If the term has previously been used with an assumption of + ** higher selectivity, then set the flag to rerun the + ** loop computations. */ + pBuilder->bldFlags2 |= SQLITE_BLDF2_2NDPASS; + } + } + if( pNew->nOut>saved_nOut ) pNew->nOut = saved_nOut; + pNew->nOut -= nIn; + } + } + if( nOut==0 ) +#endif + { + pNew->nOut += (pProbe->aiRowLogEst[nEq] - pProbe->aiRowLogEst[nEq-1]); + if( eOp & WO_ISNULL ){ + /* TUNING: If there is no likelihood() value, assume that a + ** "col IS NULL" expression matches twice as many rows + ** as (col=?). */ + pNew->nOut += 10; + } + } + } + } + + /* Set rCostIdx to the cost of visiting selected rows in index. Add + ** it to pNew->rRun, which is currently set to the cost of the index + ** seek only. Then, if this is a non-covering index, add the cost of + ** visiting the rows in the main table. */ + assert( pSrc->pTab->szTabRow>0 ); + if( pProbe->idxType==SQLITE_IDXTYPE_IPK ){ + /* The pProbe->szIdxRow is low for an IPK table since the interior + ** pages are small. Thuse szIdxRow gives a good estimate of seek cost. + ** But the leaf pages are full-size, so pProbe->szIdxRow would badly + ** under-estimate the scanning cost. */ + rCostIdx = pNew->nOut + 16; + }else{ + rCostIdx = pNew->nOut + 1 + (15*pProbe->szIdxRow)/pSrc->pTab->szTabRow; + } + pNew->rRun = sqlite3LogEstAdd(rLogSize, rCostIdx); + if( (pNew->wsFlags & (WHERE_IDX_ONLY|WHERE_IPK|WHERE_EXPRIDX))==0 ){ + pNew->rRun = sqlite3LogEstAdd(pNew->rRun, pNew->nOut + 16); + } + ApplyCostMultiplier(pNew->rRun, pProbe->pTable->costMult); + + nOutUnadjusted = pNew->nOut; + pNew->rRun += nInMul + nIn; + pNew->nOut += nInMul + nIn; + whereLoopOutputAdjust(pBuilder->pWC, pNew, rSize); + rc = whereLoopInsert(pBuilder, pNew); + + if( pNew->wsFlags & WHERE_COLUMN_RANGE ){ + pNew->nOut = saved_nOut; + }else{ + pNew->nOut = nOutUnadjusted; + } + + if( (pNew->wsFlags & WHERE_TOP_LIMIT)==0 + && pNew->u.btree.nEqnColumn + && (pNew->u.btree.nEqnKeyCol || + pProbe->idxType!=SQLITE_IDXTYPE_PRIMARYKEY) + ){ + if( pNew->u.btree.nEq>3 ){ + sqlite3ProgressCheck(pParse); + } + whereLoopAddBtreeIndex(pBuilder, pSrc, pProbe, nInMul+nIn); + } + pNew->nOut = saved_nOut; +#ifdef SQLITE_ENABLE_STAT4 + pBuilder->nRecValid = nRecValid; +#endif + } + pNew->prereq = saved_prereq; + pNew->u.btree.nEq = saved_nEq; + pNew->u.btree.nBtm = saved_nBtm; + pNew->u.btree.nTop = saved_nTop; + pNew->nSkip = saved_nSkip; + pNew->wsFlags = saved_wsFlags; + pNew->nOut = saved_nOut; + pNew->nLTerm = saved_nLTerm; + + /* Consider using a skip-scan if there are no WHERE clause constraints + ** available for the left-most terms of the index, and if the average + ** number of repeats in the left-most terms is at least 18. + ** + ** The magic number 18 is selected on the basis that scanning 17 rows + ** is almost always quicker than an index seek (even though if the index + ** contains fewer than 2^17 rows we assume otherwise in other parts of + ** the code). And, even if it is not, it should not be too much slower. + ** On the other hand, the extra seeks could end up being significantly + ** more expensive. */ + assert( 42==sqlite3LogEst(18) ); + if( saved_nEq==saved_nSkip + && saved_nEq+1nKeyCol + && saved_nEq==pNew->nLTerm + && pProbe->noSkipScan==0 + && pProbe->hasStat1!=0 + && OptimizationEnabled(db, SQLITE_SkipScan) + && pProbe->aiRowLogEst[saved_nEq+1]>=42 /* TUNING: Minimum for skip-scan */ + && (rc = whereLoopResize(db, pNew, pNew->nLTerm+1))==SQLITE_OK + ){ + LogEst nIter; + pNew->u.btree.nEq++; + pNew->nSkip++; + pNew->aLTerm[pNew->nLTerm++] = 0; + pNew->wsFlags |= WHERE_SKIPSCAN; + nIter = pProbe->aiRowLogEst[saved_nEq] - pProbe->aiRowLogEst[saved_nEq+1]; + pNew->nOut -= nIter; + /* TUNING: Because uncertainties in the estimates for skip-scan queries, + ** add a 1.375 fudge factor to make skip-scan slightly less likely. */ + nIter += 5; + whereLoopAddBtreeIndex(pBuilder, pSrc, pProbe, nIter + nInMul); + pNew->nOut = saved_nOut; + pNew->u.btree.nEq = saved_nEq; + pNew->nSkip = saved_nSkip; + pNew->wsFlags = saved_wsFlags; + } + + WHERETRACE(0x800, ("END %s.addBtreeIdx(%s), nEq=%d, rc=%d\n", + pProbe->pTable->zName, pProbe->zName, saved_nEq, rc)); + return rc; +} + +/* +** Return True if it is possible that pIndex might be useful in +** implementing the ORDER BY clause in pBuilder. +** +** Return False if pBuilder does not contain an ORDER BY clause or +** if there is no way for pIndex to be useful in implementing that +** ORDER BY clause. +*/ +static int indexMightHelpWithOrderBy( + WhereLoopBuilder *pBuilder, + Index *pIndex, + int iCursor +){ + ExprList *pOB; + ExprList *aColExpr; + int ii, jj; + + if( pIndex->bUnordered ) return 0; + if( (pOB = pBuilder->pWInfo->pOrderBy)==0 ) return 0; + for(ii=0; iinExpr; ii++){ + Expr *pExpr = sqlite3ExprSkipCollateAndLikely(pOB->a[ii].pExpr); + if( NEVER(pExpr==0) ) continue; + if( pExpr->op==TK_COLUMN && pExpr->iTable==iCursor ){ + if( pExpr->iColumn<0 ) return 1; + for(jj=0; jjnKeyCol; jj++){ + if( pExpr->iColumn==pIndex->aiColumn[jj] ) return 1; + } + }else if( (aColExpr = pIndex->aColExpr)!=0 ){ + for(jj=0; jjnKeyCol; jj++){ + if( pIndex->aiColumn[jj]!=XN_EXPR ) continue; + if( sqlite3ExprCompareSkip(pExpr,aColExpr->a[jj].pExpr,iCursor)==0 ){ + return 1; + } + } + } + } + return 0; +} + +/* Check to see if a partial index with pPartIndexWhere can be used +** in the current query. Return true if it can be and false if not. +*/ +static int whereUsablePartialIndex( + int iTab, /* The table for which we want an index */ + u8 jointype, /* The JT_* flags on the join */ + WhereClause *pWC, /* The WHERE clause of the query */ + Expr *pWhere /* The WHERE clause from the partial index */ +){ + int i; + WhereTerm *pTerm; + Parse *pParse; + + if( jointype & JT_LTORJ ) return 0; + pParse = pWC->pWInfo->pParse; + while( pWhere->op==TK_AND ){ + if( !whereUsablePartialIndex(iTab,jointype,pWC,pWhere->pLeft) ) return 0; + pWhere = pWhere->pRight; + } + if( pParse->db->flags & SQLITE_EnableQPSG ) pParse = 0; + for(i=0, pTerm=pWC->a; inTerm; i++, pTerm++){ + Expr *pExpr; + pExpr = pTerm->pExpr; + if( (!ExprHasProperty(pExpr, EP_OuterON) || pExpr->w.iJoin==iTab) + && ((jointype & JT_OUTER)==0 || ExprHasProperty(pExpr, EP_OuterON)) + && sqlite3ExprImpliesExpr(pParse, pExpr, pWhere, iTab) + && (pTerm->wtFlags & TERM_VNULL)==0 + ){ + return 1; + } + } + return 0; +} + +/* +** pIdx is an index containing expressions. Check it see if any of the +** expressions in the index match the pExpr expression. +*/ +static int exprIsCoveredByIndex( + const Expr *pExpr, + const Index *pIdx, + int iTabCur +){ + int i; + for(i=0; inColumn; i++){ + if( pIdx->aiColumn[i]==XN_EXPR + && sqlite3ExprCompare(0, pExpr, pIdx->aColExpr->a[i].pExpr, iTabCur)==0 + ){ + return 1; + } + } + return 0; +} + +/* +** Structure passed to the whereIsCoveringIndex Walker callback. +*/ +typedef struct CoveringIndexCheck CoveringIndexCheck; +struct CoveringIndexCheck { + Index *pIdx; /* The index */ + int iTabCur; /* Cursor number for the corresponding table */ + u8 bExpr; /* Uses an indexed expression */ + u8 bUnidx; /* Uses an unindexed column not within an indexed expr */ +}; + +/* +** Information passed in is pWalk->u.pCovIdxCk. Call it pCk. +** +** If the Expr node references the table with cursor pCk->iTabCur, then +** make sure that column is covered by the index pCk->pIdx. We know that +** all columns less than 63 (really BMS-1) are covered, so we don't need +** to check them. But we do need to check any column at 63 or greater. +** +** If the index does not cover the column, then set pWalk->eCode to +** non-zero and return WRC_Abort to stop the search. +** +** If this node does not disprove that the index can be a covering index, +** then just return WRC_Continue, to continue the search. +** +** If pCk->pIdx contains indexed expressions and one of those expressions +** matches pExpr, then prune the search. +*/ +static int whereIsCoveringIndexWalkCallback(Walker *pWalk, Expr *pExpr){ + int i; /* Loop counter */ + const Index *pIdx; /* The index of interest */ + const i16 *aiColumn; /* Columns contained in the index */ + u16 nColumn; /* Number of columns in the index */ + CoveringIndexCheck *pCk; /* Info about this search */ + + pCk = pWalk->u.pCovIdxCk; + pIdx = pCk->pIdx; + if( (pExpr->op==TK_COLUMN || pExpr->op==TK_AGG_COLUMN) ){ + /* if( pExpr->iColumn<(BMS-1) && pIdx->bHasExpr==0 ) return WRC_Continue;*/ + if( pExpr->iTable!=pCk->iTabCur ) return WRC_Continue; + pIdx = pWalk->u.pCovIdxCk->pIdx; + aiColumn = pIdx->aiColumn; + nColumn = pIdx->nColumn; + for(i=0; iiColumn ) return WRC_Continue; + } + pCk->bUnidx = 1; + return WRC_Abort; + }else if( pIdx->bHasExpr + && exprIsCoveredByIndex(pExpr, pIdx, pWalk->u.pCovIdxCk->iTabCur) ){ + pCk->bExpr = 1; + return WRC_Prune; + } + return WRC_Continue; +} + + +/* +** pIdx is an index that covers all of the low-number columns used by +** pWInfo->pSelect (columns from 0 through 62) or an index that has +** expressions terms. Hence, we cannot determine whether or not it is +** a covering index by using the colUsed bitmasks. We have to do a search +** to see if the index is covering. This routine does that search. +** +** The return value is one of these: +** +** 0 The index is definitely not a covering index +** +** WHERE_IDX_ONLY The index is definitely a covering index +** +** WHERE_EXPRIDX The index is likely a covering index, but it is +** difficult to determine precisely because of the +** expressions that are indexed. Score it as a +** covering index, but still keep the main table open +** just in case we need it. +** +** This routine is an optimization. It is always safe to return zero. +** But returning one of the other two values when zero should have been +** returned can lead to incorrect bytecode and assertion faults. +*/ +static SQLITE_NOINLINE u32 whereIsCoveringIndex( + WhereInfo *pWInfo, /* The WHERE clause context */ + Index *pIdx, /* Index that is being tested */ + int iTabCur /* Cursor for the table being indexed */ +){ + int i, rc; + struct CoveringIndexCheck ck; + Walker w; + if( pWInfo->pSelect==0 ){ + /* We don't have access to the full query, so we cannot check to see + ** if pIdx is covering. Assume it is not. */ + return 0; + } + if( pIdx->bHasExpr==0 ){ + for(i=0; inColumn; i++){ + if( pIdx->aiColumn[i]>=BMS-1 ) break; + } + if( i>=pIdx->nColumn ){ + /* pIdx does not index any columns greater than 62, but we know from + ** colMask that columns greater than 62 are used, so this is not a + ** covering index */ + return 0; + } + } + ck.pIdx = pIdx; + ck.iTabCur = iTabCur; + ck.bExpr = 0; + ck.bUnidx = 0; + memset(&w, 0, sizeof(w)); + w.xExprCallback = whereIsCoveringIndexWalkCallback; + w.xSelectCallback = sqlite3SelectWalkNoop; + w.u.pCovIdxCk = &ck; + sqlite3WalkSelect(&w, pWInfo->pSelect); + if( ck.bUnidx ){ + rc = 0; + }else if( ck.bExpr ){ + rc = WHERE_EXPRIDX; + }else{ + rc = WHERE_IDX_ONLY; + } + return rc; +} + +/* +** Add all WhereLoop objects for a single table of the join where the table +** is identified by pBuilder->pNew->iTab. That table is guaranteed to be +** a b-tree table, not a virtual table. +** +** The costs (WhereLoop.rRun) of the b-tree loops added by this function +** are calculated as follows: +** +** For a full scan, assuming the table (or index) contains nRow rows: +** +** cost = nRow * 3.0 // full-table scan +** cost = nRow * K // scan of covering index +** cost = nRow * (K+3.0) // scan of non-covering index +** +** where K is a value between 1.1 and 3.0 set based on the relative +** estimated average size of the index and table records. +** +** For an index scan, where nVisit is the number of index rows visited +** by the scan, and nSeek is the number of seek operations required on +** the index b-tree: +** +** cost = nSeek * (log(nRow) + K * nVisit) // covering index +** cost = nSeek * (log(nRow) + (K+3.0) * nVisit) // non-covering index +** +** Normally, nSeek is 1. nSeek values greater than 1 come about if the +** WHERE clause includes "x IN (....)" terms used in place of "x=?". Or when +** implicit "x IN (SELECT x FROM tbl)" terms are added for skip-scans. +** +** The estimated values (nRow, nVisit, nSeek) often contain a large amount +** of uncertainty. For this reason, scoring is designed to pick plans that +** "do the least harm" if the estimates are inaccurate. For example, a +** log(nRow) factor is omitted from a non-covering index scan in order to +** bias the scoring in favor of using an index, since the worst-case +** performance of using an index is far better than the worst-case performance +** of a full table scan. +*/ +static int whereLoopAddBtree( + WhereLoopBuilder *pBuilder, /* WHERE clause information */ + Bitmask mPrereq /* Extra prerequesites for using this table */ +){ + WhereInfo *pWInfo; /* WHERE analysis context */ + Index *pProbe; /* An index we are evaluating */ + Index sPk; /* A fake index object for the primary key */ + LogEst aiRowEstPk[2]; /* The aiRowLogEst[] value for the sPk index */ + i16 aiColumnPk = -1; /* The aColumn[] value for the sPk index */ + SrcList *pTabList; /* The FROM clause */ + SrcItem *pSrc; /* The FROM clause btree term to add */ + WhereLoop *pNew; /* Template WhereLoop object */ + int rc = SQLITE_OK; /* Return code */ + int iSortIdx = 1; /* Index number */ + int b; /* A boolean value */ + LogEst rSize; /* number of rows in the table */ + WhereClause *pWC; /* The parsed WHERE clause */ + Table *pTab; /* Table being queried */ + + pNew = pBuilder->pNew; + pWInfo = pBuilder->pWInfo; + pTabList = pWInfo->pTabList; + pSrc = pTabList->a + pNew->iTab; + pTab = pSrc->pTab; + pWC = pBuilder->pWC; + assert( !IsVirtual(pSrc->pTab) ); + + if( pSrc->fg.isIndexedBy ){ + assert( pSrc->fg.isCte==0 ); + /* An INDEXED BY clause specifies a particular index to use */ + pProbe = pSrc->u2.pIBIndex; + }else if( !HasRowid(pTab) ){ + pProbe = pTab->pIndex; + }else{ + /* There is no INDEXED BY clause. Create a fake Index object in local + ** variable sPk to represent the rowid primary key index. Make this + ** fake index the first in a chain of Index objects with all of the real + ** indices to follow */ + Index *pFirst; /* First of real indices on the table */ + memset(&sPk, 0, sizeof(Index)); + sPk.nKeyCol = 1; + sPk.nColumn = 1; + sPk.aiColumn = &aiColumnPk; + sPk.aiRowLogEst = aiRowEstPk; + sPk.onError = OE_Replace; + sPk.pTable = pTab; + sPk.szIdxRow = 3; /* TUNING: Interior rows of IPK table are very small */ + sPk.idxType = SQLITE_IDXTYPE_IPK; + aiRowEstPk[0] = pTab->nRowLogEst; + aiRowEstPk[1] = 0; + pFirst = pSrc->pTab->pIndex; + if( pSrc->fg.notIndexed==0 ){ + /* The real indices of the table are only considered if the + ** NOT INDEXED qualifier is omitted from the FROM clause */ + sPk.pNext = pFirst; + } + pProbe = &sPk; + } + rSize = pTab->nRowLogEst; + +#ifndef SQLITE_OMIT_AUTOMATIC_INDEX + /* Automatic indexes */ + if( !pBuilder->pOrSet /* Not part of an OR optimization */ + && (pWInfo->wctrlFlags & (WHERE_RIGHT_JOIN|WHERE_OR_SUBCLAUSE))==0 + && (pWInfo->pParse->db->flags & SQLITE_AutoIndex)!=0 + && !pSrc->fg.isIndexedBy /* Has no INDEXED BY clause */ + && !pSrc->fg.notIndexed /* Has no NOT INDEXED clause */ + && HasRowid(pTab) /* Not WITHOUT ROWID table. (FIXME: Why not?) */ + && !pSrc->fg.isCorrelated /* Not a correlated subquery */ + && !pSrc->fg.isRecursive /* Not a recursive common table expression. */ + && (pSrc->fg.jointype & JT_RIGHT)==0 /* Not the right tab of a RIGHT JOIN */ + ){ + /* Generate auto-index WhereLoops */ + LogEst rLogSize; /* Logarithm of the number of rows in the table */ + WhereTerm *pTerm; + WhereTerm *pWCEnd = pWC->a + pWC->nTerm; + rLogSize = estLog(rSize); + for(pTerm=pWC->a; rc==SQLITE_OK && pTermprereqRight & pNew->maskSelf ) continue; + if( termCanDriveIndex(pTerm, pSrc, 0) ){ + pNew->u.btree.nEq = 1; + pNew->nSkip = 0; + pNew->u.btree.pIndex = 0; + pNew->nLTerm = 1; + pNew->aLTerm[0] = pTerm; + /* TUNING: One-time cost for computing the automatic index is + ** estimated to be X*N*log2(N) where N is the number of rows in + ** the table being indexed and where X is 7 (LogEst=28) for normal + ** tables or 0.5 (LogEst=-10) for views and subqueries. The value + ** of X is smaller for views and subqueries so that the query planner + ** will be more aggressive about generating automatic indexes for + ** those objects, since there is no opportunity to add schema + ** indexes on subqueries and views. */ + pNew->rSetup = rLogSize + rSize; + if( !IsView(pTab) && (pTab->tabFlags & TF_Ephemeral)==0 ){ + pNew->rSetup += 28; + }else{ + pNew->rSetup -= 25; /* Greatly reduced setup cost for auto indexes + ** on ephemeral materializations of views */ + } + ApplyCostMultiplier(pNew->rSetup, pTab->costMult); + if( pNew->rSetup<0 ) pNew->rSetup = 0; + /* TUNING: Each index lookup yields 20 rows in the table. This + ** is more than the usual guess of 10 rows, since we have no way + ** of knowing how selective the index will ultimately be. It would + ** not be unreasonable to make this value much larger. */ + pNew->nOut = 43; assert( 43==sqlite3LogEst(20) ); + pNew->rRun = sqlite3LogEstAdd(rLogSize,pNew->nOut); + pNew->wsFlags = WHERE_AUTO_INDEX; + pNew->prereq = mPrereq | pTerm->prereqRight; + rc = whereLoopInsert(pBuilder, pNew); + } + } + } +#endif /* SQLITE_OMIT_AUTOMATIC_INDEX */ + + /* Loop over all indices. If there was an INDEXED BY clause, then only + ** consider index pProbe. */ + for(; rc==SQLITE_OK && pProbe; + pProbe=(pSrc->fg.isIndexedBy ? 0 : pProbe->pNext), iSortIdx++ + ){ + if( pProbe->pPartIdxWhere!=0 + && !whereUsablePartialIndex(pSrc->iCursor, pSrc->fg.jointype, pWC, + pProbe->pPartIdxWhere) + ){ + testcase( pNew->iTab!=pSrc->iCursor ); /* See ticket [98d973b8f5] */ + continue; /* Partial index inappropriate for this query */ + } + if( pProbe->bNoQuery ) continue; + rSize = pProbe->aiRowLogEst[0]; + pNew->u.btree.nEq = 0; + pNew->u.btree.nBtm = 0; + pNew->u.btree.nTop = 0; + pNew->nSkip = 0; + pNew->nLTerm = 0; + pNew->iSortIdx = 0; + pNew->rSetup = 0; + pNew->prereq = mPrereq; + pNew->nOut = rSize; + pNew->u.btree.pIndex = pProbe; + b = indexMightHelpWithOrderBy(pBuilder, pProbe, pSrc->iCursor); + + /* The ONEPASS_DESIRED flags never occurs together with ORDER BY */ + assert( (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0 || b==0 ); + if( pProbe->idxType==SQLITE_IDXTYPE_IPK ){ + /* Integer primary key index */ + pNew->wsFlags = WHERE_IPK; + + /* Full table scan */ + pNew->iSortIdx = b ? iSortIdx : 0; + /* TUNING: Cost of full table scan is 3.0*N. The 3.0 factor is an + ** extra cost designed to discourage the use of full table scans, + ** since index lookups have better worst-case performance if our + ** stat guesses are wrong. Reduce the 3.0 penalty slightly + ** (to 2.75) if we have valid STAT4 information for the table. + ** At 2.75, a full table scan is preferred over using an index on + ** a column with just two distinct values where each value has about + ** an equal number of appearances. Without STAT4 data, we still want + ** to use an index in that case, since the constraint might be for + ** the scarcer of the two values, and in that case an index lookup is + ** better. + */ +#ifdef SQLITE_ENABLE_STAT4 + pNew->rRun = rSize + 16 - 2*((pTab->tabFlags & TF_HasStat4)!=0); +#else + pNew->rRun = rSize + 16; +#endif + if( IsView(pTab) || (pTab->tabFlags & TF_Ephemeral)!=0 ){ + pNew->wsFlags |= WHERE_VIEWSCAN; + } + ApplyCostMultiplier(pNew->rRun, pTab->costMult); + whereLoopOutputAdjust(pWC, pNew, rSize); + rc = whereLoopInsert(pBuilder, pNew); + pNew->nOut = rSize; + if( rc ) break; + }else{ + Bitmask m; + if( pProbe->isCovering ){ + m = 0; + pNew->wsFlags = WHERE_IDX_ONLY | WHERE_INDEXED; + }else{ + m = pSrc->colUsed & pProbe->colNotIdxed; + pNew->wsFlags = WHERE_INDEXED; + if( m==TOPBIT || (pProbe->bHasExpr && !pProbe->bHasVCol && m!=0) ){ + u32 isCov = whereIsCoveringIndex(pWInfo, pProbe, pSrc->iCursor); + if( isCov==0 ){ + WHERETRACE(0x200, + ("-> %s is not a covering index" + " according to whereIsCoveringIndex()\n", pProbe->zName)); + assert( m!=0 ); + }else{ + m = 0; + pNew->wsFlags |= isCov; + if( isCov & WHERE_IDX_ONLY ){ + WHERETRACE(0x200, + ("-> %s is a covering expression index" + " according to whereIsCoveringIndex()\n", pProbe->zName)); + }else{ + assert( isCov==WHERE_EXPRIDX ); + WHERETRACE(0x200, + ("-> %s might be a covering expression index" + " according to whereIsCoveringIndex()\n", pProbe->zName)); + } + } + }else if( m==0 ){ + WHERETRACE(0x200, + ("-> %s a covering index according to bitmasks\n", + pProbe->zName, m==0 ? "is" : "is not")); + pNew->wsFlags = WHERE_IDX_ONLY | WHERE_INDEXED; + } + } + + /* Full scan via index */ + if( b + || !HasRowid(pTab) + || pProbe->pPartIdxWhere!=0 + || pSrc->fg.isIndexedBy + || ( m==0 + && pProbe->bUnordered==0 + && (pProbe->szIdxRowszTabRow) + && (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0 + && sqlite3GlobalConfig.bUseCis + && OptimizationEnabled(pWInfo->pParse->db, SQLITE_CoverIdxScan) + ) + ){ + pNew->iSortIdx = b ? iSortIdx : 0; + + /* The cost of visiting the index rows is N*K, where K is + ** between 1.1 and 3.0, depending on the relative sizes of the + ** index and table rows. */ + pNew->rRun = rSize + 1 + (15*pProbe->szIdxRow)/pTab->szTabRow; + if( m!=0 ){ + /* If this is a non-covering index scan, add in the cost of + ** doing table lookups. The cost will be 3x the number of + ** lookups. Take into account WHERE clause terms that can be + ** satisfied using just the index, and that do not require a + ** table lookup. */ + LogEst nLookup = rSize + 16; /* Base cost: N*3 */ + int ii; + int iCur = pSrc->iCursor; + WhereClause *pWC2 = &pWInfo->sWC; + for(ii=0; iinTerm; ii++){ + WhereTerm *pTerm = &pWC2->a[ii]; + if( !sqlite3ExprCoveredByIndex(pTerm->pExpr, iCur, pProbe) ){ + break; + } + /* pTerm can be evaluated using just the index. So reduce + ** the expected number of table lookups accordingly */ + if( pTerm->truthProb<=0 ){ + nLookup += pTerm->truthProb; + }else{ + nLookup--; + if( pTerm->eOperator & (WO_EQ|WO_IS) ) nLookup -= 19; + } + } + + pNew->rRun = sqlite3LogEstAdd(pNew->rRun, nLookup); + } + ApplyCostMultiplier(pNew->rRun, pTab->costMult); + whereLoopOutputAdjust(pWC, pNew, rSize); + if( (pSrc->fg.jointype & JT_RIGHT)!=0 && pProbe->aColExpr ){ + /* Do not do an SCAN of a index-on-expression in a RIGHT JOIN + ** because the cursor used to access the index might not be + ** positioned to the correct row during the right-join no-match + ** loop. */ + }else{ + rc = whereLoopInsert(pBuilder, pNew); + } + pNew->nOut = rSize; + if( rc ) break; + } + } + + pBuilder->bldFlags1 = 0; + rc = whereLoopAddBtreeIndex(pBuilder, pSrc, pProbe, 0); + if( pBuilder->bldFlags1==SQLITE_BLDF1_INDEXED ){ + /* If a non-unique index is used, or if a prefix of the key for + ** unique index is used (making the index functionally non-unique) + ** then the sqlite_stat1 data becomes important for scoring the + ** plan */ + pTab->tabFlags |= TF_StatsUsed; + } +#ifdef SQLITE_ENABLE_STAT4 + sqlite3Stat4ProbeFree(pBuilder->pRec); + pBuilder->nRecValid = 0; + pBuilder->pRec = 0; +#endif + } + return rc; +} + +#ifndef SQLITE_OMIT_VIRTUALTABLE + +/* +** Return true if pTerm is a virtual table LIMIT or OFFSET term. +*/ +static int isLimitTerm(WhereTerm *pTerm){ + assert( pTerm->eOperator==WO_AUX || pTerm->eMatchOp==0 ); + return pTerm->eMatchOp>=SQLITE_INDEX_CONSTRAINT_LIMIT + && pTerm->eMatchOp<=SQLITE_INDEX_CONSTRAINT_OFFSET; +} + +/* +** Argument pIdxInfo is already populated with all constraints that may +** be used by the virtual table identified by pBuilder->pNew->iTab. This +** function marks a subset of those constraints usable, invokes the +** xBestIndex method and adds the returned plan to pBuilder. +** +** A constraint is marked usable if: +** +** * Argument mUsable indicates that its prerequisites are available, and +** +** * It is not one of the operators specified in the mExclude mask passed +** as the fourth argument (which in practice is either WO_IN or 0). +** +** Argument mPrereq is a mask of tables that must be scanned before the +** virtual table in question. These are added to the plans prerequisites +** before it is added to pBuilder. +** +** Output parameter *pbIn is set to true if the plan added to pBuilder +** uses one or more WO_IN terms, or false otherwise. +*/ +static int whereLoopAddVirtualOne( + WhereLoopBuilder *pBuilder, + Bitmask mPrereq, /* Mask of tables that must be used. */ + Bitmask mUsable, /* Mask of usable tables */ + u16 mExclude, /* Exclude terms using these operators */ + sqlite3_index_info *pIdxInfo, /* Populated object for xBestIndex */ + u16 mNoOmit, /* Do not omit these constraints */ + int *pbIn, /* OUT: True if plan uses an IN(...) op */ + int *pbRetryLimit /* OUT: Retry without LIMIT/OFFSET */ +){ + WhereClause *pWC = pBuilder->pWC; + HiddenIndexInfo *pHidden = (HiddenIndexInfo*)&pIdxInfo[1]; + struct sqlite3_index_constraint *pIdxCons; + struct sqlite3_index_constraint_usage *pUsage = pIdxInfo->aConstraintUsage; + int i; + int mxTerm; + int rc = SQLITE_OK; + WhereLoop *pNew = pBuilder->pNew; + Parse *pParse = pBuilder->pWInfo->pParse; + SrcItem *pSrc = &pBuilder->pWInfo->pTabList->a[pNew->iTab]; + int nConstraint = pIdxInfo->nConstraint; + + assert( (mUsable & mPrereq)==mPrereq ); + *pbIn = 0; + pNew->prereq = mPrereq; + + /* Set the usable flag on the subset of constraints identified by + ** arguments mUsable and mExclude. */ + pIdxCons = *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint; + for(i=0; ia[pIdxCons->iTermOffset]; + pIdxCons->usable = 0; + if( (pTerm->prereqRight & mUsable)==pTerm->prereqRight + && (pTerm->eOperator & mExclude)==0 + && (pbRetryLimit || !isLimitTerm(pTerm)) + ){ + pIdxCons->usable = 1; + } + } + + /* Initialize the output fields of the sqlite3_index_info structure */ + memset(pUsage, 0, sizeof(pUsage[0])*nConstraint); + assert( pIdxInfo->needToFreeIdxStr==0 ); + pIdxInfo->idxStr = 0; + pIdxInfo->idxNum = 0; + pIdxInfo->orderByConsumed = 0; + pIdxInfo->estimatedCost = SQLITE_BIG_DBL / (double)2; + pIdxInfo->estimatedRows = 25; + pIdxInfo->idxFlags = 0; + pIdxInfo->colUsed = (sqlite3_int64)pSrc->colUsed; + pHidden->mHandleIn = 0; + + /* Invoke the virtual table xBestIndex() method */ + rc = vtabBestIndex(pParse, pSrc->pTab, pIdxInfo); + if( rc ){ + if( rc==SQLITE_CONSTRAINT ){ + /* If the xBestIndex method returns SQLITE_CONSTRAINT, that means + ** that the particular combination of parameters provided is unusable. + ** Make no entries in the loop table. + */ + WHERETRACE(0xffffffff, (" ^^^^--- non-viable plan rejected!\n")); + return SQLITE_OK; + } + return rc; + } + + mxTerm = -1; + assert( pNew->nLSlot>=nConstraint ); + memset(pNew->aLTerm, 0, sizeof(pNew->aLTerm[0])*nConstraint ); + memset(&pNew->u.vtab, 0, sizeof(pNew->u.vtab)); + pIdxCons = *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint; + for(i=0; i=0 ){ + WhereTerm *pTerm; + int j = pIdxCons->iTermOffset; + if( iTerm>=nConstraint + || j<0 + || j>=pWC->nTerm + || pNew->aLTerm[iTerm]!=0 + || pIdxCons->usable==0 + ){ + sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName); + testcase( pIdxInfo->needToFreeIdxStr ); + return SQLITE_ERROR; + } + testcase( iTerm==nConstraint-1 ); + testcase( j==0 ); + testcase( j==pWC->nTerm-1 ); + pTerm = &pWC->a[j]; + pNew->prereq |= pTerm->prereqRight; + assert( iTermnLSlot ); + pNew->aLTerm[iTerm] = pTerm; + if( iTerm>mxTerm ) mxTerm = iTerm; + testcase( iTerm==15 ); + testcase( iTerm==16 ); + if( pUsage[i].omit ){ + if( i<16 && ((1<u.vtab.omitMask |= 1<eMatchOp==SQLITE_INDEX_CONSTRAINT_OFFSET ){ + pNew->u.vtab.bOmitOffset = 1; + } + } + if( SMASKBIT32(i) & pHidden->mHandleIn ){ + pNew->u.vtab.mHandleIn |= MASKBIT32(iTerm); + }else if( (pTerm->eOperator & WO_IN)!=0 ){ + /* A virtual table that is constrained by an IN clause may not + ** consume the ORDER BY clause because (1) the order of IN terms + ** is not necessarily related to the order of output terms and + ** (2) Multiple outputs from a single IN value will not merge + ** together. */ + pIdxInfo->orderByConsumed = 0; + pIdxInfo->idxFlags &= ~SQLITE_INDEX_SCAN_UNIQUE; + *pbIn = 1; assert( (mExclude & WO_IN)==0 ); + } + + assert( pbRetryLimit || !isLimitTerm(pTerm) ); + if( isLimitTerm(pTerm) && *pbIn ){ + /* If there is an IN(...) term handled as an == (separate call to + ** xFilter for each value on the RHS of the IN) and a LIMIT or + ** OFFSET term handled as well, the plan is unusable. Set output + ** variable *pbRetryLimit to true to tell the caller to retry with + ** LIMIT and OFFSET disabled. */ + if( pIdxInfo->needToFreeIdxStr ){ + sqlite3_free(pIdxInfo->idxStr); + pIdxInfo->idxStr = 0; + pIdxInfo->needToFreeIdxStr = 0; + } + *pbRetryLimit = 1; + return SQLITE_OK; + } + } + } + + pNew->nLTerm = mxTerm+1; + for(i=0; i<=mxTerm; i++){ + if( pNew->aLTerm[i]==0 ){ + /* The non-zero argvIdx values must be contiguous. Raise an + ** error if they are not */ + sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName); + testcase( pIdxInfo->needToFreeIdxStr ); + return SQLITE_ERROR; + } + } + assert( pNew->nLTerm<=pNew->nLSlot ); + pNew->u.vtab.idxNum = pIdxInfo->idxNum; + pNew->u.vtab.needFree = pIdxInfo->needToFreeIdxStr; + pIdxInfo->needToFreeIdxStr = 0; + pNew->u.vtab.idxStr = pIdxInfo->idxStr; + pNew->u.vtab.isOrdered = (i8)(pIdxInfo->orderByConsumed ? + pIdxInfo->nOrderBy : 0); + pNew->rSetup = 0; + pNew->rRun = sqlite3LogEstFromDouble(pIdxInfo->estimatedCost); + pNew->nOut = sqlite3LogEst(pIdxInfo->estimatedRows); + + /* Set the WHERE_ONEROW flag if the xBestIndex() method indicated + ** that the scan will visit at most one row. Clear it otherwise. */ + if( pIdxInfo->idxFlags & SQLITE_INDEX_SCAN_UNIQUE ){ + pNew->wsFlags |= WHERE_ONEROW; + }else{ + pNew->wsFlags &= ~WHERE_ONEROW; + } + rc = whereLoopInsert(pBuilder, pNew); + if( pNew->u.vtab.needFree ){ + sqlite3_free(pNew->u.vtab.idxStr); + pNew->u.vtab.needFree = 0; + } + WHERETRACE(0xffffffff, (" bIn=%d prereqIn=%04llx prereqOut=%04llx\n", + *pbIn, (sqlite3_uint64)mPrereq, + (sqlite3_uint64)(pNew->prereq & ~mPrereq))); + + return rc; +} + +/* +** Return the collating sequence for a constraint passed into xBestIndex. +** +** pIdxInfo must be an sqlite3_index_info structure passed into xBestIndex. +** This routine depends on there being a HiddenIndexInfo structure immediately +** following the sqlite3_index_info structure. +** +** Return a pointer to the collation name: +** +** 1. If there is an explicit COLLATE operator on the constaint, return it. +** +** 2. Else, if the column has an alternative collation, return that. +** +** 3. Otherwise, return "BINARY". +*/ +SQLITE_API const char *sqlite3_vtab_collation(sqlite3_index_info *pIdxInfo, int iCons){ + HiddenIndexInfo *pHidden = (HiddenIndexInfo*)&pIdxInfo[1]; + const char *zRet = 0; + if( iCons>=0 && iConsnConstraint ){ + CollSeq *pC = 0; + int iTerm = pIdxInfo->aConstraint[iCons].iTermOffset; + Expr *pX = pHidden->pWC->a[iTerm].pExpr; + if( pX->pLeft ){ + pC = sqlite3ExprCompareCollSeq(pHidden->pParse, pX); + } + zRet = (pC ? pC->zName : sqlite3StrBINARY); + } + return zRet; +} + +/* +** Return true if constraint iCons is really an IN(...) constraint, or +** false otherwise. If iCons is an IN(...) constraint, set (if bHandle!=0) +** or clear (if bHandle==0) the flag to handle it using an iterator. +*/ +SQLITE_API int sqlite3_vtab_in(sqlite3_index_info *pIdxInfo, int iCons, int bHandle){ + HiddenIndexInfo *pHidden = (HiddenIndexInfo*)&pIdxInfo[1]; + u32 m = SMASKBIT32(iCons); + if( m & pHidden->mIn ){ + if( bHandle==0 ){ + pHidden->mHandleIn &= ~m; + }else if( bHandle>0 ){ + pHidden->mHandleIn |= m; + } + return 1; + } + return 0; +} + +/* +** This interface is callable from within the xBestIndex callback only. +** +** If possible, set (*ppVal) to point to an object containing the value +** on the right-hand-side of constraint iCons. +*/ +SQLITE_API int sqlite3_vtab_rhs_value( + sqlite3_index_info *pIdxInfo, /* Copy of first argument to xBestIndex */ + int iCons, /* Constraint for which RHS is wanted */ + sqlite3_value **ppVal /* Write value extracted here */ +){ + HiddenIndexInfo *pH = (HiddenIndexInfo*)&pIdxInfo[1]; + sqlite3_value *pVal = 0; + int rc = SQLITE_OK; + if( iCons<0 || iCons>=pIdxInfo->nConstraint ){ + rc = SQLITE_MISUSE; /* EV: R-30545-25046 */ + }else{ + if( pH->aRhs[iCons]==0 ){ + WhereTerm *pTerm = &pH->pWC->a[pIdxInfo->aConstraint[iCons].iTermOffset]; + rc = sqlite3ValueFromExpr( + pH->pParse->db, pTerm->pExpr->pRight, ENC(pH->pParse->db), + SQLITE_AFF_BLOB, &pH->aRhs[iCons] + ); + testcase( rc!=SQLITE_OK ); + } + pVal = pH->aRhs[iCons]; + } + *ppVal = pVal; + + if( rc==SQLITE_OK && pVal==0 ){ /* IMP: R-19933-32160 */ + rc = SQLITE_NOTFOUND; /* IMP: R-36424-56542 */ + } + + return rc; +} + +/* +** Return true if ORDER BY clause may be handled as DISTINCT. +*/ +SQLITE_API int sqlite3_vtab_distinct(sqlite3_index_info *pIdxInfo){ + HiddenIndexInfo *pHidden = (HiddenIndexInfo*)&pIdxInfo[1]; + assert( pHidden->eDistinct>=0 && pHidden->eDistinct<=3 ); + return pHidden->eDistinct; +} + +/* +** Cause the prepared statement that is associated with a call to +** xBestIndex to potentially use all schemas. If the statement being +** prepared is read-only, then just start read transactions on all +** schemas. But if this is a write operation, start writes on all +** schemas. +** +** This is used by the (built-in) sqlite_dbpage virtual table. +*/ +SQLITE_PRIVATE void sqlite3VtabUsesAllSchemas(Parse *pParse){ + int nDb = pParse->db->nDb; + int i; + for(i=0; iwriteMask) ){ + for(i=0; ipNew->iTab. That table is guaranteed to be a virtual table. +** +** If there are no LEFT or CROSS JOIN joins in the query, both mPrereq and +** mUnusable are set to 0. Otherwise, mPrereq is a mask of all FROM clause +** entries that occur before the virtual table in the FROM clause and are +** separated from it by at least one LEFT or CROSS JOIN. Similarly, the +** mUnusable mask contains all FROM clause entries that occur after the +** virtual table and are separated from it by at least one LEFT or +** CROSS JOIN. +** +** For example, if the query were: +** +** ... FROM t1, t2 LEFT JOIN t3, t4, vt CROSS JOIN t5, t6; +** +** then mPrereq corresponds to (t1, t2) and mUnusable to (t5, t6). +** +** All the tables in mPrereq must be scanned before the current virtual +** table. So any terms for which all prerequisites are satisfied by +** mPrereq may be specified as "usable" in all calls to xBestIndex. +** Conversely, all tables in mUnusable must be scanned after the current +** virtual table, so any terms for which the prerequisites overlap with +** mUnusable should always be configured as "not-usable" for xBestIndex. +*/ +static int whereLoopAddVirtual( + WhereLoopBuilder *pBuilder, /* WHERE clause information */ + Bitmask mPrereq, /* Tables that must be scanned before this one */ + Bitmask mUnusable /* Tables that must be scanned after this one */ +){ + int rc = SQLITE_OK; /* Return code */ + WhereInfo *pWInfo; /* WHERE analysis context */ + Parse *pParse; /* The parsing context */ + WhereClause *pWC; /* The WHERE clause */ + SrcItem *pSrc; /* The FROM clause term to search */ + sqlite3_index_info *p; /* Object to pass to xBestIndex() */ + int nConstraint; /* Number of constraints in p */ + int bIn; /* True if plan uses IN(...) operator */ + WhereLoop *pNew; + Bitmask mBest; /* Tables used by best possible plan */ + u16 mNoOmit; + int bRetry = 0; /* True to retry with LIMIT/OFFSET disabled */ + + assert( (mPrereq & mUnusable)==0 ); + pWInfo = pBuilder->pWInfo; + pParse = pWInfo->pParse; + pWC = pBuilder->pWC; + pNew = pBuilder->pNew; + pSrc = &pWInfo->pTabList->a[pNew->iTab]; + assert( IsVirtual(pSrc->pTab) ); + p = allocateIndexInfo(pWInfo, pWC, mUnusable, pSrc, &mNoOmit); + if( p==0 ) return SQLITE_NOMEM_BKPT; + pNew->rSetup = 0; + pNew->wsFlags = WHERE_VIRTUALTABLE; + pNew->nLTerm = 0; + pNew->u.vtab.needFree = 0; + nConstraint = p->nConstraint; + if( whereLoopResize(pParse->db, pNew, nConstraint) ){ + freeIndexInfo(pParse->db, p); + return SQLITE_NOMEM_BKPT; + } + + /* First call xBestIndex() with all constraints usable. */ + WHERETRACE(0x800, ("BEGIN %s.addVirtual()\n", pSrc->pTab->zName)); + WHERETRACE(0x800, (" VirtualOne: all usable\n")); + rc = whereLoopAddVirtualOne( + pBuilder, mPrereq, ALLBITS, 0, p, mNoOmit, &bIn, &bRetry + ); + if( bRetry ){ + assert( rc==SQLITE_OK ); + rc = whereLoopAddVirtualOne( + pBuilder, mPrereq, ALLBITS, 0, p, mNoOmit, &bIn, 0 + ); + } + + /* If the call to xBestIndex() with all terms enabled produced a plan + ** that does not require any source tables (IOW: a plan with mBest==0) + ** and does not use an IN(...) operator, then there is no point in making + ** any further calls to xBestIndex() since they will all return the same + ** result (if the xBestIndex() implementation is sane). */ + if( rc==SQLITE_OK && ((mBest = (pNew->prereq & ~mPrereq))!=0 || bIn) ){ + int seenZero = 0; /* True if a plan with no prereqs seen */ + int seenZeroNoIN = 0; /* Plan with no prereqs and no IN(...) seen */ + Bitmask mPrev = 0; + Bitmask mBestNoIn = 0; + + /* If the plan produced by the earlier call uses an IN(...) term, call + ** xBestIndex again, this time with IN(...) terms disabled. */ + if( bIn ){ + WHERETRACE(0x800, (" VirtualOne: all usable w/o IN\n")); + rc = whereLoopAddVirtualOne( + pBuilder, mPrereq, ALLBITS, WO_IN, p, mNoOmit, &bIn, 0); + assert( bIn==0 ); + mBestNoIn = pNew->prereq & ~mPrereq; + if( mBestNoIn==0 ){ + seenZero = 1; + seenZeroNoIN = 1; + } + } + + /* Call xBestIndex once for each distinct value of (prereqRight & ~mPrereq) + ** in the set of terms that apply to the current virtual table. */ + while( rc==SQLITE_OK ){ + int i; + Bitmask mNext = ALLBITS; + assert( mNext>0 ); + for(i=0; ia[p->aConstraint[i].iTermOffset].prereqRight & ~mPrereq + ); + if( mThis>mPrev && mThisprereq==mPrereq ){ + seenZero = 1; + if( bIn==0 ) seenZeroNoIN = 1; + } + } + + /* If the calls to xBestIndex() in the above loop did not find a plan + ** that requires no source tables at all (i.e. one guaranteed to be + ** usable), make a call here with all source tables disabled */ + if( rc==SQLITE_OK && seenZero==0 ){ + WHERETRACE(0x800, (" VirtualOne: all disabled\n")); + rc = whereLoopAddVirtualOne( + pBuilder, mPrereq, mPrereq, 0, p, mNoOmit, &bIn, 0); + if( bIn==0 ) seenZeroNoIN = 1; + } + + /* If the calls to xBestIndex() have so far failed to find a plan + ** that requires no source tables at all and does not use an IN(...) + ** operator, make a final call to obtain one here. */ + if( rc==SQLITE_OK && seenZeroNoIN==0 ){ + WHERETRACE(0x800, (" VirtualOne: all disabled and w/o IN\n")); + rc = whereLoopAddVirtualOne( + pBuilder, mPrereq, mPrereq, WO_IN, p, mNoOmit, &bIn, 0); + } + } + + if( p->needToFreeIdxStr ) sqlite3_free(p->idxStr); + freeIndexInfo(pParse->db, p); + WHERETRACE(0x800, ("END %s.addVirtual(), rc=%d\n", pSrc->pTab->zName, rc)); + return rc; +} +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + +/* +** Add WhereLoop entries to handle OR terms. This works for either +** btrees or virtual tables. +*/ +static int whereLoopAddOr( + WhereLoopBuilder *pBuilder, + Bitmask mPrereq, + Bitmask mUnusable +){ + WhereInfo *pWInfo = pBuilder->pWInfo; + WhereClause *pWC; + WhereLoop *pNew; + WhereTerm *pTerm, *pWCEnd; + int rc = SQLITE_OK; + int iCur; + WhereClause tempWC; + WhereLoopBuilder sSubBuild; + WhereOrSet sSum, sCur; + SrcItem *pItem; + + pWC = pBuilder->pWC; + pWCEnd = pWC->a + pWC->nTerm; + pNew = pBuilder->pNew; + memset(&sSum, 0, sizeof(sSum)); + pItem = pWInfo->pTabList->a + pNew->iTab; + iCur = pItem->iCursor; + + /* The multi-index OR optimization does not work for RIGHT and FULL JOIN */ + if( pItem->fg.jointype & JT_RIGHT ) return SQLITE_OK; + + for(pTerm=pWC->a; pTermeOperator & WO_OR)!=0 + && (pTerm->u.pOrInfo->indexable & pNew->maskSelf)!=0 + ){ + WhereClause * const pOrWC = &pTerm->u.pOrInfo->wc; + WhereTerm * const pOrWCEnd = &pOrWC->a[pOrWC->nTerm]; + WhereTerm *pOrTerm; + int once = 1; + int i, j; + + sSubBuild = *pBuilder; + sSubBuild.pOrSet = &sCur; + + WHERETRACE(0x400, ("Begin processing OR-clause %p\n", pTerm)); + for(pOrTerm=pOrWC->a; pOrTermeOperator & WO_AND)!=0 ){ + sSubBuild.pWC = &pOrTerm->u.pAndInfo->wc; + }else if( pOrTerm->leftCursor==iCur ){ + tempWC.pWInfo = pWC->pWInfo; + tempWC.pOuter = pWC; + tempWC.op = TK_AND; + tempWC.nTerm = 1; + tempWC.nBase = 1; + tempWC.a = pOrTerm; + sSubBuild.pWC = &tempWC; + }else{ + continue; + } + sCur.n = 0; +#ifdef WHERETRACE_ENABLED + WHERETRACE(0x400, ("OR-term %d of %p has %d subterms:\n", + (int)(pOrTerm-pOrWC->a), pTerm, sSubBuild.pWC->nTerm)); + if( sqlite3WhereTrace & 0x20000 ){ + sqlite3WhereClausePrint(sSubBuild.pWC); + } +#endif +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pItem->pTab) ){ + rc = whereLoopAddVirtual(&sSubBuild, mPrereq, mUnusable); + }else +#endif + { + rc = whereLoopAddBtree(&sSubBuild, mPrereq); + } + if( rc==SQLITE_OK ){ + rc = whereLoopAddOr(&sSubBuild, mPrereq, mUnusable); + } + testcase( rc==SQLITE_NOMEM && sCur.n>0 ); + testcase( rc==SQLITE_DONE ); + if( sCur.n==0 ){ + sSum.n = 0; + break; + }else if( once ){ + whereOrMove(&sSum, &sCur); + once = 0; + }else{ + WhereOrSet sPrev; + whereOrMove(&sPrev, &sSum); + sSum.n = 0; + for(i=0; inLTerm = 1; + pNew->aLTerm[0] = pTerm; + pNew->wsFlags = WHERE_MULTI_OR; + pNew->rSetup = 0; + pNew->iSortIdx = 0; + memset(&pNew->u, 0, sizeof(pNew->u)); + for(i=0; rc==SQLITE_OK && irRun = sSum.a[i].rRun + 1; + pNew->nOut = sSum.a[i].nOut; + pNew->prereq = sSum.a[i].prereq; + rc = whereLoopInsert(pBuilder, pNew); + } + WHERETRACE(0x400, ("End processing OR-clause %p\n", pTerm)); + } + } + return rc; +} + +/* +** Add all WhereLoop objects for all tables +*/ +static int whereLoopAddAll(WhereLoopBuilder *pBuilder){ + WhereInfo *pWInfo = pBuilder->pWInfo; + Bitmask mPrereq = 0; + Bitmask mPrior = 0; + int iTab; + SrcList *pTabList = pWInfo->pTabList; + SrcItem *pItem; + SrcItem *pEnd = &pTabList->a[pWInfo->nLevel]; + sqlite3 *db = pWInfo->pParse->db; + int rc = SQLITE_OK; + int bFirstPastRJ = 0; + int hasRightJoin = 0; + WhereLoop *pNew; + + + /* Loop over the tables in the join, from left to right */ + pNew = pBuilder->pNew; + + /* Verify that pNew has already been initialized */ + assert( pNew->nLTerm==0 ); + assert( pNew->wsFlags==0 ); + assert( pNew->nLSlot>=ArraySize(pNew->aLTermSpace) ); + assert( pNew->aLTerm!=0 ); + + pBuilder->iPlanLimit = SQLITE_QUERY_PLANNER_LIMIT; + for(iTab=0, pItem=pTabList->a; pItemiTab = iTab; + pBuilder->iPlanLimit += SQLITE_QUERY_PLANNER_LIMIT_INCR; + pNew->maskSelf = sqlite3WhereGetMask(&pWInfo->sMaskSet, pItem->iCursor); + if( bFirstPastRJ + || (pItem->fg.jointype & (JT_OUTER|JT_CROSS|JT_LTORJ))!=0 + ){ + /* Add prerequisites to prevent reordering of FROM clause terms + ** across CROSS joins and outer joins. The bFirstPastRJ boolean + ** prevents the right operand of a RIGHT JOIN from being swapped with + ** other elements even further to the right. + ** + ** The JT_LTORJ case and the hasRightJoin flag work together to + ** prevent FROM-clause terms from moving from the right side of + ** a LEFT JOIN over to the left side of that join if the LEFT JOIN + ** is itself on the left side of a RIGHT JOIN. + */ + if( pItem->fg.jointype & JT_LTORJ ) hasRightJoin = 1; + mPrereq |= mPrior; + bFirstPastRJ = (pItem->fg.jointype & JT_RIGHT)!=0; + }else if( !hasRightJoin ){ + mPrereq = 0; + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pItem->pTab) ){ + SrcItem *p; + for(p=&pItem[1]; pfg.jointype & (JT_OUTER|JT_CROSS)) ){ + mUnusable |= sqlite3WhereGetMask(&pWInfo->sMaskSet, p->iCursor); + } + } + rc = whereLoopAddVirtual(pBuilder, mPrereq, mUnusable); + }else +#endif /* SQLITE_OMIT_VIRTUALTABLE */ + { + rc = whereLoopAddBtree(pBuilder, mPrereq); + } + if( rc==SQLITE_OK && pBuilder->pWC->hasOr ){ + rc = whereLoopAddOr(pBuilder, mPrereq, mUnusable); + } + mPrior |= pNew->maskSelf; + if( rc || db->mallocFailed ){ + if( rc==SQLITE_DONE ){ + /* We hit the query planner search limit set by iPlanLimit */ + sqlite3_log(SQLITE_WARNING, "abbreviated query algorithm search"); + rc = SQLITE_OK; + }else{ + break; + } + } + } + + whereLoopClear(db, pNew); + return rc; +} + +/* +** Examine a WherePath (with the addition of the extra WhereLoop of the 6th +** parameters) to see if it outputs rows in the requested ORDER BY +** (or GROUP BY) without requiring a separate sort operation. Return N: +** +** N>0: N terms of the ORDER BY clause are satisfied +** N==0: No terms of the ORDER BY clause are satisfied +** N<0: Unknown yet how many terms of ORDER BY might be satisfied. +** +** Note that processing for WHERE_GROUPBY and WHERE_DISTINCTBY is not as +** strict. With GROUP BY and DISTINCT the only requirement is that +** equivalent rows appear immediately adjacent to one another. GROUP BY +** and DISTINCT do not require rows to appear in any particular order as long +** as equivalent rows are grouped together. Thus for GROUP BY and DISTINCT +** the pOrderBy terms can be matched in any order. With ORDER BY, the +** pOrderBy terms must be matched in strict left-to-right order. +*/ +static i8 wherePathSatisfiesOrderBy( + WhereInfo *pWInfo, /* The WHERE clause */ + ExprList *pOrderBy, /* ORDER BY or GROUP BY or DISTINCT clause to check */ + WherePath *pPath, /* The WherePath to check */ + u16 wctrlFlags, /* WHERE_GROUPBY or _DISTINCTBY or _ORDERBY_LIMIT */ + u16 nLoop, /* Number of entries in pPath->aLoop[] */ + WhereLoop *pLast, /* Add this WhereLoop to the end of pPath->aLoop[] */ + Bitmask *pRevMask /* OUT: Mask of WhereLoops to run in reverse order */ +){ + u8 revSet; /* True if rev is known */ + u8 rev; /* Composite sort order */ + u8 revIdx; /* Index sort order */ + u8 isOrderDistinct; /* All prior WhereLoops are order-distinct */ + u8 distinctColumns; /* True if the loop has UNIQUE NOT NULL columns */ + u8 isMatch; /* iColumn matches a term of the ORDER BY clause */ + u16 eqOpMask; /* Allowed equality operators */ + u16 nKeyCol; /* Number of key columns in pIndex */ + u16 nColumn; /* Total number of ordered columns in the index */ + u16 nOrderBy; /* Number terms in the ORDER BY clause */ + int iLoop; /* Index of WhereLoop in pPath being processed */ + int i, j; /* Loop counters */ + int iCur; /* Cursor number for current WhereLoop */ + int iColumn; /* A column number within table iCur */ + WhereLoop *pLoop = 0; /* Current WhereLoop being processed. */ + WhereTerm *pTerm; /* A single term of the WHERE clause */ + Expr *pOBExpr; /* An expression from the ORDER BY clause */ + CollSeq *pColl; /* COLLATE function from an ORDER BY clause term */ + Index *pIndex; /* The index associated with pLoop */ + sqlite3 *db = pWInfo->pParse->db; /* Database connection */ + Bitmask obSat = 0; /* Mask of ORDER BY terms satisfied so far */ + Bitmask obDone; /* Mask of all ORDER BY terms */ + Bitmask orderDistinctMask; /* Mask of all well-ordered loops */ + Bitmask ready; /* Mask of inner loops */ + + /* + ** We say the WhereLoop is "one-row" if it generates no more than one + ** row of output. A WhereLoop is one-row if all of the following are true: + ** (a) All index columns match with WHERE_COLUMN_EQ. + ** (b) The index is unique + ** Any WhereLoop with an WHERE_COLUMN_EQ constraint on the rowid is one-row. + ** Every one-row WhereLoop will have the WHERE_ONEROW bit set in wsFlags. + ** + ** We say the WhereLoop is "order-distinct" if the set of columns from + ** that WhereLoop that are in the ORDER BY clause are different for every + ** row of the WhereLoop. Every one-row WhereLoop is automatically + ** order-distinct. A WhereLoop that has no columns in the ORDER BY clause + ** is not order-distinct. To be order-distinct is not quite the same as being + ** UNIQUE since a UNIQUE column or index can have multiple rows that + ** are NULL and NULL values are equivalent for the purpose of order-distinct. + ** To be order-distinct, the columns must be UNIQUE and NOT NULL. + ** + ** The rowid for a table is always UNIQUE and NOT NULL so whenever the + ** rowid appears in the ORDER BY clause, the corresponding WhereLoop is + ** automatically order-distinct. + */ + + assert( pOrderBy!=0 ); + if( nLoop && OptimizationDisabled(db, SQLITE_OrderByIdxJoin) ) return 0; + + nOrderBy = pOrderBy->nExpr; + testcase( nOrderBy==BMS-1 ); + if( nOrderBy>BMS-1 ) return 0; /* Cannot optimize overly large ORDER BYs */ + isOrderDistinct = 1; + obDone = MASKBIT(nOrderBy)-1; + orderDistinctMask = 0; + ready = 0; + eqOpMask = WO_EQ | WO_IS | WO_ISNULL; + if( wctrlFlags & (WHERE_ORDERBY_LIMIT|WHERE_ORDERBY_MAX|WHERE_ORDERBY_MIN) ){ + eqOpMask |= WO_IN; + } + for(iLoop=0; isOrderDistinct && obSat0 ) ready |= pLoop->maskSelf; + if( iLoopaLoop[iLoop]; + if( wctrlFlags & WHERE_ORDERBY_LIMIT ) continue; + }else{ + pLoop = pLast; + } + if( pLoop->wsFlags & WHERE_VIRTUALTABLE ){ + if( pLoop->u.vtab.isOrdered + && ((wctrlFlags&(WHERE_DISTINCTBY|WHERE_SORTBYGROUP))!=WHERE_DISTINCTBY) + ){ + obSat = obDone; + } + break; + }else if( wctrlFlags & WHERE_DISTINCTBY ){ + pLoop->u.btree.nDistinctCol = 0; + } + iCur = pWInfo->pTabList->a[pLoop->iTab].iCursor; + + /* Mark off any ORDER BY term X that is a column in the table of + ** the current loop for which there is term in the WHERE + ** clause of the form X IS NULL or X=? that reference only outer + ** loops. + */ + for(i=0; ia[i].pExpr); + if( NEVER(pOBExpr==0) ) continue; + if( pOBExpr->op!=TK_COLUMN && pOBExpr->op!=TK_AGG_COLUMN ) continue; + if( pOBExpr->iTable!=iCur ) continue; + pTerm = sqlite3WhereFindTerm(&pWInfo->sWC, iCur, pOBExpr->iColumn, + ~ready, eqOpMask, 0); + if( pTerm==0 ) continue; + if( pTerm->eOperator==WO_IN ){ + /* IN terms are only valid for sorting in the ORDER BY LIMIT + ** optimization, and then only if they are actually used + ** by the query plan */ + assert( wctrlFlags & + (WHERE_ORDERBY_LIMIT|WHERE_ORDERBY_MIN|WHERE_ORDERBY_MAX) ); + for(j=0; jnLTerm && pTerm!=pLoop->aLTerm[j]; j++){} + if( j>=pLoop->nLTerm ) continue; + } + if( (pTerm->eOperator&(WO_EQ|WO_IS))!=0 && pOBExpr->iColumn>=0 ){ + Parse *pParse = pWInfo->pParse; + CollSeq *pColl1 = sqlite3ExprNNCollSeq(pParse, pOrderBy->a[i].pExpr); + CollSeq *pColl2 = sqlite3ExprCompareCollSeq(pParse, pTerm->pExpr); + assert( pColl1 ); + if( pColl2==0 || sqlite3StrICmp(pColl1->zName, pColl2->zName) ){ + continue; + } + testcase( pTerm->pExpr->op==TK_IS ); + } + obSat |= MASKBIT(i); + } + + if( (pLoop->wsFlags & WHERE_ONEROW)==0 ){ + if( pLoop->wsFlags & WHERE_IPK ){ + pIndex = 0; + nKeyCol = 0; + nColumn = 1; + }else if( (pIndex = pLoop->u.btree.pIndex)==0 || pIndex->bUnordered ){ + return 0; + }else{ + nKeyCol = pIndex->nKeyCol; + nColumn = pIndex->nColumn; + assert( nColumn==nKeyCol+1 || !HasRowid(pIndex->pTable) ); + assert( pIndex->aiColumn[nColumn-1]==XN_ROWID + || !HasRowid(pIndex->pTable)); + /* All relevant terms of the index must also be non-NULL in order + ** for isOrderDistinct to be true. So the isOrderDistint value + ** computed here might be a false positive. Corrections will be + ** made at tag-20210426-1 below */ + isOrderDistinct = IsUniqueIndex(pIndex) + && (pLoop->wsFlags & WHERE_SKIPSCAN)==0; + } + + /* Loop through all columns of the index and deal with the ones + ** that are not constrained by == or IN. + */ + rev = revSet = 0; + distinctColumns = 0; + for(j=0; j=pLoop->u.btree.nEq + || (pLoop->aLTerm[j]==0)==(jnSkip) + ); + if( ju.btree.nEq && j>=pLoop->nSkip ){ + u16 eOp = pLoop->aLTerm[j]->eOperator; + + /* Skip over == and IS and ISNULL terms. (Also skip IN terms when + ** doing WHERE_ORDERBY_LIMIT processing). Except, IS and ISNULL + ** terms imply that the index is not UNIQUE NOT NULL in which case + ** the loop need to be marked as not order-distinct because it can + ** have repeated NULL rows. + ** + ** If the current term is a column of an ((?,?) IN (SELECT...)) + ** expression for which the SELECT returns more than one column, + ** check that it is the only column used by this loop. Otherwise, + ** if it is one of two or more, none of the columns can be + ** considered to match an ORDER BY term. + */ + if( (eOp & eqOpMask)!=0 ){ + if( eOp & (WO_ISNULL|WO_IS) ){ + testcase( eOp & WO_ISNULL ); + testcase( eOp & WO_IS ); + testcase( isOrderDistinct ); + isOrderDistinct = 0; + } + continue; + }else if( ALWAYS(eOp & WO_IN) ){ + /* ALWAYS() justification: eOp is an equality operator due to the + ** ju.btree.nEq constraint above. Any equality other + ** than WO_IN is captured by the previous "if". So this one + ** always has to be WO_IN. */ + Expr *pX = pLoop->aLTerm[j]->pExpr; + for(i=j+1; iu.btree.nEq; i++){ + if( pLoop->aLTerm[i]->pExpr==pX ){ + assert( (pLoop->aLTerm[i]->eOperator & WO_IN) ); + bOnce = 0; + break; + } + } + } + } + + /* Get the column number in the table (iColumn) and sort order + ** (revIdx) for the j-th column of the index. + */ + if( pIndex ){ + iColumn = pIndex->aiColumn[j]; + revIdx = pIndex->aSortOrder[j] & KEYINFO_ORDER_DESC; + if( iColumn==pIndex->pTable->iPKey ) iColumn = XN_ROWID; + }else{ + iColumn = XN_ROWID; + revIdx = 0; + } + + /* An unconstrained column that might be NULL means that this + ** WhereLoop is not well-ordered. tag-20210426-1 + */ + if( isOrderDistinct ){ + if( iColumn>=0 + && j>=pLoop->u.btree.nEq + && pIndex->pTable->aCol[iColumn].notNull==0 + ){ + isOrderDistinct = 0; + } + if( iColumn==XN_EXPR ){ + isOrderDistinct = 0; + } + } + + /* Find the ORDER BY term that corresponds to the j-th column + ** of the index and mark that ORDER BY term off + */ + isMatch = 0; + for(i=0; bOnce && ia[i].pExpr); + testcase( wctrlFlags & WHERE_GROUPBY ); + testcase( wctrlFlags & WHERE_DISTINCTBY ); + if( NEVER(pOBExpr==0) ) continue; + if( (wctrlFlags & (WHERE_GROUPBY|WHERE_DISTINCTBY))==0 ) bOnce = 0; + if( iColumn>=XN_ROWID ){ + if( pOBExpr->op!=TK_COLUMN && pOBExpr->op!=TK_AGG_COLUMN ) continue; + if( pOBExpr->iTable!=iCur ) continue; + if( pOBExpr->iColumn!=iColumn ) continue; + }else{ + Expr *pIxExpr = pIndex->aColExpr->a[j].pExpr; + if( sqlite3ExprCompareSkip(pOBExpr, pIxExpr, iCur) ){ + continue; + } + } + if( iColumn!=XN_ROWID ){ + pColl = sqlite3ExprNNCollSeq(pWInfo->pParse, pOrderBy->a[i].pExpr); + if( sqlite3StrICmp(pColl->zName, pIndex->azColl[j])!=0 ) continue; + } + if( wctrlFlags & WHERE_DISTINCTBY ){ + pLoop->u.btree.nDistinctCol = j+1; + } + isMatch = 1; + break; + } + if( isMatch && (wctrlFlags & WHERE_GROUPBY)==0 ){ + /* Make sure the sort order is compatible in an ORDER BY clause. + ** Sort order is irrelevant for a GROUP BY clause. */ + if( revSet ){ + if( (rev ^ revIdx) + != (pOrderBy->a[i].fg.sortFlags&KEYINFO_ORDER_DESC) + ){ + isMatch = 0; + } + }else{ + rev = revIdx ^ (pOrderBy->a[i].fg.sortFlags & KEYINFO_ORDER_DESC); + if( rev ) *pRevMask |= MASKBIT(iLoop); + revSet = 1; + } + } + if( isMatch && (pOrderBy->a[i].fg.sortFlags & KEYINFO_ORDER_BIGNULL) ){ + if( j==pLoop->u.btree.nEq ){ + pLoop->wsFlags |= WHERE_BIGNULL_SORT; + }else{ + isMatch = 0; + } + } + if( isMatch ){ + if( iColumn==XN_ROWID ){ + testcase( distinctColumns==0 ); + distinctColumns = 1; + } + obSat |= MASKBIT(i); + }else{ + /* No match found */ + if( j==0 || jmaskSelf; + for(i=0; ia[i].pExpr; + mTerm = sqlite3WhereExprUsage(&pWInfo->sMaskSet,p); + if( mTerm==0 && !sqlite3ExprIsConstant(p) ) continue; + if( (mTerm&~orderDistinctMask)==0 ){ + obSat |= MASKBIT(i); + } + } + } + } /* End the loop over all WhereLoops from outer-most down to inner-most */ + if( obSat==obDone ) return (i8)nOrderBy; + if( !isOrderDistinct ){ + for(i=nOrderBy-1; i>0; i--){ + Bitmask m = ALWAYS(iwctrlFlags & (WHERE_GROUPBY|WHERE_DISTINCTBY) ); + assert( pWInfo->wctrlFlags & WHERE_SORTBYGROUP ); + return pWInfo->sorted; +} + +#ifdef WHERETRACE_ENABLED +/* For debugging use only: */ +static const char *wherePathName(WherePath *pPath, int nLoop, WhereLoop *pLast){ + static char zName[65]; + int i; + for(i=0; iaLoop[i]->cId; } + if( pLast ) zName[i++] = pLast->cId; + zName[i] = 0; + return zName; +} +#endif + +/* +** Return the cost of sorting nRow rows, assuming that the keys have +** nOrderby columns and that the first nSorted columns are already in +** order. +*/ +static LogEst whereSortingCost( + WhereInfo *pWInfo, /* Query planning context */ + LogEst nRow, /* Estimated number of rows to sort */ + int nOrderBy, /* Number of ORDER BY clause terms */ + int nSorted /* Number of initial ORDER BY terms naturally in order */ +){ + /* Estimated cost of a full external sort, where N is + ** the number of rows to sort is: + ** + ** cost = (K * N * log(N)). + ** + ** Or, if the order-by clause has X terms but only the last Y + ** terms are out of order, then block-sorting will reduce the + ** sorting cost to: + ** + ** cost = (K * N * log(N)) * (Y/X) + ** + ** The constant K is at least 2.0 but will be larger if there are a + ** large number of columns to be sorted, as the sorting time is + ** proportional to the amount of content to be sorted. The algorithm + ** does not currently distinguish between fat columns (BLOBs and TEXTs) + ** and skinny columns (INTs). It just uses the number of columns as + ** an approximation for the row width. + ** + ** And extra factor of 2.0 or 3.0 is added to the sorting cost if the sort + ** is built using OP_IdxInsert and OP_Sort rather than with OP_SorterInsert. + */ + LogEst rSortCost, nCol; + assert( pWInfo->pSelect!=0 ); + assert( pWInfo->pSelect->pEList!=0 ); + /* TUNING: sorting cost proportional to the number of output columns: */ + nCol = sqlite3LogEst((pWInfo->pSelect->pEList->nExpr+59)/30); + rSortCost = nRow + nCol; + if( nSorted>0 ){ + /* Scale the result by (Y/X) */ + rSortCost += sqlite3LogEst((nOrderBy-nSorted)*100/nOrderBy) - 66; + } + + /* Multiple by log(M) where M is the number of output rows. + ** Use the LIMIT for M if it is smaller. Or if this sort is for + ** a DISTINCT operator, M will be the number of distinct output + ** rows, so fudge it downwards a bit. + */ + if( (pWInfo->wctrlFlags & WHERE_USE_LIMIT)!=0 ){ + rSortCost += 10; /* TUNING: Extra 2.0x if using LIMIT */ + if( nSorted!=0 ){ + rSortCost += 6; /* TUNING: Extra 1.5x if also using partial sort */ + } + if( pWInfo->iLimitiLimit; + } + }else if( (pWInfo->wctrlFlags & WHERE_WANT_DISTINCT) ){ + /* TUNING: In the sort for a DISTINCT operator, assume that the DISTINCT + ** reduces the number of output rows by a factor of 2 */ + if( nRow>10 ){ nRow -= 10; assert( 10==sqlite3LogEst(2) ); } + } + rSortCost += estLog(nRow); + return rSortCost; +} + +/* +** Given the list of WhereLoop objects at pWInfo->pLoops, this routine +** attempts to find the lowest cost path that visits each WhereLoop +** once. This path is then loaded into the pWInfo->a[].pWLoop fields. +** +** Assume that the total number of output rows that will need to be sorted +** will be nRowEst (in the 10*log2 representation). Or, ignore sorting +** costs if nRowEst==0. +** +** Return SQLITE_OK on success or SQLITE_NOMEM of a memory allocation +** error occurs. +*/ +static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){ + int mxChoice; /* Maximum number of simultaneous paths tracked */ + int nLoop; /* Number of terms in the join */ + Parse *pParse; /* Parsing context */ + int iLoop; /* Loop counter over the terms of the join */ + int ii, jj; /* Loop counters */ + int mxI = 0; /* Index of next entry to replace */ + int nOrderBy; /* Number of ORDER BY clause terms */ + LogEst mxCost = 0; /* Maximum cost of a set of paths */ + LogEst mxUnsorted = 0; /* Maximum unsorted cost of a set of path */ + int nTo, nFrom; /* Number of valid entries in aTo[] and aFrom[] */ + WherePath *aFrom; /* All nFrom paths at the previous level */ + WherePath *aTo; /* The nTo best paths at the current level */ + WherePath *pFrom; /* An element of aFrom[] that we are working on */ + WherePath *pTo; /* An element of aTo[] that we are working on */ + WhereLoop *pWLoop; /* One of the WhereLoop objects */ + WhereLoop **pX; /* Used to divy up the pSpace memory */ + LogEst *aSortCost = 0; /* Sorting and partial sorting costs */ + char *pSpace; /* Temporary memory used by this routine */ + int nSpace; /* Bytes of space allocated at pSpace */ + + pParse = pWInfo->pParse; + nLoop = pWInfo->nLevel; + /* TUNING: For simple queries, only the best path is tracked. + ** For 2-way joins, the 5 best paths are followed. + ** For joins of 3 or more tables, track the 10 best paths */ + mxChoice = (nLoop<=1) ? 1 : (nLoop==2 ? 5 : 10); + assert( nLoop<=pWInfo->pTabList->nSrc ); + WHERETRACE(0x002, ("---- begin solver. (nRowEst=%d)\n", nRowEst)); + + /* If nRowEst is zero and there is an ORDER BY clause, ignore it. In this + ** case the purpose of this call is to estimate the number of rows returned + ** by the overall query. Once this estimate has been obtained, the caller + ** will invoke this function a second time, passing the estimate as the + ** nRowEst parameter. */ + if( pWInfo->pOrderBy==0 || nRowEst==0 ){ + nOrderBy = 0; + }else{ + nOrderBy = pWInfo->pOrderBy->nExpr; + } + + /* Allocate and initialize space for aTo, aFrom and aSortCost[] */ + nSpace = (sizeof(WherePath)+sizeof(WhereLoop*)*nLoop)*mxChoice*2; + nSpace += sizeof(LogEst) * nOrderBy; + pSpace = sqlite3StackAllocRawNN(pParse->db, nSpace); + if( pSpace==0 ) return SQLITE_NOMEM_BKPT; + aTo = (WherePath*)pSpace; + aFrom = aTo+mxChoice; + memset(aFrom, 0, sizeof(aFrom[0])); + pX = (WhereLoop**)(aFrom+mxChoice); + for(ii=mxChoice*2, pFrom=aTo; ii>0; ii--, pFrom++, pX += nLoop){ + pFrom->aLoop = pX; + } + if( nOrderBy ){ + /* If there is an ORDER BY clause and it is not being ignored, set up + ** space for the aSortCost[] array. Each element of the aSortCost array + ** is either zero - meaning it has not yet been initialized - or the + ** cost of sorting nRowEst rows of data where the first X terms of + ** the ORDER BY clause are already in order, where X is the array + ** index. */ + aSortCost = (LogEst*)pX; + memset(aSortCost, 0, sizeof(LogEst) * nOrderBy); + } + assert( aSortCost==0 || &pSpace[nSpace]==(char*)&aSortCost[nOrderBy] ); + assert( aSortCost!=0 || &pSpace[nSpace]==(char*)pX ); + + /* Seed the search with a single WherePath containing zero WhereLoops. + ** + ** TUNING: Do not let the number of iterations go above 28. If the cost + ** of computing an automatic index is not paid back within the first 28 + ** rows, then do not use the automatic index. */ + aFrom[0].nRow = MIN(pParse->nQueryLoop, 48); assert( 48==sqlite3LogEst(28) ); + nFrom = 1; + assert( aFrom[0].isOrdered==0 ); + if( nOrderBy ){ + /* If nLoop is zero, then there are no FROM terms in the query. Since + ** in this case the query may return a maximum of one row, the results + ** are already in the requested order. Set isOrdered to nOrderBy to + ** indicate this. Or, if nLoop is greater than zero, set isOrdered to + ** -1, indicating that the result set may or may not be ordered, + ** depending on the loops added to the current plan. */ + aFrom[0].isOrdered = nLoop>0 ? -1 : nOrderBy; + } + + /* Compute successively longer WherePaths using the previous generation + ** of WherePaths as the basis for the next. Keep track of the mxChoice + ** best paths at each generation */ + for(iLoop=0; iLooppLoops; pWLoop; pWLoop=pWLoop->pNextLoop){ + LogEst nOut; /* Rows visited by (pFrom+pWLoop) */ + LogEst rCost; /* Cost of path (pFrom+pWLoop) */ + LogEst rUnsorted; /* Unsorted cost of (pFrom+pWLoop) */ + i8 isOrdered; /* isOrdered for (pFrom+pWLoop) */ + Bitmask maskNew; /* Mask of src visited by (..) */ + Bitmask revMask; /* Mask of rev-order loops for (..) */ + + if( (pWLoop->prereq & ~pFrom->maskLoop)!=0 ) continue; + if( (pWLoop->maskSelf & pFrom->maskLoop)!=0 ) continue; + if( (pWLoop->wsFlags & WHERE_AUTO_INDEX)!=0 && pFrom->nRow<3 ){ + /* Do not use an automatic index if the this loop is expected + ** to run less than 1.25 times. It is tempting to also exclude + ** automatic index usage on an outer loop, but sometimes an automatic + ** index is useful in the outer loop of a correlated subquery. */ + assert( 10==sqlite3LogEst(2) ); + continue; + } + + /* At this point, pWLoop is a candidate to be the next loop. + ** Compute its cost */ + rUnsorted = sqlite3LogEstAdd(pWLoop->rSetup,pWLoop->rRun + pFrom->nRow); + rUnsorted = sqlite3LogEstAdd(rUnsorted, pFrom->rUnsorted); + nOut = pFrom->nRow + pWLoop->nOut; + maskNew = pFrom->maskLoop | pWLoop->maskSelf; + isOrdered = pFrom->isOrdered; + if( isOrdered<0 ){ + revMask = 0; + isOrdered = wherePathSatisfiesOrderBy(pWInfo, + pWInfo->pOrderBy, pFrom, pWInfo->wctrlFlags, + iLoop, pWLoop, &revMask); + }else{ + revMask = pFrom->revLoop; + } + if( isOrdered>=0 && isOrderedwsFlags & WHERE_VIEWSCAN)!=0 ){ + rCost += -10; + nOut += -30; + } + + /* Check to see if pWLoop should be added to the set of + ** mxChoice best-so-far paths. + ** + ** First look for an existing path among best-so-far paths + ** that covers the same set of loops and has the same isOrdered + ** setting as the current path candidate. + ** + ** The term "((pTo->isOrdered^isOrdered)&0x80)==0" is equivalent + ** to (pTo->isOrdered==(-1))==(isOrdered==(-1))" for the range + ** of legal values for isOrdered, -1..64. + */ + for(jj=0, pTo=aTo; jjmaskLoop==maskNew + && ((pTo->isOrdered^isOrdered)&0x80)==0 + ){ + testcase( jj==nTo-1 ); + break; + } + } + if( jj>=nTo ){ + /* None of the existing best-so-far paths match the candidate. */ + if( nTo>=mxChoice + && (rCost>mxCost || (rCost==mxCost && rUnsorted>=mxUnsorted)) + ){ + /* The current candidate is no better than any of the mxChoice + ** paths currently in the best-so-far buffer. So discard + ** this candidate as not viable. */ +#ifdef WHERETRACE_ENABLED /* 0x4 */ + if( sqlite3WhereTrace&0x4 ){ + sqlite3DebugPrintf("Skip %s cost=%-3d,%3d,%3d order=%c\n", + wherePathName(pFrom, iLoop, pWLoop), rCost, nOut, rUnsorted, + isOrdered>=0 ? isOrdered+'0' : '?'); + } +#endif + continue; + } + /* If we reach this points it means that the new candidate path + ** needs to be added to the set of best-so-far paths. */ + if( nTo=0 ? isOrdered+'0' : '?'); + } +#endif + }else{ + /* Control reaches here if best-so-far path pTo=aTo[jj] covers the + ** same set of loops and has the same isOrdered setting as the + ** candidate path. Check to see if the candidate should replace + ** pTo or if the candidate should be skipped. + ** + ** The conditional is an expanded vector comparison equivalent to: + ** (pTo->rCost,pTo->nRow,pTo->rUnsorted) <= (rCost,nOut,rUnsorted) + */ + if( pTo->rCostrCost==rCost + && (pTo->nRownRow==nOut && pTo->rUnsorted<=rUnsorted) + ) + ) + ){ +#ifdef WHERETRACE_ENABLED /* 0x4 */ + if( sqlite3WhereTrace&0x4 ){ + sqlite3DebugPrintf( + "Skip %s cost=%-3d,%3d,%3d order=%c", + wherePathName(pFrom, iLoop, pWLoop), rCost, nOut, rUnsorted, + isOrdered>=0 ? isOrdered+'0' : '?'); + sqlite3DebugPrintf(" vs %s cost=%-3d,%3d,%3d order=%c\n", + wherePathName(pTo, iLoop+1, 0), pTo->rCost, pTo->nRow, + pTo->rUnsorted, pTo->isOrdered>=0 ? pTo->isOrdered+'0' : '?'); + } +#endif + /* Discard the candidate path from further consideration */ + testcase( pTo->rCost==rCost ); + continue; + } + testcase( pTo->rCost==rCost+1 ); + /* Control reaches here if the candidate path is better than the + ** pTo path. Replace pTo with the candidate. */ +#ifdef WHERETRACE_ENABLED /* 0x4 */ + if( sqlite3WhereTrace&0x4 ){ + sqlite3DebugPrintf( + "Update %s cost=%-3d,%3d,%3d order=%c", + wherePathName(pFrom, iLoop, pWLoop), rCost, nOut, rUnsorted, + isOrdered>=0 ? isOrdered+'0' : '?'); + sqlite3DebugPrintf(" was %s cost=%-3d,%3d,%3d order=%c\n", + wherePathName(pTo, iLoop+1, 0), pTo->rCost, pTo->nRow, + pTo->rUnsorted, pTo->isOrdered>=0 ? pTo->isOrdered+'0' : '?'); + } +#endif + } + /* pWLoop is a winner. Add it to the set of best so far */ + pTo->maskLoop = pFrom->maskLoop | pWLoop->maskSelf; + pTo->revLoop = revMask; + pTo->nRow = nOut; + pTo->rCost = rCost; + pTo->rUnsorted = rUnsorted; + pTo->isOrdered = isOrdered; + memcpy(pTo->aLoop, pFrom->aLoop, sizeof(WhereLoop*)*iLoop); + pTo->aLoop[iLoop] = pWLoop; + if( nTo>=mxChoice ){ + mxI = 0; + mxCost = aTo[0].rCost; + mxUnsorted = aTo[0].nRow; + for(jj=1, pTo=&aTo[1]; jjrCost>mxCost + || (pTo->rCost==mxCost && pTo->rUnsorted>mxUnsorted) + ){ + mxCost = pTo->rCost; + mxUnsorted = pTo->rUnsorted; + mxI = jj; + } + } + } + } + } + +#ifdef WHERETRACE_ENABLED /* >=2 */ + if( sqlite3WhereTrace & 0x02 ){ + sqlite3DebugPrintf("---- after round %d ----\n", iLoop); + for(ii=0, pTo=aTo; iirCost, pTo->nRow, + pTo->isOrdered>=0 ? (pTo->isOrdered+'0') : '?'); + if( pTo->isOrdered>0 ){ + sqlite3DebugPrintf(" rev=0x%llx\n", pTo->revLoop); + }else{ + sqlite3DebugPrintf("\n"); + } + } + } +#endif + + /* Swap the roles of aFrom and aTo for the next generation */ + pFrom = aTo; + aTo = aFrom; + aFrom = pFrom; + nFrom = nTo; + } + + if( nFrom==0 ){ + sqlite3ErrorMsg(pParse, "no query solution"); + sqlite3StackFreeNN(pParse->db, pSpace); + return SQLITE_ERROR; + } + + /* Find the lowest cost path. pFrom will be left pointing to that path */ + pFrom = aFrom; + for(ii=1; iirCost>aFrom[ii].rCost ) pFrom = &aFrom[ii]; + } + assert( pWInfo->nLevel==nLoop ); + /* Load the lowest cost path into pWInfo */ + for(iLoop=0; iLoopa + iLoop; + pLevel->pWLoop = pWLoop = pFrom->aLoop[iLoop]; + pLevel->iFrom = pWLoop->iTab; + pLevel->iTabCur = pWInfo->pTabList->a[pLevel->iFrom].iCursor; + } + if( (pWInfo->wctrlFlags & WHERE_WANT_DISTINCT)!=0 + && (pWInfo->wctrlFlags & WHERE_DISTINCTBY)==0 + && pWInfo->eDistinct==WHERE_DISTINCT_NOOP + && nRowEst + ){ + Bitmask notUsed; + int rc = wherePathSatisfiesOrderBy(pWInfo, pWInfo->pResultSet, pFrom, + WHERE_DISTINCTBY, nLoop-1, pFrom->aLoop[nLoop-1], ¬Used); + if( rc==pWInfo->pResultSet->nExpr ){ + pWInfo->eDistinct = WHERE_DISTINCT_ORDERED; + } + } + pWInfo->bOrderedInnerLoop = 0; + if( pWInfo->pOrderBy ){ + pWInfo->nOBSat = pFrom->isOrdered; + if( pWInfo->wctrlFlags & WHERE_DISTINCTBY ){ + if( pFrom->isOrdered==pWInfo->pOrderBy->nExpr ){ + pWInfo->eDistinct = WHERE_DISTINCT_ORDERED; + } + if( pWInfo->pSelect->pOrderBy + && pWInfo->nOBSat > pWInfo->pSelect->pOrderBy->nExpr ){ + pWInfo->nOBSat = pWInfo->pSelect->pOrderBy->nExpr; + } + }else{ + pWInfo->revMask = pFrom->revLoop; + if( pWInfo->nOBSat<=0 ){ + pWInfo->nOBSat = 0; + if( nLoop>0 ){ + u32 wsFlags = pFrom->aLoop[nLoop-1]->wsFlags; + if( (wsFlags & WHERE_ONEROW)==0 + && (wsFlags&(WHERE_IPK|WHERE_COLUMN_IN))!=(WHERE_IPK|WHERE_COLUMN_IN) + ){ + Bitmask m = 0; + int rc = wherePathSatisfiesOrderBy(pWInfo, pWInfo->pOrderBy, pFrom, + WHERE_ORDERBY_LIMIT, nLoop-1, pFrom->aLoop[nLoop-1], &m); + testcase( wsFlags & WHERE_IPK ); + testcase( wsFlags & WHERE_COLUMN_IN ); + if( rc==pWInfo->pOrderBy->nExpr ){ + pWInfo->bOrderedInnerLoop = 1; + pWInfo->revMask = m; + } + } + } + }else if( nLoop + && pWInfo->nOBSat==1 + && (pWInfo->wctrlFlags & (WHERE_ORDERBY_MIN|WHERE_ORDERBY_MAX))!=0 + ){ + pWInfo->bOrderedInnerLoop = 1; + } + } + if( (pWInfo->wctrlFlags & WHERE_SORTBYGROUP) + && pWInfo->nOBSat==pWInfo->pOrderBy->nExpr && nLoop>0 + ){ + Bitmask revMask = 0; + int nOrder = wherePathSatisfiesOrderBy(pWInfo, pWInfo->pOrderBy, + pFrom, 0, nLoop-1, pFrom->aLoop[nLoop-1], &revMask + ); + assert( pWInfo->sorted==0 ); + if( nOrder==pWInfo->pOrderBy->nExpr ){ + pWInfo->sorted = 1; + pWInfo->revMask = revMask; + } + } + } + + + pWInfo->nRowOut = pFrom->nRow; + + /* Free temporary memory and return success */ + sqlite3StackFreeNN(pParse->db, pSpace); + return SQLITE_OK; +} + +/* +** Most queries use only a single table (they are not joins) and have +** simple == constraints against indexed fields. This routine attempts +** to plan those simple cases using much less ceremony than the +** general-purpose query planner, and thereby yield faster sqlite3_prepare() +** times for the common case. +** +** Return non-zero on success, if this query can be handled by this +** no-frills query planner. Return zero if this query needs the +** general-purpose query planner. +*/ +static int whereShortCut(WhereLoopBuilder *pBuilder){ + WhereInfo *pWInfo; + SrcItem *pItem; + WhereClause *pWC; + WhereTerm *pTerm; + WhereLoop *pLoop; + int iCur; + int j; + Table *pTab; + Index *pIdx; + WhereScan scan; + + pWInfo = pBuilder->pWInfo; + if( pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE ) return 0; + assert( pWInfo->pTabList->nSrc>=1 ); + pItem = pWInfo->pTabList->a; + pTab = pItem->pTab; + if( IsVirtual(pTab) ) return 0; + if( pItem->fg.isIndexedBy || pItem->fg.notIndexed ){ + testcase( pItem->fg.isIndexedBy ); + testcase( pItem->fg.notIndexed ); + return 0; + } + iCur = pItem->iCursor; + pWC = &pWInfo->sWC; + pLoop = pBuilder->pNew; + pLoop->wsFlags = 0; + pLoop->nSkip = 0; + pTerm = whereScanInit(&scan, pWC, iCur, -1, WO_EQ|WO_IS, 0); + while( pTerm && pTerm->prereqRight ) pTerm = whereScanNext(&scan); + if( pTerm ){ + testcase( pTerm->eOperator & WO_IS ); + pLoop->wsFlags = WHERE_COLUMN_EQ|WHERE_IPK|WHERE_ONEROW; + pLoop->aLTerm[0] = pTerm; + pLoop->nLTerm = 1; + pLoop->u.btree.nEq = 1; + /* TUNING: Cost of a rowid lookup is 10 */ + pLoop->rRun = 33; /* 33==sqlite3LogEst(10) */ + }else{ + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + int opMask; + assert( pLoop->aLTermSpace==pLoop->aLTerm ); + if( !IsUniqueIndex(pIdx) + || pIdx->pPartIdxWhere!=0 + || pIdx->nKeyCol>ArraySize(pLoop->aLTermSpace) + ) continue; + opMask = pIdx->uniqNotNull ? (WO_EQ|WO_IS) : WO_EQ; + for(j=0; jnKeyCol; j++){ + pTerm = whereScanInit(&scan, pWC, iCur, j, opMask, pIdx); + while( pTerm && pTerm->prereqRight ) pTerm = whereScanNext(&scan); + if( pTerm==0 ) break; + testcase( pTerm->eOperator & WO_IS ); + pLoop->aLTerm[j] = pTerm; + } + if( j!=pIdx->nKeyCol ) continue; + pLoop->wsFlags = WHERE_COLUMN_EQ|WHERE_ONEROW|WHERE_INDEXED; + if( pIdx->isCovering || (pItem->colUsed & pIdx->colNotIdxed)==0 ){ + pLoop->wsFlags |= WHERE_IDX_ONLY; + } + pLoop->nLTerm = j; + pLoop->u.btree.nEq = j; + pLoop->u.btree.pIndex = pIdx; + /* TUNING: Cost of a unique index lookup is 15 */ + pLoop->rRun = 39; /* 39==sqlite3LogEst(15) */ + break; + } + } + if( pLoop->wsFlags ){ + pLoop->nOut = (LogEst)1; + pWInfo->a[0].pWLoop = pLoop; + assert( pWInfo->sMaskSet.n==1 && iCur==pWInfo->sMaskSet.ix[0] ); + pLoop->maskSelf = 1; /* sqlite3WhereGetMask(&pWInfo->sMaskSet, iCur); */ + pWInfo->a[0].iTabCur = iCur; + pWInfo->nRowOut = 1; + if( pWInfo->pOrderBy ) pWInfo->nOBSat = pWInfo->pOrderBy->nExpr; + if( pWInfo->wctrlFlags & WHERE_WANT_DISTINCT ){ + pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE; + } + if( scan.iEquiv>1 ) pLoop->wsFlags |= WHERE_TRANSCONS; +#ifdef SQLITE_DEBUG + pLoop->cId = '0'; +#endif +#ifdef WHERETRACE_ENABLED + if( sqlite3WhereTrace & 0x02 ){ + sqlite3DebugPrintf("whereShortCut() used to compute solution\n"); + } +#endif + return 1; + } + return 0; +} + +/* +** Helper function for exprIsDeterministic(). +*/ +static int exprNodeIsDeterministic(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_FUNCTION && ExprHasProperty(pExpr, EP_ConstFunc)==0 ){ + pWalker->eCode = 0; + return WRC_Abort; + } + return WRC_Continue; +} + +/* +** Return true if the expression contains no non-deterministic SQL +** functions. Do not consider non-deterministic SQL functions that are +** part of sub-select statements. +*/ +static int exprIsDeterministic(Expr *p){ + Walker w; + memset(&w, 0, sizeof(w)); + w.eCode = 1; + w.xExprCallback = exprNodeIsDeterministic; + w.xSelectCallback = sqlite3SelectWalkFail; + sqlite3WalkExpr(&w, p); + return w.eCode; +} + + +#ifdef WHERETRACE_ENABLED +/* +** Display all WhereLoops in pWInfo +*/ +static void showAllWhereLoops(WhereInfo *pWInfo, WhereClause *pWC){ + if( sqlite3WhereTrace ){ /* Display all of the WhereLoop objects */ + WhereLoop *p; + int i; + static const char zLabel[] = "0123456789abcdefghijklmnopqrstuvwyxz" + "ABCDEFGHIJKLMNOPQRSTUVWYXZ"; + for(p=pWInfo->pLoops, i=0; p; p=p->pNextLoop, i++){ + p->cId = zLabel[i%(sizeof(zLabel)-1)]; + sqlite3WhereLoopPrint(p, pWC); + } + } +} +# define WHERETRACE_ALL_LOOPS(W,C) showAllWhereLoops(W,C) +#else +# define WHERETRACE_ALL_LOOPS(W,C) +#endif + +/* Attempt to omit tables from a join that do not affect the result. +** For a table to not affect the result, the following must be true: +** +** 1) The query must not be an aggregate. +** 2) The table must be the RHS of a LEFT JOIN. +** 3) Either the query must be DISTINCT, or else the ON or USING clause +** must contain a constraint that limits the scan of the table to +** at most a single row. +** 4) The table must not be referenced by any part of the query apart +** from its own USING or ON clause. +** 5) The table must not have an inner-join ON or USING clause if there is +** a RIGHT JOIN anywhere in the query. Otherwise the ON/USING clause +** might move from the right side to the left side of the RIGHT JOIN. +** Note: Due to (2), this condition can only arise if the table is +** the right-most table of a subquery that was flattened into the +** main query and that subquery was the right-hand operand of an +** inner join that held an ON or USING clause. +** +** For example, given: +** +** CREATE TABLE t1(ipk INTEGER PRIMARY KEY, v1); +** CREATE TABLE t2(ipk INTEGER PRIMARY KEY, v2); +** CREATE TABLE t3(ipk INTEGER PRIMARY KEY, v3); +** +** then table t2 can be omitted from the following: +** +** SELECT v1, v3 FROM t1 +** LEFT JOIN t2 ON (t1.ipk=t2.ipk) +** LEFT JOIN t3 ON (t1.ipk=t3.ipk) +** +** or from: +** +** SELECT DISTINCT v1, v3 FROM t1 +** LEFT JOIN t2 +** LEFT JOIN t3 ON (t1.ipk=t3.ipk) +*/ +static SQLITE_NOINLINE Bitmask whereOmitNoopJoin( + WhereInfo *pWInfo, + Bitmask notReady +){ + int i; + Bitmask tabUsed; + int hasRightJoin; + + /* Preconditions checked by the caller */ + assert( pWInfo->nLevel>=2 ); + assert( OptimizationEnabled(pWInfo->pParse->db, SQLITE_OmitNoopJoin) ); + + /* These two preconditions checked by the caller combine to guarantee + ** condition (1) of the header comment */ + assert( pWInfo->pResultSet!=0 ); + assert( 0==(pWInfo->wctrlFlags & WHERE_AGG_DISTINCT) ); + + tabUsed = sqlite3WhereExprListUsage(&pWInfo->sMaskSet, pWInfo->pResultSet); + if( pWInfo->pOrderBy ){ + tabUsed |= sqlite3WhereExprListUsage(&pWInfo->sMaskSet, pWInfo->pOrderBy); + } + hasRightJoin = (pWInfo->pTabList->a[0].fg.jointype & JT_LTORJ)!=0; + for(i=pWInfo->nLevel-1; i>=1; i--){ + WhereTerm *pTerm, *pEnd; + SrcItem *pItem; + WhereLoop *pLoop; + pLoop = pWInfo->a[i].pWLoop; + pItem = &pWInfo->pTabList->a[pLoop->iTab]; + if( (pItem->fg.jointype & (JT_LEFT|JT_RIGHT))!=JT_LEFT ) continue; + if( (pWInfo->wctrlFlags & WHERE_WANT_DISTINCT)==0 + && (pLoop->wsFlags & WHERE_ONEROW)==0 + ){ + continue; + } + if( (tabUsed & pLoop->maskSelf)!=0 ) continue; + pEnd = pWInfo->sWC.a + pWInfo->sWC.nTerm; + for(pTerm=pWInfo->sWC.a; pTermprereqAll & pLoop->maskSelf)!=0 ){ + if( !ExprHasProperty(pTerm->pExpr, EP_OuterON) + || pTerm->pExpr->w.iJoin!=pItem->iCursor + ){ + break; + } + } + if( hasRightJoin + && ExprHasProperty(pTerm->pExpr, EP_InnerON) + && pTerm->pExpr->w.iJoin==pItem->iCursor + ){ + break; /* restriction (5) */ + } + } + if( pTerm drop loop %c not used\n", pLoop->cId)); + notReady &= ~pLoop->maskSelf; + for(pTerm=pWInfo->sWC.a; pTermprereqAll & pLoop->maskSelf)!=0 ){ + pTerm->wtFlags |= TERM_CODED; + } + } + if( i!=pWInfo->nLevel-1 ){ + int nByte = (pWInfo->nLevel-1-i) * sizeof(WhereLevel); + memmove(&pWInfo->a[i], &pWInfo->a[i+1], nByte); + } + pWInfo->nLevel--; + assert( pWInfo->nLevel>0 ); + } + return notReady; +} + +/* +** Check to see if there are any SEARCH loops that might benefit from +** using a Bloom filter. Consider a Bloom filter if: +** +** (1) The SEARCH happens more than N times where N is the number +** of rows in the table that is being considered for the Bloom +** filter. +** (2) Some searches are expected to find zero rows. (This is determined +** by the WHERE_SELFCULL flag on the term.) +** (3) Bloom-filter processing is not disabled. (Checked by the +** caller.) +** (4) The size of the table being searched is known by ANALYZE. +** +** This block of code merely checks to see if a Bloom filter would be +** appropriate, and if so sets the WHERE_BLOOMFILTER flag on the +** WhereLoop. The implementation of the Bloom filter comes further +** down where the code for each WhereLoop is generated. +*/ +static SQLITE_NOINLINE void whereCheckIfBloomFilterIsUseful( + const WhereInfo *pWInfo +){ + int i; + LogEst nSearch = 0; + + assert( pWInfo->nLevel>=2 ); + assert( OptimizationEnabled(pWInfo->pParse->db, SQLITE_BloomFilter) ); + for(i=0; inLevel; i++){ + WhereLoop *pLoop = pWInfo->a[i].pWLoop; + const unsigned int reqFlags = (WHERE_SELFCULL|WHERE_COLUMN_EQ); + SrcItem *pItem = &pWInfo->pTabList->a[pLoop->iTab]; + Table *pTab = pItem->pTab; + if( (pTab->tabFlags & TF_HasStat1)==0 ) break; + pTab->tabFlags |= TF_StatsUsed; + if( i>=1 + && (pLoop->wsFlags & reqFlags)==reqFlags + /* vvvvvv--- Always the case if WHERE_COLUMN_EQ is defined */ + && ALWAYS((pLoop->wsFlags & (WHERE_IPK|WHERE_INDEXED))!=0) + ){ + if( nSearch > pTab->nRowLogEst ){ + testcase( pItem->fg.jointype & JT_LEFT ); + pLoop->wsFlags |= WHERE_BLOOMFILTER; + pLoop->wsFlags &= ~WHERE_IDX_ONLY; + WHERETRACE(0xffffffff, ( + "-> use Bloom-filter on loop %c because there are ~%.1e " + "lookups into %s which has only ~%.1e rows\n", + pLoop->cId, (double)sqlite3LogEstToInt(nSearch), pTab->zName, + (double)sqlite3LogEstToInt(pTab->nRowLogEst))); + } + } + nSearch += pLoop->nOut; + } +} + +/* +** This is an sqlite3ParserAddCleanup() callback that is invoked to +** free the Parse->pIdxEpr list when the Parse object is destroyed. +*/ +static void whereIndexedExprCleanup(sqlite3 *db, void *pObject){ + Parse *pParse = (Parse*)pObject; + while( pParse->pIdxEpr!=0 ){ + IndexedExpr *p = pParse->pIdxEpr; + pParse->pIdxEpr = p->pIENext; + sqlite3ExprDelete(db, p->pExpr); + sqlite3DbFreeNN(db, p); + } +} + +/* +** The index pIdx is used by a query and contains one or more expressions. +** In other words pIdx is an index on an expression. iIdxCur is the cursor +** number for the index and iDataCur is the cursor number for the corresponding +** table. +** +** This routine adds IndexedExpr entries to the Parse->pIdxEpr field for +** each of the expressions in the index so that the expression code generator +** will know to replace occurrences of the indexed expression with +** references to the corresponding column of the index. +*/ +static SQLITE_NOINLINE void whereAddIndexedExpr( + Parse *pParse, /* Add IndexedExpr entries to pParse->pIdxEpr */ + Index *pIdx, /* The index-on-expression that contains the expressions */ + int iIdxCur, /* Cursor number for pIdx */ + SrcItem *pTabItem /* The FROM clause entry for the table */ +){ + int i; + IndexedExpr *p; + Table *pTab; + assert( pIdx->bHasExpr ); + pTab = pIdx->pTable; + for(i=0; inColumn; i++){ + Expr *pExpr; + int j = pIdx->aiColumn[i]; + int bMaybeNullRow; + if( j==XN_EXPR ){ + pExpr = pIdx->aColExpr->a[i].pExpr; + testcase( pTabItem->fg.jointype & JT_LEFT ); + testcase( pTabItem->fg.jointype & JT_RIGHT ); + testcase( pTabItem->fg.jointype & JT_LTORJ ); + bMaybeNullRow = (pTabItem->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT))!=0; + }else if( j>=0 && (pTab->aCol[j].colFlags & COLFLAG_VIRTUAL)!=0 ){ + pExpr = sqlite3ColumnExpr(pTab, &pTab->aCol[j]); + bMaybeNullRow = 0; + }else{ + continue; + } + if( sqlite3ExprIsConstant(pExpr) ) continue; + p = sqlite3DbMallocRaw(pParse->db, sizeof(IndexedExpr)); + if( p==0 ) break; + p->pIENext = pParse->pIdxEpr; +#ifdef WHERETRACE_ENABLED + if( sqlite3WhereTrace & 0x200 ){ + sqlite3DebugPrintf("New pParse->pIdxEpr term {%d,%d}\n", iIdxCur, i); + if( sqlite3WhereTrace & 0x5000 ) sqlite3ShowExpr(pExpr); + } +#endif + p->pExpr = sqlite3ExprDup(pParse->db, pExpr, 0); + p->iDataCur = pTabItem->iCursor; + p->iIdxCur = iIdxCur; + p->iIdxCol = i; + p->bMaybeNullRow = bMaybeNullRow; + if( sqlite3IndexAffinityStr(pParse->db, pIdx) ){ + p->aff = pIdx->zColAff[i]; + } +#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS + p->zIdxName = pIdx->zName; +#endif + pParse->pIdxEpr = p; + if( p->pIENext==0 ){ + sqlite3ParserAddCleanup(pParse, whereIndexedExprCleanup, pParse); + } + } +} + +/* +** Generate the beginning of the loop used for WHERE clause processing. +** The return value is a pointer to an opaque structure that contains +** information needed to terminate the loop. Later, the calling routine +** should invoke sqlite3WhereEnd() with the return value of this function +** in order to complete the WHERE clause processing. +** +** If an error occurs, this routine returns NULL. +** +** The basic idea is to do a nested loop, one loop for each table in +** the FROM clause of a select. (INSERT and UPDATE statements are the +** same as a SELECT with only a single table in the FROM clause.) For +** example, if the SQL is this: +** +** SELECT * FROM t1, t2, t3 WHERE ...; +** +** Then the code generated is conceptually like the following: +** +** foreach row1 in t1 do \ Code generated +** foreach row2 in t2 do |-- by sqlite3WhereBegin() +** foreach row3 in t3 do / +** ... +** end \ Code generated +** end |-- by sqlite3WhereEnd() +** end / +** +** Note that the loops might not be nested in the order in which they +** appear in the FROM clause if a different order is better able to make +** use of indices. Note also that when the IN operator appears in +** the WHERE clause, it might result in additional nested loops for +** scanning through all values on the right-hand side of the IN. +** +** There are Btree cursors associated with each table. t1 uses cursor +** number pTabList->a[0].iCursor. t2 uses the cursor pTabList->a[1].iCursor. +** And so forth. This routine generates code to open those VDBE cursors +** and sqlite3WhereEnd() generates the code to close them. +** +** The code that sqlite3WhereBegin() generates leaves the cursors named +** in pTabList pointing at their appropriate entries. The [...] code +** can use OP_Column and OP_Rowid opcodes on these cursors to extract +** data from the various tables of the loop. +** +** If the WHERE clause is empty, the foreach loops must each scan their +** entire tables. Thus a three-way join is an O(N^3) operation. But if +** the tables have indices and there are terms in the WHERE clause that +** refer to those indices, a complete table scan can be avoided and the +** code will run much faster. Most of the work of this routine is checking +** to see if there are indices that can be used to speed up the loop. +** +** Terms of the WHERE clause are also used to limit which rows actually +** make it to the "..." in the middle of the loop. After each "foreach", +** terms of the WHERE clause that use only terms in that loop and outer +** loops are evaluated and if false a jump is made around all subsequent +** inner loops (or around the "..." if the test occurs within the inner- +** most loop) +** +** OUTER JOINS +** +** An outer join of tables t1 and t2 is conceptally coded as follows: +** +** foreach row1 in t1 do +** flag = 0 +** foreach row2 in t2 do +** start: +** ... +** flag = 1 +** end +** if flag==0 then +** move the row2 cursor to a null row +** goto start +** fi +** end +** +** ORDER BY CLAUSE PROCESSING +** +** pOrderBy is a pointer to the ORDER BY clause (or the GROUP BY clause +** if the WHERE_GROUPBY flag is set in wctrlFlags) of a SELECT statement +** if there is one. If there is no ORDER BY clause or if this routine +** is called from an UPDATE or DELETE statement, then pOrderBy is NULL. +** +** The iIdxCur parameter is the cursor number of an index. If +** WHERE_OR_SUBCLAUSE is set, iIdxCur is the cursor number of an index +** to use for OR clause processing. The WHERE clause should use this +** specific cursor. If WHERE_ONEPASS_DESIRED is set, then iIdxCur is +** the first cursor in an array of cursors for all indices. iIdxCur should +** be used to compute the appropriate cursor depending on which index is +** used. +*/ +SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin( + Parse *pParse, /* The parser context */ + SrcList *pTabList, /* FROM clause: A list of all tables to be scanned */ + Expr *pWhere, /* The WHERE clause */ + ExprList *pOrderBy, /* An ORDER BY (or GROUP BY) clause, or NULL */ + ExprList *pResultSet, /* Query result set. Req'd for DISTINCT */ + Select *pSelect, /* The entire SELECT statement */ + u16 wctrlFlags, /* The WHERE_* flags defined in sqliteInt.h */ + int iAuxArg /* If WHERE_OR_SUBCLAUSE is set, index cursor number + ** If WHERE_USE_LIMIT, then the limit amount */ +){ + int nByteWInfo; /* Num. bytes allocated for WhereInfo struct */ + int nTabList; /* Number of elements in pTabList */ + WhereInfo *pWInfo; /* Will become the return value of this function */ + Vdbe *v = pParse->pVdbe; /* The virtual database engine */ + Bitmask notReady; /* Cursors that are not yet positioned */ + WhereLoopBuilder sWLB; /* The WhereLoop builder */ + WhereMaskSet *pMaskSet; /* The expression mask set */ + WhereLevel *pLevel; /* A single level in pWInfo->a[] */ + WhereLoop *pLoop; /* Pointer to a single WhereLoop object */ + int ii; /* Loop counter */ + sqlite3 *db; /* Database connection */ + int rc; /* Return code */ + u8 bFordelete = 0; /* OPFLAG_FORDELETE or zero, as appropriate */ + + assert( (wctrlFlags & WHERE_ONEPASS_MULTIROW)==0 || ( + (wctrlFlags & WHERE_ONEPASS_DESIRED)!=0 + && (wctrlFlags & WHERE_OR_SUBCLAUSE)==0 + )); + + /* Only one of WHERE_OR_SUBCLAUSE or WHERE_USE_LIMIT */ + assert( (wctrlFlags & WHERE_OR_SUBCLAUSE)==0 + || (wctrlFlags & WHERE_USE_LIMIT)==0 ); + + /* Variable initialization */ + db = pParse->db; + memset(&sWLB, 0, sizeof(sWLB)); + + /* An ORDER/GROUP BY clause of more than 63 terms cannot be optimized */ + testcase( pOrderBy && pOrderBy->nExpr==BMS-1 ); + if( pOrderBy && pOrderBy->nExpr>=BMS ) pOrderBy = 0; + + /* The number of tables in the FROM clause is limited by the number of + ** bits in a Bitmask + */ + testcase( pTabList->nSrc==BMS ); + if( pTabList->nSrc>BMS ){ + sqlite3ErrorMsg(pParse, "at most %d tables in a join", BMS); + return 0; + } + + /* This function normally generates a nested loop for all tables in + ** pTabList. But if the WHERE_OR_SUBCLAUSE flag is set, then we should + ** only generate code for the first table in pTabList and assume that + ** any cursors associated with subsequent tables are uninitialized. + */ + nTabList = (wctrlFlags & WHERE_OR_SUBCLAUSE) ? 1 : pTabList->nSrc; + + /* Allocate and initialize the WhereInfo structure that will become the + ** return value. A single allocation is used to store the WhereInfo + ** struct, the contents of WhereInfo.a[], the WhereClause structure + ** and the WhereMaskSet structure. Since WhereClause contains an 8-byte + ** field (type Bitmask) it must be aligned on an 8-byte boundary on + ** some architectures. Hence the ROUND8() below. + */ + nByteWInfo = ROUND8P(sizeof(WhereInfo)+(nTabList-1)*sizeof(WhereLevel)); + pWInfo = sqlite3DbMallocRawNN(db, nByteWInfo + sizeof(WhereLoop)); + if( db->mallocFailed ){ + sqlite3DbFree(db, pWInfo); + pWInfo = 0; + goto whereBeginError; + } + pWInfo->pParse = pParse; + pWInfo->pTabList = pTabList; + pWInfo->pOrderBy = pOrderBy; +#if WHERETRACE_ENABLED + pWInfo->pWhere = pWhere; +#endif + pWInfo->pResultSet = pResultSet; + pWInfo->aiCurOnePass[0] = pWInfo->aiCurOnePass[1] = -1; + pWInfo->nLevel = nTabList; + pWInfo->iBreak = pWInfo->iContinue = sqlite3VdbeMakeLabel(pParse); + pWInfo->wctrlFlags = wctrlFlags; + pWInfo->iLimit = iAuxArg; + pWInfo->savedNQueryLoop = pParse->nQueryLoop; + pWInfo->pSelect = pSelect; + memset(&pWInfo->nOBSat, 0, + offsetof(WhereInfo,sWC) - offsetof(WhereInfo,nOBSat)); + memset(&pWInfo->a[0], 0, sizeof(WhereLoop)+nTabList*sizeof(WhereLevel)); + assert( pWInfo->eOnePass==ONEPASS_OFF ); /* ONEPASS defaults to OFF */ + pMaskSet = &pWInfo->sMaskSet; + pMaskSet->n = 0; + pMaskSet->ix[0] = -99; /* Initialize ix[0] to a value that can never be + ** a valid cursor number, to avoid an initial + ** test for pMaskSet->n==0 in sqlite3WhereGetMask() */ + sWLB.pWInfo = pWInfo; + sWLB.pWC = &pWInfo->sWC; + sWLB.pNew = (WhereLoop*)(((char*)pWInfo)+nByteWInfo); + assert( EIGHT_BYTE_ALIGNMENT(sWLB.pNew) ); + whereLoopInit(sWLB.pNew); +#ifdef SQLITE_DEBUG + sWLB.pNew->cId = '*'; +#endif + + /* Split the WHERE clause into separate subexpressions where each + ** subexpression is separated by an AND operator. + */ + sqlite3WhereClauseInit(&pWInfo->sWC, pWInfo); + sqlite3WhereSplit(&pWInfo->sWC, pWhere, TK_AND); + + /* Special case: No FROM clause + */ + if( nTabList==0 ){ + if( pOrderBy ) pWInfo->nOBSat = pOrderBy->nExpr; + if( (wctrlFlags & WHERE_WANT_DISTINCT)!=0 + && OptimizationEnabled(db, SQLITE_DistinctOpt) + ){ + pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE; + } + ExplainQueryPlan((pParse, 0, "SCAN CONSTANT ROW")); + }else{ + /* Assign a bit from the bitmask to every term in the FROM clause. + ** + ** The N-th term of the FROM clause is assigned a bitmask of 1<nSrc tables in + ** pTabList, not just the first nTabList tables. nTabList is normally + ** equal to pTabList->nSrc but might be shortened to 1 if the + ** WHERE_OR_SUBCLAUSE flag is set. + */ + ii = 0; + do{ + createMask(pMaskSet, pTabList->a[ii].iCursor); + sqlite3WhereTabFuncArgs(pParse, &pTabList->a[ii], &pWInfo->sWC); + }while( (++ii)nSrc ); + #ifdef SQLITE_DEBUG + { + Bitmask mx = 0; + for(ii=0; iinSrc; ii++){ + Bitmask m = sqlite3WhereGetMask(pMaskSet, pTabList->a[ii].iCursor); + assert( m>=mx ); + mx = m; + } + } + #endif + } + + /* Analyze all of the subexpressions. */ + sqlite3WhereExprAnalyze(pTabList, &pWInfo->sWC); + if( pSelect && pSelect->pLimit ){ + sqlite3WhereAddLimit(&pWInfo->sWC, pSelect); + } + if( pParse->nErr ) goto whereBeginError; + + /* The False-WHERE-Term-Bypass optimization: + ** + ** If there are WHERE terms that are false, then no rows will be output, + ** so skip over all of the code generated here. + ** + ** Conditions: + ** + ** (1) The WHERE term must not refer to any tables in the join. + ** (2) The term must not come from an ON clause on the + ** right-hand side of a LEFT or FULL JOIN. + ** (3) The term must not come from an ON clause, or there must be + ** no RIGHT or FULL OUTER joins in pTabList. + ** (4) If the expression contains non-deterministic functions + ** that are not within a sub-select. This is not required + ** for correctness but rather to preserves SQLite's legacy + ** behaviour in the following two cases: + ** + ** WHERE random()>0; -- eval random() once per row + ** WHERE (SELECT random())>0; -- eval random() just once overall + ** + ** Note that the Where term need not be a constant in order for this + ** optimization to apply, though it does need to be constant relative to + ** the current subquery (condition 1). The term might include variables + ** from outer queries so that the value of the term changes from one + ** invocation of the current subquery to the next. + */ + for(ii=0; iinBase; ii++){ + WhereTerm *pT = &sWLB.pWC->a[ii]; /* A term of the WHERE clause */ + Expr *pX; /* The expression of pT */ + if( pT->wtFlags & TERM_VIRTUAL ) continue; + pX = pT->pExpr; + assert( pX!=0 ); + assert( pT->prereqAll!=0 || !ExprHasProperty(pX, EP_OuterON) ); + if( pT->prereqAll==0 /* Conditions (1) and (2) */ + && (nTabList==0 || exprIsDeterministic(pX)) /* Condition (4) */ + && !(ExprHasProperty(pX, EP_InnerON) /* Condition (3) */ + && (pTabList->a[0].fg.jointype & JT_LTORJ)!=0 ) + ){ + sqlite3ExprIfFalse(pParse, pX, pWInfo->iBreak, SQLITE_JUMPIFNULL); + pT->wtFlags |= TERM_CODED; + } + } + + if( wctrlFlags & WHERE_WANT_DISTINCT ){ + if( OptimizationDisabled(db, SQLITE_DistinctOpt) ){ + /* Disable the DISTINCT optimization if SQLITE_DistinctOpt is set via + ** sqlite3_test_ctrl(SQLITE_TESTCTRL_OPTIMIZATIONS,...) */ + wctrlFlags &= ~WHERE_WANT_DISTINCT; + pWInfo->wctrlFlags &= ~WHERE_WANT_DISTINCT; + }else if( isDistinctRedundant(pParse, pTabList, &pWInfo->sWC, pResultSet) ){ + /* The DISTINCT marking is pointless. Ignore it. */ + pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE; + }else if( pOrderBy==0 ){ + /* Try to ORDER BY the result set to make distinct processing easier */ + pWInfo->wctrlFlags |= WHERE_DISTINCTBY; + pWInfo->pOrderBy = pResultSet; + } + } + + /* Construct the WhereLoop objects */ +#if defined(WHERETRACE_ENABLED) + if( sqlite3WhereTrace & 0xffffffff ){ + sqlite3DebugPrintf("*** Optimizer Start *** (wctrlFlags: 0x%x",wctrlFlags); + if( wctrlFlags & WHERE_USE_LIMIT ){ + sqlite3DebugPrintf(", limit: %d", iAuxArg); + } + sqlite3DebugPrintf(")\n"); + if( sqlite3WhereTrace & 0x8000 ){ + Select sSelect; + memset(&sSelect, 0, sizeof(sSelect)); + sSelect.selFlags = SF_WhereBegin; + sSelect.pSrc = pTabList; + sSelect.pWhere = pWhere; + sSelect.pOrderBy = pOrderBy; + sSelect.pEList = pResultSet; + sqlite3TreeViewSelect(0, &sSelect, 0); + } + if( sqlite3WhereTrace & 0x4000 ){ /* Display all WHERE clause terms */ + sqlite3DebugPrintf("---- WHERE clause at start of analysis:\n"); + sqlite3WhereClausePrint(sWLB.pWC); + } + } +#endif + + if( nTabList!=1 || whereShortCut(&sWLB)==0 ){ + rc = whereLoopAddAll(&sWLB); + if( rc ) goto whereBeginError; + +#ifdef SQLITE_ENABLE_STAT4 + /* If one or more WhereTerm.truthProb values were used in estimating + ** loop parameters, but then those truthProb values were subsequently + ** changed based on STAT4 information while computing subsequent loops, + ** then we need to rerun the whole loop building process so that all + ** loops will be built using the revised truthProb values. */ + if( sWLB.bldFlags2 & SQLITE_BLDF2_2NDPASS ){ + WHERETRACE_ALL_LOOPS(pWInfo, sWLB.pWC); + WHERETRACE(0xffffffff, + ("**** Redo all loop computations due to" + " TERM_HIGHTRUTH changes ****\n")); + while( pWInfo->pLoops ){ + WhereLoop *p = pWInfo->pLoops; + pWInfo->pLoops = p->pNextLoop; + whereLoopDelete(db, p); + } + rc = whereLoopAddAll(&sWLB); + if( rc ) goto whereBeginError; + } +#endif + WHERETRACE_ALL_LOOPS(pWInfo, sWLB.pWC); + + wherePathSolver(pWInfo, 0); + if( db->mallocFailed ) goto whereBeginError; + if( pWInfo->pOrderBy ){ + wherePathSolver(pWInfo, pWInfo->nRowOut+1); + if( db->mallocFailed ) goto whereBeginError; + } + } + if( pWInfo->pOrderBy==0 && (db->flags & SQLITE_ReverseOrder)!=0 ){ + pWInfo->revMask = ALLBITS; + } + if( pParse->nErr ){ + goto whereBeginError; + } + assert( db->mallocFailed==0 ); +#ifdef WHERETRACE_ENABLED + if( sqlite3WhereTrace ){ + sqlite3DebugPrintf("---- Solution nRow=%d", pWInfo->nRowOut); + if( pWInfo->nOBSat>0 ){ + sqlite3DebugPrintf(" ORDERBY=%d,0x%llx", pWInfo->nOBSat, pWInfo->revMask); + } + switch( pWInfo->eDistinct ){ + case WHERE_DISTINCT_UNIQUE: { + sqlite3DebugPrintf(" DISTINCT=unique"); + break; + } + case WHERE_DISTINCT_ORDERED: { + sqlite3DebugPrintf(" DISTINCT=ordered"); + break; + } + case WHERE_DISTINCT_UNORDERED: { + sqlite3DebugPrintf(" DISTINCT=unordered"); + break; + } + } + sqlite3DebugPrintf("\n"); + for(ii=0; iinLevel; ii++){ + sqlite3WhereLoopPrint(pWInfo->a[ii].pWLoop, sWLB.pWC); + } + } +#endif + + /* Attempt to omit tables from a join that do not affect the result. + ** See the comment on whereOmitNoopJoin() for further information. + ** + ** This query optimization is factored out into a separate "no-inline" + ** procedure to keep the sqlite3WhereBegin() procedure from becoming + ** too large. If sqlite3WhereBegin() becomes too large, that prevents + ** some C-compiler optimizers from in-lining the + ** sqlite3WhereCodeOneLoopStart() procedure, and it is important to + ** in-line sqlite3WhereCodeOneLoopStart() for performance reasons. + */ + notReady = ~(Bitmask)0; + if( pWInfo->nLevel>=2 + && pResultSet!=0 /* these two combine to guarantee */ + && 0==(wctrlFlags & WHERE_AGG_DISTINCT) /* condition (1) above */ + && OptimizationEnabled(db, SQLITE_OmitNoopJoin) + ){ + notReady = whereOmitNoopJoin(pWInfo, notReady); + nTabList = pWInfo->nLevel; + assert( nTabList>0 ); + } + + /* Check to see if there are any SEARCH loops that might benefit from + ** using a Bloom filter. + */ + if( pWInfo->nLevel>=2 + && OptimizationEnabled(db, SQLITE_BloomFilter) + ){ + whereCheckIfBloomFilterIsUseful(pWInfo); + } + +#if defined(WHERETRACE_ENABLED) + if( sqlite3WhereTrace & 0x4000 ){ /* Display all terms of the WHERE clause */ + sqlite3DebugPrintf("---- WHERE clause at end of analysis:\n"); + sqlite3WhereClausePrint(sWLB.pWC); + } + WHERETRACE(0xffffffff,("*** Optimizer Finished ***\n")); +#endif + pWInfo->pParse->nQueryLoop += pWInfo->nRowOut; + + /* If the caller is an UPDATE or DELETE statement that is requesting + ** to use a one-pass algorithm, determine if this is appropriate. + ** + ** A one-pass approach can be used if the caller has requested one + ** and either (a) the scan visits at most one row or (b) each + ** of the following are true: + ** + ** * the caller has indicated that a one-pass approach can be used + ** with multiple rows (by setting WHERE_ONEPASS_MULTIROW), and + ** * the table is not a virtual table, and + ** * either the scan does not use the OR optimization or the caller + ** is a DELETE operation (WHERE_DUPLICATES_OK is only specified + ** for DELETE). + ** + ** The last qualification is because an UPDATE statement uses + ** WhereInfo.aiCurOnePass[1] to determine whether or not it really can + ** use a one-pass approach, and this is not set accurately for scans + ** that use the OR optimization. + */ + assert( (wctrlFlags & WHERE_ONEPASS_DESIRED)==0 || pWInfo->nLevel==1 ); + if( (wctrlFlags & WHERE_ONEPASS_DESIRED)!=0 ){ + int wsFlags = pWInfo->a[0].pWLoop->wsFlags; + int bOnerow = (wsFlags & WHERE_ONEROW)!=0; + assert( !(wsFlags & WHERE_VIRTUALTABLE) || IsVirtual(pTabList->a[0].pTab) ); + if( bOnerow || ( + 0!=(wctrlFlags & WHERE_ONEPASS_MULTIROW) + && !IsVirtual(pTabList->a[0].pTab) + && (0==(wsFlags & WHERE_MULTI_OR) || (wctrlFlags & WHERE_DUPLICATES_OK)) + )){ + pWInfo->eOnePass = bOnerow ? ONEPASS_SINGLE : ONEPASS_MULTI; + if( HasRowid(pTabList->a[0].pTab) && (wsFlags & WHERE_IDX_ONLY) ){ + if( wctrlFlags & WHERE_ONEPASS_MULTIROW ){ + bFordelete = OPFLAG_FORDELETE; + } + pWInfo->a[0].pWLoop->wsFlags = (wsFlags & ~WHERE_IDX_ONLY); + } + } + } + + /* Open all tables in the pTabList and any indices selected for + ** searching those tables. + */ + for(ii=0, pLevel=pWInfo->a; iia[pLevel->iFrom]; + pTab = pTabItem->pTab; + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + pLoop = pLevel->pWLoop; + if( (pTab->tabFlags & TF_Ephemeral)!=0 || IsView(pTab) ){ + /* Do nothing */ + }else +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)!=0 ){ + const char *pVTab = (const char *)sqlite3GetVTable(db, pTab); + int iCur = pTabItem->iCursor; + sqlite3VdbeAddOp4(v, OP_VOpen, iCur, 0, 0, pVTab, P4_VTAB); + }else if( IsVirtual(pTab) ){ + /* noop */ + }else +#endif + if( ((pLoop->wsFlags & WHERE_IDX_ONLY)==0 + && (wctrlFlags & WHERE_OR_SUBCLAUSE)==0) + || (pTabItem->fg.jointype & (JT_LTORJ|JT_RIGHT))!=0 + ){ + int op = OP_OpenRead; + if( pWInfo->eOnePass!=ONEPASS_OFF ){ + op = OP_OpenWrite; + pWInfo->aiCurOnePass[0] = pTabItem->iCursor; + }; + sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op); + assert( pTabItem->iCursor==pLevel->iTabCur ); + testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS-1 ); + testcase( pWInfo->eOnePass==ONEPASS_OFF && pTab->nCol==BMS ); + if( pWInfo->eOnePass==ONEPASS_OFF + && pTab->nColtabFlags & (TF_HasGenerated|TF_WithoutRowid))==0 + && (pLoop->wsFlags & (WHERE_AUTO_INDEX|WHERE_BLOOMFILTER))==0 + ){ + /* If we know that only a prefix of the record will be used, + ** it is advantageous to reduce the "column count" field in + ** the P4 operand of the OP_OpenRead/Write opcode. */ + Bitmask b = pTabItem->colUsed; + int n = 0; + for(; b; b=b>>1, n++){} + sqlite3VdbeChangeP4(v, -1, SQLITE_INT_TO_PTR(n), P4_INT32); + assert( n<=pTab->nCol ); + } +#ifdef SQLITE_ENABLE_CURSOR_HINTS + if( pLoop->u.btree.pIndex!=0 && (pTab->tabFlags & TF_WithoutRowid)==0 ){ + sqlite3VdbeChangeP5(v, OPFLAG_SEEKEQ|bFordelete); + }else +#endif + { + sqlite3VdbeChangeP5(v, bFordelete); + } +#ifdef SQLITE_ENABLE_COLUMN_USED_MASK + sqlite3VdbeAddOp4Dup8(v, OP_ColumnsUsed, pTabItem->iCursor, 0, 0, + (const u8*)&pTabItem->colUsed, P4_INT64); +#endif + }else{ + sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName); + } + if( pLoop->wsFlags & WHERE_INDEXED ){ + Index *pIx = pLoop->u.btree.pIndex; + int iIndexCur; + int op = OP_OpenRead; + /* iAuxArg is always set to a positive value if ONEPASS is possible */ + assert( iAuxArg!=0 || (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0 ); + if( !HasRowid(pTab) && IsPrimaryKeyIndex(pIx) + && (wctrlFlags & WHERE_OR_SUBCLAUSE)!=0 + ){ + /* This is one term of an OR-optimization using the PRIMARY KEY of a + ** WITHOUT ROWID table. No need for a separate index */ + iIndexCur = pLevel->iTabCur; + op = 0; + }else if( pWInfo->eOnePass!=ONEPASS_OFF ){ + Index *pJ = pTabItem->pTab->pIndex; + iIndexCur = iAuxArg; + assert( wctrlFlags & WHERE_ONEPASS_DESIRED ); + while( ALWAYS(pJ) && pJ!=pIx ){ + iIndexCur++; + pJ = pJ->pNext; + } + op = OP_OpenWrite; + pWInfo->aiCurOnePass[1] = iIndexCur; + }else if( iAuxArg && (wctrlFlags & WHERE_OR_SUBCLAUSE)!=0 ){ + iIndexCur = iAuxArg; + op = OP_ReopenIdx; + }else{ + iIndexCur = pParse->nTab++; + if( pIx->bHasExpr && OptimizationEnabled(db, SQLITE_IndexedExpr) ){ + whereAddIndexedExpr(pParse, pIx, iIndexCur, pTabItem); + } + } + pLevel->iIdxCur = iIndexCur; + assert( pIx!=0 ); + assert( pIx->pSchema==pTab->pSchema ); + assert( iIndexCur>=0 ); + if( op ){ + sqlite3VdbeAddOp3(v, op, iIndexCur, pIx->tnum, iDb); + sqlite3VdbeSetP4KeyInfo(pParse, pIx); + if( (pLoop->wsFlags & WHERE_CONSTRAINT)!=0 + && (pLoop->wsFlags & (WHERE_COLUMN_RANGE|WHERE_SKIPSCAN))==0 + && (pLoop->wsFlags & WHERE_BIGNULL_SORT)==0 + && (pLoop->wsFlags & WHERE_IN_SEEKSCAN)==0 + && (pWInfo->wctrlFlags&WHERE_ORDERBY_MIN)==0 + && pWInfo->eDistinct!=WHERE_DISTINCT_ORDERED + ){ + sqlite3VdbeChangeP5(v, OPFLAG_SEEKEQ); + } + VdbeComment((v, "%s", pIx->zName)); +#ifdef SQLITE_ENABLE_COLUMN_USED_MASK + { + u64 colUsed = 0; + int ii, jj; + for(ii=0; iinColumn; ii++){ + jj = pIx->aiColumn[ii]; + if( jj<0 ) continue; + if( jj>63 ) jj = 63; + if( (pTabItem->colUsed & MASKBIT(jj))==0 ) continue; + colUsed |= ((u64)1)<<(ii<63 ? ii : 63); + } + sqlite3VdbeAddOp4Dup8(v, OP_ColumnsUsed, iIndexCur, 0, 0, + (u8*)&colUsed, P4_INT64); + } +#endif /* SQLITE_ENABLE_COLUMN_USED_MASK */ + } + } + if( iDb>=0 ) sqlite3CodeVerifySchema(pParse, iDb); + if( (pTabItem->fg.jointype & JT_RIGHT)!=0 + && (pLevel->pRJ = sqlite3WhereMalloc(pWInfo, sizeof(WhereRightJoin)))!=0 + ){ + WhereRightJoin *pRJ = pLevel->pRJ; + pRJ->iMatch = pParse->nTab++; + pRJ->regBloom = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Blob, 65536, pRJ->regBloom); + pRJ->regReturn = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Null, 0, pRJ->regReturn); + assert( pTab==pTabItem->pTab ); + if( HasRowid(pTab) ){ + KeyInfo *pInfo; + sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pRJ->iMatch, 1); + pInfo = sqlite3KeyInfoAlloc(pParse->db, 1, 0); + if( pInfo ){ + pInfo->aColl[0] = 0; + pInfo->aSortFlags[0] = 0; + sqlite3VdbeAppendP4(v, pInfo, P4_KEYINFO); + } + }else{ + Index *pPk = sqlite3PrimaryKeyIndex(pTab); + sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pRJ->iMatch, pPk->nKeyCol); + sqlite3VdbeSetP4KeyInfo(pParse, pPk); + } + pLoop->wsFlags &= ~WHERE_IDX_ONLY; + /* The nature of RIGHT JOIN processing is such that it messes up + ** the output order. So omit any ORDER BY/GROUP BY elimination + ** optimizations. We need to do an actual sort for RIGHT JOIN. */ + pWInfo->nOBSat = 0; + pWInfo->eDistinct = WHERE_DISTINCT_UNORDERED; + } + } + pWInfo->iTop = sqlite3VdbeCurrentAddr(v); + if( db->mallocFailed ) goto whereBeginError; + + /* Generate the code to do the search. Each iteration of the for + ** loop below generates code for a single nested loop of the VM + ** program. + */ + for(ii=0; iinErr ) goto whereBeginError; + pLevel = &pWInfo->a[ii]; + wsFlags = pLevel->pWLoop->wsFlags; + pSrc = &pTabList->a[pLevel->iFrom]; + if( pSrc->fg.isMaterialized ){ + if( pSrc->fg.isCorrelated ){ + sqlite3VdbeAddOp2(v, OP_Gosub, pSrc->regReturn, pSrc->addrFillSub); + }else{ + int iOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); + sqlite3VdbeAddOp2(v, OP_Gosub, pSrc->regReturn, pSrc->addrFillSub); + sqlite3VdbeJumpHere(v, iOnce); + } + } + assert( pTabList == pWInfo->pTabList ); + if( (wsFlags & (WHERE_AUTO_INDEX|WHERE_BLOOMFILTER))!=0 ){ + if( (wsFlags & WHERE_AUTO_INDEX)!=0 ){ +#ifndef SQLITE_OMIT_AUTOMATIC_INDEX + constructAutomaticIndex(pParse, &pWInfo->sWC, notReady, pLevel); +#endif + }else{ + sqlite3ConstructBloomFilter(pWInfo, ii, pLevel, notReady); + } + if( db->mallocFailed ) goto whereBeginError; + } + addrExplain = sqlite3WhereExplainOneScan( + pParse, pTabList, pLevel, wctrlFlags + ); + pLevel->addrBody = sqlite3VdbeCurrentAddr(v); + notReady = sqlite3WhereCodeOneLoopStart(pParse,v,pWInfo,ii,pLevel,notReady); + pWInfo->iContinue = pLevel->addrCont; + if( (wsFlags&WHERE_MULTI_OR)==0 && (wctrlFlags&WHERE_OR_SUBCLAUSE)==0 ){ + sqlite3WhereAddScanStatus(v, pTabList, pLevel, addrExplain); + } + } + + /* Done. */ + VdbeModuleComment((v, "Begin WHERE-core")); + pWInfo->iEndWhere = sqlite3VdbeCurrentAddr(v); + return pWInfo; + + /* Jump here if malloc fails */ +whereBeginError: + if( pWInfo ){ + pParse->nQueryLoop = pWInfo->savedNQueryLoop; + whereInfoFree(db, pWInfo); + } + return 0; +} + +/* +** Part of sqlite3WhereEnd() will rewrite opcodes to reference the +** index rather than the main table. In SQLITE_DEBUG mode, we want +** to trace those changes if PRAGMA vdbe_addoptrace=on. This routine +** does that. +*/ +#ifndef SQLITE_DEBUG +# define OpcodeRewriteTrace(D,K,P) /* no-op */ +#else +# define OpcodeRewriteTrace(D,K,P) sqlite3WhereOpcodeRewriteTrace(D,K,P) + static void sqlite3WhereOpcodeRewriteTrace( + sqlite3 *db, + int pc, + VdbeOp *pOp + ){ + if( (db->flags & SQLITE_VdbeAddopTrace)==0 ) return; + sqlite3VdbePrintOp(0, pc, pOp); + } +#endif + +#ifdef SQLITE_DEBUG +/* +** Return true if cursor iCur is opened by instruction k of the +** bytecode. Used inside of assert() only. +*/ +static int cursorIsOpen(Vdbe *v, int iCur, int k){ + while( k>=0 ){ + VdbeOp *pOp = sqlite3VdbeGetOp(v,k--); + if( pOp->p1!=iCur ) continue; + if( pOp->opcode==OP_Close ) return 0; + if( pOp->opcode==OP_OpenRead ) return 1; + if( pOp->opcode==OP_OpenWrite ) return 1; + if( pOp->opcode==OP_OpenDup ) return 1; + if( pOp->opcode==OP_OpenAutoindex ) return 1; + if( pOp->opcode==OP_OpenEphemeral ) return 1; + } + return 0; +} +#endif /* SQLITE_DEBUG */ + +/* +** Generate the end of the WHERE loop. See comments on +** sqlite3WhereBegin() for additional information. +*/ +SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){ + Parse *pParse = pWInfo->pParse; + Vdbe *v = pParse->pVdbe; + int i; + WhereLevel *pLevel; + WhereLoop *pLoop; + SrcList *pTabList = pWInfo->pTabList; + sqlite3 *db = pParse->db; + int iEnd = sqlite3VdbeCurrentAddr(v); + int nRJ = 0; + + /* Generate loop termination code. + */ + VdbeModuleComment((v, "End WHERE-core")); + for(i=pWInfo->nLevel-1; i>=0; i--){ + int addr; + pLevel = &pWInfo->a[i]; + if( pLevel->pRJ ){ + /* Terminate the subroutine that forms the interior of the loop of + ** the RIGHT JOIN table */ + WhereRightJoin *pRJ = pLevel->pRJ; + sqlite3VdbeResolveLabel(v, pLevel->addrCont); + pLevel->addrCont = 0; + pRJ->endSubrtn = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp3(v, OP_Return, pRJ->regReturn, pRJ->addrSubrtn, 1); + VdbeCoverage(v); + nRJ++; + } + pLoop = pLevel->pWLoop; + if( pLevel->op!=OP_Noop ){ +#ifndef SQLITE_DISABLE_SKIPAHEAD_DISTINCT + int addrSeek = 0; + Index *pIdx; + int n; + if( pWInfo->eDistinct==WHERE_DISTINCT_ORDERED + && i==pWInfo->nLevel-1 /* Ticket [ef9318757b152e3] 2017-10-21 */ + && (pLoop->wsFlags & WHERE_INDEXED)!=0 + && (pIdx = pLoop->u.btree.pIndex)->hasStat1 + && (n = pLoop->u.btree.nDistinctCol)>0 + && pIdx->aiRowLogEst[n]>=36 + ){ + int r1 = pParse->nMem+1; + int j, op; + for(j=0; jiIdxCur, j, r1+j); + } + pParse->nMem += n+1; + op = pLevel->op==OP_Prev ? OP_SeekLT : OP_SeekGT; + addrSeek = sqlite3VdbeAddOp4Int(v, op, pLevel->iIdxCur, 0, r1, n); + VdbeCoverageIf(v, op==OP_SeekLT); + VdbeCoverageIf(v, op==OP_SeekGT); + sqlite3VdbeAddOp2(v, OP_Goto, 1, pLevel->p2); + } +#endif /* SQLITE_DISABLE_SKIPAHEAD_DISTINCT */ + /* The common case: Advance to the next row */ + if( pLevel->addrCont ) sqlite3VdbeResolveLabel(v, pLevel->addrCont); + sqlite3VdbeAddOp3(v, pLevel->op, pLevel->p1, pLevel->p2, pLevel->p3); + sqlite3VdbeChangeP5(v, pLevel->p5); + VdbeCoverage(v); + VdbeCoverageIf(v, pLevel->op==OP_Next); + VdbeCoverageIf(v, pLevel->op==OP_Prev); + VdbeCoverageIf(v, pLevel->op==OP_VNext); + if( pLevel->regBignull ){ + sqlite3VdbeResolveLabel(v, pLevel->addrBignull); + sqlite3VdbeAddOp2(v, OP_DecrJumpZero, pLevel->regBignull, pLevel->p2-1); + VdbeCoverage(v); + } +#ifndef SQLITE_DISABLE_SKIPAHEAD_DISTINCT + if( addrSeek ) sqlite3VdbeJumpHere(v, addrSeek); +#endif + }else if( pLevel->addrCont ){ + sqlite3VdbeResolveLabel(v, pLevel->addrCont); + } + if( (pLoop->wsFlags & WHERE_IN_ABLE)!=0 && pLevel->u.in.nIn>0 ){ + struct InLoop *pIn; + int j; + sqlite3VdbeResolveLabel(v, pLevel->addrNxt); + for(j=pLevel->u.in.nIn, pIn=&pLevel->u.in.aInLoop[j-1]; j>0; j--, pIn--){ + assert( sqlite3VdbeGetOp(v, pIn->addrInTop+1)->opcode==OP_IsNull + || pParse->db->mallocFailed ); + sqlite3VdbeJumpHere(v, pIn->addrInTop+1); + if( pIn->eEndLoopOp!=OP_Noop ){ + if( pIn->nPrefix ){ + int bEarlyOut = + (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0 + && (pLoop->wsFlags & WHERE_IN_EARLYOUT)!=0; + if( pLevel->iLeftJoin ){ + /* For LEFT JOIN queries, cursor pIn->iCur may not have been + ** opened yet. This occurs for WHERE clauses such as + ** "a = ? AND b IN (...)", where the index is on (a, b). If + ** the RHS of the (a=?) is NULL, then the "b IN (...)" may + ** never have been coded, but the body of the loop run to + ** return the null-row. So, if the cursor is not open yet, + ** jump over the OP_Next or OP_Prev instruction about to + ** be coded. */ + sqlite3VdbeAddOp2(v, OP_IfNotOpen, pIn->iCur, + sqlite3VdbeCurrentAddr(v) + 2 + bEarlyOut); + VdbeCoverage(v); + } + if( bEarlyOut ){ + sqlite3VdbeAddOp4Int(v, OP_IfNoHope, pLevel->iIdxCur, + sqlite3VdbeCurrentAddr(v)+2, + pIn->iBase, pIn->nPrefix); + VdbeCoverage(v); + /* Retarget the OP_IsNull against the left operand of IN so + ** it jumps past the OP_IfNoHope. This is because the + ** OP_IsNull also bypasses the OP_Affinity opcode that is + ** required by OP_IfNoHope. */ + sqlite3VdbeJumpHere(v, pIn->addrInTop+1); + } + } + sqlite3VdbeAddOp2(v, pIn->eEndLoopOp, pIn->iCur, pIn->addrInTop); + VdbeCoverage(v); + VdbeCoverageIf(v, pIn->eEndLoopOp==OP_Prev); + VdbeCoverageIf(v, pIn->eEndLoopOp==OP_Next); + } + sqlite3VdbeJumpHere(v, pIn->addrInTop-1); + } + } + sqlite3VdbeResolveLabel(v, pLevel->addrBrk); + if( pLevel->pRJ ){ + sqlite3VdbeAddOp3(v, OP_Return, pLevel->pRJ->regReturn, 0, 1); + VdbeCoverage(v); + } + if( pLevel->addrSkip ){ + sqlite3VdbeGoto(v, pLevel->addrSkip); + VdbeComment((v, "next skip-scan on %s", pLoop->u.btree.pIndex->zName)); + sqlite3VdbeJumpHere(v, pLevel->addrSkip); + sqlite3VdbeJumpHere(v, pLevel->addrSkip-2); + } +#ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS + if( pLevel->addrLikeRep ){ + sqlite3VdbeAddOp2(v, OP_DecrJumpZero, (int)(pLevel->iLikeRepCntr>>1), + pLevel->addrLikeRep); + VdbeCoverage(v); + } +#endif + if( pLevel->iLeftJoin ){ + int ws = pLoop->wsFlags; + addr = sqlite3VdbeAddOp1(v, OP_IfPos, pLevel->iLeftJoin); VdbeCoverage(v); + assert( (ws & WHERE_IDX_ONLY)==0 || (ws & WHERE_INDEXED)!=0 ); + if( (ws & WHERE_IDX_ONLY)==0 ){ + assert( pLevel->iTabCur==pTabList->a[pLevel->iFrom].iCursor ); + sqlite3VdbeAddOp1(v, OP_NullRow, pLevel->iTabCur); + } + if( (ws & WHERE_INDEXED) + || ((ws & WHERE_MULTI_OR) && pLevel->u.pCoveringIdx) + ){ + if( ws & WHERE_MULTI_OR ){ + Index *pIx = pLevel->u.pCoveringIdx; + int iDb = sqlite3SchemaToIndex(db, pIx->pSchema); + sqlite3VdbeAddOp3(v, OP_ReopenIdx, pLevel->iIdxCur, pIx->tnum, iDb); + sqlite3VdbeSetP4KeyInfo(pParse, pIx); + } + sqlite3VdbeAddOp1(v, OP_NullRow, pLevel->iIdxCur); + } + if( pLevel->op==OP_Return ){ + sqlite3VdbeAddOp2(v, OP_Gosub, pLevel->p1, pLevel->addrFirst); + }else{ + sqlite3VdbeGoto(v, pLevel->addrFirst); + } + sqlite3VdbeJumpHere(v, addr); + } + VdbeModuleComment((v, "End WHERE-loop%d: %s", i, + pWInfo->pTabList->a[pLevel->iFrom].pTab->zName)); + } + + assert( pWInfo->nLevel<=pTabList->nSrc ); + for(i=0, pLevel=pWInfo->a; inLevel; i++, pLevel++){ + int k, last; + VdbeOp *pOp, *pLastOp; + Index *pIdx = 0; + SrcItem *pTabItem = &pTabList->a[pLevel->iFrom]; + Table *pTab = pTabItem->pTab; + assert( pTab!=0 ); + pLoop = pLevel->pWLoop; + + /* Do RIGHT JOIN processing. Generate code that will output the + ** unmatched rows of the right operand of the RIGHT JOIN with + ** all of the columns of the left operand set to NULL. + */ + if( pLevel->pRJ ){ + sqlite3WhereRightJoinLoop(pWInfo, i, pLevel); + continue; + } + + /* For a co-routine, change all OP_Column references to the table of + ** the co-routine into OP_Copy of result contained in a register. + ** OP_Rowid becomes OP_Null. + */ + if( pTabItem->fg.viaCoroutine ){ + testcase( pParse->db->mallocFailed ); + translateColumnToCopy(pParse, pLevel->addrBody, pLevel->iTabCur, + pTabItem->regResult, 0); + continue; + } + + /* If this scan uses an index, make VDBE code substitutions to read data + ** from the index instead of from the table where possible. In some cases + ** this optimization prevents the table from ever being read, which can + ** yield a significant performance boost. + ** + ** Calls to the code generator in between sqlite3WhereBegin and + ** sqlite3WhereEnd will have created code that references the table + ** directly. This loop scans all that code looking for opcodes + ** that reference the table and converts them into opcodes that + ** reference the index. + */ + if( pLoop->wsFlags & (WHERE_INDEXED|WHERE_IDX_ONLY) ){ + pIdx = pLoop->u.btree.pIndex; + }else if( pLoop->wsFlags & WHERE_MULTI_OR ){ + pIdx = pLevel->u.pCoveringIdx; + } + if( pIdx + && !db->mallocFailed + ){ + if( pWInfo->eOnePass==ONEPASS_OFF || !HasRowid(pIdx->pTable) ){ + last = iEnd; + }else{ + last = pWInfo->iEndWhere; + } + if( pIdx->bHasExpr ){ + IndexedExpr *p = pParse->pIdxEpr; + while( p ){ + if( p->iIdxCur==pLevel->iIdxCur ){ +#ifdef WHERETRACE_ENABLED + if( sqlite3WhereTrace & 0x200 ){ + sqlite3DebugPrintf("Disable pParse->pIdxEpr term {%d,%d}\n", + p->iIdxCur, p->iIdxCol); + if( sqlite3WhereTrace & 0x5000 ) sqlite3ShowExpr(p->pExpr); + } +#endif + p->iDataCur = -1; + p->iIdxCur = -1; + } + p = p->pIENext; + } + } + k = pLevel->addrBody + 1; +#ifdef SQLITE_DEBUG + if( db->flags & SQLITE_VdbeAddopTrace ){ + printf("TRANSLATE cursor %d->%d in opcode range %d..%d\n", + pLevel->iTabCur, pLevel->iIdxCur, k, last-1); + } + /* Proof that the "+1" on the k value above is safe */ + pOp = sqlite3VdbeGetOp(v, k - 1); + assert( pOp->opcode!=OP_Column || pOp->p1!=pLevel->iTabCur ); + assert( pOp->opcode!=OP_Rowid || pOp->p1!=pLevel->iTabCur ); + assert( pOp->opcode!=OP_IfNullRow || pOp->p1!=pLevel->iTabCur ); +#endif + pOp = sqlite3VdbeGetOp(v, k); + pLastOp = pOp + (last - k); + assert( pOp<=pLastOp ); + do{ + if( pOp->p1!=pLevel->iTabCur ){ + /* no-op */ + }else if( pOp->opcode==OP_Column +#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC + || pOp->opcode==OP_Offset +#endif + ){ + int x = pOp->p2; + assert( pIdx->pTable==pTab ); +#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC + if( pOp->opcode==OP_Offset ){ + /* Do not need to translate the column number */ + }else +#endif + if( !HasRowid(pTab) ){ + Index *pPk = sqlite3PrimaryKeyIndex(pTab); + x = pPk->aiColumn[x]; + assert( x>=0 ); + }else{ + testcase( x!=sqlite3StorageColumnToTable(pTab,x) ); + x = sqlite3StorageColumnToTable(pTab,x); + } + x = sqlite3TableColumnToIndex(pIdx, x); + if( x>=0 ){ + pOp->p2 = x; + pOp->p1 = pLevel->iIdxCur; + OpcodeRewriteTrace(db, k, pOp); + }else{ + /* Unable to translate the table reference into an index + ** reference. Verify that this is harmless - that the + ** table being referenced really is open. + */ +#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC + assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 + || cursorIsOpen(v,pOp->p1,k) + || pOp->opcode==OP_Offset + ); +#else + assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 + || cursorIsOpen(v,pOp->p1,k) + ); +#endif + } + }else if( pOp->opcode==OP_Rowid ){ + pOp->p1 = pLevel->iIdxCur; + pOp->opcode = OP_IdxRowid; + OpcodeRewriteTrace(db, k, pOp); + }else if( pOp->opcode==OP_IfNullRow ){ + pOp->p1 = pLevel->iIdxCur; + OpcodeRewriteTrace(db, k, pOp); + } +#ifdef SQLITE_DEBUG + k++; +#endif + }while( (++pOp)flags & SQLITE_VdbeAddopTrace ) printf("TRANSLATE complete\n"); +#endif + } + } + + /* The "break" point is here, just past the end of the outer loop. + ** Set it. + */ + sqlite3VdbeResolveLabel(v, pWInfo->iBreak); + + /* Final cleanup + */ + pParse->nQueryLoop = pWInfo->savedNQueryLoop; + whereInfoFree(db, pWInfo); + pParse->withinRJSubrtn -= nRJ; + return; +} + +/************** End of where.c ***********************************************/ +/************** Begin file window.c ******************************************/ +/* +** 2018 May 08 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +*/ +/* #include "sqliteInt.h" */ + +#ifndef SQLITE_OMIT_WINDOWFUNC + +/* +** SELECT REWRITING +** +** Any SELECT statement that contains one or more window functions in +** either the select list or ORDER BY clause (the only two places window +** functions may be used) is transformed by function sqlite3WindowRewrite() +** in order to support window function processing. For example, with the +** schema: +** +** CREATE TABLE t1(a, b, c, d, e, f, g); +** +** the statement: +** +** SELECT a+1, max(b) OVER (PARTITION BY c ORDER BY d) FROM t1 ORDER BY e; +** +** is transformed to: +** +** SELECT a+1, max(b) OVER (PARTITION BY c ORDER BY d) FROM ( +** SELECT a, e, c, d, b FROM t1 ORDER BY c, d +** ) ORDER BY e; +** +** The flattening optimization is disabled when processing this transformed +** SELECT statement. This allows the implementation of the window function +** (in this case max()) to process rows sorted in order of (c, d), which +** makes things easier for obvious reasons. More generally: +** +** * FROM, WHERE, GROUP BY and HAVING clauses are all moved to +** the sub-query. +** +** * ORDER BY, LIMIT and OFFSET remain part of the parent query. +** +** * Terminals from each of the expression trees that make up the +** select-list and ORDER BY expressions in the parent query are +** selected by the sub-query. For the purposes of the transformation, +** terminals are column references and aggregate functions. +** +** If there is more than one window function in the SELECT that uses +** the same window declaration (the OVER bit), then a single scan may +** be used to process more than one window function. For example: +** +** SELECT max(b) OVER (PARTITION BY c ORDER BY d), +** min(e) OVER (PARTITION BY c ORDER BY d) +** FROM t1; +** +** is transformed in the same way as the example above. However: +** +** SELECT max(b) OVER (PARTITION BY c ORDER BY d), +** min(e) OVER (PARTITION BY a ORDER BY b) +** FROM t1; +** +** Must be transformed to: +** +** SELECT max(b) OVER (PARTITION BY c ORDER BY d) FROM ( +** SELECT e, min(e) OVER (PARTITION BY a ORDER BY b), c, d, b FROM +** SELECT a, e, c, d, b FROM t1 ORDER BY a, b +** ) ORDER BY c, d +** ) ORDER BY e; +** +** so that both min() and max() may process rows in the order defined by +** their respective window declarations. +** +** INTERFACE WITH SELECT.C +** +** When processing the rewritten SELECT statement, code in select.c calls +** sqlite3WhereBegin() to begin iterating through the results of the +** sub-query, which is always implemented as a co-routine. It then calls +** sqlite3WindowCodeStep() to process rows and finish the scan by calling +** sqlite3WhereEnd(). +** +** sqlite3WindowCodeStep() generates VM code so that, for each row returned +** by the sub-query a sub-routine (OP_Gosub) coded by select.c is invoked. +** When the sub-routine is invoked: +** +** * The results of all window-functions for the row are stored +** in the associated Window.regResult registers. +** +** * The required terminal values are stored in the current row of +** temp table Window.iEphCsr. +** +** In some cases, depending on the window frame and the specific window +** functions invoked, sqlite3WindowCodeStep() caches each entire partition +** in a temp table before returning any rows. In other cases it does not. +** This detail is encapsulated within this file, the code generated by +** select.c is the same in either case. +** +** BUILT-IN WINDOW FUNCTIONS +** +** This implementation features the following built-in window functions: +** +** row_number() +** rank() +** dense_rank() +** percent_rank() +** cume_dist() +** ntile(N) +** lead(expr [, offset [, default]]) +** lag(expr [, offset [, default]]) +** first_value(expr) +** last_value(expr) +** nth_value(expr, N) +** +** These are the same built-in window functions supported by Postgres. +** Although the behaviour of aggregate window functions (functions that +** can be used as either aggregates or window funtions) allows them to +** be implemented using an API, built-in window functions are much more +** esoteric. Additionally, some window functions (e.g. nth_value()) +** may only be implemented by caching the entire partition in memory. +** As such, some built-in window functions use the same API as aggregate +** window functions and some are implemented directly using VDBE +** instructions. Additionally, for those functions that use the API, the +** window frame is sometimes modified before the SELECT statement is +** rewritten. For example, regardless of the specified window frame, the +** row_number() function always uses: +** +** ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW +** +** See sqlite3WindowUpdate() for details. +** +** As well as some of the built-in window functions, aggregate window +** functions min() and max() are implemented using VDBE instructions if +** the start of the window frame is declared as anything other than +** UNBOUNDED PRECEDING. +*/ + +/* +** Implementation of built-in window function row_number(). Assumes that the +** window frame has been coerced to: +** +** ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW +*/ +static void row_numberStepFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + i64 *p = (i64*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p ) (*p)++; + UNUSED_PARAMETER(nArg); + UNUSED_PARAMETER(apArg); +} +static void row_numberValueFunc(sqlite3_context *pCtx){ + i64 *p = (i64*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + sqlite3_result_int64(pCtx, (p ? *p : 0)); +} + +/* +** Context object type used by rank(), dense_rank(), percent_rank() and +** cume_dist(). +*/ +struct CallCount { + i64 nValue; + i64 nStep; + i64 nTotal; +}; + +/* +** Implementation of built-in window function dense_rank(). Assumes that +** the window frame has been set to: +** +** RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW +*/ +static void dense_rankStepFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + struct CallCount *p; + p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p ) p->nStep = 1; + UNUSED_PARAMETER(nArg); + UNUSED_PARAMETER(apArg); +} +static void dense_rankValueFunc(sqlite3_context *pCtx){ + struct CallCount *p; + p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p ){ + if( p->nStep ){ + p->nValue++; + p->nStep = 0; + } + sqlite3_result_int64(pCtx, p->nValue); + } +} + +/* +** Implementation of built-in window function nth_value(). This +** implementation is used in "slow mode" only - when the EXCLUDE clause +** is not set to the default value "NO OTHERS". +*/ +struct NthValueCtx { + i64 nStep; + sqlite3_value *pValue; +}; +static void nth_valueStepFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + struct NthValueCtx *p; + p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p ){ + i64 iVal; + switch( sqlite3_value_numeric_type(apArg[1]) ){ + case SQLITE_INTEGER: + iVal = sqlite3_value_int64(apArg[1]); + break; + case SQLITE_FLOAT: { + double fVal = sqlite3_value_double(apArg[1]); + if( ((i64)fVal)!=fVal ) goto error_out; + iVal = (i64)fVal; + break; + } + default: + goto error_out; + } + if( iVal<=0 ) goto error_out; + + p->nStep++; + if( iVal==p->nStep ){ + p->pValue = sqlite3_value_dup(apArg[0]); + if( !p->pValue ){ + sqlite3_result_error_nomem(pCtx); + } + } + } + UNUSED_PARAMETER(nArg); + UNUSED_PARAMETER(apArg); + return; + + error_out: + sqlite3_result_error( + pCtx, "second argument to nth_value must be a positive integer", -1 + ); +} +static void nth_valueFinalizeFunc(sqlite3_context *pCtx){ + struct NthValueCtx *p; + p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, 0); + if( p && p->pValue ){ + sqlite3_result_value(pCtx, p->pValue); + sqlite3_value_free(p->pValue); + p->pValue = 0; + } +} +#define nth_valueInvFunc noopStepFunc +#define nth_valueValueFunc noopValueFunc + +static void first_valueStepFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + struct NthValueCtx *p; + p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p && p->pValue==0 ){ + p->pValue = sqlite3_value_dup(apArg[0]); + if( !p->pValue ){ + sqlite3_result_error_nomem(pCtx); + } + } + UNUSED_PARAMETER(nArg); + UNUSED_PARAMETER(apArg); +} +static void first_valueFinalizeFunc(sqlite3_context *pCtx){ + struct NthValueCtx *p; + p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p && p->pValue ){ + sqlite3_result_value(pCtx, p->pValue); + sqlite3_value_free(p->pValue); + p->pValue = 0; + } +} +#define first_valueInvFunc noopStepFunc +#define first_valueValueFunc noopValueFunc + +/* +** Implementation of built-in window function rank(). Assumes that +** the window frame has been set to: +** +** RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW +*/ +static void rankStepFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + struct CallCount *p; + p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p ){ + p->nStep++; + if( p->nValue==0 ){ + p->nValue = p->nStep; + } + } + UNUSED_PARAMETER(nArg); + UNUSED_PARAMETER(apArg); +} +static void rankValueFunc(sqlite3_context *pCtx){ + struct CallCount *p; + p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p ){ + sqlite3_result_int64(pCtx, p->nValue); + p->nValue = 0; + } +} + +/* +** Implementation of built-in window function percent_rank(). Assumes that +** the window frame has been set to: +** +** GROUPS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING +*/ +static void percent_rankStepFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + struct CallCount *p; + UNUSED_PARAMETER(nArg); assert( nArg==0 ); + UNUSED_PARAMETER(apArg); + p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p ){ + p->nTotal++; + } +} +static void percent_rankInvFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + struct CallCount *p; + UNUSED_PARAMETER(nArg); assert( nArg==0 ); + UNUSED_PARAMETER(apArg); + p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + p->nStep++; +} +static void percent_rankValueFunc(sqlite3_context *pCtx){ + struct CallCount *p; + p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p ){ + p->nValue = p->nStep; + if( p->nTotal>1 ){ + double r = (double)p->nValue / (double)(p->nTotal-1); + sqlite3_result_double(pCtx, r); + }else{ + sqlite3_result_double(pCtx, 0.0); + } + } +} +#define percent_rankFinalizeFunc percent_rankValueFunc + +/* +** Implementation of built-in window function cume_dist(). Assumes that +** the window frame has been set to: +** +** GROUPS BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING +*/ +static void cume_distStepFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + struct CallCount *p; + UNUSED_PARAMETER(nArg); assert( nArg==0 ); + UNUSED_PARAMETER(apArg); + p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p ){ + p->nTotal++; + } +} +static void cume_distInvFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + struct CallCount *p; + UNUSED_PARAMETER(nArg); assert( nArg==0 ); + UNUSED_PARAMETER(apArg); + p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + p->nStep++; +} +static void cume_distValueFunc(sqlite3_context *pCtx){ + struct CallCount *p; + p = (struct CallCount*)sqlite3_aggregate_context(pCtx, 0); + if( p ){ + double r = (double)(p->nStep) / (double)(p->nTotal); + sqlite3_result_double(pCtx, r); + } +} +#define cume_distFinalizeFunc cume_distValueFunc + +/* +** Context object for ntile() window function. +*/ +struct NtileCtx { + i64 nTotal; /* Total rows in partition */ + i64 nParam; /* Parameter passed to ntile(N) */ + i64 iRow; /* Current row */ +}; + +/* +** Implementation of ntile(). This assumes that the window frame has +** been coerced to: +** +** ROWS CURRENT ROW AND UNBOUNDED FOLLOWING +*/ +static void ntileStepFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + struct NtileCtx *p; + assert( nArg==1 ); UNUSED_PARAMETER(nArg); + p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p ){ + if( p->nTotal==0 ){ + p->nParam = sqlite3_value_int64(apArg[0]); + if( p->nParam<=0 ){ + sqlite3_result_error( + pCtx, "argument of ntile must be a positive integer", -1 + ); + } + } + p->nTotal++; + } +} +static void ntileInvFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + struct NtileCtx *p; + assert( nArg==1 ); UNUSED_PARAMETER(nArg); + UNUSED_PARAMETER(apArg); + p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + p->iRow++; +} +static void ntileValueFunc(sqlite3_context *pCtx){ + struct NtileCtx *p; + p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p && p->nParam>0 ){ + int nSize = (p->nTotal / p->nParam); + if( nSize==0 ){ + sqlite3_result_int64(pCtx, p->iRow+1); + }else{ + i64 nLarge = p->nTotal - p->nParam*nSize; + i64 iSmall = nLarge*(nSize+1); + i64 iRow = p->iRow; + + assert( (nLarge*(nSize+1) + (p->nParam-nLarge)*nSize)==p->nTotal ); + + if( iRowpVal); + p->pVal = sqlite3_value_dup(apArg[0]); + if( p->pVal==0 ){ + sqlite3_result_error_nomem(pCtx); + }else{ + p->nVal++; + } + } +} +static void last_valueInvFunc( + sqlite3_context *pCtx, + int nArg, + sqlite3_value **apArg +){ + struct LastValueCtx *p; + UNUSED_PARAMETER(nArg); + UNUSED_PARAMETER(apArg); + p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( ALWAYS(p) ){ + p->nVal--; + if( p->nVal==0 ){ + sqlite3_value_free(p->pVal); + p->pVal = 0; + } + } +} +static void last_valueValueFunc(sqlite3_context *pCtx){ + struct LastValueCtx *p; + p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, 0); + if( p && p->pVal ){ + sqlite3_result_value(pCtx, p->pVal); + } +} +static void last_valueFinalizeFunc(sqlite3_context *pCtx){ + struct LastValueCtx *p; + p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); + if( p && p->pVal ){ + sqlite3_result_value(pCtx, p->pVal); + sqlite3_value_free(p->pVal); + p->pVal = 0; + } +} + +/* +** Static names for the built-in window function names. These static +** names are used, rather than string literals, so that FuncDef objects +** can be associated with a particular window function by direct +** comparison of the zName pointer. Example: +** +** if( pFuncDef->zName==row_valueName ){ ... } +*/ +static const char row_numberName[] = "row_number"; +static const char dense_rankName[] = "dense_rank"; +static const char rankName[] = "rank"; +static const char percent_rankName[] = "percent_rank"; +static const char cume_distName[] = "cume_dist"; +static const char ntileName[] = "ntile"; +static const char last_valueName[] = "last_value"; +static const char nth_valueName[] = "nth_value"; +static const char first_valueName[] = "first_value"; +static const char leadName[] = "lead"; +static const char lagName[] = "lag"; + +/* +** No-op implementations of xStep() and xFinalize(). Used as place-holders +** for built-in window functions that never call those interfaces. +** +** The noopValueFunc() is called but is expected to do nothing. The +** noopStepFunc() is never called, and so it is marked with NO_TEST to +** let the test coverage routine know not to expect this function to be +** invoked. +*/ +static void noopStepFunc( /*NO_TEST*/ + sqlite3_context *p, /*NO_TEST*/ + int n, /*NO_TEST*/ + sqlite3_value **a /*NO_TEST*/ +){ /*NO_TEST*/ + UNUSED_PARAMETER(p); /*NO_TEST*/ + UNUSED_PARAMETER(n); /*NO_TEST*/ + UNUSED_PARAMETER(a); /*NO_TEST*/ + assert(0); /*NO_TEST*/ +} /*NO_TEST*/ +static void noopValueFunc(sqlite3_context *p){ UNUSED_PARAMETER(p); /*no-op*/ } + +/* Window functions that use all window interfaces: xStep, xFinal, +** xValue, and xInverse */ +#define WINDOWFUNCALL(name,nArg,extra) { \ + nArg, (SQLITE_FUNC_BUILTIN|SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0, \ + name ## StepFunc, name ## FinalizeFunc, name ## ValueFunc, \ + name ## InvFunc, name ## Name, {0} \ +} + +/* Window functions that are implemented using bytecode and thus have +** no-op routines for their methods */ +#define WINDOWFUNCNOOP(name,nArg,extra) { \ + nArg, (SQLITE_FUNC_BUILTIN|SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0, \ + noopStepFunc, noopValueFunc, noopValueFunc, \ + noopStepFunc, name ## Name, {0} \ +} + +/* Window functions that use all window interfaces: xStep, the +** same routine for xFinalize and xValue and which never call +** xInverse. */ +#define WINDOWFUNCX(name,nArg,extra) { \ + nArg, (SQLITE_FUNC_BUILTIN|SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0, \ + name ## StepFunc, name ## ValueFunc, name ## ValueFunc, \ + noopStepFunc, name ## Name, {0} \ +} + + +/* +** Register those built-in window functions that are not also aggregates. +*/ +SQLITE_PRIVATE void sqlite3WindowFunctions(void){ + static FuncDef aWindowFuncs[] = { + WINDOWFUNCX(row_number, 0, 0), + WINDOWFUNCX(dense_rank, 0, 0), + WINDOWFUNCX(rank, 0, 0), + WINDOWFUNCALL(percent_rank, 0, 0), + WINDOWFUNCALL(cume_dist, 0, 0), + WINDOWFUNCALL(ntile, 1, 0), + WINDOWFUNCALL(last_value, 1, 0), + WINDOWFUNCALL(nth_value, 2, 0), + WINDOWFUNCALL(first_value, 1, 0), + WINDOWFUNCNOOP(lead, 1, 0), + WINDOWFUNCNOOP(lead, 2, 0), + WINDOWFUNCNOOP(lead, 3, 0), + WINDOWFUNCNOOP(lag, 1, 0), + WINDOWFUNCNOOP(lag, 2, 0), + WINDOWFUNCNOOP(lag, 3, 0), + }; + sqlite3InsertBuiltinFuncs(aWindowFuncs, ArraySize(aWindowFuncs)); +} + +static Window *windowFind(Parse *pParse, Window *pList, const char *zName){ + Window *p; + for(p=pList; p; p=p->pNextWin){ + if( sqlite3StrICmp(p->zName, zName)==0 ) break; + } + if( p==0 ){ + sqlite3ErrorMsg(pParse, "no such window: %s", zName); + } + return p; +} + +/* +** This function is called immediately after resolving the function name +** for a window function within a SELECT statement. Argument pList is a +** linked list of WINDOW definitions for the current SELECT statement. +** Argument pFunc is the function definition just resolved and pWin +** is the Window object representing the associated OVER clause. This +** function updates the contents of pWin as follows: +** +** * If the OVER clause refered to a named window (as in "max(x) OVER win"), +** search list pList for a matching WINDOW definition, and update pWin +** accordingly. If no such WINDOW clause can be found, leave an error +** in pParse. +** +** * If the function is a built-in window function that requires the +** window to be coerced (see "BUILT-IN WINDOW FUNCTIONS" at the top +** of this file), pWin is updated here. +*/ +SQLITE_PRIVATE void sqlite3WindowUpdate( + Parse *pParse, + Window *pList, /* List of named windows for this SELECT */ + Window *pWin, /* Window frame to update */ + FuncDef *pFunc /* Window function definition */ +){ + if( pWin->zName && pWin->eFrmType==0 ){ + Window *p = windowFind(pParse, pList, pWin->zName); + if( p==0 ) return; + pWin->pPartition = sqlite3ExprListDup(pParse->db, p->pPartition, 0); + pWin->pOrderBy = sqlite3ExprListDup(pParse->db, p->pOrderBy, 0); + pWin->pStart = sqlite3ExprDup(pParse->db, p->pStart, 0); + pWin->pEnd = sqlite3ExprDup(pParse->db, p->pEnd, 0); + pWin->eStart = p->eStart; + pWin->eEnd = p->eEnd; + pWin->eFrmType = p->eFrmType; + pWin->eExclude = p->eExclude; + }else{ + sqlite3WindowChain(pParse, pWin, pList); + } + if( (pWin->eFrmType==TK_RANGE) + && (pWin->pStart || pWin->pEnd) + && (pWin->pOrderBy==0 || pWin->pOrderBy->nExpr!=1) + ){ + sqlite3ErrorMsg(pParse, + "RANGE with offset PRECEDING/FOLLOWING requires one ORDER BY expression" + ); + }else + if( pFunc->funcFlags & SQLITE_FUNC_WINDOW ){ + sqlite3 *db = pParse->db; + if( pWin->pFilter ){ + sqlite3ErrorMsg(pParse, + "FILTER clause may only be used with aggregate window functions" + ); + }else{ + struct WindowUpdate { + const char *zFunc; + int eFrmType; + int eStart; + int eEnd; + } aUp[] = { + { row_numberName, TK_ROWS, TK_UNBOUNDED, TK_CURRENT }, + { dense_rankName, TK_RANGE, TK_UNBOUNDED, TK_CURRENT }, + { rankName, TK_RANGE, TK_UNBOUNDED, TK_CURRENT }, + { percent_rankName, TK_GROUPS, TK_CURRENT, TK_UNBOUNDED }, + { cume_distName, TK_GROUPS, TK_FOLLOWING, TK_UNBOUNDED }, + { ntileName, TK_ROWS, TK_CURRENT, TK_UNBOUNDED }, + { leadName, TK_ROWS, TK_UNBOUNDED, TK_UNBOUNDED }, + { lagName, TK_ROWS, TK_UNBOUNDED, TK_CURRENT }, + }; + int i; + for(i=0; izName==aUp[i].zFunc ){ + sqlite3ExprDelete(db, pWin->pStart); + sqlite3ExprDelete(db, pWin->pEnd); + pWin->pEnd = pWin->pStart = 0; + pWin->eFrmType = aUp[i].eFrmType; + pWin->eStart = aUp[i].eStart; + pWin->eEnd = aUp[i].eEnd; + pWin->eExclude = 0; + if( pWin->eStart==TK_FOLLOWING ){ + pWin->pStart = sqlite3Expr(db, TK_INTEGER, "1"); + } + break; + } + } + } + } + pWin->pWFunc = pFunc; +} + +/* +** Context object passed through sqlite3WalkExprList() to +** selectWindowRewriteExprCb() by selectWindowRewriteEList(). +*/ +typedef struct WindowRewrite WindowRewrite; +struct WindowRewrite { + Window *pWin; + SrcList *pSrc; + ExprList *pSub; + Table *pTab; + Select *pSubSelect; /* Current sub-select, if any */ +}; + +/* +** Callback function used by selectWindowRewriteEList(). If necessary, +** this function appends to the output expression-list and updates +** expression (*ppExpr) in place. +*/ +static int selectWindowRewriteExprCb(Walker *pWalker, Expr *pExpr){ + struct WindowRewrite *p = pWalker->u.pRewrite; + Parse *pParse = pWalker->pParse; + assert( p!=0 ); + assert( p->pWin!=0 ); + + /* If this function is being called from within a scalar sub-select + ** that used by the SELECT statement being processed, only process + ** TK_COLUMN expressions that refer to it (the outer SELECT). Do + ** not process aggregates or window functions at all, as they belong + ** to the scalar sub-select. */ + if( p->pSubSelect ){ + if( pExpr->op!=TK_COLUMN ){ + return WRC_Continue; + }else{ + int nSrc = p->pSrc->nSrc; + int i; + for(i=0; iiTable==p->pSrc->a[i].iCursor ) break; + } + if( i==nSrc ) return WRC_Continue; + } + } + + switch( pExpr->op ){ + + case TK_FUNCTION: + if( !ExprHasProperty(pExpr, EP_WinFunc) ){ + break; + }else{ + Window *pWin; + for(pWin=p->pWin; pWin; pWin=pWin->pNextWin){ + if( pExpr->y.pWin==pWin ){ + assert( pWin->pOwner==pExpr ); + return WRC_Prune; + } + } + } + /* no break */ deliberate_fall_through + + case TK_IF_NULL_ROW: + case TK_AGG_FUNCTION: + case TK_COLUMN: { + int iCol = -1; + if( pParse->db->mallocFailed ) return WRC_Abort; + if( p->pSub ){ + int i; + for(i=0; ipSub->nExpr; i++){ + if( 0==sqlite3ExprCompare(0, p->pSub->a[i].pExpr, pExpr, -1) ){ + iCol = i; + break; + } + } + } + if( iCol<0 ){ + Expr *pDup = sqlite3ExprDup(pParse->db, pExpr, 0); + if( pDup && pDup->op==TK_AGG_FUNCTION ) pDup->op = TK_FUNCTION; + p->pSub = sqlite3ExprListAppend(pParse, p->pSub, pDup); + } + if( p->pSub ){ + int f = pExpr->flags & EP_Collate; + assert( ExprHasProperty(pExpr, EP_Static)==0 ); + ExprSetProperty(pExpr, EP_Static); + sqlite3ExprDelete(pParse->db, pExpr); + ExprClearProperty(pExpr, EP_Static); + memset(pExpr, 0, sizeof(Expr)); + + pExpr->op = TK_COLUMN; + pExpr->iColumn = (iCol<0 ? p->pSub->nExpr-1: iCol); + pExpr->iTable = p->pWin->iEphCsr; + pExpr->y.pTab = p->pTab; + pExpr->flags = f; + } + if( pParse->db->mallocFailed ) return WRC_Abort; + break; + } + + default: /* no-op */ + break; + } + + return WRC_Continue; +} +static int selectWindowRewriteSelectCb(Walker *pWalker, Select *pSelect){ + struct WindowRewrite *p = pWalker->u.pRewrite; + Select *pSave = p->pSubSelect; + if( pSave==pSelect ){ + return WRC_Continue; + }else{ + p->pSubSelect = pSelect; + sqlite3WalkSelect(pWalker, pSelect); + p->pSubSelect = pSave; + } + return WRC_Prune; +} + + +/* +** Iterate through each expression in expression-list pEList. For each: +** +** * TK_COLUMN, +** * aggregate function, or +** * window function with a Window object that is not a member of the +** Window list passed as the second argument (pWin). +** +** Append the node to output expression-list (*ppSub). And replace it +** with a TK_COLUMN that reads the (N-1)th element of table +** pWin->iEphCsr, where N is the number of elements in (*ppSub) after +** appending the new one. +*/ +static void selectWindowRewriteEList( + Parse *pParse, + Window *pWin, + SrcList *pSrc, + ExprList *pEList, /* Rewrite expressions in this list */ + Table *pTab, + ExprList **ppSub /* IN/OUT: Sub-select expression-list */ +){ + Walker sWalker; + WindowRewrite sRewrite; + + assert( pWin!=0 ); + memset(&sWalker, 0, sizeof(Walker)); + memset(&sRewrite, 0, sizeof(WindowRewrite)); + + sRewrite.pSub = *ppSub; + sRewrite.pWin = pWin; + sRewrite.pSrc = pSrc; + sRewrite.pTab = pTab; + + sWalker.pParse = pParse; + sWalker.xExprCallback = selectWindowRewriteExprCb; + sWalker.xSelectCallback = selectWindowRewriteSelectCb; + sWalker.u.pRewrite = &sRewrite; + + (void)sqlite3WalkExprList(&sWalker, pEList); + + *ppSub = sRewrite.pSub; +} + +/* +** Append a copy of each expression in expression-list pAppend to +** expression list pList. Return a pointer to the result list. +*/ +static ExprList *exprListAppendList( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* List to which to append. Might be NULL */ + ExprList *pAppend, /* List of values to append. Might be NULL */ + int bIntToNull +){ + if( pAppend ){ + int i; + int nInit = pList ? pList->nExpr : 0; + for(i=0; inExpr; i++){ + sqlite3 *db = pParse->db; + Expr *pDup = sqlite3ExprDup(db, pAppend->a[i].pExpr, 0); + if( db->mallocFailed ){ + sqlite3ExprDelete(db, pDup); + break; + } + if( bIntToNull ){ + int iDummy; + Expr *pSub; + pSub = sqlite3ExprSkipCollateAndLikely(pDup); + if( sqlite3ExprIsInteger(pSub, &iDummy) ){ + pSub->op = TK_NULL; + pSub->flags &= ~(EP_IntValue|EP_IsTrue|EP_IsFalse); + pSub->u.zToken = 0; + } + } + pList = sqlite3ExprListAppend(pParse, pList, pDup); + if( pList ) pList->a[nInit+i].fg.sortFlags = pAppend->a[i].fg.sortFlags; + } + } + return pList; +} + +/* +** When rewriting a query, if the new subquery in the FROM clause +** contains TK_AGG_FUNCTION nodes that refer to an outer query, +** then we have to increase the Expr->op2 values of those nodes +** due to the extra subquery layer that was added. +** +** See also the incrAggDepth() routine in resolve.c +*/ +static int sqlite3WindowExtraAggFuncDepth(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_AGG_FUNCTION + && pExpr->op2>=pWalker->walkerDepth + ){ + pExpr->op2++; + } + return WRC_Continue; +} + +static int disallowAggregatesInOrderByCb(Walker *pWalker, Expr *pExpr){ + if( pExpr->op==TK_AGG_FUNCTION && pExpr->pAggInfo==0 ){ + assert( !ExprHasProperty(pExpr, EP_IntValue) ); + sqlite3ErrorMsg(pWalker->pParse, + "misuse of aggregate: %s()", pExpr->u.zToken); + } + return WRC_Continue; +} + +/* +** If the SELECT statement passed as the second argument does not invoke +** any SQL window functions, this function is a no-op. Otherwise, it +** rewrites the SELECT statement so that window function xStep functions +** are invoked in the correct order as described under "SELECT REWRITING" +** at the top of this file. +*/ +SQLITE_PRIVATE int sqlite3WindowRewrite(Parse *pParse, Select *p){ + int rc = SQLITE_OK; + if( p->pWin + && p->pPrior==0 + && ALWAYS((p->selFlags & SF_WinRewrite)==0) + && ALWAYS(!IN_RENAME_OBJECT) + ){ + Vdbe *v = sqlite3GetVdbe(pParse); + sqlite3 *db = pParse->db; + Select *pSub = 0; /* The subquery */ + SrcList *pSrc = p->pSrc; + Expr *pWhere = p->pWhere; + ExprList *pGroupBy = p->pGroupBy; + Expr *pHaving = p->pHaving; + ExprList *pSort = 0; + + ExprList *pSublist = 0; /* Expression list for sub-query */ + Window *pMWin = p->pWin; /* Main window object */ + Window *pWin; /* Window object iterator */ + Table *pTab; + Walker w; + + u32 selFlags = p->selFlags; + + pTab = sqlite3DbMallocZero(db, sizeof(Table)); + if( pTab==0 ){ + return sqlite3ErrorToParser(db, SQLITE_NOMEM); + } + sqlite3AggInfoPersistWalkerInit(&w, pParse); + sqlite3WalkSelect(&w, p); + if( (p->selFlags & SF_Aggregate)==0 ){ + w.xExprCallback = disallowAggregatesInOrderByCb; + w.xSelectCallback = 0; + sqlite3WalkExprList(&w, p->pOrderBy); + } + + p->pSrc = 0; + p->pWhere = 0; + p->pGroupBy = 0; + p->pHaving = 0; + p->selFlags &= ~SF_Aggregate; + p->selFlags |= SF_WinRewrite; + + /* Create the ORDER BY clause for the sub-select. This is the concatenation + ** of the window PARTITION and ORDER BY clauses. Then, if this makes it + ** redundant, remove the ORDER BY from the parent SELECT. */ + pSort = exprListAppendList(pParse, 0, pMWin->pPartition, 1); + pSort = exprListAppendList(pParse, pSort, pMWin->pOrderBy, 1); + if( pSort && p->pOrderBy && p->pOrderBy->nExpr<=pSort->nExpr ){ + int nSave = pSort->nExpr; + pSort->nExpr = p->pOrderBy->nExpr; + if( sqlite3ExprListCompare(pSort, p->pOrderBy, -1)==0 ){ + sqlite3ExprListDelete(db, p->pOrderBy); + p->pOrderBy = 0; + } + pSort->nExpr = nSave; + } + + /* Assign a cursor number for the ephemeral table used to buffer rows. + ** The OpenEphemeral instruction is coded later, after it is known how + ** many columns the table will have. */ + pMWin->iEphCsr = pParse->nTab++; + pParse->nTab += 3; + + selectWindowRewriteEList(pParse, pMWin, pSrc, p->pEList, pTab, &pSublist); + selectWindowRewriteEList(pParse, pMWin, pSrc, p->pOrderBy, pTab, &pSublist); + pMWin->nBufferCol = (pSublist ? pSublist->nExpr : 0); + + /* Append the PARTITION BY and ORDER BY expressions to the to the + ** sub-select expression list. They are required to figure out where + ** boundaries for partitions and sets of peer rows lie. */ + pSublist = exprListAppendList(pParse, pSublist, pMWin->pPartition, 0); + pSublist = exprListAppendList(pParse, pSublist, pMWin->pOrderBy, 0); + + /* Append the arguments passed to each window function to the + ** sub-select expression list. Also allocate two registers for each + ** window function - one for the accumulator, another for interim + ** results. */ + for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ + ExprList *pArgs; + assert( ExprUseXList(pWin->pOwner) ); + assert( pWin->pWFunc!=0 ); + pArgs = pWin->pOwner->x.pList; + if( pWin->pWFunc->funcFlags & SQLITE_FUNC_SUBTYPE ){ + selectWindowRewriteEList(pParse, pMWin, pSrc, pArgs, pTab, &pSublist); + pWin->iArgCol = (pSublist ? pSublist->nExpr : 0); + pWin->bExprArgs = 1; + }else{ + pWin->iArgCol = (pSublist ? pSublist->nExpr : 0); + pSublist = exprListAppendList(pParse, pSublist, pArgs, 0); + } + if( pWin->pFilter ){ + Expr *pFilter = sqlite3ExprDup(db, pWin->pFilter, 0); + pSublist = sqlite3ExprListAppend(pParse, pSublist, pFilter); + } + pWin->regAccum = ++pParse->nMem; + pWin->regResult = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum); + } + + /* If there is no ORDER BY or PARTITION BY clause, and the window + ** function accepts zero arguments, and there are no other columns + ** selected (e.g. "SELECT row_number() OVER () FROM t1"), it is possible + ** that pSublist is still NULL here. Add a constant expression here to + ** keep everything legal in this case. + */ + if( pSublist==0 ){ + pSublist = sqlite3ExprListAppend(pParse, 0, + sqlite3Expr(db, TK_INTEGER, "0") + ); + } + + pSub = sqlite3SelectNew( + pParse, pSublist, pSrc, pWhere, pGroupBy, pHaving, pSort, 0, 0 + ); + TREETRACE(0x40,pParse,pSub, + ("New window-function subquery in FROM clause of (%u/%p)\n", + p->selId, p)); + p->pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0); + assert( pSub!=0 || p->pSrc==0 ); /* Due to db->mallocFailed test inside + ** of sqlite3DbMallocRawNN() called from + ** sqlite3SrcListAppend() */ + if( p->pSrc ){ + Table *pTab2; + p->pSrc->a[0].pSelect = pSub; + p->pSrc->a[0].fg.isCorrelated = 1; + sqlite3SrcListAssignCursors(pParse, p->pSrc); + pSub->selFlags |= SF_Expanded|SF_OrderByReqd; + pTab2 = sqlite3ResultSetOfSelect(pParse, pSub, SQLITE_AFF_NONE); + pSub->selFlags |= (selFlags & SF_Aggregate); + if( pTab2==0 ){ + /* Might actually be some other kind of error, but in that case + ** pParse->nErr will be set, so if SQLITE_NOMEM is set, we will get + ** the correct error message regardless. */ + rc = SQLITE_NOMEM; + }else{ + memcpy(pTab, pTab2, sizeof(Table)); + pTab->tabFlags |= TF_Ephemeral; + p->pSrc->a[0].pTab = pTab; + pTab = pTab2; + memset(&w, 0, sizeof(w)); + w.xExprCallback = sqlite3WindowExtraAggFuncDepth; + w.xSelectCallback = sqlite3WalkerDepthIncrease; + w.xSelectCallback2 = sqlite3WalkerDepthDecrease; + sqlite3WalkSelect(&w, pSub); + } + }else{ + sqlite3SelectDelete(db, pSub); + } + if( db->mallocFailed ) rc = SQLITE_NOMEM; + + /* Defer deleting the temporary table pTab because if an error occurred, + ** there could still be references to that table embedded in the + ** result-set or ORDER BY clause of the SELECT statement p. */ + sqlite3ParserAddCleanup(pParse, sqlite3DbFree, pTab); + } + + assert( rc==SQLITE_OK || pParse->nErr!=0 ); + return rc; +} + +/* +** Unlink the Window object from the Select to which it is attached, +** if it is attached. +*/ +SQLITE_PRIVATE void sqlite3WindowUnlinkFromSelect(Window *p){ + if( p->ppThis ){ + *p->ppThis = p->pNextWin; + if( p->pNextWin ) p->pNextWin->ppThis = p->ppThis; + p->ppThis = 0; + } +} + +/* +** Free the Window object passed as the second argument. +*/ +SQLITE_PRIVATE void sqlite3WindowDelete(sqlite3 *db, Window *p){ + if( p ){ + sqlite3WindowUnlinkFromSelect(p); + sqlite3ExprDelete(db, p->pFilter); + sqlite3ExprListDelete(db, p->pPartition); + sqlite3ExprListDelete(db, p->pOrderBy); + sqlite3ExprDelete(db, p->pEnd); + sqlite3ExprDelete(db, p->pStart); + sqlite3DbFree(db, p->zName); + sqlite3DbFree(db, p->zBase); + sqlite3DbFree(db, p); + } +} + +/* +** Free the linked list of Window objects starting at the second argument. +*/ +SQLITE_PRIVATE void sqlite3WindowListDelete(sqlite3 *db, Window *p){ + while( p ){ + Window *pNext = p->pNextWin; + sqlite3WindowDelete(db, p); + p = pNext; + } +} + +/* +** The argument expression is an PRECEDING or FOLLOWING offset. The +** value should be a non-negative integer. If the value is not a +** constant, change it to NULL. The fact that it is then a non-negative +** integer will be caught later. But it is important not to leave +** variable values in the expression tree. +*/ +static Expr *sqlite3WindowOffsetExpr(Parse *pParse, Expr *pExpr){ + if( 0==sqlite3ExprIsConstant(pExpr) ){ + if( IN_RENAME_OBJECT ) sqlite3RenameExprUnmap(pParse, pExpr); + sqlite3ExprDelete(pParse->db, pExpr); + pExpr = sqlite3ExprAlloc(pParse->db, TK_NULL, 0, 0); + } + return pExpr; +} + +/* +** Allocate and return a new Window object describing a Window Definition. +*/ +SQLITE_PRIVATE Window *sqlite3WindowAlloc( + Parse *pParse, /* Parsing context */ + int eType, /* Frame type. TK_RANGE, TK_ROWS, TK_GROUPS, or 0 */ + int eStart, /* Start type: CURRENT, PRECEDING, FOLLOWING, UNBOUNDED */ + Expr *pStart, /* Start window size if TK_PRECEDING or FOLLOWING */ + int eEnd, /* End type: CURRENT, FOLLOWING, TK_UNBOUNDED, PRECEDING */ + Expr *pEnd, /* End window size if TK_FOLLOWING or PRECEDING */ + u8 eExclude /* EXCLUDE clause */ +){ + Window *pWin = 0; + int bImplicitFrame = 0; + + /* Parser assures the following: */ + assert( eType==0 || eType==TK_RANGE || eType==TK_ROWS || eType==TK_GROUPS ); + assert( eStart==TK_CURRENT || eStart==TK_PRECEDING + || eStart==TK_UNBOUNDED || eStart==TK_FOLLOWING ); + assert( eEnd==TK_CURRENT || eEnd==TK_FOLLOWING + || eEnd==TK_UNBOUNDED || eEnd==TK_PRECEDING ); + assert( (eStart==TK_PRECEDING || eStart==TK_FOLLOWING)==(pStart!=0) ); + assert( (eEnd==TK_FOLLOWING || eEnd==TK_PRECEDING)==(pEnd!=0) ); + + if( eType==0 ){ + bImplicitFrame = 1; + eType = TK_RANGE; + } + + /* Additionally, the + ** starting boundary type may not occur earlier in the following list than + ** the ending boundary type: + ** + ** UNBOUNDED PRECEDING + ** PRECEDING + ** CURRENT ROW + ** FOLLOWING + ** UNBOUNDED FOLLOWING + ** + ** The parser ensures that "UNBOUNDED PRECEDING" cannot be used as an ending + ** boundary, and than "UNBOUNDED FOLLOWING" cannot be used as a starting + ** frame boundary. + */ + if( (eStart==TK_CURRENT && eEnd==TK_PRECEDING) + || (eStart==TK_FOLLOWING && (eEnd==TK_PRECEDING || eEnd==TK_CURRENT)) + ){ + sqlite3ErrorMsg(pParse, "unsupported frame specification"); + goto windowAllocErr; + } + + pWin = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window)); + if( pWin==0 ) goto windowAllocErr; + pWin->eFrmType = eType; + pWin->eStart = eStart; + pWin->eEnd = eEnd; + if( eExclude==0 && OptimizationDisabled(pParse->db, SQLITE_WindowFunc) ){ + eExclude = TK_NO; + } + pWin->eExclude = eExclude; + pWin->bImplicitFrame = bImplicitFrame; + pWin->pEnd = sqlite3WindowOffsetExpr(pParse, pEnd); + pWin->pStart = sqlite3WindowOffsetExpr(pParse, pStart); + return pWin; + +windowAllocErr: + sqlite3ExprDelete(pParse->db, pEnd); + sqlite3ExprDelete(pParse->db, pStart); + return 0; +} + +/* +** Attach PARTITION and ORDER BY clauses pPartition and pOrderBy to window +** pWin. Also, if parameter pBase is not NULL, set pWin->zBase to the +** equivalent nul-terminated string. +*/ +SQLITE_PRIVATE Window *sqlite3WindowAssemble( + Parse *pParse, + Window *pWin, + ExprList *pPartition, + ExprList *pOrderBy, + Token *pBase +){ + if( pWin ){ + pWin->pPartition = pPartition; + pWin->pOrderBy = pOrderBy; + if( pBase ){ + pWin->zBase = sqlite3DbStrNDup(pParse->db, pBase->z, pBase->n); + } + }else{ + sqlite3ExprListDelete(pParse->db, pPartition); + sqlite3ExprListDelete(pParse->db, pOrderBy); + } + return pWin; +} + +/* +** Window *pWin has just been created from a WINDOW clause. Tokne pBase +** is the base window. Earlier windows from the same WINDOW clause are +** stored in the linked list starting at pWin->pNextWin. This function +** either updates *pWin according to the base specification, or else +** leaves an error in pParse. +*/ +SQLITE_PRIVATE void sqlite3WindowChain(Parse *pParse, Window *pWin, Window *pList){ + if( pWin->zBase ){ + sqlite3 *db = pParse->db; + Window *pExist = windowFind(pParse, pList, pWin->zBase); + if( pExist ){ + const char *zErr = 0; + /* Check for errors */ + if( pWin->pPartition ){ + zErr = "PARTITION clause"; + }else if( pExist->pOrderBy && pWin->pOrderBy ){ + zErr = "ORDER BY clause"; + }else if( pExist->bImplicitFrame==0 ){ + zErr = "frame specification"; + } + if( zErr ){ + sqlite3ErrorMsg(pParse, + "cannot override %s of window: %s", zErr, pWin->zBase + ); + }else{ + pWin->pPartition = sqlite3ExprListDup(db, pExist->pPartition, 0); + if( pExist->pOrderBy ){ + assert( pWin->pOrderBy==0 ); + pWin->pOrderBy = sqlite3ExprListDup(db, pExist->pOrderBy, 0); + } + sqlite3DbFree(db, pWin->zBase); + pWin->zBase = 0; + } + } + } +} + +/* +** Attach window object pWin to expression p. +*/ +SQLITE_PRIVATE void sqlite3WindowAttach(Parse *pParse, Expr *p, Window *pWin){ + if( p ){ + assert( p->op==TK_FUNCTION ); + assert( pWin ); + p->y.pWin = pWin; + ExprSetProperty(p, EP_WinFunc); + pWin->pOwner = p; + if( (p->flags & EP_Distinct) && pWin->eFrmType!=TK_FILTER ){ + sqlite3ErrorMsg(pParse, + "DISTINCT is not supported for window functions" + ); + } + }else{ + sqlite3WindowDelete(pParse->db, pWin); + } +} + +/* +** Possibly link window pWin into the list at pSel->pWin (window functions +** to be processed as part of SELECT statement pSel). The window is linked +** in if either (a) there are no other windows already linked to this +** SELECT, or (b) the windows already linked use a compatible window frame. +*/ +SQLITE_PRIVATE void sqlite3WindowLink(Select *pSel, Window *pWin){ + if( pSel ){ + if( 0==pSel->pWin || 0==sqlite3WindowCompare(0, pSel->pWin, pWin, 0) ){ + pWin->pNextWin = pSel->pWin; + if( pSel->pWin ){ + pSel->pWin->ppThis = &pWin->pNextWin; + } + pSel->pWin = pWin; + pWin->ppThis = &pSel->pWin; + }else{ + if( sqlite3ExprListCompare(pWin->pPartition, pSel->pWin->pPartition,-1) ){ + pSel->selFlags |= SF_MultiPart; + } + } + } +} + +/* +** Return 0 if the two window objects are identical, 1 if they are +** different, or 2 if it cannot be determined if the objects are identical +** or not. Identical window objects can be processed in a single scan. +*/ +SQLITE_PRIVATE int sqlite3WindowCompare( + const Parse *pParse, + const Window *p1, + const Window *p2, + int bFilter +){ + int res; + if( NEVER(p1==0) || NEVER(p2==0) ) return 1; + if( p1->eFrmType!=p2->eFrmType ) return 1; + if( p1->eStart!=p2->eStart ) return 1; + if( p1->eEnd!=p2->eEnd ) return 1; + if( p1->eExclude!=p2->eExclude ) return 1; + if( sqlite3ExprCompare(pParse, p1->pStart, p2->pStart, -1) ) return 1; + if( sqlite3ExprCompare(pParse, p1->pEnd, p2->pEnd, -1) ) return 1; + if( (res = sqlite3ExprListCompare(p1->pPartition, p2->pPartition, -1)) ){ + return res; + } + if( (res = sqlite3ExprListCompare(p1->pOrderBy, p2->pOrderBy, -1)) ){ + return res; + } + if( bFilter ){ + if( (res = sqlite3ExprCompare(pParse, p1->pFilter, p2->pFilter, -1)) ){ + return res; + } + } + return 0; +} + + +/* +** This is called by code in select.c before it calls sqlite3WhereBegin() +** to begin iterating through the sub-query results. It is used to allocate +** and initialize registers and cursors used by sqlite3WindowCodeStep(). +*/ +SQLITE_PRIVATE void sqlite3WindowCodeInit(Parse *pParse, Select *pSelect){ + int nEphExpr = pSelect->pSrc->a[0].pSelect->pEList->nExpr; + Window *pMWin = pSelect->pWin; + Window *pWin; + Vdbe *v = sqlite3GetVdbe(pParse); + + sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pMWin->iEphCsr, nEphExpr); + sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->iEphCsr+1, pMWin->iEphCsr); + sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->iEphCsr+2, pMWin->iEphCsr); + sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->iEphCsr+3, pMWin->iEphCsr); + + /* Allocate registers to use for PARTITION BY values, if any. Initialize + ** said registers to NULL. */ + if( pMWin->pPartition ){ + int nExpr = pMWin->pPartition->nExpr; + pMWin->regPart = pParse->nMem+1; + pParse->nMem += nExpr; + sqlite3VdbeAddOp3(v, OP_Null, 0, pMWin->regPart, pMWin->regPart+nExpr-1); + } + + pMWin->regOne = ++pParse->nMem; + sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regOne); + + if( pMWin->eExclude ){ + pMWin->regStartRowid = ++pParse->nMem; + pMWin->regEndRowid = ++pParse->nMem; + pMWin->csrApp = pParse->nTab++; + sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regStartRowid); + sqlite3VdbeAddOp2(v, OP_Integer, 0, pMWin->regEndRowid); + sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->csrApp, pMWin->iEphCsr); + return; + } + + for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ + FuncDef *p = pWin->pWFunc; + if( (p->funcFlags & SQLITE_FUNC_MINMAX) && pWin->eStart!=TK_UNBOUNDED ){ + /* The inline versions of min() and max() require a single ephemeral + ** table and 3 registers. The registers are used as follows: + ** + ** regApp+0: slot to copy min()/max() argument to for MakeRecord + ** regApp+1: integer value used to ensure keys are unique + ** regApp+2: output of MakeRecord + */ + ExprList *pList; + KeyInfo *pKeyInfo; + assert( ExprUseXList(pWin->pOwner) ); + pList = pWin->pOwner->x.pList; + pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pList, 0, 0); + pWin->csrApp = pParse->nTab++; + pWin->regApp = pParse->nMem+1; + pParse->nMem += 3; + if( pKeyInfo && pWin->pWFunc->zName[1]=='i' ){ + assert( pKeyInfo->aSortFlags[0]==0 ); + pKeyInfo->aSortFlags[0] = KEYINFO_ORDER_DESC; + } + sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pWin->csrApp, 2); + sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO); + sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1); + } + else if( p->zName==nth_valueName || p->zName==first_valueName ){ + /* Allocate two registers at pWin->regApp. These will be used to + ** store the start and end index of the current frame. */ + pWin->regApp = pParse->nMem+1; + pWin->csrApp = pParse->nTab++; + pParse->nMem += 2; + sqlite3VdbeAddOp2(v, OP_OpenDup, pWin->csrApp, pMWin->iEphCsr); + } + else if( p->zName==leadName || p->zName==lagName ){ + pWin->csrApp = pParse->nTab++; + sqlite3VdbeAddOp2(v, OP_OpenDup, pWin->csrApp, pMWin->iEphCsr); + } + } +} + +#define WINDOW_STARTING_INT 0 +#define WINDOW_ENDING_INT 1 +#define WINDOW_NTH_VALUE_INT 2 +#define WINDOW_STARTING_NUM 3 +#define WINDOW_ENDING_NUM 4 + +/* +** A "PRECEDING " (eCond==0) or "FOLLOWING " (eCond==1) or the +** value of the second argument to nth_value() (eCond==2) has just been +** evaluated and the result left in register reg. This function generates VM +** code to check that the value is a non-negative integer and throws an +** exception if it is not. +*/ +static void windowCheckValue(Parse *pParse, int reg, int eCond){ + static const char *azErr[] = { + "frame starting offset must be a non-negative integer", + "frame ending offset must be a non-negative integer", + "second argument to nth_value must be a positive integer", + "frame starting offset must be a non-negative number", + "frame ending offset must be a non-negative number", + }; + static int aOp[] = { OP_Ge, OP_Ge, OP_Gt, OP_Ge, OP_Ge }; + Vdbe *v = sqlite3GetVdbe(pParse); + int regZero = sqlite3GetTempReg(pParse); + assert( eCond>=0 && eCond=WINDOW_STARTING_NUM ){ + int regString = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp4(v, OP_String8, 0, regString, 0, "", P4_STATIC); + sqlite3VdbeAddOp3(v, OP_Ge, regString, sqlite3VdbeCurrentAddr(v)+2, reg); + sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC|SQLITE_JUMPIFNULL); + VdbeCoverage(v); + assert( eCond==3 || eCond==4 ); + VdbeCoverageIf(v, eCond==3); + VdbeCoverageIf(v, eCond==4); + }else{ + sqlite3VdbeAddOp2(v, OP_MustBeInt, reg, sqlite3VdbeCurrentAddr(v)+2); + VdbeCoverage(v); + assert( eCond==0 || eCond==1 || eCond==2 ); + VdbeCoverageIf(v, eCond==0); + VdbeCoverageIf(v, eCond==1); + VdbeCoverageIf(v, eCond==2); + } + sqlite3VdbeAddOp3(v, aOp[eCond], regZero, sqlite3VdbeCurrentAddr(v)+2, reg); + sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC); + VdbeCoverageNeverNullIf(v, eCond==0); /* NULL case captured by */ + VdbeCoverageNeverNullIf(v, eCond==1); /* the OP_MustBeInt */ + VdbeCoverageNeverNullIf(v, eCond==2); + VdbeCoverageNeverNullIf(v, eCond==3); /* NULL case caught by */ + VdbeCoverageNeverNullIf(v, eCond==4); /* the OP_Ge */ + sqlite3MayAbort(pParse); + sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_ERROR, OE_Abort); + sqlite3VdbeAppendP4(v, (void*)azErr[eCond], P4_STATIC); + sqlite3ReleaseTempReg(pParse, regZero); +} + +/* +** Return the number of arguments passed to the window-function associated +** with the object passed as the only argument to this function. +*/ +static int windowArgCount(Window *pWin){ + const ExprList *pList; + assert( ExprUseXList(pWin->pOwner) ); + pList = pWin->pOwner->x.pList; + return (pList ? pList->nExpr : 0); +} + +typedef struct WindowCodeArg WindowCodeArg; +typedef struct WindowCsrAndReg WindowCsrAndReg; + +/* +** See comments above struct WindowCodeArg. +*/ +struct WindowCsrAndReg { + int csr; /* Cursor number */ + int reg; /* First in array of peer values */ +}; + +/* +** A single instance of this structure is allocated on the stack by +** sqlite3WindowCodeStep() and a pointer to it passed to the various helper +** routines. This is to reduce the number of arguments required by each +** helper function. +** +** regArg: +** Each window function requires an accumulator register (just as an +** ordinary aggregate function does). This variable is set to the first +** in an array of accumulator registers - one for each window function +** in the WindowCodeArg.pMWin list. +** +** eDelete: +** The window functions implementation sometimes caches the input rows +** that it processes in a temporary table. If it is not zero, this +** variable indicates when rows may be removed from the temp table (in +** order to reduce memory requirements - it would always be safe just +** to leave them there). Possible values for eDelete are: +** +** WINDOW_RETURN_ROW: +** An input row can be discarded after it is returned to the caller. +** +** WINDOW_AGGINVERSE: +** An input row can be discarded after the window functions xInverse() +** callbacks have been invoked in it. +** +** WINDOW_AGGSTEP: +** An input row can be discarded after the window functions xStep() +** callbacks have been invoked in it. +** +** start,current,end +** Consider a window-frame similar to the following: +** +** (ORDER BY a, b GROUPS BETWEEN 2 PRECEDING AND 2 FOLLOWING) +** +** The windows functions implmentation caches the input rows in a temp +** table, sorted by "a, b" (it actually populates the cache lazily, and +** aggressively removes rows once they are no longer required, but that's +** a mere detail). It keeps three cursors open on the temp table. One +** (current) that points to the next row to return to the query engine +** once its window function values have been calculated. Another (end) +** points to the next row to call the xStep() method of each window function +** on (so that it is 2 groups ahead of current). And a third (start) that +** points to the next row to call the xInverse() method of each window +** function on. +** +** Each cursor (start, current and end) consists of a VDBE cursor +** (WindowCsrAndReg.csr) and an array of registers (starting at +** WindowCodeArg.reg) that always contains a copy of the peer values +** read from the corresponding cursor. +** +** Depending on the window-frame in question, all three cursors may not +** be required. In this case both WindowCodeArg.csr and reg are set to +** 0. +*/ +struct WindowCodeArg { + Parse *pParse; /* Parse context */ + Window *pMWin; /* First in list of functions being processed */ + Vdbe *pVdbe; /* VDBE object */ + int addrGosub; /* OP_Gosub to this address to return one row */ + int regGosub; /* Register used with OP_Gosub(addrGosub) */ + int regArg; /* First in array of accumulator registers */ + int eDelete; /* See above */ + int regRowid; + + WindowCsrAndReg start; + WindowCsrAndReg current; + WindowCsrAndReg end; +}; + +/* +** Generate VM code to read the window frames peer values from cursor csr into +** an array of registers starting at reg. +*/ +static void windowReadPeerValues( + WindowCodeArg *p, + int csr, + int reg +){ + Window *pMWin = p->pMWin; + ExprList *pOrderBy = pMWin->pOrderBy; + if( pOrderBy ){ + Vdbe *v = sqlite3GetVdbe(p->pParse); + ExprList *pPart = pMWin->pPartition; + int iColOff = pMWin->nBufferCol + (pPart ? pPart->nExpr : 0); + int i; + for(i=0; inExpr; i++){ + sqlite3VdbeAddOp3(v, OP_Column, csr, iColOff+i, reg+i); + } + } +} + +/* +** Generate VM code to invoke either xStep() (if bInverse is 0) or +** xInverse (if bInverse is non-zero) for each window function in the +** linked list starting at pMWin. Or, for built-in window functions +** that do not use the standard function API, generate the required +** inline VM code. +** +** If argument csr is greater than or equal to 0, then argument reg is +** the first register in an array of registers guaranteed to be large +** enough to hold the array of arguments for each function. In this case +** the arguments are extracted from the current row of csr into the +** array of registers before invoking OP_AggStep or OP_AggInverse +** +** Or, if csr is less than zero, then the array of registers at reg is +** already populated with all columns from the current row of the sub-query. +** +** If argument regPartSize is non-zero, then it is a register containing the +** number of rows in the current partition. +*/ +static void windowAggStep( + WindowCodeArg *p, + Window *pMWin, /* Linked list of window functions */ + int csr, /* Read arguments from this cursor */ + int bInverse, /* True to invoke xInverse instead of xStep */ + int reg /* Array of registers */ +){ + Parse *pParse = p->pParse; + Vdbe *v = sqlite3GetVdbe(pParse); + Window *pWin; + for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ + FuncDef *pFunc = pWin->pWFunc; + int regArg; + int nArg = pWin->bExprArgs ? 0 : windowArgCount(pWin); + int i; + + assert( bInverse==0 || pWin->eStart!=TK_UNBOUNDED ); + + /* All OVER clauses in the same window function aggregate step must + ** be the same. */ + assert( pWin==pMWin || sqlite3WindowCompare(pParse,pWin,pMWin,0)!=1 ); + + for(i=0; izName!=nth_valueName ){ + sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol+i, reg+i); + }else{ + sqlite3VdbeAddOp3(v, OP_Column, pMWin->iEphCsr, pWin->iArgCol+i, reg+i); + } + } + regArg = reg; + + if( pMWin->regStartRowid==0 + && (pFunc->funcFlags & SQLITE_FUNC_MINMAX) + && (pWin->eStart!=TK_UNBOUNDED) + ){ + int addrIsNull = sqlite3VdbeAddOp1(v, OP_IsNull, regArg); + VdbeCoverage(v); + if( bInverse==0 ){ + sqlite3VdbeAddOp2(v, OP_AddImm, pWin->regApp+1, 1); + sqlite3VdbeAddOp2(v, OP_SCopy, regArg, pWin->regApp); + sqlite3VdbeAddOp3(v, OP_MakeRecord, pWin->regApp, 2, pWin->regApp+2); + sqlite3VdbeAddOp2(v, OP_IdxInsert, pWin->csrApp, pWin->regApp+2); + }else{ + sqlite3VdbeAddOp4Int(v, OP_SeekGE, pWin->csrApp, 0, regArg, 1); + VdbeCoverageNeverTaken(v); + sqlite3VdbeAddOp1(v, OP_Delete, pWin->csrApp); + sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2); + } + sqlite3VdbeJumpHere(v, addrIsNull); + }else if( pWin->regApp ){ + assert( pFunc->zName==nth_valueName + || pFunc->zName==first_valueName + ); + assert( bInverse==0 || bInverse==1 ); + sqlite3VdbeAddOp2(v, OP_AddImm, pWin->regApp+1-bInverse, 1); + }else if( pFunc->xSFunc!=noopStepFunc ){ + int addrIf = 0; + if( pWin->pFilter ){ + int regTmp; + assert( ExprUseXList(pWin->pOwner) ); + assert( pWin->bExprArgs || !nArg ||nArg==pWin->pOwner->x.pList->nExpr ); + assert( pWin->bExprArgs || nArg ||pWin->pOwner->x.pList==0 ); + regTmp = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol+nArg,regTmp); + addrIf = sqlite3VdbeAddOp3(v, OP_IfNot, regTmp, 0, 1); + VdbeCoverage(v); + sqlite3ReleaseTempReg(pParse, regTmp); + } + + if( pWin->bExprArgs ){ + int iOp = sqlite3VdbeCurrentAddr(v); + int iEnd; + + assert( ExprUseXList(pWin->pOwner) ); + nArg = pWin->pOwner->x.pList->nExpr; + regArg = sqlite3GetTempRange(pParse, nArg); + sqlite3ExprCodeExprList(pParse, pWin->pOwner->x.pList, regArg, 0, 0); + + for(iEnd=sqlite3VdbeCurrentAddr(v); iOpopcode==OP_Column && pOp->p1==pMWin->iEphCsr ){ + pOp->p1 = csr; + } + } + } + if( pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL ){ + CollSeq *pColl; + assert( nArg>0 ); + assert( ExprUseXList(pWin->pOwner) ); + pColl = sqlite3ExprNNCollSeq(pParse, pWin->pOwner->x.pList->a[0].pExpr); + sqlite3VdbeAddOp4(v, OP_CollSeq, 0,0,0, (const char*)pColl, P4_COLLSEQ); + } + sqlite3VdbeAddOp3(v, bInverse? OP_AggInverse : OP_AggStep, + bInverse, regArg, pWin->regAccum); + sqlite3VdbeAppendP4(v, pFunc, P4_FUNCDEF); + sqlite3VdbeChangeP5(v, (u8)nArg); + if( pWin->bExprArgs ){ + sqlite3ReleaseTempRange(pParse, regArg, nArg); + } + if( addrIf ) sqlite3VdbeJumpHere(v, addrIf); + } + } +} + +/* +** Values that may be passed as the second argument to windowCodeOp(). +*/ +#define WINDOW_RETURN_ROW 1 +#define WINDOW_AGGINVERSE 2 +#define WINDOW_AGGSTEP 3 + +/* +** Generate VM code to invoke either xValue() (bFin==0) or xFinalize() +** (bFin==1) for each window function in the linked list starting at +** pMWin. Or, for built-in window-functions that do not use the standard +** API, generate the equivalent VM code. +*/ +static void windowAggFinal(WindowCodeArg *p, int bFin){ + Parse *pParse = p->pParse; + Window *pMWin = p->pMWin; + Vdbe *v = sqlite3GetVdbe(pParse); + Window *pWin; + + for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ + if( pMWin->regStartRowid==0 + && (pWin->pWFunc->funcFlags & SQLITE_FUNC_MINMAX) + && (pWin->eStart!=TK_UNBOUNDED) + ){ + sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult); + sqlite3VdbeAddOp1(v, OP_Last, pWin->csrApp); + VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_Column, pWin->csrApp, 0, pWin->regResult); + sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2); + }else if( pWin->regApp ){ + assert( pMWin->regStartRowid==0 ); + }else{ + int nArg = windowArgCount(pWin); + if( bFin ){ + sqlite3VdbeAddOp2(v, OP_AggFinal, pWin->regAccum, nArg); + sqlite3VdbeAppendP4(v, pWin->pWFunc, P4_FUNCDEF); + sqlite3VdbeAddOp2(v, OP_Copy, pWin->regAccum, pWin->regResult); + sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum); + }else{ + sqlite3VdbeAddOp3(v, OP_AggValue,pWin->regAccum,nArg,pWin->regResult); + sqlite3VdbeAppendP4(v, pWin->pWFunc, P4_FUNCDEF); + } + } + } +} + +/* +** Generate code to calculate the current values of all window functions in the +** p->pMWin list by doing a full scan of the current window frame. Store the +** results in the Window.regResult registers, ready to return the upper +** layer. +*/ +static void windowFullScan(WindowCodeArg *p){ + Window *pWin; + Parse *pParse = p->pParse; + Window *pMWin = p->pMWin; + Vdbe *v = p->pVdbe; + + int regCRowid = 0; /* Current rowid value */ + int regCPeer = 0; /* Current peer values */ + int regRowid = 0; /* AggStep rowid value */ + int regPeer = 0; /* AggStep peer values */ + + int nPeer; + int lblNext; + int lblBrk; + int addrNext; + int csr; + + VdbeModuleComment((v, "windowFullScan begin")); + + assert( pMWin!=0 ); + csr = pMWin->csrApp; + nPeer = (pMWin->pOrderBy ? pMWin->pOrderBy->nExpr : 0); + + lblNext = sqlite3VdbeMakeLabel(pParse); + lblBrk = sqlite3VdbeMakeLabel(pParse); + + regCRowid = sqlite3GetTempReg(pParse); + regRowid = sqlite3GetTempReg(pParse); + if( nPeer ){ + regCPeer = sqlite3GetTempRange(pParse, nPeer); + regPeer = sqlite3GetTempRange(pParse, nPeer); + } + + sqlite3VdbeAddOp2(v, OP_Rowid, pMWin->iEphCsr, regCRowid); + windowReadPeerValues(p, pMWin->iEphCsr, regCPeer); + + for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ + sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum); + } + + sqlite3VdbeAddOp3(v, OP_SeekGE, csr, lblBrk, pMWin->regStartRowid); + VdbeCoverage(v); + addrNext = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp2(v, OP_Rowid, csr, regRowid); + sqlite3VdbeAddOp3(v, OP_Gt, pMWin->regEndRowid, lblBrk, regRowid); + VdbeCoverageNeverNull(v); + + if( pMWin->eExclude==TK_CURRENT ){ + sqlite3VdbeAddOp3(v, OP_Eq, regCRowid, lblNext, regRowid); + VdbeCoverageNeverNull(v); + }else if( pMWin->eExclude!=TK_NO ){ + int addr; + int addrEq = 0; + KeyInfo *pKeyInfo = 0; + + if( pMWin->pOrderBy ){ + pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pMWin->pOrderBy, 0, 0); + } + if( pMWin->eExclude==TK_TIES ){ + addrEq = sqlite3VdbeAddOp3(v, OP_Eq, regCRowid, 0, regRowid); + VdbeCoverageNeverNull(v); + } + if( pKeyInfo ){ + windowReadPeerValues(p, csr, regPeer); + sqlite3VdbeAddOp3(v, OP_Compare, regPeer, regCPeer, nPeer); + sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO); + addr = sqlite3VdbeCurrentAddr(v)+1; + sqlite3VdbeAddOp3(v, OP_Jump, addr, lblNext, addr); + VdbeCoverageEqNe(v); + }else{ + sqlite3VdbeAddOp2(v, OP_Goto, 0, lblNext); + } + if( addrEq ) sqlite3VdbeJumpHere(v, addrEq); + } + + windowAggStep(p, pMWin, csr, 0, p->regArg); + + sqlite3VdbeResolveLabel(v, lblNext); + sqlite3VdbeAddOp2(v, OP_Next, csr, addrNext); + VdbeCoverage(v); + sqlite3VdbeJumpHere(v, addrNext-1); + sqlite3VdbeJumpHere(v, addrNext+1); + sqlite3ReleaseTempReg(pParse, regRowid); + sqlite3ReleaseTempReg(pParse, regCRowid); + if( nPeer ){ + sqlite3ReleaseTempRange(pParse, regPeer, nPeer); + sqlite3ReleaseTempRange(pParse, regCPeer, nPeer); + } + + windowAggFinal(p, 1); + VdbeModuleComment((v, "windowFullScan end")); +} + +/* +** Invoke the sub-routine at regGosub (generated by code in select.c) to +** return the current row of Window.iEphCsr. If all window functions are +** aggregate window functions that use the standard API, a single +** OP_Gosub instruction is all that this routine generates. Extra VM code +** for per-row processing is only generated for the following built-in window +** functions: +** +** nth_value() +** first_value() +** lag() +** lead() +*/ +static void windowReturnOneRow(WindowCodeArg *p){ + Window *pMWin = p->pMWin; + Vdbe *v = p->pVdbe; + + if( pMWin->regStartRowid ){ + windowFullScan(p); + }else{ + Parse *pParse = p->pParse; + Window *pWin; + + for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ + FuncDef *pFunc = pWin->pWFunc; + assert( ExprUseXList(pWin->pOwner) ); + if( pFunc->zName==nth_valueName + || pFunc->zName==first_valueName + ){ + int csr = pWin->csrApp; + int lbl = sqlite3VdbeMakeLabel(pParse); + int tmpReg = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult); + + if( pFunc->zName==nth_valueName ){ + sqlite3VdbeAddOp3(v, OP_Column,pMWin->iEphCsr,pWin->iArgCol+1,tmpReg); + windowCheckValue(pParse, tmpReg, 2); + }else{ + sqlite3VdbeAddOp2(v, OP_Integer, 1, tmpReg); + } + sqlite3VdbeAddOp3(v, OP_Add, tmpReg, pWin->regApp, tmpReg); + sqlite3VdbeAddOp3(v, OP_Gt, pWin->regApp+1, lbl, tmpReg); + VdbeCoverageNeverNull(v); + sqlite3VdbeAddOp3(v, OP_SeekRowid, csr, 0, tmpReg); + VdbeCoverageNeverTaken(v); + sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol, pWin->regResult); + sqlite3VdbeResolveLabel(v, lbl); + sqlite3ReleaseTempReg(pParse, tmpReg); + } + else if( pFunc->zName==leadName || pFunc->zName==lagName ){ + int nArg = pWin->pOwner->x.pList->nExpr; + int csr = pWin->csrApp; + int lbl = sqlite3VdbeMakeLabel(pParse); + int tmpReg = sqlite3GetTempReg(pParse); + int iEph = pMWin->iEphCsr; + + if( nArg<3 ){ + sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult); + }else{ + sqlite3VdbeAddOp3(v, OP_Column, iEph,pWin->iArgCol+2,pWin->regResult); + } + sqlite3VdbeAddOp2(v, OP_Rowid, iEph, tmpReg); + if( nArg<2 ){ + int val = (pFunc->zName==leadName ? 1 : -1); + sqlite3VdbeAddOp2(v, OP_AddImm, tmpReg, val); + }else{ + int op = (pFunc->zName==leadName ? OP_Add : OP_Subtract); + int tmpReg2 = sqlite3GetTempReg(pParse); + sqlite3VdbeAddOp3(v, OP_Column, iEph, pWin->iArgCol+1, tmpReg2); + sqlite3VdbeAddOp3(v, op, tmpReg2, tmpReg, tmpReg); + sqlite3ReleaseTempReg(pParse, tmpReg2); + } + + sqlite3VdbeAddOp3(v, OP_SeekRowid, csr, lbl, tmpReg); + VdbeCoverage(v); + sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol, pWin->regResult); + sqlite3VdbeResolveLabel(v, lbl); + sqlite3ReleaseTempReg(pParse, tmpReg); + } + } + } + sqlite3VdbeAddOp2(v, OP_Gosub, p->regGosub, p->addrGosub); +} + +/* +** Generate code to set the accumulator register for each window function +** in the linked list passed as the second argument to NULL. And perform +** any equivalent initialization required by any built-in window functions +** in the list. +*/ +static int windowInitAccum(Parse *pParse, Window *pMWin){ + Vdbe *v = sqlite3GetVdbe(pParse); + int regArg; + int nArg = 0; + Window *pWin; + for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ + FuncDef *pFunc = pWin->pWFunc; + assert( pWin->regAccum ); + sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum); + nArg = MAX(nArg, windowArgCount(pWin)); + if( pMWin->regStartRowid==0 ){ + if( pFunc->zName==nth_valueName || pFunc->zName==first_valueName ){ + sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp); + sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1); + } + + if( (pFunc->funcFlags & SQLITE_FUNC_MINMAX) && pWin->csrApp ){ + assert( pWin->eStart!=TK_UNBOUNDED ); + sqlite3VdbeAddOp1(v, OP_ResetSorter, pWin->csrApp); + sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1); + } + } + } + regArg = pParse->nMem+1; + pParse->nMem += nArg; + return regArg; +} + +/* +** Return true if the current frame should be cached in the ephemeral table, +** even if there are no xInverse() calls required. +*/ +static int windowCacheFrame(Window *pMWin){ + Window *pWin; + if( pMWin->regStartRowid ) return 1; + for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ + FuncDef *pFunc = pWin->pWFunc; + if( (pFunc->zName==nth_valueName) + || (pFunc->zName==first_valueName) + || (pFunc->zName==leadName) + || (pFunc->zName==lagName) + ){ + return 1; + } + } + return 0; +} + +/* +** regOld and regNew are each the first register in an array of size +** pOrderBy->nExpr. This function generates code to compare the two +** arrays of registers using the collation sequences and other comparison +** parameters specified by pOrderBy. +** +** If the two arrays are not equal, the contents of regNew is copied to +** regOld and control falls through. Otherwise, if the contents of the arrays +** are equal, an OP_Goto is executed. The address of the OP_Goto is returned. +*/ +static void windowIfNewPeer( + Parse *pParse, + ExprList *pOrderBy, + int regNew, /* First in array of new values */ + int regOld, /* First in array of old values */ + int addr /* Jump here */ +){ + Vdbe *v = sqlite3GetVdbe(pParse); + if( pOrderBy ){ + int nVal = pOrderBy->nExpr; + KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pOrderBy, 0, 0); + sqlite3VdbeAddOp3(v, OP_Compare, regOld, regNew, nVal); + sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO); + sqlite3VdbeAddOp3(v, OP_Jump, + sqlite3VdbeCurrentAddr(v)+1, addr, sqlite3VdbeCurrentAddr(v)+1 + ); + VdbeCoverageEqNe(v); + sqlite3VdbeAddOp3(v, OP_Copy, regNew, regOld, nVal-1); + }else{ + sqlite3VdbeAddOp2(v, OP_Goto, 0, addr); + } +} + +/* +** This function is called as part of generating VM programs for RANGE +** offset PRECEDING/FOLLOWING frame boundaries. Assuming "ASC" order for +** the ORDER BY term in the window, and that argument op is OP_Ge, it generates +** code equivalent to: +** +** if( csr1.peerVal + regVal >= csr2.peerVal ) goto lbl; +** +** The value of parameter op may also be OP_Gt or OP_Le. In these cases the +** operator in the above pseudo-code is replaced with ">" or "<=", respectively. +** +** If the sort-order for the ORDER BY term in the window is DESC, then the +** comparison is reversed. Instead of adding regVal to csr1.peerVal, it is +** subtracted. And the comparison operator is inverted to - ">=" becomes "<=", +** ">" becomes "<", and so on. So, with DESC sort order, if the argument op +** is OP_Ge, the generated code is equivalent to: +** +** if( csr1.peerVal - regVal <= csr2.peerVal ) goto lbl; +** +** A special type of arithmetic is used such that if csr1.peerVal is not +** a numeric type (real or integer), then the result of the addition +** or subtraction is a a copy of csr1.peerVal. +*/ +static void windowCodeRangeTest( + WindowCodeArg *p, + int op, /* OP_Ge, OP_Gt, or OP_Le */ + int csr1, /* Cursor number for cursor 1 */ + int regVal, /* Register containing non-negative number */ + int csr2, /* Cursor number for cursor 2 */ + int lbl /* Jump destination if condition is true */ +){ + Parse *pParse = p->pParse; + Vdbe *v = sqlite3GetVdbe(pParse); + ExprList *pOrderBy = p->pMWin->pOrderBy; /* ORDER BY clause for window */ + int reg1 = sqlite3GetTempReg(pParse); /* Reg. for csr1.peerVal+regVal */ + int reg2 = sqlite3GetTempReg(pParse); /* Reg. for csr2.peerVal */ + int regString = ++pParse->nMem; /* Reg. for constant value '' */ + int arith = OP_Add; /* OP_Add or OP_Subtract */ + int addrGe; /* Jump destination */ + int addrDone = sqlite3VdbeMakeLabel(pParse); /* Address past OP_Ge */ + CollSeq *pColl; + + /* Read the peer-value from each cursor into a register */ + windowReadPeerValues(p, csr1, reg1); + windowReadPeerValues(p, csr2, reg2); + + assert( op==OP_Ge || op==OP_Gt || op==OP_Le ); + assert( pOrderBy && pOrderBy->nExpr==1 ); + if( pOrderBy->a[0].fg.sortFlags & KEYINFO_ORDER_DESC ){ + switch( op ){ + case OP_Ge: op = OP_Le; break; + case OP_Gt: op = OP_Lt; break; + default: assert( op==OP_Le ); op = OP_Ge; break; + } + arith = OP_Subtract; + } + + VdbeModuleComment((v, "CodeRangeTest: if( R%d %s R%d %s R%d ) goto lbl", + reg1, (arith==OP_Add ? "+" : "-"), regVal, + ((op==OP_Ge) ? ">=" : (op==OP_Le) ? "<=" : (op==OP_Gt) ? ">" : "<"), reg2 + )); + + /* If the BIGNULL flag is set for the ORDER BY, then it is required to + ** consider NULL values to be larger than all other values, instead of + ** the usual smaller. The VDBE opcodes OP_Ge and so on do not handle this + ** (and adding that capability causes a performance regression), so + ** instead if the BIGNULL flag is set then cases where either reg1 or + ** reg2 are NULL are handled separately in the following block. The code + ** generated is equivalent to: + ** + ** if( reg1 IS NULL ){ + ** if( op==OP_Ge ) goto lbl; + ** if( op==OP_Gt && reg2 IS NOT NULL ) goto lbl; + ** if( op==OP_Le && reg2 IS NULL ) goto lbl; + ** }else if( reg2 IS NULL ){ + ** if( op==OP_Le ) goto lbl; + ** } + ** + ** Additionally, if either reg1 or reg2 are NULL but the jump to lbl is + ** not taken, control jumps over the comparison operator coded below this + ** block. */ + if( pOrderBy->a[0].fg.sortFlags & KEYINFO_ORDER_BIGNULL ){ + /* This block runs if reg1 contains a NULL. */ + int addr = sqlite3VdbeAddOp1(v, OP_NotNull, reg1); VdbeCoverage(v); + switch( op ){ + case OP_Ge: + sqlite3VdbeAddOp2(v, OP_Goto, 0, lbl); + break; + case OP_Gt: + sqlite3VdbeAddOp2(v, OP_NotNull, reg2, lbl); + VdbeCoverage(v); + break; + case OP_Le: + sqlite3VdbeAddOp2(v, OP_IsNull, reg2, lbl); + VdbeCoverage(v); + break; + default: assert( op==OP_Lt ); /* no-op */ break; + } + sqlite3VdbeAddOp2(v, OP_Goto, 0, addrDone); + + /* This block runs if reg1 is not NULL, but reg2 is. */ + sqlite3VdbeJumpHere(v, addr); + sqlite3VdbeAddOp2(v, OP_IsNull, reg2, + (op==OP_Gt || op==OP_Ge) ? addrDone : lbl); + VdbeCoverage(v); + } + + /* Register reg1 currently contains csr1.peerVal (the peer-value from csr1). + ** This block adds (or subtracts for DESC) the numeric value in regVal + ** from it. Or, if reg1 is not numeric (it is a NULL, a text value or a blob), + ** then leave reg1 as it is. In pseudo-code, this is implemented as: + ** + ** if( reg1>='' ) goto addrGe; + ** reg1 = reg1 +/- regVal + ** addrGe: + ** + ** Since all strings and blobs are greater-than-or-equal-to an empty string, + ** the add/subtract is skipped for these, as required. If reg1 is a NULL, + ** then the arithmetic is performed, but since adding or subtracting from + ** NULL is always NULL anyway, this case is handled as required too. */ + sqlite3VdbeAddOp4(v, OP_String8, 0, regString, 0, "", P4_STATIC); + addrGe = sqlite3VdbeAddOp3(v, OP_Ge, regString, 0, reg1); + VdbeCoverage(v); + if( (op==OP_Ge && arith==OP_Add) || (op==OP_Le && arith==OP_Subtract) ){ + sqlite3VdbeAddOp3(v, op, reg2, lbl, reg1); VdbeCoverage(v); + } + sqlite3VdbeAddOp3(v, arith, regVal, reg1, reg1); + sqlite3VdbeJumpHere(v, addrGe); + + /* Compare registers reg2 and reg1, taking the jump if required. Note that + ** control skips over this test if the BIGNULL flag is set and either + ** reg1 or reg2 contain a NULL value. */ + sqlite3VdbeAddOp3(v, op, reg2, lbl, reg1); VdbeCoverage(v); + pColl = sqlite3ExprNNCollSeq(pParse, pOrderBy->a[0].pExpr); + sqlite3VdbeAppendP4(v, (void*)pColl, P4_COLLSEQ); + sqlite3VdbeChangeP5(v, SQLITE_NULLEQ); + sqlite3VdbeResolveLabel(v, addrDone); + + assert( op==OP_Ge || op==OP_Gt || op==OP_Lt || op==OP_Le ); + testcase(op==OP_Ge); VdbeCoverageIf(v, op==OP_Ge); + testcase(op==OP_Lt); VdbeCoverageIf(v, op==OP_Lt); + testcase(op==OP_Le); VdbeCoverageIf(v, op==OP_Le); + testcase(op==OP_Gt); VdbeCoverageIf(v, op==OP_Gt); + sqlite3ReleaseTempReg(pParse, reg1); + sqlite3ReleaseTempReg(pParse, reg2); + + VdbeModuleComment((v, "CodeRangeTest: end")); +} + +/* +** Helper function for sqlite3WindowCodeStep(). Each call to this function +** generates VM code for a single RETURN_ROW, AGGSTEP or AGGINVERSE +** operation. Refer to the header comment for sqlite3WindowCodeStep() for +** details. +*/ +static int windowCodeOp( + WindowCodeArg *p, /* Context object */ + int op, /* WINDOW_RETURN_ROW, AGGSTEP or AGGINVERSE */ + int regCountdown, /* Register for OP_IfPos countdown */ + int jumpOnEof /* Jump here if stepped cursor reaches EOF */ +){ + int csr, reg; + Parse *pParse = p->pParse; + Window *pMWin = p->pMWin; + int ret = 0; + Vdbe *v = p->pVdbe; + int addrContinue = 0; + int bPeer = (pMWin->eFrmType!=TK_ROWS); + + int lblDone = sqlite3VdbeMakeLabel(pParse); + int addrNextRange = 0; + + /* Special case - WINDOW_AGGINVERSE is always a no-op if the frame + ** starts with UNBOUNDED PRECEDING. */ + if( op==WINDOW_AGGINVERSE && pMWin->eStart==TK_UNBOUNDED ){ + assert( regCountdown==0 && jumpOnEof==0 ); + return 0; + } + + if( regCountdown>0 ){ + if( pMWin->eFrmType==TK_RANGE ){ + addrNextRange = sqlite3VdbeCurrentAddr(v); + assert( op==WINDOW_AGGINVERSE || op==WINDOW_AGGSTEP ); + if( op==WINDOW_AGGINVERSE ){ + if( pMWin->eStart==TK_FOLLOWING ){ + windowCodeRangeTest( + p, OP_Le, p->current.csr, regCountdown, p->start.csr, lblDone + ); + }else{ + windowCodeRangeTest( + p, OP_Ge, p->start.csr, regCountdown, p->current.csr, lblDone + ); + } + }else{ + windowCodeRangeTest( + p, OP_Gt, p->end.csr, regCountdown, p->current.csr, lblDone + ); + } + }else{ + sqlite3VdbeAddOp3(v, OP_IfPos, regCountdown, lblDone, 1); + VdbeCoverage(v); + } + } + + if( op==WINDOW_RETURN_ROW && pMWin->regStartRowid==0 ){ + windowAggFinal(p, 0); + } + addrContinue = sqlite3VdbeCurrentAddr(v); + + /* If this is a (RANGE BETWEEN a FOLLOWING AND b FOLLOWING) or + ** (RANGE BETWEEN b PRECEDING AND a PRECEDING) frame, ensure the + ** start cursor does not advance past the end cursor within the + ** temporary table. It otherwise might, if (a>b). Also ensure that, + ** if the input cursor is still finding new rows, that the end + ** cursor does not go past it to EOF. */ + if( pMWin->eStart==pMWin->eEnd && regCountdown + && pMWin->eFrmType==TK_RANGE + ){ + int regRowid1 = sqlite3GetTempReg(pParse); + int regRowid2 = sqlite3GetTempReg(pParse); + if( op==WINDOW_AGGINVERSE ){ + sqlite3VdbeAddOp2(v, OP_Rowid, p->start.csr, regRowid1); + sqlite3VdbeAddOp2(v, OP_Rowid, p->end.csr, regRowid2); + sqlite3VdbeAddOp3(v, OP_Ge, regRowid2, lblDone, regRowid1); + VdbeCoverage(v); + }else if( p->regRowid ){ + sqlite3VdbeAddOp2(v, OP_Rowid, p->end.csr, regRowid1); + sqlite3VdbeAddOp3(v, OP_Ge, p->regRowid, lblDone, regRowid1); + VdbeCoverageNeverNull(v); + } + sqlite3ReleaseTempReg(pParse, regRowid1); + sqlite3ReleaseTempReg(pParse, regRowid2); + assert( pMWin->eStart==TK_PRECEDING || pMWin->eStart==TK_FOLLOWING ); + } + + switch( op ){ + case WINDOW_RETURN_ROW: + csr = p->current.csr; + reg = p->current.reg; + windowReturnOneRow(p); + break; + + case WINDOW_AGGINVERSE: + csr = p->start.csr; + reg = p->start.reg; + if( pMWin->regStartRowid ){ + assert( pMWin->regEndRowid ); + sqlite3VdbeAddOp2(v, OP_AddImm, pMWin->regStartRowid, 1); + }else{ + windowAggStep(p, pMWin, csr, 1, p->regArg); + } + break; + + default: + assert( op==WINDOW_AGGSTEP ); + csr = p->end.csr; + reg = p->end.reg; + if( pMWin->regStartRowid ){ + assert( pMWin->regEndRowid ); + sqlite3VdbeAddOp2(v, OP_AddImm, pMWin->regEndRowid, 1); + }else{ + windowAggStep(p, pMWin, csr, 0, p->regArg); + } + break; + } + + if( op==p->eDelete ){ + sqlite3VdbeAddOp1(v, OP_Delete, csr); + sqlite3VdbeChangeP5(v, OPFLAG_SAVEPOSITION); + } + + if( jumpOnEof ){ + sqlite3VdbeAddOp2(v, OP_Next, csr, sqlite3VdbeCurrentAddr(v)+2); + VdbeCoverage(v); + ret = sqlite3VdbeAddOp0(v, OP_Goto); + }else{ + sqlite3VdbeAddOp2(v, OP_Next, csr, sqlite3VdbeCurrentAddr(v)+1+bPeer); + VdbeCoverage(v); + if( bPeer ){ + sqlite3VdbeAddOp2(v, OP_Goto, 0, lblDone); + } + } + + if( bPeer ){ + int nReg = (pMWin->pOrderBy ? pMWin->pOrderBy->nExpr : 0); + int regTmp = (nReg ? sqlite3GetTempRange(pParse, nReg) : 0); + windowReadPeerValues(p, csr, regTmp); + windowIfNewPeer(pParse, pMWin->pOrderBy, regTmp, reg, addrContinue); + sqlite3ReleaseTempRange(pParse, regTmp, nReg); + } + + if( addrNextRange ){ + sqlite3VdbeAddOp2(v, OP_Goto, 0, addrNextRange); + } + sqlite3VdbeResolveLabel(v, lblDone); + return ret; +} + + +/* +** Allocate and return a duplicate of the Window object indicated by the +** third argument. Set the Window.pOwner field of the new object to +** pOwner. +*/ +SQLITE_PRIVATE Window *sqlite3WindowDup(sqlite3 *db, Expr *pOwner, Window *p){ + Window *pNew = 0; + if( ALWAYS(p) ){ + pNew = sqlite3DbMallocZero(db, sizeof(Window)); + if( pNew ){ + pNew->zName = sqlite3DbStrDup(db, p->zName); + pNew->zBase = sqlite3DbStrDup(db, p->zBase); + pNew->pFilter = sqlite3ExprDup(db, p->pFilter, 0); + pNew->pWFunc = p->pWFunc; + pNew->pPartition = sqlite3ExprListDup(db, p->pPartition, 0); + pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, 0); + pNew->eFrmType = p->eFrmType; + pNew->eEnd = p->eEnd; + pNew->eStart = p->eStart; + pNew->eExclude = p->eExclude; + pNew->regResult = p->regResult; + pNew->regAccum = p->regAccum; + pNew->iArgCol = p->iArgCol; + pNew->iEphCsr = p->iEphCsr; + pNew->bExprArgs = p->bExprArgs; + pNew->pStart = sqlite3ExprDup(db, p->pStart, 0); + pNew->pEnd = sqlite3ExprDup(db, p->pEnd, 0); + pNew->pOwner = pOwner; + pNew->bImplicitFrame = p->bImplicitFrame; + } + } + return pNew; +} + +/* +** Return a copy of the linked list of Window objects passed as the +** second argument. +*/ +SQLITE_PRIVATE Window *sqlite3WindowListDup(sqlite3 *db, Window *p){ + Window *pWin; + Window *pRet = 0; + Window **pp = &pRet; + + for(pWin=p; pWin; pWin=pWin->pNextWin){ + *pp = sqlite3WindowDup(db, 0, pWin); + if( *pp==0 ) break; + pp = &((*pp)->pNextWin); + } + + return pRet; +} + +/* +** Return true if it can be determined at compile time that expression +** pExpr evaluates to a value that, when cast to an integer, is greater +** than zero. False otherwise. +** +** If an OOM error occurs, this function sets the Parse.db.mallocFailed +** flag and returns zero. +*/ +static int windowExprGtZero(Parse *pParse, Expr *pExpr){ + int ret = 0; + sqlite3 *db = pParse->db; + sqlite3_value *pVal = 0; + sqlite3ValueFromExpr(db, pExpr, db->enc, SQLITE_AFF_NUMERIC, &pVal); + if( pVal && sqlite3_value_int(pVal)>0 ){ + ret = 1; + } + sqlite3ValueFree(pVal); + return ret; +} + +/* +** sqlite3WhereBegin() has already been called for the SELECT statement +** passed as the second argument when this function is invoked. It generates +** code to populate the Window.regResult register for each window function +** and invoke the sub-routine at instruction addrGosub once for each row. +** sqlite3WhereEnd() is always called before returning. +** +** This function handles several different types of window frames, which +** require slightly different processing. The following pseudo code is +** used to implement window frames of the form: +** +** ROWS BETWEEN PRECEDING AND FOLLOWING +** +** Other window frame types use variants of the following: +** +** ... loop started by sqlite3WhereBegin() ... +** if( new partition ){ +** Gosub flush +** } +** Insert new row into eph table. +** +** if( first row of partition ){ +** // Rewind three cursors, all open on the eph table. +** Rewind(csrEnd); +** Rewind(csrStart); +** Rewind(csrCurrent); +** +** regEnd = // FOLLOWING expression +** regStart = // PRECEDING expression +** }else{ +** // First time this branch is taken, the eph table contains two +** // rows. The first row in the partition, which all three cursors +** // currently point to, and the following row. +** AGGSTEP +** if( (regEnd--)<=0 ){ +** RETURN_ROW +** if( (regStart--)<=0 ){ +** AGGINVERSE +** } +** } +** } +** } +** flush: +** AGGSTEP +** while( 1 ){ +** RETURN ROW +** if( csrCurrent is EOF ) break; +** if( (regStart--)<=0 ){ +** AggInverse(csrStart) +** Next(csrStart) +** } +** } +** +** The pseudo-code above uses the following shorthand: +** +** AGGSTEP: invoke the aggregate xStep() function for each window function +** with arguments read from the current row of cursor csrEnd, then +** step cursor csrEnd forward one row (i.e. sqlite3BtreeNext()). +** +** RETURN_ROW: return a row to the caller based on the contents of the +** current row of csrCurrent and the current state of all +** aggregates. Then step cursor csrCurrent forward one row. +** +** AGGINVERSE: invoke the aggregate xInverse() function for each window +** functions with arguments read from the current row of cursor +** csrStart. Then step csrStart forward one row. +** +** There are two other ROWS window frames that are handled significantly +** differently from the above - "BETWEEN PRECEDING AND PRECEDING" +** and "BETWEEN FOLLOWING AND FOLLOWING". These are special +** cases because they change the order in which the three cursors (csrStart, +** csrCurrent and csrEnd) iterate through the ephemeral table. Cases that +** use UNBOUNDED or CURRENT ROW are much simpler variations on one of these +** three. +** +** ROWS BETWEEN PRECEDING AND PRECEDING +** +** ... loop started by sqlite3WhereBegin() ... +** if( new partition ){ +** Gosub flush +** } +** Insert new row into eph table. +** if( first row of partition ){ +** Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) +** regEnd = +** regStart = +** }else{ +** if( (regEnd--)<=0 ){ +** AGGSTEP +** } +** RETURN_ROW +** if( (regStart--)<=0 ){ +** AGGINVERSE +** } +** } +** } +** flush: +** if( (regEnd--)<=0 ){ +** AGGSTEP +** } +** RETURN_ROW +** +** +** ROWS BETWEEN FOLLOWING AND FOLLOWING +** +** ... loop started by sqlite3WhereBegin() ... +** if( new partition ){ +** Gosub flush +** } +** Insert new row into eph table. +** if( first row of partition ){ +** Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) +** regEnd = +** regStart = regEnd - +** }else{ +** AGGSTEP +** if( (regEnd--)<=0 ){ +** RETURN_ROW +** } +** if( (regStart--)<=0 ){ +** AGGINVERSE +** } +** } +** } +** flush: +** AGGSTEP +** while( 1 ){ +** if( (regEnd--)<=0 ){ +** RETURN_ROW +** if( eof ) break; +** } +** if( (regStart--)<=0 ){ +** AGGINVERSE +** if( eof ) break +** } +** } +** while( !eof csrCurrent ){ +** RETURN_ROW +** } +** +** For the most part, the patterns above are adapted to support UNBOUNDED by +** assuming that it is equivalent to "infinity PRECEDING/FOLLOWING" and +** CURRENT ROW by assuming that it is equivilent to "0 PRECEDING/FOLLOWING". +** This is optimized of course - branches that will never be taken and +** conditions that are always true are omitted from the VM code. The only +** exceptional case is: +** +** ROWS BETWEEN FOLLOWING AND UNBOUNDED FOLLOWING +** +** ... loop started by sqlite3WhereBegin() ... +** if( new partition ){ +** Gosub flush +** } +** Insert new row into eph table. +** if( first row of partition ){ +** Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) +** regStart = +** }else{ +** AGGSTEP +** } +** } +** flush: +** AGGSTEP +** while( 1 ){ +** if( (regStart--)<=0 ){ +** AGGINVERSE +** if( eof ) break +** } +** RETURN_ROW +** } +** while( !eof csrCurrent ){ +** RETURN_ROW +** } +** +** Also requiring special handling are the cases: +** +** ROWS BETWEEN PRECEDING AND PRECEDING +** ROWS BETWEEN FOLLOWING AND FOLLOWING +** +** when (expr1 < expr2). This is detected at runtime, not by this function. +** To handle this case, the pseudo-code programs depicted above are modified +** slightly to be: +** +** ... loop started by sqlite3WhereBegin() ... +** if( new partition ){ +** Gosub flush +** } +** Insert new row into eph table. +** if( first row of partition ){ +** Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) +** regEnd = +** regStart = +** if( regEnd < regStart ){ +** RETURN_ROW +** delete eph table contents +** continue +** } +** ... +** +** The new "continue" statement in the above jumps to the next iteration +** of the outer loop - the one started by sqlite3WhereBegin(). +** +** The various GROUPS cases are implemented using the same patterns as +** ROWS. The VM code is modified slightly so that: +** +** 1. The else branch in the main loop is only taken if the row just +** added to the ephemeral table is the start of a new group. In +** other words, it becomes: +** +** ... loop started by sqlite3WhereBegin() ... +** if( new partition ){ +** Gosub flush +** } +** Insert new row into eph table. +** if( first row of partition ){ +** Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) +** regEnd = +** regStart = +** }else if( new group ){ +** ... +** } +** } +** +** 2. Instead of processing a single row, each RETURN_ROW, AGGSTEP or +** AGGINVERSE step processes the current row of the relevant cursor and +** all subsequent rows belonging to the same group. +** +** RANGE window frames are a little different again. As for GROUPS, the +** main loop runs once per group only. And RETURN_ROW, AGGSTEP and AGGINVERSE +** deal in groups instead of rows. As for ROWS and GROUPS, there are three +** basic cases: +** +** RANGE BETWEEN PRECEDING AND FOLLOWING +** +** ... loop started by sqlite3WhereBegin() ... +** if( new partition ){ +** Gosub flush +** } +** Insert new row into eph table. +** if( first row of partition ){ +** Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) +** regEnd = +** regStart = +** }else{ +** AGGSTEP +** while( (csrCurrent.key + regEnd) < csrEnd.key ){ +** RETURN_ROW +** while( csrStart.key + regStart) < csrCurrent.key ){ +** AGGINVERSE +** } +** } +** } +** } +** flush: +** AGGSTEP +** while( 1 ){ +** RETURN ROW +** if( csrCurrent is EOF ) break; +** while( csrStart.key + regStart) < csrCurrent.key ){ +** AGGINVERSE +** } +** } +** } +** +** In the above notation, "csr.key" means the current value of the ORDER BY +** expression (there is only ever 1 for a RANGE that uses an FOLLOWING +** or PRECEDING AND PRECEDING +** +** ... loop started by sqlite3WhereBegin() ... +** if( new partition ){ +** Gosub flush +** } +** Insert new row into eph table. +** if( first row of partition ){ +** Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) +** regEnd = +** regStart = +** }else{ +** while( (csrEnd.key + regEnd) <= csrCurrent.key ){ +** AGGSTEP +** } +** while( (csrStart.key + regStart) < csrCurrent.key ){ +** AGGINVERSE +** } +** RETURN_ROW +** } +** } +** flush: +** while( (csrEnd.key + regEnd) <= csrCurrent.key ){ +** AGGSTEP +** } +** while( (csrStart.key + regStart) < csrCurrent.key ){ +** AGGINVERSE +** } +** RETURN_ROW +** +** RANGE BETWEEN FOLLOWING AND FOLLOWING +** +** ... loop started by sqlite3WhereBegin() ... +** if( new partition ){ +** Gosub flush +** } +** Insert new row into eph table. +** if( first row of partition ){ +** Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) +** regEnd = +** regStart = +** }else{ +** AGGSTEP +** while( (csrCurrent.key + regEnd) < csrEnd.key ){ +** while( (csrCurrent.key + regStart) > csrStart.key ){ +** AGGINVERSE +** } +** RETURN_ROW +** } +** } +** } +** flush: +** AGGSTEP +** while( 1 ){ +** while( (csrCurrent.key + regStart) > csrStart.key ){ +** AGGINVERSE +** if( eof ) break "while( 1 )" loop. +** } +** RETURN_ROW +** } +** while( !eof csrCurrent ){ +** RETURN_ROW +** } +** +** The text above leaves out many details. Refer to the code and comments +** below for a more complete picture. +*/ +SQLITE_PRIVATE void sqlite3WindowCodeStep( + Parse *pParse, /* Parse context */ + Select *p, /* Rewritten SELECT statement */ + WhereInfo *pWInfo, /* Context returned by sqlite3WhereBegin() */ + int regGosub, /* Register for OP_Gosub */ + int addrGosub /* OP_Gosub here to return each row */ +){ + Window *pMWin = p->pWin; + ExprList *pOrderBy = pMWin->pOrderBy; + Vdbe *v = sqlite3GetVdbe(pParse); + int csrWrite; /* Cursor used to write to eph. table */ + int csrInput = p->pSrc->a[0].iCursor; /* Cursor of sub-select */ + int nInput = p->pSrc->a[0].pTab->nCol; /* Number of cols returned by sub */ + int iInput; /* To iterate through sub cols */ + int addrNe; /* Address of OP_Ne */ + int addrGosubFlush = 0; /* Address of OP_Gosub to flush: */ + int addrInteger = 0; /* Address of OP_Integer */ + int addrEmpty; /* Address of OP_Rewind in flush: */ + int regNew; /* Array of registers holding new input row */ + int regRecord; /* regNew array in record form */ + int regNewPeer = 0; /* Peer values for new row (part of regNew) */ + int regPeer = 0; /* Peer values for current row */ + int regFlushPart = 0; /* Register for "Gosub flush_partition" */ + WindowCodeArg s; /* Context object for sub-routines */ + int lblWhereEnd; /* Label just before sqlite3WhereEnd() code */ + int regStart = 0; /* Value of PRECEDING */ + int regEnd = 0; /* Value of FOLLOWING */ + + assert( pMWin->eStart==TK_PRECEDING || pMWin->eStart==TK_CURRENT + || pMWin->eStart==TK_FOLLOWING || pMWin->eStart==TK_UNBOUNDED + ); + assert( pMWin->eEnd==TK_FOLLOWING || pMWin->eEnd==TK_CURRENT + || pMWin->eEnd==TK_UNBOUNDED || pMWin->eEnd==TK_PRECEDING + ); + assert( pMWin->eExclude==0 || pMWin->eExclude==TK_CURRENT + || pMWin->eExclude==TK_GROUP || pMWin->eExclude==TK_TIES + || pMWin->eExclude==TK_NO + ); + + lblWhereEnd = sqlite3VdbeMakeLabel(pParse); + + /* Fill in the context object */ + memset(&s, 0, sizeof(WindowCodeArg)); + s.pParse = pParse; + s.pMWin = pMWin; + s.pVdbe = v; + s.regGosub = regGosub; + s.addrGosub = addrGosub; + s.current.csr = pMWin->iEphCsr; + csrWrite = s.current.csr+1; + s.start.csr = s.current.csr+2; + s.end.csr = s.current.csr+3; + + /* Figure out when rows may be deleted from the ephemeral table. There + ** are four options - they may never be deleted (eDelete==0), they may + ** be deleted as soon as they are no longer part of the window frame + ** (eDelete==WINDOW_AGGINVERSE), they may be deleted as after the row + ** has been returned to the caller (WINDOW_RETURN_ROW), or they may + ** be deleted after they enter the frame (WINDOW_AGGSTEP). */ + switch( pMWin->eStart ){ + case TK_FOLLOWING: + if( pMWin->eFrmType!=TK_RANGE + && windowExprGtZero(pParse, pMWin->pStart) + ){ + s.eDelete = WINDOW_RETURN_ROW; + } + break; + case TK_UNBOUNDED: + if( windowCacheFrame(pMWin)==0 ){ + if( pMWin->eEnd==TK_PRECEDING ){ + if( pMWin->eFrmType!=TK_RANGE + && windowExprGtZero(pParse, pMWin->pEnd) + ){ + s.eDelete = WINDOW_AGGSTEP; + } + }else{ + s.eDelete = WINDOW_RETURN_ROW; + } + } + break; + default: + s.eDelete = WINDOW_AGGINVERSE; + break; + } + + /* Allocate registers for the array of values from the sub-query, the + ** samve values in record form, and the rowid used to insert said record + ** into the ephemeral table. */ + regNew = pParse->nMem+1; + pParse->nMem += nInput; + regRecord = ++pParse->nMem; + s.regRowid = ++pParse->nMem; + + /* If the window frame contains an " PRECEDING" or " FOLLOWING" + ** clause, allocate registers to store the results of evaluating each + ** . */ + if( pMWin->eStart==TK_PRECEDING || pMWin->eStart==TK_FOLLOWING ){ + regStart = ++pParse->nMem; + } + if( pMWin->eEnd==TK_PRECEDING || pMWin->eEnd==TK_FOLLOWING ){ + regEnd = ++pParse->nMem; + } + + /* If this is not a "ROWS BETWEEN ..." frame, then allocate arrays of + ** registers to store copies of the ORDER BY expressions (peer values) + ** for the main loop, and for each cursor (start, current and end). */ + if( pMWin->eFrmType!=TK_ROWS ){ + int nPeer = (pOrderBy ? pOrderBy->nExpr : 0); + regNewPeer = regNew + pMWin->nBufferCol; + if( pMWin->pPartition ) regNewPeer += pMWin->pPartition->nExpr; + regPeer = pParse->nMem+1; pParse->nMem += nPeer; + s.start.reg = pParse->nMem+1; pParse->nMem += nPeer; + s.current.reg = pParse->nMem+1; pParse->nMem += nPeer; + s.end.reg = pParse->nMem+1; pParse->nMem += nPeer; + } + + /* Load the column values for the row returned by the sub-select + ** into an array of registers starting at regNew. Assemble them into + ** a record in register regRecord. */ + for(iInput=0; iInputpPartition ){ + int addr; + ExprList *pPart = pMWin->pPartition; + int nPart = pPart->nExpr; + int regNewPart = regNew + pMWin->nBufferCol; + KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pPart, 0, 0); + + regFlushPart = ++pParse->nMem; + addr = sqlite3VdbeAddOp3(v, OP_Compare, regNewPart, pMWin->regPart, nPart); + sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO); + sqlite3VdbeAddOp3(v, OP_Jump, addr+2, addr+4, addr+2); + VdbeCoverageEqNe(v); + addrGosubFlush = sqlite3VdbeAddOp1(v, OP_Gosub, regFlushPart); + VdbeComment((v, "call flush_partition")); + sqlite3VdbeAddOp3(v, OP_Copy, regNewPart, pMWin->regPart, nPart-1); + } + + /* Insert the new row into the ephemeral table */ + sqlite3VdbeAddOp2(v, OP_NewRowid, csrWrite, s.regRowid); + sqlite3VdbeAddOp3(v, OP_Insert, csrWrite, regRecord, s.regRowid); + addrNe = sqlite3VdbeAddOp3(v, OP_Ne, pMWin->regOne, 0, s.regRowid); + VdbeCoverageNeverNull(v); + + /* This block is run for the first row of each partition */ + s.regArg = windowInitAccum(pParse, pMWin); + + if( regStart ){ + sqlite3ExprCode(pParse, pMWin->pStart, regStart); + windowCheckValue(pParse, regStart, 0 + (pMWin->eFrmType==TK_RANGE?3:0)); + } + if( regEnd ){ + sqlite3ExprCode(pParse, pMWin->pEnd, regEnd); + windowCheckValue(pParse, regEnd, 1 + (pMWin->eFrmType==TK_RANGE?3:0)); + } + + if( pMWin->eFrmType!=TK_RANGE && pMWin->eStart==pMWin->eEnd && regStart ){ + int op = ((pMWin->eStart==TK_FOLLOWING) ? OP_Ge : OP_Le); + int addrGe = sqlite3VdbeAddOp3(v, op, regStart, 0, regEnd); + VdbeCoverageNeverNullIf(v, op==OP_Ge); /* NeverNull because bound */ + VdbeCoverageNeverNullIf(v, op==OP_Le); /* values previously checked */ + windowAggFinal(&s, 0); + sqlite3VdbeAddOp1(v, OP_Rewind, s.current.csr); + windowReturnOneRow(&s); + sqlite3VdbeAddOp1(v, OP_ResetSorter, s.current.csr); + sqlite3VdbeAddOp2(v, OP_Goto, 0, lblWhereEnd); + sqlite3VdbeJumpHere(v, addrGe); + } + if( pMWin->eStart==TK_FOLLOWING && pMWin->eFrmType!=TK_RANGE && regEnd ){ + assert( pMWin->eEnd==TK_FOLLOWING ); + sqlite3VdbeAddOp3(v, OP_Subtract, regStart, regEnd, regStart); + } + + if( pMWin->eStart!=TK_UNBOUNDED ){ + sqlite3VdbeAddOp1(v, OP_Rewind, s.start.csr); + } + sqlite3VdbeAddOp1(v, OP_Rewind, s.current.csr); + sqlite3VdbeAddOp1(v, OP_Rewind, s.end.csr); + if( regPeer && pOrderBy ){ + sqlite3VdbeAddOp3(v, OP_Copy, regNewPeer, regPeer, pOrderBy->nExpr-1); + sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.start.reg, pOrderBy->nExpr-1); + sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.current.reg, pOrderBy->nExpr-1); + sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.end.reg, pOrderBy->nExpr-1); + } + + sqlite3VdbeAddOp2(v, OP_Goto, 0, lblWhereEnd); + + sqlite3VdbeJumpHere(v, addrNe); + + /* Beginning of the block executed for the second and subsequent rows. */ + if( regPeer ){ + windowIfNewPeer(pParse, pOrderBy, regNewPeer, regPeer, lblWhereEnd); + } + if( pMWin->eStart==TK_FOLLOWING ){ + windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0); + if( pMWin->eEnd!=TK_UNBOUNDED ){ + if( pMWin->eFrmType==TK_RANGE ){ + int lbl = sqlite3VdbeMakeLabel(pParse); + int addrNext = sqlite3VdbeCurrentAddr(v); + windowCodeRangeTest(&s, OP_Ge, s.current.csr, regEnd, s.end.csr, lbl); + windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); + windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0); + sqlite3VdbeAddOp2(v, OP_Goto, 0, addrNext); + sqlite3VdbeResolveLabel(v, lbl); + }else{ + windowCodeOp(&s, WINDOW_RETURN_ROW, regEnd, 0); + windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); + } + } + }else + if( pMWin->eEnd==TK_PRECEDING ){ + int bRPS = (pMWin->eStart==TK_PRECEDING && pMWin->eFrmType==TK_RANGE); + windowCodeOp(&s, WINDOW_AGGSTEP, regEnd, 0); + if( bRPS ) windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); + windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0); + if( !bRPS ) windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); + }else{ + int addr = 0; + windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0); + if( pMWin->eEnd!=TK_UNBOUNDED ){ + if( pMWin->eFrmType==TK_RANGE ){ + int lbl = 0; + addr = sqlite3VdbeCurrentAddr(v); + if( regEnd ){ + lbl = sqlite3VdbeMakeLabel(pParse); + windowCodeRangeTest(&s, OP_Ge, s.current.csr, regEnd, s.end.csr, lbl); + } + windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0); + windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); + if( regEnd ){ + sqlite3VdbeAddOp2(v, OP_Goto, 0, addr); + sqlite3VdbeResolveLabel(v, lbl); + } + }else{ + if( regEnd ){ + addr = sqlite3VdbeAddOp3(v, OP_IfPos, regEnd, 0, 1); + VdbeCoverage(v); + } + windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0); + windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); + if( regEnd ) sqlite3VdbeJumpHere(v, addr); + } + } + } + + /* End of the main input loop */ + sqlite3VdbeResolveLabel(v, lblWhereEnd); + sqlite3WhereEnd(pWInfo); + + /* Fall through */ + if( pMWin->pPartition ){ + addrInteger = sqlite3VdbeAddOp2(v, OP_Integer, 0, regFlushPart); + sqlite3VdbeJumpHere(v, addrGosubFlush); + } + + s.regRowid = 0; + addrEmpty = sqlite3VdbeAddOp1(v, OP_Rewind, csrWrite); + VdbeCoverage(v); + if( pMWin->eEnd==TK_PRECEDING ){ + int bRPS = (pMWin->eStart==TK_PRECEDING && pMWin->eFrmType==TK_RANGE); + windowCodeOp(&s, WINDOW_AGGSTEP, regEnd, 0); + if( bRPS ) windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); + windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0); + }else if( pMWin->eStart==TK_FOLLOWING ){ + int addrStart; + int addrBreak1; + int addrBreak2; + int addrBreak3; + windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0); + if( pMWin->eFrmType==TK_RANGE ){ + addrStart = sqlite3VdbeCurrentAddr(v); + addrBreak2 = windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 1); + addrBreak1 = windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 1); + }else + if( pMWin->eEnd==TK_UNBOUNDED ){ + addrStart = sqlite3VdbeCurrentAddr(v); + addrBreak1 = windowCodeOp(&s, WINDOW_RETURN_ROW, regStart, 1); + addrBreak2 = windowCodeOp(&s, WINDOW_AGGINVERSE, 0, 1); + }else{ + assert( pMWin->eEnd==TK_FOLLOWING ); + addrStart = sqlite3VdbeCurrentAddr(v); + addrBreak1 = windowCodeOp(&s, WINDOW_RETURN_ROW, regEnd, 1); + addrBreak2 = windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 1); + } + sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart); + sqlite3VdbeJumpHere(v, addrBreak2); + addrStart = sqlite3VdbeCurrentAddr(v); + addrBreak3 = windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 1); + sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart); + sqlite3VdbeJumpHere(v, addrBreak1); + sqlite3VdbeJumpHere(v, addrBreak3); + }else{ + int addrBreak; + int addrStart; + windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0); + addrStart = sqlite3VdbeCurrentAddr(v); + addrBreak = windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 1); + windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); + sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart); + sqlite3VdbeJumpHere(v, addrBreak); + } + sqlite3VdbeJumpHere(v, addrEmpty); + + sqlite3VdbeAddOp1(v, OP_ResetSorter, s.current.csr); + if( pMWin->pPartition ){ + if( pMWin->regStartRowid ){ + sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regStartRowid); + sqlite3VdbeAddOp2(v, OP_Integer, 0, pMWin->regEndRowid); + } + sqlite3VdbeChangeP1(v, addrInteger, sqlite3VdbeCurrentAddr(v)); + sqlite3VdbeAddOp1(v, OP_Return, regFlushPart); + } +} + +#endif /* SQLITE_OMIT_WINDOWFUNC */ + +/************** End of window.c **********************************************/ +/************** Begin file parse.c *******************************************/ +/* This file is automatically generated by Lemon from input grammar +** source file "parse.y". */ +/* +** 2001-09-15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains SQLite's SQL parser. +** +** The canonical source code to this file ("parse.y") is a Lemon grammar +** file that specifies the input grammar and actions to take while parsing. +** That input file is processed by Lemon to generate a C-language +** implementation of a parser for the given grammer. You might be reading +** this comment as part of the translated C-code. Edits should be made +** to the original parse.y sources. +*/ + +/* #include "sqliteInt.h" */ + +/* +** Disable all error recovery processing in the parser push-down +** automaton. +*/ +#define YYNOERRORRECOVERY 1 + +/* +** Make yytestcase() the same as testcase() +*/ +#define yytestcase(X) testcase(X) + +/* +** Indicate that sqlite3ParserFree() will never be called with a null +** pointer. +*/ +#define YYPARSEFREENEVERNULL 1 + +/* +** In the amalgamation, the parse.c file generated by lemon and the +** tokenize.c file are concatenated. In that case, sqlite3RunParser() +** has access to the the size of the yyParser object and so the parser +** engine can be allocated from stack. In that case, only the +** sqlite3ParserInit() and sqlite3ParserFinalize() routines are invoked +** and the sqlite3ParserAlloc() and sqlite3ParserFree() routines can be +** omitted. +*/ +#ifdef SQLITE_AMALGAMATION +# define sqlite3Parser_ENGINEALWAYSONSTACK 1 +#endif + +/* +** Alternative datatype for the argument to the malloc() routine passed +** into sqlite3ParserAlloc(). The default is size_t. +*/ +#define YYMALLOCARGTYPE u64 + +/* +** An instance of the following structure describes the event of a +** TRIGGER. "a" is the event type, one of TK_UPDATE, TK_INSERT, +** TK_DELETE, or TK_INSTEAD. If the event is of the form +** +** UPDATE ON (a,b,c) +** +** Then the "b" IdList records the list "a,b,c". +*/ +struct TrigEvent { int a; IdList * b; }; + +struct FrameBound { int eType; Expr *pExpr; }; + +/* +** Disable lookaside memory allocation for objects that might be +** shared across database connections. +*/ +static void disableLookaside(Parse *pParse){ + sqlite3 *db = pParse->db; + pParse->disableLookaside++; + DisableLookaside; +} + +#if !defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) \ + && defined(SQLITE_UDL_CAPABLE_PARSER) +/* +** Issue an error message if an ORDER BY or LIMIT clause occurs on an +** UPDATE or DELETE statement. +*/ +static void updateDeleteLimitError( + Parse *pParse, + ExprList *pOrderBy, + Expr *pLimit +){ + if( pOrderBy ){ + sqlite3ErrorMsg(pParse, "syntax error near \"ORDER BY\""); + }else{ + sqlite3ErrorMsg(pParse, "syntax error near \"LIMIT\""); + } + sqlite3ExprListDelete(pParse->db, pOrderBy); + sqlite3ExprDelete(pParse->db, pLimit); +} +#endif /* SQLITE_ENABLE_UPDATE_DELETE_LIMIT */ + + + /* + ** For a compound SELECT statement, make sure p->pPrior->pNext==p for + ** all elements in the list. And make sure list length does not exceed + ** SQLITE_LIMIT_COMPOUND_SELECT. + */ + static void parserDoubleLinkSelect(Parse *pParse, Select *p){ + assert( p!=0 ); + if( p->pPrior ){ + Select *pNext = 0, *pLoop = p; + int mxSelect, cnt = 1; + while(1){ + pLoop->pNext = pNext; + pLoop->selFlags |= SF_Compound; + pNext = pLoop; + pLoop = pLoop->pPrior; + if( pLoop==0 ) break; + cnt++; + if( pLoop->pOrderBy || pLoop->pLimit ){ + sqlite3ErrorMsg(pParse,"%s clause should come after %s not before", + pLoop->pOrderBy!=0 ? "ORDER BY" : "LIMIT", + sqlite3SelectOpName(pNext->op)); + break; + } + } + if( (p->selFlags & SF_MultiValue)==0 && + (mxSelect = pParse->db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT])>0 && + cnt>mxSelect + ){ + sqlite3ErrorMsg(pParse, "too many terms in compound SELECT"); + } + } + } + + /* Attach a With object describing the WITH clause to a Select + ** object describing the query for which the WITH clause is a prefix. + */ + static Select *attachWithToSelect(Parse *pParse, Select *pSelect, With *pWith){ + if( pSelect ){ + pSelect->pWith = pWith; + parserDoubleLinkSelect(pParse, pSelect); + }else{ + sqlite3WithDelete(pParse->db, pWith); + } + return pSelect; + } + + + /* Construct a new Expr object from a single token */ + static Expr *tokenExpr(Parse *pParse, int op, Token t){ + Expr *p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr)+t.n+1); + if( p ){ + /* memset(p, 0, sizeof(Expr)); */ + p->op = (u8)op; + p->affExpr = 0; + p->flags = EP_Leaf; + ExprClearVVAProperties(p); + /* p->iAgg = -1; // Not required */ + p->pLeft = p->pRight = 0; + p->pAggInfo = 0; + memset(&p->x, 0, sizeof(p->x)); + memset(&p->y, 0, sizeof(p->y)); + p->op2 = 0; + p->iTable = 0; + p->iColumn = 0; + p->u.zToken = (char*)&p[1]; + memcpy(p->u.zToken, t.z, t.n); + p->u.zToken[t.n] = 0; + p->w.iOfst = (int)(t.z - pParse->zTail); + if( sqlite3Isquote(p->u.zToken[0]) ){ + sqlite3DequoteExpr(p); + } +#if SQLITE_MAX_EXPR_DEPTH>0 + p->nHeight = 1; +#endif + if( IN_RENAME_OBJECT ){ + return (Expr*)sqlite3RenameTokenMap(pParse, (void*)p, &t); + } + } + return p; + } + + + /* A routine to convert a binary TK_IS or TK_ISNOT expression into a + ** unary TK_ISNULL or TK_NOTNULL expression. */ + static void binaryToUnaryIfNull(Parse *pParse, Expr *pY, Expr *pA, int op){ + sqlite3 *db = pParse->db; + if( pA && pY && pY->op==TK_NULL && !IN_RENAME_OBJECT ){ + pA->op = (u8)op; + sqlite3ExprDelete(db, pA->pRight); + pA->pRight = 0; + } + } + + /* Add a single new term to an ExprList that is used to store a + ** list of identifiers. Report an error if the ID list contains + ** a COLLATE clause or an ASC or DESC keyword, except ignore the + ** error while parsing a legacy schema. + */ + static ExprList *parserAddExprIdListTerm( + Parse *pParse, + ExprList *pPrior, + Token *pIdToken, + int hasCollate, + int sortOrder + ){ + ExprList *p = sqlite3ExprListAppend(pParse, pPrior, 0); + if( (hasCollate || sortOrder!=SQLITE_SO_UNDEFINED) + && pParse->db->init.busy==0 + ){ + sqlite3ErrorMsg(pParse, "syntax error after column name \"%.*s\"", + pIdToken->n, pIdToken->z); + } + sqlite3ExprListSetName(pParse, p, pIdToken, 1); + return p; + } + +#if TK_SPAN>255 +# error too many tokens in the grammar +#endif +/**************** End of %include directives **********************************/ +/* These constants specify the various numeric values for terminal symbols. +***************** Begin token definitions *************************************/ +#ifndef TK_SEMI +#define TK_SEMI 1 +#define TK_EXPLAIN 2 +#define TK_QUERY 3 +#define TK_PLAN 4 +#define TK_BEGIN 5 +#define TK_TRANSACTION 6 +#define TK_DEFERRED 7 +#define TK_IMMEDIATE 8 +#define TK_EXCLUSIVE 9 +#define TK_COMMIT 10 +#define TK_END 11 +#define TK_ROLLBACK 12 +#define TK_SAVEPOINT 13 +#define TK_RELEASE 14 +#define TK_TO 15 +#define TK_TABLE 16 +#define TK_CREATE 17 +#define TK_IF 18 +#define TK_NOT 19 +#define TK_EXISTS 20 +#define TK_TEMP 21 +#define TK_LP 22 +#define TK_RP 23 +#define TK_AS 24 +#define TK_COMMA 25 +#define TK_WITHOUT 26 +#define TK_ABORT 27 +#define TK_ACTION 28 +#define TK_AFTER 29 +#define TK_ANALYZE 30 +#define TK_ASC 31 +#define TK_ATTACH 32 +#define TK_BEFORE 33 +#define TK_BY 34 +#define TK_CASCADE 35 +#define TK_CAST 36 +#define TK_CONFLICT 37 +#define TK_DATABASE 38 +#define TK_DESC 39 +#define TK_DETACH 40 +#define TK_EACH 41 +#define TK_FAIL 42 +#define TK_OR 43 +#define TK_AND 44 +#define TK_IS 45 +#define TK_MATCH 46 +#define TK_LIKE_KW 47 +#define TK_BETWEEN 48 +#define TK_IN 49 +#define TK_ISNULL 50 +#define TK_NOTNULL 51 +#define TK_NE 52 +#define TK_EQ 53 +#define TK_GT 54 +#define TK_LE 55 +#define TK_LT 56 +#define TK_GE 57 +#define TK_ESCAPE 58 +#define TK_ID 59 +#define TK_COLUMNKW 60 +#define TK_DO 61 +#define TK_FOR 62 +#define TK_IGNORE 63 +#define TK_INITIALLY 64 +#define TK_INSTEAD 65 +#define TK_NO 66 +#define TK_KEY 67 +#define TK_OF 68 +#define TK_OFFSET 69 +#define TK_PRAGMA 70 +#define TK_RAISE 71 +#define TK_RECURSIVE 72 +#define TK_REPLACE 73 +#define TK_RESTRICT 74 +#define TK_ROW 75 +#define TK_ROWS 76 +#define TK_TRIGGER 77 +#define TK_VACUUM 78 +#define TK_VIEW 79 +#define TK_VIRTUAL 80 +#define TK_WITH 81 +#define TK_NULLS 82 +#define TK_FIRST 83 +#define TK_LAST 84 +#define TK_CURRENT 85 +#define TK_FOLLOWING 86 +#define TK_PARTITION 87 +#define TK_PRECEDING 88 +#define TK_RANGE 89 +#define TK_UNBOUNDED 90 +#define TK_EXCLUDE 91 +#define TK_GROUPS 92 +#define TK_OTHERS 93 +#define TK_TIES 94 +#define TK_GENERATED 95 +#define TK_ALWAYS 96 +#define TK_MATERIALIZED 97 +#define TK_REINDEX 98 +#define TK_RENAME 99 +#define TK_CTIME_KW 100 +#define TK_ANY 101 +#define TK_BITAND 102 +#define TK_BITOR 103 +#define TK_LSHIFT 104 +#define TK_RSHIFT 105 +#define TK_PLUS 106 +#define TK_MINUS 107 +#define TK_STAR 108 +#define TK_SLASH 109 +#define TK_REM 110 +#define TK_CONCAT 111 +#define TK_PTR 112 +#define TK_COLLATE 113 +#define TK_BITNOT 114 +#define TK_ON 115 +#define TK_INDEXED 116 +#define TK_STRING 117 +#define TK_JOIN_KW 118 +#define TK_CONSTRAINT 119 +#define TK_DEFAULT 120 +#define TK_NULL 121 +#define TK_PRIMARY 122 +#define TK_UNIQUE 123 +#define TK_CHECK 124 +#define TK_REFERENCES 125 +#define TK_AUTOINCR 126 +#define TK_INSERT 127 +#define TK_DELETE 128 +#define TK_UPDATE 129 +#define TK_SET 130 +#define TK_DEFERRABLE 131 +#define TK_FOREIGN 132 +#define TK_DROP 133 +#define TK_UNION 134 +#define TK_ALL 135 +#define TK_EXCEPT 136 +#define TK_INTERSECT 137 +#define TK_SELECT 138 +#define TK_VALUES 139 +#define TK_DISTINCT 140 +#define TK_DOT 141 +#define TK_FROM 142 +#define TK_JOIN 143 +#define TK_USING 144 +#define TK_ORDER 145 +#define TK_GROUP 146 +#define TK_HAVING 147 +#define TK_LIMIT 148 +#define TK_WHERE 149 +#define TK_RETURNING 150 +#define TK_INTO 151 +#define TK_NOTHING 152 +#define TK_FLOAT 153 +#define TK_BLOB 154 +#define TK_INTEGER 155 +#define TK_VARIABLE 156 +#define TK_CASE 157 +#define TK_WHEN 158 +#define TK_THEN 159 +#define TK_ELSE 160 +#define TK_INDEX 161 +#define TK_ALTER 162 +#define TK_ADD 163 +#define TK_WINDOW 164 +#define TK_OVER 165 +#define TK_FILTER 166 +#define TK_COLUMN 167 +#define TK_AGG_FUNCTION 168 +#define TK_AGG_COLUMN 169 +#define TK_TRUEFALSE 170 +#define TK_ISNOT 171 +#define TK_FUNCTION 172 +#define TK_UMINUS 173 +#define TK_UPLUS 174 +#define TK_TRUTH 175 +#define TK_REGISTER 176 +#define TK_VECTOR 177 +#define TK_SELECT_COLUMN 178 +#define TK_IF_NULL_ROW 179 +#define TK_ASTERISK 180 +#define TK_SPAN 181 +#define TK_ERROR 182 +#define TK_SPACE 183 +#define TK_ILLEGAL 184 +#endif +/**************** End token definitions ***************************************/ + +/* The next sections is a series of control #defines. +** various aspects of the generated parser. +** YYCODETYPE is the data type used to store the integer codes +** that represent terminal and non-terminal symbols. +** "unsigned char" is used if there are fewer than +** 256 symbols. Larger types otherwise. +** YYNOCODE is a number of type YYCODETYPE that is not used for +** any terminal or nonterminal symbol. +** YYFALLBACK If defined, this indicates that one or more tokens +** (also known as: "terminal symbols") have fall-back +** values which should be used if the original symbol +** would not parse. This permits keywords to sometimes +** be used as identifiers, for example. +** YYACTIONTYPE is the data type used for "action codes" - numbers +** that indicate what to do in response to the next +** token. +** sqlite3ParserTOKENTYPE is the data type used for minor type for terminal +** symbols. Background: A "minor type" is a semantic +** value associated with a terminal or non-terminal +** symbols. For example, for an "ID" terminal symbol, +** the minor type might be the name of the identifier. +** Each non-terminal can have a different minor type. +** Terminal symbols all have the same minor type, though. +** This macros defines the minor type for terminal +** symbols. +** YYMINORTYPE is the data type used for all minor types. +** This is typically a union of many types, one of +** which is sqlite3ParserTOKENTYPE. The entry in the union +** for terminal symbols is called "yy0". +** YYSTACKDEPTH is the maximum depth of the parser's stack. If +** zero the stack is dynamically sized using realloc() +** sqlite3ParserARG_SDECL A static variable declaration for the %extra_argument +** sqlite3ParserARG_PDECL A parameter declaration for the %extra_argument +** sqlite3ParserARG_PARAM Code to pass %extra_argument as a subroutine parameter +** sqlite3ParserARG_STORE Code to store %extra_argument into yypParser +** sqlite3ParserARG_FETCH Code to extract %extra_argument from yypParser +** sqlite3ParserCTX_* As sqlite3ParserARG_ except for %extra_context +** YYERRORSYMBOL is the code number of the error symbol. If not +** defined, then do no error processing. +** YYNSTATE the combined number of states. +** YYNRULE the number of rules in the grammar +** YYNTOKEN Number of terminal symbols +** YY_MAX_SHIFT Maximum value for shift actions +** YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions +** YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions +** YY_ERROR_ACTION The yy_action[] code for syntax error +** YY_ACCEPT_ACTION The yy_action[] code for accept +** YY_NO_ACTION The yy_action[] code for no-op +** YY_MIN_REDUCE Minimum value for reduce actions +** YY_MAX_REDUCE Maximum value for reduce actions +*/ +#ifndef INTERFACE +# define INTERFACE 1 +#endif +/************* Begin control #defines *****************************************/ +#define YYCODETYPE unsigned short int +#define YYNOCODE 319 +#define YYACTIONTYPE unsigned short int +#define YYWILDCARD 101 +#define sqlite3ParserTOKENTYPE Token +typedef union { + int yyinit; + sqlite3ParserTOKENTYPE yy0; + TriggerStep* yy33; + Window* yy41; + Select* yy47; + SrcList* yy131; + struct TrigEvent yy180; + struct {int value; int mask;} yy231; + IdList* yy254; + u32 yy285; + ExprList* yy322; + Cte* yy385; + int yy394; + Upsert* yy444; + u8 yy516; + With* yy521; + const char* yy522; + Expr* yy528; + OnOrUsing yy561; + struct FrameBound yy595; +} YYMINORTYPE; +#ifndef YYSTACKDEPTH +#define YYSTACKDEPTH 100 +#endif +#define sqlite3ParserARG_SDECL +#define sqlite3ParserARG_PDECL +#define sqlite3ParserARG_PARAM +#define sqlite3ParserARG_FETCH +#define sqlite3ParserARG_STORE +#define sqlite3ParserCTX_SDECL Parse *pParse; +#define sqlite3ParserCTX_PDECL ,Parse *pParse +#define sqlite3ParserCTX_PARAM ,pParse +#define sqlite3ParserCTX_FETCH Parse *pParse=yypParser->pParse; +#define sqlite3ParserCTX_STORE yypParser->pParse=pParse; +#define YYFALLBACK 1 +#define YYNSTATE 575 +#define YYNRULE 403 +#define YYNRULE_WITH_ACTION 340 +#define YYNTOKEN 185 +#define YY_MAX_SHIFT 574 +#define YY_MIN_SHIFTREDUCE 833 +#define YY_MAX_SHIFTREDUCE 1235 +#define YY_ERROR_ACTION 1236 +#define YY_ACCEPT_ACTION 1237 +#define YY_NO_ACTION 1238 +#define YY_MIN_REDUCE 1239 +#define YY_MAX_REDUCE 1641 +/************* End control #defines *******************************************/ +#define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) + +/* Define the yytestcase() macro to be a no-op if is not already defined +** otherwise. +** +** Applications can choose to define yytestcase() in the %include section +** to a macro that can assist in verifying code coverage. For production +** code the yytestcase() macro should be turned off. But it is useful +** for testing. +*/ +#ifndef yytestcase +# define yytestcase(X) +#endif + + +/* Next are the tables used to determine what action to take based on the +** current state and lookahead token. These tables are used to implement +** functions that take a state number and lookahead value and return an +** action integer. +** +** Suppose the action integer is N. Then the action is determined as +** follows +** +** 0 <= N <= YY_MAX_SHIFT Shift N. That is, push the lookahead +** token onto the stack and goto state N. +** +** N between YY_MIN_SHIFTREDUCE Shift to an arbitrary state then +** and YY_MAX_SHIFTREDUCE reduce by rule N-YY_MIN_SHIFTREDUCE. +** +** N == YY_ERROR_ACTION A syntax error has occurred. +** +** N == YY_ACCEPT_ACTION The parser accepts its input. +** +** N == YY_NO_ACTION No such action. Denotes unused +** slots in the yy_action[] table. +** +** N between YY_MIN_REDUCE Reduce by rule N-YY_MIN_REDUCE +** and YY_MAX_REDUCE +** +** The action table is constructed as a single large table named yy_action[]. +** Given state S and lookahead X, the action is computed as either: +** +** (A) N = yy_action[ yy_shift_ofst[S] + X ] +** (B) N = yy_default[S] +** +** The (A) formula is preferred. The B formula is used instead if +** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X. +** +** The formulas above are for computing the action when the lookahead is +** a terminal symbol. If the lookahead is a non-terminal (as occurs after +** a reduce action) then the yy_reduce_ofst[] array is used in place of +** the yy_shift_ofst[] array. +** +** The following are the tables generated in this section: +** +** yy_action[] A single table containing all actions. +** yy_lookahead[] A table containing the lookahead for each entry in +** yy_action. Used to detect hash collisions. +** yy_shift_ofst[] For each state, the offset into yy_action for +** shifting terminals. +** yy_reduce_ofst[] For each state, the offset into yy_action for +** shifting non-terminals after a reduce. +** yy_default[] Default action for each state. +** +*********** Begin parsing tables **********************************************/ +#define YY_ACTTAB_COUNT (2096) +static const YYACTIONTYPE yy_action[] = { + /* 0 */ 568, 208, 568, 118, 115, 229, 568, 118, 115, 229, + /* 10 */ 568, 1310, 377, 1289, 408, 562, 562, 562, 568, 409, + /* 20 */ 378, 1310, 1272, 41, 41, 41, 41, 208, 1520, 71, + /* 30 */ 71, 969, 419, 41, 41, 491, 303, 279, 303, 970, + /* 40 */ 397, 71, 71, 125, 126, 80, 1212, 1212, 1047, 1050, + /* 50 */ 1037, 1037, 123, 123, 124, 124, 124, 124, 476, 409, + /* 60 */ 1237, 1, 1, 574, 2, 1241, 550, 118, 115, 229, + /* 70 */ 317, 480, 146, 480, 524, 118, 115, 229, 529, 1323, + /* 80 */ 417, 523, 142, 125, 126, 80, 1212, 1212, 1047, 1050, + /* 90 */ 1037, 1037, 123, 123, 124, 124, 124, 124, 118, 115, + /* 100 */ 229, 327, 122, 122, 122, 122, 121, 121, 120, 120, + /* 110 */ 120, 119, 116, 444, 284, 284, 284, 284, 442, 442, + /* 120 */ 442, 1561, 376, 1563, 1188, 375, 1159, 565, 1159, 565, + /* 130 */ 409, 1561, 537, 259, 226, 444, 101, 145, 449, 316, + /* 140 */ 559, 240, 122, 122, 122, 122, 121, 121, 120, 120, + /* 150 */ 120, 119, 116, 444, 125, 126, 80, 1212, 1212, 1047, + /* 160 */ 1050, 1037, 1037, 123, 123, 124, 124, 124, 124, 142, + /* 170 */ 294, 1188, 339, 448, 120, 120, 120, 119, 116, 444, + /* 180 */ 127, 1188, 1189, 1188, 148, 441, 440, 568, 119, 116, + /* 190 */ 444, 124, 124, 124, 124, 117, 122, 122, 122, 122, + /* 200 */ 121, 121, 120, 120, 120, 119, 116, 444, 454, 113, + /* 210 */ 13, 13, 546, 122, 122, 122, 122, 121, 121, 120, + /* 220 */ 120, 120, 119, 116, 444, 422, 316, 559, 1188, 1189, + /* 230 */ 1188, 149, 1220, 409, 1220, 124, 124, 124, 124, 122, + /* 240 */ 122, 122, 122, 121, 121, 120, 120, 120, 119, 116, + /* 250 */ 444, 465, 342, 1034, 1034, 1048, 1051, 125, 126, 80, + /* 260 */ 1212, 1212, 1047, 1050, 1037, 1037, 123, 123, 124, 124, + /* 270 */ 124, 124, 1275, 522, 222, 1188, 568, 409, 224, 514, + /* 280 */ 175, 82, 83, 122, 122, 122, 122, 121, 121, 120, + /* 290 */ 120, 120, 119, 116, 444, 1005, 16, 16, 1188, 133, + /* 300 */ 133, 125, 126, 80, 1212, 1212, 1047, 1050, 1037, 1037, + /* 310 */ 123, 123, 124, 124, 124, 124, 122, 122, 122, 122, + /* 320 */ 121, 121, 120, 120, 120, 119, 116, 444, 1038, 546, + /* 330 */ 1188, 373, 1188, 1189, 1188, 252, 1429, 399, 504, 501, + /* 340 */ 500, 111, 560, 566, 4, 924, 924, 433, 499, 340, + /* 350 */ 460, 328, 360, 394, 1233, 1188, 1189, 1188, 563, 568, + /* 360 */ 122, 122, 122, 122, 121, 121, 120, 120, 120, 119, + /* 370 */ 116, 444, 284, 284, 369, 1574, 1600, 441, 440, 154, + /* 380 */ 409, 445, 71, 71, 1282, 565, 1217, 1188, 1189, 1188, + /* 390 */ 85, 1219, 271, 557, 543, 515, 1555, 568, 98, 1218, + /* 400 */ 6, 1274, 472, 142, 125, 126, 80, 1212, 1212, 1047, + /* 410 */ 1050, 1037, 1037, 123, 123, 124, 124, 124, 124, 550, + /* 420 */ 13, 13, 1024, 507, 1220, 1188, 1220, 549, 109, 109, + /* 430 */ 222, 568, 1234, 175, 568, 427, 110, 197, 445, 569, + /* 440 */ 445, 430, 1546, 1014, 325, 551, 1188, 270, 287, 368, + /* 450 */ 510, 363, 509, 257, 71, 71, 543, 71, 71, 359, + /* 460 */ 316, 559, 1606, 122, 122, 122, 122, 121, 121, 120, + /* 470 */ 120, 120, 119, 116, 444, 1014, 1014, 1016, 1017, 27, + /* 480 */ 284, 284, 1188, 1189, 1188, 1154, 568, 1605, 409, 899, + /* 490 */ 190, 550, 356, 565, 550, 935, 533, 517, 1154, 516, + /* 500 */ 413, 1154, 552, 1188, 1189, 1188, 568, 544, 1548, 51, + /* 510 */ 51, 214, 125, 126, 80, 1212, 1212, 1047, 1050, 1037, + /* 520 */ 1037, 123, 123, 124, 124, 124, 124, 1188, 474, 135, + /* 530 */ 135, 409, 284, 284, 1484, 505, 121, 121, 120, 120, + /* 540 */ 120, 119, 116, 444, 1005, 565, 518, 217, 541, 1555, + /* 550 */ 316, 559, 142, 6, 532, 125, 126, 80, 1212, 1212, + /* 560 */ 1047, 1050, 1037, 1037, 123, 123, 124, 124, 124, 124, + /* 570 */ 1549, 122, 122, 122, 122, 121, 121, 120, 120, 120, + /* 580 */ 119, 116, 444, 485, 1188, 1189, 1188, 482, 281, 1263, + /* 590 */ 955, 252, 1188, 373, 504, 501, 500, 1188, 340, 570, + /* 600 */ 1188, 570, 409, 292, 499, 955, 874, 191, 480, 316, + /* 610 */ 559, 384, 290, 380, 122, 122, 122, 122, 121, 121, + /* 620 */ 120, 120, 120, 119, 116, 444, 125, 126, 80, 1212, + /* 630 */ 1212, 1047, 1050, 1037, 1037, 123, 123, 124, 124, 124, + /* 640 */ 124, 409, 394, 1132, 1188, 867, 100, 284, 284, 1188, + /* 650 */ 1189, 1188, 373, 1089, 1188, 1189, 1188, 1188, 1189, 1188, + /* 660 */ 565, 455, 32, 373, 233, 125, 126, 80, 1212, 1212, + /* 670 */ 1047, 1050, 1037, 1037, 123, 123, 124, 124, 124, 124, + /* 680 */ 1428, 957, 568, 228, 956, 122, 122, 122, 122, 121, + /* 690 */ 121, 120, 120, 120, 119, 116, 444, 1154, 228, 1188, + /* 700 */ 157, 1188, 1189, 1188, 1547, 13, 13, 301, 955, 1228, + /* 710 */ 1154, 153, 409, 1154, 373, 1577, 1172, 5, 369, 1574, + /* 720 */ 429, 1234, 3, 955, 122, 122, 122, 122, 121, 121, + /* 730 */ 120, 120, 120, 119, 116, 444, 125, 126, 80, 1212, + /* 740 */ 1212, 1047, 1050, 1037, 1037, 123, 123, 124, 124, 124, + /* 750 */ 124, 409, 208, 567, 1188, 1025, 1188, 1189, 1188, 1188, + /* 760 */ 388, 850, 155, 1546, 286, 402, 1094, 1094, 488, 568, + /* 770 */ 465, 342, 1315, 1315, 1546, 125, 126, 80, 1212, 1212, + /* 780 */ 1047, 1050, 1037, 1037, 123, 123, 124, 124, 124, 124, + /* 790 */ 129, 568, 13, 13, 374, 122, 122, 122, 122, 121, + /* 800 */ 121, 120, 120, 120, 119, 116, 444, 302, 568, 453, + /* 810 */ 528, 1188, 1189, 1188, 13, 13, 1188, 1189, 1188, 1293, + /* 820 */ 463, 1263, 409, 1313, 1313, 1546, 1010, 453, 452, 200, + /* 830 */ 299, 71, 71, 1261, 122, 122, 122, 122, 121, 121, + /* 840 */ 120, 120, 120, 119, 116, 444, 125, 126, 80, 1212, + /* 850 */ 1212, 1047, 1050, 1037, 1037, 123, 123, 124, 124, 124, + /* 860 */ 124, 409, 227, 1069, 1154, 284, 284, 419, 312, 278, + /* 870 */ 278, 285, 285, 1415, 406, 405, 382, 1154, 565, 568, + /* 880 */ 1154, 1191, 565, 1594, 565, 125, 126, 80, 1212, 1212, + /* 890 */ 1047, 1050, 1037, 1037, 123, 123, 124, 124, 124, 124, + /* 900 */ 453, 1476, 13, 13, 1530, 122, 122, 122, 122, 121, + /* 910 */ 121, 120, 120, 120, 119, 116, 444, 201, 568, 354, + /* 920 */ 1580, 574, 2, 1241, 838, 839, 840, 1556, 317, 1207, + /* 930 */ 146, 6, 409, 255, 254, 253, 206, 1323, 9, 1191, + /* 940 */ 262, 71, 71, 424, 122, 122, 122, 122, 121, 121, + /* 950 */ 120, 120, 120, 119, 116, 444, 125, 126, 80, 1212, + /* 960 */ 1212, 1047, 1050, 1037, 1037, 123, 123, 124, 124, 124, + /* 970 */ 124, 568, 284, 284, 568, 1208, 409, 573, 313, 1241, + /* 980 */ 349, 1292, 352, 419, 317, 565, 146, 491, 525, 1637, + /* 990 */ 395, 371, 491, 1323, 70, 70, 1291, 71, 71, 240, + /* 1000 */ 1321, 104, 80, 1212, 1212, 1047, 1050, 1037, 1037, 123, + /* 1010 */ 123, 124, 124, 124, 124, 122, 122, 122, 122, 121, + /* 1020 */ 121, 120, 120, 120, 119, 116, 444, 1110, 284, 284, + /* 1030 */ 428, 448, 1519, 1208, 439, 284, 284, 1483, 1348, 311, + /* 1040 */ 474, 565, 1111, 969, 491, 491, 217, 1259, 565, 1532, + /* 1050 */ 568, 970, 207, 568, 1024, 240, 383, 1112, 519, 122, + /* 1060 */ 122, 122, 122, 121, 121, 120, 120, 120, 119, 116, + /* 1070 */ 444, 1015, 107, 71, 71, 1014, 13, 13, 910, 568, + /* 1080 */ 1489, 568, 284, 284, 97, 526, 491, 448, 911, 1322, + /* 1090 */ 1318, 545, 409, 284, 284, 565, 151, 209, 1489, 1491, + /* 1100 */ 262, 450, 55, 55, 56, 56, 565, 1014, 1014, 1016, + /* 1110 */ 443, 332, 409, 527, 12, 295, 125, 126, 80, 1212, + /* 1120 */ 1212, 1047, 1050, 1037, 1037, 123, 123, 124, 124, 124, + /* 1130 */ 124, 347, 409, 862, 1528, 1208, 125, 126, 80, 1212, + /* 1140 */ 1212, 1047, 1050, 1037, 1037, 123, 123, 124, 124, 124, + /* 1150 */ 124, 1133, 1635, 474, 1635, 371, 125, 114, 80, 1212, + /* 1160 */ 1212, 1047, 1050, 1037, 1037, 123, 123, 124, 124, 124, + /* 1170 */ 124, 1489, 329, 474, 331, 122, 122, 122, 122, 121, + /* 1180 */ 121, 120, 120, 120, 119, 116, 444, 203, 1415, 568, + /* 1190 */ 1290, 862, 464, 1208, 436, 122, 122, 122, 122, 121, + /* 1200 */ 121, 120, 120, 120, 119, 116, 444, 553, 1133, 1636, + /* 1210 */ 539, 1636, 15, 15, 890, 122, 122, 122, 122, 121, + /* 1220 */ 121, 120, 120, 120, 119, 116, 444, 568, 298, 538, + /* 1230 */ 1131, 1415, 1553, 1554, 1327, 409, 6, 6, 1165, 1264, + /* 1240 */ 415, 320, 284, 284, 1415, 508, 565, 525, 300, 457, + /* 1250 */ 43, 43, 568, 891, 12, 565, 330, 478, 425, 407, + /* 1260 */ 126, 80, 1212, 1212, 1047, 1050, 1037, 1037, 123, 123, + /* 1270 */ 124, 124, 124, 124, 568, 57, 57, 288, 1188, 1415, + /* 1280 */ 496, 458, 392, 392, 391, 273, 389, 1131, 1552, 847, + /* 1290 */ 1165, 407, 6, 568, 321, 1154, 470, 44, 44, 1551, + /* 1300 */ 1110, 426, 234, 6, 323, 256, 540, 256, 1154, 431, + /* 1310 */ 568, 1154, 322, 17, 487, 1111, 58, 58, 122, 122, + /* 1320 */ 122, 122, 121, 121, 120, 120, 120, 119, 116, 444, + /* 1330 */ 1112, 216, 481, 59, 59, 1188, 1189, 1188, 111, 560, + /* 1340 */ 324, 4, 236, 456, 526, 568, 237, 456, 568, 437, + /* 1350 */ 168, 556, 420, 141, 479, 563, 568, 293, 568, 1091, + /* 1360 */ 568, 293, 568, 1091, 531, 568, 870, 8, 60, 60, + /* 1370 */ 235, 61, 61, 568, 414, 568, 414, 568, 445, 62, + /* 1380 */ 62, 45, 45, 46, 46, 47, 47, 199, 49, 49, + /* 1390 */ 557, 568, 359, 568, 100, 486, 50, 50, 63, 63, + /* 1400 */ 64, 64, 561, 415, 535, 410, 568, 1024, 568, 534, + /* 1410 */ 316, 559, 316, 559, 65, 65, 14, 14, 568, 1024, + /* 1420 */ 568, 512, 930, 870, 1015, 109, 109, 929, 1014, 66, + /* 1430 */ 66, 131, 131, 110, 451, 445, 569, 445, 416, 177, + /* 1440 */ 1014, 132, 132, 67, 67, 568, 467, 568, 930, 471, + /* 1450 */ 1360, 283, 226, 929, 315, 1359, 407, 568, 459, 407, + /* 1460 */ 1014, 1014, 1016, 239, 407, 86, 213, 1346, 52, 52, + /* 1470 */ 68, 68, 1014, 1014, 1016, 1017, 27, 1579, 1176, 447, + /* 1480 */ 69, 69, 288, 97, 108, 1535, 106, 392, 392, 391, + /* 1490 */ 273, 389, 568, 877, 847, 881, 568, 111, 560, 466, + /* 1500 */ 4, 568, 152, 30, 38, 568, 1128, 234, 396, 323, + /* 1510 */ 111, 560, 527, 4, 563, 53, 53, 322, 568, 163, + /* 1520 */ 163, 568, 337, 468, 164, 164, 333, 563, 76, 76, + /* 1530 */ 568, 289, 1508, 568, 31, 1507, 568, 445, 338, 483, + /* 1540 */ 100, 54, 54, 344, 72, 72, 296, 236, 1076, 557, + /* 1550 */ 445, 877, 1356, 134, 134, 168, 73, 73, 141, 161, + /* 1560 */ 161, 1568, 557, 535, 568, 319, 568, 348, 536, 1007, + /* 1570 */ 473, 261, 261, 889, 888, 235, 535, 568, 1024, 568, + /* 1580 */ 475, 534, 261, 367, 109, 109, 521, 136, 136, 130, + /* 1590 */ 130, 1024, 110, 366, 445, 569, 445, 109, 109, 1014, + /* 1600 */ 162, 162, 156, 156, 568, 110, 1076, 445, 569, 445, + /* 1610 */ 410, 351, 1014, 568, 353, 316, 559, 568, 343, 568, + /* 1620 */ 100, 497, 357, 258, 100, 896, 897, 140, 140, 355, + /* 1630 */ 1306, 1014, 1014, 1016, 1017, 27, 139, 139, 362, 451, + /* 1640 */ 137, 137, 138, 138, 1014, 1014, 1016, 1017, 27, 1176, + /* 1650 */ 447, 568, 372, 288, 111, 560, 1018, 4, 392, 392, + /* 1660 */ 391, 273, 389, 568, 1137, 847, 568, 1072, 568, 258, + /* 1670 */ 492, 563, 568, 211, 75, 75, 555, 960, 234, 261, + /* 1680 */ 323, 111, 560, 927, 4, 113, 77, 77, 322, 74, + /* 1690 */ 74, 42, 42, 1369, 445, 48, 48, 1414, 563, 972, + /* 1700 */ 973, 1088, 1087, 1088, 1087, 860, 557, 150, 928, 1342, + /* 1710 */ 113, 1354, 554, 1419, 1018, 1271, 1262, 1250, 236, 1249, + /* 1720 */ 1251, 445, 1587, 1339, 308, 276, 168, 309, 11, 141, + /* 1730 */ 393, 310, 232, 557, 1401, 1024, 335, 291, 1396, 219, + /* 1740 */ 336, 109, 109, 934, 297, 1406, 235, 341, 477, 110, + /* 1750 */ 502, 445, 569, 445, 1389, 1405, 1014, 400, 1289, 365, + /* 1760 */ 223, 1480, 1024, 1479, 1351, 1352, 1350, 1349, 109, 109, + /* 1770 */ 204, 1590, 1228, 558, 265, 218, 110, 205, 445, 569, + /* 1780 */ 445, 410, 387, 1014, 1527, 179, 316, 559, 1014, 1014, + /* 1790 */ 1016, 1017, 27, 230, 1525, 1225, 79, 560, 85, 4, + /* 1800 */ 418, 215, 548, 81, 84, 188, 1402, 173, 181, 461, + /* 1810 */ 451, 35, 462, 563, 183, 1014, 1014, 1016, 1017, 27, + /* 1820 */ 184, 1485, 185, 186, 495, 242, 98, 398, 1408, 36, + /* 1830 */ 1407, 484, 91, 469, 401, 1410, 445, 192, 1474, 246, + /* 1840 */ 1496, 490, 346, 277, 248, 196, 493, 511, 557, 350, + /* 1850 */ 1252, 249, 250, 403, 1309, 1308, 111, 560, 432, 4, + /* 1860 */ 1307, 1300, 93, 1604, 881, 1603, 224, 404, 434, 520, + /* 1870 */ 263, 435, 1573, 563, 1279, 1278, 364, 1024, 306, 1277, + /* 1880 */ 264, 1602, 1559, 109, 109, 370, 1299, 307, 1558, 438, + /* 1890 */ 128, 110, 1374, 445, 569, 445, 445, 546, 1014, 10, + /* 1900 */ 1461, 105, 381, 1373, 34, 571, 99, 1332, 557, 314, + /* 1910 */ 1182, 530, 272, 274, 379, 210, 1331, 547, 385, 386, + /* 1920 */ 275, 572, 1247, 1242, 411, 412, 1512, 165, 178, 1513, + /* 1930 */ 1014, 1014, 1016, 1017, 27, 1511, 1510, 1024, 78, 147, + /* 1940 */ 166, 220, 221, 109, 109, 834, 304, 167, 446, 212, + /* 1950 */ 318, 110, 231, 445, 569, 445, 144, 1086, 1014, 1084, + /* 1960 */ 326, 180, 169, 1207, 182, 334, 238, 913, 241, 1100, + /* 1970 */ 187, 170, 171, 421, 87, 88, 423, 189, 89, 90, + /* 1980 */ 172, 1103, 243, 1099, 244, 158, 18, 245, 345, 247, + /* 1990 */ 1014, 1014, 1016, 1017, 27, 261, 1092, 193, 1222, 489, + /* 2000 */ 194, 37, 366, 849, 494, 251, 195, 506, 92, 19, + /* 2010 */ 498, 358, 20, 503, 879, 361, 94, 892, 305, 159, + /* 2020 */ 513, 39, 95, 1170, 160, 1053, 964, 1139, 96, 174, + /* 2030 */ 1138, 225, 280, 282, 198, 958, 113, 1160, 1156, 260, + /* 2040 */ 21, 22, 23, 1158, 1164, 1163, 1144, 24, 33, 25, + /* 2050 */ 202, 542, 26, 100, 1067, 102, 1054, 103, 7, 1052, + /* 2060 */ 1056, 1109, 1057, 1108, 266, 267, 28, 40, 390, 1019, + /* 2070 */ 861, 112, 29, 564, 1178, 1177, 268, 176, 143, 923, + /* 2080 */ 1238, 1238, 1238, 1238, 1238, 1238, 1238, 1238, 1238, 1238, + /* 2090 */ 1238, 1238, 1238, 1238, 269, 1595, +}; +static const YYCODETYPE yy_lookahead[] = { + /* 0 */ 193, 193, 193, 274, 275, 276, 193, 274, 275, 276, + /* 10 */ 193, 223, 219, 225, 206, 210, 211, 212, 193, 19, + /* 20 */ 219, 233, 216, 216, 217, 216, 217, 193, 295, 216, + /* 30 */ 217, 31, 193, 216, 217, 193, 228, 213, 230, 39, + /* 40 */ 206, 216, 217, 43, 44, 45, 46, 47, 48, 49, + /* 50 */ 50, 51, 52, 53, 54, 55, 56, 57, 193, 19, + /* 60 */ 185, 186, 187, 188, 189, 190, 253, 274, 275, 276, + /* 70 */ 195, 193, 197, 193, 261, 274, 275, 276, 253, 204, + /* 80 */ 238, 204, 81, 43, 44, 45, 46, 47, 48, 49, + /* 90 */ 50, 51, 52, 53, 54, 55, 56, 57, 274, 275, + /* 100 */ 276, 262, 102, 103, 104, 105, 106, 107, 108, 109, + /* 110 */ 110, 111, 112, 113, 239, 240, 239, 240, 210, 211, + /* 120 */ 212, 314, 315, 314, 59, 316, 86, 252, 88, 252, + /* 130 */ 19, 314, 315, 256, 257, 113, 25, 72, 296, 138, + /* 140 */ 139, 266, 102, 103, 104, 105, 106, 107, 108, 109, + /* 150 */ 110, 111, 112, 113, 43, 44, 45, 46, 47, 48, + /* 160 */ 49, 50, 51, 52, 53, 54, 55, 56, 57, 81, + /* 170 */ 292, 59, 292, 298, 108, 109, 110, 111, 112, 113, + /* 180 */ 69, 116, 117, 118, 72, 106, 107, 193, 111, 112, + /* 190 */ 113, 54, 55, 56, 57, 58, 102, 103, 104, 105, + /* 200 */ 106, 107, 108, 109, 110, 111, 112, 113, 120, 25, + /* 210 */ 216, 217, 145, 102, 103, 104, 105, 106, 107, 108, + /* 220 */ 109, 110, 111, 112, 113, 231, 138, 139, 116, 117, + /* 230 */ 118, 164, 153, 19, 155, 54, 55, 56, 57, 102, + /* 240 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + /* 250 */ 113, 128, 129, 46, 47, 48, 49, 43, 44, 45, + /* 260 */ 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + /* 270 */ 56, 57, 216, 193, 25, 59, 193, 19, 165, 166, + /* 280 */ 193, 67, 24, 102, 103, 104, 105, 106, 107, 108, + /* 290 */ 109, 110, 111, 112, 113, 73, 216, 217, 59, 216, + /* 300 */ 217, 43, 44, 45, 46, 47, 48, 49, 50, 51, + /* 310 */ 52, 53, 54, 55, 56, 57, 102, 103, 104, 105, + /* 320 */ 106, 107, 108, 109, 110, 111, 112, 113, 121, 145, + /* 330 */ 59, 193, 116, 117, 118, 119, 273, 204, 122, 123, + /* 340 */ 124, 19, 20, 134, 22, 136, 137, 19, 132, 127, + /* 350 */ 128, 129, 24, 22, 23, 116, 117, 118, 36, 193, + /* 360 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + /* 370 */ 112, 113, 239, 240, 311, 312, 215, 106, 107, 241, + /* 380 */ 19, 59, 216, 217, 223, 252, 115, 116, 117, 118, + /* 390 */ 151, 120, 26, 71, 193, 308, 309, 193, 149, 128, + /* 400 */ 313, 216, 269, 81, 43, 44, 45, 46, 47, 48, + /* 410 */ 49, 50, 51, 52, 53, 54, 55, 56, 57, 253, + /* 420 */ 216, 217, 100, 95, 153, 59, 155, 261, 106, 107, + /* 430 */ 25, 193, 101, 193, 193, 231, 114, 25, 116, 117, + /* 440 */ 118, 113, 304, 121, 193, 204, 59, 119, 120, 121, + /* 450 */ 122, 123, 124, 125, 216, 217, 193, 216, 217, 131, + /* 460 */ 138, 139, 230, 102, 103, 104, 105, 106, 107, 108, + /* 470 */ 109, 110, 111, 112, 113, 153, 154, 155, 156, 157, + /* 480 */ 239, 240, 116, 117, 118, 76, 193, 23, 19, 25, + /* 490 */ 22, 253, 23, 252, 253, 108, 87, 204, 89, 261, + /* 500 */ 198, 92, 261, 116, 117, 118, 193, 306, 307, 216, + /* 510 */ 217, 150, 43, 44, 45, 46, 47, 48, 49, 50, + /* 520 */ 51, 52, 53, 54, 55, 56, 57, 59, 193, 216, + /* 530 */ 217, 19, 239, 240, 283, 23, 106, 107, 108, 109, + /* 540 */ 110, 111, 112, 113, 73, 252, 253, 142, 308, 309, + /* 550 */ 138, 139, 81, 313, 145, 43, 44, 45, 46, 47, + /* 560 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + /* 570 */ 307, 102, 103, 104, 105, 106, 107, 108, 109, 110, + /* 580 */ 111, 112, 113, 281, 116, 117, 118, 285, 23, 193, + /* 590 */ 25, 119, 59, 193, 122, 123, 124, 59, 127, 203, + /* 600 */ 59, 205, 19, 268, 132, 25, 23, 22, 193, 138, + /* 610 */ 139, 249, 204, 251, 102, 103, 104, 105, 106, 107, + /* 620 */ 108, 109, 110, 111, 112, 113, 43, 44, 45, 46, + /* 630 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + /* 640 */ 57, 19, 22, 23, 59, 23, 25, 239, 240, 116, + /* 650 */ 117, 118, 193, 11, 116, 117, 118, 116, 117, 118, + /* 660 */ 252, 269, 22, 193, 15, 43, 44, 45, 46, 47, + /* 670 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + /* 680 */ 273, 143, 193, 118, 143, 102, 103, 104, 105, 106, + /* 690 */ 107, 108, 109, 110, 111, 112, 113, 76, 118, 59, + /* 700 */ 241, 116, 117, 118, 304, 216, 217, 292, 143, 60, + /* 710 */ 89, 241, 19, 92, 193, 193, 23, 22, 311, 312, + /* 720 */ 231, 101, 22, 143, 102, 103, 104, 105, 106, 107, + /* 730 */ 108, 109, 110, 111, 112, 113, 43, 44, 45, 46, + /* 740 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + /* 750 */ 57, 19, 193, 193, 59, 23, 116, 117, 118, 59, + /* 760 */ 201, 21, 241, 304, 22, 206, 127, 128, 129, 193, + /* 770 */ 128, 129, 235, 236, 304, 43, 44, 45, 46, 47, + /* 780 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + /* 790 */ 22, 193, 216, 217, 193, 102, 103, 104, 105, 106, + /* 800 */ 107, 108, 109, 110, 111, 112, 113, 231, 193, 193, + /* 810 */ 193, 116, 117, 118, 216, 217, 116, 117, 118, 226, + /* 820 */ 80, 193, 19, 235, 236, 304, 23, 211, 212, 231, + /* 830 */ 204, 216, 217, 205, 102, 103, 104, 105, 106, 107, + /* 840 */ 108, 109, 110, 111, 112, 113, 43, 44, 45, 46, + /* 850 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + /* 860 */ 57, 19, 193, 123, 76, 239, 240, 193, 253, 239, + /* 870 */ 240, 239, 240, 193, 106, 107, 193, 89, 252, 193, + /* 880 */ 92, 59, 252, 141, 252, 43, 44, 45, 46, 47, + /* 890 */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + /* 900 */ 284, 161, 216, 217, 193, 102, 103, 104, 105, 106, + /* 910 */ 107, 108, 109, 110, 111, 112, 113, 231, 193, 16, + /* 920 */ 187, 188, 189, 190, 7, 8, 9, 309, 195, 25, + /* 930 */ 197, 313, 19, 127, 128, 129, 262, 204, 22, 117, + /* 940 */ 24, 216, 217, 263, 102, 103, 104, 105, 106, 107, + /* 950 */ 108, 109, 110, 111, 112, 113, 43, 44, 45, 46, + /* 960 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + /* 970 */ 57, 193, 239, 240, 193, 59, 19, 188, 253, 190, + /* 980 */ 77, 226, 79, 193, 195, 252, 197, 193, 19, 301, + /* 990 */ 302, 193, 193, 204, 216, 217, 226, 216, 217, 266, + /* 1000 */ 204, 159, 45, 46, 47, 48, 49, 50, 51, 52, + /* 1010 */ 53, 54, 55, 56, 57, 102, 103, 104, 105, 106, + /* 1020 */ 107, 108, 109, 110, 111, 112, 113, 12, 239, 240, + /* 1030 */ 232, 298, 238, 117, 253, 239, 240, 238, 259, 260, + /* 1040 */ 193, 252, 27, 31, 193, 193, 142, 204, 252, 193, + /* 1050 */ 193, 39, 262, 193, 100, 266, 278, 42, 204, 102, + /* 1060 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + /* 1070 */ 113, 117, 159, 216, 217, 121, 216, 217, 63, 193, + /* 1080 */ 193, 193, 239, 240, 115, 116, 193, 298, 73, 238, + /* 1090 */ 238, 231, 19, 239, 240, 252, 22, 24, 211, 212, + /* 1100 */ 24, 193, 216, 217, 216, 217, 252, 153, 154, 155, + /* 1110 */ 253, 16, 19, 144, 213, 268, 43, 44, 45, 46, + /* 1120 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + /* 1130 */ 57, 238, 19, 59, 193, 59, 43, 44, 45, 46, + /* 1140 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + /* 1150 */ 57, 22, 23, 193, 25, 193, 43, 44, 45, 46, + /* 1160 */ 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + /* 1170 */ 57, 284, 77, 193, 79, 102, 103, 104, 105, 106, + /* 1180 */ 107, 108, 109, 110, 111, 112, 113, 286, 193, 193, + /* 1190 */ 193, 117, 291, 117, 232, 102, 103, 104, 105, 106, + /* 1200 */ 107, 108, 109, 110, 111, 112, 113, 204, 22, 23, + /* 1210 */ 66, 25, 216, 217, 35, 102, 103, 104, 105, 106, + /* 1220 */ 107, 108, 109, 110, 111, 112, 113, 193, 268, 85, + /* 1230 */ 101, 193, 309, 309, 240, 19, 313, 313, 94, 208, + /* 1240 */ 209, 193, 239, 240, 193, 66, 252, 19, 268, 244, + /* 1250 */ 216, 217, 193, 74, 213, 252, 161, 19, 263, 254, + /* 1260 */ 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + /* 1270 */ 54, 55, 56, 57, 193, 216, 217, 5, 59, 193, + /* 1280 */ 19, 244, 10, 11, 12, 13, 14, 101, 309, 17, + /* 1290 */ 146, 254, 313, 193, 193, 76, 115, 216, 217, 309, + /* 1300 */ 12, 263, 30, 313, 32, 46, 87, 46, 89, 130, + /* 1310 */ 193, 92, 40, 22, 263, 27, 216, 217, 102, 103, + /* 1320 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + /* 1330 */ 42, 150, 291, 216, 217, 116, 117, 118, 19, 20, + /* 1340 */ 193, 22, 70, 260, 116, 193, 24, 264, 193, 263, + /* 1350 */ 78, 63, 61, 81, 116, 36, 193, 260, 193, 29, + /* 1360 */ 193, 264, 193, 33, 145, 193, 59, 48, 216, 217, + /* 1370 */ 98, 216, 217, 193, 115, 193, 115, 193, 59, 216, + /* 1380 */ 217, 216, 217, 216, 217, 216, 217, 255, 216, 217, + /* 1390 */ 71, 193, 131, 193, 25, 65, 216, 217, 216, 217, + /* 1400 */ 216, 217, 208, 209, 85, 133, 193, 100, 193, 90, + /* 1410 */ 138, 139, 138, 139, 216, 217, 216, 217, 193, 100, + /* 1420 */ 193, 108, 135, 116, 117, 106, 107, 140, 121, 216, + /* 1430 */ 217, 216, 217, 114, 162, 116, 117, 118, 299, 300, + /* 1440 */ 121, 216, 217, 216, 217, 193, 244, 193, 135, 244, + /* 1450 */ 193, 256, 257, 140, 244, 193, 254, 193, 193, 254, + /* 1460 */ 153, 154, 155, 141, 254, 149, 150, 258, 216, 217, + /* 1470 */ 216, 217, 153, 154, 155, 156, 157, 0, 1, 2, + /* 1480 */ 216, 217, 5, 115, 158, 193, 160, 10, 11, 12, + /* 1490 */ 13, 14, 193, 59, 17, 126, 193, 19, 20, 129, + /* 1500 */ 22, 193, 22, 22, 24, 193, 23, 30, 25, 32, + /* 1510 */ 19, 20, 144, 22, 36, 216, 217, 40, 193, 216, + /* 1520 */ 217, 193, 152, 129, 216, 217, 193, 36, 216, 217, + /* 1530 */ 193, 99, 193, 193, 53, 193, 193, 59, 23, 193, + /* 1540 */ 25, 216, 217, 193, 216, 217, 152, 70, 59, 71, + /* 1550 */ 59, 117, 193, 216, 217, 78, 216, 217, 81, 216, + /* 1560 */ 217, 318, 71, 85, 193, 133, 193, 193, 90, 23, + /* 1570 */ 23, 25, 25, 120, 121, 98, 85, 193, 100, 193, + /* 1580 */ 23, 90, 25, 121, 106, 107, 19, 216, 217, 216, + /* 1590 */ 217, 100, 114, 131, 116, 117, 118, 106, 107, 121, + /* 1600 */ 216, 217, 216, 217, 193, 114, 117, 116, 117, 118, + /* 1610 */ 133, 193, 121, 193, 193, 138, 139, 193, 23, 193, + /* 1620 */ 25, 23, 23, 25, 25, 7, 8, 216, 217, 193, + /* 1630 */ 193, 153, 154, 155, 156, 157, 216, 217, 193, 162, + /* 1640 */ 216, 217, 216, 217, 153, 154, 155, 156, 157, 1, + /* 1650 */ 2, 193, 193, 5, 19, 20, 59, 22, 10, 11, + /* 1660 */ 12, 13, 14, 193, 97, 17, 193, 23, 193, 25, + /* 1670 */ 288, 36, 193, 242, 216, 217, 236, 23, 30, 25, + /* 1680 */ 32, 19, 20, 23, 22, 25, 216, 217, 40, 216, + /* 1690 */ 217, 216, 217, 193, 59, 216, 217, 193, 36, 83, + /* 1700 */ 84, 153, 153, 155, 155, 23, 71, 25, 23, 193, + /* 1710 */ 25, 193, 193, 193, 117, 193, 193, 193, 70, 193, + /* 1720 */ 193, 59, 193, 255, 255, 287, 78, 255, 243, 81, + /* 1730 */ 191, 255, 297, 71, 271, 100, 293, 245, 267, 214, + /* 1740 */ 246, 106, 107, 108, 246, 271, 98, 245, 293, 114, + /* 1750 */ 220, 116, 117, 118, 267, 271, 121, 271, 225, 219, + /* 1760 */ 229, 219, 100, 219, 259, 259, 259, 259, 106, 107, + /* 1770 */ 249, 196, 60, 280, 141, 243, 114, 249, 116, 117, + /* 1780 */ 118, 133, 245, 121, 200, 297, 138, 139, 153, 154, + /* 1790 */ 155, 156, 157, 297, 200, 38, 19, 20, 151, 22, + /* 1800 */ 200, 150, 140, 294, 294, 22, 272, 43, 234, 18, + /* 1810 */ 162, 270, 200, 36, 237, 153, 154, 155, 156, 157, + /* 1820 */ 237, 283, 237, 237, 18, 199, 149, 246, 272, 270, + /* 1830 */ 272, 200, 158, 246, 246, 234, 59, 234, 246, 199, + /* 1840 */ 290, 62, 289, 200, 199, 22, 221, 115, 71, 200, + /* 1850 */ 200, 199, 199, 221, 218, 218, 19, 20, 64, 22, + /* 1860 */ 218, 227, 22, 224, 126, 224, 165, 221, 24, 305, + /* 1870 */ 200, 113, 312, 36, 218, 220, 218, 100, 282, 218, + /* 1880 */ 91, 218, 317, 106, 107, 221, 227, 282, 317, 82, + /* 1890 */ 148, 114, 265, 116, 117, 118, 59, 145, 121, 22, + /* 1900 */ 277, 158, 200, 265, 25, 202, 147, 250, 71, 279, + /* 1910 */ 13, 146, 194, 194, 249, 248, 250, 140, 247, 246, + /* 1920 */ 6, 192, 192, 192, 303, 303, 213, 207, 300, 213, + /* 1930 */ 153, 154, 155, 156, 157, 213, 213, 100, 213, 222, + /* 1940 */ 207, 214, 214, 106, 107, 4, 222, 207, 3, 22, + /* 1950 */ 163, 114, 15, 116, 117, 118, 16, 23, 121, 23, + /* 1960 */ 139, 151, 130, 25, 142, 16, 24, 20, 144, 1, + /* 1970 */ 142, 130, 130, 61, 53, 53, 37, 151, 53, 53, + /* 1980 */ 130, 116, 34, 1, 141, 5, 22, 115, 161, 141, + /* 1990 */ 153, 154, 155, 156, 157, 25, 68, 68, 75, 41, + /* 2000 */ 115, 24, 131, 20, 19, 125, 22, 96, 22, 22, + /* 2010 */ 67, 23, 22, 67, 59, 24, 22, 28, 67, 23, + /* 2020 */ 22, 22, 149, 23, 23, 23, 116, 23, 25, 37, + /* 2030 */ 97, 141, 23, 23, 22, 143, 25, 75, 88, 34, + /* 2040 */ 34, 34, 34, 86, 75, 93, 23, 34, 22, 34, + /* 2050 */ 25, 24, 34, 25, 23, 142, 23, 142, 44, 23, + /* 2060 */ 23, 23, 11, 23, 25, 22, 22, 22, 15, 23, + /* 2070 */ 23, 22, 22, 25, 1, 1, 141, 25, 23, 135, + /* 2080 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + /* 2090 */ 319, 319, 319, 319, 141, 141, 319, 319, 319, 319, + /* 2100 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + /* 2110 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + /* 2120 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + /* 2130 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + /* 2140 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + /* 2150 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + /* 2160 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + /* 2170 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + /* 2180 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + /* 2190 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + /* 2200 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + /* 2210 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + /* 2220 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + /* 2230 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + /* 2240 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + /* 2250 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + /* 2260 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + /* 2270 */ 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + /* 2280 */ 319, +}; +#define YY_SHIFT_COUNT (574) +#define YY_SHIFT_MIN (0) +#define YY_SHIFT_MAX (2074) +static const unsigned short int yy_shift_ofst[] = { + /* 0 */ 1648, 1477, 1272, 322, 322, 1, 1319, 1478, 1491, 1837, + /* 10 */ 1837, 1837, 471, 0, 0, 214, 1093, 1837, 1837, 1837, + /* 20 */ 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, + /* 30 */ 271, 271, 1219, 1219, 216, 88, 1, 1, 1, 1, + /* 40 */ 1, 40, 111, 258, 361, 469, 512, 583, 622, 693, + /* 50 */ 732, 803, 842, 913, 1073, 1093, 1093, 1093, 1093, 1093, + /* 60 */ 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1093, + /* 70 */ 1093, 1093, 1093, 1113, 1093, 1216, 957, 957, 1635, 1662, + /* 80 */ 1777, 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, + /* 90 */ 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, + /* 100 */ 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, + /* 110 */ 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, + /* 120 */ 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, 1837, + /* 130 */ 137, 181, 181, 181, 181, 181, 181, 181, 94, 430, + /* 140 */ 66, 65, 112, 366, 533, 533, 740, 1261, 533, 533, + /* 150 */ 79, 79, 533, 412, 412, 412, 77, 412, 123, 113, + /* 160 */ 113, 22, 22, 2096, 2096, 328, 328, 328, 239, 468, + /* 170 */ 468, 468, 468, 1015, 1015, 409, 366, 1129, 1186, 533, + /* 180 */ 533, 533, 533, 533, 533, 533, 533, 533, 533, 533, + /* 190 */ 533, 533, 533, 533, 533, 533, 533, 533, 533, 969, + /* 200 */ 621, 621, 533, 642, 788, 788, 1228, 1228, 822, 822, + /* 210 */ 67, 1274, 2096, 2096, 2096, 2096, 2096, 2096, 2096, 1307, + /* 220 */ 954, 954, 585, 472, 640, 387, 695, 538, 541, 700, + /* 230 */ 533, 533, 533, 533, 533, 533, 533, 533, 533, 533, + /* 240 */ 222, 533, 533, 533, 533, 533, 533, 533, 533, 533, + /* 250 */ 533, 533, 533, 1179, 1179, 1179, 533, 533, 533, 565, + /* 260 */ 533, 533, 533, 916, 1144, 533, 533, 1288, 533, 533, + /* 270 */ 533, 533, 533, 533, 533, 533, 639, 1330, 209, 1076, + /* 280 */ 1076, 1076, 1076, 580, 209, 209, 1313, 768, 917, 649, + /* 290 */ 1181, 1316, 405, 1316, 1238, 249, 1181, 1181, 249, 1181, + /* 300 */ 405, 1238, 1369, 464, 1259, 1012, 1012, 1012, 1368, 1368, + /* 310 */ 1368, 1368, 184, 184, 1326, 904, 1287, 1480, 1712, 1712, + /* 320 */ 1633, 1633, 1757, 1757, 1633, 1647, 1651, 1783, 1764, 1791, + /* 330 */ 1791, 1791, 1791, 1633, 1806, 1677, 1651, 1651, 1677, 1783, + /* 340 */ 1764, 1677, 1764, 1677, 1633, 1806, 1674, 1779, 1633, 1806, + /* 350 */ 1823, 1633, 1806, 1633, 1806, 1823, 1732, 1732, 1732, 1794, + /* 360 */ 1840, 1840, 1823, 1732, 1738, 1732, 1794, 1732, 1732, 1701, + /* 370 */ 1844, 1758, 1758, 1823, 1633, 1789, 1789, 1807, 1807, 1742, + /* 380 */ 1752, 1877, 1633, 1743, 1742, 1759, 1765, 1677, 1879, 1897, + /* 390 */ 1897, 1914, 1914, 1914, 2096, 2096, 2096, 2096, 2096, 2096, + /* 400 */ 2096, 2096, 2096, 2096, 2096, 2096, 2096, 2096, 2096, 207, + /* 410 */ 1095, 331, 620, 903, 806, 1074, 1483, 1432, 1481, 1322, + /* 420 */ 1370, 1394, 1515, 1291, 1546, 1547, 1557, 1595, 1598, 1599, + /* 430 */ 1434, 1453, 1618, 1462, 1567, 1489, 1644, 1654, 1616, 1660, + /* 440 */ 1548, 1549, 1682, 1685, 1597, 742, 1941, 1945, 1927, 1787, + /* 450 */ 1937, 1940, 1934, 1936, 1821, 1810, 1832, 1938, 1938, 1942, + /* 460 */ 1822, 1947, 1824, 1949, 1968, 1828, 1841, 1938, 1842, 1912, + /* 470 */ 1939, 1938, 1826, 1921, 1922, 1925, 1926, 1850, 1865, 1948, + /* 480 */ 1843, 1982, 1980, 1964, 1872, 1827, 1928, 1970, 1929, 1923, + /* 490 */ 1958, 1848, 1885, 1977, 1983, 1985, 1871, 1880, 1984, 1943, + /* 500 */ 1986, 1987, 1988, 1990, 1946, 1955, 1991, 1911, 1989, 1994, + /* 510 */ 1951, 1992, 1996, 1873, 1998, 2000, 2001, 2002, 2003, 2004, + /* 520 */ 1999, 1933, 1890, 2009, 2010, 1910, 2005, 2012, 1892, 2011, + /* 530 */ 2006, 2007, 2008, 2013, 1950, 1962, 1957, 2014, 1969, 1952, + /* 540 */ 2015, 2023, 2026, 2027, 2025, 2028, 2018, 1913, 1915, 2031, + /* 550 */ 2011, 2033, 2036, 2037, 2038, 2039, 2040, 2043, 2051, 2044, + /* 560 */ 2045, 2046, 2047, 2049, 2050, 2048, 1944, 1935, 1953, 1954, + /* 570 */ 2052, 2055, 2053, 2073, 2074, +}; +#define YY_REDUCE_COUNT (408) +#define YY_REDUCE_MIN (-271) +#define YY_REDUCE_MAX (1740) +static const short yy_reduce_ofst[] = { + /* 0 */ -125, 733, 789, 241, 293, -123, -193, -191, -183, -187, + /* 10 */ 166, 238, 133, -207, -199, -267, -176, -6, 204, 489, + /* 20 */ 576, -175, 598, 686, 615, 725, 860, 778, 781, 857, + /* 30 */ 616, 887, 87, 240, -192, 408, 626, 796, 843, 854, + /* 40 */ 1003, -271, -271, -271, -271, -271, -271, -271, -271, -271, + /* 50 */ -271, -271, -271, -271, -271, -271, -271, -271, -271, -271, + /* 60 */ -271, -271, -271, -271, -271, -271, -271, -271, -271, -271, + /* 70 */ -271, -271, -271, -271, -271, -271, -271, -271, 80, 83, + /* 80 */ 313, 886, 888, 996, 1034, 1059, 1081, 1100, 1117, 1152, + /* 90 */ 1155, 1163, 1165, 1167, 1169, 1172, 1180, 1182, 1184, 1198, + /* 100 */ 1200, 1213, 1215, 1225, 1227, 1252, 1254, 1264, 1299, 1303, + /* 110 */ 1308, 1312, 1325, 1328, 1337, 1340, 1343, 1371, 1373, 1384, + /* 120 */ 1386, 1411, 1420, 1424, 1426, 1458, 1470, 1473, 1475, 1479, + /* 130 */ -271, -271, -271, -271, -271, -271, -271, -271, -271, -271, + /* 140 */ -271, 138, 459, 396, -158, 470, 302, -212, 521, 201, + /* 150 */ -195, -92, 559, 630, 632, 630, -271, 632, 901, 63, + /* 160 */ 407, -271, -271, -271, -271, 161, 161, 161, 251, 335, + /* 170 */ 847, 960, 980, 537, 588, 618, 628, 688, 688, -166, + /* 180 */ -161, 674, 790, 794, 799, 851, 852, -122, 680, -120, + /* 190 */ 995, 1038, 415, 1051, 893, 798, 962, 400, 1086, 779, + /* 200 */ 923, 924, 263, 1041, 979, 990, 1083, 1097, 1031, 1194, + /* 210 */ 362, 994, 1139, 1005, 1037, 1202, 1205, 1195, 1210, -194, + /* 220 */ 56, 185, -135, 232, 522, 560, 601, 617, 669, 683, + /* 230 */ 711, 856, 908, 941, 1048, 1101, 1147, 1257, 1262, 1265, + /* 240 */ 392, 1292, 1333, 1339, 1342, 1346, 1350, 1359, 1374, 1418, + /* 250 */ 1421, 1436, 1437, 593, 755, 770, 997, 1445, 1459, 1209, + /* 260 */ 1500, 1504, 1516, 1132, 1243, 1518, 1519, 1440, 1520, 560, + /* 270 */ 1522, 1523, 1524, 1526, 1527, 1529, 1382, 1438, 1431, 1468, + /* 280 */ 1469, 1472, 1476, 1209, 1431, 1431, 1485, 1525, 1539, 1435, + /* 290 */ 1463, 1471, 1492, 1487, 1443, 1494, 1474, 1484, 1498, 1486, + /* 300 */ 1502, 1455, 1530, 1531, 1533, 1540, 1542, 1544, 1505, 1506, + /* 310 */ 1507, 1508, 1521, 1528, 1493, 1537, 1532, 1575, 1488, 1496, + /* 320 */ 1584, 1594, 1509, 1510, 1600, 1538, 1534, 1541, 1574, 1577, + /* 330 */ 1583, 1585, 1586, 1612, 1626, 1581, 1556, 1558, 1587, 1559, + /* 340 */ 1601, 1588, 1603, 1592, 1631, 1640, 1550, 1553, 1643, 1645, + /* 350 */ 1625, 1649, 1652, 1650, 1653, 1632, 1636, 1637, 1642, 1634, + /* 360 */ 1639, 1641, 1646, 1656, 1655, 1658, 1659, 1661, 1663, 1560, + /* 370 */ 1564, 1596, 1605, 1664, 1670, 1565, 1571, 1627, 1638, 1657, + /* 380 */ 1665, 1623, 1702, 1630, 1666, 1667, 1671, 1673, 1703, 1718, + /* 390 */ 1719, 1729, 1730, 1731, 1621, 1622, 1628, 1720, 1713, 1716, + /* 400 */ 1722, 1723, 1733, 1717, 1724, 1727, 1728, 1725, 1740, +}; +static const YYACTIONTYPE yy_default[] = { + /* 0 */ 1641, 1641, 1641, 1469, 1236, 1347, 1236, 1236, 1236, 1469, + /* 10 */ 1469, 1469, 1236, 1377, 1377, 1522, 1269, 1236, 1236, 1236, + /* 20 */ 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1468, 1236, 1236, + /* 30 */ 1236, 1236, 1557, 1557, 1236, 1236, 1236, 1236, 1236, 1236, + /* 40 */ 1236, 1236, 1386, 1236, 1393, 1236, 1236, 1236, 1236, 1236, + /* 50 */ 1470, 1471, 1236, 1236, 1236, 1521, 1523, 1486, 1400, 1399, + /* 60 */ 1398, 1397, 1504, 1365, 1391, 1384, 1388, 1465, 1466, 1464, + /* 70 */ 1619, 1471, 1470, 1236, 1387, 1433, 1449, 1432, 1236, 1236, + /* 80 */ 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, + /* 90 */ 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, + /* 100 */ 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, + /* 110 */ 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, + /* 120 */ 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, + /* 130 */ 1441, 1448, 1447, 1446, 1455, 1445, 1442, 1435, 1434, 1436, + /* 140 */ 1437, 1236, 1236, 1260, 1236, 1236, 1257, 1311, 1236, 1236, + /* 150 */ 1236, 1236, 1236, 1541, 1540, 1236, 1438, 1236, 1269, 1427, + /* 160 */ 1426, 1452, 1439, 1451, 1450, 1529, 1593, 1592, 1487, 1236, + /* 170 */ 1236, 1236, 1236, 1236, 1236, 1557, 1236, 1236, 1236, 1236, + /* 180 */ 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, + /* 190 */ 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1367, + /* 200 */ 1557, 1557, 1236, 1269, 1557, 1557, 1368, 1368, 1265, 1265, + /* 210 */ 1371, 1236, 1536, 1338, 1338, 1338, 1338, 1347, 1338, 1236, + /* 220 */ 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, + /* 230 */ 1236, 1236, 1236, 1236, 1526, 1524, 1236, 1236, 1236, 1236, + /* 240 */ 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, + /* 250 */ 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, + /* 260 */ 1236, 1236, 1236, 1343, 1236, 1236, 1236, 1236, 1236, 1236, + /* 270 */ 1236, 1236, 1236, 1236, 1236, 1586, 1236, 1499, 1325, 1343, + /* 280 */ 1343, 1343, 1343, 1345, 1326, 1324, 1337, 1270, 1243, 1633, + /* 290 */ 1403, 1392, 1344, 1392, 1630, 1390, 1403, 1403, 1390, 1403, + /* 300 */ 1344, 1630, 1286, 1608, 1281, 1377, 1377, 1377, 1367, 1367, + /* 310 */ 1367, 1367, 1371, 1371, 1467, 1344, 1337, 1236, 1633, 1633, + /* 320 */ 1353, 1353, 1632, 1632, 1353, 1487, 1616, 1412, 1314, 1320, + /* 330 */ 1320, 1320, 1320, 1353, 1254, 1390, 1616, 1616, 1390, 1412, + /* 340 */ 1314, 1390, 1314, 1390, 1353, 1254, 1503, 1627, 1353, 1254, + /* 350 */ 1477, 1353, 1254, 1353, 1254, 1477, 1312, 1312, 1312, 1301, + /* 360 */ 1236, 1236, 1477, 1312, 1286, 1312, 1301, 1312, 1312, 1575, + /* 370 */ 1236, 1481, 1481, 1477, 1353, 1567, 1567, 1380, 1380, 1385, + /* 380 */ 1371, 1472, 1353, 1236, 1385, 1383, 1381, 1390, 1304, 1589, + /* 390 */ 1589, 1585, 1585, 1585, 1638, 1638, 1536, 1601, 1269, 1269, + /* 400 */ 1269, 1269, 1601, 1288, 1288, 1270, 1270, 1269, 1601, 1236, + /* 410 */ 1236, 1236, 1236, 1236, 1236, 1596, 1236, 1531, 1488, 1357, + /* 420 */ 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, + /* 430 */ 1236, 1236, 1236, 1236, 1542, 1236, 1236, 1236, 1236, 1236, + /* 440 */ 1236, 1236, 1236, 1236, 1236, 1417, 1236, 1239, 1533, 1236, + /* 450 */ 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1394, 1395, 1358, + /* 460 */ 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1409, 1236, 1236, + /* 470 */ 1236, 1404, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, + /* 480 */ 1629, 1236, 1236, 1236, 1236, 1236, 1236, 1502, 1501, 1236, + /* 490 */ 1236, 1355, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, + /* 500 */ 1236, 1236, 1236, 1236, 1236, 1284, 1236, 1236, 1236, 1236, + /* 510 */ 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, + /* 520 */ 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1382, + /* 530 */ 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, + /* 540 */ 1236, 1236, 1236, 1236, 1572, 1372, 1236, 1236, 1236, 1236, + /* 550 */ 1620, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, 1236, + /* 560 */ 1236, 1236, 1236, 1236, 1236, 1612, 1328, 1418, 1236, 1421, + /* 570 */ 1258, 1236, 1248, 1236, 1236, +}; +/********** End of lemon-generated parsing tables *****************************/ + +/* The next table maps tokens (terminal symbols) into fallback tokens. +** If a construct like the following: +** +** %fallback ID X Y Z. +** +** appears in the grammar, then ID becomes a fallback token for X, Y, +** and Z. Whenever one of the tokens X, Y, or Z is input to the parser +** but it does not parse, the type of the token is changed to ID and +** the parse is retried before an error is thrown. +** +** This feature can be used, for example, to cause some keywords in a language +** to revert to identifiers if they keyword does not apply in the context where +** it appears. +*/ +#ifdef YYFALLBACK +static const YYCODETYPE yyFallback[] = { + 0, /* $ => nothing */ + 0, /* SEMI => nothing */ + 59, /* EXPLAIN => ID */ + 59, /* QUERY => ID */ + 59, /* PLAN => ID */ + 59, /* BEGIN => ID */ + 0, /* TRANSACTION => nothing */ + 59, /* DEFERRED => ID */ + 59, /* IMMEDIATE => ID */ + 59, /* EXCLUSIVE => ID */ + 0, /* COMMIT => nothing */ + 59, /* END => ID */ + 59, /* ROLLBACK => ID */ + 59, /* SAVEPOINT => ID */ + 59, /* RELEASE => ID */ + 0, /* TO => nothing */ + 0, /* TABLE => nothing */ + 0, /* CREATE => nothing */ + 59, /* IF => ID */ + 0, /* NOT => nothing */ + 0, /* EXISTS => nothing */ + 59, /* TEMP => ID */ + 0, /* LP => nothing */ + 0, /* RP => nothing */ + 0, /* AS => nothing */ + 0, /* COMMA => nothing */ + 59, /* WITHOUT => ID */ + 59, /* ABORT => ID */ + 59, /* ACTION => ID */ + 59, /* AFTER => ID */ + 59, /* ANALYZE => ID */ + 59, /* ASC => ID */ + 59, /* ATTACH => ID */ + 59, /* BEFORE => ID */ + 59, /* BY => ID */ + 59, /* CASCADE => ID */ + 59, /* CAST => ID */ + 59, /* CONFLICT => ID */ + 59, /* DATABASE => ID */ + 59, /* DESC => ID */ + 59, /* DETACH => ID */ + 59, /* EACH => ID */ + 59, /* FAIL => ID */ + 0, /* OR => nothing */ + 0, /* AND => nothing */ + 0, /* IS => nothing */ + 59, /* MATCH => ID */ + 59, /* LIKE_KW => ID */ + 0, /* BETWEEN => nothing */ + 0, /* IN => nothing */ + 0, /* ISNULL => nothing */ + 0, /* NOTNULL => nothing */ + 0, /* NE => nothing */ + 0, /* EQ => nothing */ + 0, /* GT => nothing */ + 0, /* LE => nothing */ + 0, /* LT => nothing */ + 0, /* GE => nothing */ + 0, /* ESCAPE => nothing */ + 0, /* ID => nothing */ + 59, /* COLUMNKW => ID */ + 59, /* DO => ID */ + 59, /* FOR => ID */ + 59, /* IGNORE => ID */ + 59, /* INITIALLY => ID */ + 59, /* INSTEAD => ID */ + 59, /* NO => ID */ + 59, /* KEY => ID */ + 59, /* OF => ID */ + 59, /* OFFSET => ID */ + 59, /* PRAGMA => ID */ + 59, /* RAISE => ID */ + 59, /* RECURSIVE => ID */ + 59, /* REPLACE => ID */ + 59, /* RESTRICT => ID */ + 59, /* ROW => ID */ + 59, /* ROWS => ID */ + 59, /* TRIGGER => ID */ + 59, /* VACUUM => ID */ + 59, /* VIEW => ID */ + 59, /* VIRTUAL => ID */ + 59, /* WITH => ID */ + 59, /* NULLS => ID */ + 59, /* FIRST => ID */ + 59, /* LAST => ID */ + 59, /* CURRENT => ID */ + 59, /* FOLLOWING => ID */ + 59, /* PARTITION => ID */ + 59, /* PRECEDING => ID */ + 59, /* RANGE => ID */ + 59, /* UNBOUNDED => ID */ + 59, /* EXCLUDE => ID */ + 59, /* GROUPS => ID */ + 59, /* OTHERS => ID */ + 59, /* TIES => ID */ + 59, /* GENERATED => ID */ + 59, /* ALWAYS => ID */ + 59, /* MATERIALIZED => ID */ + 59, /* REINDEX => ID */ + 59, /* RENAME => ID */ + 59, /* CTIME_KW => ID */ + 0, /* ANY => nothing */ + 0, /* BITAND => nothing */ + 0, /* BITOR => nothing */ + 0, /* LSHIFT => nothing */ + 0, /* RSHIFT => nothing */ + 0, /* PLUS => nothing */ + 0, /* MINUS => nothing */ + 0, /* STAR => nothing */ + 0, /* SLASH => nothing */ + 0, /* REM => nothing */ + 0, /* CONCAT => nothing */ + 0, /* PTR => nothing */ + 0, /* COLLATE => nothing */ + 0, /* BITNOT => nothing */ + 0, /* ON => nothing */ + 0, /* INDEXED => nothing */ + 0, /* STRING => nothing */ + 0, /* JOIN_KW => nothing */ + 0, /* CONSTRAINT => nothing */ + 0, /* DEFAULT => nothing */ + 0, /* NULL => nothing */ + 0, /* PRIMARY => nothing */ + 0, /* UNIQUE => nothing */ + 0, /* CHECK => nothing */ + 0, /* REFERENCES => nothing */ + 0, /* AUTOINCR => nothing */ + 0, /* INSERT => nothing */ + 0, /* DELETE => nothing */ + 0, /* UPDATE => nothing */ + 0, /* SET => nothing */ + 0, /* DEFERRABLE => nothing */ + 0, /* FOREIGN => nothing */ + 0, /* DROP => nothing */ + 0, /* UNION => nothing */ + 0, /* ALL => nothing */ + 0, /* EXCEPT => nothing */ + 0, /* INTERSECT => nothing */ + 0, /* SELECT => nothing */ + 0, /* VALUES => nothing */ + 0, /* DISTINCT => nothing */ + 0, /* DOT => nothing */ + 0, /* FROM => nothing */ + 0, /* JOIN => nothing */ + 0, /* USING => nothing */ + 0, /* ORDER => nothing */ + 0, /* GROUP => nothing */ + 0, /* HAVING => nothing */ + 0, /* LIMIT => nothing */ + 0, /* WHERE => nothing */ + 0, /* RETURNING => nothing */ + 0, /* INTO => nothing */ + 0, /* NOTHING => nothing */ + 0, /* FLOAT => nothing */ + 0, /* BLOB => nothing */ + 0, /* INTEGER => nothing */ + 0, /* VARIABLE => nothing */ + 0, /* CASE => nothing */ + 0, /* WHEN => nothing */ + 0, /* THEN => nothing */ + 0, /* ELSE => nothing */ + 0, /* INDEX => nothing */ + 0, /* ALTER => nothing */ + 0, /* ADD => nothing */ + 0, /* WINDOW => nothing */ + 0, /* OVER => nothing */ + 0, /* FILTER => nothing */ + 0, /* COLUMN => nothing */ + 0, /* AGG_FUNCTION => nothing */ + 0, /* AGG_COLUMN => nothing */ + 0, /* TRUEFALSE => nothing */ + 0, /* ISNOT => nothing */ + 0, /* FUNCTION => nothing */ + 0, /* UMINUS => nothing */ + 0, /* UPLUS => nothing */ + 0, /* TRUTH => nothing */ + 0, /* REGISTER => nothing */ + 0, /* VECTOR => nothing */ + 0, /* SELECT_COLUMN => nothing */ + 0, /* IF_NULL_ROW => nothing */ + 0, /* ASTERISK => nothing */ + 0, /* SPAN => nothing */ + 0, /* ERROR => nothing */ + 0, /* SPACE => nothing */ + 0, /* ILLEGAL => nothing */ +}; +#endif /* YYFALLBACK */ + +/* The following structure represents a single element of the +** parser's stack. Information stored includes: +** +** + The state number for the parser at this level of the stack. +** +** + The value of the token stored at this level of the stack. +** (In other words, the "major" token.) +** +** + The semantic value stored at this level of the stack. This is +** the information used by the action routines in the grammar. +** It is sometimes called the "minor" token. +** +** After the "shift" half of a SHIFTREDUCE action, the stateno field +** actually contains the reduce action for the second half of the +** SHIFTREDUCE. +*/ +struct yyStackEntry { + YYACTIONTYPE stateno; /* The state-number, or reduce action in SHIFTREDUCE */ + YYCODETYPE major; /* The major token value. This is the code + ** number for the token at this stack level */ + YYMINORTYPE minor; /* The user-supplied minor token value. This + ** is the value of the token */ +}; +typedef struct yyStackEntry yyStackEntry; + +/* The state of the parser is completely contained in an instance of +** the following structure */ +struct yyParser { + yyStackEntry *yytos; /* Pointer to top element of the stack */ +#ifdef YYTRACKMAXSTACKDEPTH + int yyhwm; /* High-water mark of the stack */ +#endif +#ifndef YYNOERRORRECOVERY + int yyerrcnt; /* Shifts left before out of the error */ +#endif + sqlite3ParserARG_SDECL /* A place to hold %extra_argument */ + sqlite3ParserCTX_SDECL /* A place to hold %extra_context */ +#if YYSTACKDEPTH<=0 + int yystksz; /* Current side of the stack */ + yyStackEntry *yystack; /* The parser's stack */ + yyStackEntry yystk0; /* First stack entry */ +#else + yyStackEntry yystack[YYSTACKDEPTH]; /* The parser's stack */ + yyStackEntry *yystackEnd; /* Last entry in the stack */ +#endif +}; +typedef struct yyParser yyParser; + +/* #include */ +#ifndef NDEBUG +/* #include */ +static FILE *yyTraceFILE = 0; +static char *yyTracePrompt = 0; +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* +** Turn parser tracing on by giving a stream to which to write the trace +** and a prompt to preface each trace message. Tracing is turned off +** by making either argument NULL +** +** Inputs: +**
    +**
  • A FILE* to which trace output should be written. +** If NULL, then tracing is turned off. +**
  • A prefix string written at the beginning of every +** line of trace output. If NULL, then tracing is +** turned off. +**
+** +** Outputs: +** None. +*/ +SQLITE_PRIVATE void sqlite3ParserTrace(FILE *TraceFILE, char *zTracePrompt){ + yyTraceFILE = TraceFILE; + yyTracePrompt = zTracePrompt; + if( yyTraceFILE==0 ) yyTracePrompt = 0; + else if( yyTracePrompt==0 ) yyTraceFILE = 0; +} +#endif /* NDEBUG */ + +#if defined(YYCOVERAGE) || !defined(NDEBUG) +/* For tracing shifts, the names of all terminals and nonterminals +** are required. The following table supplies these names */ +static const char *const yyTokenName[] = { + /* 0 */ "$", + /* 1 */ "SEMI", + /* 2 */ "EXPLAIN", + /* 3 */ "QUERY", + /* 4 */ "PLAN", + /* 5 */ "BEGIN", + /* 6 */ "TRANSACTION", + /* 7 */ "DEFERRED", + /* 8 */ "IMMEDIATE", + /* 9 */ "EXCLUSIVE", + /* 10 */ "COMMIT", + /* 11 */ "END", + /* 12 */ "ROLLBACK", + /* 13 */ "SAVEPOINT", + /* 14 */ "RELEASE", + /* 15 */ "TO", + /* 16 */ "TABLE", + /* 17 */ "CREATE", + /* 18 */ "IF", + /* 19 */ "NOT", + /* 20 */ "EXISTS", + /* 21 */ "TEMP", + /* 22 */ "LP", + /* 23 */ "RP", + /* 24 */ "AS", + /* 25 */ "COMMA", + /* 26 */ "WITHOUT", + /* 27 */ "ABORT", + /* 28 */ "ACTION", + /* 29 */ "AFTER", + /* 30 */ "ANALYZE", + /* 31 */ "ASC", + /* 32 */ "ATTACH", + /* 33 */ "BEFORE", + /* 34 */ "BY", + /* 35 */ "CASCADE", + /* 36 */ "CAST", + /* 37 */ "CONFLICT", + /* 38 */ "DATABASE", + /* 39 */ "DESC", + /* 40 */ "DETACH", + /* 41 */ "EACH", + /* 42 */ "FAIL", + /* 43 */ "OR", + /* 44 */ "AND", + /* 45 */ "IS", + /* 46 */ "MATCH", + /* 47 */ "LIKE_KW", + /* 48 */ "BETWEEN", + /* 49 */ "IN", + /* 50 */ "ISNULL", + /* 51 */ "NOTNULL", + /* 52 */ "NE", + /* 53 */ "EQ", + /* 54 */ "GT", + /* 55 */ "LE", + /* 56 */ "LT", + /* 57 */ "GE", + /* 58 */ "ESCAPE", + /* 59 */ "ID", + /* 60 */ "COLUMNKW", + /* 61 */ "DO", + /* 62 */ "FOR", + /* 63 */ "IGNORE", + /* 64 */ "INITIALLY", + /* 65 */ "INSTEAD", + /* 66 */ "NO", + /* 67 */ "KEY", + /* 68 */ "OF", + /* 69 */ "OFFSET", + /* 70 */ "PRAGMA", + /* 71 */ "RAISE", + /* 72 */ "RECURSIVE", + /* 73 */ "REPLACE", + /* 74 */ "RESTRICT", + /* 75 */ "ROW", + /* 76 */ "ROWS", + /* 77 */ "TRIGGER", + /* 78 */ "VACUUM", + /* 79 */ "VIEW", + /* 80 */ "VIRTUAL", + /* 81 */ "WITH", + /* 82 */ "NULLS", + /* 83 */ "FIRST", + /* 84 */ "LAST", + /* 85 */ "CURRENT", + /* 86 */ "FOLLOWING", + /* 87 */ "PARTITION", + /* 88 */ "PRECEDING", + /* 89 */ "RANGE", + /* 90 */ "UNBOUNDED", + /* 91 */ "EXCLUDE", + /* 92 */ "GROUPS", + /* 93 */ "OTHERS", + /* 94 */ "TIES", + /* 95 */ "GENERATED", + /* 96 */ "ALWAYS", + /* 97 */ "MATERIALIZED", + /* 98 */ "REINDEX", + /* 99 */ "RENAME", + /* 100 */ "CTIME_KW", + /* 101 */ "ANY", + /* 102 */ "BITAND", + /* 103 */ "BITOR", + /* 104 */ "LSHIFT", + /* 105 */ "RSHIFT", + /* 106 */ "PLUS", + /* 107 */ "MINUS", + /* 108 */ "STAR", + /* 109 */ "SLASH", + /* 110 */ "REM", + /* 111 */ "CONCAT", + /* 112 */ "PTR", + /* 113 */ "COLLATE", + /* 114 */ "BITNOT", + /* 115 */ "ON", + /* 116 */ "INDEXED", + /* 117 */ "STRING", + /* 118 */ "JOIN_KW", + /* 119 */ "CONSTRAINT", + /* 120 */ "DEFAULT", + /* 121 */ "NULL", + /* 122 */ "PRIMARY", + /* 123 */ "UNIQUE", + /* 124 */ "CHECK", + /* 125 */ "REFERENCES", + /* 126 */ "AUTOINCR", + /* 127 */ "INSERT", + /* 128 */ "DELETE", + /* 129 */ "UPDATE", + /* 130 */ "SET", + /* 131 */ "DEFERRABLE", + /* 132 */ "FOREIGN", + /* 133 */ "DROP", + /* 134 */ "UNION", + /* 135 */ "ALL", + /* 136 */ "EXCEPT", + /* 137 */ "INTERSECT", + /* 138 */ "SELECT", + /* 139 */ "VALUES", + /* 140 */ "DISTINCT", + /* 141 */ "DOT", + /* 142 */ "FROM", + /* 143 */ "JOIN", + /* 144 */ "USING", + /* 145 */ "ORDER", + /* 146 */ "GROUP", + /* 147 */ "HAVING", + /* 148 */ "LIMIT", + /* 149 */ "WHERE", + /* 150 */ "RETURNING", + /* 151 */ "INTO", + /* 152 */ "NOTHING", + /* 153 */ "FLOAT", + /* 154 */ "BLOB", + /* 155 */ "INTEGER", + /* 156 */ "VARIABLE", + /* 157 */ "CASE", + /* 158 */ "WHEN", + /* 159 */ "THEN", + /* 160 */ "ELSE", + /* 161 */ "INDEX", + /* 162 */ "ALTER", + /* 163 */ "ADD", + /* 164 */ "WINDOW", + /* 165 */ "OVER", + /* 166 */ "FILTER", + /* 167 */ "COLUMN", + /* 168 */ "AGG_FUNCTION", + /* 169 */ "AGG_COLUMN", + /* 170 */ "TRUEFALSE", + /* 171 */ "ISNOT", + /* 172 */ "FUNCTION", + /* 173 */ "UMINUS", + /* 174 */ "UPLUS", + /* 175 */ "TRUTH", + /* 176 */ "REGISTER", + /* 177 */ "VECTOR", + /* 178 */ "SELECT_COLUMN", + /* 179 */ "IF_NULL_ROW", + /* 180 */ "ASTERISK", + /* 181 */ "SPAN", + /* 182 */ "ERROR", + /* 183 */ "SPACE", + /* 184 */ "ILLEGAL", + /* 185 */ "input", + /* 186 */ "cmdlist", + /* 187 */ "ecmd", + /* 188 */ "cmdx", + /* 189 */ "explain", + /* 190 */ "cmd", + /* 191 */ "transtype", + /* 192 */ "trans_opt", + /* 193 */ "nm", + /* 194 */ "savepoint_opt", + /* 195 */ "create_table", + /* 196 */ "create_table_args", + /* 197 */ "createkw", + /* 198 */ "temp", + /* 199 */ "ifnotexists", + /* 200 */ "dbnm", + /* 201 */ "columnlist", + /* 202 */ "conslist_opt", + /* 203 */ "table_option_set", + /* 204 */ "select", + /* 205 */ "table_option", + /* 206 */ "columnname", + /* 207 */ "carglist", + /* 208 */ "typetoken", + /* 209 */ "typename", + /* 210 */ "signed", + /* 211 */ "plus_num", + /* 212 */ "minus_num", + /* 213 */ "scanpt", + /* 214 */ "scantok", + /* 215 */ "ccons", + /* 216 */ "term", + /* 217 */ "expr", + /* 218 */ "onconf", + /* 219 */ "sortorder", + /* 220 */ "autoinc", + /* 221 */ "eidlist_opt", + /* 222 */ "refargs", + /* 223 */ "defer_subclause", + /* 224 */ "generated", + /* 225 */ "refarg", + /* 226 */ "refact", + /* 227 */ "init_deferred_pred_opt", + /* 228 */ "conslist", + /* 229 */ "tconscomma", + /* 230 */ "tcons", + /* 231 */ "sortlist", + /* 232 */ "eidlist", + /* 233 */ "defer_subclause_opt", + /* 234 */ "orconf", + /* 235 */ "resolvetype", + /* 236 */ "raisetype", + /* 237 */ "ifexists", + /* 238 */ "fullname", + /* 239 */ "selectnowith", + /* 240 */ "oneselect", + /* 241 */ "wqlist", + /* 242 */ "multiselect_op", + /* 243 */ "distinct", + /* 244 */ "selcollist", + /* 245 */ "from", + /* 246 */ "where_opt", + /* 247 */ "groupby_opt", + /* 248 */ "having_opt", + /* 249 */ "orderby_opt", + /* 250 */ "limit_opt", + /* 251 */ "window_clause", + /* 252 */ "values", + /* 253 */ "nexprlist", + /* 254 */ "sclp", + /* 255 */ "as", + /* 256 */ "seltablist", + /* 257 */ "stl_prefix", + /* 258 */ "joinop", + /* 259 */ "on_using", + /* 260 */ "indexed_by", + /* 261 */ "exprlist", + /* 262 */ "xfullname", + /* 263 */ "idlist", + /* 264 */ "indexed_opt", + /* 265 */ "nulls", + /* 266 */ "with", + /* 267 */ "where_opt_ret", + /* 268 */ "setlist", + /* 269 */ "insert_cmd", + /* 270 */ "idlist_opt", + /* 271 */ "upsert", + /* 272 */ "returning", + /* 273 */ "filter_over", + /* 274 */ "likeop", + /* 275 */ "between_op", + /* 276 */ "in_op", + /* 277 */ "paren_exprlist", + /* 278 */ "case_operand", + /* 279 */ "case_exprlist", + /* 280 */ "case_else", + /* 281 */ "uniqueflag", + /* 282 */ "collate", + /* 283 */ "vinto", + /* 284 */ "nmnum", + /* 285 */ "trigger_decl", + /* 286 */ "trigger_cmd_list", + /* 287 */ "trigger_time", + /* 288 */ "trigger_event", + /* 289 */ "foreach_clause", + /* 290 */ "when_clause", + /* 291 */ "trigger_cmd", + /* 292 */ "trnm", + /* 293 */ "tridxby", + /* 294 */ "database_kw_opt", + /* 295 */ "key_opt", + /* 296 */ "add_column_fullname", + /* 297 */ "kwcolumn_opt", + /* 298 */ "create_vtab", + /* 299 */ "vtabarglist", + /* 300 */ "vtabarg", + /* 301 */ "vtabargtoken", + /* 302 */ "lp", + /* 303 */ "anylist", + /* 304 */ "wqitem", + /* 305 */ "wqas", + /* 306 */ "windowdefn_list", + /* 307 */ "windowdefn", + /* 308 */ "window", + /* 309 */ "frame_opt", + /* 310 */ "part_opt", + /* 311 */ "filter_clause", + /* 312 */ "over_clause", + /* 313 */ "range_or_rows", + /* 314 */ "frame_bound", + /* 315 */ "frame_bound_s", + /* 316 */ "frame_bound_e", + /* 317 */ "frame_exclude_opt", + /* 318 */ "frame_exclude", +}; +#endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */ + +#ifndef NDEBUG +/* For tracing reduce actions, the names of all rules are required. +*/ +static const char *const yyRuleName[] = { + /* 0 */ "explain ::= EXPLAIN", + /* 1 */ "explain ::= EXPLAIN QUERY PLAN", + /* 2 */ "cmdx ::= cmd", + /* 3 */ "cmd ::= BEGIN transtype trans_opt", + /* 4 */ "transtype ::=", + /* 5 */ "transtype ::= DEFERRED", + /* 6 */ "transtype ::= IMMEDIATE", + /* 7 */ "transtype ::= EXCLUSIVE", + /* 8 */ "cmd ::= COMMIT|END trans_opt", + /* 9 */ "cmd ::= ROLLBACK trans_opt", + /* 10 */ "cmd ::= SAVEPOINT nm", + /* 11 */ "cmd ::= RELEASE savepoint_opt nm", + /* 12 */ "cmd ::= ROLLBACK trans_opt TO savepoint_opt nm", + /* 13 */ "create_table ::= createkw temp TABLE ifnotexists nm dbnm", + /* 14 */ "createkw ::= CREATE", + /* 15 */ "ifnotexists ::=", + /* 16 */ "ifnotexists ::= IF NOT EXISTS", + /* 17 */ "temp ::= TEMP", + /* 18 */ "temp ::=", + /* 19 */ "create_table_args ::= LP columnlist conslist_opt RP table_option_set", + /* 20 */ "create_table_args ::= AS select", + /* 21 */ "table_option_set ::=", + /* 22 */ "table_option_set ::= table_option_set COMMA table_option", + /* 23 */ "table_option ::= WITHOUT nm", + /* 24 */ "table_option ::= nm", + /* 25 */ "columnname ::= nm typetoken", + /* 26 */ "typetoken ::=", + /* 27 */ "typetoken ::= typename LP signed RP", + /* 28 */ "typetoken ::= typename LP signed COMMA signed RP", + /* 29 */ "typename ::= typename ID|STRING", + /* 30 */ "scanpt ::=", + /* 31 */ "scantok ::=", + /* 32 */ "ccons ::= CONSTRAINT nm", + /* 33 */ "ccons ::= DEFAULT scantok term", + /* 34 */ "ccons ::= DEFAULT LP expr RP", + /* 35 */ "ccons ::= DEFAULT PLUS scantok term", + /* 36 */ "ccons ::= DEFAULT MINUS scantok term", + /* 37 */ "ccons ::= DEFAULT scantok ID|INDEXED", + /* 38 */ "ccons ::= NOT NULL onconf", + /* 39 */ "ccons ::= PRIMARY KEY sortorder onconf autoinc", + /* 40 */ "ccons ::= UNIQUE onconf", + /* 41 */ "ccons ::= CHECK LP expr RP", + /* 42 */ "ccons ::= REFERENCES nm eidlist_opt refargs", + /* 43 */ "ccons ::= defer_subclause", + /* 44 */ "ccons ::= COLLATE ID|STRING", + /* 45 */ "generated ::= LP expr RP", + /* 46 */ "generated ::= LP expr RP ID", + /* 47 */ "autoinc ::=", + /* 48 */ "autoinc ::= AUTOINCR", + /* 49 */ "refargs ::=", + /* 50 */ "refargs ::= refargs refarg", + /* 51 */ "refarg ::= MATCH nm", + /* 52 */ "refarg ::= ON INSERT refact", + /* 53 */ "refarg ::= ON DELETE refact", + /* 54 */ "refarg ::= ON UPDATE refact", + /* 55 */ "refact ::= SET NULL", + /* 56 */ "refact ::= SET DEFAULT", + /* 57 */ "refact ::= CASCADE", + /* 58 */ "refact ::= RESTRICT", + /* 59 */ "refact ::= NO ACTION", + /* 60 */ "defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt", + /* 61 */ "defer_subclause ::= DEFERRABLE init_deferred_pred_opt", + /* 62 */ "init_deferred_pred_opt ::=", + /* 63 */ "init_deferred_pred_opt ::= INITIALLY DEFERRED", + /* 64 */ "init_deferred_pred_opt ::= INITIALLY IMMEDIATE", + /* 65 */ "conslist_opt ::=", + /* 66 */ "tconscomma ::= COMMA", + /* 67 */ "tcons ::= CONSTRAINT nm", + /* 68 */ "tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf", + /* 69 */ "tcons ::= UNIQUE LP sortlist RP onconf", + /* 70 */ "tcons ::= CHECK LP expr RP onconf", + /* 71 */ "tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt", + /* 72 */ "defer_subclause_opt ::=", + /* 73 */ "onconf ::=", + /* 74 */ "onconf ::= ON CONFLICT resolvetype", + /* 75 */ "orconf ::=", + /* 76 */ "orconf ::= OR resolvetype", + /* 77 */ "resolvetype ::= IGNORE", + /* 78 */ "resolvetype ::= REPLACE", + /* 79 */ "cmd ::= DROP TABLE ifexists fullname", + /* 80 */ "ifexists ::= IF EXISTS", + /* 81 */ "ifexists ::=", + /* 82 */ "cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select", + /* 83 */ "cmd ::= DROP VIEW ifexists fullname", + /* 84 */ "cmd ::= select", + /* 85 */ "select ::= WITH wqlist selectnowith", + /* 86 */ "select ::= WITH RECURSIVE wqlist selectnowith", + /* 87 */ "select ::= selectnowith", + /* 88 */ "selectnowith ::= selectnowith multiselect_op oneselect", + /* 89 */ "multiselect_op ::= UNION", + /* 90 */ "multiselect_op ::= UNION ALL", + /* 91 */ "multiselect_op ::= EXCEPT|INTERSECT", + /* 92 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt", + /* 93 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt", + /* 94 */ "values ::= VALUES LP nexprlist RP", + /* 95 */ "values ::= values COMMA LP nexprlist RP", + /* 96 */ "distinct ::= DISTINCT", + /* 97 */ "distinct ::= ALL", + /* 98 */ "distinct ::=", + /* 99 */ "sclp ::=", + /* 100 */ "selcollist ::= sclp scanpt expr scanpt as", + /* 101 */ "selcollist ::= sclp scanpt STAR", + /* 102 */ "selcollist ::= sclp scanpt nm DOT STAR", + /* 103 */ "as ::= AS nm", + /* 104 */ "as ::=", + /* 105 */ "from ::=", + /* 106 */ "from ::= FROM seltablist", + /* 107 */ "stl_prefix ::= seltablist joinop", + /* 108 */ "stl_prefix ::=", + /* 109 */ "seltablist ::= stl_prefix nm dbnm as on_using", + /* 110 */ "seltablist ::= stl_prefix nm dbnm as indexed_by on_using", + /* 111 */ "seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using", + /* 112 */ "seltablist ::= stl_prefix LP select RP as on_using", + /* 113 */ "seltablist ::= stl_prefix LP seltablist RP as on_using", + /* 114 */ "dbnm ::=", + /* 115 */ "dbnm ::= DOT nm", + /* 116 */ "fullname ::= nm", + /* 117 */ "fullname ::= nm DOT nm", + /* 118 */ "xfullname ::= nm", + /* 119 */ "xfullname ::= nm DOT nm", + /* 120 */ "xfullname ::= nm DOT nm AS nm", + /* 121 */ "xfullname ::= nm AS nm", + /* 122 */ "joinop ::= COMMA|JOIN", + /* 123 */ "joinop ::= JOIN_KW JOIN", + /* 124 */ "joinop ::= JOIN_KW nm JOIN", + /* 125 */ "joinop ::= JOIN_KW nm nm JOIN", + /* 126 */ "on_using ::= ON expr", + /* 127 */ "on_using ::= USING LP idlist RP", + /* 128 */ "on_using ::=", + /* 129 */ "indexed_opt ::=", + /* 130 */ "indexed_by ::= INDEXED BY nm", + /* 131 */ "indexed_by ::= NOT INDEXED", + /* 132 */ "orderby_opt ::=", + /* 133 */ "orderby_opt ::= ORDER BY sortlist", + /* 134 */ "sortlist ::= sortlist COMMA expr sortorder nulls", + /* 135 */ "sortlist ::= expr sortorder nulls", + /* 136 */ "sortorder ::= ASC", + /* 137 */ "sortorder ::= DESC", + /* 138 */ "sortorder ::=", + /* 139 */ "nulls ::= NULLS FIRST", + /* 140 */ "nulls ::= NULLS LAST", + /* 141 */ "nulls ::=", + /* 142 */ "groupby_opt ::=", + /* 143 */ "groupby_opt ::= GROUP BY nexprlist", + /* 144 */ "having_opt ::=", + /* 145 */ "having_opt ::= HAVING expr", + /* 146 */ "limit_opt ::=", + /* 147 */ "limit_opt ::= LIMIT expr", + /* 148 */ "limit_opt ::= LIMIT expr OFFSET expr", + /* 149 */ "limit_opt ::= LIMIT expr COMMA expr", + /* 150 */ "cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret", + /* 151 */ "where_opt ::=", + /* 152 */ "where_opt ::= WHERE expr", + /* 153 */ "where_opt_ret ::=", + /* 154 */ "where_opt_ret ::= WHERE expr", + /* 155 */ "where_opt_ret ::= RETURNING selcollist", + /* 156 */ "where_opt_ret ::= WHERE expr RETURNING selcollist", + /* 157 */ "cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret", + /* 158 */ "setlist ::= setlist COMMA nm EQ expr", + /* 159 */ "setlist ::= setlist COMMA LP idlist RP EQ expr", + /* 160 */ "setlist ::= nm EQ expr", + /* 161 */ "setlist ::= LP idlist RP EQ expr", + /* 162 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert", + /* 163 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning", + /* 164 */ "upsert ::=", + /* 165 */ "upsert ::= RETURNING selcollist", + /* 166 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert", + /* 167 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert", + /* 168 */ "upsert ::= ON CONFLICT DO NOTHING returning", + /* 169 */ "upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning", + /* 170 */ "returning ::= RETURNING selcollist", + /* 171 */ "insert_cmd ::= INSERT orconf", + /* 172 */ "insert_cmd ::= REPLACE", + /* 173 */ "idlist_opt ::=", + /* 174 */ "idlist_opt ::= LP idlist RP", + /* 175 */ "idlist ::= idlist COMMA nm", + /* 176 */ "idlist ::= nm", + /* 177 */ "expr ::= LP expr RP", + /* 178 */ "expr ::= ID|INDEXED|JOIN_KW", + /* 179 */ "expr ::= nm DOT nm", + /* 180 */ "expr ::= nm DOT nm DOT nm", + /* 181 */ "term ::= NULL|FLOAT|BLOB", + /* 182 */ "term ::= STRING", + /* 183 */ "term ::= INTEGER", + /* 184 */ "expr ::= VARIABLE", + /* 185 */ "expr ::= expr COLLATE ID|STRING", + /* 186 */ "expr ::= CAST LP expr AS typetoken RP", + /* 187 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP", + /* 188 */ "expr ::= ID|INDEXED|JOIN_KW LP STAR RP", + /* 189 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over", + /* 190 */ "expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over", + /* 191 */ "term ::= CTIME_KW", + /* 192 */ "expr ::= LP nexprlist COMMA expr RP", + /* 193 */ "expr ::= expr AND expr", + /* 194 */ "expr ::= expr OR expr", + /* 195 */ "expr ::= expr LT|GT|GE|LE expr", + /* 196 */ "expr ::= expr EQ|NE expr", + /* 197 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr", + /* 198 */ "expr ::= expr PLUS|MINUS expr", + /* 199 */ "expr ::= expr STAR|SLASH|REM expr", + /* 200 */ "expr ::= expr CONCAT expr", + /* 201 */ "likeop ::= NOT LIKE_KW|MATCH", + /* 202 */ "expr ::= expr likeop expr", + /* 203 */ "expr ::= expr likeop expr ESCAPE expr", + /* 204 */ "expr ::= expr ISNULL|NOTNULL", + /* 205 */ "expr ::= expr NOT NULL", + /* 206 */ "expr ::= expr IS expr", + /* 207 */ "expr ::= expr IS NOT expr", + /* 208 */ "expr ::= expr IS NOT DISTINCT FROM expr", + /* 209 */ "expr ::= expr IS DISTINCT FROM expr", + /* 210 */ "expr ::= NOT expr", + /* 211 */ "expr ::= BITNOT expr", + /* 212 */ "expr ::= PLUS|MINUS expr", + /* 213 */ "expr ::= expr PTR expr", + /* 214 */ "between_op ::= BETWEEN", + /* 215 */ "between_op ::= NOT BETWEEN", + /* 216 */ "expr ::= expr between_op expr AND expr", + /* 217 */ "in_op ::= IN", + /* 218 */ "in_op ::= NOT IN", + /* 219 */ "expr ::= expr in_op LP exprlist RP", + /* 220 */ "expr ::= LP select RP", + /* 221 */ "expr ::= expr in_op LP select RP", + /* 222 */ "expr ::= expr in_op nm dbnm paren_exprlist", + /* 223 */ "expr ::= EXISTS LP select RP", + /* 224 */ "expr ::= CASE case_operand case_exprlist case_else END", + /* 225 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr", + /* 226 */ "case_exprlist ::= WHEN expr THEN expr", + /* 227 */ "case_else ::= ELSE expr", + /* 228 */ "case_else ::=", + /* 229 */ "case_operand ::=", + /* 230 */ "exprlist ::=", + /* 231 */ "nexprlist ::= nexprlist COMMA expr", + /* 232 */ "nexprlist ::= expr", + /* 233 */ "paren_exprlist ::=", + /* 234 */ "paren_exprlist ::= LP exprlist RP", + /* 235 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt", + /* 236 */ "uniqueflag ::= UNIQUE", + /* 237 */ "uniqueflag ::=", + /* 238 */ "eidlist_opt ::=", + /* 239 */ "eidlist_opt ::= LP eidlist RP", + /* 240 */ "eidlist ::= eidlist COMMA nm collate sortorder", + /* 241 */ "eidlist ::= nm collate sortorder", + /* 242 */ "collate ::=", + /* 243 */ "collate ::= COLLATE ID|STRING", + /* 244 */ "cmd ::= DROP INDEX ifexists fullname", + /* 245 */ "cmd ::= VACUUM vinto", + /* 246 */ "cmd ::= VACUUM nm vinto", + /* 247 */ "vinto ::= INTO expr", + /* 248 */ "vinto ::=", + /* 249 */ "cmd ::= PRAGMA nm dbnm", + /* 250 */ "cmd ::= PRAGMA nm dbnm EQ nmnum", + /* 251 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP", + /* 252 */ "cmd ::= PRAGMA nm dbnm EQ minus_num", + /* 253 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP", + /* 254 */ "plus_num ::= PLUS INTEGER|FLOAT", + /* 255 */ "minus_num ::= MINUS INTEGER|FLOAT", + /* 256 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END", + /* 257 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause", + /* 258 */ "trigger_time ::= BEFORE|AFTER", + /* 259 */ "trigger_time ::= INSTEAD OF", + /* 260 */ "trigger_time ::=", + /* 261 */ "trigger_event ::= DELETE|INSERT", + /* 262 */ "trigger_event ::= UPDATE", + /* 263 */ "trigger_event ::= UPDATE OF idlist", + /* 264 */ "when_clause ::=", + /* 265 */ "when_clause ::= WHEN expr", + /* 266 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI", + /* 267 */ "trigger_cmd_list ::= trigger_cmd SEMI", + /* 268 */ "trnm ::= nm DOT nm", + /* 269 */ "tridxby ::= INDEXED BY nm", + /* 270 */ "tridxby ::= NOT INDEXED", + /* 271 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt", + /* 272 */ "trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt", + /* 273 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt", + /* 274 */ "trigger_cmd ::= scanpt select scanpt", + /* 275 */ "expr ::= RAISE LP IGNORE RP", + /* 276 */ "expr ::= RAISE LP raisetype COMMA nm RP", + /* 277 */ "raisetype ::= ROLLBACK", + /* 278 */ "raisetype ::= ABORT", + /* 279 */ "raisetype ::= FAIL", + /* 280 */ "cmd ::= DROP TRIGGER ifexists fullname", + /* 281 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt", + /* 282 */ "cmd ::= DETACH database_kw_opt expr", + /* 283 */ "key_opt ::=", + /* 284 */ "key_opt ::= KEY expr", + /* 285 */ "cmd ::= REINDEX", + /* 286 */ "cmd ::= REINDEX nm dbnm", + /* 287 */ "cmd ::= ANALYZE", + /* 288 */ "cmd ::= ANALYZE nm dbnm", + /* 289 */ "cmd ::= ALTER TABLE fullname RENAME TO nm", + /* 290 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist", + /* 291 */ "cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm", + /* 292 */ "add_column_fullname ::= fullname", + /* 293 */ "cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm", + /* 294 */ "cmd ::= create_vtab", + /* 295 */ "cmd ::= create_vtab LP vtabarglist RP", + /* 296 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm", + /* 297 */ "vtabarg ::=", + /* 298 */ "vtabargtoken ::= ANY", + /* 299 */ "vtabargtoken ::= lp anylist RP", + /* 300 */ "lp ::= LP", + /* 301 */ "with ::= WITH wqlist", + /* 302 */ "with ::= WITH RECURSIVE wqlist", + /* 303 */ "wqas ::= AS", + /* 304 */ "wqas ::= AS MATERIALIZED", + /* 305 */ "wqas ::= AS NOT MATERIALIZED", + /* 306 */ "wqitem ::= nm eidlist_opt wqas LP select RP", + /* 307 */ "wqlist ::= wqitem", + /* 308 */ "wqlist ::= wqlist COMMA wqitem", + /* 309 */ "windowdefn_list ::= windowdefn", + /* 310 */ "windowdefn_list ::= windowdefn_list COMMA windowdefn", + /* 311 */ "windowdefn ::= nm AS LP window RP", + /* 312 */ "window ::= PARTITION BY nexprlist orderby_opt frame_opt", + /* 313 */ "window ::= nm PARTITION BY nexprlist orderby_opt frame_opt", + /* 314 */ "window ::= ORDER BY sortlist frame_opt", + /* 315 */ "window ::= nm ORDER BY sortlist frame_opt", + /* 316 */ "window ::= frame_opt", + /* 317 */ "window ::= nm frame_opt", + /* 318 */ "frame_opt ::=", + /* 319 */ "frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt", + /* 320 */ "frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt", + /* 321 */ "range_or_rows ::= RANGE|ROWS|GROUPS", + /* 322 */ "frame_bound_s ::= frame_bound", + /* 323 */ "frame_bound_s ::= UNBOUNDED PRECEDING", + /* 324 */ "frame_bound_e ::= frame_bound", + /* 325 */ "frame_bound_e ::= UNBOUNDED FOLLOWING", + /* 326 */ "frame_bound ::= expr PRECEDING|FOLLOWING", + /* 327 */ "frame_bound ::= CURRENT ROW", + /* 328 */ "frame_exclude_opt ::=", + /* 329 */ "frame_exclude_opt ::= EXCLUDE frame_exclude", + /* 330 */ "frame_exclude ::= NO OTHERS", + /* 331 */ "frame_exclude ::= CURRENT ROW", + /* 332 */ "frame_exclude ::= GROUP|TIES", + /* 333 */ "window_clause ::= WINDOW windowdefn_list", + /* 334 */ "filter_over ::= filter_clause over_clause", + /* 335 */ "filter_over ::= over_clause", + /* 336 */ "filter_over ::= filter_clause", + /* 337 */ "over_clause ::= OVER LP window RP", + /* 338 */ "over_clause ::= OVER nm", + /* 339 */ "filter_clause ::= FILTER LP WHERE expr RP", + /* 340 */ "input ::= cmdlist", + /* 341 */ "cmdlist ::= cmdlist ecmd", + /* 342 */ "cmdlist ::= ecmd", + /* 343 */ "ecmd ::= SEMI", + /* 344 */ "ecmd ::= cmdx SEMI", + /* 345 */ "ecmd ::= explain cmdx SEMI", + /* 346 */ "trans_opt ::=", + /* 347 */ "trans_opt ::= TRANSACTION", + /* 348 */ "trans_opt ::= TRANSACTION nm", + /* 349 */ "savepoint_opt ::= SAVEPOINT", + /* 350 */ "savepoint_opt ::=", + /* 351 */ "cmd ::= create_table create_table_args", + /* 352 */ "table_option_set ::= table_option", + /* 353 */ "columnlist ::= columnlist COMMA columnname carglist", + /* 354 */ "columnlist ::= columnname carglist", + /* 355 */ "nm ::= ID|INDEXED|JOIN_KW", + /* 356 */ "nm ::= STRING", + /* 357 */ "typetoken ::= typename", + /* 358 */ "typename ::= ID|STRING", + /* 359 */ "signed ::= plus_num", + /* 360 */ "signed ::= minus_num", + /* 361 */ "carglist ::= carglist ccons", + /* 362 */ "carglist ::=", + /* 363 */ "ccons ::= NULL onconf", + /* 364 */ "ccons ::= GENERATED ALWAYS AS generated", + /* 365 */ "ccons ::= AS generated", + /* 366 */ "conslist_opt ::= COMMA conslist", + /* 367 */ "conslist ::= conslist tconscomma tcons", + /* 368 */ "conslist ::= tcons", + /* 369 */ "tconscomma ::=", + /* 370 */ "defer_subclause_opt ::= defer_subclause", + /* 371 */ "resolvetype ::= raisetype", + /* 372 */ "selectnowith ::= oneselect", + /* 373 */ "oneselect ::= values", + /* 374 */ "sclp ::= selcollist COMMA", + /* 375 */ "as ::= ID|STRING", + /* 376 */ "indexed_opt ::= indexed_by", + /* 377 */ "returning ::=", + /* 378 */ "expr ::= term", + /* 379 */ "likeop ::= LIKE_KW|MATCH", + /* 380 */ "case_operand ::= expr", + /* 381 */ "exprlist ::= nexprlist", + /* 382 */ "nmnum ::= plus_num", + /* 383 */ "nmnum ::= nm", + /* 384 */ "nmnum ::= ON", + /* 385 */ "nmnum ::= DELETE", + /* 386 */ "nmnum ::= DEFAULT", + /* 387 */ "plus_num ::= INTEGER|FLOAT", + /* 388 */ "foreach_clause ::=", + /* 389 */ "foreach_clause ::= FOR EACH ROW", + /* 390 */ "trnm ::= nm", + /* 391 */ "tridxby ::=", + /* 392 */ "database_kw_opt ::= DATABASE", + /* 393 */ "database_kw_opt ::=", + /* 394 */ "kwcolumn_opt ::=", + /* 395 */ "kwcolumn_opt ::= COLUMNKW", + /* 396 */ "vtabarglist ::= vtabarg", + /* 397 */ "vtabarglist ::= vtabarglist COMMA vtabarg", + /* 398 */ "vtabarg ::= vtabarg vtabargtoken", + /* 399 */ "anylist ::=", + /* 400 */ "anylist ::= anylist LP anylist RP", + /* 401 */ "anylist ::= anylist ANY", + /* 402 */ "with ::=", +}; +#endif /* NDEBUG */ + + +#if YYSTACKDEPTH<=0 +/* +** Try to increase the size of the parser stack. Return the number +** of errors. Return 0 on success. +*/ +static int yyGrowStack(yyParser *p){ + int newSize; + int idx; + yyStackEntry *pNew; + + newSize = p->yystksz*2 + 100; + idx = p->yytos ? (int)(p->yytos - p->yystack) : 0; + if( p->yystack==&p->yystk0 ){ + pNew = malloc(newSize*sizeof(pNew[0])); + if( pNew ) pNew[0] = p->yystk0; + }else{ + pNew = realloc(p->yystack, newSize*sizeof(pNew[0])); + } + if( pNew ){ + p->yystack = pNew; + p->yytos = &p->yystack[idx]; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sStack grows from %d to %d entries.\n", + yyTracePrompt, p->yystksz, newSize); + } +#endif + p->yystksz = newSize; + } + return pNew==0; +} +#endif + +/* Datatype of the argument to the memory allocated passed as the +** second argument to sqlite3ParserAlloc() below. This can be changed by +** putting an appropriate #define in the %include section of the input +** grammar. +*/ +#ifndef YYMALLOCARGTYPE +# define YYMALLOCARGTYPE size_t +#endif + +/* Initialize a new parser that has already been allocated. +*/ +SQLITE_PRIVATE void sqlite3ParserInit(void *yypRawParser sqlite3ParserCTX_PDECL){ + yyParser *yypParser = (yyParser*)yypRawParser; + sqlite3ParserCTX_STORE +#ifdef YYTRACKMAXSTACKDEPTH + yypParser->yyhwm = 0; +#endif +#if YYSTACKDEPTH<=0 + yypParser->yytos = NULL; + yypParser->yystack = NULL; + yypParser->yystksz = 0; + if( yyGrowStack(yypParser) ){ + yypParser->yystack = &yypParser->yystk0; + yypParser->yystksz = 1; + } +#endif +#ifndef YYNOERRORRECOVERY + yypParser->yyerrcnt = -1; +#endif + yypParser->yytos = yypParser->yystack; + yypParser->yystack[0].stateno = 0; + yypParser->yystack[0].major = 0; +#if YYSTACKDEPTH>0 + yypParser->yystackEnd = &yypParser->yystack[YYSTACKDEPTH-1]; +#endif +} + +#ifndef sqlite3Parser_ENGINEALWAYSONSTACK +/* +** This function allocates a new parser. +** The only argument is a pointer to a function which works like +** malloc. +** +** Inputs: +** A pointer to the function used to allocate memory. +** +** Outputs: +** A pointer to a parser. This pointer is used in subsequent calls +** to sqlite3Parser and sqlite3ParserFree. +*/ +SQLITE_PRIVATE void *sqlite3ParserAlloc(void *(*mallocProc)(YYMALLOCARGTYPE) sqlite3ParserCTX_PDECL){ + yyParser *yypParser; + yypParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) ); + if( yypParser ){ + sqlite3ParserCTX_STORE + sqlite3ParserInit(yypParser sqlite3ParserCTX_PARAM); + } + return (void*)yypParser; +} +#endif /* sqlite3Parser_ENGINEALWAYSONSTACK */ + + +/* The following function deletes the "minor type" or semantic value +** associated with a symbol. The symbol can be either a terminal +** or nonterminal. "yymajor" is the symbol code, and "yypminor" is +** a pointer to the value to be deleted. The code used to do the +** deletions is derived from the %destructor and/or %token_destructor +** directives of the input grammar. +*/ +static void yy_destructor( + yyParser *yypParser, /* The parser */ + YYCODETYPE yymajor, /* Type code for object to destroy */ + YYMINORTYPE *yypminor /* The object to be destroyed */ +){ + sqlite3ParserARG_FETCH + sqlite3ParserCTX_FETCH + switch( yymajor ){ + /* Here is inserted the actions which take place when a + ** terminal or non-terminal is destroyed. This can happen + ** when the symbol is popped from the stack during a + ** reduce or during error processing or when a parser is + ** being destroyed before it is finished parsing. + ** + ** Note: during a reduce, the only symbols destroyed are those + ** which appear on the RHS of the rule, but which are *not* used + ** inside the C code. + */ +/********* Begin destructor definitions ***************************************/ + case 204: /* select */ + case 239: /* selectnowith */ + case 240: /* oneselect */ + case 252: /* values */ +{ +sqlite3SelectDelete(pParse->db, (yypminor->yy47)); +} + break; + case 216: /* term */ + case 217: /* expr */ + case 246: /* where_opt */ + case 248: /* having_opt */ + case 267: /* where_opt_ret */ + case 278: /* case_operand */ + case 280: /* case_else */ + case 283: /* vinto */ + case 290: /* when_clause */ + case 295: /* key_opt */ + case 311: /* filter_clause */ +{ +sqlite3ExprDelete(pParse->db, (yypminor->yy528)); +} + break; + case 221: /* eidlist_opt */ + case 231: /* sortlist */ + case 232: /* eidlist */ + case 244: /* selcollist */ + case 247: /* groupby_opt */ + case 249: /* orderby_opt */ + case 253: /* nexprlist */ + case 254: /* sclp */ + case 261: /* exprlist */ + case 268: /* setlist */ + case 277: /* paren_exprlist */ + case 279: /* case_exprlist */ + case 310: /* part_opt */ +{ +sqlite3ExprListDelete(pParse->db, (yypminor->yy322)); +} + break; + case 238: /* fullname */ + case 245: /* from */ + case 256: /* seltablist */ + case 257: /* stl_prefix */ + case 262: /* xfullname */ +{ +sqlite3SrcListDelete(pParse->db, (yypminor->yy131)); +} + break; + case 241: /* wqlist */ +{ +sqlite3WithDelete(pParse->db, (yypminor->yy521)); +} + break; + case 251: /* window_clause */ + case 306: /* windowdefn_list */ +{ +sqlite3WindowListDelete(pParse->db, (yypminor->yy41)); +} + break; + case 263: /* idlist */ + case 270: /* idlist_opt */ +{ +sqlite3IdListDelete(pParse->db, (yypminor->yy254)); +} + break; + case 273: /* filter_over */ + case 307: /* windowdefn */ + case 308: /* window */ + case 309: /* frame_opt */ + case 312: /* over_clause */ +{ +sqlite3WindowDelete(pParse->db, (yypminor->yy41)); +} + break; + case 286: /* trigger_cmd_list */ + case 291: /* trigger_cmd */ +{ +sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy33)); +} + break; + case 288: /* trigger_event */ +{ +sqlite3IdListDelete(pParse->db, (yypminor->yy180).b); +} + break; + case 314: /* frame_bound */ + case 315: /* frame_bound_s */ + case 316: /* frame_bound_e */ +{ +sqlite3ExprDelete(pParse->db, (yypminor->yy595).pExpr); +} + break; +/********* End destructor definitions *****************************************/ + default: break; /* If no destructor action specified: do nothing */ + } +} + +/* +** Pop the parser's stack once. +** +** If there is a destructor routine associated with the token which +** is popped from the stack, then call it. +*/ +static void yy_pop_parser_stack(yyParser *pParser){ + yyStackEntry *yytos; + assert( pParser->yytos!=0 ); + assert( pParser->yytos > pParser->yystack ); + yytos = pParser->yytos--; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sPopping %s\n", + yyTracePrompt, + yyTokenName[yytos->major]); + } +#endif + yy_destructor(pParser, yytos->major, &yytos->minor); +} + +/* +** Clear all secondary memory allocations from the parser +*/ +SQLITE_PRIVATE void sqlite3ParserFinalize(void *p){ + yyParser *pParser = (yyParser*)p; + while( pParser->yytos>pParser->yystack ) yy_pop_parser_stack(pParser); +#if YYSTACKDEPTH<=0 + if( pParser->yystack!=&pParser->yystk0 ) free(pParser->yystack); +#endif +} + +#ifndef sqlite3Parser_ENGINEALWAYSONSTACK +/* +** Deallocate and destroy a parser. Destructors are called for +** all stack elements before shutting the parser down. +** +** If the YYPARSEFREENEVERNULL macro exists (for example because it +** is defined in a %include section of the input grammar) then it is +** assumed that the input pointer is never NULL. +*/ +SQLITE_PRIVATE void sqlite3ParserFree( + void *p, /* The parser to be deleted */ + void (*freeProc)(void*) /* Function used to reclaim memory */ +){ +#ifndef YYPARSEFREENEVERNULL + if( p==0 ) return; +#endif + sqlite3ParserFinalize(p); + (*freeProc)(p); +} +#endif /* sqlite3Parser_ENGINEALWAYSONSTACK */ + +/* +** Return the peak depth of the stack for a parser. +*/ +#ifdef YYTRACKMAXSTACKDEPTH +SQLITE_PRIVATE int sqlite3ParserStackPeak(void *p){ + yyParser *pParser = (yyParser*)p; + return pParser->yyhwm; +} +#endif + +/* This array of booleans keeps track of the parser statement +** coverage. The element yycoverage[X][Y] is set when the parser +** is in state X and has a lookahead token Y. In a well-tested +** systems, every element of this matrix should end up being set. +*/ +#if defined(YYCOVERAGE) +static unsigned char yycoverage[YYNSTATE][YYNTOKEN]; +#endif + +/* +** Write into out a description of every state/lookahead combination that +** +** (1) has not been used by the parser, and +** (2) is not a syntax error. +** +** Return the number of missed state/lookahead combinations. +*/ +#if defined(YYCOVERAGE) +SQLITE_PRIVATE int sqlite3ParserCoverage(FILE *out){ + int stateno, iLookAhead, i; + int nMissed = 0; + for(stateno=0; statenoYY_MAX_SHIFT ) return stateno; + assert( stateno <= YY_SHIFT_COUNT ); +#if defined(YYCOVERAGE) + yycoverage[stateno][iLookAhead] = 1; +#endif + do{ + i = yy_shift_ofst[stateno]; + assert( i>=0 ); + assert( i<=YY_ACTTAB_COUNT ); + assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD ); + assert( iLookAhead!=YYNOCODE ); + assert( iLookAhead < YYNTOKEN ); + i += iLookAhead; + assert( i<(int)YY_NLOOKAHEAD ); + if( yy_lookahead[i]!=iLookAhead ){ +#ifdef YYFALLBACK + YYCODETYPE iFallback; /* Fallback token */ + assert( iLookAhead %s\n", + yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]); + } +#endif + assert( yyFallback[iFallback]==0 ); /* Fallback loop must terminate */ + iLookAhead = iFallback; + continue; + } +#endif +#ifdef YYWILDCARD + { + int j = i - iLookAhead + YYWILDCARD; + assert( j<(int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])) ); + if( yy_lookahead[j]==YYWILDCARD && iLookAhead>0 ){ +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n", + yyTracePrompt, yyTokenName[iLookAhead], + yyTokenName[YYWILDCARD]); + } +#endif /* NDEBUG */ + return yy_action[j]; + } + } +#endif /* YYWILDCARD */ + return yy_default[stateno]; + }else{ + assert( i>=0 && i<(int)(sizeof(yy_action)/sizeof(yy_action[0])) ); + return yy_action[i]; + } + }while(1); +} + +/* +** Find the appropriate action for a parser given the non-terminal +** look-ahead token iLookAhead. +*/ +static YYACTIONTYPE yy_find_reduce_action( + YYACTIONTYPE stateno, /* Current state number */ + YYCODETYPE iLookAhead /* The look-ahead token */ +){ + int i; +#ifdef YYERRORSYMBOL + if( stateno>YY_REDUCE_COUNT ){ + return yy_default[stateno]; + } +#else + assert( stateno<=YY_REDUCE_COUNT ); +#endif + i = yy_reduce_ofst[stateno]; + assert( iLookAhead!=YYNOCODE ); + i += iLookAhead; +#ifdef YYERRORSYMBOL + if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){ + return yy_default[stateno]; + } +#else + assert( i>=0 && iyytos>yypParser->yystack ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will execute if the parser + ** stack every overflows */ +/******** Begin %stack_overflow code ******************************************/ + + sqlite3ErrorMsg(pParse, "parser stack overflow"); +/******** End %stack_overflow code ********************************************/ + sqlite3ParserARG_STORE /* Suppress warning about unused %extra_argument var */ + sqlite3ParserCTX_STORE +} + +/* +** Print tracing information for a SHIFT action +*/ +#ifndef NDEBUG +static void yyTraceShift(yyParser *yypParser, int yyNewState, const char *zTag){ + if( yyTraceFILE ){ + if( yyNewStateyytos->major], + yyNewState); + }else{ + fprintf(yyTraceFILE,"%s%s '%s', pending reduce %d\n", + yyTracePrompt, zTag, yyTokenName[yypParser->yytos->major], + yyNewState - YY_MIN_REDUCE); + } + } +} +#else +# define yyTraceShift(X,Y,Z) +#endif + +/* +** Perform a shift action. +*/ +static void yy_shift( + yyParser *yypParser, /* The parser to be shifted */ + YYACTIONTYPE yyNewState, /* The new state to shift in */ + YYCODETYPE yyMajor, /* The major token to shift in */ + sqlite3ParserTOKENTYPE yyMinor /* The minor token to shift in */ +){ + yyStackEntry *yytos; + yypParser->yytos++; +#ifdef YYTRACKMAXSTACKDEPTH + if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){ + yypParser->yyhwm++; + assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack) ); + } +#endif +#if YYSTACKDEPTH>0 + if( yypParser->yytos>yypParser->yystackEnd ){ + yypParser->yytos--; + yyStackOverflow(yypParser); + return; + } +#else + if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz] ){ + if( yyGrowStack(yypParser) ){ + yypParser->yytos--; + yyStackOverflow(yypParser); + return; + } + } +#endif + if( yyNewState > YY_MAX_SHIFT ){ + yyNewState += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE; + } + yytos = yypParser->yytos; + yytos->stateno = yyNewState; + yytos->major = yyMajor; + yytos->minor.yy0 = yyMinor; + yyTraceShift(yypParser, yyNewState, "Shift"); +} + +/* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side +** of that rule */ +static const YYCODETYPE yyRuleInfoLhs[] = { + 189, /* (0) explain ::= EXPLAIN */ + 189, /* (1) explain ::= EXPLAIN QUERY PLAN */ + 188, /* (2) cmdx ::= cmd */ + 190, /* (3) cmd ::= BEGIN transtype trans_opt */ + 191, /* (4) transtype ::= */ + 191, /* (5) transtype ::= DEFERRED */ + 191, /* (6) transtype ::= IMMEDIATE */ + 191, /* (7) transtype ::= EXCLUSIVE */ + 190, /* (8) cmd ::= COMMIT|END trans_opt */ + 190, /* (9) cmd ::= ROLLBACK trans_opt */ + 190, /* (10) cmd ::= SAVEPOINT nm */ + 190, /* (11) cmd ::= RELEASE savepoint_opt nm */ + 190, /* (12) cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */ + 195, /* (13) create_table ::= createkw temp TABLE ifnotexists nm dbnm */ + 197, /* (14) createkw ::= CREATE */ + 199, /* (15) ifnotexists ::= */ + 199, /* (16) ifnotexists ::= IF NOT EXISTS */ + 198, /* (17) temp ::= TEMP */ + 198, /* (18) temp ::= */ + 196, /* (19) create_table_args ::= LP columnlist conslist_opt RP table_option_set */ + 196, /* (20) create_table_args ::= AS select */ + 203, /* (21) table_option_set ::= */ + 203, /* (22) table_option_set ::= table_option_set COMMA table_option */ + 205, /* (23) table_option ::= WITHOUT nm */ + 205, /* (24) table_option ::= nm */ + 206, /* (25) columnname ::= nm typetoken */ + 208, /* (26) typetoken ::= */ + 208, /* (27) typetoken ::= typename LP signed RP */ + 208, /* (28) typetoken ::= typename LP signed COMMA signed RP */ + 209, /* (29) typename ::= typename ID|STRING */ + 213, /* (30) scanpt ::= */ + 214, /* (31) scantok ::= */ + 215, /* (32) ccons ::= CONSTRAINT nm */ + 215, /* (33) ccons ::= DEFAULT scantok term */ + 215, /* (34) ccons ::= DEFAULT LP expr RP */ + 215, /* (35) ccons ::= DEFAULT PLUS scantok term */ + 215, /* (36) ccons ::= DEFAULT MINUS scantok term */ + 215, /* (37) ccons ::= DEFAULT scantok ID|INDEXED */ + 215, /* (38) ccons ::= NOT NULL onconf */ + 215, /* (39) ccons ::= PRIMARY KEY sortorder onconf autoinc */ + 215, /* (40) ccons ::= UNIQUE onconf */ + 215, /* (41) ccons ::= CHECK LP expr RP */ + 215, /* (42) ccons ::= REFERENCES nm eidlist_opt refargs */ + 215, /* (43) ccons ::= defer_subclause */ + 215, /* (44) ccons ::= COLLATE ID|STRING */ + 224, /* (45) generated ::= LP expr RP */ + 224, /* (46) generated ::= LP expr RP ID */ + 220, /* (47) autoinc ::= */ + 220, /* (48) autoinc ::= AUTOINCR */ + 222, /* (49) refargs ::= */ + 222, /* (50) refargs ::= refargs refarg */ + 225, /* (51) refarg ::= MATCH nm */ + 225, /* (52) refarg ::= ON INSERT refact */ + 225, /* (53) refarg ::= ON DELETE refact */ + 225, /* (54) refarg ::= ON UPDATE refact */ + 226, /* (55) refact ::= SET NULL */ + 226, /* (56) refact ::= SET DEFAULT */ + 226, /* (57) refact ::= CASCADE */ + 226, /* (58) refact ::= RESTRICT */ + 226, /* (59) refact ::= NO ACTION */ + 223, /* (60) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */ + 223, /* (61) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */ + 227, /* (62) init_deferred_pred_opt ::= */ + 227, /* (63) init_deferred_pred_opt ::= INITIALLY DEFERRED */ + 227, /* (64) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ + 202, /* (65) conslist_opt ::= */ + 229, /* (66) tconscomma ::= COMMA */ + 230, /* (67) tcons ::= CONSTRAINT nm */ + 230, /* (68) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */ + 230, /* (69) tcons ::= UNIQUE LP sortlist RP onconf */ + 230, /* (70) tcons ::= CHECK LP expr RP onconf */ + 230, /* (71) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */ + 233, /* (72) defer_subclause_opt ::= */ + 218, /* (73) onconf ::= */ + 218, /* (74) onconf ::= ON CONFLICT resolvetype */ + 234, /* (75) orconf ::= */ + 234, /* (76) orconf ::= OR resolvetype */ + 235, /* (77) resolvetype ::= IGNORE */ + 235, /* (78) resolvetype ::= REPLACE */ + 190, /* (79) cmd ::= DROP TABLE ifexists fullname */ + 237, /* (80) ifexists ::= IF EXISTS */ + 237, /* (81) ifexists ::= */ + 190, /* (82) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */ + 190, /* (83) cmd ::= DROP VIEW ifexists fullname */ + 190, /* (84) cmd ::= select */ + 204, /* (85) select ::= WITH wqlist selectnowith */ + 204, /* (86) select ::= WITH RECURSIVE wqlist selectnowith */ + 204, /* (87) select ::= selectnowith */ + 239, /* (88) selectnowith ::= selectnowith multiselect_op oneselect */ + 242, /* (89) multiselect_op ::= UNION */ + 242, /* (90) multiselect_op ::= UNION ALL */ + 242, /* (91) multiselect_op ::= EXCEPT|INTERSECT */ + 240, /* (92) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */ + 240, /* (93) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */ + 252, /* (94) values ::= VALUES LP nexprlist RP */ + 252, /* (95) values ::= values COMMA LP nexprlist RP */ + 243, /* (96) distinct ::= DISTINCT */ + 243, /* (97) distinct ::= ALL */ + 243, /* (98) distinct ::= */ + 254, /* (99) sclp ::= */ + 244, /* (100) selcollist ::= sclp scanpt expr scanpt as */ + 244, /* (101) selcollist ::= sclp scanpt STAR */ + 244, /* (102) selcollist ::= sclp scanpt nm DOT STAR */ + 255, /* (103) as ::= AS nm */ + 255, /* (104) as ::= */ + 245, /* (105) from ::= */ + 245, /* (106) from ::= FROM seltablist */ + 257, /* (107) stl_prefix ::= seltablist joinop */ + 257, /* (108) stl_prefix ::= */ + 256, /* (109) seltablist ::= stl_prefix nm dbnm as on_using */ + 256, /* (110) seltablist ::= stl_prefix nm dbnm as indexed_by on_using */ + 256, /* (111) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */ + 256, /* (112) seltablist ::= stl_prefix LP select RP as on_using */ + 256, /* (113) seltablist ::= stl_prefix LP seltablist RP as on_using */ + 200, /* (114) dbnm ::= */ + 200, /* (115) dbnm ::= DOT nm */ + 238, /* (116) fullname ::= nm */ + 238, /* (117) fullname ::= nm DOT nm */ + 262, /* (118) xfullname ::= nm */ + 262, /* (119) xfullname ::= nm DOT nm */ + 262, /* (120) xfullname ::= nm DOT nm AS nm */ + 262, /* (121) xfullname ::= nm AS nm */ + 258, /* (122) joinop ::= COMMA|JOIN */ + 258, /* (123) joinop ::= JOIN_KW JOIN */ + 258, /* (124) joinop ::= JOIN_KW nm JOIN */ + 258, /* (125) joinop ::= JOIN_KW nm nm JOIN */ + 259, /* (126) on_using ::= ON expr */ + 259, /* (127) on_using ::= USING LP idlist RP */ + 259, /* (128) on_using ::= */ + 264, /* (129) indexed_opt ::= */ + 260, /* (130) indexed_by ::= INDEXED BY nm */ + 260, /* (131) indexed_by ::= NOT INDEXED */ + 249, /* (132) orderby_opt ::= */ + 249, /* (133) orderby_opt ::= ORDER BY sortlist */ + 231, /* (134) sortlist ::= sortlist COMMA expr sortorder nulls */ + 231, /* (135) sortlist ::= expr sortorder nulls */ + 219, /* (136) sortorder ::= ASC */ + 219, /* (137) sortorder ::= DESC */ + 219, /* (138) sortorder ::= */ + 265, /* (139) nulls ::= NULLS FIRST */ + 265, /* (140) nulls ::= NULLS LAST */ + 265, /* (141) nulls ::= */ + 247, /* (142) groupby_opt ::= */ + 247, /* (143) groupby_opt ::= GROUP BY nexprlist */ + 248, /* (144) having_opt ::= */ + 248, /* (145) having_opt ::= HAVING expr */ + 250, /* (146) limit_opt ::= */ + 250, /* (147) limit_opt ::= LIMIT expr */ + 250, /* (148) limit_opt ::= LIMIT expr OFFSET expr */ + 250, /* (149) limit_opt ::= LIMIT expr COMMA expr */ + 190, /* (150) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */ + 246, /* (151) where_opt ::= */ + 246, /* (152) where_opt ::= WHERE expr */ + 267, /* (153) where_opt_ret ::= */ + 267, /* (154) where_opt_ret ::= WHERE expr */ + 267, /* (155) where_opt_ret ::= RETURNING selcollist */ + 267, /* (156) where_opt_ret ::= WHERE expr RETURNING selcollist */ + 190, /* (157) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */ + 268, /* (158) setlist ::= setlist COMMA nm EQ expr */ + 268, /* (159) setlist ::= setlist COMMA LP idlist RP EQ expr */ + 268, /* (160) setlist ::= nm EQ expr */ + 268, /* (161) setlist ::= LP idlist RP EQ expr */ + 190, /* (162) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */ + 190, /* (163) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */ + 271, /* (164) upsert ::= */ + 271, /* (165) upsert ::= RETURNING selcollist */ + 271, /* (166) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */ + 271, /* (167) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */ + 271, /* (168) upsert ::= ON CONFLICT DO NOTHING returning */ + 271, /* (169) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */ + 272, /* (170) returning ::= RETURNING selcollist */ + 269, /* (171) insert_cmd ::= INSERT orconf */ + 269, /* (172) insert_cmd ::= REPLACE */ + 270, /* (173) idlist_opt ::= */ + 270, /* (174) idlist_opt ::= LP idlist RP */ + 263, /* (175) idlist ::= idlist COMMA nm */ + 263, /* (176) idlist ::= nm */ + 217, /* (177) expr ::= LP expr RP */ + 217, /* (178) expr ::= ID|INDEXED|JOIN_KW */ + 217, /* (179) expr ::= nm DOT nm */ + 217, /* (180) expr ::= nm DOT nm DOT nm */ + 216, /* (181) term ::= NULL|FLOAT|BLOB */ + 216, /* (182) term ::= STRING */ + 216, /* (183) term ::= INTEGER */ + 217, /* (184) expr ::= VARIABLE */ + 217, /* (185) expr ::= expr COLLATE ID|STRING */ + 217, /* (186) expr ::= CAST LP expr AS typetoken RP */ + 217, /* (187) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */ + 217, /* (188) expr ::= ID|INDEXED|JOIN_KW LP STAR RP */ + 217, /* (189) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */ + 217, /* (190) expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */ + 216, /* (191) term ::= CTIME_KW */ + 217, /* (192) expr ::= LP nexprlist COMMA expr RP */ + 217, /* (193) expr ::= expr AND expr */ + 217, /* (194) expr ::= expr OR expr */ + 217, /* (195) expr ::= expr LT|GT|GE|LE expr */ + 217, /* (196) expr ::= expr EQ|NE expr */ + 217, /* (197) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ + 217, /* (198) expr ::= expr PLUS|MINUS expr */ + 217, /* (199) expr ::= expr STAR|SLASH|REM expr */ + 217, /* (200) expr ::= expr CONCAT expr */ + 274, /* (201) likeop ::= NOT LIKE_KW|MATCH */ + 217, /* (202) expr ::= expr likeop expr */ + 217, /* (203) expr ::= expr likeop expr ESCAPE expr */ + 217, /* (204) expr ::= expr ISNULL|NOTNULL */ + 217, /* (205) expr ::= expr NOT NULL */ + 217, /* (206) expr ::= expr IS expr */ + 217, /* (207) expr ::= expr IS NOT expr */ + 217, /* (208) expr ::= expr IS NOT DISTINCT FROM expr */ + 217, /* (209) expr ::= expr IS DISTINCT FROM expr */ + 217, /* (210) expr ::= NOT expr */ + 217, /* (211) expr ::= BITNOT expr */ + 217, /* (212) expr ::= PLUS|MINUS expr */ + 217, /* (213) expr ::= expr PTR expr */ + 275, /* (214) between_op ::= BETWEEN */ + 275, /* (215) between_op ::= NOT BETWEEN */ + 217, /* (216) expr ::= expr between_op expr AND expr */ + 276, /* (217) in_op ::= IN */ + 276, /* (218) in_op ::= NOT IN */ + 217, /* (219) expr ::= expr in_op LP exprlist RP */ + 217, /* (220) expr ::= LP select RP */ + 217, /* (221) expr ::= expr in_op LP select RP */ + 217, /* (222) expr ::= expr in_op nm dbnm paren_exprlist */ + 217, /* (223) expr ::= EXISTS LP select RP */ + 217, /* (224) expr ::= CASE case_operand case_exprlist case_else END */ + 279, /* (225) case_exprlist ::= case_exprlist WHEN expr THEN expr */ + 279, /* (226) case_exprlist ::= WHEN expr THEN expr */ + 280, /* (227) case_else ::= ELSE expr */ + 280, /* (228) case_else ::= */ + 278, /* (229) case_operand ::= */ + 261, /* (230) exprlist ::= */ + 253, /* (231) nexprlist ::= nexprlist COMMA expr */ + 253, /* (232) nexprlist ::= expr */ + 277, /* (233) paren_exprlist ::= */ + 277, /* (234) paren_exprlist ::= LP exprlist RP */ + 190, /* (235) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */ + 281, /* (236) uniqueflag ::= UNIQUE */ + 281, /* (237) uniqueflag ::= */ + 221, /* (238) eidlist_opt ::= */ + 221, /* (239) eidlist_opt ::= LP eidlist RP */ + 232, /* (240) eidlist ::= eidlist COMMA nm collate sortorder */ + 232, /* (241) eidlist ::= nm collate sortorder */ + 282, /* (242) collate ::= */ + 282, /* (243) collate ::= COLLATE ID|STRING */ + 190, /* (244) cmd ::= DROP INDEX ifexists fullname */ + 190, /* (245) cmd ::= VACUUM vinto */ + 190, /* (246) cmd ::= VACUUM nm vinto */ + 283, /* (247) vinto ::= INTO expr */ + 283, /* (248) vinto ::= */ + 190, /* (249) cmd ::= PRAGMA nm dbnm */ + 190, /* (250) cmd ::= PRAGMA nm dbnm EQ nmnum */ + 190, /* (251) cmd ::= PRAGMA nm dbnm LP nmnum RP */ + 190, /* (252) cmd ::= PRAGMA nm dbnm EQ minus_num */ + 190, /* (253) cmd ::= PRAGMA nm dbnm LP minus_num RP */ + 211, /* (254) plus_num ::= PLUS INTEGER|FLOAT */ + 212, /* (255) minus_num ::= MINUS INTEGER|FLOAT */ + 190, /* (256) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */ + 285, /* (257) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */ + 287, /* (258) trigger_time ::= BEFORE|AFTER */ + 287, /* (259) trigger_time ::= INSTEAD OF */ + 287, /* (260) trigger_time ::= */ + 288, /* (261) trigger_event ::= DELETE|INSERT */ + 288, /* (262) trigger_event ::= UPDATE */ + 288, /* (263) trigger_event ::= UPDATE OF idlist */ + 290, /* (264) when_clause ::= */ + 290, /* (265) when_clause ::= WHEN expr */ + 286, /* (266) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */ + 286, /* (267) trigger_cmd_list ::= trigger_cmd SEMI */ + 292, /* (268) trnm ::= nm DOT nm */ + 293, /* (269) tridxby ::= INDEXED BY nm */ + 293, /* (270) tridxby ::= NOT INDEXED */ + 291, /* (271) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */ + 291, /* (272) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */ + 291, /* (273) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */ + 291, /* (274) trigger_cmd ::= scanpt select scanpt */ + 217, /* (275) expr ::= RAISE LP IGNORE RP */ + 217, /* (276) expr ::= RAISE LP raisetype COMMA nm RP */ + 236, /* (277) raisetype ::= ROLLBACK */ + 236, /* (278) raisetype ::= ABORT */ + 236, /* (279) raisetype ::= FAIL */ + 190, /* (280) cmd ::= DROP TRIGGER ifexists fullname */ + 190, /* (281) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ + 190, /* (282) cmd ::= DETACH database_kw_opt expr */ + 295, /* (283) key_opt ::= */ + 295, /* (284) key_opt ::= KEY expr */ + 190, /* (285) cmd ::= REINDEX */ + 190, /* (286) cmd ::= REINDEX nm dbnm */ + 190, /* (287) cmd ::= ANALYZE */ + 190, /* (288) cmd ::= ANALYZE nm dbnm */ + 190, /* (289) cmd ::= ALTER TABLE fullname RENAME TO nm */ + 190, /* (290) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */ + 190, /* (291) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */ + 296, /* (292) add_column_fullname ::= fullname */ + 190, /* (293) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ + 190, /* (294) cmd ::= create_vtab */ + 190, /* (295) cmd ::= create_vtab LP vtabarglist RP */ + 298, /* (296) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ + 300, /* (297) vtabarg ::= */ + 301, /* (298) vtabargtoken ::= ANY */ + 301, /* (299) vtabargtoken ::= lp anylist RP */ + 302, /* (300) lp ::= LP */ + 266, /* (301) with ::= WITH wqlist */ + 266, /* (302) with ::= WITH RECURSIVE wqlist */ + 305, /* (303) wqas ::= AS */ + 305, /* (304) wqas ::= AS MATERIALIZED */ + 305, /* (305) wqas ::= AS NOT MATERIALIZED */ + 304, /* (306) wqitem ::= nm eidlist_opt wqas LP select RP */ + 241, /* (307) wqlist ::= wqitem */ + 241, /* (308) wqlist ::= wqlist COMMA wqitem */ + 306, /* (309) windowdefn_list ::= windowdefn */ + 306, /* (310) windowdefn_list ::= windowdefn_list COMMA windowdefn */ + 307, /* (311) windowdefn ::= nm AS LP window RP */ + 308, /* (312) window ::= PARTITION BY nexprlist orderby_opt frame_opt */ + 308, /* (313) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ + 308, /* (314) window ::= ORDER BY sortlist frame_opt */ + 308, /* (315) window ::= nm ORDER BY sortlist frame_opt */ + 308, /* (316) window ::= frame_opt */ + 308, /* (317) window ::= nm frame_opt */ + 309, /* (318) frame_opt ::= */ + 309, /* (319) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ + 309, /* (320) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ + 313, /* (321) range_or_rows ::= RANGE|ROWS|GROUPS */ + 315, /* (322) frame_bound_s ::= frame_bound */ + 315, /* (323) frame_bound_s ::= UNBOUNDED PRECEDING */ + 316, /* (324) frame_bound_e ::= frame_bound */ + 316, /* (325) frame_bound_e ::= UNBOUNDED FOLLOWING */ + 314, /* (326) frame_bound ::= expr PRECEDING|FOLLOWING */ + 314, /* (327) frame_bound ::= CURRENT ROW */ + 317, /* (328) frame_exclude_opt ::= */ + 317, /* (329) frame_exclude_opt ::= EXCLUDE frame_exclude */ + 318, /* (330) frame_exclude ::= NO OTHERS */ + 318, /* (331) frame_exclude ::= CURRENT ROW */ + 318, /* (332) frame_exclude ::= GROUP|TIES */ + 251, /* (333) window_clause ::= WINDOW windowdefn_list */ + 273, /* (334) filter_over ::= filter_clause over_clause */ + 273, /* (335) filter_over ::= over_clause */ + 273, /* (336) filter_over ::= filter_clause */ + 312, /* (337) over_clause ::= OVER LP window RP */ + 312, /* (338) over_clause ::= OVER nm */ + 311, /* (339) filter_clause ::= FILTER LP WHERE expr RP */ + 185, /* (340) input ::= cmdlist */ + 186, /* (341) cmdlist ::= cmdlist ecmd */ + 186, /* (342) cmdlist ::= ecmd */ + 187, /* (343) ecmd ::= SEMI */ + 187, /* (344) ecmd ::= cmdx SEMI */ + 187, /* (345) ecmd ::= explain cmdx SEMI */ + 192, /* (346) trans_opt ::= */ + 192, /* (347) trans_opt ::= TRANSACTION */ + 192, /* (348) trans_opt ::= TRANSACTION nm */ + 194, /* (349) savepoint_opt ::= SAVEPOINT */ + 194, /* (350) savepoint_opt ::= */ + 190, /* (351) cmd ::= create_table create_table_args */ + 203, /* (352) table_option_set ::= table_option */ + 201, /* (353) columnlist ::= columnlist COMMA columnname carglist */ + 201, /* (354) columnlist ::= columnname carglist */ + 193, /* (355) nm ::= ID|INDEXED|JOIN_KW */ + 193, /* (356) nm ::= STRING */ + 208, /* (357) typetoken ::= typename */ + 209, /* (358) typename ::= ID|STRING */ + 210, /* (359) signed ::= plus_num */ + 210, /* (360) signed ::= minus_num */ + 207, /* (361) carglist ::= carglist ccons */ + 207, /* (362) carglist ::= */ + 215, /* (363) ccons ::= NULL onconf */ + 215, /* (364) ccons ::= GENERATED ALWAYS AS generated */ + 215, /* (365) ccons ::= AS generated */ + 202, /* (366) conslist_opt ::= COMMA conslist */ + 228, /* (367) conslist ::= conslist tconscomma tcons */ + 228, /* (368) conslist ::= tcons */ + 229, /* (369) tconscomma ::= */ + 233, /* (370) defer_subclause_opt ::= defer_subclause */ + 235, /* (371) resolvetype ::= raisetype */ + 239, /* (372) selectnowith ::= oneselect */ + 240, /* (373) oneselect ::= values */ + 254, /* (374) sclp ::= selcollist COMMA */ + 255, /* (375) as ::= ID|STRING */ + 264, /* (376) indexed_opt ::= indexed_by */ + 272, /* (377) returning ::= */ + 217, /* (378) expr ::= term */ + 274, /* (379) likeop ::= LIKE_KW|MATCH */ + 278, /* (380) case_operand ::= expr */ + 261, /* (381) exprlist ::= nexprlist */ + 284, /* (382) nmnum ::= plus_num */ + 284, /* (383) nmnum ::= nm */ + 284, /* (384) nmnum ::= ON */ + 284, /* (385) nmnum ::= DELETE */ + 284, /* (386) nmnum ::= DEFAULT */ + 211, /* (387) plus_num ::= INTEGER|FLOAT */ + 289, /* (388) foreach_clause ::= */ + 289, /* (389) foreach_clause ::= FOR EACH ROW */ + 292, /* (390) trnm ::= nm */ + 293, /* (391) tridxby ::= */ + 294, /* (392) database_kw_opt ::= DATABASE */ + 294, /* (393) database_kw_opt ::= */ + 297, /* (394) kwcolumn_opt ::= */ + 297, /* (395) kwcolumn_opt ::= COLUMNKW */ + 299, /* (396) vtabarglist ::= vtabarg */ + 299, /* (397) vtabarglist ::= vtabarglist COMMA vtabarg */ + 300, /* (398) vtabarg ::= vtabarg vtabargtoken */ + 303, /* (399) anylist ::= */ + 303, /* (400) anylist ::= anylist LP anylist RP */ + 303, /* (401) anylist ::= anylist ANY */ + 266, /* (402) with ::= */ +}; + +/* For rule J, yyRuleInfoNRhs[J] contains the negative of the number +** of symbols on the right-hand side of that rule. */ +static const signed char yyRuleInfoNRhs[] = { + -1, /* (0) explain ::= EXPLAIN */ + -3, /* (1) explain ::= EXPLAIN QUERY PLAN */ + -1, /* (2) cmdx ::= cmd */ + -3, /* (3) cmd ::= BEGIN transtype trans_opt */ + 0, /* (4) transtype ::= */ + -1, /* (5) transtype ::= DEFERRED */ + -1, /* (6) transtype ::= IMMEDIATE */ + -1, /* (7) transtype ::= EXCLUSIVE */ + -2, /* (8) cmd ::= COMMIT|END trans_opt */ + -2, /* (9) cmd ::= ROLLBACK trans_opt */ + -2, /* (10) cmd ::= SAVEPOINT nm */ + -3, /* (11) cmd ::= RELEASE savepoint_opt nm */ + -5, /* (12) cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */ + -6, /* (13) create_table ::= createkw temp TABLE ifnotexists nm dbnm */ + -1, /* (14) createkw ::= CREATE */ + 0, /* (15) ifnotexists ::= */ + -3, /* (16) ifnotexists ::= IF NOT EXISTS */ + -1, /* (17) temp ::= TEMP */ + 0, /* (18) temp ::= */ + -5, /* (19) create_table_args ::= LP columnlist conslist_opt RP table_option_set */ + -2, /* (20) create_table_args ::= AS select */ + 0, /* (21) table_option_set ::= */ + -3, /* (22) table_option_set ::= table_option_set COMMA table_option */ + -2, /* (23) table_option ::= WITHOUT nm */ + -1, /* (24) table_option ::= nm */ + -2, /* (25) columnname ::= nm typetoken */ + 0, /* (26) typetoken ::= */ + -4, /* (27) typetoken ::= typename LP signed RP */ + -6, /* (28) typetoken ::= typename LP signed COMMA signed RP */ + -2, /* (29) typename ::= typename ID|STRING */ + 0, /* (30) scanpt ::= */ + 0, /* (31) scantok ::= */ + -2, /* (32) ccons ::= CONSTRAINT nm */ + -3, /* (33) ccons ::= DEFAULT scantok term */ + -4, /* (34) ccons ::= DEFAULT LP expr RP */ + -4, /* (35) ccons ::= DEFAULT PLUS scantok term */ + -4, /* (36) ccons ::= DEFAULT MINUS scantok term */ + -3, /* (37) ccons ::= DEFAULT scantok ID|INDEXED */ + -3, /* (38) ccons ::= NOT NULL onconf */ + -5, /* (39) ccons ::= PRIMARY KEY sortorder onconf autoinc */ + -2, /* (40) ccons ::= UNIQUE onconf */ + -4, /* (41) ccons ::= CHECK LP expr RP */ + -4, /* (42) ccons ::= REFERENCES nm eidlist_opt refargs */ + -1, /* (43) ccons ::= defer_subclause */ + -2, /* (44) ccons ::= COLLATE ID|STRING */ + -3, /* (45) generated ::= LP expr RP */ + -4, /* (46) generated ::= LP expr RP ID */ + 0, /* (47) autoinc ::= */ + -1, /* (48) autoinc ::= AUTOINCR */ + 0, /* (49) refargs ::= */ + -2, /* (50) refargs ::= refargs refarg */ + -2, /* (51) refarg ::= MATCH nm */ + -3, /* (52) refarg ::= ON INSERT refact */ + -3, /* (53) refarg ::= ON DELETE refact */ + -3, /* (54) refarg ::= ON UPDATE refact */ + -2, /* (55) refact ::= SET NULL */ + -2, /* (56) refact ::= SET DEFAULT */ + -1, /* (57) refact ::= CASCADE */ + -1, /* (58) refact ::= RESTRICT */ + -2, /* (59) refact ::= NO ACTION */ + -3, /* (60) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */ + -2, /* (61) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */ + 0, /* (62) init_deferred_pred_opt ::= */ + -2, /* (63) init_deferred_pred_opt ::= INITIALLY DEFERRED */ + -2, /* (64) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ + 0, /* (65) conslist_opt ::= */ + -1, /* (66) tconscomma ::= COMMA */ + -2, /* (67) tcons ::= CONSTRAINT nm */ + -7, /* (68) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */ + -5, /* (69) tcons ::= UNIQUE LP sortlist RP onconf */ + -5, /* (70) tcons ::= CHECK LP expr RP onconf */ + -10, /* (71) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */ + 0, /* (72) defer_subclause_opt ::= */ + 0, /* (73) onconf ::= */ + -3, /* (74) onconf ::= ON CONFLICT resolvetype */ + 0, /* (75) orconf ::= */ + -2, /* (76) orconf ::= OR resolvetype */ + -1, /* (77) resolvetype ::= IGNORE */ + -1, /* (78) resolvetype ::= REPLACE */ + -4, /* (79) cmd ::= DROP TABLE ifexists fullname */ + -2, /* (80) ifexists ::= IF EXISTS */ + 0, /* (81) ifexists ::= */ + -9, /* (82) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */ + -4, /* (83) cmd ::= DROP VIEW ifexists fullname */ + -1, /* (84) cmd ::= select */ + -3, /* (85) select ::= WITH wqlist selectnowith */ + -4, /* (86) select ::= WITH RECURSIVE wqlist selectnowith */ + -1, /* (87) select ::= selectnowith */ + -3, /* (88) selectnowith ::= selectnowith multiselect_op oneselect */ + -1, /* (89) multiselect_op ::= UNION */ + -2, /* (90) multiselect_op ::= UNION ALL */ + -1, /* (91) multiselect_op ::= EXCEPT|INTERSECT */ + -9, /* (92) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */ + -10, /* (93) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */ + -4, /* (94) values ::= VALUES LP nexprlist RP */ + -5, /* (95) values ::= values COMMA LP nexprlist RP */ + -1, /* (96) distinct ::= DISTINCT */ + -1, /* (97) distinct ::= ALL */ + 0, /* (98) distinct ::= */ + 0, /* (99) sclp ::= */ + -5, /* (100) selcollist ::= sclp scanpt expr scanpt as */ + -3, /* (101) selcollist ::= sclp scanpt STAR */ + -5, /* (102) selcollist ::= sclp scanpt nm DOT STAR */ + -2, /* (103) as ::= AS nm */ + 0, /* (104) as ::= */ + 0, /* (105) from ::= */ + -2, /* (106) from ::= FROM seltablist */ + -2, /* (107) stl_prefix ::= seltablist joinop */ + 0, /* (108) stl_prefix ::= */ + -5, /* (109) seltablist ::= stl_prefix nm dbnm as on_using */ + -6, /* (110) seltablist ::= stl_prefix nm dbnm as indexed_by on_using */ + -8, /* (111) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */ + -6, /* (112) seltablist ::= stl_prefix LP select RP as on_using */ + -6, /* (113) seltablist ::= stl_prefix LP seltablist RP as on_using */ + 0, /* (114) dbnm ::= */ + -2, /* (115) dbnm ::= DOT nm */ + -1, /* (116) fullname ::= nm */ + -3, /* (117) fullname ::= nm DOT nm */ + -1, /* (118) xfullname ::= nm */ + -3, /* (119) xfullname ::= nm DOT nm */ + -5, /* (120) xfullname ::= nm DOT nm AS nm */ + -3, /* (121) xfullname ::= nm AS nm */ + -1, /* (122) joinop ::= COMMA|JOIN */ + -2, /* (123) joinop ::= JOIN_KW JOIN */ + -3, /* (124) joinop ::= JOIN_KW nm JOIN */ + -4, /* (125) joinop ::= JOIN_KW nm nm JOIN */ + -2, /* (126) on_using ::= ON expr */ + -4, /* (127) on_using ::= USING LP idlist RP */ + 0, /* (128) on_using ::= */ + 0, /* (129) indexed_opt ::= */ + -3, /* (130) indexed_by ::= INDEXED BY nm */ + -2, /* (131) indexed_by ::= NOT INDEXED */ + 0, /* (132) orderby_opt ::= */ + -3, /* (133) orderby_opt ::= ORDER BY sortlist */ + -5, /* (134) sortlist ::= sortlist COMMA expr sortorder nulls */ + -3, /* (135) sortlist ::= expr sortorder nulls */ + -1, /* (136) sortorder ::= ASC */ + -1, /* (137) sortorder ::= DESC */ + 0, /* (138) sortorder ::= */ + -2, /* (139) nulls ::= NULLS FIRST */ + -2, /* (140) nulls ::= NULLS LAST */ + 0, /* (141) nulls ::= */ + 0, /* (142) groupby_opt ::= */ + -3, /* (143) groupby_opt ::= GROUP BY nexprlist */ + 0, /* (144) having_opt ::= */ + -2, /* (145) having_opt ::= HAVING expr */ + 0, /* (146) limit_opt ::= */ + -2, /* (147) limit_opt ::= LIMIT expr */ + -4, /* (148) limit_opt ::= LIMIT expr OFFSET expr */ + -4, /* (149) limit_opt ::= LIMIT expr COMMA expr */ + -6, /* (150) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */ + 0, /* (151) where_opt ::= */ + -2, /* (152) where_opt ::= WHERE expr */ + 0, /* (153) where_opt_ret ::= */ + -2, /* (154) where_opt_ret ::= WHERE expr */ + -2, /* (155) where_opt_ret ::= RETURNING selcollist */ + -4, /* (156) where_opt_ret ::= WHERE expr RETURNING selcollist */ + -9, /* (157) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */ + -5, /* (158) setlist ::= setlist COMMA nm EQ expr */ + -7, /* (159) setlist ::= setlist COMMA LP idlist RP EQ expr */ + -3, /* (160) setlist ::= nm EQ expr */ + -5, /* (161) setlist ::= LP idlist RP EQ expr */ + -7, /* (162) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */ + -8, /* (163) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */ + 0, /* (164) upsert ::= */ + -2, /* (165) upsert ::= RETURNING selcollist */ + -12, /* (166) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */ + -9, /* (167) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */ + -5, /* (168) upsert ::= ON CONFLICT DO NOTHING returning */ + -8, /* (169) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */ + -2, /* (170) returning ::= RETURNING selcollist */ + -2, /* (171) insert_cmd ::= INSERT orconf */ + -1, /* (172) insert_cmd ::= REPLACE */ + 0, /* (173) idlist_opt ::= */ + -3, /* (174) idlist_opt ::= LP idlist RP */ + -3, /* (175) idlist ::= idlist COMMA nm */ + -1, /* (176) idlist ::= nm */ + -3, /* (177) expr ::= LP expr RP */ + -1, /* (178) expr ::= ID|INDEXED|JOIN_KW */ + -3, /* (179) expr ::= nm DOT nm */ + -5, /* (180) expr ::= nm DOT nm DOT nm */ + -1, /* (181) term ::= NULL|FLOAT|BLOB */ + -1, /* (182) term ::= STRING */ + -1, /* (183) term ::= INTEGER */ + -1, /* (184) expr ::= VARIABLE */ + -3, /* (185) expr ::= expr COLLATE ID|STRING */ + -6, /* (186) expr ::= CAST LP expr AS typetoken RP */ + -5, /* (187) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */ + -4, /* (188) expr ::= ID|INDEXED|JOIN_KW LP STAR RP */ + -6, /* (189) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */ + -5, /* (190) expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */ + -1, /* (191) term ::= CTIME_KW */ + -5, /* (192) expr ::= LP nexprlist COMMA expr RP */ + -3, /* (193) expr ::= expr AND expr */ + -3, /* (194) expr ::= expr OR expr */ + -3, /* (195) expr ::= expr LT|GT|GE|LE expr */ + -3, /* (196) expr ::= expr EQ|NE expr */ + -3, /* (197) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ + -3, /* (198) expr ::= expr PLUS|MINUS expr */ + -3, /* (199) expr ::= expr STAR|SLASH|REM expr */ + -3, /* (200) expr ::= expr CONCAT expr */ + -2, /* (201) likeop ::= NOT LIKE_KW|MATCH */ + -3, /* (202) expr ::= expr likeop expr */ + -5, /* (203) expr ::= expr likeop expr ESCAPE expr */ + -2, /* (204) expr ::= expr ISNULL|NOTNULL */ + -3, /* (205) expr ::= expr NOT NULL */ + -3, /* (206) expr ::= expr IS expr */ + -4, /* (207) expr ::= expr IS NOT expr */ + -6, /* (208) expr ::= expr IS NOT DISTINCT FROM expr */ + -5, /* (209) expr ::= expr IS DISTINCT FROM expr */ + -2, /* (210) expr ::= NOT expr */ + -2, /* (211) expr ::= BITNOT expr */ + -2, /* (212) expr ::= PLUS|MINUS expr */ + -3, /* (213) expr ::= expr PTR expr */ + -1, /* (214) between_op ::= BETWEEN */ + -2, /* (215) between_op ::= NOT BETWEEN */ + -5, /* (216) expr ::= expr between_op expr AND expr */ + -1, /* (217) in_op ::= IN */ + -2, /* (218) in_op ::= NOT IN */ + -5, /* (219) expr ::= expr in_op LP exprlist RP */ + -3, /* (220) expr ::= LP select RP */ + -5, /* (221) expr ::= expr in_op LP select RP */ + -5, /* (222) expr ::= expr in_op nm dbnm paren_exprlist */ + -4, /* (223) expr ::= EXISTS LP select RP */ + -5, /* (224) expr ::= CASE case_operand case_exprlist case_else END */ + -5, /* (225) case_exprlist ::= case_exprlist WHEN expr THEN expr */ + -4, /* (226) case_exprlist ::= WHEN expr THEN expr */ + -2, /* (227) case_else ::= ELSE expr */ + 0, /* (228) case_else ::= */ + 0, /* (229) case_operand ::= */ + 0, /* (230) exprlist ::= */ + -3, /* (231) nexprlist ::= nexprlist COMMA expr */ + -1, /* (232) nexprlist ::= expr */ + 0, /* (233) paren_exprlist ::= */ + -3, /* (234) paren_exprlist ::= LP exprlist RP */ + -12, /* (235) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */ + -1, /* (236) uniqueflag ::= UNIQUE */ + 0, /* (237) uniqueflag ::= */ + 0, /* (238) eidlist_opt ::= */ + -3, /* (239) eidlist_opt ::= LP eidlist RP */ + -5, /* (240) eidlist ::= eidlist COMMA nm collate sortorder */ + -3, /* (241) eidlist ::= nm collate sortorder */ + 0, /* (242) collate ::= */ + -2, /* (243) collate ::= COLLATE ID|STRING */ + -4, /* (244) cmd ::= DROP INDEX ifexists fullname */ + -2, /* (245) cmd ::= VACUUM vinto */ + -3, /* (246) cmd ::= VACUUM nm vinto */ + -2, /* (247) vinto ::= INTO expr */ + 0, /* (248) vinto ::= */ + -3, /* (249) cmd ::= PRAGMA nm dbnm */ + -5, /* (250) cmd ::= PRAGMA nm dbnm EQ nmnum */ + -6, /* (251) cmd ::= PRAGMA nm dbnm LP nmnum RP */ + -5, /* (252) cmd ::= PRAGMA nm dbnm EQ minus_num */ + -6, /* (253) cmd ::= PRAGMA nm dbnm LP minus_num RP */ + -2, /* (254) plus_num ::= PLUS INTEGER|FLOAT */ + -2, /* (255) minus_num ::= MINUS INTEGER|FLOAT */ + -5, /* (256) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */ + -11, /* (257) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */ + -1, /* (258) trigger_time ::= BEFORE|AFTER */ + -2, /* (259) trigger_time ::= INSTEAD OF */ + 0, /* (260) trigger_time ::= */ + -1, /* (261) trigger_event ::= DELETE|INSERT */ + -1, /* (262) trigger_event ::= UPDATE */ + -3, /* (263) trigger_event ::= UPDATE OF idlist */ + 0, /* (264) when_clause ::= */ + -2, /* (265) when_clause ::= WHEN expr */ + -3, /* (266) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */ + -2, /* (267) trigger_cmd_list ::= trigger_cmd SEMI */ + -3, /* (268) trnm ::= nm DOT nm */ + -3, /* (269) tridxby ::= INDEXED BY nm */ + -2, /* (270) tridxby ::= NOT INDEXED */ + -9, /* (271) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */ + -8, /* (272) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */ + -6, /* (273) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */ + -3, /* (274) trigger_cmd ::= scanpt select scanpt */ + -4, /* (275) expr ::= RAISE LP IGNORE RP */ + -6, /* (276) expr ::= RAISE LP raisetype COMMA nm RP */ + -1, /* (277) raisetype ::= ROLLBACK */ + -1, /* (278) raisetype ::= ABORT */ + -1, /* (279) raisetype ::= FAIL */ + -4, /* (280) cmd ::= DROP TRIGGER ifexists fullname */ + -6, /* (281) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ + -3, /* (282) cmd ::= DETACH database_kw_opt expr */ + 0, /* (283) key_opt ::= */ + -2, /* (284) key_opt ::= KEY expr */ + -1, /* (285) cmd ::= REINDEX */ + -3, /* (286) cmd ::= REINDEX nm dbnm */ + -1, /* (287) cmd ::= ANALYZE */ + -3, /* (288) cmd ::= ANALYZE nm dbnm */ + -6, /* (289) cmd ::= ALTER TABLE fullname RENAME TO nm */ + -7, /* (290) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */ + -6, /* (291) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */ + -1, /* (292) add_column_fullname ::= fullname */ + -8, /* (293) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ + -1, /* (294) cmd ::= create_vtab */ + -4, /* (295) cmd ::= create_vtab LP vtabarglist RP */ + -8, /* (296) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ + 0, /* (297) vtabarg ::= */ + -1, /* (298) vtabargtoken ::= ANY */ + -3, /* (299) vtabargtoken ::= lp anylist RP */ + -1, /* (300) lp ::= LP */ + -2, /* (301) with ::= WITH wqlist */ + -3, /* (302) with ::= WITH RECURSIVE wqlist */ + -1, /* (303) wqas ::= AS */ + -2, /* (304) wqas ::= AS MATERIALIZED */ + -3, /* (305) wqas ::= AS NOT MATERIALIZED */ + -6, /* (306) wqitem ::= nm eidlist_opt wqas LP select RP */ + -1, /* (307) wqlist ::= wqitem */ + -3, /* (308) wqlist ::= wqlist COMMA wqitem */ + -1, /* (309) windowdefn_list ::= windowdefn */ + -3, /* (310) windowdefn_list ::= windowdefn_list COMMA windowdefn */ + -5, /* (311) windowdefn ::= nm AS LP window RP */ + -5, /* (312) window ::= PARTITION BY nexprlist orderby_opt frame_opt */ + -6, /* (313) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ + -4, /* (314) window ::= ORDER BY sortlist frame_opt */ + -5, /* (315) window ::= nm ORDER BY sortlist frame_opt */ + -1, /* (316) window ::= frame_opt */ + -2, /* (317) window ::= nm frame_opt */ + 0, /* (318) frame_opt ::= */ + -3, /* (319) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ + -6, /* (320) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ + -1, /* (321) range_or_rows ::= RANGE|ROWS|GROUPS */ + -1, /* (322) frame_bound_s ::= frame_bound */ + -2, /* (323) frame_bound_s ::= UNBOUNDED PRECEDING */ + -1, /* (324) frame_bound_e ::= frame_bound */ + -2, /* (325) frame_bound_e ::= UNBOUNDED FOLLOWING */ + -2, /* (326) frame_bound ::= expr PRECEDING|FOLLOWING */ + -2, /* (327) frame_bound ::= CURRENT ROW */ + 0, /* (328) frame_exclude_opt ::= */ + -2, /* (329) frame_exclude_opt ::= EXCLUDE frame_exclude */ + -2, /* (330) frame_exclude ::= NO OTHERS */ + -2, /* (331) frame_exclude ::= CURRENT ROW */ + -1, /* (332) frame_exclude ::= GROUP|TIES */ + -2, /* (333) window_clause ::= WINDOW windowdefn_list */ + -2, /* (334) filter_over ::= filter_clause over_clause */ + -1, /* (335) filter_over ::= over_clause */ + -1, /* (336) filter_over ::= filter_clause */ + -4, /* (337) over_clause ::= OVER LP window RP */ + -2, /* (338) over_clause ::= OVER nm */ + -5, /* (339) filter_clause ::= FILTER LP WHERE expr RP */ + -1, /* (340) input ::= cmdlist */ + -2, /* (341) cmdlist ::= cmdlist ecmd */ + -1, /* (342) cmdlist ::= ecmd */ + -1, /* (343) ecmd ::= SEMI */ + -2, /* (344) ecmd ::= cmdx SEMI */ + -3, /* (345) ecmd ::= explain cmdx SEMI */ + 0, /* (346) trans_opt ::= */ + -1, /* (347) trans_opt ::= TRANSACTION */ + -2, /* (348) trans_opt ::= TRANSACTION nm */ + -1, /* (349) savepoint_opt ::= SAVEPOINT */ + 0, /* (350) savepoint_opt ::= */ + -2, /* (351) cmd ::= create_table create_table_args */ + -1, /* (352) table_option_set ::= table_option */ + -4, /* (353) columnlist ::= columnlist COMMA columnname carglist */ + -2, /* (354) columnlist ::= columnname carglist */ + -1, /* (355) nm ::= ID|INDEXED|JOIN_KW */ + -1, /* (356) nm ::= STRING */ + -1, /* (357) typetoken ::= typename */ + -1, /* (358) typename ::= ID|STRING */ + -1, /* (359) signed ::= plus_num */ + -1, /* (360) signed ::= minus_num */ + -2, /* (361) carglist ::= carglist ccons */ + 0, /* (362) carglist ::= */ + -2, /* (363) ccons ::= NULL onconf */ + -4, /* (364) ccons ::= GENERATED ALWAYS AS generated */ + -2, /* (365) ccons ::= AS generated */ + -2, /* (366) conslist_opt ::= COMMA conslist */ + -3, /* (367) conslist ::= conslist tconscomma tcons */ + -1, /* (368) conslist ::= tcons */ + 0, /* (369) tconscomma ::= */ + -1, /* (370) defer_subclause_opt ::= defer_subclause */ + -1, /* (371) resolvetype ::= raisetype */ + -1, /* (372) selectnowith ::= oneselect */ + -1, /* (373) oneselect ::= values */ + -2, /* (374) sclp ::= selcollist COMMA */ + -1, /* (375) as ::= ID|STRING */ + -1, /* (376) indexed_opt ::= indexed_by */ + 0, /* (377) returning ::= */ + -1, /* (378) expr ::= term */ + -1, /* (379) likeop ::= LIKE_KW|MATCH */ + -1, /* (380) case_operand ::= expr */ + -1, /* (381) exprlist ::= nexprlist */ + -1, /* (382) nmnum ::= plus_num */ + -1, /* (383) nmnum ::= nm */ + -1, /* (384) nmnum ::= ON */ + -1, /* (385) nmnum ::= DELETE */ + -1, /* (386) nmnum ::= DEFAULT */ + -1, /* (387) plus_num ::= INTEGER|FLOAT */ + 0, /* (388) foreach_clause ::= */ + -3, /* (389) foreach_clause ::= FOR EACH ROW */ + -1, /* (390) trnm ::= nm */ + 0, /* (391) tridxby ::= */ + -1, /* (392) database_kw_opt ::= DATABASE */ + 0, /* (393) database_kw_opt ::= */ + 0, /* (394) kwcolumn_opt ::= */ + -1, /* (395) kwcolumn_opt ::= COLUMNKW */ + -1, /* (396) vtabarglist ::= vtabarg */ + -3, /* (397) vtabarglist ::= vtabarglist COMMA vtabarg */ + -2, /* (398) vtabarg ::= vtabarg vtabargtoken */ + 0, /* (399) anylist ::= */ + -4, /* (400) anylist ::= anylist LP anylist RP */ + -2, /* (401) anylist ::= anylist ANY */ + 0, /* (402) with ::= */ +}; + +static void yy_accept(yyParser*); /* Forward Declaration */ + +/* +** Perform a reduce action and the shift that must immediately +** follow the reduce. +** +** The yyLookahead and yyLookaheadToken parameters provide reduce actions +** access to the lookahead token (if any). The yyLookahead will be YYNOCODE +** if the lookahead token has already been consumed. As this procedure is +** only called from one place, optimizing compilers will in-line it, which +** means that the extra parameters have no performance impact. +*/ +static YYACTIONTYPE yy_reduce( + yyParser *yypParser, /* The parser */ + unsigned int yyruleno, /* Number of the rule by which to reduce */ + int yyLookahead, /* Lookahead token, or YYNOCODE if none */ + sqlite3ParserTOKENTYPE yyLookaheadToken /* Value of the lookahead token */ + sqlite3ParserCTX_PDECL /* %extra_context */ +){ + int yygoto; /* The next state */ + YYACTIONTYPE yyact; /* The next action */ + yyStackEntry *yymsp; /* The top of the parser's stack */ + int yysize; /* Amount to pop the stack */ + sqlite3ParserARG_FETCH + (void)yyLookahead; + (void)yyLookaheadToken; + yymsp = yypParser->yytos; + + switch( yyruleno ){ + /* Beginning here are the reduction cases. A typical example + ** follows: + ** case 0: + ** #line + ** { ... } // User supplied code + ** #line + ** break; + */ +/********** Begin reduce actions **********************************************/ + YYMINORTYPE yylhsminor; + case 0: /* explain ::= EXPLAIN */ +{ pParse->explain = 1; } + break; + case 1: /* explain ::= EXPLAIN QUERY PLAN */ +{ pParse->explain = 2; } + break; + case 2: /* cmdx ::= cmd */ +{ sqlite3FinishCoding(pParse); } + break; + case 3: /* cmd ::= BEGIN transtype trans_opt */ +{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy394);} + break; + case 4: /* transtype ::= */ +{yymsp[1].minor.yy394 = TK_DEFERRED;} + break; + case 5: /* transtype ::= DEFERRED */ + case 6: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==6); + case 7: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==7); + case 321: /* range_or_rows ::= RANGE|ROWS|GROUPS */ yytestcase(yyruleno==321); +{yymsp[0].minor.yy394 = yymsp[0].major; /*A-overwrites-X*/} + break; + case 8: /* cmd ::= COMMIT|END trans_opt */ + case 9: /* cmd ::= ROLLBACK trans_opt */ yytestcase(yyruleno==9); +{sqlite3EndTransaction(pParse,yymsp[-1].major);} + break; + case 10: /* cmd ::= SAVEPOINT nm */ +{ + sqlite3Savepoint(pParse, SAVEPOINT_BEGIN, &yymsp[0].minor.yy0); +} + break; + case 11: /* cmd ::= RELEASE savepoint_opt nm */ +{ + sqlite3Savepoint(pParse, SAVEPOINT_RELEASE, &yymsp[0].minor.yy0); +} + break; + case 12: /* cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */ +{ + sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &yymsp[0].minor.yy0); +} + break; + case 13: /* create_table ::= createkw temp TABLE ifnotexists nm dbnm */ +{ + sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy394,0,0,yymsp[-2].minor.yy394); +} + break; + case 14: /* createkw ::= CREATE */ +{disableLookaside(pParse);} + break; + case 15: /* ifnotexists ::= */ + case 18: /* temp ::= */ yytestcase(yyruleno==18); + case 47: /* autoinc ::= */ yytestcase(yyruleno==47); + case 62: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==62); + case 72: /* defer_subclause_opt ::= */ yytestcase(yyruleno==72); + case 81: /* ifexists ::= */ yytestcase(yyruleno==81); + case 98: /* distinct ::= */ yytestcase(yyruleno==98); + case 242: /* collate ::= */ yytestcase(yyruleno==242); +{yymsp[1].minor.yy394 = 0;} + break; + case 16: /* ifnotexists ::= IF NOT EXISTS */ +{yymsp[-2].minor.yy394 = 1;} + break; + case 17: /* temp ::= TEMP */ +{yymsp[0].minor.yy394 = pParse->db->init.busy==0;} + break; + case 19: /* create_table_args ::= LP columnlist conslist_opt RP table_option_set */ +{ + sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy285,0); +} + break; + case 20: /* create_table_args ::= AS select */ +{ + sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy47); + sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy47); +} + break; + case 21: /* table_option_set ::= */ +{yymsp[1].minor.yy285 = 0;} + break; + case 22: /* table_option_set ::= table_option_set COMMA table_option */ +{yylhsminor.yy285 = yymsp[-2].minor.yy285|yymsp[0].minor.yy285;} + yymsp[-2].minor.yy285 = yylhsminor.yy285; + break; + case 23: /* table_option ::= WITHOUT nm */ +{ + if( yymsp[0].minor.yy0.n==5 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"rowid",5)==0 ){ + yymsp[-1].minor.yy285 = TF_WithoutRowid | TF_NoVisibleRowid; + }else{ + yymsp[-1].minor.yy285 = 0; + sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z); + } +} + break; + case 24: /* table_option ::= nm */ +{ + if( yymsp[0].minor.yy0.n==6 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"strict",6)==0 ){ + yylhsminor.yy285 = TF_Strict; + }else{ + yylhsminor.yy285 = 0; + sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z); + } +} + yymsp[0].minor.yy285 = yylhsminor.yy285; + break; + case 25: /* columnname ::= nm typetoken */ +{sqlite3AddColumn(pParse,yymsp[-1].minor.yy0,yymsp[0].minor.yy0);} + break; + case 26: /* typetoken ::= */ + case 65: /* conslist_opt ::= */ yytestcase(yyruleno==65); + case 104: /* as ::= */ yytestcase(yyruleno==104); +{yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = 0;} + break; + case 27: /* typetoken ::= typename LP signed RP */ +{ + yymsp[-3].minor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-3].minor.yy0.z); +} + break; + case 28: /* typetoken ::= typename LP signed COMMA signed RP */ +{ + yymsp[-5].minor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-5].minor.yy0.z); +} + break; + case 29: /* typename ::= typename ID|STRING */ +{yymsp[-1].minor.yy0.n=yymsp[0].minor.yy0.n+(int)(yymsp[0].minor.yy0.z-yymsp[-1].minor.yy0.z);} + break; + case 30: /* scanpt ::= */ +{ + assert( yyLookahead!=YYNOCODE ); + yymsp[1].minor.yy522 = yyLookaheadToken.z; +} + break; + case 31: /* scantok ::= */ +{ + assert( yyLookahead!=YYNOCODE ); + yymsp[1].minor.yy0 = yyLookaheadToken; +} + break; + case 32: /* ccons ::= CONSTRAINT nm */ + case 67: /* tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==67); +{pParse->constraintName = yymsp[0].minor.yy0;} + break; + case 33: /* ccons ::= DEFAULT scantok term */ +{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy528,yymsp[-1].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);} + break; + case 34: /* ccons ::= DEFAULT LP expr RP */ +{sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy528,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);} + break; + case 35: /* ccons ::= DEFAULT PLUS scantok term */ +{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy528,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);} + break; + case 36: /* ccons ::= DEFAULT MINUS scantok term */ +{ + Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy528, 0); + sqlite3AddDefaultValue(pParse,p,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]); +} + break; + case 37: /* ccons ::= DEFAULT scantok ID|INDEXED */ +{ + Expr *p = tokenExpr(pParse, TK_STRING, yymsp[0].minor.yy0); + if( p ){ + sqlite3ExprIdToTrueFalse(p); + testcase( p->op==TK_TRUEFALSE && sqlite3ExprTruthValue(p) ); + } + sqlite3AddDefaultValue(pParse,p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.z+yymsp[0].minor.yy0.n); +} + break; + case 38: /* ccons ::= NOT NULL onconf */ +{sqlite3AddNotNull(pParse, yymsp[0].minor.yy394);} + break; + case 39: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */ +{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy394,yymsp[0].minor.yy394,yymsp[-2].minor.yy394);} + break; + case 40: /* ccons ::= UNIQUE onconf */ +{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy394,0,0,0,0, + SQLITE_IDXTYPE_UNIQUE);} + break; + case 41: /* ccons ::= CHECK LP expr RP */ +{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy528,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy0.z);} + break; + case 42: /* ccons ::= REFERENCES nm eidlist_opt refargs */ +{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy322,yymsp[0].minor.yy394);} + break; + case 43: /* ccons ::= defer_subclause */ +{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy394);} + break; + case 44: /* ccons ::= COLLATE ID|STRING */ +{sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);} + break; + case 45: /* generated ::= LP expr RP */ +{sqlite3AddGenerated(pParse,yymsp[-1].minor.yy528,0);} + break; + case 46: /* generated ::= LP expr RP ID */ +{sqlite3AddGenerated(pParse,yymsp[-2].minor.yy528,&yymsp[0].minor.yy0);} + break; + case 48: /* autoinc ::= AUTOINCR */ +{yymsp[0].minor.yy394 = 1;} + break; + case 49: /* refargs ::= */ +{ yymsp[1].minor.yy394 = OE_None*0x0101; /* EV: R-19803-45884 */} + break; + case 50: /* refargs ::= refargs refarg */ +{ yymsp[-1].minor.yy394 = (yymsp[-1].minor.yy394 & ~yymsp[0].minor.yy231.mask) | yymsp[0].minor.yy231.value; } + break; + case 51: /* refarg ::= MATCH nm */ +{ yymsp[-1].minor.yy231.value = 0; yymsp[-1].minor.yy231.mask = 0x000000; } + break; + case 52: /* refarg ::= ON INSERT refact */ +{ yymsp[-2].minor.yy231.value = 0; yymsp[-2].minor.yy231.mask = 0x000000; } + break; + case 53: /* refarg ::= ON DELETE refact */ +{ yymsp[-2].minor.yy231.value = yymsp[0].minor.yy394; yymsp[-2].minor.yy231.mask = 0x0000ff; } + break; + case 54: /* refarg ::= ON UPDATE refact */ +{ yymsp[-2].minor.yy231.value = yymsp[0].minor.yy394<<8; yymsp[-2].minor.yy231.mask = 0x00ff00; } + break; + case 55: /* refact ::= SET NULL */ +{ yymsp[-1].minor.yy394 = OE_SetNull; /* EV: R-33326-45252 */} + break; + case 56: /* refact ::= SET DEFAULT */ +{ yymsp[-1].minor.yy394 = OE_SetDflt; /* EV: R-33326-45252 */} + break; + case 57: /* refact ::= CASCADE */ +{ yymsp[0].minor.yy394 = OE_Cascade; /* EV: R-33326-45252 */} + break; + case 58: /* refact ::= RESTRICT */ +{ yymsp[0].minor.yy394 = OE_Restrict; /* EV: R-33326-45252 */} + break; + case 59: /* refact ::= NO ACTION */ +{ yymsp[-1].minor.yy394 = OE_None; /* EV: R-33326-45252 */} + break; + case 60: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */ +{yymsp[-2].minor.yy394 = 0;} + break; + case 61: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */ + case 76: /* orconf ::= OR resolvetype */ yytestcase(yyruleno==76); + case 171: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==171); +{yymsp[-1].minor.yy394 = yymsp[0].minor.yy394;} + break; + case 63: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */ + case 80: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==80); + case 215: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==215); + case 218: /* in_op ::= NOT IN */ yytestcase(yyruleno==218); + case 243: /* collate ::= COLLATE ID|STRING */ yytestcase(yyruleno==243); +{yymsp[-1].minor.yy394 = 1;} + break; + case 64: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ +{yymsp[-1].minor.yy394 = 0;} + break; + case 66: /* tconscomma ::= COMMA */ +{pParse->constraintName.n = 0;} + break; + case 68: /* tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */ +{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy322,yymsp[0].minor.yy394,yymsp[-2].minor.yy394,0);} + break; + case 69: /* tcons ::= UNIQUE LP sortlist RP onconf */ +{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy322,yymsp[0].minor.yy394,0,0,0,0, + SQLITE_IDXTYPE_UNIQUE);} + break; + case 70: /* tcons ::= CHECK LP expr RP onconf */ +{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy528,yymsp[-3].minor.yy0.z,yymsp[-1].minor.yy0.z);} + break; + case 71: /* tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */ +{ + sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy322, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy322, yymsp[-1].minor.yy394); + sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy394); +} + break; + case 73: /* onconf ::= */ + case 75: /* orconf ::= */ yytestcase(yyruleno==75); +{yymsp[1].minor.yy394 = OE_Default;} + break; + case 74: /* onconf ::= ON CONFLICT resolvetype */ +{yymsp[-2].minor.yy394 = yymsp[0].minor.yy394;} + break; + case 77: /* resolvetype ::= IGNORE */ +{yymsp[0].minor.yy394 = OE_Ignore;} + break; + case 78: /* resolvetype ::= REPLACE */ + case 172: /* insert_cmd ::= REPLACE */ yytestcase(yyruleno==172); +{yymsp[0].minor.yy394 = OE_Replace;} + break; + case 79: /* cmd ::= DROP TABLE ifexists fullname */ +{ + sqlite3DropTable(pParse, yymsp[0].minor.yy131, 0, yymsp[-1].minor.yy394); +} + break; + case 82: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */ +{ + sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy322, yymsp[0].minor.yy47, yymsp[-7].minor.yy394, yymsp[-5].minor.yy394); +} + break; + case 83: /* cmd ::= DROP VIEW ifexists fullname */ +{ + sqlite3DropTable(pParse, yymsp[0].minor.yy131, 1, yymsp[-1].minor.yy394); +} + break; + case 84: /* cmd ::= select */ +{ + SelectDest dest = {SRT_Output, 0, 0, 0, 0, 0, 0}; + sqlite3Select(pParse, yymsp[0].minor.yy47, &dest); + sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy47); +} + break; + case 85: /* select ::= WITH wqlist selectnowith */ +{yymsp[-2].minor.yy47 = attachWithToSelect(pParse,yymsp[0].minor.yy47,yymsp[-1].minor.yy521);} + break; + case 86: /* select ::= WITH RECURSIVE wqlist selectnowith */ +{yymsp[-3].minor.yy47 = attachWithToSelect(pParse,yymsp[0].minor.yy47,yymsp[-1].minor.yy521);} + break; + case 87: /* select ::= selectnowith */ +{ + Select *p = yymsp[0].minor.yy47; + if( p ){ + parserDoubleLinkSelect(pParse, p); + } + yymsp[0].minor.yy47 = p; /*A-overwrites-X*/ +} + break; + case 88: /* selectnowith ::= selectnowith multiselect_op oneselect */ +{ + Select *pRhs = yymsp[0].minor.yy47; + Select *pLhs = yymsp[-2].minor.yy47; + if( pRhs && pRhs->pPrior ){ + SrcList *pFrom; + Token x; + x.n = 0; + parserDoubleLinkSelect(pParse, pRhs); + pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&x,pRhs,0); + pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0); + } + if( pRhs ){ + pRhs->op = (u8)yymsp[-1].minor.yy394; + pRhs->pPrior = pLhs; + if( ALWAYS(pLhs) ) pLhs->selFlags &= ~SF_MultiValue; + pRhs->selFlags &= ~SF_MultiValue; + if( yymsp[-1].minor.yy394!=TK_ALL ) pParse->hasCompound = 1; + }else{ + sqlite3SelectDelete(pParse->db, pLhs); + } + yymsp[-2].minor.yy47 = pRhs; +} + break; + case 89: /* multiselect_op ::= UNION */ + case 91: /* multiselect_op ::= EXCEPT|INTERSECT */ yytestcase(yyruleno==91); +{yymsp[0].minor.yy394 = yymsp[0].major; /*A-overwrites-OP*/} + break; + case 90: /* multiselect_op ::= UNION ALL */ +{yymsp[-1].minor.yy394 = TK_ALL;} + break; + case 92: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */ +{ + yymsp[-8].minor.yy47 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy322,yymsp[-5].minor.yy131,yymsp[-4].minor.yy528,yymsp[-3].minor.yy322,yymsp[-2].minor.yy528,yymsp[-1].minor.yy322,yymsp[-7].minor.yy394,yymsp[0].minor.yy528); +} + break; + case 93: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */ +{ + yymsp[-9].minor.yy47 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy322,yymsp[-6].minor.yy131,yymsp[-5].minor.yy528,yymsp[-4].minor.yy322,yymsp[-3].minor.yy528,yymsp[-1].minor.yy322,yymsp[-8].minor.yy394,yymsp[0].minor.yy528); + if( yymsp[-9].minor.yy47 ){ + yymsp[-9].minor.yy47->pWinDefn = yymsp[-2].minor.yy41; + }else{ + sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy41); + } +} + break; + case 94: /* values ::= VALUES LP nexprlist RP */ +{ + yymsp[-3].minor.yy47 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy322,0,0,0,0,0,SF_Values,0); +} + break; + case 95: /* values ::= values COMMA LP nexprlist RP */ +{ + Select *pRight, *pLeft = yymsp[-4].minor.yy47; + pRight = sqlite3SelectNew(pParse,yymsp[-1].minor.yy322,0,0,0,0,0,SF_Values|SF_MultiValue,0); + if( ALWAYS(pLeft) ) pLeft->selFlags &= ~SF_MultiValue; + if( pRight ){ + pRight->op = TK_ALL; + pRight->pPrior = pLeft; + yymsp[-4].minor.yy47 = pRight; + }else{ + yymsp[-4].minor.yy47 = pLeft; + } +} + break; + case 96: /* distinct ::= DISTINCT */ +{yymsp[0].minor.yy394 = SF_Distinct;} + break; + case 97: /* distinct ::= ALL */ +{yymsp[0].minor.yy394 = SF_All;} + break; + case 99: /* sclp ::= */ + case 132: /* orderby_opt ::= */ yytestcase(yyruleno==132); + case 142: /* groupby_opt ::= */ yytestcase(yyruleno==142); + case 230: /* exprlist ::= */ yytestcase(yyruleno==230); + case 233: /* paren_exprlist ::= */ yytestcase(yyruleno==233); + case 238: /* eidlist_opt ::= */ yytestcase(yyruleno==238); +{yymsp[1].minor.yy322 = 0;} + break; + case 100: /* selcollist ::= sclp scanpt expr scanpt as */ +{ + yymsp[-4].minor.yy322 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy322, yymsp[-2].minor.yy528); + if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy322, &yymsp[0].minor.yy0, 1); + sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy322,yymsp[-3].minor.yy522,yymsp[-1].minor.yy522); +} + break; + case 101: /* selcollist ::= sclp scanpt STAR */ +{ + Expr *p = sqlite3Expr(pParse->db, TK_ASTERISK, 0); + yymsp[-2].minor.yy322 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy322, p); +} + break; + case 102: /* selcollist ::= sclp scanpt nm DOT STAR */ +{ + Expr *pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0); + Expr *pLeft = tokenExpr(pParse, TK_ID, yymsp[-2].minor.yy0); + Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight); + yymsp[-4].minor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy322, pDot); +} + break; + case 103: /* as ::= AS nm */ + case 115: /* dbnm ::= DOT nm */ yytestcase(yyruleno==115); + case 254: /* plus_num ::= PLUS INTEGER|FLOAT */ yytestcase(yyruleno==254); + case 255: /* minus_num ::= MINUS INTEGER|FLOAT */ yytestcase(yyruleno==255); +{yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;} + break; + case 105: /* from ::= */ + case 108: /* stl_prefix ::= */ yytestcase(yyruleno==108); +{yymsp[1].minor.yy131 = 0;} + break; + case 106: /* from ::= FROM seltablist */ +{ + yymsp[-1].minor.yy131 = yymsp[0].minor.yy131; + sqlite3SrcListShiftJoinType(pParse,yymsp[-1].minor.yy131); +} + break; + case 107: /* stl_prefix ::= seltablist joinop */ +{ + if( ALWAYS(yymsp[-1].minor.yy131 && yymsp[-1].minor.yy131->nSrc>0) ) yymsp[-1].minor.yy131->a[yymsp[-1].minor.yy131->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy394; +} + break; + case 109: /* seltablist ::= stl_prefix nm dbnm as on_using */ +{ + yymsp[-4].minor.yy131 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-4].minor.yy131,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy561); +} + break; + case 110: /* seltablist ::= stl_prefix nm dbnm as indexed_by on_using */ +{ + yymsp[-5].minor.yy131 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy131,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,0,&yymsp[0].minor.yy561); + sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy131, &yymsp[-1].minor.yy0); +} + break; + case 111: /* seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */ +{ + yymsp[-7].minor.yy131 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-7].minor.yy131,&yymsp[-6].minor.yy0,&yymsp[-5].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy561); + sqlite3SrcListFuncArgs(pParse, yymsp[-7].minor.yy131, yymsp[-3].minor.yy322); +} + break; + case 112: /* seltablist ::= stl_prefix LP select RP as on_using */ +{ + yymsp[-5].minor.yy131 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy131,0,0,&yymsp[-1].minor.yy0,yymsp[-3].minor.yy47,&yymsp[0].minor.yy561); + } + break; + case 113: /* seltablist ::= stl_prefix LP seltablist RP as on_using */ +{ + if( yymsp[-5].minor.yy131==0 && yymsp[-1].minor.yy0.n==0 && yymsp[0].minor.yy561.pOn==0 && yymsp[0].minor.yy561.pUsing==0 ){ + yymsp[-5].minor.yy131 = yymsp[-3].minor.yy131; + }else if( ALWAYS(yymsp[-3].minor.yy131!=0) && yymsp[-3].minor.yy131->nSrc==1 ){ + yymsp[-5].minor.yy131 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy131,0,0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy561); + if( yymsp[-5].minor.yy131 ){ + SrcItem *pNew = &yymsp[-5].minor.yy131->a[yymsp[-5].minor.yy131->nSrc-1]; + SrcItem *pOld = yymsp[-3].minor.yy131->a; + pNew->zName = pOld->zName; + pNew->zDatabase = pOld->zDatabase; + pNew->pSelect = pOld->pSelect; + if( pNew->pSelect && (pNew->pSelect->selFlags & SF_NestedFrom)!=0 ){ + pNew->fg.isNestedFrom = 1; + } + if( pOld->fg.isTabFunc ){ + pNew->u1.pFuncArg = pOld->u1.pFuncArg; + pOld->u1.pFuncArg = 0; + pOld->fg.isTabFunc = 0; + pNew->fg.isTabFunc = 1; + } + pOld->zName = pOld->zDatabase = 0; + pOld->pSelect = 0; + } + sqlite3SrcListDelete(pParse->db, yymsp[-3].minor.yy131); + }else{ + Select *pSubquery; + sqlite3SrcListShiftJoinType(pParse,yymsp[-3].minor.yy131); + pSubquery = sqlite3SelectNew(pParse,0,yymsp[-3].minor.yy131,0,0,0,0,SF_NestedFrom,0); + yymsp[-5].minor.yy131 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy131,0,0,&yymsp[-1].minor.yy0,pSubquery,&yymsp[0].minor.yy561); + } + } + break; + case 114: /* dbnm ::= */ + case 129: /* indexed_opt ::= */ yytestcase(yyruleno==129); +{yymsp[1].minor.yy0.z=0; yymsp[1].minor.yy0.n=0;} + break; + case 116: /* fullname ::= nm */ +{ + yylhsminor.yy131 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); + if( IN_RENAME_OBJECT && yylhsminor.yy131 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy131->a[0].zName, &yymsp[0].minor.yy0); +} + yymsp[0].minor.yy131 = yylhsminor.yy131; + break; + case 117: /* fullname ::= nm DOT nm */ +{ + yylhsminor.yy131 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); + if( IN_RENAME_OBJECT && yylhsminor.yy131 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy131->a[0].zName, &yymsp[0].minor.yy0); +} + yymsp[-2].minor.yy131 = yylhsminor.yy131; + break; + case 118: /* xfullname ::= nm */ +{yymsp[0].minor.yy131 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); /*A-overwrites-X*/} + break; + case 119: /* xfullname ::= nm DOT nm */ +{yymsp[-2].minor.yy131 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-X*/} + break; + case 120: /* xfullname ::= nm DOT nm AS nm */ +{ + yymsp[-4].minor.yy131 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0); /*A-overwrites-X*/ + if( yymsp[-4].minor.yy131 ) yymsp[-4].minor.yy131->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0); +} + break; + case 121: /* xfullname ::= nm AS nm */ +{ + yymsp[-2].minor.yy131 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0); /*A-overwrites-X*/ + if( yymsp[-2].minor.yy131 ) yymsp[-2].minor.yy131->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0); +} + break; + case 122: /* joinop ::= COMMA|JOIN */ +{ yymsp[0].minor.yy394 = JT_INNER; } + break; + case 123: /* joinop ::= JOIN_KW JOIN */ +{yymsp[-1].minor.yy394 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); /*X-overwrites-A*/} + break; + case 124: /* joinop ::= JOIN_KW nm JOIN */ +{yymsp[-2].minor.yy394 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /*X-overwrites-A*/} + break; + case 125: /* joinop ::= JOIN_KW nm nm JOIN */ +{yymsp[-3].minor.yy394 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/*X-overwrites-A*/} + break; + case 126: /* on_using ::= ON expr */ +{yymsp[-1].minor.yy561.pOn = yymsp[0].minor.yy528; yymsp[-1].minor.yy561.pUsing = 0;} + break; + case 127: /* on_using ::= USING LP idlist RP */ +{yymsp[-3].minor.yy561.pOn = 0; yymsp[-3].minor.yy561.pUsing = yymsp[-1].minor.yy254;} + break; + case 128: /* on_using ::= */ +{yymsp[1].minor.yy561.pOn = 0; yymsp[1].minor.yy561.pUsing = 0;} + break; + case 130: /* indexed_by ::= INDEXED BY nm */ +{yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;} + break; + case 131: /* indexed_by ::= NOT INDEXED */ +{yymsp[-1].minor.yy0.z=0; yymsp[-1].minor.yy0.n=1;} + break; + case 133: /* orderby_opt ::= ORDER BY sortlist */ + case 143: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==143); +{yymsp[-2].minor.yy322 = yymsp[0].minor.yy322;} + break; + case 134: /* sortlist ::= sortlist COMMA expr sortorder nulls */ +{ + yymsp[-4].minor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy322,yymsp[-2].minor.yy528); + sqlite3ExprListSetSortOrder(yymsp[-4].minor.yy322,yymsp[-1].minor.yy394,yymsp[0].minor.yy394); +} + break; + case 135: /* sortlist ::= expr sortorder nulls */ +{ + yymsp[-2].minor.yy322 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy528); /*A-overwrites-Y*/ + sqlite3ExprListSetSortOrder(yymsp[-2].minor.yy322,yymsp[-1].minor.yy394,yymsp[0].minor.yy394); +} + break; + case 136: /* sortorder ::= ASC */ +{yymsp[0].minor.yy394 = SQLITE_SO_ASC;} + break; + case 137: /* sortorder ::= DESC */ +{yymsp[0].minor.yy394 = SQLITE_SO_DESC;} + break; + case 138: /* sortorder ::= */ + case 141: /* nulls ::= */ yytestcase(yyruleno==141); +{yymsp[1].minor.yy394 = SQLITE_SO_UNDEFINED;} + break; + case 139: /* nulls ::= NULLS FIRST */ +{yymsp[-1].minor.yy394 = SQLITE_SO_ASC;} + break; + case 140: /* nulls ::= NULLS LAST */ +{yymsp[-1].minor.yy394 = SQLITE_SO_DESC;} + break; + case 144: /* having_opt ::= */ + case 146: /* limit_opt ::= */ yytestcase(yyruleno==146); + case 151: /* where_opt ::= */ yytestcase(yyruleno==151); + case 153: /* where_opt_ret ::= */ yytestcase(yyruleno==153); + case 228: /* case_else ::= */ yytestcase(yyruleno==228); + case 229: /* case_operand ::= */ yytestcase(yyruleno==229); + case 248: /* vinto ::= */ yytestcase(yyruleno==248); +{yymsp[1].minor.yy528 = 0;} + break; + case 145: /* having_opt ::= HAVING expr */ + case 152: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==152); + case 154: /* where_opt_ret ::= WHERE expr */ yytestcase(yyruleno==154); + case 227: /* case_else ::= ELSE expr */ yytestcase(yyruleno==227); + case 247: /* vinto ::= INTO expr */ yytestcase(yyruleno==247); +{yymsp[-1].minor.yy528 = yymsp[0].minor.yy528;} + break; + case 147: /* limit_opt ::= LIMIT expr */ +{yymsp[-1].minor.yy528 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy528,0);} + break; + case 148: /* limit_opt ::= LIMIT expr OFFSET expr */ +{yymsp[-3].minor.yy528 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy528,yymsp[0].minor.yy528);} + break; + case 149: /* limit_opt ::= LIMIT expr COMMA expr */ +{yymsp[-3].minor.yy528 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy528,yymsp[-2].minor.yy528);} + break; + case 150: /* cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */ +{ + sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy131, &yymsp[-1].minor.yy0); + sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy131,yymsp[0].minor.yy528,0,0); +} + break; + case 155: /* where_opt_ret ::= RETURNING selcollist */ +{sqlite3AddReturning(pParse,yymsp[0].minor.yy322); yymsp[-1].minor.yy528 = 0;} + break; + case 156: /* where_opt_ret ::= WHERE expr RETURNING selcollist */ +{sqlite3AddReturning(pParse,yymsp[0].minor.yy322); yymsp[-3].minor.yy528 = yymsp[-2].minor.yy528;} + break; + case 157: /* cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */ +{ + sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy131, &yymsp[-4].minor.yy0); + sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy322,"set list"); + if( yymsp[-1].minor.yy131 ){ + SrcList *pFromClause = yymsp[-1].minor.yy131; + if( pFromClause->nSrc>1 ){ + Select *pSubquery; + Token as; + pSubquery = sqlite3SelectNew(pParse,0,pFromClause,0,0,0,0,SF_NestedFrom,0); + as.n = 0; + as.z = 0; + pFromClause = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&as,pSubquery,0); + } + yymsp[-5].minor.yy131 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy131, pFromClause); + } + sqlite3Update(pParse,yymsp[-5].minor.yy131,yymsp[-2].minor.yy322,yymsp[0].minor.yy528,yymsp[-6].minor.yy394,0,0,0); +} + break; + case 158: /* setlist ::= setlist COMMA nm EQ expr */ +{ + yymsp[-4].minor.yy322 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy322, yymsp[0].minor.yy528); + sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy322, &yymsp[-2].minor.yy0, 1); +} + break; + case 159: /* setlist ::= setlist COMMA LP idlist RP EQ expr */ +{ + yymsp[-6].minor.yy322 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy322, yymsp[-3].minor.yy254, yymsp[0].minor.yy528); +} + break; + case 160: /* setlist ::= nm EQ expr */ +{ + yylhsminor.yy322 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy528); + sqlite3ExprListSetName(pParse, yylhsminor.yy322, &yymsp[-2].minor.yy0, 1); +} + yymsp[-2].minor.yy322 = yylhsminor.yy322; + break; + case 161: /* setlist ::= LP idlist RP EQ expr */ +{ + yymsp[-4].minor.yy322 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy254, yymsp[0].minor.yy528); +} + break; + case 162: /* cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */ +{ + sqlite3Insert(pParse, yymsp[-3].minor.yy131, yymsp[-1].minor.yy47, yymsp[-2].minor.yy254, yymsp[-5].minor.yy394, yymsp[0].minor.yy444); +} + break; + case 163: /* cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */ +{ + sqlite3Insert(pParse, yymsp[-4].minor.yy131, 0, yymsp[-3].minor.yy254, yymsp[-6].minor.yy394, 0); +} + break; + case 164: /* upsert ::= */ +{ yymsp[1].minor.yy444 = 0; } + break; + case 165: /* upsert ::= RETURNING selcollist */ +{ yymsp[-1].minor.yy444 = 0; sqlite3AddReturning(pParse,yymsp[0].minor.yy322); } + break; + case 166: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */ +{ yymsp[-11].minor.yy444 = sqlite3UpsertNew(pParse->db,yymsp[-8].minor.yy322,yymsp[-6].minor.yy528,yymsp[-2].minor.yy322,yymsp[-1].minor.yy528,yymsp[0].minor.yy444);} + break; + case 167: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */ +{ yymsp[-8].minor.yy444 = sqlite3UpsertNew(pParse->db,yymsp[-5].minor.yy322,yymsp[-3].minor.yy528,0,0,yymsp[0].minor.yy444); } + break; + case 168: /* upsert ::= ON CONFLICT DO NOTHING returning */ +{ yymsp[-4].minor.yy444 = sqlite3UpsertNew(pParse->db,0,0,0,0,0); } + break; + case 169: /* upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */ +{ yymsp[-7].minor.yy444 = sqlite3UpsertNew(pParse->db,0,0,yymsp[-2].minor.yy322,yymsp[-1].minor.yy528,0);} + break; + case 170: /* returning ::= RETURNING selcollist */ +{sqlite3AddReturning(pParse,yymsp[0].minor.yy322);} + break; + case 173: /* idlist_opt ::= */ +{yymsp[1].minor.yy254 = 0;} + break; + case 174: /* idlist_opt ::= LP idlist RP */ +{yymsp[-2].minor.yy254 = yymsp[-1].minor.yy254;} + break; + case 175: /* idlist ::= idlist COMMA nm */ +{yymsp[-2].minor.yy254 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy254,&yymsp[0].minor.yy0);} + break; + case 176: /* idlist ::= nm */ +{yymsp[0].minor.yy254 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /*A-overwrites-Y*/} + break; + case 177: /* expr ::= LP expr RP */ +{yymsp[-2].minor.yy528 = yymsp[-1].minor.yy528;} + break; + case 178: /* expr ::= ID|INDEXED|JOIN_KW */ +{yymsp[0].minor.yy528=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /*A-overwrites-X*/} + break; + case 179: /* expr ::= nm DOT nm */ +{ + Expr *temp1 = tokenExpr(pParse,TK_ID,yymsp[-2].minor.yy0); + Expr *temp2 = tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); + yylhsminor.yy528 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2); +} + yymsp[-2].minor.yy528 = yylhsminor.yy528; + break; + case 180: /* expr ::= nm DOT nm DOT nm */ +{ + Expr *temp1 = tokenExpr(pParse,TK_ID,yymsp[-4].minor.yy0); + Expr *temp2 = tokenExpr(pParse,TK_ID,yymsp[-2].minor.yy0); + Expr *temp3 = tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); + Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3); + if( IN_RENAME_OBJECT ){ + sqlite3RenameTokenRemap(pParse, 0, temp1); + } + yylhsminor.yy528 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4); +} + yymsp[-4].minor.yy528 = yylhsminor.yy528; + break; + case 181: /* term ::= NULL|FLOAT|BLOB */ + case 182: /* term ::= STRING */ yytestcase(yyruleno==182); +{yymsp[0].minor.yy528=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /*A-overwrites-X*/} + break; + case 183: /* term ::= INTEGER */ +{ + yylhsminor.yy528 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1); + if( yylhsminor.yy528 ) yylhsminor.yy528->w.iOfst = (int)(yymsp[0].minor.yy0.z - pParse->zTail); +} + yymsp[0].minor.yy528 = yylhsminor.yy528; + break; + case 184: /* expr ::= VARIABLE */ +{ + if( !(yymsp[0].minor.yy0.z[0]=='#' && sqlite3Isdigit(yymsp[0].minor.yy0.z[1])) ){ + u32 n = yymsp[0].minor.yy0.n; + yymsp[0].minor.yy528 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0); + sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy528, n); + }else{ + /* When doing a nested parse, one can include terms in an expression + ** that look like this: #1 #2 ... These terms refer to registers + ** in the virtual machine. #N is the N-th register. */ + Token t = yymsp[0].minor.yy0; /*A-overwrites-X*/ + assert( t.n>=2 ); + if( pParse->nested==0 ){ + sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &t); + yymsp[0].minor.yy528 = 0; + }else{ + yymsp[0].minor.yy528 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0); + if( yymsp[0].minor.yy528 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy528->iTable); + } + } +} + break; + case 185: /* expr ::= expr COLLATE ID|STRING */ +{ + yymsp[-2].minor.yy528 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy528, &yymsp[0].minor.yy0, 1); +} + break; + case 186: /* expr ::= CAST LP expr AS typetoken RP */ +{ + yymsp[-5].minor.yy528 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1); + sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy528, yymsp[-3].minor.yy528, 0); +} + break; + case 187: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */ +{ + yylhsminor.yy528 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy322, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy394); +} + yymsp[-4].minor.yy528 = yylhsminor.yy528; + break; + case 188: /* expr ::= ID|INDEXED|JOIN_KW LP STAR RP */ +{ + yylhsminor.yy528 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0); +} + yymsp[-3].minor.yy528 = yylhsminor.yy528; + break; + case 189: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */ +{ + yylhsminor.yy528 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy322, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy394); + sqlite3WindowAttach(pParse, yylhsminor.yy528, yymsp[0].minor.yy41); +} + yymsp[-5].minor.yy528 = yylhsminor.yy528; + break; + case 190: /* expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */ +{ + yylhsminor.yy528 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0); + sqlite3WindowAttach(pParse, yylhsminor.yy528, yymsp[0].minor.yy41); +} + yymsp[-4].minor.yy528 = yylhsminor.yy528; + break; + case 191: /* term ::= CTIME_KW */ +{ + yylhsminor.yy528 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0); +} + yymsp[0].minor.yy528 = yylhsminor.yy528; + break; + case 192: /* expr ::= LP nexprlist COMMA expr RP */ +{ + ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy322, yymsp[-1].minor.yy528); + yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0); + if( yymsp[-4].minor.yy528 ){ + yymsp[-4].minor.yy528->x.pList = pList; + if( ALWAYS(pList->nExpr) ){ + yymsp[-4].minor.yy528->flags |= pList->a[0].pExpr->flags & EP_Propagate; + } + }else{ + sqlite3ExprListDelete(pParse->db, pList); + } +} + break; + case 193: /* expr ::= expr AND expr */ +{yymsp[-2].minor.yy528=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy528,yymsp[0].minor.yy528);} + break; + case 194: /* expr ::= expr OR expr */ + case 195: /* expr ::= expr LT|GT|GE|LE expr */ yytestcase(yyruleno==195); + case 196: /* expr ::= expr EQ|NE expr */ yytestcase(yyruleno==196); + case 197: /* expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ yytestcase(yyruleno==197); + case 198: /* expr ::= expr PLUS|MINUS expr */ yytestcase(yyruleno==198); + case 199: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==199); + case 200: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==200); +{yymsp[-2].minor.yy528=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy528,yymsp[0].minor.yy528);} + break; + case 201: /* likeop ::= NOT LIKE_KW|MATCH */ +{yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n|=0x80000000; /*yymsp[-1].minor.yy0-overwrite-yymsp[0].minor.yy0*/} + break; + case 202: /* expr ::= expr likeop expr */ +{ + ExprList *pList; + int bNot = yymsp[-1].minor.yy0.n & 0x80000000; + yymsp[-1].minor.yy0.n &= 0x7fffffff; + pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy528); + pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy528); + yymsp[-2].minor.yy528 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0); + if( bNot ) yymsp[-2].minor.yy528 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy528, 0); + if( yymsp[-2].minor.yy528 ) yymsp[-2].minor.yy528->flags |= EP_InfixFunc; +} + break; + case 203: /* expr ::= expr likeop expr ESCAPE expr */ +{ + ExprList *pList; + int bNot = yymsp[-3].minor.yy0.n & 0x80000000; + yymsp[-3].minor.yy0.n &= 0x7fffffff; + pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy528); + pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy528); + pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy528); + yymsp[-4].minor.yy528 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0); + if( bNot ) yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy528, 0); + if( yymsp[-4].minor.yy528 ) yymsp[-4].minor.yy528->flags |= EP_InfixFunc; +} + break; + case 204: /* expr ::= expr ISNULL|NOTNULL */ +{yymsp[-1].minor.yy528 = sqlite3PExpr(pParse,yymsp[0].major,yymsp[-1].minor.yy528,0);} + break; + case 205: /* expr ::= expr NOT NULL */ +{yymsp[-2].minor.yy528 = sqlite3PExpr(pParse,TK_NOTNULL,yymsp[-2].minor.yy528,0);} + break; + case 206: /* expr ::= expr IS expr */ +{ + yymsp[-2].minor.yy528 = sqlite3PExpr(pParse,TK_IS,yymsp[-2].minor.yy528,yymsp[0].minor.yy528); + binaryToUnaryIfNull(pParse, yymsp[0].minor.yy528, yymsp[-2].minor.yy528, TK_ISNULL); +} + break; + case 207: /* expr ::= expr IS NOT expr */ +{ + yymsp[-3].minor.yy528 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-3].minor.yy528,yymsp[0].minor.yy528); + binaryToUnaryIfNull(pParse, yymsp[0].minor.yy528, yymsp[-3].minor.yy528, TK_NOTNULL); +} + break; + case 208: /* expr ::= expr IS NOT DISTINCT FROM expr */ +{ + yymsp[-5].minor.yy528 = sqlite3PExpr(pParse,TK_IS,yymsp[-5].minor.yy528,yymsp[0].minor.yy528); + binaryToUnaryIfNull(pParse, yymsp[0].minor.yy528, yymsp[-5].minor.yy528, TK_ISNULL); +} + break; + case 209: /* expr ::= expr IS DISTINCT FROM expr */ +{ + yymsp[-4].minor.yy528 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-4].minor.yy528,yymsp[0].minor.yy528); + binaryToUnaryIfNull(pParse, yymsp[0].minor.yy528, yymsp[-4].minor.yy528, TK_NOTNULL); +} + break; + case 210: /* expr ::= NOT expr */ + case 211: /* expr ::= BITNOT expr */ yytestcase(yyruleno==211); +{yymsp[-1].minor.yy528 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy528, 0);/*A-overwrites-B*/} + break; + case 212: /* expr ::= PLUS|MINUS expr */ +{ + yymsp[-1].minor.yy528 = sqlite3PExpr(pParse, yymsp[-1].major==TK_PLUS ? TK_UPLUS : TK_UMINUS, yymsp[0].minor.yy528, 0); + /*A-overwrites-B*/ +} + break; + case 213: /* expr ::= expr PTR expr */ +{ + ExprList *pList = sqlite3ExprListAppend(pParse, 0, yymsp[-2].minor.yy528); + pList = sqlite3ExprListAppend(pParse, pList, yymsp[0].minor.yy528); + yylhsminor.yy528 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0); +} + yymsp[-2].minor.yy528 = yylhsminor.yy528; + break; + case 214: /* between_op ::= BETWEEN */ + case 217: /* in_op ::= IN */ yytestcase(yyruleno==217); +{yymsp[0].minor.yy394 = 0;} + break; + case 216: /* expr ::= expr between_op expr AND expr */ +{ + ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy528); + pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy528); + yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy528, 0); + if( yymsp[-4].minor.yy528 ){ + yymsp[-4].minor.yy528->x.pList = pList; + }else{ + sqlite3ExprListDelete(pParse->db, pList); + } + if( yymsp[-3].minor.yy394 ) yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy528, 0); +} + break; + case 219: /* expr ::= expr in_op LP exprlist RP */ +{ + if( yymsp[-1].minor.yy322==0 ){ + /* Expressions of the form + ** + ** expr1 IN () + ** expr1 NOT IN () + ** + ** simplify to constants 0 (false) and 1 (true), respectively, + ** regardless of the value of expr1. + */ + sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy528); + yymsp[-4].minor.yy528 = sqlite3Expr(pParse->db, TK_STRING, yymsp[-3].minor.yy394 ? "true" : "false"); + if( yymsp[-4].minor.yy528 ) sqlite3ExprIdToTrueFalse(yymsp[-4].minor.yy528); + }else{ + Expr *pRHS = yymsp[-1].minor.yy322->a[0].pExpr; + if( yymsp[-1].minor.yy322->nExpr==1 && sqlite3ExprIsConstant(pRHS) && yymsp[-4].minor.yy528->op!=TK_VECTOR ){ + yymsp[-1].minor.yy322->a[0].pExpr = 0; + sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy322); + pRHS = sqlite3PExpr(pParse, TK_UPLUS, pRHS, 0); + yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy528, pRHS); + }else if( yymsp[-1].minor.yy322->nExpr==1 && pRHS->op==TK_SELECT ){ + yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy528, 0); + sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy528, pRHS->x.pSelect); + pRHS->x.pSelect = 0; + sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy322); + }else{ + yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy528, 0); + if( yymsp[-4].minor.yy528==0 ){ + sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy322); + }else if( yymsp[-4].minor.yy528->pLeft->op==TK_VECTOR ){ + int nExpr = yymsp[-4].minor.yy528->pLeft->x.pList->nExpr; + Select *pSelectRHS = sqlite3ExprListToValues(pParse, nExpr, yymsp[-1].minor.yy322); + if( pSelectRHS ){ + parserDoubleLinkSelect(pParse, pSelectRHS); + sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy528, pSelectRHS); + } + }else{ + yymsp[-4].minor.yy528->x.pList = yymsp[-1].minor.yy322; + sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy528); + } + } + if( yymsp[-3].minor.yy394 ) yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy528, 0); + } + } + break; + case 220: /* expr ::= LP select RP */ +{ + yymsp[-2].minor.yy528 = sqlite3PExpr(pParse, TK_SELECT, 0, 0); + sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy528, yymsp[-1].minor.yy47); + } + break; + case 221: /* expr ::= expr in_op LP select RP */ +{ + yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy528, 0); + sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy528, yymsp[-1].minor.yy47); + if( yymsp[-3].minor.yy394 ) yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy528, 0); + } + break; + case 222: /* expr ::= expr in_op nm dbnm paren_exprlist */ +{ + SrcList *pSrc = sqlite3SrcListAppend(pParse, 0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0); + Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0); + if( yymsp[0].minor.yy322 ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy322); + yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy528, 0); + sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy528, pSelect); + if( yymsp[-3].minor.yy394 ) yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy528, 0); + } + break; + case 223: /* expr ::= EXISTS LP select RP */ +{ + Expr *p; + p = yymsp[-3].minor.yy528 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0); + sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy47); + } + break; + case 224: /* expr ::= CASE case_operand case_exprlist case_else END */ +{ + yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy528, 0); + if( yymsp[-4].minor.yy528 ){ + yymsp[-4].minor.yy528->x.pList = yymsp[-1].minor.yy528 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy322,yymsp[-1].minor.yy528) : yymsp[-2].minor.yy322; + sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy528); + }else{ + sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy322); + sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy528); + } +} + break; + case 225: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */ +{ + yymsp[-4].minor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy322, yymsp[-2].minor.yy528); + yymsp[-4].minor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy322, yymsp[0].minor.yy528); +} + break; + case 226: /* case_exprlist ::= WHEN expr THEN expr */ +{ + yymsp[-3].minor.yy322 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy528); + yymsp[-3].minor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy322, yymsp[0].minor.yy528); +} + break; + case 231: /* nexprlist ::= nexprlist COMMA expr */ +{yymsp[-2].minor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy322,yymsp[0].minor.yy528);} + break; + case 232: /* nexprlist ::= expr */ +{yymsp[0].minor.yy322 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy528); /*A-overwrites-Y*/} + break; + case 234: /* paren_exprlist ::= LP exprlist RP */ + case 239: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==239); +{yymsp[-2].minor.yy322 = yymsp[-1].minor.yy322;} + break; + case 235: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */ +{ + sqlite3CreateIndex(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, + sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy322, yymsp[-10].minor.yy394, + &yymsp[-11].minor.yy0, yymsp[0].minor.yy528, SQLITE_SO_ASC, yymsp[-8].minor.yy394, SQLITE_IDXTYPE_APPDEF); + if( IN_RENAME_OBJECT && pParse->pNewIndex ){ + sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0); + } +} + break; + case 236: /* uniqueflag ::= UNIQUE */ + case 278: /* raisetype ::= ABORT */ yytestcase(yyruleno==278); +{yymsp[0].minor.yy394 = OE_Abort;} + break; + case 237: /* uniqueflag ::= */ +{yymsp[1].minor.yy394 = OE_None;} + break; + case 240: /* eidlist ::= eidlist COMMA nm collate sortorder */ +{ + yymsp[-4].minor.yy322 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy322, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy394, yymsp[0].minor.yy394); +} + break; + case 241: /* eidlist ::= nm collate sortorder */ +{ + yymsp[-2].minor.yy322 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy394, yymsp[0].minor.yy394); /*A-overwrites-Y*/ +} + break; + case 244: /* cmd ::= DROP INDEX ifexists fullname */ +{sqlite3DropIndex(pParse, yymsp[0].minor.yy131, yymsp[-1].minor.yy394);} + break; + case 245: /* cmd ::= VACUUM vinto */ +{sqlite3Vacuum(pParse,0,yymsp[0].minor.yy528);} + break; + case 246: /* cmd ::= VACUUM nm vinto */ +{sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy528);} + break; + case 249: /* cmd ::= PRAGMA nm dbnm */ +{sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);} + break; + case 250: /* cmd ::= PRAGMA nm dbnm EQ nmnum */ +{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);} + break; + case 251: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */ +{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);} + break; + case 252: /* cmd ::= PRAGMA nm dbnm EQ minus_num */ +{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);} + break; + case 253: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */ +{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);} + break; + case 256: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */ +{ + Token all; + all.z = yymsp[-3].minor.yy0.z; + all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n; + sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy33, &all); +} + break; + case 257: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */ +{ + sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy394, yymsp[-4].minor.yy180.a, yymsp[-4].minor.yy180.b, yymsp[-2].minor.yy131, yymsp[0].minor.yy528, yymsp[-10].minor.yy394, yymsp[-8].minor.yy394); + yymsp[-10].minor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0); /*A-overwrites-T*/ +} + break; + case 258: /* trigger_time ::= BEFORE|AFTER */ +{ yymsp[0].minor.yy394 = yymsp[0].major; /*A-overwrites-X*/ } + break; + case 259: /* trigger_time ::= INSTEAD OF */ +{ yymsp[-1].minor.yy394 = TK_INSTEAD;} + break; + case 260: /* trigger_time ::= */ +{ yymsp[1].minor.yy394 = TK_BEFORE; } + break; + case 261: /* trigger_event ::= DELETE|INSERT */ + case 262: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==262); +{yymsp[0].minor.yy180.a = yymsp[0].major; /*A-overwrites-X*/ yymsp[0].minor.yy180.b = 0;} + break; + case 263: /* trigger_event ::= UPDATE OF idlist */ +{yymsp[-2].minor.yy180.a = TK_UPDATE; yymsp[-2].minor.yy180.b = yymsp[0].minor.yy254;} + break; + case 264: /* when_clause ::= */ + case 283: /* key_opt ::= */ yytestcase(yyruleno==283); +{ yymsp[1].minor.yy528 = 0; } + break; + case 265: /* when_clause ::= WHEN expr */ + case 284: /* key_opt ::= KEY expr */ yytestcase(yyruleno==284); +{ yymsp[-1].minor.yy528 = yymsp[0].minor.yy528; } + break; + case 266: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */ +{ + assert( yymsp[-2].minor.yy33!=0 ); + yymsp[-2].minor.yy33->pLast->pNext = yymsp[-1].minor.yy33; + yymsp[-2].minor.yy33->pLast = yymsp[-1].minor.yy33; +} + break; + case 267: /* trigger_cmd_list ::= trigger_cmd SEMI */ +{ + assert( yymsp[-1].minor.yy33!=0 ); + yymsp[-1].minor.yy33->pLast = yymsp[-1].minor.yy33; +} + break; + case 268: /* trnm ::= nm DOT nm */ +{ + yymsp[-2].minor.yy0 = yymsp[0].minor.yy0; + sqlite3ErrorMsg(pParse, + "qualified table names are not allowed on INSERT, UPDATE, and DELETE " + "statements within triggers"); +} + break; + case 269: /* tridxby ::= INDEXED BY nm */ +{ + sqlite3ErrorMsg(pParse, + "the INDEXED BY clause is not allowed on UPDATE or DELETE statements " + "within triggers"); +} + break; + case 270: /* tridxby ::= NOT INDEXED */ +{ + sqlite3ErrorMsg(pParse, + "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements " + "within triggers"); +} + break; + case 271: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */ +{yylhsminor.yy33 = sqlite3TriggerUpdateStep(pParse, &yymsp[-6].minor.yy0, yymsp[-2].minor.yy131, yymsp[-3].minor.yy322, yymsp[-1].minor.yy528, yymsp[-7].minor.yy394, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy522);} + yymsp[-8].minor.yy33 = yylhsminor.yy33; + break; + case 272: /* trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */ +{ + yylhsminor.yy33 = sqlite3TriggerInsertStep(pParse,&yymsp[-4].minor.yy0,yymsp[-3].minor.yy254,yymsp[-2].minor.yy47,yymsp[-6].minor.yy394,yymsp[-1].minor.yy444,yymsp[-7].minor.yy522,yymsp[0].minor.yy522);/*yylhsminor.yy33-overwrites-yymsp[-6].minor.yy394*/ +} + yymsp[-7].minor.yy33 = yylhsminor.yy33; + break; + case 273: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */ +{yylhsminor.yy33 = sqlite3TriggerDeleteStep(pParse, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy528, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy522);} + yymsp[-5].minor.yy33 = yylhsminor.yy33; + break; + case 274: /* trigger_cmd ::= scanpt select scanpt */ +{yylhsminor.yy33 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy47, yymsp[-2].minor.yy522, yymsp[0].minor.yy522); /*yylhsminor.yy33-overwrites-yymsp[-1].minor.yy47*/} + yymsp[-2].minor.yy33 = yylhsminor.yy33; + break; + case 275: /* expr ::= RAISE LP IGNORE RP */ +{ + yymsp[-3].minor.yy528 = sqlite3PExpr(pParse, TK_RAISE, 0, 0); + if( yymsp[-3].minor.yy528 ){ + yymsp[-3].minor.yy528->affExpr = OE_Ignore; + } +} + break; + case 276: /* expr ::= RAISE LP raisetype COMMA nm RP */ +{ + yymsp[-5].minor.yy528 = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1); + if( yymsp[-5].minor.yy528 ) { + yymsp[-5].minor.yy528->affExpr = (char)yymsp[-3].minor.yy394; + } +} + break; + case 277: /* raisetype ::= ROLLBACK */ +{yymsp[0].minor.yy394 = OE_Rollback;} + break; + case 279: /* raisetype ::= FAIL */ +{yymsp[0].minor.yy394 = OE_Fail;} + break; + case 280: /* cmd ::= DROP TRIGGER ifexists fullname */ +{ + sqlite3DropTrigger(pParse,yymsp[0].minor.yy131,yymsp[-1].minor.yy394); +} + break; + case 281: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */ +{ + sqlite3Attach(pParse, yymsp[-3].minor.yy528, yymsp[-1].minor.yy528, yymsp[0].minor.yy528); +} + break; + case 282: /* cmd ::= DETACH database_kw_opt expr */ +{ + sqlite3Detach(pParse, yymsp[0].minor.yy528); +} + break; + case 285: /* cmd ::= REINDEX */ +{sqlite3Reindex(pParse, 0, 0);} + break; + case 286: /* cmd ::= REINDEX nm dbnm */ +{sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);} + break; + case 287: /* cmd ::= ANALYZE */ +{sqlite3Analyze(pParse, 0, 0);} + break; + case 288: /* cmd ::= ANALYZE nm dbnm */ +{sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);} + break; + case 289: /* cmd ::= ALTER TABLE fullname RENAME TO nm */ +{ + sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy131,&yymsp[0].minor.yy0); +} + break; + case 290: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */ +{ + yymsp[-1].minor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-1].minor.yy0.z) + pParse->sLastToken.n; + sqlite3AlterFinishAddColumn(pParse, &yymsp[-1].minor.yy0); +} + break; + case 291: /* cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */ +{ + sqlite3AlterDropColumn(pParse, yymsp[-3].minor.yy131, &yymsp[0].minor.yy0); +} + break; + case 292: /* add_column_fullname ::= fullname */ +{ + disableLookaside(pParse); + sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy131); +} + break; + case 293: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */ +{ + sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy131, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); +} + break; + case 294: /* cmd ::= create_vtab */ +{sqlite3VtabFinishParse(pParse,0);} + break; + case 295: /* cmd ::= create_vtab LP vtabarglist RP */ +{sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);} + break; + case 296: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */ +{ + sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy394); +} + break; + case 297: /* vtabarg ::= */ +{sqlite3VtabArgInit(pParse);} + break; + case 298: /* vtabargtoken ::= ANY */ + case 299: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==299); + case 300: /* lp ::= LP */ yytestcase(yyruleno==300); +{sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);} + break; + case 301: /* with ::= WITH wqlist */ + case 302: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==302); +{ sqlite3WithPush(pParse, yymsp[0].minor.yy521, 1); } + break; + case 303: /* wqas ::= AS */ +{yymsp[0].minor.yy516 = M10d_Any;} + break; + case 304: /* wqas ::= AS MATERIALIZED */ +{yymsp[-1].minor.yy516 = M10d_Yes;} + break; + case 305: /* wqas ::= AS NOT MATERIALIZED */ +{yymsp[-2].minor.yy516 = M10d_No;} + break; + case 306: /* wqitem ::= nm eidlist_opt wqas LP select RP */ +{ + yymsp[-5].minor.yy385 = sqlite3CteNew(pParse, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy322, yymsp[-1].minor.yy47, yymsp[-3].minor.yy516); /*A-overwrites-X*/ +} + break; + case 307: /* wqlist ::= wqitem */ +{ + yymsp[0].minor.yy521 = sqlite3WithAdd(pParse, 0, yymsp[0].minor.yy385); /*A-overwrites-X*/ +} + break; + case 308: /* wqlist ::= wqlist COMMA wqitem */ +{ + yymsp[-2].minor.yy521 = sqlite3WithAdd(pParse, yymsp[-2].minor.yy521, yymsp[0].minor.yy385); +} + break; + case 309: /* windowdefn_list ::= windowdefn */ +{ yylhsminor.yy41 = yymsp[0].minor.yy41; } + yymsp[0].minor.yy41 = yylhsminor.yy41; + break; + case 310: /* windowdefn_list ::= windowdefn_list COMMA windowdefn */ +{ + assert( yymsp[0].minor.yy41!=0 ); + sqlite3WindowChain(pParse, yymsp[0].minor.yy41, yymsp[-2].minor.yy41); + yymsp[0].minor.yy41->pNextWin = yymsp[-2].minor.yy41; + yylhsminor.yy41 = yymsp[0].minor.yy41; +} + yymsp[-2].minor.yy41 = yylhsminor.yy41; + break; + case 311: /* windowdefn ::= nm AS LP window RP */ +{ + if( ALWAYS(yymsp[-1].minor.yy41) ){ + yymsp[-1].minor.yy41->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n); + } + yylhsminor.yy41 = yymsp[-1].minor.yy41; +} + yymsp[-4].minor.yy41 = yylhsminor.yy41; + break; + case 312: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */ +{ + yymsp[-4].minor.yy41 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy41, yymsp[-2].minor.yy322, yymsp[-1].minor.yy322, 0); +} + break; + case 313: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */ +{ + yylhsminor.yy41 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy41, yymsp[-2].minor.yy322, yymsp[-1].minor.yy322, &yymsp[-5].minor.yy0); +} + yymsp[-5].minor.yy41 = yylhsminor.yy41; + break; + case 314: /* window ::= ORDER BY sortlist frame_opt */ +{ + yymsp[-3].minor.yy41 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy41, 0, yymsp[-1].minor.yy322, 0); +} + break; + case 315: /* window ::= nm ORDER BY sortlist frame_opt */ +{ + yylhsminor.yy41 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy41, 0, yymsp[-1].minor.yy322, &yymsp[-4].minor.yy0); +} + yymsp[-4].minor.yy41 = yylhsminor.yy41; + break; + case 316: /* window ::= frame_opt */ + case 335: /* filter_over ::= over_clause */ yytestcase(yyruleno==335); +{ + yylhsminor.yy41 = yymsp[0].minor.yy41; +} + yymsp[0].minor.yy41 = yylhsminor.yy41; + break; + case 317: /* window ::= nm frame_opt */ +{ + yylhsminor.yy41 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy41, 0, 0, &yymsp[-1].minor.yy0); +} + yymsp[-1].minor.yy41 = yylhsminor.yy41; + break; + case 318: /* frame_opt ::= */ +{ + yymsp[1].minor.yy41 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0); +} + break; + case 319: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */ +{ + yylhsminor.yy41 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy394, yymsp[-1].minor.yy595.eType, yymsp[-1].minor.yy595.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy516); +} + yymsp[-2].minor.yy41 = yylhsminor.yy41; + break; + case 320: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */ +{ + yylhsminor.yy41 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy394, yymsp[-3].minor.yy595.eType, yymsp[-3].minor.yy595.pExpr, yymsp[-1].minor.yy595.eType, yymsp[-1].minor.yy595.pExpr, yymsp[0].minor.yy516); +} + yymsp[-5].minor.yy41 = yylhsminor.yy41; + break; + case 322: /* frame_bound_s ::= frame_bound */ + case 324: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==324); +{yylhsminor.yy595 = yymsp[0].minor.yy595;} + yymsp[0].minor.yy595 = yylhsminor.yy595; + break; + case 323: /* frame_bound_s ::= UNBOUNDED PRECEDING */ + case 325: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==325); + case 327: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==327); +{yylhsminor.yy595.eType = yymsp[-1].major; yylhsminor.yy595.pExpr = 0;} + yymsp[-1].minor.yy595 = yylhsminor.yy595; + break; + case 326: /* frame_bound ::= expr PRECEDING|FOLLOWING */ +{yylhsminor.yy595.eType = yymsp[0].major; yylhsminor.yy595.pExpr = yymsp[-1].minor.yy528;} + yymsp[-1].minor.yy595 = yylhsminor.yy595; + break; + case 328: /* frame_exclude_opt ::= */ +{yymsp[1].minor.yy516 = 0;} + break; + case 329: /* frame_exclude_opt ::= EXCLUDE frame_exclude */ +{yymsp[-1].minor.yy516 = yymsp[0].minor.yy516;} + break; + case 330: /* frame_exclude ::= NO OTHERS */ + case 331: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==331); +{yymsp[-1].minor.yy516 = yymsp[-1].major; /*A-overwrites-X*/} + break; + case 332: /* frame_exclude ::= GROUP|TIES */ +{yymsp[0].minor.yy516 = yymsp[0].major; /*A-overwrites-X*/} + break; + case 333: /* window_clause ::= WINDOW windowdefn_list */ +{ yymsp[-1].minor.yy41 = yymsp[0].minor.yy41; } + break; + case 334: /* filter_over ::= filter_clause over_clause */ +{ + if( yymsp[0].minor.yy41 ){ + yymsp[0].minor.yy41->pFilter = yymsp[-1].minor.yy528; + }else{ + sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy528); + } + yylhsminor.yy41 = yymsp[0].minor.yy41; +} + yymsp[-1].minor.yy41 = yylhsminor.yy41; + break; + case 336: /* filter_over ::= filter_clause */ +{ + yylhsminor.yy41 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window)); + if( yylhsminor.yy41 ){ + yylhsminor.yy41->eFrmType = TK_FILTER; + yylhsminor.yy41->pFilter = yymsp[0].minor.yy528; + }else{ + sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy528); + } +} + yymsp[0].minor.yy41 = yylhsminor.yy41; + break; + case 337: /* over_clause ::= OVER LP window RP */ +{ + yymsp[-3].minor.yy41 = yymsp[-1].minor.yy41; + assert( yymsp[-3].minor.yy41!=0 ); +} + break; + case 338: /* over_clause ::= OVER nm */ +{ + yymsp[-1].minor.yy41 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window)); + if( yymsp[-1].minor.yy41 ){ + yymsp[-1].minor.yy41->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n); + } +} + break; + case 339: /* filter_clause ::= FILTER LP WHERE expr RP */ +{ yymsp[-4].minor.yy528 = yymsp[-1].minor.yy528; } + break; + default: + /* (340) input ::= cmdlist */ yytestcase(yyruleno==340); + /* (341) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==341); + /* (342) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=342); + /* (343) ecmd ::= SEMI */ yytestcase(yyruleno==343); + /* (344) ecmd ::= cmdx SEMI */ yytestcase(yyruleno==344); + /* (345) ecmd ::= explain cmdx SEMI (NEVER REDUCES) */ assert(yyruleno!=345); + /* (346) trans_opt ::= */ yytestcase(yyruleno==346); + /* (347) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==347); + /* (348) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==348); + /* (349) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==349); + /* (350) savepoint_opt ::= */ yytestcase(yyruleno==350); + /* (351) cmd ::= create_table create_table_args */ yytestcase(yyruleno==351); + /* (352) table_option_set ::= table_option (OPTIMIZED OUT) */ assert(yyruleno!=352); + /* (353) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==353); + /* (354) columnlist ::= columnname carglist */ yytestcase(yyruleno==354); + /* (355) nm ::= ID|INDEXED|JOIN_KW */ yytestcase(yyruleno==355); + /* (356) nm ::= STRING */ yytestcase(yyruleno==356); + /* (357) typetoken ::= typename */ yytestcase(yyruleno==357); + /* (358) typename ::= ID|STRING */ yytestcase(yyruleno==358); + /* (359) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=359); + /* (360) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=360); + /* (361) carglist ::= carglist ccons */ yytestcase(yyruleno==361); + /* (362) carglist ::= */ yytestcase(yyruleno==362); + /* (363) ccons ::= NULL onconf */ yytestcase(yyruleno==363); + /* (364) ccons ::= GENERATED ALWAYS AS generated */ yytestcase(yyruleno==364); + /* (365) ccons ::= AS generated */ yytestcase(yyruleno==365); + /* (366) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==366); + /* (367) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==367); + /* (368) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=368); + /* (369) tconscomma ::= */ yytestcase(yyruleno==369); + /* (370) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=370); + /* (371) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=371); + /* (372) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=372); + /* (373) oneselect ::= values */ yytestcase(yyruleno==373); + /* (374) sclp ::= selcollist COMMA */ yytestcase(yyruleno==374); + /* (375) as ::= ID|STRING */ yytestcase(yyruleno==375); + /* (376) indexed_opt ::= indexed_by (OPTIMIZED OUT) */ assert(yyruleno!=376); + /* (377) returning ::= */ yytestcase(yyruleno==377); + /* (378) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=378); + /* (379) likeop ::= LIKE_KW|MATCH */ yytestcase(yyruleno==379); + /* (380) case_operand ::= expr */ yytestcase(yyruleno==380); + /* (381) exprlist ::= nexprlist */ yytestcase(yyruleno==381); + /* (382) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=382); + /* (383) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=383); + /* (384) nmnum ::= ON */ yytestcase(yyruleno==384); + /* (385) nmnum ::= DELETE */ yytestcase(yyruleno==385); + /* (386) nmnum ::= DEFAULT */ yytestcase(yyruleno==386); + /* (387) plus_num ::= INTEGER|FLOAT */ yytestcase(yyruleno==387); + /* (388) foreach_clause ::= */ yytestcase(yyruleno==388); + /* (389) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==389); + /* (390) trnm ::= nm */ yytestcase(yyruleno==390); + /* (391) tridxby ::= */ yytestcase(yyruleno==391); + /* (392) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==392); + /* (393) database_kw_opt ::= */ yytestcase(yyruleno==393); + /* (394) kwcolumn_opt ::= */ yytestcase(yyruleno==394); + /* (395) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==395); + /* (396) vtabarglist ::= vtabarg */ yytestcase(yyruleno==396); + /* (397) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==397); + /* (398) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==398); + /* (399) anylist ::= */ yytestcase(yyruleno==399); + /* (400) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==400); + /* (401) anylist ::= anylist ANY */ yytestcase(yyruleno==401); + /* (402) with ::= */ yytestcase(yyruleno==402); + break; +/********** End reduce actions ************************************************/ + }; + assert( yyrulenoYY_MAX_SHIFT && yyact<=YY_MAX_SHIFTREDUCE) ); + + /* It is not possible for a REDUCE to be followed by an error */ + assert( yyact!=YY_ERROR_ACTION ); + + yymsp += yysize+1; + yypParser->yytos = yymsp; + yymsp->stateno = (YYACTIONTYPE)yyact; + yymsp->major = (YYCODETYPE)yygoto; + yyTraceShift(yypParser, yyact, "... then shift"); + return yyact; +} + +/* +** The following code executes when the parse fails +*/ +#ifndef YYNOERRORRECOVERY +static void yy_parse_failed( + yyParser *yypParser /* The parser */ +){ + sqlite3ParserARG_FETCH + sqlite3ParserCTX_FETCH +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt); + } +#endif + while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will be executed whenever the + ** parser fails */ +/************ Begin %parse_failure code ***************************************/ +/************ End %parse_failure code *****************************************/ + sqlite3ParserARG_STORE /* Suppress warning about unused %extra_argument variable */ + sqlite3ParserCTX_STORE +} +#endif /* YYNOERRORRECOVERY */ + +/* +** The following code executes when a syntax error first occurs. +*/ +static void yy_syntax_error( + yyParser *yypParser, /* The parser */ + int yymajor, /* The major type of the error token */ + sqlite3ParserTOKENTYPE yyminor /* The minor type of the error token */ +){ + sqlite3ParserARG_FETCH + sqlite3ParserCTX_FETCH +#define TOKEN yyminor +/************ Begin %syntax_error code ****************************************/ + + UNUSED_PARAMETER(yymajor); /* Silence some compiler warnings */ + if( TOKEN.z[0] ){ + sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN); + }else{ + sqlite3ErrorMsg(pParse, "incomplete input"); + } +/************ End %syntax_error code ******************************************/ + sqlite3ParserARG_STORE /* Suppress warning about unused %extra_argument variable */ + sqlite3ParserCTX_STORE +} + +/* +** The following is executed when the parser accepts +*/ +static void yy_accept( + yyParser *yypParser /* The parser */ +){ + sqlite3ParserARG_FETCH + sqlite3ParserCTX_FETCH +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt); + } +#endif +#ifndef YYNOERRORRECOVERY + yypParser->yyerrcnt = -1; +#endif + assert( yypParser->yytos==yypParser->yystack ); + /* Here code is inserted which will be executed whenever the + ** parser accepts */ +/*********** Begin %parse_accept code *****************************************/ +/*********** End %parse_accept code *******************************************/ + sqlite3ParserARG_STORE /* Suppress warning about unused %extra_argument variable */ + sqlite3ParserCTX_STORE +} + +/* The main parser program. +** The first argument is a pointer to a structure obtained from +** "sqlite3ParserAlloc" which describes the current state of the parser. +** The second argument is the major token number. The third is +** the minor token. The fourth optional argument is whatever the +** user wants (and specified in the grammar) and is available for +** use by the action routines. +** +** Inputs: +**
    +**
  • A pointer to the parser (an opaque structure.) +**
  • The major token number. +**
  • The minor token number. +**
  • An option argument of a grammar-specified type. +**
+** +** Outputs: +** None. +*/ +SQLITE_PRIVATE void sqlite3Parser( + void *yyp, /* The parser */ + int yymajor, /* The major token code number */ + sqlite3ParserTOKENTYPE yyminor /* The value for the token */ + sqlite3ParserARG_PDECL /* Optional %extra_argument parameter */ +){ + YYMINORTYPE yyminorunion; + YYACTIONTYPE yyact; /* The parser action. */ +#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY) + int yyendofinput; /* True if we are at the end of input */ +#endif +#ifdef YYERRORSYMBOL + int yyerrorhit = 0; /* True if yymajor has invoked an error */ +#endif + yyParser *yypParser = (yyParser*)yyp; /* The parser */ + sqlite3ParserCTX_FETCH + sqlite3ParserARG_STORE + + assert( yypParser->yytos!=0 ); +#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY) + yyendofinput = (yymajor==0); +#endif + + yyact = yypParser->yytos->stateno; +#ifndef NDEBUG + if( yyTraceFILE ){ + if( yyact < YY_MIN_REDUCE ){ + fprintf(yyTraceFILE,"%sInput '%s' in state %d\n", + yyTracePrompt,yyTokenName[yymajor],yyact); + }else{ + fprintf(yyTraceFILE,"%sInput '%s' with pending reduce %d\n", + yyTracePrompt,yyTokenName[yymajor],yyact-YY_MIN_REDUCE); + } + } +#endif + + while(1){ /* Exit by "break" */ + assert( yypParser->yytos>=yypParser->yystack ); + assert( yyact==yypParser->yytos->stateno ); + yyact = yy_find_shift_action((YYCODETYPE)yymajor,yyact); + if( yyact >= YY_MIN_REDUCE ){ + unsigned int yyruleno = yyact - YY_MIN_REDUCE; /* Reduce by this rule */ +#ifndef NDEBUG + assert( yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ); + if( yyTraceFILE ){ + int yysize = yyRuleInfoNRhs[yyruleno]; + if( yysize ){ + fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n", + yyTracePrompt, + yyruleno, yyRuleName[yyruleno], + yyrulenoyytos[yysize].stateno); + }else{ + fprintf(yyTraceFILE, "%sReduce %d [%s]%s.\n", + yyTracePrompt, yyruleno, yyRuleName[yyruleno], + yyrulenoyytos - yypParser->yystack)>yypParser->yyhwm ){ + yypParser->yyhwm++; + assert( yypParser->yyhwm == + (int)(yypParser->yytos - yypParser->yystack)); + } +#endif +#if YYSTACKDEPTH>0 + if( yypParser->yytos>=yypParser->yystackEnd ){ + yyStackOverflow(yypParser); + break; + } +#else + if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){ + if( yyGrowStack(yypParser) ){ + yyStackOverflow(yypParser); + break; + } + } +#endif + } + yyact = yy_reduce(yypParser,yyruleno,yymajor,yyminor sqlite3ParserCTX_PARAM); + }else if( yyact <= YY_MAX_SHIFTREDUCE ){ + yy_shift(yypParser,yyact,(YYCODETYPE)yymajor,yyminor); +#ifndef YYNOERRORRECOVERY + yypParser->yyerrcnt--; +#endif + break; + }else if( yyact==YY_ACCEPT_ACTION ){ + yypParser->yytos--; + yy_accept(yypParser); + return; + }else{ + assert( yyact == YY_ERROR_ACTION ); + yyminorunion.yy0 = yyminor; +#ifdef YYERRORSYMBOL + int yymx; +#endif +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt); + } +#endif +#ifdef YYERRORSYMBOL + /* A syntax error has occurred. + ** The response to an error depends upon whether or not the + ** grammar defines an error token "ERROR". + ** + ** This is what we do if the grammar does define ERROR: + ** + ** * Call the %syntax_error function. + ** + ** * Begin popping the stack until we enter a state where + ** it is legal to shift the error symbol, then shift + ** the error symbol. + ** + ** * Set the error count to three. + ** + ** * Begin accepting and shifting new tokens. No new error + ** processing will occur until three tokens have been + ** shifted successfully. + ** + */ + if( yypParser->yyerrcnt<0 ){ + yy_syntax_error(yypParser,yymajor,yyminor); + } + yymx = yypParser->yytos->major; + if( yymx==YYERRORSYMBOL || yyerrorhit ){ +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sDiscard input token %s\n", + yyTracePrompt,yyTokenName[yymajor]); + } +#endif + yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion); + yymajor = YYNOCODE; + }else{ + while( yypParser->yytos > yypParser->yystack ){ + yyact = yy_find_reduce_action(yypParser->yytos->stateno, + YYERRORSYMBOL); + if( yyact<=YY_MAX_SHIFTREDUCE ) break; + yy_pop_parser_stack(yypParser); + } + if( yypParser->yytos <= yypParser->yystack || yymajor==0 ){ + yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); + yy_parse_failed(yypParser); +#ifndef YYNOERRORRECOVERY + yypParser->yyerrcnt = -1; +#endif + yymajor = YYNOCODE; + }else if( yymx!=YYERRORSYMBOL ){ + yy_shift(yypParser,yyact,YYERRORSYMBOL,yyminor); + } + } + yypParser->yyerrcnt = 3; + yyerrorhit = 1; + if( yymajor==YYNOCODE ) break; + yyact = yypParser->yytos->stateno; +#elif defined(YYNOERRORRECOVERY) + /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to + ** do any kind of error recovery. Instead, simply invoke the syntax + ** error routine and continue going as if nothing had happened. + ** + ** Applications can set this macro (for example inside %include) if + ** they intend to abandon the parse upon the first syntax error seen. + */ + yy_syntax_error(yypParser,yymajor, yyminor); + yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); + break; +#else /* YYERRORSYMBOL is not defined */ + /* This is what we do if the grammar does not define ERROR: + ** + ** * Report an error message, and throw away the input token. + ** + ** * If the input token is $, then fail the parse. + ** + ** As before, subsequent error messages are suppressed until + ** three input tokens have been successfully shifted. + */ + if( yypParser->yyerrcnt<=0 ){ + yy_syntax_error(yypParser,yymajor, yyminor); + } + yypParser->yyerrcnt = 3; + yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); + if( yyendofinput ){ + yy_parse_failed(yypParser); +#ifndef YYNOERRORRECOVERY + yypParser->yyerrcnt = -1; +#endif + } + break; +#endif + } + } +#ifndef NDEBUG + if( yyTraceFILE ){ + yyStackEntry *i; + char cDiv = '['; + fprintf(yyTraceFILE,"%sReturn. Stack=",yyTracePrompt); + for(i=&yypParser->yystack[1]; i<=yypParser->yytos; i++){ + fprintf(yyTraceFILE,"%c%s", cDiv, yyTokenName[i->major]); + cDiv = ' '; + } + fprintf(yyTraceFILE,"]\n"); + } +#endif + return; +} + +/* +** Return the fallback token corresponding to canonical token iToken, or +** 0 if iToken has no fallback. +*/ +SQLITE_PRIVATE int sqlite3ParserFallback(int iToken){ +#ifdef YYFALLBACK + assert( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) ); + return yyFallback[iToken]; +#else + (void)iToken; + return 0; +#endif +} + +/************** End of parse.c ***********************************************/ +/************** Begin file tokenize.c ****************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** An tokenizer for SQL +** +** This file contains C code that splits an SQL input string up into +** individual tokens and sends those tokens one-by-one over to the +** parser for analysis. +*/ +/* #include "sqliteInt.h" */ +/* #include */ + +/* Character classes for tokenizing +** +** In the sqlite3GetToken() function, a switch() on aiClass[c] is implemented +** using a lookup table, whereas a switch() directly on c uses a binary search. +** The lookup table is much faster. To maximize speed, and to ensure that +** a lookup table is used, all of the classes need to be small integers and +** all of them need to be used within the switch. +*/ +#define CC_X 0 /* The letter 'x', or start of BLOB literal */ +#define CC_KYWD0 1 /* First letter of a keyword */ +#define CC_KYWD 2 /* Alphabetics or '_'. Usable in a keyword */ +#define CC_DIGIT 3 /* Digits */ +#define CC_DOLLAR 4 /* '$' */ +#define CC_VARALPHA 5 /* '@', '#', ':'. Alphabetic SQL variables */ +#define CC_VARNUM 6 /* '?'. Numeric SQL variables */ +#define CC_SPACE 7 /* Space characters */ +#define CC_QUOTE 8 /* '"', '\'', or '`'. String literals, quoted ids */ +#define CC_QUOTE2 9 /* '['. [...] style quoted ids */ +#define CC_PIPE 10 /* '|'. Bitwise OR or concatenate */ +#define CC_MINUS 11 /* '-'. Minus or SQL-style comment */ +#define CC_LT 12 /* '<'. Part of < or <= or <> */ +#define CC_GT 13 /* '>'. Part of > or >= */ +#define CC_EQ 14 /* '='. Part of = or == */ +#define CC_BANG 15 /* '!'. Part of != */ +#define CC_SLASH 16 /* '/'. / or c-style comment */ +#define CC_LP 17 /* '(' */ +#define CC_RP 18 /* ')' */ +#define CC_SEMI 19 /* ';' */ +#define CC_PLUS 20 /* '+' */ +#define CC_STAR 21 /* '*' */ +#define CC_PERCENT 22 /* '%' */ +#define CC_COMMA 23 /* ',' */ +#define CC_AND 24 /* '&' */ +#define CC_TILDA 25 /* '~' */ +#define CC_DOT 26 /* '.' */ +#define CC_ID 27 /* unicode characters usable in IDs */ +#define CC_ILLEGAL 28 /* Illegal character */ +#define CC_NUL 29 /* 0x00 */ +#define CC_BOM 30 /* First byte of UTF8 BOM: 0xEF 0xBB 0xBF */ + +static const unsigned char aiClass[] = { +#ifdef SQLITE_ASCII +/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xa xb xc xd xe xf */ +/* 0x */ 29, 28, 28, 28, 28, 28, 28, 28, 28, 7, 7, 28, 7, 7, 28, 28, +/* 1x */ 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +/* 2x */ 7, 15, 8, 5, 4, 22, 24, 8, 17, 18, 21, 20, 23, 11, 26, 16, +/* 3x */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 19, 12, 14, 13, 6, +/* 4x */ 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, +/* 5x */ 1, 1, 1, 1, 1, 1, 1, 1, 0, 2, 2, 9, 28, 28, 28, 2, +/* 6x */ 8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, +/* 7x */ 1, 1, 1, 1, 1, 1, 1, 1, 0, 2, 2, 28, 10, 28, 25, 28, +/* 8x */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +/* 9x */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +/* Ax */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +/* Bx */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +/* Cx */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +/* Dx */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +/* Ex */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 30, +/* Fx */ 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27 +#endif +#ifdef SQLITE_EBCDIC +/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xa xb xc xd xe xf */ +/* 0x */ 29, 28, 28, 28, 28, 7, 28, 28, 28, 28, 28, 28, 7, 7, 28, 28, +/* 1x */ 28, 28, 28, 28, 28, 7, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +/* 2x */ 28, 28, 28, 28, 28, 7, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +/* 3x */ 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +/* 4x */ 7, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 26, 12, 17, 20, 10, +/* 5x */ 24, 28, 28, 28, 28, 28, 28, 28, 28, 28, 15, 4, 21, 18, 19, 28, +/* 6x */ 11, 16, 28, 28, 28, 28, 28, 28, 28, 28, 28, 23, 22, 2, 13, 6, +/* 7x */ 28, 28, 28, 28, 28, 28, 28, 28, 28, 8, 5, 5, 5, 8, 14, 8, +/* 8x */ 28, 1, 1, 1, 1, 1, 1, 1, 1, 1, 28, 28, 28, 28, 28, 28, +/* 9x */ 28, 1, 1, 1, 1, 1, 1, 1, 1, 1, 28, 28, 28, 28, 28, 28, +/* Ax */ 28, 25, 1, 1, 1, 1, 1, 0, 2, 2, 28, 28, 28, 28, 28, 28, +/* Bx */ 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 9, 28, 28, 28, 28, 28, +/* Cx */ 28, 1, 1, 1, 1, 1, 1, 1, 1, 1, 28, 28, 28, 28, 28, 28, +/* Dx */ 28, 1, 1, 1, 1, 1, 1, 1, 1, 1, 28, 28, 28, 28, 28, 28, +/* Ex */ 28, 28, 1, 1, 1, 1, 1, 0, 2, 2, 28, 28, 28, 28, 28, 28, +/* Fx */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 28, 28, 28, 28, 28, 28, +#endif +}; + +/* +** The charMap() macro maps alphabetic characters (only) into their +** lower-case ASCII equivalent. On ASCII machines, this is just +** an upper-to-lower case map. On EBCDIC machines we also need +** to adjust the encoding. The mapping is only valid for alphabetics +** which are the only characters for which this feature is used. +** +** Used by keywordhash.h +*/ +#ifdef SQLITE_ASCII +# define charMap(X) sqlite3UpperToLower[(unsigned char)X] +#endif +#ifdef SQLITE_EBCDIC +# define charMap(X) ebcdicToAscii[(unsigned char)X] +const unsigned char ebcdicToAscii[] = { +/* 0 1 2 3 4 5 6 7 8 9 A B C D E F */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 1x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 2x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 3x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 4x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 5x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 0, /* 6x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 7x */ + 0, 97, 98, 99,100,101,102,103,104,105, 0, 0, 0, 0, 0, 0, /* 8x */ + 0,106,107,108,109,110,111,112,113,114, 0, 0, 0, 0, 0, 0, /* 9x */ + 0, 0,115,116,117,118,119,120,121,122, 0, 0, 0, 0, 0, 0, /* Ax */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Bx */ + 0, 97, 98, 99,100,101,102,103,104,105, 0, 0, 0, 0, 0, 0, /* Cx */ + 0,106,107,108,109,110,111,112,113,114, 0, 0, 0, 0, 0, 0, /* Dx */ + 0, 0,115,116,117,118,119,120,121,122, 0, 0, 0, 0, 0, 0, /* Ex */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Fx */ +}; +#endif + +/* +** The sqlite3KeywordCode function looks up an identifier to determine if +** it is a keyword. If it is a keyword, the token code of that keyword is +** returned. If the input is not a keyword, TK_ID is returned. +** +** The implementation of this routine was generated by a program, +** mkkeywordhash.c, located in the tool subdirectory of the distribution. +** The output of the mkkeywordhash.c program is written into a file +** named keywordhash.h and then included into this source file by +** the #include below. +*/ +/************** Include keywordhash.h in the middle of tokenize.c ************/ +/************** Begin file keywordhash.h *************************************/ +/***** This file contains automatically generated code ****** +** +** The code in this file has been automatically generated by +** +** sqlite/tool/mkkeywordhash.c +** +** The code in this file implements a function that determines whether +** or not a given identifier is really an SQL keyword. The same thing +** might be implemented more directly using a hand-written hash table. +** But by using this automatically generated code, the size of the code +** is substantially reduced. This is important for embedded applications +** on platforms with limited memory. +*/ +/* Hash score: 231 */ +/* zKWText[] encodes 1007 bytes of keyword text in 667 bytes */ +/* REINDEXEDESCAPEACHECKEYBEFOREIGNOREGEXPLAINSTEADDATABASELECT */ +/* ABLEFTHENDEFERRABLELSEXCLUDELETEMPORARYISNULLSAVEPOINTERSECT */ +/* IESNOTNULLIKEXCEPTRANSACTIONATURALTERAISEXCLUSIVEXISTS */ +/* CONSTRAINTOFFSETRIGGERANGENERATEDETACHAVINGLOBEGINNEREFERENCES */ +/* UNIQUERYWITHOUTERELEASEATTACHBETWEENOTHINGROUPSCASCADEFAULT */ +/* CASECOLLATECREATECURRENT_DATEIMMEDIATEJOINSERTMATCHPLANALYZE */ +/* PRAGMATERIALIZEDEFERREDISTINCTUPDATEVALUESVIRTUALWAYSWHENWHERE */ +/* CURSIVEABORTAFTERENAMEANDROPARTITIONAUTOINCREMENTCASTCOLUMN */ +/* COMMITCONFLICTCROSSCURRENT_TIMESTAMPRECEDINGFAILASTFILTER */ +/* EPLACEFIRSTFOLLOWINGFROMFULLIMITIFORDERESTRICTOTHERSOVER */ +/* ETURNINGRIGHTROLLBACKROWSUNBOUNDEDUNIONUSINGVACUUMVIEWINDOWBY */ +/* INITIALLYPRIMARY */ +static const char zKWText[666] = { + 'R','E','I','N','D','E','X','E','D','E','S','C','A','P','E','A','C','H', + 'E','C','K','E','Y','B','E','F','O','R','E','I','G','N','O','R','E','G', + 'E','X','P','L','A','I','N','S','T','E','A','D','D','A','T','A','B','A', + 'S','E','L','E','C','T','A','B','L','E','F','T','H','E','N','D','E','F', + 'E','R','R','A','B','L','E','L','S','E','X','C','L','U','D','E','L','E', + 'T','E','M','P','O','R','A','R','Y','I','S','N','U','L','L','S','A','V', + 'E','P','O','I','N','T','E','R','S','E','C','T','I','E','S','N','O','T', + 'N','U','L','L','I','K','E','X','C','E','P','T','R','A','N','S','A','C', + 'T','I','O','N','A','T','U','R','A','L','T','E','R','A','I','S','E','X', + 'C','L','U','S','I','V','E','X','I','S','T','S','C','O','N','S','T','R', + 'A','I','N','T','O','F','F','S','E','T','R','I','G','G','E','R','A','N', + 'G','E','N','E','R','A','T','E','D','E','T','A','C','H','A','V','I','N', + 'G','L','O','B','E','G','I','N','N','E','R','E','F','E','R','E','N','C', + 'E','S','U','N','I','Q','U','E','R','Y','W','I','T','H','O','U','T','E', + 'R','E','L','E','A','S','E','A','T','T','A','C','H','B','E','T','W','E', + 'E','N','O','T','H','I','N','G','R','O','U','P','S','C','A','S','C','A', + 'D','E','F','A','U','L','T','C','A','S','E','C','O','L','L','A','T','E', + 'C','R','E','A','T','E','C','U','R','R','E','N','T','_','D','A','T','E', + 'I','M','M','E','D','I','A','T','E','J','O','I','N','S','E','R','T','M', + 'A','T','C','H','P','L','A','N','A','L','Y','Z','E','P','R','A','G','M', + 'A','T','E','R','I','A','L','I','Z','E','D','E','F','E','R','R','E','D', + 'I','S','T','I','N','C','T','U','P','D','A','T','E','V','A','L','U','E', + 'S','V','I','R','T','U','A','L','W','A','Y','S','W','H','E','N','W','H', + 'E','R','E','C','U','R','S','I','V','E','A','B','O','R','T','A','F','T', + 'E','R','E','N','A','M','E','A','N','D','R','O','P','A','R','T','I','T', + 'I','O','N','A','U','T','O','I','N','C','R','E','M','E','N','T','C','A', + 'S','T','C','O','L','U','M','N','C','O','M','M','I','T','C','O','N','F', + 'L','I','C','T','C','R','O','S','S','C','U','R','R','E','N','T','_','T', + 'I','M','E','S','T','A','M','P','R','E','C','E','D','I','N','G','F','A', + 'I','L','A','S','T','F','I','L','T','E','R','E','P','L','A','C','E','F', + 'I','R','S','T','F','O','L','L','O','W','I','N','G','F','R','O','M','F', + 'U','L','L','I','M','I','T','I','F','O','R','D','E','R','E','S','T','R', + 'I','C','T','O','T','H','E','R','S','O','V','E','R','E','T','U','R','N', + 'I','N','G','R','I','G','H','T','R','O','L','L','B','A','C','K','R','O', + 'W','S','U','N','B','O','U','N','D','E','D','U','N','I','O','N','U','S', + 'I','N','G','V','A','C','U','U','M','V','I','E','W','I','N','D','O','W', + 'B','Y','I','N','I','T','I','A','L','L','Y','P','R','I','M','A','R','Y', +}; +/* aKWHash[i] is the hash value for the i-th keyword */ +static const unsigned char aKWHash[127] = { + 84, 92, 134, 82, 105, 29, 0, 0, 94, 0, 85, 72, 0, + 53, 35, 86, 15, 0, 42, 97, 54, 89, 135, 19, 0, 0, + 140, 0, 40, 129, 0, 22, 107, 0, 9, 0, 0, 123, 80, + 0, 78, 6, 0, 65, 103, 147, 0, 136, 115, 0, 0, 48, + 0, 90, 24, 0, 17, 0, 27, 70, 23, 26, 5, 60, 142, + 110, 122, 0, 73, 91, 71, 145, 61, 120, 74, 0, 49, 0, + 11, 41, 0, 113, 0, 0, 0, 109, 10, 111, 116, 125, 14, + 50, 124, 0, 100, 0, 18, 121, 144, 56, 130, 139, 88, 83, + 37, 30, 126, 0, 0, 108, 51, 131, 128, 0, 34, 0, 0, + 132, 0, 98, 38, 39, 0, 20, 45, 117, 93, +}; +/* aKWNext[] forms the hash collision chain. If aKWHash[i]==0 +** then the i-th keyword has no more hash collisions. Otherwise, +** the next keyword with the same hash is aKWHash[i]-1. */ +static const unsigned char aKWNext[148] = {0, + 0, 0, 0, 0, 4, 0, 43, 0, 0, 106, 114, 0, 0, + 0, 2, 0, 0, 143, 0, 0, 0, 13, 0, 0, 0, 0, + 141, 0, 0, 119, 52, 0, 0, 137, 12, 0, 0, 62, 0, + 138, 0, 133, 0, 0, 36, 0, 0, 28, 77, 0, 0, 0, + 0, 59, 0, 47, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 69, 0, 0, 0, 0, 0, 146, 3, 0, 58, 0, 1, + 75, 0, 0, 0, 31, 0, 0, 0, 0, 0, 127, 0, 104, + 0, 64, 66, 63, 0, 0, 0, 0, 0, 46, 0, 16, 8, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 81, 101, 0, + 112, 21, 7, 67, 0, 79, 96, 118, 0, 0, 68, 0, 0, + 99, 44, 0, 55, 0, 76, 0, 95, 32, 33, 57, 25, 0, + 102, 0, 0, 87, +}; +/* aKWLen[i] is the length (in bytes) of the i-th keyword */ +static const unsigned char aKWLen[148] = {0, + 7, 7, 5, 4, 6, 4, 5, 3, 6, 7, 3, 6, 6, + 7, 7, 3, 8, 2, 6, 5, 4, 4, 3, 10, 4, 7, + 6, 9, 4, 2, 6, 5, 9, 9, 4, 7, 3, 2, 4, + 4, 6, 11, 6, 2, 7, 5, 5, 9, 6, 10, 4, 6, + 2, 3, 7, 5, 9, 6, 6, 4, 5, 5, 10, 6, 5, + 7, 4, 5, 7, 6, 7, 7, 6, 5, 7, 3, 7, 4, + 7, 6, 12, 9, 4, 6, 5, 4, 7, 6, 12, 8, 8, + 2, 6, 6, 7, 6, 4, 5, 9, 5, 5, 6, 3, 4, + 9, 13, 2, 2, 4, 6, 6, 8, 5, 17, 12, 7, 9, + 4, 4, 6, 7, 5, 9, 4, 4, 5, 2, 5, 8, 6, + 4, 9, 5, 8, 4, 3, 9, 5, 5, 6, 4, 6, 2, + 2, 9, 3, 7, +}; +/* aKWOffset[i] is the index into zKWText[] of the start of +** the text for the i-th keyword. */ +static const unsigned short int aKWOffset[148] = {0, + 0, 2, 2, 8, 9, 14, 16, 20, 23, 25, 25, 29, 33, + 36, 41, 46, 48, 53, 54, 59, 62, 65, 67, 69, 78, 81, + 86, 90, 90, 94, 99, 101, 105, 111, 119, 123, 123, 123, 126, + 129, 132, 137, 142, 146, 147, 152, 156, 160, 168, 174, 181, 184, + 184, 187, 189, 195, 198, 206, 211, 216, 219, 222, 226, 236, 239, + 244, 244, 248, 252, 259, 265, 271, 277, 277, 283, 284, 288, 295, + 299, 306, 312, 324, 333, 335, 341, 346, 348, 355, 359, 370, 377, + 378, 385, 391, 397, 402, 408, 412, 415, 424, 429, 433, 439, 441, + 444, 453, 455, 457, 466, 470, 476, 482, 490, 495, 495, 495, 511, + 520, 523, 527, 532, 539, 544, 553, 557, 560, 565, 567, 571, 579, + 585, 588, 597, 602, 610, 610, 614, 623, 628, 633, 639, 642, 645, + 648, 650, 655, 659, +}; +/* aKWCode[i] is the parser symbol code for the i-th keyword */ +static const unsigned char aKWCode[148] = {0, + TK_REINDEX, TK_INDEXED, TK_INDEX, TK_DESC, TK_ESCAPE, + TK_EACH, TK_CHECK, TK_KEY, TK_BEFORE, TK_FOREIGN, + TK_FOR, TK_IGNORE, TK_LIKE_KW, TK_EXPLAIN, TK_INSTEAD, + TK_ADD, TK_DATABASE, TK_AS, TK_SELECT, TK_TABLE, + TK_JOIN_KW, TK_THEN, TK_END, TK_DEFERRABLE, TK_ELSE, + TK_EXCLUDE, TK_DELETE, TK_TEMP, TK_TEMP, TK_OR, + TK_ISNULL, TK_NULLS, TK_SAVEPOINT, TK_INTERSECT, TK_TIES, + TK_NOTNULL, TK_NOT, TK_NO, TK_NULL, TK_LIKE_KW, + TK_EXCEPT, TK_TRANSACTION,TK_ACTION, TK_ON, TK_JOIN_KW, + TK_ALTER, TK_RAISE, TK_EXCLUSIVE, TK_EXISTS, TK_CONSTRAINT, + TK_INTO, TK_OFFSET, TK_OF, TK_SET, TK_TRIGGER, + TK_RANGE, TK_GENERATED, TK_DETACH, TK_HAVING, TK_LIKE_KW, + TK_BEGIN, TK_JOIN_KW, TK_REFERENCES, TK_UNIQUE, TK_QUERY, + TK_WITHOUT, TK_WITH, TK_JOIN_KW, TK_RELEASE, TK_ATTACH, + TK_BETWEEN, TK_NOTHING, TK_GROUPS, TK_GROUP, TK_CASCADE, + TK_ASC, TK_DEFAULT, TK_CASE, TK_COLLATE, TK_CREATE, + TK_CTIME_KW, TK_IMMEDIATE, TK_JOIN, TK_INSERT, TK_MATCH, + TK_PLAN, TK_ANALYZE, TK_PRAGMA, TK_MATERIALIZED, TK_DEFERRED, + TK_DISTINCT, TK_IS, TK_UPDATE, TK_VALUES, TK_VIRTUAL, + TK_ALWAYS, TK_WHEN, TK_WHERE, TK_RECURSIVE, TK_ABORT, + TK_AFTER, TK_RENAME, TK_AND, TK_DROP, TK_PARTITION, + TK_AUTOINCR, TK_TO, TK_IN, TK_CAST, TK_COLUMNKW, + TK_COMMIT, TK_CONFLICT, TK_JOIN_KW, TK_CTIME_KW, TK_CTIME_KW, + TK_CURRENT, TK_PRECEDING, TK_FAIL, TK_LAST, TK_FILTER, + TK_REPLACE, TK_FIRST, TK_FOLLOWING, TK_FROM, TK_JOIN_KW, + TK_LIMIT, TK_IF, TK_ORDER, TK_RESTRICT, TK_OTHERS, + TK_OVER, TK_RETURNING, TK_JOIN_KW, TK_ROLLBACK, TK_ROWS, + TK_ROW, TK_UNBOUNDED, TK_UNION, TK_USING, TK_VACUUM, + TK_VIEW, TK_WINDOW, TK_DO, TK_BY, TK_INITIALLY, + TK_ALL, TK_PRIMARY, +}; +/* Hash table decoded: +** 0: INSERT +** 1: IS +** 2: ROLLBACK TRIGGER +** 3: IMMEDIATE +** 4: PARTITION +** 5: TEMP +** 6: +** 7: +** 8: VALUES WITHOUT +** 9: +** 10: MATCH +** 11: NOTHING +** 12: +** 13: OF +** 14: TIES IGNORE +** 15: PLAN +** 16: INSTEAD INDEXED +** 17: +** 18: TRANSACTION RIGHT +** 19: WHEN +** 20: SET HAVING +** 21: MATERIALIZED IF +** 22: ROWS +** 23: SELECT +** 24: +** 25: +** 26: VACUUM SAVEPOINT +** 27: +** 28: LIKE UNION VIRTUAL REFERENCES +** 29: RESTRICT +** 30: +** 31: THEN REGEXP +** 32: TO +** 33: +** 34: BEFORE +** 35: +** 36: +** 37: FOLLOWING COLLATE CASCADE +** 38: CREATE +** 39: +** 40: CASE REINDEX +** 41: EACH +** 42: +** 43: QUERY +** 44: AND ADD +** 45: PRIMARY ANALYZE +** 46: +** 47: ROW ASC DETACH +** 48: CURRENT_TIME CURRENT_DATE +** 49: +** 50: +** 51: EXCLUSIVE TEMPORARY +** 52: +** 53: DEFERRED +** 54: DEFERRABLE +** 55: +** 56: DATABASE +** 57: +** 58: DELETE VIEW GENERATED +** 59: ATTACH +** 60: END +** 61: EXCLUDE +** 62: ESCAPE DESC +** 63: GLOB +** 64: WINDOW ELSE +** 65: COLUMN +** 66: FIRST +** 67: +** 68: GROUPS ALL +** 69: DISTINCT DROP KEY +** 70: BETWEEN +** 71: INITIALLY +** 72: BEGIN +** 73: FILTER CHECK ACTION +** 74: GROUP INDEX +** 75: +** 76: EXISTS DEFAULT +** 77: +** 78: FOR CURRENT_TIMESTAMP +** 79: EXCEPT +** 80: +** 81: CROSS +** 82: +** 83: +** 84: +** 85: CAST +** 86: FOREIGN AUTOINCREMENT +** 87: COMMIT +** 88: CURRENT AFTER ALTER +** 89: FULL FAIL CONFLICT +** 90: EXPLAIN +** 91: CONSTRAINT +** 92: FROM ALWAYS +** 93: +** 94: ABORT +** 95: +** 96: AS DO +** 97: REPLACE WITH RELEASE +** 98: BY RENAME +** 99: RANGE RAISE +** 100: OTHERS +** 101: USING NULLS +** 102: PRAGMA +** 103: JOIN ISNULL OFFSET +** 104: NOT +** 105: OR LAST LEFT +** 106: LIMIT +** 107: +** 108: +** 109: IN +** 110: INTO +** 111: OVER RECURSIVE +** 112: ORDER OUTER +** 113: +** 114: INTERSECT UNBOUNDED +** 115: +** 116: +** 117: RETURNING ON +** 118: +** 119: WHERE +** 120: NO INNER +** 121: NULL +** 122: +** 123: TABLE +** 124: NATURAL NOTNULL +** 125: PRECEDING +** 126: UPDATE UNIQUE +*/ +/* Check to see if z[0..n-1] is a keyword. If it is, write the +** parser symbol code for that keyword into *pType. Always +** return the integer n (the length of the token). */ +static int keywordCode(const char *z, int n, int *pType){ + int i, j; + const char *zKW; + if( n>=2 ){ + i = ((charMap(z[0])*4) ^ (charMap(z[n-1])*3) ^ n*1) % 127; + for(i=(int)aKWHash[i]; i>0; i=aKWNext[i]){ + if( aKWLen[i]!=n ) continue; + zKW = &zKWText[aKWOffset[i]]; +#ifdef SQLITE_ASCII + if( (z[0]&~0x20)!=zKW[0] ) continue; + if( (z[1]&~0x20)!=zKW[1] ) continue; + j = 2; + while( j=SQLITE_N_KEYWORD ) return SQLITE_ERROR; + i++; + *pzName = zKWText + aKWOffset[i]; + *pnName = aKWLen[i]; + return SQLITE_OK; +} +SQLITE_API int sqlite3_keyword_count(void){ return SQLITE_N_KEYWORD; } +SQLITE_API int sqlite3_keyword_check(const char *zName, int nName){ + return TK_ID!=sqlite3KeywordCode((const u8*)zName, nName); +} + +/************** End of keywordhash.h *****************************************/ +/************** Continuing where we left off in tokenize.c *******************/ + + +/* +** If X is a character that can be used in an identifier then +** IdChar(X) will be true. Otherwise it is false. +** +** For ASCII, any character with the high-order bit set is +** allowed in an identifier. For 7-bit characters, +** sqlite3IsIdChar[X] must be 1. +** +** For EBCDIC, the rules are more complex but have the same +** end result. +** +** Ticket #1066. the SQL standard does not allow '$' in the +** middle of identifiers. But many SQL implementations do. +** SQLite will allow '$' in identifiers for compatibility. +** But the feature is undocumented. +*/ +#ifdef SQLITE_ASCII +#define IdChar(C) ((sqlite3CtypeMap[(unsigned char)C]&0x46)!=0) +#endif +#ifdef SQLITE_EBCDIC +SQLITE_PRIVATE const char sqlite3IsEbcdicIdChar[] = { +/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */ + 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 4x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, /* 5x */ + 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, /* 6x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, /* 7x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, /* 8x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, /* 9x */ + 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, /* Ax */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Bx */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* Cx */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* Dx */ + 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* Ex */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, /* Fx */ +}; +#define IdChar(C) (((c=C)>=0x42 && sqlite3IsEbcdicIdChar[c-0x40])) +#endif + +/* Make the IdChar function accessible from ctime.c and alter.c */ +SQLITE_PRIVATE int sqlite3IsIdChar(u8 c){ return IdChar(c); } + +#ifndef SQLITE_OMIT_WINDOWFUNC +/* +** Return the id of the next token in string (*pz). Before returning, set +** (*pz) to point to the byte following the parsed token. +*/ +static int getToken(const unsigned char **pz){ + const unsigned char *z = *pz; + int t; /* Token type to return */ + do { + z += sqlite3GetToken(z, &t); + }while( t==TK_SPACE ); + if( t==TK_ID + || t==TK_STRING + || t==TK_JOIN_KW + || t==TK_WINDOW + || t==TK_OVER + || sqlite3ParserFallback(t)==TK_ID + ){ + t = TK_ID; + } + *pz = z; + return t; +} + +/* +** The following three functions are called immediately after the tokenizer +** reads the keywords WINDOW, OVER and FILTER, respectively, to determine +** whether the token should be treated as a keyword or an SQL identifier. +** This cannot be handled by the usual lemon %fallback method, due to +** the ambiguity in some constructions. e.g. +** +** SELECT sum(x) OVER ... +** +** In the above, "OVER" might be a keyword, or it might be an alias for the +** sum(x) expression. If a "%fallback ID OVER" directive were added to +** grammar, then SQLite would always treat "OVER" as an alias, making it +** impossible to call a window-function without a FILTER clause. +** +** WINDOW is treated as a keyword if: +** +** * the following token is an identifier, or a keyword that can fallback +** to being an identifier, and +** * the token after than one is TK_AS. +** +** OVER is a keyword if: +** +** * the previous token was TK_RP, and +** * the next token is either TK_LP or an identifier. +** +** FILTER is a keyword if: +** +** * the previous token was TK_RP, and +** * the next token is TK_LP. +*/ +static int analyzeWindowKeyword(const unsigned char *z){ + int t; + t = getToken(&z); + if( t!=TK_ID ) return TK_ID; + t = getToken(&z); + if( t!=TK_AS ) return TK_ID; + return TK_WINDOW; +} +static int analyzeOverKeyword(const unsigned char *z, int lastToken){ + if( lastToken==TK_RP ){ + int t = getToken(&z); + if( t==TK_LP || t==TK_ID ) return TK_OVER; + } + return TK_ID; +} +static int analyzeFilterKeyword(const unsigned char *z, int lastToken){ + if( lastToken==TK_RP && getToken(&z)==TK_LP ){ + return TK_FILTER; + } + return TK_ID; +} +#endif /* SQLITE_OMIT_WINDOWFUNC */ + +/* +** Return the length (in bytes) of the token that begins at z[0]. +** Store the token type in *tokenType before returning. +*/ +SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){ + int i, c; + switch( aiClass[*z] ){ /* Switch on the character-class of the first byte + ** of the token. See the comment on the CC_ defines + ** above. */ + case CC_SPACE: { + testcase( z[0]==' ' ); + testcase( z[0]=='\t' ); + testcase( z[0]=='\n' ); + testcase( z[0]=='\f' ); + testcase( z[0]=='\r' ); + for(i=1; sqlite3Isspace(z[i]); i++){} + *tokenType = TK_SPACE; + return i; + } + case CC_MINUS: { + if( z[1]=='-' ){ + for(i=2; (c=z[i])!=0 && c!='\n'; i++){} + *tokenType = TK_SPACE; /* IMP: R-22934-25134 */ + return i; + }else if( z[1]=='>' ){ + *tokenType = TK_PTR; + return 2 + (z[2]=='>'); + } + *tokenType = TK_MINUS; + return 1; + } + case CC_LP: { + *tokenType = TK_LP; + return 1; + } + case CC_RP: { + *tokenType = TK_RP; + return 1; + } + case CC_SEMI: { + *tokenType = TK_SEMI; + return 1; + } + case CC_PLUS: { + *tokenType = TK_PLUS; + return 1; + } + case CC_STAR: { + *tokenType = TK_STAR; + return 1; + } + case CC_SLASH: { + if( z[1]!='*' || z[2]==0 ){ + *tokenType = TK_SLASH; + return 1; + } + for(i=3, c=z[2]; (c!='*' || z[i]!='/') && (c=z[i])!=0; i++){} + if( c ) i++; + *tokenType = TK_SPACE; /* IMP: R-22934-25134 */ + return i; + } + case CC_PERCENT: { + *tokenType = TK_REM; + return 1; + } + case CC_EQ: { + *tokenType = TK_EQ; + return 1 + (z[1]=='='); + } + case CC_LT: { + if( (c=z[1])=='=' ){ + *tokenType = TK_LE; + return 2; + }else if( c=='>' ){ + *tokenType = TK_NE; + return 2; + }else if( c=='<' ){ + *tokenType = TK_LSHIFT; + return 2; + }else{ + *tokenType = TK_LT; + return 1; + } + } + case CC_GT: { + if( (c=z[1])=='=' ){ + *tokenType = TK_GE; + return 2; + }else if( c=='>' ){ + *tokenType = TK_RSHIFT; + return 2; + }else{ + *tokenType = TK_GT; + return 1; + } + } + case CC_BANG: { + if( z[1]!='=' ){ + *tokenType = TK_ILLEGAL; + return 1; + }else{ + *tokenType = TK_NE; + return 2; + } + } + case CC_PIPE: { + if( z[1]!='|' ){ + *tokenType = TK_BITOR; + return 1; + }else{ + *tokenType = TK_CONCAT; + return 2; + } + } + case CC_COMMA: { + *tokenType = TK_COMMA; + return 1; + } + case CC_AND: { + *tokenType = TK_BITAND; + return 1; + } + case CC_TILDA: { + *tokenType = TK_BITNOT; + return 1; + } + case CC_QUOTE: { + int delim = z[0]; + testcase( delim=='`' ); + testcase( delim=='\'' ); + testcase( delim=='"' ); + for(i=1; (c=z[i])!=0; i++){ + if( c==delim ){ + if( z[i+1]==delim ){ + i++; + }else{ + break; + } + } + } + if( c=='\'' ){ + *tokenType = TK_STRING; + return i+1; + }else if( c!=0 ){ + *tokenType = TK_ID; + return i+1; + }else{ + *tokenType = TK_ILLEGAL; + return i; + } + } + case CC_DOT: { +#ifndef SQLITE_OMIT_FLOATING_POINT + if( !sqlite3Isdigit(z[1]) ) +#endif + { + *tokenType = TK_DOT; + return 1; + } + /* If the next character is a digit, this is a floating point + ** number that begins with ".". Fall thru into the next case */ + /* no break */ deliberate_fall_through + } + case CC_DIGIT: { + testcase( z[0]=='0' ); testcase( z[0]=='1' ); testcase( z[0]=='2' ); + testcase( z[0]=='3' ); testcase( z[0]=='4' ); testcase( z[0]=='5' ); + testcase( z[0]=='6' ); testcase( z[0]=='7' ); testcase( z[0]=='8' ); + testcase( z[0]=='9' ); + *tokenType = TK_INTEGER; +#ifndef SQLITE_OMIT_HEX_INTEGER + if( z[0]=='0' && (z[1]=='x' || z[1]=='X') && sqlite3Isxdigit(z[2]) ){ + for(i=3; sqlite3Isxdigit(z[i]); i++){} + return i; + } +#endif + for(i=0; sqlite3Isdigit(z[i]); i++){} +#ifndef SQLITE_OMIT_FLOATING_POINT + if( z[i]=='.' ){ + i++; + while( sqlite3Isdigit(z[i]) ){ i++; } + *tokenType = TK_FLOAT; + } + if( (z[i]=='e' || z[i]=='E') && + ( sqlite3Isdigit(z[i+1]) + || ((z[i+1]=='+' || z[i+1]=='-') && sqlite3Isdigit(z[i+2])) + ) + ){ + i += 2; + while( sqlite3Isdigit(z[i]) ){ i++; } + *tokenType = TK_FLOAT; + } +#endif + while( IdChar(z[i]) ){ + *tokenType = TK_ILLEGAL; + i++; + } + return i; + } + case CC_QUOTE2: { + for(i=1, c=z[0]; c!=']' && (c=z[i])!=0; i++){} + *tokenType = c==']' ? TK_ID : TK_ILLEGAL; + return i; + } + case CC_VARNUM: { + *tokenType = TK_VARIABLE; + for(i=1; sqlite3Isdigit(z[i]); i++){} + return i; + } + case CC_DOLLAR: + case CC_VARALPHA: { + int n = 0; + testcase( z[0]=='$' ); testcase( z[0]=='@' ); + testcase( z[0]==':' ); testcase( z[0]=='#' ); + *tokenType = TK_VARIABLE; + for(i=1; (c=z[i])!=0; i++){ + if( IdChar(c) ){ + n++; +#ifndef SQLITE_OMIT_TCL_VARIABLE + }else if( c=='(' && n>0 ){ + do{ + i++; + }while( (c=z[i])!=0 && !sqlite3Isspace(c) && c!=')' ); + if( c==')' ){ + i++; + }else{ + *tokenType = TK_ILLEGAL; + } + break; + }else if( c==':' && z[i+1]==':' ){ + i++; +#endif + }else{ + break; + } + } + if( n==0 ) *tokenType = TK_ILLEGAL; + return i; + } + case CC_KYWD0: { + for(i=1; aiClass[z[i]]<=CC_KYWD; i++){} + if( IdChar(z[i]) ){ + /* This token started out using characters that can appear in keywords, + ** but z[i] is a character not allowed within keywords, so this must + ** be an identifier instead */ + i++; + break; + } + *tokenType = TK_ID; + return keywordCode((char*)z, i, tokenType); + } + case CC_X: { +#ifndef SQLITE_OMIT_BLOB_LITERAL + testcase( z[0]=='x' ); testcase( z[0]=='X' ); + if( z[1]=='\'' ){ + *tokenType = TK_BLOB; + for(i=2; sqlite3Isxdigit(z[i]); i++){} + if( z[i]!='\'' || i%2 ){ + *tokenType = TK_ILLEGAL; + while( z[i] && z[i]!='\'' ){ i++; } + } + if( z[i] ) i++; + return i; + } +#endif + /* If it is not a BLOB literal, then it must be an ID, since no + ** SQL keywords start with the letter 'x'. Fall through */ + /* no break */ deliberate_fall_through + } + case CC_KYWD: + case CC_ID: { + i = 1; + break; + } + case CC_BOM: { + if( z[1]==0xbb && z[2]==0xbf ){ + *tokenType = TK_SPACE; + return 3; + } + i = 1; + break; + } + case CC_NUL: { + *tokenType = TK_ILLEGAL; + return 0; + } + default: { + *tokenType = TK_ILLEGAL; + return 1; + } + } + while( IdChar(z[i]) ){ i++; } + *tokenType = TK_ID; + return i; +} + +/* +** Run the parser on the given SQL string. +*/ +SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql){ + int nErr = 0; /* Number of errors encountered */ + void *pEngine; /* The LEMON-generated LALR(1) parser */ + int n = 0; /* Length of the next token token */ + int tokenType; /* type of the next token */ + int lastTokenParsed = -1; /* type of the previous token */ + sqlite3 *db = pParse->db; /* The database connection */ + int mxSqlLen; /* Max length of an SQL string */ + Parse *pParentParse = 0; /* Outer parse context, if any */ +#ifdef sqlite3Parser_ENGINEALWAYSONSTACK + yyParser sEngine; /* Space to hold the Lemon-generated Parser object */ +#endif + VVA_ONLY( u8 startedWithOom = db->mallocFailed ); + + assert( zSql!=0 ); + mxSqlLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH]; + if( db->nVdbeActive==0 ){ + AtomicStore(&db->u1.isInterrupted, 0); + } + pParse->rc = SQLITE_OK; + pParse->zTail = zSql; +#ifdef SQLITE_DEBUG + if( db->flags & SQLITE_ParserTrace ){ + printf("parser: [[[%s]]]\n", zSql); + sqlite3ParserTrace(stdout, "parser: "); + }else{ + sqlite3ParserTrace(0, 0); + } +#endif +#ifdef sqlite3Parser_ENGINEALWAYSONSTACK + pEngine = &sEngine; + sqlite3ParserInit(pEngine, pParse); +#else + pEngine = sqlite3ParserAlloc(sqlite3Malloc, pParse); + if( pEngine==0 ){ + sqlite3OomFault(db); + return SQLITE_NOMEM_BKPT; + } +#endif + assert( pParse->pNewTable==0 ); + assert( pParse->pNewTrigger==0 ); + assert( pParse->nVar==0 ); + assert( pParse->pVList==0 ); + pParentParse = db->pParse; + db->pParse = pParse; + while( 1 ){ + n = sqlite3GetToken((u8*)zSql, &tokenType); + mxSqlLen -= n; + if( mxSqlLen<0 ){ + pParse->rc = SQLITE_TOOBIG; + pParse->nErr++; + break; + } +#ifndef SQLITE_OMIT_WINDOWFUNC + if( tokenType>=TK_WINDOW ){ + assert( tokenType==TK_SPACE || tokenType==TK_OVER || tokenType==TK_FILTER + || tokenType==TK_ILLEGAL || tokenType==TK_WINDOW + ); +#else + if( tokenType>=TK_SPACE ){ + assert( tokenType==TK_SPACE || tokenType==TK_ILLEGAL ); +#endif /* SQLITE_OMIT_WINDOWFUNC */ + if( AtomicLoad(&db->u1.isInterrupted) ){ + pParse->rc = SQLITE_INTERRUPT; + pParse->nErr++; + break; + } + if( tokenType==TK_SPACE ){ + zSql += n; + continue; + } + if( zSql[0]==0 ){ + /* Upon reaching the end of input, call the parser two more times + ** with tokens TK_SEMI and 0, in that order. */ + if( lastTokenParsed==TK_SEMI ){ + tokenType = 0; + }else if( lastTokenParsed==0 ){ + break; + }else{ + tokenType = TK_SEMI; + } + n = 0; +#ifndef SQLITE_OMIT_WINDOWFUNC + }else if( tokenType==TK_WINDOW ){ + assert( n==6 ); + tokenType = analyzeWindowKeyword((const u8*)&zSql[6]); + }else if( tokenType==TK_OVER ){ + assert( n==4 ); + tokenType = analyzeOverKeyword((const u8*)&zSql[4], lastTokenParsed); + }else if( tokenType==TK_FILTER ){ + assert( n==6 ); + tokenType = analyzeFilterKeyword((const u8*)&zSql[6], lastTokenParsed); +#endif /* SQLITE_OMIT_WINDOWFUNC */ + }else{ + Token x; + x.z = zSql; + x.n = n; + sqlite3ErrorMsg(pParse, "unrecognized token: \"%T\"", &x); + break; + } + } + pParse->sLastToken.z = zSql; + pParse->sLastToken.n = n; + sqlite3Parser(pEngine, tokenType, pParse->sLastToken); + lastTokenParsed = tokenType; + zSql += n; + assert( db->mallocFailed==0 || pParse->rc!=SQLITE_OK || startedWithOom ); + if( pParse->rc!=SQLITE_OK ) break; + } + assert( nErr==0 ); +#ifdef YYTRACKMAXSTACKDEPTH + sqlite3_mutex_enter(sqlite3MallocMutex()); + sqlite3StatusHighwater(SQLITE_STATUS_PARSER_STACK, + sqlite3ParserStackPeak(pEngine) + ); + sqlite3_mutex_leave(sqlite3MallocMutex()); +#endif /* YYDEBUG */ +#ifdef sqlite3Parser_ENGINEALWAYSONSTACK + sqlite3ParserFinalize(pEngine); +#else + sqlite3ParserFree(pEngine, sqlite3_free); +#endif + if( db->mallocFailed ){ + pParse->rc = SQLITE_NOMEM_BKPT; + } + if( pParse->zErrMsg || (pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE) ){ + if( pParse->zErrMsg==0 ){ + pParse->zErrMsg = sqlite3MPrintf(db, "%s", sqlite3ErrStr(pParse->rc)); + } + sqlite3_log(pParse->rc, "%s in \"%s\"", pParse->zErrMsg, pParse->zTail); + nErr++; + } + pParse->zTail = zSql; +#ifndef SQLITE_OMIT_VIRTUALTABLE + sqlite3_free(pParse->apVtabLock); +#endif + + if( pParse->pNewTable && !IN_SPECIAL_PARSE ){ + /* If the pParse->declareVtab flag is set, do not delete any table + ** structure built up in pParse->pNewTable. The calling code (see vtab.c) + ** will take responsibility for freeing the Table structure. + */ + sqlite3DeleteTable(db, pParse->pNewTable); + } + if( pParse->pNewTrigger && !IN_RENAME_OBJECT ){ + sqlite3DeleteTrigger(db, pParse->pNewTrigger); + } + if( pParse->pVList ) sqlite3DbNNFreeNN(db, pParse->pVList); + db->pParse = pParentParse; + assert( nErr==0 || pParse->rc!=SQLITE_OK ); + return nErr; +} + + +#ifdef SQLITE_ENABLE_NORMALIZE +/* +** Insert a single space character into pStr if the current string +** ends with an identifier +*/ +static void addSpaceSeparator(sqlite3_str *pStr){ + if( pStr->nChar && sqlite3IsIdChar(pStr->zText[pStr->nChar-1]) ){ + sqlite3_str_append(pStr, " ", 1); + } +} + +/* +** Compute a normalization of the SQL given by zSql[0..nSql-1]. Return +** the normalization in space obtained from sqlite3DbMalloc(). Or return +** NULL if anything goes wrong or if zSql is NULL. +*/ +SQLITE_PRIVATE char *sqlite3Normalize( + Vdbe *pVdbe, /* VM being reprepared */ + const char *zSql /* The original SQL string */ +){ + sqlite3 *db; /* The database connection */ + int i; /* Next unread byte of zSql[] */ + int n; /* length of current token */ + int tokenType; /* type of current token */ + int prevType = 0; /* Previous non-whitespace token */ + int nParen; /* Number of nested levels of parentheses */ + int iStartIN; /* Start of RHS of IN operator in z[] */ + int nParenAtIN; /* Value of nParent at start of RHS of IN operator */ + u32 j; /* Bytes of normalized SQL generated so far */ + sqlite3_str *pStr; /* The normalized SQL string under construction */ + + db = sqlite3VdbeDb(pVdbe); + tokenType = -1; + nParen = iStartIN = nParenAtIN = 0; + pStr = sqlite3_str_new(db); + assert( pStr!=0 ); /* sqlite3_str_new() never returns NULL */ + for(i=0; zSql[i] && pStr->accError==0; i+=n){ + if( tokenType!=TK_SPACE ){ + prevType = tokenType; + } + n = sqlite3GetToken((unsigned char*)zSql+i, &tokenType); + if( NEVER(n<=0) ) break; + switch( tokenType ){ + case TK_SPACE: { + break; + } + case TK_NULL: { + if( prevType==TK_IS || prevType==TK_NOT ){ + sqlite3_str_append(pStr, " NULL", 5); + break; + } + /* Fall through */ + } + case TK_STRING: + case TK_INTEGER: + case TK_FLOAT: + case TK_VARIABLE: + case TK_BLOB: { + sqlite3_str_append(pStr, "?", 1); + break; + } + case TK_LP: { + nParen++; + if( prevType==TK_IN ){ + iStartIN = pStr->nChar; + nParenAtIN = nParen; + } + sqlite3_str_append(pStr, "(", 1); + break; + } + case TK_RP: { + if( iStartIN>0 && nParen==nParenAtIN ){ + assert( pStr->nChar>=(u32)iStartIN ); + pStr->nChar = iStartIN+1; + sqlite3_str_append(pStr, "?,?,?", 5); + iStartIN = 0; + } + nParen--; + sqlite3_str_append(pStr, ")", 1); + break; + } + case TK_ID: { + iStartIN = 0; + j = pStr->nChar; + if( sqlite3Isquote(zSql[i]) ){ + char *zId = sqlite3DbStrNDup(db, zSql+i, n); + int nId; + int eType = 0; + if( zId==0 ) break; + sqlite3Dequote(zId); + if( zSql[i]=='"' && sqlite3VdbeUsesDoubleQuotedString(pVdbe, zId) ){ + sqlite3_str_append(pStr, "?", 1); + sqlite3DbFree(db, zId); + break; + } + nId = sqlite3Strlen30(zId); + if( sqlite3GetToken((u8*)zId, &eType)==nId && eType==TK_ID ){ + addSpaceSeparator(pStr); + sqlite3_str_append(pStr, zId, nId); + }else{ + sqlite3_str_appendf(pStr, "\"%w\"", zId); + } + sqlite3DbFree(db, zId); + }else{ + addSpaceSeparator(pStr); + sqlite3_str_append(pStr, zSql+i, n); + } + while( jnChar ){ + pStr->zText[j] = sqlite3Tolower(pStr->zText[j]); + j++; + } + break; + } + case TK_SELECT: { + iStartIN = 0; + /* fall through */ + } + default: { + if( sqlite3IsIdChar(zSql[i]) ) addSpaceSeparator(pStr); + j = pStr->nChar; + sqlite3_str_append(pStr, zSql+i, n); + while( jnChar ){ + pStr->zText[j] = sqlite3Toupper(pStr->zText[j]); + j++; + } + break; + } + } + } + if( tokenType!=TK_SEMI ) sqlite3_str_append(pStr, ";", 1); + return sqlite3_str_finish(pStr); +} +#endif /* SQLITE_ENABLE_NORMALIZE */ + +/************** End of tokenize.c ********************************************/ +/************** Begin file complete.c ****************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** An tokenizer for SQL +** +** This file contains C code that implements the sqlite3_complete() API. +** This code used to be part of the tokenizer.c source file. But by +** separating it out, the code will be automatically omitted from +** static links that do not use it. +*/ +/* #include "sqliteInt.h" */ +#ifndef SQLITE_OMIT_COMPLETE + +/* +** This is defined in tokenize.c. We just have to import the definition. +*/ +#ifndef SQLITE_AMALGAMATION +#ifdef SQLITE_ASCII +#define IdChar(C) ((sqlite3CtypeMap[(unsigned char)C]&0x46)!=0) +#endif +#ifdef SQLITE_EBCDIC +SQLITE_PRIVATE const char sqlite3IsEbcdicIdChar[]; +#define IdChar(C) (((c=C)>=0x42 && sqlite3IsEbcdicIdChar[c-0x40])) +#endif +#endif /* SQLITE_AMALGAMATION */ + + +/* +** Token types used by the sqlite3_complete() routine. See the header +** comments on that procedure for additional information. +*/ +#define tkSEMI 0 +#define tkWS 1 +#define tkOTHER 2 +#ifndef SQLITE_OMIT_TRIGGER +#define tkEXPLAIN 3 +#define tkCREATE 4 +#define tkTEMP 5 +#define tkTRIGGER 6 +#define tkEND 7 +#endif + +/* +** Return TRUE if the given SQL string ends in a semicolon. +** +** Special handling is require for CREATE TRIGGER statements. +** Whenever the CREATE TRIGGER keywords are seen, the statement +** must end with ";END;". +** +** This implementation uses a state machine with 8 states: +** +** (0) INVALID We have not yet seen a non-whitespace character. +** +** (1) START At the beginning or end of an SQL statement. This routine +** returns 1 if it ends in the START state and 0 if it ends +** in any other state. +** +** (2) NORMAL We are in the middle of statement which ends with a single +** semicolon. +** +** (3) EXPLAIN The keyword EXPLAIN has been seen at the beginning of +** a statement. +** +** (4) CREATE The keyword CREATE has been seen at the beginning of a +** statement, possibly preceded by EXPLAIN and/or followed by +** TEMP or TEMPORARY +** +** (5) TRIGGER We are in the middle of a trigger definition that must be +** ended by a semicolon, the keyword END, and another semicolon. +** +** (6) SEMI We've seen the first semicolon in the ";END;" that occurs at +** the end of a trigger definition. +** +** (7) END We've seen the ";END" of the ";END;" that occurs at the end +** of a trigger definition. +** +** Transitions between states above are determined by tokens extracted +** from the input. The following tokens are significant: +** +** (0) tkSEMI A semicolon. +** (1) tkWS Whitespace. +** (2) tkOTHER Any other SQL token. +** (3) tkEXPLAIN The "explain" keyword. +** (4) tkCREATE The "create" keyword. +** (5) tkTEMP The "temp" or "temporary" keyword. +** (6) tkTRIGGER The "trigger" keyword. +** (7) tkEND The "end" keyword. +** +** Whitespace never causes a state transition and is always ignored. +** This means that a SQL string of all whitespace is invalid. +** +** If we compile with SQLITE_OMIT_TRIGGER, all of the computation needed +** to recognize the end of a trigger can be omitted. All we have to do +** is look for a semicolon that is not part of an string or comment. +*/ +SQLITE_API int sqlite3_complete(const char *zSql){ + u8 state = 0; /* Current state, using numbers defined in header comment */ + u8 token; /* Value of the next token */ + +#ifndef SQLITE_OMIT_TRIGGER + /* A complex statement machine used to detect the end of a CREATE TRIGGER + ** statement. This is the normal case. + */ + static const u8 trans[8][8] = { + /* Token: */ + /* State: ** SEMI WS OTHER EXPLAIN CREATE TEMP TRIGGER END */ + /* 0 INVALID: */ { 1, 0, 2, 3, 4, 2, 2, 2, }, + /* 1 START: */ { 1, 1, 2, 3, 4, 2, 2, 2, }, + /* 2 NORMAL: */ { 1, 2, 2, 2, 2, 2, 2, 2, }, + /* 3 EXPLAIN: */ { 1, 3, 3, 2, 4, 2, 2, 2, }, + /* 4 CREATE: */ { 1, 4, 2, 2, 2, 4, 5, 2, }, + /* 5 TRIGGER: */ { 6, 5, 5, 5, 5, 5, 5, 5, }, + /* 6 SEMI: */ { 6, 6, 5, 5, 5, 5, 5, 7, }, + /* 7 END: */ { 1, 7, 5, 5, 5, 5, 5, 5, }, + }; +#else + /* If triggers are not supported by this compile then the statement machine + ** used to detect the end of a statement is much simpler + */ + static const u8 trans[3][3] = { + /* Token: */ + /* State: ** SEMI WS OTHER */ + /* 0 INVALID: */ { 1, 0, 2, }, + /* 1 START: */ { 1, 1, 2, }, + /* 2 NORMAL: */ { 1, 2, 2, }, + }; +#endif /* SQLITE_OMIT_TRIGGER */ + +#ifdef SQLITE_ENABLE_API_ARMOR + if( zSql==0 ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + + while( *zSql ){ + switch( *zSql ){ + case ';': { /* A semicolon */ + token = tkSEMI; + break; + } + case ' ': + case '\r': + case '\t': + case '\n': + case '\f': { /* White space is ignored */ + token = tkWS; + break; + } + case '/': { /* C-style comments */ + if( zSql[1]!='*' ){ + token = tkOTHER; + break; + } + zSql += 2; + while( zSql[0] && (zSql[0]!='*' || zSql[1]!='/') ){ zSql++; } + if( zSql[0]==0 ) return 0; + zSql++; + token = tkWS; + break; + } + case '-': { /* SQL-style comments from "--" to end of line */ + if( zSql[1]!='-' ){ + token = tkOTHER; + break; + } + while( *zSql && *zSql!='\n' ){ zSql++; } + if( *zSql==0 ) return state==1; + token = tkWS; + break; + } + case '[': { /* Microsoft-style identifiers in [...] */ + zSql++; + while( *zSql && *zSql!=']' ){ zSql++; } + if( *zSql==0 ) return 0; + token = tkOTHER; + break; + } + case '`': /* Grave-accent quoted symbols used by MySQL */ + case '"': /* single- and double-quoted strings */ + case '\'': { + int c = *zSql; + zSql++; + while( *zSql && *zSql!=c ){ zSql++; } + if( *zSql==0 ) return 0; + token = tkOTHER; + break; + } + default: { +#ifdef SQLITE_EBCDIC + unsigned char c; +#endif + if( IdChar((u8)*zSql) ){ + /* Keywords and unquoted identifiers */ + int nId; + for(nId=1; IdChar(zSql[nId]); nId++){} +#ifdef SQLITE_OMIT_TRIGGER + token = tkOTHER; +#else + switch( *zSql ){ + case 'c': case 'C': { + if( nId==6 && sqlite3StrNICmp(zSql, "create", 6)==0 ){ + token = tkCREATE; + }else{ + token = tkOTHER; + } + break; + } + case 't': case 'T': { + if( nId==7 && sqlite3StrNICmp(zSql, "trigger", 7)==0 ){ + token = tkTRIGGER; + }else if( nId==4 && sqlite3StrNICmp(zSql, "temp", 4)==0 ){ + token = tkTEMP; + }else if( nId==9 && sqlite3StrNICmp(zSql, "temporary", 9)==0 ){ + token = tkTEMP; + }else{ + token = tkOTHER; + } + break; + } + case 'e': case 'E': { + if( nId==3 && sqlite3StrNICmp(zSql, "end", 3)==0 ){ + token = tkEND; + }else +#ifndef SQLITE_OMIT_EXPLAIN + if( nId==7 && sqlite3StrNICmp(zSql, "explain", 7)==0 ){ + token = tkEXPLAIN; + }else +#endif + { + token = tkOTHER; + } + break; + } + default: { + token = tkOTHER; + break; + } + } +#endif /* SQLITE_OMIT_TRIGGER */ + zSql += nId-1; + }else{ + /* Operators and special symbols */ + token = tkOTHER; + } + break; + } + } + state = trans[state][token]; + zSql++; + } + return state==1; +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** This routine is the same as the sqlite3_complete() routine described +** above, except that the parameter is required to be UTF-16 encoded, not +** UTF-8. +*/ +SQLITE_API int sqlite3_complete16(const void *zSql){ + sqlite3_value *pVal; + char const *zSql8; + int rc; + +#ifndef SQLITE_OMIT_AUTOINIT + rc = sqlite3_initialize(); + if( rc ) return rc; +#endif + pVal = sqlite3ValueNew(0); + sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC); + zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8); + if( zSql8 ){ + rc = sqlite3_complete(zSql8); + }else{ + rc = SQLITE_NOMEM_BKPT; + } + sqlite3ValueFree(pVal); + return rc & 0xff; +} +#endif /* SQLITE_OMIT_UTF16 */ +#endif /* SQLITE_OMIT_COMPLETE */ + +/************** End of complete.c ********************************************/ +/************** Begin file main.c ********************************************/ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** Main file for the SQLite library. The routines in this file +** implement the programmer interface to the library. Routines in +** other files are for internal use by SQLite and should not be +** accessed by users of the library. +*/ +/* #include "sqliteInt.h" */ + +#ifdef SQLITE_ENABLE_FTS3 +/************** Include fts3.h in the middle of main.c ***********************/ +/************** Begin file fts3.h ********************************************/ +/* +** 2006 Oct 10 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This header file is used by programs that want to link against the +** FTS3 library. All it does is declare the sqlite3Fts3Init() interface. +*/ +/* #include "sqlite3.h" */ + +#if 0 +extern "C" { +#endif /* __cplusplus */ + +SQLITE_PRIVATE int sqlite3Fts3Init(sqlite3 *db); + +#if 0 +} /* extern "C" */ +#endif /* __cplusplus */ + +/************** End of fts3.h ************************************************/ +/************** Continuing where we left off in main.c ***********************/ +#endif +#ifdef SQLITE_ENABLE_RTREE +/************** Include rtree.h in the middle of main.c **********************/ +/************** Begin file rtree.h *******************************************/ +/* +** 2008 May 26 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This header file is used by programs that want to link against the +** RTREE library. All it does is declare the sqlite3RtreeInit() interface. +*/ +/* #include "sqlite3.h" */ + +#ifdef SQLITE_OMIT_VIRTUALTABLE +# undef SQLITE_ENABLE_RTREE +#endif + +#if 0 +extern "C" { +#endif /* __cplusplus */ + +SQLITE_PRIVATE int sqlite3RtreeInit(sqlite3 *db); + +#if 0 +} /* extern "C" */ +#endif /* __cplusplus */ + +/************** End of rtree.h ***********************************************/ +/************** Continuing where we left off in main.c ***********************/ +#endif +#if defined(SQLITE_ENABLE_ICU) || defined(SQLITE_ENABLE_ICU_COLLATIONS) +/************** Include sqliteicu.h in the middle of main.c ******************/ +/************** Begin file sqliteicu.h ***************************************/ +/* +** 2008 May 26 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This header file is used by programs that want to link against the +** ICU extension. All it does is declare the sqlite3IcuInit() interface. +*/ +/* #include "sqlite3.h" */ + +#if 0 +extern "C" { +#endif /* __cplusplus */ + +SQLITE_PRIVATE int sqlite3IcuInit(sqlite3 *db); + +#if 0 +} /* extern "C" */ +#endif /* __cplusplus */ + +/************** End of sqliteicu.h *******************************************/ +/************** Continuing where we left off in main.c ***********************/ +#endif + +/* +** This is an extension initializer that is a no-op and always +** succeeds, except that it fails if the fault-simulation is set +** to 500. +*/ +static int sqlite3TestExtInit(sqlite3 *db){ + (void)db; + return sqlite3FaultSim(500); +} + + +/* +** Forward declarations of external module initializer functions +** for modules that need them. +*/ +#ifdef SQLITE_ENABLE_FTS1 +SQLITE_PRIVATE int sqlite3Fts1Init(sqlite3*); +#endif +#ifdef SQLITE_ENABLE_FTS2 +SQLITE_PRIVATE int sqlite3Fts2Init(sqlite3*); +#endif +#ifdef SQLITE_ENABLE_FTS5 +SQLITE_PRIVATE int sqlite3Fts5Init(sqlite3*); +#endif +#ifdef SQLITE_ENABLE_STMTVTAB +SQLITE_PRIVATE int sqlite3StmtVtabInit(sqlite3*); +#endif + +/* +** An array of pointers to extension initializer functions for +** built-in extensions. +*/ +static int (*const sqlite3BuiltinExtensions[])(sqlite3*) = { +#ifdef SQLITE_ENABLE_FTS1 + sqlite3Fts1Init, +#endif +#ifdef SQLITE_ENABLE_FTS2 + sqlite3Fts2Init, +#endif +#ifdef SQLITE_ENABLE_FTS3 + sqlite3Fts3Init, +#endif +#ifdef SQLITE_ENABLE_FTS5 + sqlite3Fts5Init, +#endif +#if defined(SQLITE_ENABLE_ICU) || defined(SQLITE_ENABLE_ICU_COLLATIONS) + sqlite3IcuInit, +#endif +#ifdef SQLITE_ENABLE_RTREE + sqlite3RtreeInit, +#endif +#ifdef SQLITE_ENABLE_DBPAGE_VTAB + sqlite3DbpageRegister, +#endif +#ifdef SQLITE_ENABLE_DBSTAT_VTAB + sqlite3DbstatRegister, +#endif + sqlite3TestExtInit, +#if !defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_JSON) + sqlite3JsonTableFunctions, +#endif +#ifdef SQLITE_ENABLE_STMTVTAB + sqlite3StmtVtabInit, +#endif +#ifdef SQLITE_ENABLE_BYTECODE_VTAB + sqlite3VdbeBytecodeVtabInit, +#endif +}; + +#ifndef SQLITE_AMALGAMATION +/* IMPLEMENTATION-OF: R-46656-45156 The sqlite3_version[] string constant +** contains the text of SQLITE_VERSION macro. +*/ +SQLITE_API const char sqlite3_version[] = SQLITE_VERSION; +#endif + +/* IMPLEMENTATION-OF: R-53536-42575 The sqlite3_libversion() function returns +** a pointer to the to the sqlite3_version[] string constant. +*/ +SQLITE_API const char *sqlite3_libversion(void){ return sqlite3_version; } + +/* IMPLEMENTATION-OF: R-25063-23286 The sqlite3_sourceid() function returns a +** pointer to a string constant whose value is the same as the +** SQLITE_SOURCE_ID C preprocessor macro. Except if SQLite is built using +** an edited copy of the amalgamation, then the last four characters of +** the hash might be different from SQLITE_SOURCE_ID. +*/ +/* SQLITE_API const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; } */ + +/* IMPLEMENTATION-OF: R-35210-63508 The sqlite3_libversion_number() function +** returns an integer equal to SQLITE_VERSION_NUMBER. +*/ +SQLITE_API int sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER; } + +/* IMPLEMENTATION-OF: R-20790-14025 The sqlite3_threadsafe() function returns +** zero if and only if SQLite was compiled with mutexing code omitted due to +** the SQLITE_THREADSAFE compile-time option being set to 0. +*/ +SQLITE_API int sqlite3_threadsafe(void){ return SQLITE_THREADSAFE; } + +/* +** When compiling the test fixture or with debugging enabled (on Win32), +** this variable being set to non-zero will cause OSTRACE macros to emit +** extra diagnostic information. +*/ +#ifdef SQLITE_HAVE_OS_TRACE +# ifndef SQLITE_DEBUG_OS_TRACE +# define SQLITE_DEBUG_OS_TRACE 0 +# endif + int sqlite3OSTrace = SQLITE_DEBUG_OS_TRACE; +#endif + +#if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE) +/* +** If the following function pointer is not NULL and if +** SQLITE_ENABLE_IOTRACE is enabled, then messages describing +** I/O active are written using this function. These messages +** are intended for debugging activity only. +*/ +SQLITE_API void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...) = 0; +#endif + +/* +** If the following global variable points to a string which is the +** name of a directory, then that directory will be used to store +** temporary files. +** +** See also the "PRAGMA temp_store_directory" SQL command. +*/ +SQLITE_API char *sqlite3_temp_directory = 0; + +/* +** If the following global variable points to a string which is the +** name of a directory, then that directory will be used to store +** all database files specified with a relative pathname. +** +** See also the "PRAGMA data_store_directory" SQL command. +*/ +SQLITE_API char *sqlite3_data_directory = 0; + +/* +** Initialize SQLite. +** +** This routine must be called to initialize the memory allocation, +** VFS, and mutex subsystems prior to doing any serious work with +** SQLite. But as long as you do not compile with SQLITE_OMIT_AUTOINIT +** this routine will be called automatically by key routines such as +** sqlite3_open(). +** +** This routine is a no-op except on its very first call for the process, +** or for the first call after a call to sqlite3_shutdown. +** +** The first thread to call this routine runs the initialization to +** completion. If subsequent threads call this routine before the first +** thread has finished the initialization process, then the subsequent +** threads must block until the first thread finishes with the initialization. +** +** The first thread might call this routine recursively. Recursive +** calls to this routine should not block, of course. Otherwise the +** initialization process would never complete. +** +** Let X be the first thread to enter this routine. Let Y be some other +** thread. Then while the initial invocation of this routine by X is +** incomplete, it is required that: +** +** * Calls to this routine from Y must block until the outer-most +** call by X completes. +** +** * Recursive calls to this routine from thread X return immediately +** without blocking. +*/ +SQLITE_API int sqlite3_initialize(void){ + MUTEX_LOGIC( sqlite3_mutex *pMainMtx; ) /* The main static mutex */ + int rc; /* Result code */ +#ifdef SQLITE_EXTRA_INIT + int bRunExtraInit = 0; /* Extra initialization needed */ +#endif + +#ifdef SQLITE_OMIT_WSD + rc = sqlite3_wsd_init(4096, 24); + if( rc!=SQLITE_OK ){ + return rc; + } +#endif + + /* If the following assert() fails on some obscure processor/compiler + ** combination, the work-around is to set the correct pointer + ** size at compile-time using -DSQLITE_PTRSIZE=n compile-time option */ + assert( SQLITE_PTRSIZE==sizeof(char*) ); + + /* If SQLite is already completely initialized, then this call + ** to sqlite3_initialize() should be a no-op. But the initialization + ** must be complete. So isInit must not be set until the very end + ** of this routine. + */ + if( sqlite3GlobalConfig.isInit ){ + sqlite3MemoryBarrier(); + return SQLITE_OK; + } + + /* Make sure the mutex subsystem is initialized. If unable to + ** initialize the mutex subsystem, return early with the error. + ** If the system is so sick that we are unable to allocate a mutex, + ** there is not much SQLite is going to be able to do. + ** + ** The mutex subsystem must take care of serializing its own + ** initialization. + */ + rc = sqlite3MutexInit(); + if( rc ) return rc; + + /* Initialize the malloc() system and the recursive pInitMutex mutex. + ** This operation is protected by the STATIC_MAIN mutex. Note that + ** MutexAlloc() is called for a static mutex prior to initializing the + ** malloc subsystem - this implies that the allocation of a static + ** mutex must not require support from the malloc subsystem. + */ + MUTEX_LOGIC( pMainMtx = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); ) + sqlite3_mutex_enter(pMainMtx); + sqlite3GlobalConfig.isMutexInit = 1; + if( !sqlite3GlobalConfig.isMallocInit ){ + rc = sqlite3MallocInit(); + } + if( rc==SQLITE_OK ){ + sqlite3GlobalConfig.isMallocInit = 1; + if( !sqlite3GlobalConfig.pInitMutex ){ + sqlite3GlobalConfig.pInitMutex = + sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE); + if( sqlite3GlobalConfig.bCoreMutex && !sqlite3GlobalConfig.pInitMutex ){ + rc = SQLITE_NOMEM_BKPT; + } + } + } + if( rc==SQLITE_OK ){ + sqlite3GlobalConfig.nRefInitMutex++; + } + sqlite3_mutex_leave(pMainMtx); + + /* If rc is not SQLITE_OK at this point, then either the malloc + ** subsystem could not be initialized or the system failed to allocate + ** the pInitMutex mutex. Return an error in either case. */ + if( rc!=SQLITE_OK ){ + return rc; + } + + /* Do the rest of the initialization under the recursive mutex so + ** that we will be able to handle recursive calls into + ** sqlite3_initialize(). The recursive calls normally come through + ** sqlite3_os_init() when it invokes sqlite3_vfs_register(), but other + ** recursive calls might also be possible. + ** + ** IMPLEMENTATION-OF: R-00140-37445 SQLite automatically serializes calls + ** to the xInit method, so the xInit method need not be threadsafe. + ** + ** The following mutex is what serializes access to the appdef pcache xInit + ** methods. The sqlite3_pcache_methods.xInit() all is embedded in the + ** call to sqlite3PcacheInitialize(). + */ + sqlite3_mutex_enter(sqlite3GlobalConfig.pInitMutex); + if( sqlite3GlobalConfig.isInit==0 && sqlite3GlobalConfig.inProgress==0 ){ + sqlite3GlobalConfig.inProgress = 1; +#ifdef SQLITE_ENABLE_SQLLOG + { + extern void sqlite3_init_sqllog(void); + sqlite3_init_sqllog(); + } +#endif + memset(&sqlite3BuiltinFunctions, 0, sizeof(sqlite3BuiltinFunctions)); + sqlite3RegisterBuiltinFunctions(); + if( sqlite3GlobalConfig.isPCacheInit==0 ){ + rc = sqlite3PcacheInitialize(); + } + if( rc==SQLITE_OK ){ + sqlite3GlobalConfig.isPCacheInit = 1; + rc = sqlite3OsInit(); + } +#ifndef SQLITE_OMIT_DESERIALIZE + if( rc==SQLITE_OK ){ + rc = sqlite3MemdbInit(); + } +#endif + if( rc==SQLITE_OK ){ + sqlite3PCacheBufferSetup( sqlite3GlobalConfig.pPage, + sqlite3GlobalConfig.szPage, sqlite3GlobalConfig.nPage); + sqlite3MemoryBarrier(); + sqlite3GlobalConfig.isInit = 1; +#ifdef SQLITE_EXTRA_INIT + bRunExtraInit = 1; +#endif + } + sqlite3GlobalConfig.inProgress = 0; + } + sqlite3_mutex_leave(sqlite3GlobalConfig.pInitMutex); + + /* Go back under the static mutex and clean up the recursive + ** mutex to prevent a resource leak. + */ + sqlite3_mutex_enter(pMainMtx); + sqlite3GlobalConfig.nRefInitMutex--; + if( sqlite3GlobalConfig.nRefInitMutex<=0 ){ + assert( sqlite3GlobalConfig.nRefInitMutex==0 ); + sqlite3_mutex_free(sqlite3GlobalConfig.pInitMutex); + sqlite3GlobalConfig.pInitMutex = 0; + } + sqlite3_mutex_leave(pMainMtx); + + /* The following is just a sanity check to make sure SQLite has + ** been compiled correctly. It is important to run this code, but + ** we don't want to run it too often and soak up CPU cycles for no + ** reason. So we run it once during initialization. + */ +#ifndef NDEBUG +#ifndef SQLITE_OMIT_FLOATING_POINT + /* This section of code's only "output" is via assert() statements. */ + if( rc==SQLITE_OK ){ + u64 x = (((u64)1)<<63)-1; + double y; + assert(sizeof(x)==8); + assert(sizeof(x)==sizeof(y)); + memcpy(&y, &x, 8); + assert( sqlite3IsNaN(y) ); + } +#endif +#endif + + /* Do extra initialization steps requested by the SQLITE_EXTRA_INIT + ** compile-time option. + */ +#ifdef SQLITE_EXTRA_INIT + if( bRunExtraInit ){ + int SQLITE_EXTRA_INIT(const char*); + rc = SQLITE_EXTRA_INIT(0); + } +#endif + + return rc; +} + +/* +** Undo the effects of sqlite3_initialize(). Must not be called while +** there are outstanding database connections or memory allocations or +** while any part of SQLite is otherwise in use in any thread. This +** routine is not threadsafe. But it is safe to invoke this routine +** on when SQLite is already shut down. If SQLite is already shut down +** when this routine is invoked, then this routine is a harmless no-op. +*/ +SQLITE_API int sqlite3_shutdown(void){ +#ifdef SQLITE_OMIT_WSD + int rc = sqlite3_wsd_init(4096, 24); + if( rc!=SQLITE_OK ){ + return rc; + } +#endif + + if( sqlite3GlobalConfig.isInit ){ +#ifdef SQLITE_EXTRA_SHUTDOWN + void SQLITE_EXTRA_SHUTDOWN(void); + SQLITE_EXTRA_SHUTDOWN(); +#endif + sqlite3_os_end(); + sqlite3_reset_auto_extension(); + sqlite3GlobalConfig.isInit = 0; + } + if( sqlite3GlobalConfig.isPCacheInit ){ + sqlite3PcacheShutdown(); + sqlite3GlobalConfig.isPCacheInit = 0; + } + if( sqlite3GlobalConfig.isMallocInit ){ + sqlite3MallocEnd(); + sqlite3GlobalConfig.isMallocInit = 0; + +#ifndef SQLITE_OMIT_SHUTDOWN_DIRECTORIES + /* The heap subsystem has now been shutdown and these values are supposed + ** to be NULL or point to memory that was obtained from sqlite3_malloc(), + ** which would rely on that heap subsystem; therefore, make sure these + ** values cannot refer to heap memory that was just invalidated when the + ** heap subsystem was shutdown. This is only done if the current call to + ** this function resulted in the heap subsystem actually being shutdown. + */ + sqlite3_data_directory = 0; + sqlite3_temp_directory = 0; +#endif + } + if( sqlite3GlobalConfig.isMutexInit ){ + sqlite3MutexEnd(); + sqlite3GlobalConfig.isMutexInit = 0; + } + + return SQLITE_OK; +} + +/* +** This API allows applications to modify the global configuration of +** the SQLite library at run-time. +** +** This routine should only be called when there are no outstanding +** database connections or memory allocations. This routine is not +** threadsafe. Failure to heed these warnings can lead to unpredictable +** behavior. +*/ +SQLITE_API int sqlite3_config(int op, ...){ + va_list ap; + int rc = SQLITE_OK; + + /* sqlite3_config() normally returns SQLITE_MISUSE if it is invoked while + ** the SQLite library is in use. Except, a few selected opcodes + ** are allowed. + */ + if( sqlite3GlobalConfig.isInit ){ + static const u64 mAnytimeConfigOption = 0 + | MASKBIT64( SQLITE_CONFIG_LOG ) + | MASKBIT64( SQLITE_CONFIG_PCACHE_HDRSZ ) + ; + if( op<0 || op>63 || (MASKBIT64(op) & mAnytimeConfigOption)==0 ){ + return SQLITE_MISUSE_BKPT; + } + testcase( op==SQLITE_CONFIG_LOG ); + testcase( op==SQLITE_CONFIG_PCACHE_HDRSZ ); + } + + va_start(ap, op); + switch( op ){ + + /* Mutex configuration options are only available in a threadsafe + ** compile. + */ +#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-54466-46756 */ + case SQLITE_CONFIG_SINGLETHREAD: { + /* EVIDENCE-OF: R-02748-19096 This option sets the threading mode to + ** Single-thread. */ + sqlite3GlobalConfig.bCoreMutex = 0; /* Disable mutex on core */ + sqlite3GlobalConfig.bFullMutex = 0; /* Disable mutex on connections */ + break; + } +#endif +#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-20520-54086 */ + case SQLITE_CONFIG_MULTITHREAD: { + /* EVIDENCE-OF: R-14374-42468 This option sets the threading mode to + ** Multi-thread. */ + sqlite3GlobalConfig.bCoreMutex = 1; /* Enable mutex on core */ + sqlite3GlobalConfig.bFullMutex = 0; /* Disable mutex on connections */ + break; + } +#endif +#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-59593-21810 */ + case SQLITE_CONFIG_SERIALIZED: { + /* EVIDENCE-OF: R-41220-51800 This option sets the threading mode to + ** Serialized. */ + sqlite3GlobalConfig.bCoreMutex = 1; /* Enable mutex on core */ + sqlite3GlobalConfig.bFullMutex = 1; /* Enable mutex on connections */ + break; + } +#endif +#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-63666-48755 */ + case SQLITE_CONFIG_MUTEX: { + /* Specify an alternative mutex implementation */ + sqlite3GlobalConfig.mutex = *va_arg(ap, sqlite3_mutex_methods*); + break; + } +#endif +#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-14450-37597 */ + case SQLITE_CONFIG_GETMUTEX: { + /* Retrieve the current mutex implementation */ + *va_arg(ap, sqlite3_mutex_methods*) = sqlite3GlobalConfig.mutex; + break; + } +#endif + + case SQLITE_CONFIG_MALLOC: { + /* EVIDENCE-OF: R-55594-21030 The SQLITE_CONFIG_MALLOC option takes a + ** single argument which is a pointer to an instance of the + ** sqlite3_mem_methods structure. The argument specifies alternative + ** low-level memory allocation routines to be used in place of the memory + ** allocation routines built into SQLite. */ + sqlite3GlobalConfig.m = *va_arg(ap, sqlite3_mem_methods*); + break; + } + case SQLITE_CONFIG_GETMALLOC: { + /* EVIDENCE-OF: R-51213-46414 The SQLITE_CONFIG_GETMALLOC option takes a + ** single argument which is a pointer to an instance of the + ** sqlite3_mem_methods structure. The sqlite3_mem_methods structure is + ** filled with the currently defined memory allocation routines. */ + if( sqlite3GlobalConfig.m.xMalloc==0 ) sqlite3MemSetDefault(); + *va_arg(ap, sqlite3_mem_methods*) = sqlite3GlobalConfig.m; + break; + } + case SQLITE_CONFIG_MEMSTATUS: { + assert( !sqlite3GlobalConfig.isInit ); /* Cannot change at runtime */ + /* EVIDENCE-OF: R-61275-35157 The SQLITE_CONFIG_MEMSTATUS option takes + ** single argument of type int, interpreted as a boolean, which enables + ** or disables the collection of memory allocation statistics. */ + sqlite3GlobalConfig.bMemstat = va_arg(ap, int); + break; + } + case SQLITE_CONFIG_SMALL_MALLOC: { + sqlite3GlobalConfig.bSmallMalloc = va_arg(ap, int); + break; + } + case SQLITE_CONFIG_PAGECACHE: { + /* EVIDENCE-OF: R-18761-36601 There are three arguments to + ** SQLITE_CONFIG_PAGECACHE: A pointer to 8-byte aligned memory (pMem), + ** the size of each page cache line (sz), and the number of cache lines + ** (N). */ + sqlite3GlobalConfig.pPage = va_arg(ap, void*); + sqlite3GlobalConfig.szPage = va_arg(ap, int); + sqlite3GlobalConfig.nPage = va_arg(ap, int); + break; + } + case SQLITE_CONFIG_PCACHE_HDRSZ: { + /* EVIDENCE-OF: R-39100-27317 The SQLITE_CONFIG_PCACHE_HDRSZ option takes + ** a single parameter which is a pointer to an integer and writes into + ** that integer the number of extra bytes per page required for each page + ** in SQLITE_CONFIG_PAGECACHE. */ + *va_arg(ap, int*) = + sqlite3HeaderSizeBtree() + + sqlite3HeaderSizePcache() + + sqlite3HeaderSizePcache1(); + break; + } + + case SQLITE_CONFIG_PCACHE: { + /* no-op */ + break; + } + case SQLITE_CONFIG_GETPCACHE: { + /* now an error */ + rc = SQLITE_ERROR; + break; + } + + case SQLITE_CONFIG_PCACHE2: { + /* EVIDENCE-OF: R-63325-48378 The SQLITE_CONFIG_PCACHE2 option takes a + ** single argument which is a pointer to an sqlite3_pcache_methods2 + ** object. This object specifies the interface to a custom page cache + ** implementation. */ + sqlite3GlobalConfig.pcache2 = *va_arg(ap, sqlite3_pcache_methods2*); + break; + } + case SQLITE_CONFIG_GETPCACHE2: { + /* EVIDENCE-OF: R-22035-46182 The SQLITE_CONFIG_GETPCACHE2 option takes a + ** single argument which is a pointer to an sqlite3_pcache_methods2 + ** object. SQLite copies of the current page cache implementation into + ** that object. */ + if( sqlite3GlobalConfig.pcache2.xInit==0 ){ + sqlite3PCacheSetDefault(); + } + *va_arg(ap, sqlite3_pcache_methods2*) = sqlite3GlobalConfig.pcache2; + break; + } + +/* EVIDENCE-OF: R-06626-12911 The SQLITE_CONFIG_HEAP option is only +** available if SQLite is compiled with either SQLITE_ENABLE_MEMSYS3 or +** SQLITE_ENABLE_MEMSYS5 and returns SQLITE_ERROR if invoked otherwise. */ +#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5) + case SQLITE_CONFIG_HEAP: { + /* EVIDENCE-OF: R-19854-42126 There are three arguments to + ** SQLITE_CONFIG_HEAP: An 8-byte aligned pointer to the memory, the + ** number of bytes in the memory buffer, and the minimum allocation size. + */ + sqlite3GlobalConfig.pHeap = va_arg(ap, void*); + sqlite3GlobalConfig.nHeap = va_arg(ap, int); + sqlite3GlobalConfig.mnReq = va_arg(ap, int); + + if( sqlite3GlobalConfig.mnReq<1 ){ + sqlite3GlobalConfig.mnReq = 1; + }else if( sqlite3GlobalConfig.mnReq>(1<<12) ){ + /* cap min request size at 2^12 */ + sqlite3GlobalConfig.mnReq = (1<<12); + } + + if( sqlite3GlobalConfig.pHeap==0 ){ + /* EVIDENCE-OF: R-49920-60189 If the first pointer (the memory pointer) + ** is NULL, then SQLite reverts to using its default memory allocator + ** (the system malloc() implementation), undoing any prior invocation of + ** SQLITE_CONFIG_MALLOC. + ** + ** Setting sqlite3GlobalConfig.m to all zeros will cause malloc to + ** revert to its default implementation when sqlite3_initialize() is run + */ + memset(&sqlite3GlobalConfig.m, 0, sizeof(sqlite3GlobalConfig.m)); + }else{ + /* EVIDENCE-OF: R-61006-08918 If the memory pointer is not NULL then the + ** alternative memory allocator is engaged to handle all of SQLites + ** memory allocation needs. */ +#ifdef SQLITE_ENABLE_MEMSYS3 + sqlite3GlobalConfig.m = *sqlite3MemGetMemsys3(); +#endif +#ifdef SQLITE_ENABLE_MEMSYS5 + sqlite3GlobalConfig.m = *sqlite3MemGetMemsys5(); +#endif + } + break; + } +#endif + + case SQLITE_CONFIG_LOOKASIDE: { + sqlite3GlobalConfig.szLookaside = va_arg(ap, int); + sqlite3GlobalConfig.nLookaside = va_arg(ap, int); + break; + } + + /* Record a pointer to the logger function and its first argument. + ** The default is NULL. Logging is disabled if the function pointer is + ** NULL. + */ + case SQLITE_CONFIG_LOG: { + /* MSVC is picky about pulling func ptrs from va lists. + ** http://support.microsoft.com/kb/47961 + ** sqlite3GlobalConfig.xLog = va_arg(ap, void(*)(void*,int,const char*)); + */ + typedef void(*LOGFUNC_t)(void*,int,const char*); + LOGFUNC_t xLog = va_arg(ap, LOGFUNC_t); + void *pLogArg = va_arg(ap, void*); + AtomicStore(&sqlite3GlobalConfig.xLog, xLog); + AtomicStore(&sqlite3GlobalConfig.pLogArg, pLogArg); + break; + } + + /* EVIDENCE-OF: R-55548-33817 The compile-time setting for URI filenames + ** can be changed at start-time using the + ** sqlite3_config(SQLITE_CONFIG_URI,1) or + ** sqlite3_config(SQLITE_CONFIG_URI,0) configuration calls. + */ + case SQLITE_CONFIG_URI: { + /* EVIDENCE-OF: R-25451-61125 The SQLITE_CONFIG_URI option takes a single + ** argument of type int. If non-zero, then URI handling is globally + ** enabled. If the parameter is zero, then URI handling is globally + ** disabled. */ + int bOpenUri = va_arg(ap, int); + AtomicStore(&sqlite3GlobalConfig.bOpenUri, bOpenUri); + break; + } + + case SQLITE_CONFIG_COVERING_INDEX_SCAN: { + /* EVIDENCE-OF: R-36592-02772 The SQLITE_CONFIG_COVERING_INDEX_SCAN + ** option takes a single integer argument which is interpreted as a + ** boolean in order to enable or disable the use of covering indices for + ** full table scans in the query optimizer. */ + sqlite3GlobalConfig.bUseCis = va_arg(ap, int); + break; + } + +#ifdef SQLITE_ENABLE_SQLLOG + case SQLITE_CONFIG_SQLLOG: { + typedef void(*SQLLOGFUNC_t)(void*, sqlite3*, const char*, int); + sqlite3GlobalConfig.xSqllog = va_arg(ap, SQLLOGFUNC_t); + sqlite3GlobalConfig.pSqllogArg = va_arg(ap, void *); + break; + } +#endif + + case SQLITE_CONFIG_MMAP_SIZE: { + /* EVIDENCE-OF: R-58063-38258 SQLITE_CONFIG_MMAP_SIZE takes two 64-bit + ** integer (sqlite3_int64) values that are the default mmap size limit + ** (the default setting for PRAGMA mmap_size) and the maximum allowed + ** mmap size limit. */ + sqlite3_int64 szMmap = va_arg(ap, sqlite3_int64); + sqlite3_int64 mxMmap = va_arg(ap, sqlite3_int64); + /* EVIDENCE-OF: R-53367-43190 If either argument to this option is + ** negative, then that argument is changed to its compile-time default. + ** + ** EVIDENCE-OF: R-34993-45031 The maximum allowed mmap size will be + ** silently truncated if necessary so that it does not exceed the + ** compile-time maximum mmap size set by the SQLITE_MAX_MMAP_SIZE + ** compile-time option. + */ + if( mxMmap<0 || mxMmap>SQLITE_MAX_MMAP_SIZE ){ + mxMmap = SQLITE_MAX_MMAP_SIZE; + } + if( szMmap<0 ) szMmap = SQLITE_DEFAULT_MMAP_SIZE; + if( szMmap>mxMmap) szMmap = mxMmap; + sqlite3GlobalConfig.mxMmap = mxMmap; + sqlite3GlobalConfig.szMmap = szMmap; + break; + } + +#if SQLITE_OS_WIN && defined(SQLITE_WIN32_MALLOC) /* IMP: R-04780-55815 */ + case SQLITE_CONFIG_WIN32_HEAPSIZE: { + /* EVIDENCE-OF: R-34926-03360 SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit + ** unsigned integer value that specifies the maximum size of the created + ** heap. */ + sqlite3GlobalConfig.nHeap = va_arg(ap, int); + break; + } +#endif + + case SQLITE_CONFIG_PMASZ: { + sqlite3GlobalConfig.szPma = va_arg(ap, unsigned int); + break; + } + + case SQLITE_CONFIG_STMTJRNL_SPILL: { + sqlite3GlobalConfig.nStmtSpill = va_arg(ap, int); + break; + } + +#ifdef SQLITE_ENABLE_SORTER_REFERENCES + case SQLITE_CONFIG_SORTERREF_SIZE: { + int iVal = va_arg(ap, int); + if( iVal<0 ){ + iVal = SQLITE_DEFAULT_SORTERREF_SIZE; + } + sqlite3GlobalConfig.szSorterRef = (u32)iVal; + break; + } +#endif /* SQLITE_ENABLE_SORTER_REFERENCES */ + +#ifndef SQLITE_OMIT_DESERIALIZE + case SQLITE_CONFIG_MEMDB_MAXSIZE: { + sqlite3GlobalConfig.mxMemdbSize = va_arg(ap, sqlite3_int64); + break; + } +#endif /* SQLITE_OMIT_DESERIALIZE */ + + default: { + rc = SQLITE_ERROR; + break; + } + } + va_end(ap); + return rc; +} + +/* +** Set up the lookaside buffers for a database connection. +** Return SQLITE_OK on success. +** If lookaside is already active, return SQLITE_BUSY. +** +** The sz parameter is the number of bytes in each lookaside slot. +** The cnt parameter is the number of slots. If pStart is NULL the +** space for the lookaside memory is obtained from sqlite3_malloc(). +** If pStart is not NULL then it is sz*cnt bytes of memory to use for +** the lookaside memory. +*/ +static int setupLookaside(sqlite3 *db, void *pBuf, int sz, int cnt){ +#ifndef SQLITE_OMIT_LOOKASIDE + void *pStart; + sqlite3_int64 szAlloc = sz*(sqlite3_int64)cnt; + int nBig; /* Number of full-size slots */ + int nSm; /* Number smaller LOOKASIDE_SMALL-byte slots */ + + if( sqlite3LookasideUsed(db,0)>0 ){ + return SQLITE_BUSY; + } + /* Free any existing lookaside buffer for this handle before + ** allocating a new one so we don't have to have space for + ** both at the same time. + */ + if( db->lookaside.bMalloced ){ + sqlite3_free(db->lookaside.pStart); + } + /* The size of a lookaside slot after ROUNDDOWN8 needs to be larger + ** than a pointer to be useful. + */ + sz = ROUNDDOWN8(sz); /* IMP: R-33038-09382 */ + if( sz<=(int)sizeof(LookasideSlot*) ) sz = 0; + if( cnt<0 ) cnt = 0; + if( sz==0 || cnt==0 ){ + sz = 0; + pStart = 0; + }else if( pBuf==0 ){ + sqlite3BeginBenignMalloc(); + pStart = sqlite3Malloc( szAlloc ); /* IMP: R-61949-35727 */ + sqlite3EndBenignMalloc(); + if( pStart ) szAlloc = sqlite3MallocSize(pStart); + }else{ + pStart = pBuf; + } +#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE + if( sz>=LOOKASIDE_SMALL*3 ){ + nBig = szAlloc/(3*LOOKASIDE_SMALL+sz); + nSm = (szAlloc - sz*nBig)/LOOKASIDE_SMALL; + }else if( sz>=LOOKASIDE_SMALL*2 ){ + nBig = szAlloc/(LOOKASIDE_SMALL+sz); + nSm = (szAlloc - sz*nBig)/LOOKASIDE_SMALL; + }else +#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */ + if( sz>0 ){ + nBig = szAlloc/sz; + nSm = 0; + }else{ + nBig = nSm = 0; + } + db->lookaside.pStart = pStart; + db->lookaside.pInit = 0; + db->lookaside.pFree = 0; + db->lookaside.sz = (u16)sz; + db->lookaside.szTrue = (u16)sz; + if( pStart ){ + int i; + LookasideSlot *p; + assert( sz > (int)sizeof(LookasideSlot*) ); + p = (LookasideSlot*)pStart; + for(i=0; ipNext = db->lookaside.pInit; + db->lookaside.pInit = p; + p = (LookasideSlot*)&((u8*)p)[sz]; + } +#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE + db->lookaside.pSmallInit = 0; + db->lookaside.pSmallFree = 0; + db->lookaside.pMiddle = p; + for(i=0; ipNext = db->lookaside.pSmallInit; + db->lookaside.pSmallInit = p; + p = (LookasideSlot*)&((u8*)p)[LOOKASIDE_SMALL]; + } +#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */ + assert( ((uptr)p)<=szAlloc + (uptr)pStart ); + db->lookaside.pEnd = p; + db->lookaside.bDisable = 0; + db->lookaside.bMalloced = pBuf==0 ?1:0; + db->lookaside.nSlot = nBig+nSm; + }else{ + db->lookaside.pStart = 0; +#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE + db->lookaside.pSmallInit = 0; + db->lookaside.pSmallFree = 0; + db->lookaside.pMiddle = 0; +#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */ + db->lookaside.pEnd = 0; + db->lookaside.bDisable = 1; + db->lookaside.sz = 0; + db->lookaside.bMalloced = 0; + db->lookaside.nSlot = 0; + } + db->lookaside.pTrueEnd = db->lookaside.pEnd; + assert( sqlite3LookasideUsed(db,0)==0 ); +#endif /* SQLITE_OMIT_LOOKASIDE */ + return SQLITE_OK; +} + +/* +** Return the mutex associated with a database connection. +*/ +SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3 *db){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + return db->mutex; +} + +/* +** Free up as much memory as we can from the given database +** connection. +*/ +SQLITE_API int sqlite3_db_release_memory(sqlite3 *db){ + int i; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + sqlite3BtreeEnterAll(db); + for(i=0; inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + Pager *pPager = sqlite3BtreePager(pBt); + sqlite3PagerShrink(pPager); + } + } + sqlite3BtreeLeaveAll(db); + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +/* +** Flush any dirty pages in the pager-cache for any attached database +** to disk. +*/ +SQLITE_API int sqlite3_db_cacheflush(sqlite3 *db){ + int i; + int rc = SQLITE_OK; + int bSeenBusy = 0; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + sqlite3BtreeEnterAll(db); + for(i=0; rc==SQLITE_OK && inDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt && sqlite3BtreeTxnState(pBt)==SQLITE_TXN_WRITE ){ + Pager *pPager = sqlite3BtreePager(pBt); + rc = sqlite3PagerFlush(pPager); + if( rc==SQLITE_BUSY ){ + bSeenBusy = 1; + rc = SQLITE_OK; + } + } + } + sqlite3BtreeLeaveAll(db); + sqlite3_mutex_leave(db->mutex); + return ((rc==SQLITE_OK && bSeenBusy) ? SQLITE_BUSY : rc); +} + +/* +** Configuration settings for an individual database connection +*/ +SQLITE_API int sqlite3_db_config(sqlite3 *db, int op, ...){ + va_list ap; + int rc; + sqlite3_mutex_enter(db->mutex); + va_start(ap, op); + switch( op ){ + case SQLITE_DBCONFIG_MAINDBNAME: { + /* IMP: R-06824-28531 */ + /* IMP: R-36257-52125 */ + db->aDb[0].zDbSName = va_arg(ap,char*); + rc = SQLITE_OK; + break; + } + case SQLITE_DBCONFIG_LOOKASIDE: { + void *pBuf = va_arg(ap, void*); /* IMP: R-26835-10964 */ + int sz = va_arg(ap, int); /* IMP: R-47871-25994 */ + int cnt = va_arg(ap, int); /* IMP: R-04460-53386 */ + rc = setupLookaside(db, pBuf, sz, cnt); + break; + } + default: { + static const struct { + int op; /* The opcode */ + u32 mask; /* Mask of the bit in sqlite3.flags to set/clear */ + } aFlagOp[] = { + { SQLITE_DBCONFIG_ENABLE_FKEY, SQLITE_ForeignKeys }, + { SQLITE_DBCONFIG_ENABLE_TRIGGER, SQLITE_EnableTrigger }, + { SQLITE_DBCONFIG_ENABLE_VIEW, SQLITE_EnableView }, + { SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, SQLITE_Fts3Tokenizer }, + { SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, SQLITE_LoadExtension }, + { SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE, SQLITE_NoCkptOnClose }, + { SQLITE_DBCONFIG_ENABLE_QPSG, SQLITE_EnableQPSG }, + { SQLITE_DBCONFIG_TRIGGER_EQP, SQLITE_TriggerEQP }, + { SQLITE_DBCONFIG_RESET_DATABASE, SQLITE_ResetDatabase }, + { SQLITE_DBCONFIG_DEFENSIVE, SQLITE_Defensive }, + { SQLITE_DBCONFIG_WRITABLE_SCHEMA, SQLITE_WriteSchema| + SQLITE_NoSchemaError }, + { SQLITE_DBCONFIG_LEGACY_ALTER_TABLE, SQLITE_LegacyAlter }, + { SQLITE_DBCONFIG_DQS_DDL, SQLITE_DqsDDL }, + { SQLITE_DBCONFIG_DQS_DML, SQLITE_DqsDML }, + { SQLITE_DBCONFIG_LEGACY_FILE_FORMAT, SQLITE_LegacyFileFmt }, + { SQLITE_DBCONFIG_TRUSTED_SCHEMA, SQLITE_TrustedSchema }, + { SQLITE_DBCONFIG_STMT_SCANSTATUS, SQLITE_StmtScanStatus }, + { SQLITE_DBCONFIG_REVERSE_SCANORDER, SQLITE_ReverseOrder }, + }; + unsigned int i; + rc = SQLITE_ERROR; /* IMP: R-42790-23372 */ + for(i=0; iflags; + if( onoff>0 ){ + db->flags |= aFlagOp[i].mask; + }else if( onoff==0 ){ + db->flags &= ~(u64)aFlagOp[i].mask; + } + if( oldFlags!=db->flags ){ + sqlite3ExpirePreparedStatements(db, 0); + } + if( pRes ){ + *pRes = (db->flags & aFlagOp[i].mask)!=0; + } + rc = SQLITE_OK; + break; + } + } + break; + } + } + va_end(ap); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** This is the default collating function named "BINARY" which is always +** available. +*/ +static int binCollFunc( + void *NotUsed, + int nKey1, const void *pKey1, + int nKey2, const void *pKey2 +){ + int rc, n; + UNUSED_PARAMETER(NotUsed); + n = nKey1xCmp!=binCollFunc || strcmp(p->zName,"BINARY")==0 ); + return p==0 || p->xCmp==binCollFunc; +} + +/* +** Another built-in collating sequence: NOCASE. +** +** This collating sequence is intended to be used for "case independent +** comparison". SQLite's knowledge of upper and lower case equivalents +** extends only to the 26 characters used in the English language. +** +** At the moment there is only a UTF-8 implementation. +*/ +static int nocaseCollatingFunc( + void *NotUsed, + int nKey1, const void *pKey1, + int nKey2, const void *pKey2 +){ + int r = sqlite3StrNICmp( + (const char *)pKey1, (const char *)pKey2, (nKey1lastRowid; +} + +/* +** Set the value returned by the sqlite3_last_insert_rowid() API function. +*/ +SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3 *db, sqlite3_int64 iRowid){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return; + } +#endif + sqlite3_mutex_enter(db->mutex); + db->lastRowid = iRowid; + sqlite3_mutex_leave(db->mutex); +} + +/* +** Return the number of changes in the most recent call to sqlite3_exec(). +*/ +SQLITE_API sqlite3_int64 sqlite3_changes64(sqlite3 *db){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + return db->nChange; +} +SQLITE_API int sqlite3_changes(sqlite3 *db){ + return (int)sqlite3_changes64(db); +} + +/* +** Return the number of changes since the database handle was opened. +*/ +SQLITE_API sqlite3_int64 sqlite3_total_changes64(sqlite3 *db){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + return db->nTotalChange; +} +SQLITE_API int sqlite3_total_changes(sqlite3 *db){ + return (int)sqlite3_total_changes64(db); +} + +/* +** Close all open savepoints. This function only manipulates fields of the +** database handle object, it does not close any savepoints that may be open +** at the b-tree/pager level. +*/ +SQLITE_PRIVATE void sqlite3CloseSavepoints(sqlite3 *db){ + while( db->pSavepoint ){ + Savepoint *pTmp = db->pSavepoint; + db->pSavepoint = pTmp->pNext; + sqlite3DbFree(db, pTmp); + } + db->nSavepoint = 0; + db->nStatement = 0; + db->isTransactionSavepoint = 0; +} + +/* +** Invoke the destructor function associated with FuncDef p, if any. Except, +** if this is not the last copy of the function, do not invoke it. Multiple +** copies of a single function are created when create_function() is called +** with SQLITE_ANY as the encoding. +*/ +static void functionDestroy(sqlite3 *db, FuncDef *p){ + FuncDestructor *pDestructor; + assert( (p->funcFlags & SQLITE_FUNC_BUILTIN)==0 ); + pDestructor = p->u.pDestructor; + if( pDestructor ){ + pDestructor->nRef--; + if( pDestructor->nRef==0 ){ + pDestructor->xDestroy(pDestructor->pUserData); + sqlite3DbFree(db, pDestructor); + } + } +} + +/* +** Disconnect all sqlite3_vtab objects that belong to database connection +** db. This is called when db is being closed. +*/ +static void disconnectAllVtab(sqlite3 *db){ +#ifndef SQLITE_OMIT_VIRTUALTABLE + int i; + HashElem *p; + sqlite3BtreeEnterAll(db); + for(i=0; inDb; i++){ + Schema *pSchema = db->aDb[i].pSchema; + if( pSchema ){ + for(p=sqliteHashFirst(&pSchema->tblHash); p; p=sqliteHashNext(p)){ + Table *pTab = (Table *)sqliteHashData(p); + if( IsVirtual(pTab) ) sqlite3VtabDisconnect(db, pTab); + } + } + } + for(p=sqliteHashFirst(&db->aModule); p; p=sqliteHashNext(p)){ + Module *pMod = (Module *)sqliteHashData(p); + if( pMod->pEpoTab ){ + sqlite3VtabDisconnect(db, pMod->pEpoTab); + } + } + sqlite3VtabUnlockList(db); + sqlite3BtreeLeaveAll(db); +#else + UNUSED_PARAMETER(db); +#endif +} + +/* +** Return TRUE if database connection db has unfinalized prepared +** statements or unfinished sqlite3_backup objects. +*/ +static int connectionIsBusy(sqlite3 *db){ + int j; + assert( sqlite3_mutex_held(db->mutex) ); + if( db->pVdbe ) return 1; + for(j=0; jnDb; j++){ + Btree *pBt = db->aDb[j].pBt; + if( pBt && sqlite3BtreeIsInBackup(pBt) ) return 1; + } + return 0; +} + +/* +** Close an existing SQLite database +*/ +static int sqlite3Close(sqlite3 *db, int forceZombie){ + if( !db ){ + /* EVIDENCE-OF: R-63257-11740 Calling sqlite3_close() or + ** sqlite3_close_v2() with a NULL pointer argument is a harmless no-op. */ + return SQLITE_OK; + } + if( !sqlite3SafetyCheckSickOrOk(db) ){ + return SQLITE_MISUSE_BKPT; + } + sqlite3_mutex_enter(db->mutex); + if( db->mTrace & SQLITE_TRACE_CLOSE ){ + db->trace.xV2(SQLITE_TRACE_CLOSE, db->pTraceArg, db, 0); + } + + /* Force xDisconnect calls on all virtual tables */ + disconnectAllVtab(db); + + /* If a transaction is open, the disconnectAllVtab() call above + ** will not have called the xDisconnect() method on any virtual + ** tables in the db->aVTrans[] array. The following sqlite3VtabRollback() + ** call will do so. We need to do this before the check for active + ** SQL statements below, as the v-table implementation may be storing + ** some prepared statements internally. + */ + sqlite3VtabRollback(db); + + /* Legacy behavior (sqlite3_close() behavior) is to return + ** SQLITE_BUSY if the connection can not be closed immediately. + */ + if( !forceZombie && connectionIsBusy(db) ){ + sqlite3ErrorWithMsg(db, SQLITE_BUSY, "unable to close due to unfinalized " + "statements or unfinished backups"); + sqlite3_mutex_leave(db->mutex); + return SQLITE_BUSY; + } + +#ifdef SQLITE_ENABLE_SQLLOG + if( sqlite3GlobalConfig.xSqllog ){ + /* Closing the handle. Fourth parameter is passed the value 2. */ + sqlite3GlobalConfig.xSqllog(sqlite3GlobalConfig.pSqllogArg, db, 0, 2); + } +#endif + + /* Convert the connection into a zombie and then close it. + */ + db->eOpenState = SQLITE_STATE_ZOMBIE; + sqlite3LeaveMutexAndCloseZombie(db); + return SQLITE_OK; +} + +/* +** Return the transaction state for a single databse, or the maximum +** transaction state over all attached databases if zSchema is null. +*/ +SQLITE_API int sqlite3_txn_state(sqlite3 *db, const char *zSchema){ + int iDb, nDb; + int iTxn = -1; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return -1; + } +#endif + sqlite3_mutex_enter(db->mutex); + if( zSchema ){ + nDb = iDb = sqlite3FindDbName(db, zSchema); + if( iDb<0 ) nDb--; + }else{ + iDb = 0; + nDb = db->nDb-1; + } + for(; iDb<=nDb; iDb++){ + Btree *pBt = db->aDb[iDb].pBt; + int x = pBt!=0 ? sqlite3BtreeTxnState(pBt) : SQLITE_TXN_NONE; + if( x>iTxn ) iTxn = x; + } + sqlite3_mutex_leave(db->mutex); + return iTxn; +} + +/* +** Two variations on the public interface for closing a database +** connection. The sqlite3_close() version returns SQLITE_BUSY and +** leaves the connection open if there are unfinalized prepared +** statements or unfinished sqlite3_backups. The sqlite3_close_v2() +** version forces the connection to become a zombie if there are +** unclosed resources, and arranges for deallocation when the last +** prepare statement or sqlite3_backup closes. +*/ +SQLITE_API int sqlite3_close(sqlite3 *db){ return sqlite3Close(db,0); } +SQLITE_API int sqlite3_close_v2(sqlite3 *db){ return sqlite3Close(db,1); } + + +/* +** Close the mutex on database connection db. +** +** Furthermore, if database connection db is a zombie (meaning that there +** has been a prior call to sqlite3_close(db) or sqlite3_close_v2(db)) and +** every sqlite3_stmt has now been finalized and every sqlite3_backup has +** finished, then free all resources. +*/ +SQLITE_PRIVATE void sqlite3LeaveMutexAndCloseZombie(sqlite3 *db){ + HashElem *i; /* Hash table iterator */ + int j; + + /* If there are outstanding sqlite3_stmt or sqlite3_backup objects + ** or if the connection has not yet been closed by sqlite3_close_v2(), + ** then just leave the mutex and return. + */ + if( db->eOpenState!=SQLITE_STATE_ZOMBIE || connectionIsBusy(db) ){ + sqlite3_mutex_leave(db->mutex); + return; + } + + /* If we reach this point, it means that the database connection has + ** closed all sqlite3_stmt and sqlite3_backup objects and has been + ** passed to sqlite3_close (meaning that it is a zombie). Therefore, + ** go ahead and free all resources. + */ + + /* If a transaction is open, roll it back. This also ensures that if + ** any database schemas have been modified by an uncommitted transaction + ** they are reset. And that the required b-tree mutex is held to make + ** the pager rollback and schema reset an atomic operation. */ + sqlite3RollbackAll(db, SQLITE_OK); + + /* Free any outstanding Savepoint structures. */ + sqlite3CloseSavepoints(db); + + /* Close all database connections */ + for(j=0; jnDb; j++){ + struct Db *pDb = &db->aDb[j]; + if( pDb->pBt ){ + sqlite3BtreeClose(pDb->pBt); + pDb->pBt = 0; + if( j!=1 ){ + pDb->pSchema = 0; + } + } + } + /* Clear the TEMP schema separately and last */ + if( db->aDb[1].pSchema ){ + sqlite3SchemaClear(db->aDb[1].pSchema); + } + sqlite3VtabUnlockList(db); + + /* Free up the array of auxiliary databases */ + sqlite3CollapseDatabaseArray(db); + assert( db->nDb<=2 ); + assert( db->aDb==db->aDbStatic ); + + /* Tell the code in notify.c that the connection no longer holds any + ** locks and does not require any further unlock-notify callbacks. + */ + sqlite3ConnectionClosed(db); + + for(i=sqliteHashFirst(&db->aFunc); i; i=sqliteHashNext(i)){ + FuncDef *pNext, *p; + p = sqliteHashData(i); + do{ + functionDestroy(db, p); + pNext = p->pNext; + sqlite3DbFree(db, p); + p = pNext; + }while( p ); + } + sqlite3HashClear(&db->aFunc); + for(i=sqliteHashFirst(&db->aCollSeq); i; i=sqliteHashNext(i)){ + CollSeq *pColl = (CollSeq *)sqliteHashData(i); + /* Invoke any destructors registered for collation sequence user data. */ + for(j=0; j<3; j++){ + if( pColl[j].xDel ){ + pColl[j].xDel(pColl[j].pUser); + } + } + sqlite3DbFree(db, pColl); + } + sqlite3HashClear(&db->aCollSeq); +#ifndef SQLITE_OMIT_VIRTUALTABLE + for(i=sqliteHashFirst(&db->aModule); i; i=sqliteHashNext(i)){ + Module *pMod = (Module *)sqliteHashData(i); + sqlite3VtabEponymousTableClear(db, pMod); + sqlite3VtabModuleUnref(db, pMod); + } + sqlite3HashClear(&db->aModule); +#endif + + sqlite3Error(db, SQLITE_OK); /* Deallocates any cached error strings. */ + sqlite3ValueFree(db->pErr); + sqlite3CloseExtensions(db); +#if SQLITE_USER_AUTHENTICATION + sqlite3_free(db->auth.zAuthUser); + sqlite3_free(db->auth.zAuthPW); +#endif + + db->eOpenState = SQLITE_STATE_ERROR; + + /* The temp-database schema is allocated differently from the other schema + ** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()). + ** So it needs to be freed here. Todo: Why not roll the temp schema into + ** the same sqliteMalloc() as the one that allocates the database + ** structure? + */ + sqlite3DbFree(db, db->aDb[1].pSchema); + if( db->xAutovacDestr ){ + db->xAutovacDestr(db->pAutovacPagesArg); + } + sqlite3_mutex_leave(db->mutex); + db->eOpenState = SQLITE_STATE_CLOSED; + sqlite3_mutex_free(db->mutex); + assert( sqlite3LookasideUsed(db,0)==0 ); + if( db->lookaside.bMalloced ){ + sqlite3_free(db->lookaside.pStart); + } + sqlite3_free(db); +} + +/* +** Rollback all database files. If tripCode is not SQLITE_OK, then +** any write cursors are invalidated ("tripped" - as in "tripping a circuit +** breaker") and made to return tripCode if there are any further +** attempts to use that cursor. Read cursors remain open and valid +** but are "saved" in case the table pages are moved around. +*/ +SQLITE_PRIVATE void sqlite3RollbackAll(sqlite3 *db, int tripCode){ + int i; + int inTrans = 0; + int schemaChange; + assert( sqlite3_mutex_held(db->mutex) ); + sqlite3BeginBenignMalloc(); + + /* Obtain all b-tree mutexes before making any calls to BtreeRollback(). + ** This is important in case the transaction being rolled back has + ** modified the database schema. If the b-tree mutexes are not taken + ** here, then another shared-cache connection might sneak in between + ** the database rollback and schema reset, which can cause false + ** corruption reports in some cases. */ + sqlite3BtreeEnterAll(db); + schemaChange = (db->mDbFlags & DBFLAG_SchemaChange)!=0 && db->init.busy==0; + + for(i=0; inDb; i++){ + Btree *p = db->aDb[i].pBt; + if( p ){ + if( sqlite3BtreeTxnState(p)==SQLITE_TXN_WRITE ){ + inTrans = 1; + } + sqlite3BtreeRollback(p, tripCode, !schemaChange); + } + } + sqlite3VtabRollback(db); + sqlite3EndBenignMalloc(); + + if( schemaChange ){ + sqlite3ExpirePreparedStatements(db, 0); + sqlite3ResetAllSchemasOfConnection(db); + } + sqlite3BtreeLeaveAll(db); + + /* Any deferred constraint violations have now been resolved. */ + db->nDeferredCons = 0; + db->nDeferredImmCons = 0; + db->flags &= ~(u64)(SQLITE_DeferFKs|SQLITE_CorruptRdOnly); + + /* If one has been configured, invoke the rollback-hook callback */ + if( db->xRollbackCallback && (inTrans || !db->autoCommit) ){ + db->xRollbackCallback(db->pRollbackArg); + } +} + +/* +** Return a static string containing the name corresponding to the error code +** specified in the argument. +*/ +#if defined(SQLITE_NEED_ERR_NAME) +SQLITE_PRIVATE const char *sqlite3ErrName(int rc){ + const char *zName = 0; + int i, origRc = rc; + for(i=0; i<2 && zName==0; i++, rc &= 0xff){ + switch( rc ){ + case SQLITE_OK: zName = "SQLITE_OK"; break; + case SQLITE_ERROR: zName = "SQLITE_ERROR"; break; + case SQLITE_ERROR_SNAPSHOT: zName = "SQLITE_ERROR_SNAPSHOT"; break; + case SQLITE_INTERNAL: zName = "SQLITE_INTERNAL"; break; + case SQLITE_PERM: zName = "SQLITE_PERM"; break; + case SQLITE_ABORT: zName = "SQLITE_ABORT"; break; + case SQLITE_ABORT_ROLLBACK: zName = "SQLITE_ABORT_ROLLBACK"; break; + case SQLITE_BUSY: zName = "SQLITE_BUSY"; break; + case SQLITE_BUSY_RECOVERY: zName = "SQLITE_BUSY_RECOVERY"; break; + case SQLITE_BUSY_SNAPSHOT: zName = "SQLITE_BUSY_SNAPSHOT"; break; + case SQLITE_LOCKED: zName = "SQLITE_LOCKED"; break; + case SQLITE_LOCKED_SHAREDCACHE: zName = "SQLITE_LOCKED_SHAREDCACHE";break; + case SQLITE_NOMEM: zName = "SQLITE_NOMEM"; break; + case SQLITE_READONLY: zName = "SQLITE_READONLY"; break; + case SQLITE_READONLY_RECOVERY: zName = "SQLITE_READONLY_RECOVERY"; break; + case SQLITE_READONLY_CANTINIT: zName = "SQLITE_READONLY_CANTINIT"; break; + case SQLITE_READONLY_ROLLBACK: zName = "SQLITE_READONLY_ROLLBACK"; break; + case SQLITE_READONLY_DBMOVED: zName = "SQLITE_READONLY_DBMOVED"; break; + case SQLITE_READONLY_DIRECTORY: zName = "SQLITE_READONLY_DIRECTORY";break; + case SQLITE_INTERRUPT: zName = "SQLITE_INTERRUPT"; break; + case SQLITE_IOERR: zName = "SQLITE_IOERR"; break; + case SQLITE_IOERR_READ: zName = "SQLITE_IOERR_READ"; break; + case SQLITE_IOERR_SHORT_READ: zName = "SQLITE_IOERR_SHORT_READ"; break; + case SQLITE_IOERR_WRITE: zName = "SQLITE_IOERR_WRITE"; break; + case SQLITE_IOERR_FSYNC: zName = "SQLITE_IOERR_FSYNC"; break; + case SQLITE_IOERR_DIR_FSYNC: zName = "SQLITE_IOERR_DIR_FSYNC"; break; + case SQLITE_IOERR_TRUNCATE: zName = "SQLITE_IOERR_TRUNCATE"; break; + case SQLITE_IOERR_FSTAT: zName = "SQLITE_IOERR_FSTAT"; break; + case SQLITE_IOERR_UNLOCK: zName = "SQLITE_IOERR_UNLOCK"; break; + case SQLITE_IOERR_RDLOCK: zName = "SQLITE_IOERR_RDLOCK"; break; + case SQLITE_IOERR_DELETE: zName = "SQLITE_IOERR_DELETE"; break; + case SQLITE_IOERR_NOMEM: zName = "SQLITE_IOERR_NOMEM"; break; + case SQLITE_IOERR_ACCESS: zName = "SQLITE_IOERR_ACCESS"; break; + case SQLITE_IOERR_CHECKRESERVEDLOCK: + zName = "SQLITE_IOERR_CHECKRESERVEDLOCK"; break; + case SQLITE_IOERR_LOCK: zName = "SQLITE_IOERR_LOCK"; break; + case SQLITE_IOERR_CLOSE: zName = "SQLITE_IOERR_CLOSE"; break; + case SQLITE_IOERR_DIR_CLOSE: zName = "SQLITE_IOERR_DIR_CLOSE"; break; + case SQLITE_IOERR_SHMOPEN: zName = "SQLITE_IOERR_SHMOPEN"; break; + case SQLITE_IOERR_SHMSIZE: zName = "SQLITE_IOERR_SHMSIZE"; break; + case SQLITE_IOERR_SHMLOCK: zName = "SQLITE_IOERR_SHMLOCK"; break; + case SQLITE_IOERR_SHMMAP: zName = "SQLITE_IOERR_SHMMAP"; break; + case SQLITE_IOERR_SEEK: zName = "SQLITE_IOERR_SEEK"; break; + case SQLITE_IOERR_DELETE_NOENT: zName = "SQLITE_IOERR_DELETE_NOENT";break; + case SQLITE_IOERR_MMAP: zName = "SQLITE_IOERR_MMAP"; break; + case SQLITE_IOERR_GETTEMPPATH: zName = "SQLITE_IOERR_GETTEMPPATH"; break; + case SQLITE_IOERR_CONVPATH: zName = "SQLITE_IOERR_CONVPATH"; break; + case SQLITE_CORRUPT: zName = "SQLITE_CORRUPT"; break; + case SQLITE_CORRUPT_VTAB: zName = "SQLITE_CORRUPT_VTAB"; break; + case SQLITE_NOTFOUND: zName = "SQLITE_NOTFOUND"; break; + case SQLITE_FULL: zName = "SQLITE_FULL"; break; + case SQLITE_CANTOPEN: zName = "SQLITE_CANTOPEN"; break; + case SQLITE_CANTOPEN_NOTEMPDIR: zName = "SQLITE_CANTOPEN_NOTEMPDIR";break; + case SQLITE_CANTOPEN_ISDIR: zName = "SQLITE_CANTOPEN_ISDIR"; break; + case SQLITE_CANTOPEN_FULLPATH: zName = "SQLITE_CANTOPEN_FULLPATH"; break; + case SQLITE_CANTOPEN_CONVPATH: zName = "SQLITE_CANTOPEN_CONVPATH"; break; + case SQLITE_CANTOPEN_SYMLINK: zName = "SQLITE_CANTOPEN_SYMLINK"; break; + case SQLITE_PROTOCOL: zName = "SQLITE_PROTOCOL"; break; + case SQLITE_EMPTY: zName = "SQLITE_EMPTY"; break; + case SQLITE_SCHEMA: zName = "SQLITE_SCHEMA"; break; + case SQLITE_TOOBIG: zName = "SQLITE_TOOBIG"; break; + case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT"; break; + case SQLITE_CONSTRAINT_UNIQUE: zName = "SQLITE_CONSTRAINT_UNIQUE"; break; + case SQLITE_CONSTRAINT_TRIGGER: zName = "SQLITE_CONSTRAINT_TRIGGER";break; + case SQLITE_CONSTRAINT_FOREIGNKEY: + zName = "SQLITE_CONSTRAINT_FOREIGNKEY"; break; + case SQLITE_CONSTRAINT_CHECK: zName = "SQLITE_CONSTRAINT_CHECK"; break; + case SQLITE_CONSTRAINT_PRIMARYKEY: + zName = "SQLITE_CONSTRAINT_PRIMARYKEY"; break; + case SQLITE_CONSTRAINT_NOTNULL: zName = "SQLITE_CONSTRAINT_NOTNULL";break; + case SQLITE_CONSTRAINT_COMMITHOOK: + zName = "SQLITE_CONSTRAINT_COMMITHOOK"; break; + case SQLITE_CONSTRAINT_VTAB: zName = "SQLITE_CONSTRAINT_VTAB"; break; + case SQLITE_CONSTRAINT_FUNCTION: + zName = "SQLITE_CONSTRAINT_FUNCTION"; break; + case SQLITE_CONSTRAINT_ROWID: zName = "SQLITE_CONSTRAINT_ROWID"; break; + case SQLITE_MISMATCH: zName = "SQLITE_MISMATCH"; break; + case SQLITE_MISUSE: zName = "SQLITE_MISUSE"; break; + case SQLITE_NOLFS: zName = "SQLITE_NOLFS"; break; + case SQLITE_AUTH: zName = "SQLITE_AUTH"; break; + case SQLITE_FORMAT: zName = "SQLITE_FORMAT"; break; + case SQLITE_RANGE: zName = "SQLITE_RANGE"; break; + case SQLITE_NOTADB: zName = "SQLITE_NOTADB"; break; + case SQLITE_ROW: zName = "SQLITE_ROW"; break; + case SQLITE_NOTICE: zName = "SQLITE_NOTICE"; break; + case SQLITE_NOTICE_RECOVER_WAL: zName = "SQLITE_NOTICE_RECOVER_WAL";break; + case SQLITE_NOTICE_RECOVER_ROLLBACK: + zName = "SQLITE_NOTICE_RECOVER_ROLLBACK"; break; + case SQLITE_NOTICE_RBU: zName = "SQLITE_NOTICE_RBU"; break; + case SQLITE_WARNING: zName = "SQLITE_WARNING"; break; + case SQLITE_WARNING_AUTOINDEX: zName = "SQLITE_WARNING_AUTOINDEX"; break; + case SQLITE_DONE: zName = "SQLITE_DONE"; break; + } + } + if( zName==0 ){ + static char zBuf[50]; + sqlite3_snprintf(sizeof(zBuf), zBuf, "SQLITE_UNKNOWN(%d)", origRc); + zName = zBuf; + } + return zName; +} +#endif + +/* +** Return a static string that describes the kind of error specified in the +** argument. +*/ +SQLITE_PRIVATE const char *sqlite3ErrStr(int rc){ + static const char* const aMsg[] = { + /* SQLITE_OK */ "not an error", + /* SQLITE_ERROR */ "SQL logic error", + /* SQLITE_INTERNAL */ 0, + /* SQLITE_PERM */ "access permission denied", + /* SQLITE_ABORT */ "query aborted", + /* SQLITE_BUSY */ "database is locked", + /* SQLITE_LOCKED */ "database table is locked", + /* SQLITE_NOMEM */ "out of memory", + /* SQLITE_READONLY */ "attempt to write a readonly database", + /* SQLITE_INTERRUPT */ "interrupted", + /* SQLITE_IOERR */ "disk I/O error", + /* SQLITE_CORRUPT */ "database disk image is malformed", + /* SQLITE_NOTFOUND */ "unknown operation", + /* SQLITE_FULL */ "database or disk is full", + /* SQLITE_CANTOPEN */ "unable to open database file", + /* SQLITE_PROTOCOL */ "locking protocol", + /* SQLITE_EMPTY */ 0, + /* SQLITE_SCHEMA */ "database schema has changed", + /* SQLITE_TOOBIG */ "string or blob too big", + /* SQLITE_CONSTRAINT */ "constraint failed", + /* SQLITE_MISMATCH */ "datatype mismatch", + /* SQLITE_MISUSE */ "bad parameter or other API misuse", +#ifdef SQLITE_DISABLE_LFS + /* SQLITE_NOLFS */ "large file support is disabled", +#else + /* SQLITE_NOLFS */ 0, +#endif + /* SQLITE_AUTH */ "authorization denied", + /* SQLITE_FORMAT */ 0, + /* SQLITE_RANGE */ "column index out of range", + /* SQLITE_NOTADB */ "file is not a database", + /* SQLITE_NOTICE */ "notification message", + /* SQLITE_WARNING */ "warning message", + }; + const char *zErr = "unknown error"; + switch( rc ){ + case SQLITE_ABORT_ROLLBACK: { + zErr = "abort due to ROLLBACK"; + break; + } + case SQLITE_ROW: { + zErr = "another row available"; + break; + } + case SQLITE_DONE: { + zErr = "no more rows available"; + break; + } + default: { + rc &= 0xff; + if( ALWAYS(rc>=0) && rcbusyTimeout; + int delay, prior; + + assert( count>=0 ); + if( count < NDELAY ){ + delay = delays[count]; + prior = totals[count]; + }else{ + delay = delays[NDELAY-1]; + prior = totals[NDELAY-1] + delay*(count-(NDELAY-1)); + } + if( prior + delay > tmout ){ + delay = tmout - prior; + if( delay<=0 ) return 0; + } + sqlite3OsSleep(db->pVfs, delay*1000); + return 1; +#else + /* This case for unix systems that lack usleep() support. Sleeping + ** must be done in increments of whole seconds */ + sqlite3 *db = (sqlite3 *)ptr; + int tmout = ((sqlite3 *)ptr)->busyTimeout; + if( (count+1)*1000 > tmout ){ + return 0; + } + sqlite3OsSleep(db->pVfs, 1000000); + return 1; +#endif +} + +/* +** Invoke the given busy handler. +** +** This routine is called when an operation failed to acquire a +** lock on VFS file pFile. +** +** If this routine returns non-zero, the lock is retried. If it +** returns 0, the operation aborts with an SQLITE_BUSY error. +*/ +SQLITE_PRIVATE int sqlite3InvokeBusyHandler(BusyHandler *p){ + int rc; + if( p->xBusyHandler==0 || p->nBusy<0 ) return 0; + rc = p->xBusyHandler(p->pBusyArg, p->nBusy); + if( rc==0 ){ + p->nBusy = -1; + }else{ + p->nBusy++; + } + return rc; +} + +/* +** This routine sets the busy callback for an Sqlite database to the +** given callback function with the given argument. +*/ +SQLITE_API int sqlite3_busy_handler( + sqlite3 *db, + int (*xBusy)(void*,int), + void *pArg +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + db->busyHandler.xBusyHandler = xBusy; + db->busyHandler.pBusyArg = pArg; + db->busyHandler.nBusy = 0; + db->busyTimeout = 0; + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK +/* +** This routine sets the progress callback for an Sqlite database to the +** given callback function with the given argument. The progress callback will +** be invoked every nOps opcodes. +*/ +SQLITE_API void sqlite3_progress_handler( + sqlite3 *db, + int nOps, + int (*xProgress)(void*), + void *pArg +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return; + } +#endif + sqlite3_mutex_enter(db->mutex); + if( nOps>0 ){ + db->xProgress = xProgress; + db->nProgressOps = (unsigned)nOps; + db->pProgressArg = pArg; + }else{ + db->xProgress = 0; + db->nProgressOps = 0; + db->pProgressArg = 0; + } + sqlite3_mutex_leave(db->mutex); +} +#endif + + +/* +** This routine installs a default busy handler that waits for the +** specified number of milliseconds before returning 0. +*/ +SQLITE_API int sqlite3_busy_timeout(sqlite3 *db, int ms){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + if( ms>0 ){ + sqlite3_busy_handler(db, (int(*)(void*,int))sqliteDefaultBusyCallback, + (void*)db); + db->busyTimeout = ms; + }else{ + sqlite3_busy_handler(db, 0, 0); + } + return SQLITE_OK; +} + +/* +** Cause any pending operation to stop at its earliest opportunity. +*/ +SQLITE_API void sqlite3_interrupt(sqlite3 *db){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) + && (db==0 || db->eOpenState!=SQLITE_STATE_ZOMBIE) + ){ + (void)SQLITE_MISUSE_BKPT; + return; + } +#endif + AtomicStore(&db->u1.isInterrupted, 1); +} + +/* +** Return true or false depending on whether or not an interrupt is +** pending on connection db. +*/ +SQLITE_API int sqlite3_is_interrupted(sqlite3 *db){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) + && (db==0 || db->eOpenState!=SQLITE_STATE_ZOMBIE) + ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + return AtomicLoad(&db->u1.isInterrupted)!=0; +} + +/* +** This function is exactly the same as sqlite3_create_function(), except +** that it is designed to be called by internal code. The difference is +** that if a malloc() fails in sqlite3_create_function(), an error code +** is returned and the mallocFailed flag cleared. +*/ +SQLITE_PRIVATE int sqlite3CreateFunc( + sqlite3 *db, + const char *zFunctionName, + int nArg, + int enc, + void *pUserData, + void (*xSFunc)(sqlite3_context*,int,sqlite3_value **), + void (*xStep)(sqlite3_context*,int,sqlite3_value **), + void (*xFinal)(sqlite3_context*), + void (*xValue)(sqlite3_context*), + void (*xInverse)(sqlite3_context*,int,sqlite3_value **), + FuncDestructor *pDestructor +){ + FuncDef *p; + int extraFlags; + + assert( sqlite3_mutex_held(db->mutex) ); + assert( xValue==0 || xSFunc==0 ); + if( zFunctionName==0 /* Must have a valid name */ + || (xSFunc!=0 && xFinal!=0) /* Not both xSFunc and xFinal */ + || ((xFinal==0)!=(xStep==0)) /* Both or neither of xFinal and xStep */ + || ((xValue==0)!=(xInverse==0)) /* Both or neither of xValue, xInverse */ + || (nArg<-1 || nArg>SQLITE_MAX_FUNCTION_ARG) + || (255funcFlags & SQLITE_FUNC_ENCMASK)==(u32)enc && p->nArg==nArg ){ + if( db->nVdbeActive ){ + sqlite3ErrorWithMsg(db, SQLITE_BUSY, + "unable to delete/modify user-function due to active statements"); + assert( !db->mallocFailed ); + return SQLITE_BUSY; + }else{ + sqlite3ExpirePreparedStatements(db, 0); + } + }else if( xSFunc==0 && xFinal==0 ){ + /* Trying to delete a function that does not exist. This is a no-op. + ** https://sqlite.org/forum/forumpost/726219164b */ + return SQLITE_OK; + } + + p = sqlite3FindFunction(db, zFunctionName, nArg, (u8)enc, 1); + assert(p || db->mallocFailed); + if( !p ){ + return SQLITE_NOMEM_BKPT; + } + + /* If an older version of the function with a configured destructor is + ** being replaced invoke the destructor function here. */ + functionDestroy(db, p); + + if( pDestructor ){ + pDestructor->nRef++; + } + p->u.pDestructor = pDestructor; + p->funcFlags = (p->funcFlags & SQLITE_FUNC_ENCMASK) | extraFlags; + testcase( p->funcFlags & SQLITE_DETERMINISTIC ); + testcase( p->funcFlags & SQLITE_DIRECTONLY ); + p->xSFunc = xSFunc ? xSFunc : xStep; + p->xFinalize = xFinal; + p->xValue = xValue; + p->xInverse = xInverse; + p->pUserData = pUserData; + p->nArg = (u16)nArg; + return SQLITE_OK; +} + +/* +** Worker function used by utf-8 APIs that create new functions: +** +** sqlite3_create_function() +** sqlite3_create_function_v2() +** sqlite3_create_window_function() +*/ +static int createFunctionApi( + sqlite3 *db, + const char *zFunc, + int nArg, + int enc, + void *p, + void (*xSFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*), + void (*xValue)(sqlite3_context*), + void (*xInverse)(sqlite3_context*,int,sqlite3_value**), + void(*xDestroy)(void*) +){ + int rc = SQLITE_ERROR; + FuncDestructor *pArg = 0; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + return SQLITE_MISUSE_BKPT; + } +#endif + sqlite3_mutex_enter(db->mutex); + if( xDestroy ){ + pArg = (FuncDestructor *)sqlite3Malloc(sizeof(FuncDestructor)); + if( !pArg ){ + sqlite3OomFault(db); + xDestroy(p); + goto out; + } + pArg->nRef = 0; + pArg->xDestroy = xDestroy; + pArg->pUserData = p; + } + rc = sqlite3CreateFunc(db, zFunc, nArg, enc, p, + xSFunc, xStep, xFinal, xValue, xInverse, pArg + ); + if( pArg && pArg->nRef==0 ){ + assert( rc!=SQLITE_OK || (xStep==0 && xFinal==0) ); + xDestroy(p); + sqlite3_free(pArg); + } + + out: + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Create new user functions. +*/ +SQLITE_API int sqlite3_create_function( + sqlite3 *db, + const char *zFunc, + int nArg, + int enc, + void *p, + void (*xSFunc)(sqlite3_context*,int,sqlite3_value **), + void (*xStep)(sqlite3_context*,int,sqlite3_value **), + void (*xFinal)(sqlite3_context*) +){ + return createFunctionApi(db, zFunc, nArg, enc, p, xSFunc, xStep, + xFinal, 0, 0, 0); +} +SQLITE_API int sqlite3_create_function_v2( + sqlite3 *db, + const char *zFunc, + int nArg, + int enc, + void *p, + void (*xSFunc)(sqlite3_context*,int,sqlite3_value **), + void (*xStep)(sqlite3_context*,int,sqlite3_value **), + void (*xFinal)(sqlite3_context*), + void (*xDestroy)(void *) +){ + return createFunctionApi(db, zFunc, nArg, enc, p, xSFunc, xStep, + xFinal, 0, 0, xDestroy); +} +SQLITE_API int sqlite3_create_window_function( + sqlite3 *db, + const char *zFunc, + int nArg, + int enc, + void *p, + void (*xStep)(sqlite3_context*,int,sqlite3_value **), + void (*xFinal)(sqlite3_context*), + void (*xValue)(sqlite3_context*), + void (*xInverse)(sqlite3_context*,int,sqlite3_value **), + void (*xDestroy)(void *) +){ + return createFunctionApi(db, zFunc, nArg, enc, p, 0, xStep, + xFinal, xValue, xInverse, xDestroy); +} + +#ifndef SQLITE_OMIT_UTF16 +SQLITE_API int sqlite3_create_function16( + sqlite3 *db, + const void *zFunctionName, + int nArg, + int eTextRep, + void *p, + void (*xSFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +){ + int rc; + char *zFunc8; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zFunctionName==0 ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + assert( !db->mallocFailed ); + zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1, SQLITE_UTF16NATIVE); + rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xSFunc,xStep,xFinal,0,0,0); + sqlite3DbFree(db, zFunc8); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} +#endif + + +/* +** The following is the implementation of an SQL function that always +** fails with an error message stating that the function is used in the +** wrong context. The sqlite3_overload_function() API might construct +** SQL function that use this routine so that the functions will exist +** for name resolution but are actually overloaded by the xFindFunction +** method of virtual tables. +*/ +static void sqlite3InvalidFunction( + sqlite3_context *context, /* The function calling context */ + int NotUsed, /* Number of arguments to the function */ + sqlite3_value **NotUsed2 /* Value of each argument */ +){ + const char *zName = (const char*)sqlite3_user_data(context); + char *zErr; + UNUSED_PARAMETER2(NotUsed, NotUsed2); + zErr = sqlite3_mprintf( + "unable to use function %s in the requested context", zName); + sqlite3_result_error(context, zErr, -1); + sqlite3_free(zErr); +} + +/* +** Declare that a function has been overloaded by a virtual table. +** +** If the function already exists as a regular global function, then +** this routine is a no-op. If the function does not exist, then create +** a new one that always throws a run-time error. +** +** When virtual tables intend to provide an overloaded function, they +** should call this routine to make sure the global function exists. +** A global function must exist in order for name resolution to work +** properly. +*/ +SQLITE_API int sqlite3_overload_function( + sqlite3 *db, + const char *zName, + int nArg +){ + int rc; + char *zCopy; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zName==0 || nArg<-2 ){ + return SQLITE_MISUSE_BKPT; + } +#endif + sqlite3_mutex_enter(db->mutex); + rc = sqlite3FindFunction(db, zName, nArg, SQLITE_UTF8, 0)!=0; + sqlite3_mutex_leave(db->mutex); + if( rc ) return SQLITE_OK; + zCopy = sqlite3_mprintf("%s", zName); + if( zCopy==0 ) return SQLITE_NOMEM; + return sqlite3_create_function_v2(db, zName, nArg, SQLITE_UTF8, + zCopy, sqlite3InvalidFunction, 0, 0, sqlite3_free); +} + +#ifndef SQLITE_OMIT_TRACE +/* +** Register a trace function. The pArg from the previously registered trace +** is returned. +** +** A NULL trace function means that no tracing is executes. A non-NULL +** trace is a pointer to a function that is invoked at the start of each +** SQL statement. +*/ +#ifndef SQLITE_OMIT_DEPRECATED +SQLITE_API void *sqlite3_trace(sqlite3 *db, void(*xTrace)(void*,const char*), void *pArg){ + void *pOld; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + sqlite3_mutex_enter(db->mutex); + pOld = db->pTraceArg; + db->mTrace = xTrace ? SQLITE_TRACE_LEGACY : 0; + db->trace.xLegacy = xTrace; + db->pTraceArg = pArg; + sqlite3_mutex_leave(db->mutex); + return pOld; +} +#endif /* SQLITE_OMIT_DEPRECATED */ + +/* Register a trace callback using the version-2 interface. +*/ +SQLITE_API int sqlite3_trace_v2( + sqlite3 *db, /* Trace this connection */ + unsigned mTrace, /* Mask of events to be traced */ + int(*xTrace)(unsigned,void*,void*,void*), /* Callback to invoke */ + void *pArg /* Context */ +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + return SQLITE_MISUSE_BKPT; + } +#endif + sqlite3_mutex_enter(db->mutex); + if( mTrace==0 ) xTrace = 0; + if( xTrace==0 ) mTrace = 0; + db->mTrace = mTrace; + db->trace.xV2 = xTrace; + db->pTraceArg = pArg; + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +#ifndef SQLITE_OMIT_DEPRECATED +/* +** Register a profile function. The pArg from the previously registered +** profile function is returned. +** +** A NULL profile function means that no profiling is executes. A non-NULL +** profile is a pointer to a function that is invoked at the conclusion of +** each SQL statement that is run. +*/ +SQLITE_API void *sqlite3_profile( + sqlite3 *db, + void (*xProfile)(void*,const char*,sqlite_uint64), + void *pArg +){ + void *pOld; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + sqlite3_mutex_enter(db->mutex); + pOld = db->pProfileArg; + db->xProfile = xProfile; + db->pProfileArg = pArg; + db->mTrace &= SQLITE_TRACE_NONLEGACY_MASK; + if( db->xProfile ) db->mTrace |= SQLITE_TRACE_XPROFILE; + sqlite3_mutex_leave(db->mutex); + return pOld; +} +#endif /* SQLITE_OMIT_DEPRECATED */ +#endif /* SQLITE_OMIT_TRACE */ + +/* +** Register a function to be invoked when a transaction commits. +** If the invoked function returns non-zero, then the commit becomes a +** rollback. +*/ +SQLITE_API void *sqlite3_commit_hook( + sqlite3 *db, /* Attach the hook to this database */ + int (*xCallback)(void*), /* Function to invoke on each commit */ + void *pArg /* Argument to the function */ +){ + void *pOld; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + sqlite3_mutex_enter(db->mutex); + pOld = db->pCommitArg; + db->xCommitCallback = xCallback; + db->pCommitArg = pArg; + sqlite3_mutex_leave(db->mutex); + return pOld; +} + +/* +** Register a callback to be invoked each time a row is updated, +** inserted or deleted using this database connection. +*/ +SQLITE_API void *sqlite3_update_hook( + sqlite3 *db, /* Attach the hook to this database */ + void (*xCallback)(void*,int,char const *,char const *,sqlite_int64), + void *pArg /* Argument to the function */ +){ + void *pRet; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + sqlite3_mutex_enter(db->mutex); + pRet = db->pUpdateArg; + db->xUpdateCallback = xCallback; + db->pUpdateArg = pArg; + sqlite3_mutex_leave(db->mutex); + return pRet; +} + +/* +** Register a callback to be invoked each time a transaction is rolled +** back by this database connection. +*/ +SQLITE_API void *sqlite3_rollback_hook( + sqlite3 *db, /* Attach the hook to this database */ + void (*xCallback)(void*), /* Callback function */ + void *pArg /* Argument to the function */ +){ + void *pRet; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + sqlite3_mutex_enter(db->mutex); + pRet = db->pRollbackArg; + db->xRollbackCallback = xCallback; + db->pRollbackArg = pArg; + sqlite3_mutex_leave(db->mutex); + return pRet; +} + +#ifdef SQLITE_ENABLE_PREUPDATE_HOOK +/* +** Register a callback to be invoked each time a row is updated, +** inserted or deleted using this database connection. +*/ +SQLITE_API void *sqlite3_preupdate_hook( + sqlite3 *db, /* Attach the hook to this database */ + void(*xCallback)( /* Callback function */ + void*,sqlite3*,int,char const*,char const*,sqlite3_int64,sqlite3_int64), + void *pArg /* First callback argument */ +){ + void *pRet; + sqlite3_mutex_enter(db->mutex); + pRet = db->pPreUpdateArg; + db->xPreUpdateCallback = xCallback; + db->pPreUpdateArg = pArg; + sqlite3_mutex_leave(db->mutex); + return pRet; +} +#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ + +/* +** Register a function to be invoked prior to each autovacuum that +** determines the number of pages to vacuum. +*/ +SQLITE_API int sqlite3_autovacuum_pages( + sqlite3 *db, /* Attach the hook to this database */ + unsigned int (*xCallback)(void*,const char*,u32,u32,u32), + void *pArg, /* Argument to the function */ + void (*xDestructor)(void*) /* Destructor for pArg */ +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + if( xDestructor ) xDestructor(pArg); + return SQLITE_MISUSE_BKPT; + } +#endif + sqlite3_mutex_enter(db->mutex); + if( db->xAutovacDestr ){ + db->xAutovacDestr(db->pAutovacPagesArg); + } + db->xAutovacPages = xCallback; + db->pAutovacPagesArg = pArg; + db->xAutovacDestr = xDestructor; + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + + +#ifndef SQLITE_OMIT_WAL +/* +** The sqlite3_wal_hook() callback registered by sqlite3_wal_autocheckpoint(). +** Invoke sqlite3_wal_checkpoint if the number of frames in the log file +** is greater than sqlite3.pWalArg cast to an integer (the value configured by +** wal_autocheckpoint()). +*/ +SQLITE_PRIVATE int sqlite3WalDefaultHook( + void *pClientData, /* Argument */ + sqlite3 *db, /* Connection */ + const char *zDb, /* Database */ + int nFrame /* Size of WAL */ +){ + if( nFrame>=SQLITE_PTR_TO_INT(pClientData) ){ + sqlite3BeginBenignMalloc(); + sqlite3_wal_checkpoint(db, zDb); + sqlite3EndBenignMalloc(); + } + return SQLITE_OK; +} +#endif /* SQLITE_OMIT_WAL */ + +/* +** Configure an sqlite3_wal_hook() callback to automatically checkpoint +** a database after committing a transaction if there are nFrame or +** more frames in the log file. Passing zero or a negative value as the +** nFrame parameter disables automatic checkpoints entirely. +** +** The callback registered by this function replaces any existing callback +** registered using sqlite3_wal_hook(). Likewise, registering a callback +** using sqlite3_wal_hook() disables the automatic checkpoint mechanism +** configured by this function. +*/ +SQLITE_API int sqlite3_wal_autocheckpoint(sqlite3 *db, int nFrame){ +#ifdef SQLITE_OMIT_WAL + UNUSED_PARAMETER(db); + UNUSED_PARAMETER(nFrame); +#else +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + if( nFrame>0 ){ + sqlite3_wal_hook(db, sqlite3WalDefaultHook, SQLITE_INT_TO_PTR(nFrame)); + }else{ + sqlite3_wal_hook(db, 0, 0); + } +#endif + return SQLITE_OK; +} + +/* +** Register a callback to be invoked each time a transaction is written +** into the write-ahead-log by this database connection. +*/ +SQLITE_API void *sqlite3_wal_hook( + sqlite3 *db, /* Attach the hook to this db handle */ + int(*xCallback)(void *, sqlite3*, const char*, int), + void *pArg /* First argument passed to xCallback() */ +){ +#ifndef SQLITE_OMIT_WAL + void *pRet; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + sqlite3_mutex_enter(db->mutex); + pRet = db->pWalArg; + db->xWalCallback = xCallback; + db->pWalArg = pArg; + sqlite3_mutex_leave(db->mutex); + return pRet; +#else + return 0; +#endif +} + +/* +** Checkpoint database zDb. +*/ +SQLITE_API int sqlite3_wal_checkpoint_v2( + sqlite3 *db, /* Database handle */ + const char *zDb, /* Name of attached database (or NULL) */ + int eMode, /* SQLITE_CHECKPOINT_* value */ + int *pnLog, /* OUT: Size of WAL log in frames */ + int *pnCkpt /* OUT: Total number of frames checkpointed */ +){ +#ifdef SQLITE_OMIT_WAL + return SQLITE_OK; +#else + int rc; /* Return code */ + int iDb; /* Schema to checkpoint */ + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + + /* Initialize the output variables to -1 in case an error occurs. */ + if( pnLog ) *pnLog = -1; + if( pnCkpt ) *pnCkpt = -1; + + assert( SQLITE_CHECKPOINT_PASSIVE==0 ); + assert( SQLITE_CHECKPOINT_FULL==1 ); + assert( SQLITE_CHECKPOINT_RESTART==2 ); + assert( SQLITE_CHECKPOINT_TRUNCATE==3 ); + if( eModeSQLITE_CHECKPOINT_TRUNCATE ){ + /* EVIDENCE-OF: R-03996-12088 The M parameter must be a valid checkpoint + ** mode: */ + return SQLITE_MISUSE; + } + + sqlite3_mutex_enter(db->mutex); + if( zDb && zDb[0] ){ + iDb = sqlite3FindDbName(db, zDb); + }else{ + iDb = SQLITE_MAX_DB; /* This means process all schemas */ + } + if( iDb<0 ){ + rc = SQLITE_ERROR; + sqlite3ErrorWithMsg(db, SQLITE_ERROR, "unknown database: %s", zDb); + }else{ + db->busyHandler.nBusy = 0; + rc = sqlite3Checkpoint(db, iDb, eMode, pnLog, pnCkpt); + sqlite3Error(db, rc); + } + rc = sqlite3ApiExit(db, rc); + + /* If there are no active statements, clear the interrupt flag at this + ** point. */ + if( db->nVdbeActive==0 ){ + AtomicStore(&db->u1.isInterrupted, 0); + } + + sqlite3_mutex_leave(db->mutex); + return rc; +#endif +} + + +/* +** Checkpoint database zDb. If zDb is NULL, or if the buffer zDb points +** to contains a zero-length string, all attached databases are +** checkpointed. +*/ +SQLITE_API int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb){ + /* EVIDENCE-OF: R-41613-20553 The sqlite3_wal_checkpoint(D,X) is equivalent to + ** sqlite3_wal_checkpoint_v2(D,X,SQLITE_CHECKPOINT_PASSIVE,0,0). */ + return sqlite3_wal_checkpoint_v2(db,zDb,SQLITE_CHECKPOINT_PASSIVE,0,0); +} + +#ifndef SQLITE_OMIT_WAL +/* +** Run a checkpoint on database iDb. This is a no-op if database iDb is +** not currently open in WAL mode. +** +** If a transaction is open on the database being checkpointed, this +** function returns SQLITE_LOCKED and a checkpoint is not attempted. If +** an error occurs while running the checkpoint, an SQLite error code is +** returned (i.e. SQLITE_IOERR). Otherwise, SQLITE_OK. +** +** The mutex on database handle db should be held by the caller. The mutex +** associated with the specific b-tree being checkpointed is taken by +** this function while the checkpoint is running. +** +** If iDb is passed SQLITE_MAX_DB then all attached databases are +** checkpointed. If an error is encountered it is returned immediately - +** no attempt is made to checkpoint any remaining databases. +** +** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL, RESTART +** or TRUNCATE. +*/ +SQLITE_PRIVATE int sqlite3Checkpoint(sqlite3 *db, int iDb, int eMode, int *pnLog, int *pnCkpt){ + int rc = SQLITE_OK; /* Return code */ + int i; /* Used to iterate through attached dbs */ + int bBusy = 0; /* True if SQLITE_BUSY has been encountered */ + + assert( sqlite3_mutex_held(db->mutex) ); + assert( !pnLog || *pnLog==-1 ); + assert( !pnCkpt || *pnCkpt==-1 ); + testcase( iDb==SQLITE_MAX_ATTACHED ); /* See forum post a006d86f72 */ + testcase( iDb==SQLITE_MAX_DB ); + + for(i=0; inDb && rc==SQLITE_OK; i++){ + if( i==iDb || iDb==SQLITE_MAX_DB ){ + rc = sqlite3BtreeCheckpoint(db->aDb[i].pBt, eMode, pnLog, pnCkpt); + pnLog = 0; + pnCkpt = 0; + if( rc==SQLITE_BUSY ){ + bBusy = 1; + rc = SQLITE_OK; + } + } + } + + return (rc==SQLITE_OK && bBusy) ? SQLITE_BUSY : rc; +} +#endif /* SQLITE_OMIT_WAL */ + +/* +** This function returns true if main-memory should be used instead of +** a temporary file for transient pager files and statement journals. +** The value returned depends on the value of db->temp_store (runtime +** parameter) and the compile time value of SQLITE_TEMP_STORE. The +** following table describes the relationship between these two values +** and this functions return value. +** +** SQLITE_TEMP_STORE db->temp_store Location of temporary database +** ----------------- -------------- ------------------------------ +** 0 any file (return 0) +** 1 1 file (return 0) +** 1 2 memory (return 1) +** 1 0 file (return 0) +** 2 1 file (return 0) +** 2 2 memory (return 1) +** 2 0 memory (return 1) +** 3 any memory (return 1) +*/ +SQLITE_PRIVATE int sqlite3TempInMemory(const sqlite3 *db){ +#if SQLITE_TEMP_STORE==1 + return ( db->temp_store==2 ); +#endif +#if SQLITE_TEMP_STORE==2 + return ( db->temp_store!=1 ); +#endif +#if SQLITE_TEMP_STORE==3 + UNUSED_PARAMETER(db); + return 1; +#endif +#if SQLITE_TEMP_STORE<1 || SQLITE_TEMP_STORE>3 + UNUSED_PARAMETER(db); + return 0; +#endif +} + +/* +** Return UTF-8 encoded English language explanation of the most recent +** error. +*/ +SQLITE_API const char *sqlite3_errmsg(sqlite3 *db){ + const char *z; + if( !db ){ + return sqlite3ErrStr(SQLITE_NOMEM_BKPT); + } + if( !sqlite3SafetyCheckSickOrOk(db) ){ + return sqlite3ErrStr(SQLITE_MISUSE_BKPT); + } + sqlite3_mutex_enter(db->mutex); + if( db->mallocFailed ){ + z = sqlite3ErrStr(SQLITE_NOMEM_BKPT); + }else{ + testcase( db->pErr==0 ); + z = db->errCode ? (char*)sqlite3_value_text(db->pErr) : 0; + assert( !db->mallocFailed ); + if( z==0 ){ + z = sqlite3ErrStr(db->errCode); + } + } + sqlite3_mutex_leave(db->mutex); + return z; +} + +/* +** Return the byte offset of the most recent error +*/ +SQLITE_API int sqlite3_error_offset(sqlite3 *db){ + int iOffset = -1; + if( db && sqlite3SafetyCheckSickOrOk(db) && db->errCode ){ + sqlite3_mutex_enter(db->mutex); + iOffset = db->errByteOffset; + sqlite3_mutex_leave(db->mutex); + } + return iOffset; +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** Return UTF-16 encoded English language explanation of the most recent +** error. +*/ +SQLITE_API const void *sqlite3_errmsg16(sqlite3 *db){ + static const u16 outOfMem[] = { + 'o', 'u', 't', ' ', 'o', 'f', ' ', 'm', 'e', 'm', 'o', 'r', 'y', 0 + }; + static const u16 misuse[] = { + 'b', 'a', 'd', ' ', 'p', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', ' ', + 'o', 'r', ' ', 'o', 't', 'h', 'e', 'r', ' ', 'A', 'P', 'I', ' ', + 'm', 'i', 's', 'u', 's', 'e', 0 + }; + + const void *z; + if( !db ){ + return (void *)outOfMem; + } + if( !sqlite3SafetyCheckSickOrOk(db) ){ + return (void *)misuse; + } + sqlite3_mutex_enter(db->mutex); + if( db->mallocFailed ){ + z = (void *)outOfMem; + }else{ + z = sqlite3_value_text16(db->pErr); + if( z==0 ){ + sqlite3ErrorWithMsg(db, db->errCode, sqlite3ErrStr(db->errCode)); + z = sqlite3_value_text16(db->pErr); + } + /* A malloc() may have failed within the call to sqlite3_value_text16() + ** above. If this is the case, then the db->mallocFailed flag needs to + ** be cleared before returning. Do this directly, instead of via + ** sqlite3ApiExit(), to avoid setting the database handle error message. + */ + sqlite3OomClear(db); + } + sqlite3_mutex_leave(db->mutex); + return z; +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** Return the most recent error code generated by an SQLite routine. If NULL is +** passed to this function, we assume a malloc() failed during sqlite3_open(). +*/ +SQLITE_API int sqlite3_errcode(sqlite3 *db){ + if( db && !sqlite3SafetyCheckSickOrOk(db) ){ + return SQLITE_MISUSE_BKPT; + } + if( !db || db->mallocFailed ){ + return SQLITE_NOMEM_BKPT; + } + return db->errCode & db->errMask; +} +SQLITE_API int sqlite3_extended_errcode(sqlite3 *db){ + if( db && !sqlite3SafetyCheckSickOrOk(db) ){ + return SQLITE_MISUSE_BKPT; + } + if( !db || db->mallocFailed ){ + return SQLITE_NOMEM_BKPT; + } + return db->errCode; +} +SQLITE_API int sqlite3_system_errno(sqlite3 *db){ + return db ? db->iSysErrno : 0; +} + +/* +** Return a string that describes the kind of error specified in the +** argument. For now, this simply calls the internal sqlite3ErrStr() +** function. +*/ +SQLITE_API const char *sqlite3_errstr(int rc){ + return sqlite3ErrStr(rc); +} + +/* +** Create a new collating function for database "db". The name is zName +** and the encoding is enc. +*/ +static int createCollation( + sqlite3* db, + const char *zName, + u8 enc, + void* pCtx, + int(*xCompare)(void*,int,const void*,int,const void*), + void(*xDel)(void*) +){ + CollSeq *pColl; + int enc2; + + assert( sqlite3_mutex_held(db->mutex) ); + + /* If SQLITE_UTF16 is specified as the encoding type, transform this + ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the + ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally. + */ + enc2 = enc; + testcase( enc2==SQLITE_UTF16 ); + testcase( enc2==SQLITE_UTF16_ALIGNED ); + if( enc2==SQLITE_UTF16 || enc2==SQLITE_UTF16_ALIGNED ){ + enc2 = SQLITE_UTF16NATIVE; + } + if( enc2SQLITE_UTF16BE ){ + return SQLITE_MISUSE_BKPT; + } + + /* Check if this call is removing or replacing an existing collation + ** sequence. If so, and there are active VMs, return busy. If there + ** are no active VMs, invalidate any pre-compiled statements. + */ + pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 0); + if( pColl && pColl->xCmp ){ + if( db->nVdbeActive ){ + sqlite3ErrorWithMsg(db, SQLITE_BUSY, + "unable to delete/modify collation sequence due to active statements"); + return SQLITE_BUSY; + } + sqlite3ExpirePreparedStatements(db, 0); + + /* If collation sequence pColl was created directly by a call to + ** sqlite3_create_collation, and not generated by synthCollSeq(), + ** then any copies made by synthCollSeq() need to be invalidated. + ** Also, collation destructor - CollSeq.xDel() - function may need + ** to be called. + */ + if( (pColl->enc & ~SQLITE_UTF16_ALIGNED)==enc2 ){ + CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName); + int j; + for(j=0; j<3; j++){ + CollSeq *p = &aColl[j]; + if( p->enc==pColl->enc ){ + if( p->xDel ){ + p->xDel(p->pUser); + } + p->xCmp = 0; + } + } + } + } + + pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 1); + if( pColl==0 ) return SQLITE_NOMEM_BKPT; + pColl->xCmp = xCompare; + pColl->pUser = pCtx; + pColl->xDel = xDel; + pColl->enc = (u8)(enc2 | (enc & SQLITE_UTF16_ALIGNED)); + sqlite3Error(db, SQLITE_OK); + return SQLITE_OK; +} + + +/* +** This array defines hard upper bounds on limit values. The +** initializer must be kept in sync with the SQLITE_LIMIT_* +** #defines in sqlite3.h. +*/ +static const int aHardLimit[] = { + SQLITE_MAX_LENGTH, + SQLITE_MAX_SQL_LENGTH, + SQLITE_MAX_COLUMN, + SQLITE_MAX_EXPR_DEPTH, + SQLITE_MAX_COMPOUND_SELECT, + SQLITE_MAX_VDBE_OP, + SQLITE_MAX_FUNCTION_ARG, + SQLITE_MAX_ATTACHED, + SQLITE_MAX_LIKE_PATTERN_LENGTH, + SQLITE_MAX_VARIABLE_NUMBER, /* IMP: R-38091-32352 */ + SQLITE_MAX_TRIGGER_DEPTH, + SQLITE_MAX_WORKER_THREADS, +}; + +/* +** Make sure the hard limits are set to reasonable values +*/ +#if SQLITE_MAX_LENGTH<100 +# error SQLITE_MAX_LENGTH must be at least 100 +#endif +#if SQLITE_MAX_SQL_LENGTH<100 +# error SQLITE_MAX_SQL_LENGTH must be at least 100 +#endif +#if SQLITE_MAX_SQL_LENGTH>SQLITE_MAX_LENGTH +# error SQLITE_MAX_SQL_LENGTH must not be greater than SQLITE_MAX_LENGTH +#endif +#if SQLITE_MAX_COMPOUND_SELECT<2 +# error SQLITE_MAX_COMPOUND_SELECT must be at least 2 +#endif +#if SQLITE_MAX_VDBE_OP<40 +# error SQLITE_MAX_VDBE_OP must be at least 40 +#endif +#if SQLITE_MAX_FUNCTION_ARG<0 || SQLITE_MAX_FUNCTION_ARG>127 +# error SQLITE_MAX_FUNCTION_ARG must be between 0 and 127 +#endif +#if SQLITE_MAX_ATTACHED<0 || SQLITE_MAX_ATTACHED>125 +# error SQLITE_MAX_ATTACHED must be between 0 and 125 +#endif +#if SQLITE_MAX_LIKE_PATTERN_LENGTH<1 +# error SQLITE_MAX_LIKE_PATTERN_LENGTH must be at least 1 +#endif +#if SQLITE_MAX_COLUMN>32767 +# error SQLITE_MAX_COLUMN must not exceed 32767 +#endif +#if SQLITE_MAX_TRIGGER_DEPTH<1 +# error SQLITE_MAX_TRIGGER_DEPTH must be at least 1 +#endif +#if SQLITE_MAX_WORKER_THREADS<0 || SQLITE_MAX_WORKER_THREADS>50 +# error SQLITE_MAX_WORKER_THREADS must be between 0 and 50 +#endif + + +/* +** Change the value of a limit. Report the old value. +** If an invalid limit index is supplied, report -1. +** Make no changes but still report the old value if the +** new limit is negative. +** +** A new lower limit does not shrink existing constructs. +** It merely prevents new constructs that exceed the limit +** from forming. +*/ +SQLITE_API int sqlite3_limit(sqlite3 *db, int limitId, int newLimit){ + int oldLimit; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return -1; + } +#endif + + /* EVIDENCE-OF: R-30189-54097 For each limit category SQLITE_LIMIT_NAME + ** there is a hard upper bound set at compile-time by a C preprocessor + ** macro called SQLITE_MAX_NAME. (The "_LIMIT_" in the name is changed to + ** "_MAX_".) + */ + assert( aHardLimit[SQLITE_LIMIT_LENGTH]==SQLITE_MAX_LENGTH ); + assert( aHardLimit[SQLITE_LIMIT_SQL_LENGTH]==SQLITE_MAX_SQL_LENGTH ); + assert( aHardLimit[SQLITE_LIMIT_COLUMN]==SQLITE_MAX_COLUMN ); + assert( aHardLimit[SQLITE_LIMIT_EXPR_DEPTH]==SQLITE_MAX_EXPR_DEPTH ); + assert( aHardLimit[SQLITE_LIMIT_COMPOUND_SELECT]==SQLITE_MAX_COMPOUND_SELECT); + assert( aHardLimit[SQLITE_LIMIT_VDBE_OP]==SQLITE_MAX_VDBE_OP ); + assert( aHardLimit[SQLITE_LIMIT_FUNCTION_ARG]==SQLITE_MAX_FUNCTION_ARG ); + assert( aHardLimit[SQLITE_LIMIT_ATTACHED]==SQLITE_MAX_ATTACHED ); + assert( aHardLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]== + SQLITE_MAX_LIKE_PATTERN_LENGTH ); + assert( aHardLimit[SQLITE_LIMIT_VARIABLE_NUMBER]==SQLITE_MAX_VARIABLE_NUMBER); + assert( aHardLimit[SQLITE_LIMIT_TRIGGER_DEPTH]==SQLITE_MAX_TRIGGER_DEPTH ); + assert( aHardLimit[SQLITE_LIMIT_WORKER_THREADS]==SQLITE_MAX_WORKER_THREADS ); + assert( SQLITE_LIMIT_WORKER_THREADS==(SQLITE_N_LIMIT-1) ); + + + if( limitId<0 || limitId>=SQLITE_N_LIMIT ){ + return -1; + } + oldLimit = db->aLimit[limitId]; + if( newLimit>=0 ){ /* IMP: R-52476-28732 */ + if( newLimit>aHardLimit[limitId] ){ + newLimit = aHardLimit[limitId]; /* IMP: R-51463-25634 */ + }else if( newLimit<1 && limitId==SQLITE_LIMIT_LENGTH ){ + newLimit = 1; + } + db->aLimit[limitId] = newLimit; + } + return oldLimit; /* IMP: R-53341-35419 */ +} + +/* +** This function is used to parse both URIs and non-URI filenames passed by the +** user to API functions sqlite3_open() or sqlite3_open_v2(), and for database +** URIs specified as part of ATTACH statements. +** +** The first argument to this function is the name of the VFS to use (or +** a NULL to signify the default VFS) if the URI does not contain a "vfs=xxx" +** query parameter. The second argument contains the URI (or non-URI filename) +** itself. When this function is called the *pFlags variable should contain +** the default flags to open the database handle with. The value stored in +** *pFlags may be updated before returning if the URI filename contains +** "cache=xxx" or "mode=xxx" query parameters. +** +** If successful, SQLITE_OK is returned. In this case *ppVfs is set to point to +** the VFS that should be used to open the database file. *pzFile is set to +** point to a buffer containing the name of the file to open. The value +** stored in *pzFile is a database name acceptable to sqlite3_uri_parameter() +** and is in the same format as names created using sqlite3_create_filename(). +** The caller must invoke sqlite3_free_filename() (not sqlite3_free()!) on +** the value returned in *pzFile to avoid a memory leak. +** +** If an error occurs, then an SQLite error code is returned and *pzErrMsg +** may be set to point to a buffer containing an English language error +** message. It is the responsibility of the caller to eventually release +** this buffer by calling sqlite3_free(). +*/ +SQLITE_PRIVATE int sqlite3ParseUri( + const char *zDefaultVfs, /* VFS to use if no "vfs=xxx" query option */ + const char *zUri, /* Nul-terminated URI to parse */ + unsigned int *pFlags, /* IN/OUT: SQLITE_OPEN_XXX flags */ + sqlite3_vfs **ppVfs, /* OUT: VFS to use */ + char **pzFile, /* OUT: Filename component of URI */ + char **pzErrMsg /* OUT: Error message (if rc!=SQLITE_OK) */ +){ + int rc = SQLITE_OK; + unsigned int flags = *pFlags; + const char *zVfs = zDefaultVfs; + char *zFile; + char c; + int nUri = sqlite3Strlen30(zUri); + + assert( *pzErrMsg==0 ); + + if( ((flags & SQLITE_OPEN_URI) /* IMP: R-48725-32206 */ + || AtomicLoad(&sqlite3GlobalConfig.bOpenUri)) /* IMP: R-51689-46548 */ + && nUri>=5 && memcmp(zUri, "file:", 5)==0 /* IMP: R-57884-37496 */ + ){ + char *zOpt; + int eState; /* Parser state when parsing URI */ + int iIn; /* Input character index */ + int iOut = 0; /* Output character index */ + u64 nByte = nUri+8; /* Bytes of space to allocate */ + + /* Make sure the SQLITE_OPEN_URI flag is set to indicate to the VFS xOpen + ** method that there may be extra parameters following the file-name. */ + flags |= SQLITE_OPEN_URI; + + for(iIn=0; iIn=0 && octet<256 ); + if( octet==0 ){ +#ifndef SQLITE_ENABLE_URI_00_ERROR + /* This branch is taken when "%00" appears within the URI. In this + ** case we ignore all text in the remainder of the path, name or + ** value currently being parsed. So ignore the current character + ** and skip to the next "?", "=" or "&", as appropriate. */ + while( (c = zUri[iIn])!=0 && c!='#' + && (eState!=0 || c!='?') + && (eState!=1 || (c!='=' && c!='&')) + && (eState!=2 || c!='&') + ){ + iIn++; + } + continue; +#else + /* If ENABLE_URI_00_ERROR is defined, "%00" in a URI is an error. */ + *pzErrMsg = sqlite3_mprintf("unexpected %%00 in uri"); + rc = SQLITE_ERROR; + goto parse_uri_out; +#endif + } + c = octet; + }else if( eState==1 && (c=='&' || c=='=') ){ + if( zFile[iOut-1]==0 ){ + /* An empty option name. Ignore this option altogether. */ + while( zUri[iIn] && zUri[iIn]!='#' && zUri[iIn-1]!='&' ) iIn++; + continue; + } + if( c=='&' ){ + zFile[iOut++] = '\0'; + }else{ + eState = 2; + } + c = 0; + }else if( (eState==0 && c=='?') || (eState==2 && c=='&') ){ + c = 0; + eState = 1; + } + zFile[iOut++] = c; + } + if( eState==1 ) zFile[iOut++] = '\0'; + memset(zFile+iOut, 0, 4); /* end-of-options + empty journal filenames */ + + /* Check if there were any options specified that should be interpreted + ** here. Options that are interpreted here include "vfs" and those that + ** correspond to flags that may be passed to the sqlite3_open_v2() + ** method. */ + zOpt = &zFile[sqlite3Strlen30(zFile)+1]; + while( zOpt[0] ){ + int nOpt = sqlite3Strlen30(zOpt); + char *zVal = &zOpt[nOpt+1]; + int nVal = sqlite3Strlen30(zVal); + + if( nOpt==3 && memcmp("vfs", zOpt, 3)==0 ){ + zVfs = zVal; + }else{ + struct OpenMode { + const char *z; + int mode; + } *aMode = 0; + char *zModeType = 0; + int mask = 0; + int limit = 0; + + if( nOpt==5 && memcmp("cache", zOpt, 5)==0 ){ + static struct OpenMode aCacheMode[] = { + { "shared", SQLITE_OPEN_SHAREDCACHE }, + { "private", SQLITE_OPEN_PRIVATECACHE }, + { 0, 0 } + }; + + mask = SQLITE_OPEN_SHAREDCACHE|SQLITE_OPEN_PRIVATECACHE; + aMode = aCacheMode; + limit = mask; + zModeType = "cache"; + } + if( nOpt==4 && memcmp("mode", zOpt, 4)==0 ){ + static struct OpenMode aOpenMode[] = { + { "ro", SQLITE_OPEN_READONLY }, + { "rw", SQLITE_OPEN_READWRITE }, + { "rwc", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE }, + { "memory", SQLITE_OPEN_MEMORY }, + { 0, 0 } + }; + + mask = SQLITE_OPEN_READONLY | SQLITE_OPEN_READWRITE + | SQLITE_OPEN_CREATE | SQLITE_OPEN_MEMORY; + aMode = aOpenMode; + limit = mask & flags; + zModeType = "access"; + } + + if( aMode ){ + int i; + int mode = 0; + for(i=0; aMode[i].z; i++){ + const char *z = aMode[i].z; + if( nVal==sqlite3Strlen30(z) && 0==memcmp(zVal, z, nVal) ){ + mode = aMode[i].mode; + break; + } + } + if( mode==0 ){ + *pzErrMsg = sqlite3_mprintf("no such %s mode: %s", zModeType, zVal); + rc = SQLITE_ERROR; + goto parse_uri_out; + } + if( (mode & ~SQLITE_OPEN_MEMORY)>limit ){ + *pzErrMsg = sqlite3_mprintf("%s mode not allowed: %s", + zModeType, zVal); + rc = SQLITE_PERM; + goto parse_uri_out; + } + flags = (flags & ~mask) | mode; + } + } + + zOpt = &zVal[nVal+1]; + } + + }else{ + zFile = sqlite3_malloc64(nUri+8); + if( !zFile ) return SQLITE_NOMEM_BKPT; + memset(zFile, 0, 4); + zFile += 4; + if( nUri ){ + memcpy(zFile, zUri, nUri); + } + memset(zFile+nUri, 0, 4); + flags &= ~SQLITE_OPEN_URI; + } + + *ppVfs = sqlite3_vfs_find(zVfs); + if( *ppVfs==0 ){ + *pzErrMsg = sqlite3_mprintf("no such vfs: %s", zVfs); + rc = SQLITE_ERROR; + } + parse_uri_out: + if( rc!=SQLITE_OK ){ + sqlite3_free_filename(zFile); + zFile = 0; + } + *pFlags = flags; + *pzFile = zFile; + return rc; +} + +/* +** This routine does the core work of extracting URI parameters from a +** database filename for the sqlite3_uri_parameter() interface. +*/ +static const char *uriParameter(const char *zFilename, const char *zParam){ + zFilename += sqlite3Strlen30(zFilename) + 1; + while( ALWAYS(zFilename!=0) && zFilename[0] ){ + int x = strcmp(zFilename, zParam); + zFilename += sqlite3Strlen30(zFilename) + 1; + if( x==0 ) return zFilename; + zFilename += sqlite3Strlen30(zFilename) + 1; + } + return 0; +} + +/* BEGIN SQLCIPHER */ +#if defined(SQLITE_HAS_CODEC) +/* +** Process URI filename query parameters relevant to the SQLite Encryption +** Extension. Return true if any of the relevant query parameters are +** seen and return false if not. +*/ +SQLITE_PRIVATE int sqlite3CodecQueryParameters( + sqlite3 *db, /* Database connection */ + const char *zDb, /* Which schema is being created/attached */ + const char *zUri /* URI filename */ +){ + const char *zKey; + if( zUri==0 ){ + return 0; + }else if( (zKey = uriParameter(zUri, "hexkey"))!=0 && zKey[0] ){ + u8 iByte; + int i; + char zDecoded[40]; + for(i=0, iByte=0; imutex = sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE); + if( db->mutex==0 ){ + sqlite3_free(db); + db = 0; + goto opendb_out; + } + if( isThreadsafe==0 ){ + sqlite3MutexWarnOnContention(db->mutex); + } + } + sqlite3_mutex_enter(db->mutex); + db->errMask = (flags & SQLITE_OPEN_EXRESCODE)!=0 ? 0xffffffff : 0xff; + db->nDb = 2; + db->eOpenState = SQLITE_STATE_BUSY; + db->aDb = db->aDbStatic; + db->lookaside.bDisable = 1; + db->lookaside.sz = 0; + + assert( sizeof(db->aLimit)==sizeof(aHardLimit) ); + memcpy(db->aLimit, aHardLimit, sizeof(db->aLimit)); + db->aLimit[SQLITE_LIMIT_WORKER_THREADS] = SQLITE_DEFAULT_WORKER_THREADS; + db->autoCommit = 1; + db->nextAutovac = -1; + db->szMmap = sqlite3GlobalConfig.szMmap; + db->nextPagesize = 0; + db->init.azInit = sqlite3StdType; /* Any array of string ptrs will do */ +#ifdef SQLITE_ENABLE_SORTER_MMAP + /* Beginning with version 3.37.0, using the VFS xFetch() API to memory-map + ** the temporary files used to do external sorts (see code in vdbesort.c) + ** is disabled. It can still be used either by defining + ** SQLITE_ENABLE_SORTER_MMAP at compile time or by using the + ** SQLITE_TESTCTRL_SORTER_MMAP test-control at runtime. */ + db->nMaxSorterMmap = 0x7FFFFFFF; +#endif + db->flags |= SQLITE_ShortColNames + | SQLITE_EnableTrigger + | SQLITE_EnableView + | SQLITE_CacheSpill +#if !defined(SQLITE_TRUSTED_SCHEMA) || SQLITE_TRUSTED_SCHEMA+0!=0 + | SQLITE_TrustedSchema +#endif +/* The SQLITE_DQS compile-time option determines the default settings +** for SQLITE_DBCONFIG_DQS_DDL and SQLITE_DBCONFIG_DQS_DML. +** +** SQLITE_DQS SQLITE_DBCONFIG_DQS_DDL SQLITE_DBCONFIG_DQS_DML +** ---------- ----------------------- ----------------------- +** undefined on on +** 3 on on +** 2 on off +** 1 off on +** 0 off off +** +** Legacy behavior is 3 (double-quoted string literals are allowed anywhere) +** and so that is the default. But developers are encouranged to use +** -DSQLITE_DQS=0 (best) or -DSQLITE_DQS=1 (second choice) if possible. +*/ +#if !defined(SQLITE_DQS) +# define SQLITE_DQS 3 +#endif +#if (SQLITE_DQS&1)==1 + | SQLITE_DqsDML +#endif +#if (SQLITE_DQS&2)==2 + | SQLITE_DqsDDL +#endif + +#if !defined(SQLITE_DEFAULT_AUTOMATIC_INDEX) || SQLITE_DEFAULT_AUTOMATIC_INDEX + | SQLITE_AutoIndex +#endif +#if SQLITE_DEFAULT_CKPTFULLFSYNC + | SQLITE_CkptFullFSync +#endif +#if SQLITE_DEFAULT_FILE_FORMAT<4 + | SQLITE_LegacyFileFmt +#endif +#ifdef SQLITE_ENABLE_LOAD_EXTENSION + | SQLITE_LoadExtension +#endif +#if SQLITE_DEFAULT_RECURSIVE_TRIGGERS + | SQLITE_RecTriggers +#endif +#if defined(SQLITE_DEFAULT_FOREIGN_KEYS) && SQLITE_DEFAULT_FOREIGN_KEYS + | SQLITE_ForeignKeys +#endif +#if defined(SQLITE_REVERSE_UNORDERED_SELECTS) + | SQLITE_ReverseOrder +#endif +#if defined(SQLITE_ENABLE_OVERSIZE_CELL_CHECK) + | SQLITE_CellSizeCk +#endif +#if defined(SQLITE_ENABLE_FTS3_TOKENIZER) + | SQLITE_Fts3Tokenizer +#endif +#if defined(SQLITE_ENABLE_QPSG) + | SQLITE_EnableQPSG +#endif +#if defined(SQLITE_DEFAULT_DEFENSIVE) + | SQLITE_Defensive +#endif +#if defined(SQLITE_DEFAULT_LEGACY_ALTER_TABLE) + | SQLITE_LegacyAlter +#endif +#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) + | SQLITE_StmtScanStatus +#endif + ; + sqlite3HashInit(&db->aCollSeq); +#ifndef SQLITE_OMIT_VIRTUALTABLE + sqlite3HashInit(&db->aModule); +#endif + + /* Add the default collation sequence BINARY. BINARY works for both UTF-8 + ** and UTF-16, so add a version for each to avoid any unnecessary + ** conversions. The only error that can occur here is a malloc() failure. + ** + ** EVIDENCE-OF: R-52786-44878 SQLite defines three built-in collating + ** functions: + */ + createCollation(db, sqlite3StrBINARY, SQLITE_UTF8, 0, binCollFunc, 0); + createCollation(db, sqlite3StrBINARY, SQLITE_UTF16BE, 0, binCollFunc, 0); + createCollation(db, sqlite3StrBINARY, SQLITE_UTF16LE, 0, binCollFunc, 0); + createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc, 0); + createCollation(db, "RTRIM", SQLITE_UTF8, 0, rtrimCollFunc, 0); + if( db->mallocFailed ){ + goto opendb_out; + } + +#if SQLITE_OS_UNIX && defined(SQLITE_OS_KV_OPTIONAL) + /* Process magic filenames ":localStorage:" and ":sessionStorage:" */ + if( zFilename && zFilename[0]==':' ){ + if( strcmp(zFilename, ":localStorage:")==0 ){ + zFilename = "file:local?vfs=kvvfs"; + flags |= SQLITE_OPEN_URI; + }else if( strcmp(zFilename, ":sessionStorage:")==0 ){ + zFilename = "file:session?vfs=kvvfs"; + flags |= SQLITE_OPEN_URI; + } + } +#endif /* SQLITE_OS_UNIX && defined(SQLITE_OS_KV_OPTIONAL) */ + + /* Parse the filename/URI argument + ** + ** Only allow sensible combinations of bits in the flags argument. + ** Throw an error if any non-sense combination is used. If we + ** do not block illegal combinations here, it could trigger + ** assert() statements in deeper layers. Sensible combinations + ** are: + ** + ** 1: SQLITE_OPEN_READONLY + ** 2: SQLITE_OPEN_READWRITE + ** 6: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE + */ + db->openFlags = flags; + assert( SQLITE_OPEN_READONLY == 0x01 ); + assert( SQLITE_OPEN_READWRITE == 0x02 ); + assert( SQLITE_OPEN_CREATE == 0x04 ); + testcase( (1<<(flags&7))==0x02 ); /* READONLY */ + testcase( (1<<(flags&7))==0x04 ); /* READWRITE */ + testcase( (1<<(flags&7))==0x40 ); /* READWRITE | CREATE */ + if( ((1<<(flags&7)) & 0x46)==0 ){ + rc = SQLITE_MISUSE_BKPT; /* IMP: R-18321-05872 */ + }else{ + rc = sqlite3ParseUri(zVfs, zFilename, &flags, &db->pVfs, &zOpen, &zErrMsg); + } + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_NOMEM ) sqlite3OomFault(db); + sqlite3ErrorWithMsg(db, rc, zErrMsg ? "%s" : 0, zErrMsg); + sqlite3_free(zErrMsg); + goto opendb_out; + } + assert( db->pVfs!=0 ); +#if SQLITE_OS_KV || defined(SQLITE_OS_KV_OPTIONAL) + if( sqlite3_stricmp(db->pVfs->zName, "kvvfs")==0 ){ + db->temp_store = 2; + } +#endif + + /* Open the backend database driver */ + rc = sqlite3BtreeOpen(db->pVfs, zOpen, db, &db->aDb[0].pBt, 0, + flags | SQLITE_OPEN_MAIN_DB); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_IOERR_NOMEM ){ + rc = SQLITE_NOMEM_BKPT; + } + sqlite3Error(db, rc); + goto opendb_out; + } + sqlite3BtreeEnter(db->aDb[0].pBt); + db->aDb[0].pSchema = sqlite3SchemaGet(db, db->aDb[0].pBt); + if( !db->mallocFailed ){ + sqlite3SetTextEncoding(db, SCHEMA_ENC(db)); + } + sqlite3BtreeLeave(db->aDb[0].pBt); + db->aDb[1].pSchema = sqlite3SchemaGet(db, 0); + + /* The default safety_level for the main database is FULL; for the temp + ** database it is OFF. This matches the pager layer defaults. + */ + db->aDb[0].zDbSName = "main"; + db->aDb[0].safety_level = SQLITE_DEFAULT_SYNCHRONOUS+1; + db->aDb[1].zDbSName = "temp"; + db->aDb[1].safety_level = PAGER_SYNCHRONOUS_OFF; + + db->eOpenState = SQLITE_STATE_OPEN; + if( db->mallocFailed ){ + goto opendb_out; + } + + /* Register all built-in functions, but do not attempt to read the + ** database schema yet. This is delayed until the first time the database + ** is accessed. + */ + sqlite3Error(db, SQLITE_OK); + sqlite3RegisterPerConnectionBuiltinFunctions(db); + rc = sqlite3_errcode(db); + + + /* Load compiled-in extensions */ + for(i=0; rc==SQLITE_OK && imallocFailed && rc==SQLITE_OK ){ + extern int sqlcipherVtabInit(sqlite3 *); + rc = sqlcipherVtabInit(db); + } +#endif + +#ifdef SQLITE_ENABLE_INTERNAL_FUNCTIONS + /* Testing use only!!! The -DSQLITE_ENABLE_INTERNAL_FUNCTIONS=1 compile-time + ** option gives access to internal functions by default. + ** Testing use only!!! */ + db->mDbFlags |= DBFLAG_InternalFunc; +#endif + + /* -DSQLITE_DEFAULT_LOCKING_MODE=1 makes EXCLUSIVE the default locking + ** mode. -DSQLITE_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking + ** mode. Doing nothing at all also makes NORMAL the default. + */ +#ifdef SQLITE_DEFAULT_LOCKING_MODE + db->dfltLockMode = SQLITE_DEFAULT_LOCKING_MODE; + sqlite3PagerLockingMode(sqlite3BtreePager(db->aDb[0].pBt), + SQLITE_DEFAULT_LOCKING_MODE); +#endif + + if( rc ) sqlite3Error(db, rc); + + /* Enable the lookaside-malloc subsystem */ + setupLookaside(db, 0, sqlite3GlobalConfig.szLookaside, + sqlite3GlobalConfig.nLookaside); + + sqlite3_wal_autocheckpoint(db, SQLITE_DEFAULT_WAL_AUTOCHECKPOINT); + +opendb_out: + if( db ){ + assert( db->mutex!=0 || isThreadsafe==0 + || sqlite3GlobalConfig.bFullMutex==0 ); + sqlite3_mutex_leave(db->mutex); + } + rc = sqlite3_errcode(db); + assert( db!=0 || (rc&0xff)==SQLITE_NOMEM ); + if( (rc&0xff)==SQLITE_NOMEM ){ + sqlite3_close(db); + db = 0; + }else if( rc!=SQLITE_OK ){ + db->eOpenState = SQLITE_STATE_SICK; + } + *ppDb = db; +#ifdef SQLITE_ENABLE_SQLLOG + if( sqlite3GlobalConfig.xSqllog ){ + /* Opening a db handle. Fourth parameter is passed 0. */ + void *pArg = sqlite3GlobalConfig.pSqllogArg; + sqlite3GlobalConfig.xSqllog(pArg, db, zFilename, 0); + } +#endif +/* BEGIN SQLCIPHER */ +#if defined(SQLITE_HAS_CODEC) + if( rc==SQLITE_OK ) sqlite3CodecQueryParameters(db, 0, zOpen); +#endif +/* END SQLCIPHER */ + sqlite3_free_filename(zOpen); + return rc; +} + + +/* +** Open a new database handle. +*/ +SQLITE_API int sqlite3_open( + const char *zFilename, + sqlite3 **ppDb +){ + return openDatabase(zFilename, ppDb, + SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0); +} +SQLITE_API int sqlite3_open_v2( + const char *filename, /* Database filename (UTF-8) */ + sqlite3 **ppDb, /* OUT: SQLite db handle */ + int flags, /* Flags */ + const char *zVfs /* Name of VFS module to use */ +){ + return openDatabase(filename, ppDb, (unsigned int)flags, zVfs); +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** Open a new database handle. +*/ +SQLITE_API int sqlite3_open16( + const void *zFilename, + sqlite3 **ppDb +){ + char const *zFilename8; /* zFilename encoded in UTF-8 instead of UTF-16 */ + sqlite3_value *pVal; + int rc; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( ppDb==0 ) return SQLITE_MISUSE_BKPT; +#endif + *ppDb = 0; +#ifndef SQLITE_OMIT_AUTOINIT + rc = sqlite3_initialize(); + if( rc ) return rc; +#endif + if( zFilename==0 ) zFilename = "\000\000"; + pVal = sqlite3ValueNew(0); + sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC); + zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8); + if( zFilename8 ){ + rc = openDatabase(zFilename8, ppDb, + SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0); + assert( *ppDb || rc==SQLITE_NOMEM ); + if( rc==SQLITE_OK && !DbHasProperty(*ppDb, 0, DB_SchemaLoaded) ){ + SCHEMA_ENC(*ppDb) = ENC(*ppDb) = SQLITE_UTF16NATIVE; + } + }else{ + rc = SQLITE_NOMEM_BKPT; + } + sqlite3ValueFree(pVal); + + return rc & 0xff; +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** Register a new collation sequence with the database handle db. +*/ +SQLITE_API int sqlite3_create_collation( + sqlite3* db, + const char *zName, + int enc, + void* pCtx, + int(*xCompare)(void*,int,const void*,int,const void*) +){ + return sqlite3_create_collation_v2(db, zName, enc, pCtx, xCompare, 0); +} + +/* +** Register a new collation sequence with the database handle db. +*/ +SQLITE_API int sqlite3_create_collation_v2( + sqlite3* db, + const char *zName, + int enc, + void* pCtx, + int(*xCompare)(void*,int,const void*,int,const void*), + void(*xDel)(void*) +){ + int rc; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + assert( !db->mallocFailed ); + rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** Register a new collation sequence with the database handle db. +*/ +SQLITE_API int sqlite3_create_collation16( + sqlite3* db, + const void *zName, + int enc, + void* pCtx, + int(*xCompare)(void*,int,const void*,int,const void*) +){ + int rc = SQLITE_OK; + char *zName8; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + assert( !db->mallocFailed ); + zName8 = sqlite3Utf16to8(db, zName, -1, SQLITE_UTF16NATIVE); + if( zName8 ){ + rc = createCollation(db, zName8, (u8)enc, pCtx, xCompare, 0); + sqlite3DbFree(db, zName8); + } + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** Register a collation sequence factory callback with the database handle +** db. Replace any previously installed collation sequence factory. +*/ +SQLITE_API int sqlite3_collation_needed( + sqlite3 *db, + void *pCollNeededArg, + void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*) +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + db->xCollNeeded = xCollNeeded; + db->xCollNeeded16 = 0; + db->pCollNeededArg = pCollNeededArg; + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** Register a collation sequence factory callback with the database handle +** db. Replace any previously installed collation sequence factory. +*/ +SQLITE_API int sqlite3_collation_needed16( + sqlite3 *db, + void *pCollNeededArg, + void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*) +){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + db->xCollNeeded = 0; + db->xCollNeeded16 = xCollNeeded16; + db->pCollNeededArg = pCollNeededArg; + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} +#endif /* SQLITE_OMIT_UTF16 */ + +#ifndef SQLITE_OMIT_DEPRECATED +/* +** This function is now an anachronism. It used to be used to recover from a +** malloc() failure, but SQLite now does this automatically. +*/ +SQLITE_API int sqlite3_global_recover(void){ + return SQLITE_OK; +} +#endif + +/* +** Test to see whether or not the database connection is in autocommit +** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on +** by default. Autocommit is disabled by a BEGIN statement and reenabled +** by the next COMMIT or ROLLBACK. +*/ +SQLITE_API int sqlite3_get_autocommit(sqlite3 *db){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + return db->autoCommit; +} + +/* +** The following routines are substitutes for constants SQLITE_CORRUPT, +** SQLITE_MISUSE, SQLITE_CANTOPEN, SQLITE_NOMEM and possibly other error +** constants. They serve two purposes: +** +** 1. Serve as a convenient place to set a breakpoint in a debugger +** to detect when version error conditions occurs. +** +** 2. Invoke sqlite3_log() to provide the source code location where +** a low-level error is first detected. +*/ +SQLITE_PRIVATE int sqlite3ReportError(int iErr, int lineno, const char *zType){ + sqlite3_log(iErr, "%s at line %d of [%.10s]", + zType, lineno, 20+sqlite3_sourceid()); + return iErr; +} +SQLITE_PRIVATE int sqlite3CorruptError(int lineno){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + return sqlite3ReportError(SQLITE_CORRUPT, lineno, "database corruption"); +} +SQLITE_PRIVATE int sqlite3MisuseError(int lineno){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + return sqlite3ReportError(SQLITE_MISUSE, lineno, "misuse"); +} +SQLITE_PRIVATE int sqlite3CantopenError(int lineno){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + return sqlite3ReportError(SQLITE_CANTOPEN, lineno, "cannot open file"); +} +#if defined(SQLITE_DEBUG) || defined(SQLITE_ENABLE_CORRUPT_PGNO) +SQLITE_PRIVATE int sqlite3CorruptPgnoError(int lineno, Pgno pgno){ + char zMsg[100]; + sqlite3_snprintf(sizeof(zMsg), zMsg, "database corruption page %d", pgno); + testcase( sqlite3GlobalConfig.xLog!=0 ); + return sqlite3ReportError(SQLITE_CORRUPT, lineno, zMsg); +} +#endif +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3NomemError(int lineno){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + return sqlite3ReportError(SQLITE_NOMEM, lineno, "OOM"); +} +SQLITE_PRIVATE int sqlite3IoerrnomemError(int lineno){ + testcase( sqlite3GlobalConfig.xLog!=0 ); + return sqlite3ReportError(SQLITE_IOERR_NOMEM, lineno, "I/O OOM error"); +} +#endif + +#ifndef SQLITE_OMIT_DEPRECATED +/* +** This is a convenience routine that makes sure that all thread-specific +** data for this thread has been deallocated. +** +** SQLite no longer uses thread-specific data so this routine is now a +** no-op. It is retained for historical compatibility. +*/ +SQLITE_API void sqlite3_thread_cleanup(void){ +} +#endif + +/* +** Return meta information about a specific column of a database table. +** See comment in sqlite3.h (sqlite.h.in) for details. +*/ +SQLITE_API int sqlite3_table_column_metadata( + sqlite3 *db, /* Connection handle */ + const char *zDbName, /* Database name or NULL */ + const char *zTableName, /* Table name */ + const char *zColumnName, /* Column name */ + char const **pzDataType, /* OUTPUT: Declared data type */ + char const **pzCollSeq, /* OUTPUT: Collation sequence name */ + int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */ + int *pPrimaryKey, /* OUTPUT: True if column part of PK */ + int *pAutoinc /* OUTPUT: True if column is auto-increment */ +){ + int rc; + char *zErrMsg = 0; + Table *pTab = 0; + Column *pCol = 0; + int iCol = 0; + char const *zDataType = 0; + char const *zCollSeq = 0; + int notnull = 0; + int primarykey = 0; + int autoinc = 0; + + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) || zTableName==0 ){ + return SQLITE_MISUSE_BKPT; + } +#endif + + /* Ensure the database schema has been loaded */ + sqlite3_mutex_enter(db->mutex); + sqlite3BtreeEnterAll(db); + rc = sqlite3Init(db, &zErrMsg); + if( SQLITE_OK!=rc ){ + goto error_out; + } + + /* Locate the table in question */ + pTab = sqlite3FindTable(db, zTableName, zDbName); + if( !pTab || IsView(pTab) ){ + pTab = 0; + goto error_out; + } + + /* Find the column for which info is requested */ + if( zColumnName==0 ){ + /* Query for existance of table only */ + }else{ + for(iCol=0; iColnCol; iCol++){ + pCol = &pTab->aCol[iCol]; + if( 0==sqlite3StrICmp(pCol->zCnName, zColumnName) ){ + break; + } + } + if( iCol==pTab->nCol ){ + if( HasRowid(pTab) && sqlite3IsRowid(zColumnName) ){ + iCol = pTab->iPKey; + pCol = iCol>=0 ? &pTab->aCol[iCol] : 0; + }else{ + pTab = 0; + goto error_out; + } + } + } + + /* The following block stores the meta information that will be returned + ** to the caller in local variables zDataType, zCollSeq, notnull, primarykey + ** and autoinc. At this point there are two possibilities: + ** + ** 1. The specified column name was rowid", "oid" or "_rowid_" + ** and there is no explicitly declared IPK column. + ** + ** 2. The table is not a view and the column name identified an + ** explicitly declared column. Copy meta information from *pCol. + */ + if( pCol ){ + zDataType = sqlite3ColumnType(pCol,0); + zCollSeq = sqlite3ColumnColl(pCol); + notnull = pCol->notNull!=0; + primarykey = (pCol->colFlags & COLFLAG_PRIMKEY)!=0; + autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0; + }else{ + zDataType = "INTEGER"; + primarykey = 1; + } + if( !zCollSeq ){ + zCollSeq = sqlite3StrBINARY; + } + +error_out: + sqlite3BtreeLeaveAll(db); + + /* Whether the function call succeeded or failed, set the output parameters + ** to whatever their local counterparts contain. If an error did occur, + ** this has the effect of zeroing all output parameters. + */ + if( pzDataType ) *pzDataType = zDataType; + if( pzCollSeq ) *pzCollSeq = zCollSeq; + if( pNotNull ) *pNotNull = notnull; + if( pPrimaryKey ) *pPrimaryKey = primarykey; + if( pAutoinc ) *pAutoinc = autoinc; + + if( SQLITE_OK==rc && !pTab ){ + sqlite3DbFree(db, zErrMsg); + zErrMsg = sqlite3MPrintf(db, "no such table column: %s.%s", zTableName, + zColumnName); + rc = SQLITE_ERROR; + } + sqlite3ErrorWithMsg(db, rc, (zErrMsg?"%s":0), zErrMsg); + sqlite3DbFree(db, zErrMsg); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Sleep for a little while. Return the amount of time slept. +*/ +SQLITE_API int sqlite3_sleep(int ms){ + sqlite3_vfs *pVfs; + int rc; + pVfs = sqlite3_vfs_find(0); + if( pVfs==0 ) return 0; + + /* This function works in milliseconds, but the underlying OsSleep() + ** API uses microseconds. Hence the 1000's. + */ + rc = (sqlite3OsSleep(pVfs, ms<0 ? 0 : 1000*ms)/1000); + return rc; +} + +/* +** Enable or disable the extended result codes. +*/ +SQLITE_API int sqlite3_extended_result_codes(sqlite3 *db, int onoff){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + db->errMask = onoff ? 0xffffffff : 0xff; + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +/* +** Invoke the xFileControl method on a particular database. +*/ +SQLITE_API int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){ + int rc = SQLITE_ERROR; + Btree *pBtree; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT; +#endif + sqlite3_mutex_enter(db->mutex); + pBtree = sqlite3DbNameToBtree(db, zDbName); + if( pBtree ){ + Pager *pPager; + sqlite3_file *fd; + sqlite3BtreeEnter(pBtree); + pPager = sqlite3BtreePager(pBtree); + assert( pPager!=0 ); + fd = sqlite3PagerFile(pPager); + assert( fd!=0 ); + if( op==SQLITE_FCNTL_FILE_POINTER ){ + *(sqlite3_file**)pArg = fd; + rc = SQLITE_OK; + }else if( op==SQLITE_FCNTL_VFS_POINTER ){ + *(sqlite3_vfs**)pArg = sqlite3PagerVfs(pPager); + rc = SQLITE_OK; + }else if( op==SQLITE_FCNTL_JOURNAL_POINTER ){ + *(sqlite3_file**)pArg = sqlite3PagerJrnlFile(pPager); + rc = SQLITE_OK; + }else if( op==SQLITE_FCNTL_DATA_VERSION ){ + *(unsigned int*)pArg = sqlite3PagerDataVersion(pPager); + rc = SQLITE_OK; + }else if( op==SQLITE_FCNTL_RESERVE_BYTES ){ + int iNew = *(int*)pArg; + *(int*)pArg = sqlite3BtreeGetRequestedReserve(pBtree); + if( iNew>=0 && iNew<=255 ){ + sqlite3BtreeSetPageSize(pBtree, 0, iNew, 0); + } + rc = SQLITE_OK; + }else if( op==SQLITE_FCNTL_RESET_CACHE ){ + sqlite3BtreeClearCache(pBtree); + rc = SQLITE_OK; + }else{ + int nSave = db->busyHandler.nBusy; + rc = sqlite3OsFileControl(fd, op, pArg); + db->busyHandler.nBusy = nSave; + } + sqlite3BtreeLeave(pBtree); + } + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Interface to the testing logic. +*/ +SQLITE_API int sqlite3_test_control(int op, ...){ + int rc = 0; +#ifdef SQLITE_UNTESTABLE + UNUSED_PARAMETER(op); +#else + va_list ap; + va_start(ap, op); + switch( op ){ + + /* + ** Save the current state of the PRNG. + */ + case SQLITE_TESTCTRL_PRNG_SAVE: { + sqlite3PrngSaveState(); + break; + } + + /* + ** Restore the state of the PRNG to the last state saved using + ** PRNG_SAVE. If PRNG_SAVE has never before been called, then + ** this verb acts like PRNG_RESET. + */ + case SQLITE_TESTCTRL_PRNG_RESTORE: { + sqlite3PrngRestoreState(); + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_PRNG_SEED, int x, sqlite3 *db); + ** + ** Control the seed for the pseudo-random number generator (PRNG) that + ** is built into SQLite. Cases: + ** + ** x!=0 && db!=0 Seed the PRNG to the current value of the + ** schema cookie in the main database for db, or + ** x if the schema cookie is zero. This case + ** is convenient to use with database fuzzers + ** as it allows the fuzzer some control over the + ** the PRNG seed. + ** + ** x!=0 && db==0 Seed the PRNG to the value of x. + ** + ** x==0 && db==0 Revert to default behavior of using the + ** xRandomness method on the primary VFS. + ** + ** This test-control also resets the PRNG so that the new seed will + ** be used for the next call to sqlite3_randomness(). + */ +#ifndef SQLITE_OMIT_WSD + case SQLITE_TESTCTRL_PRNG_SEED: { + int x = va_arg(ap, int); + int y; + sqlite3 *db = va_arg(ap, sqlite3*); + assert( db==0 || db->aDb[0].pSchema!=0 ); + if( db && (y = db->aDb[0].pSchema->schema_cookie)!=0 ){ x = y; } + sqlite3Config.iPrngSeed = x; + sqlite3_randomness(0,0); + break; + } +#endif + + /* + ** sqlite3_test_control(BITVEC_TEST, size, program) + ** + ** Run a test against a Bitvec object of size. The program argument + ** is an array of integers that defines the test. Return -1 on a + ** memory allocation error, 0 on success, or non-zero for an error. + ** See the sqlite3BitvecBuiltinTest() for additional information. + */ + case SQLITE_TESTCTRL_BITVEC_TEST: { + int sz = va_arg(ap, int); + int *aProg = va_arg(ap, int*); + rc = sqlite3BitvecBuiltinTest(sz, aProg); + break; + } + + /* + ** sqlite3_test_control(FAULT_INSTALL, xCallback) + ** + ** Arrange to invoke xCallback() whenever sqlite3FaultSim() is called, + ** if xCallback is not NULL. + ** + ** As a test of the fault simulator mechanism itself, sqlite3FaultSim(0) + ** is called immediately after installing the new callback and the return + ** value from sqlite3FaultSim(0) becomes the return from + ** sqlite3_test_control(). + */ + case SQLITE_TESTCTRL_FAULT_INSTALL: { + /* A bug in MSVC prevents it from understanding pointers to functions + ** types in the second argument to va_arg(). Work around the problem + ** using a typedef. + ** http://support.microsoft.com/kb/47961 <-- dead hyperlink + ** Search at http://web.archive.org/ to find the 2015-03-16 archive + ** of the link above to see the original text. + ** sqlite3GlobalConfig.xTestCallback = va_arg(ap, int(*)(int)); + */ + typedef int(*sqlite3FaultFuncType)(int); + sqlite3GlobalConfig.xTestCallback = va_arg(ap, sqlite3FaultFuncType); + rc = sqlite3FaultSim(0); + break; + } + + /* + ** sqlite3_test_control(BENIGN_MALLOC_HOOKS, xBegin, xEnd) + ** + ** Register hooks to call to indicate which malloc() failures + ** are benign. + */ + case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: { + typedef void (*void_function)(void); + void_function xBenignBegin; + void_function xBenignEnd; + xBenignBegin = va_arg(ap, void_function); + xBenignEnd = va_arg(ap, void_function); + sqlite3BenignMallocHooks(xBenignBegin, xBenignEnd); + break; + } + + /* + ** sqlite3_test_control(SQLITE_TESTCTRL_PENDING_BYTE, unsigned int X) + ** + ** Set the PENDING byte to the value in the argument, if X>0. + ** Make no changes if X==0. Return the value of the pending byte + ** as it existing before this routine was called. + ** + ** IMPORTANT: Changing the PENDING byte from 0x40000000 results in + ** an incompatible database file format. Changing the PENDING byte + ** while any database connection is open results in undefined and + ** deleterious behavior. + */ + case SQLITE_TESTCTRL_PENDING_BYTE: { + rc = PENDING_BYTE; +#ifndef SQLITE_OMIT_WSD + { + unsigned int newVal = va_arg(ap, unsigned int); + if( newVal ) sqlite3PendingByte = newVal; + } +#endif + break; + } + + /* + ** sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, int X) + ** + ** This action provides a run-time test to see whether or not + ** assert() was enabled at compile-time. If X is true and assert() + ** is enabled, then the return value is true. If X is true and + ** assert() is disabled, then the return value is zero. If X is + ** false and assert() is enabled, then the assertion fires and the + ** process aborts. If X is false and assert() is disabled, then the + ** return value is zero. + */ + case SQLITE_TESTCTRL_ASSERT: { + volatile int x = 0; + assert( /*side-effects-ok*/ (x = va_arg(ap,int))!=0 ); + rc = x; +#if defined(SQLITE_DEBUG) + /* Invoke these debugging routines so that the compiler does not + ** issue "defined but not used" warnings. */ + if( x==9999 ){ + sqlite3ShowExpr(0); + sqlite3ShowExpr(0); + sqlite3ShowExprList(0); + sqlite3ShowIdList(0); + sqlite3ShowSrcList(0); + sqlite3ShowWith(0); + sqlite3ShowUpsert(0); + sqlite3ShowTriggerStep(0); + sqlite3ShowTriggerStepList(0); + sqlite3ShowTrigger(0); + sqlite3ShowTriggerList(0); +#ifndef SQLITE_OMIT_WINDOWFUNC + sqlite3ShowWindow(0); + sqlite3ShowWinFunc(0); +#endif + sqlite3ShowSelect(0); + } +#endif + break; + } + + + /* + ** sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, int X) + ** + ** This action provides a run-time test to see how the ALWAYS and + ** NEVER macros were defined at compile-time. + ** + ** The return value is ALWAYS(X) if X is true, or 0 if X is false. + ** + ** The recommended test is X==2. If the return value is 2, that means + ** ALWAYS() and NEVER() are both no-op pass-through macros, which is the + ** default setting. If the return value is 1, then ALWAYS() is either + ** hard-coded to true or else it asserts if its argument is false. + ** The first behavior (hard-coded to true) is the case if + ** SQLITE_TESTCTRL_ASSERT shows that assert() is disabled and the second + ** behavior (assert if the argument to ALWAYS() is false) is the case if + ** SQLITE_TESTCTRL_ASSERT shows that assert() is enabled. + ** + ** The run-time test procedure might look something like this: + ** + ** if( sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, 2)==2 ){ + ** // ALWAYS() and NEVER() are no-op pass-through macros + ** }else if( sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, 1) ){ + ** // ALWAYS(x) asserts that x is true. NEVER(x) asserts x is false. + ** }else{ + ** // ALWAYS(x) is a constant 1. NEVER(x) is a constant 0. + ** } + */ + case SQLITE_TESTCTRL_ALWAYS: { + int x = va_arg(ap,int); + rc = x ? ALWAYS(x) : 0; + break; + } + + /* + ** sqlite3_test_control(SQLITE_TESTCTRL_BYTEORDER); + ** + ** The integer returned reveals the byte-order of the computer on which + ** SQLite is running: + ** + ** 1 big-endian, determined at run-time + ** 10 little-endian, determined at run-time + ** 432101 big-endian, determined at compile-time + ** 123410 little-endian, determined at compile-time + */ + case SQLITE_TESTCTRL_BYTEORDER: { + rc = SQLITE_BYTEORDER*100 + SQLITE_LITTLEENDIAN*10 + SQLITE_BIGENDIAN; + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS, sqlite3 *db, int N) + ** + ** Enable or disable various optimizations for testing purposes. The + ** argument N is a bitmask of optimizations to be disabled. For normal + ** operation N should be 0. The idea is that a test program (like the + ** SQL Logic Test or SLT test module) can run the same SQL multiple times + ** with various optimizations disabled to verify that the same answer + ** is obtained in every case. + */ + case SQLITE_TESTCTRL_OPTIMIZATIONS: { + sqlite3 *db = va_arg(ap, sqlite3*); + db->dbOptFlags = va_arg(ap, u32); + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, onoff, xAlt); + ** + ** If parameter onoff is 1, subsequent calls to localtime() fail. + ** If 2, then invoke xAlt() instead of localtime(). If 0, normal + ** processing. + ** + ** xAlt arguments are void pointers, but they really want to be: + ** + ** int xAlt(const time_t*, struct tm*); + ** + ** xAlt should write results in to struct tm object of its 2nd argument + ** and return zero on success, or return non-zero on failure. + */ + case SQLITE_TESTCTRL_LOCALTIME_FAULT: { + sqlite3GlobalConfig.bLocaltimeFault = va_arg(ap, int); + if( sqlite3GlobalConfig.bLocaltimeFault==2 ){ + typedef int(*sqlite3LocaltimeType)(const void*,void*); + sqlite3GlobalConfig.xAltLocaltime = va_arg(ap, sqlite3LocaltimeType); + }else{ + sqlite3GlobalConfig.xAltLocaltime = 0; + } + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_INTERNAL_FUNCTIONS, sqlite3*); + ** + ** Toggle the ability to use internal functions on or off for + ** the database connection given in the argument. + */ + case SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: { + sqlite3 *db = va_arg(ap, sqlite3*); + db->mDbFlags ^= DBFLAG_InternalFunc; + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_NEVER_CORRUPT, int); + ** + ** Set or clear a flag that indicates that the database file is always well- + ** formed and never corrupt. This flag is clear by default, indicating that + ** database files might have arbitrary corruption. Setting the flag during + ** testing causes certain assert() statements in the code to be activated + ** that demonstrat invariants on well-formed database files. + */ + case SQLITE_TESTCTRL_NEVER_CORRUPT: { + sqlite3GlobalConfig.neverCorrupt = va_arg(ap, int); + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS, int); + ** + ** Set or clear a flag that causes SQLite to verify that type, name, + ** and tbl_name fields of the sqlite_schema table. This is normally + ** on, but it is sometimes useful to turn it off for testing. + ** + ** 2020-07-22: Disabling EXTRA_SCHEMA_CHECKS also disables the + ** verification of rootpage numbers when parsing the schema. This + ** is useful to make it easier to reach strange internal error states + ** during testing. The EXTRA_SCHEMA_CHECKS setting is always enabled + ** in production. + */ + case SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS: { + sqlite3GlobalConfig.bExtraSchemaChecks = va_arg(ap, int); + break; + } + + /* Set the threshold at which OP_Once counters reset back to zero. + ** By default this is 0x7ffffffe (over 2 billion), but that value is + ** too big to test in a reasonable amount of time, so this control is + ** provided to set a small and easily reachable reset value. + */ + case SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD: { + sqlite3GlobalConfig.iOnceResetThreshold = va_arg(ap, int); + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_VDBE_COVERAGE, xCallback, ptr); + ** + ** Set the VDBE coverage callback function to xCallback with context + ** pointer ptr. + */ + case SQLITE_TESTCTRL_VDBE_COVERAGE: { +#ifdef SQLITE_VDBE_COVERAGE + typedef void (*branch_callback)(void*,unsigned int, + unsigned char,unsigned char); + sqlite3GlobalConfig.xVdbeBranch = va_arg(ap,branch_callback); + sqlite3GlobalConfig.pVdbeBranchArg = va_arg(ap,void*); +#endif + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_SORTER_MMAP, db, nMax); */ + case SQLITE_TESTCTRL_SORTER_MMAP: { + sqlite3 *db = va_arg(ap, sqlite3*); + db->nMaxSorterMmap = va_arg(ap, int); + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_ISINIT); + ** + ** Return SQLITE_OK if SQLite has been initialized and SQLITE_ERROR if + ** not. + */ + case SQLITE_TESTCTRL_ISINIT: { + if( sqlite3GlobalConfig.isInit==0 ) rc = SQLITE_ERROR; + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, db, dbName, onOff, tnum); + ** + ** This test control is used to create imposter tables. "db" is a pointer + ** to the database connection. dbName is the database name (ex: "main" or + ** "temp") which will receive the imposter. "onOff" turns imposter mode on + ** or off. "tnum" is the root page of the b-tree to which the imposter + ** table should connect. + ** + ** Enable imposter mode only when the schema has already been parsed. Then + ** run a single CREATE TABLE statement to construct the imposter table in + ** the parsed schema. Then turn imposter mode back off again. + ** + ** If onOff==0 and tnum>0 then reset the schema for all databases, causing + ** the schema to be reparsed the next time it is needed. This has the + ** effect of erasing all imposter tables. + */ + case SQLITE_TESTCTRL_IMPOSTER: { + sqlite3 *db = va_arg(ap, sqlite3*); + int iDb; + sqlite3_mutex_enter(db->mutex); + iDb = sqlite3FindDbName(db, va_arg(ap,const char*)); + if( iDb>=0 ){ + db->init.iDb = iDb; + db->init.busy = db->init.imposterTable = va_arg(ap,int); + db->init.newTnum = va_arg(ap,int); + if( db->init.busy==0 && db->init.newTnum>0 ){ + sqlite3ResetAllSchemasOfConnection(db); + } + } + sqlite3_mutex_leave(db->mutex); + break; + } + +#if defined(YYCOVERAGE) + /* sqlite3_test_control(SQLITE_TESTCTRL_PARSER_COVERAGE, FILE *out) + ** + ** This test control (only available when SQLite is compiled with + ** -DYYCOVERAGE) writes a report onto "out" that shows all + ** state/lookahead combinations in the parser state machine + ** which are never exercised. If any state is missed, make the + ** return code SQLITE_ERROR. + */ + case SQLITE_TESTCTRL_PARSER_COVERAGE: { + FILE *out = va_arg(ap, FILE*); + if( sqlite3ParserCoverage(out) ) rc = SQLITE_ERROR; + break; + } +#endif /* defined(YYCOVERAGE) */ + + /* sqlite3_test_control(SQLITE_TESTCTRL_RESULT_INTREAL, sqlite3_context*); + ** + ** This test-control causes the most recent sqlite3_result_int64() value + ** to be interpreted as a MEM_IntReal instead of as an MEM_Int. Normally, + ** MEM_IntReal values only arise during an INSERT operation of integer + ** values into a REAL column, so they can be challenging to test. This + ** test-control enables us to write an intreal() SQL function that can + ** inject an intreal() value at arbitrary places in an SQL statement, + ** for testing purposes. + */ + case SQLITE_TESTCTRL_RESULT_INTREAL: { + sqlite3_context *pCtx = va_arg(ap, sqlite3_context*); + sqlite3ResultIntReal(pCtx); + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_SEEK_COUNT, + ** sqlite3 *db, // Database connection + ** u64 *pnSeek // Write seek count here + ** ); + ** + ** This test-control queries the seek-counter on the "main" database + ** file. The seek-counter is written into *pnSeek and is then reset. + ** The seek-count is only available if compiled with SQLITE_DEBUG. + */ + case SQLITE_TESTCTRL_SEEK_COUNT: { + sqlite3 *db = va_arg(ap, sqlite3*); + u64 *pn = va_arg(ap, sqlite3_uint64*); + *pn = sqlite3BtreeSeekCount(db->aDb->pBt); + (void)db; /* Silence harmless unused variable warning */ + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, op, ptr) + ** + ** "ptr" is a pointer to a u32. + ** + ** op==0 Store the current sqlite3TreeTrace in *ptr + ** op==1 Set sqlite3TreeTrace to the value *ptr + ** op==3 Store the current sqlite3WhereTrace in *ptr + ** op==3 Set sqlite3WhereTrace to the value *ptr + */ + case SQLITE_TESTCTRL_TRACEFLAGS: { + int opTrace = va_arg(ap, int); + u32 *ptr = va_arg(ap, u32*); + switch( opTrace ){ + case 0: *ptr = sqlite3TreeTrace; break; + case 1: sqlite3TreeTrace = *ptr; break; + case 2: *ptr = sqlite3WhereTrace; break; + case 3: sqlite3WhereTrace = *ptr; break; + } + break; + } + + /* sqlite3_test_control(SQLITE_TESTCTRL_LOGEST, + ** double fIn, // Input value + ** int *pLogEst, // sqlite3LogEstFromDouble(fIn) + ** u64 *pInt, // sqlite3LogEstToInt(*pLogEst) + ** int *pLogEst2 // sqlite3LogEst(*pInt) + ** ); + ** + ** Test access for the LogEst conversion routines. + */ + case SQLITE_TESTCTRL_LOGEST: { + double rIn = va_arg(ap, double); + LogEst rLogEst = sqlite3LogEstFromDouble(rIn); + int *pI1 = va_arg(ap,int*); + u64 *pU64 = va_arg(ap,u64*); + int *pI2 = va_arg(ap,int*); + *pI1 = rLogEst; + *pU64 = sqlite3LogEstToInt(rLogEst); + *pI2 = sqlite3LogEst(*pU64); + break; + } + + +#if defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_WSD) + /* sqlite3_test_control(SQLITE_TESTCTRL_TUNE, id, *piValue) + ** + ** If "id" is an integer between 1 and SQLITE_NTUNE then set the value + ** of the id-th tuning parameter to *piValue. If "id" is between -1 + ** and -SQLITE_NTUNE, then write the current value of the (-id)-th + ** tuning parameter into *piValue. + ** + ** Tuning parameters are for use during transient development builds, + ** to help find the best values for constants in the query planner. + ** Access tuning parameters using the Tuning(ID) macro. Set the + ** parameters in the CLI using ".testctrl tune ID VALUE". + ** + ** Transient use only. Tuning parameters should not be used in + ** checked-in code. + */ + case SQLITE_TESTCTRL_TUNE: { + int id = va_arg(ap, int); + int *piValue = va_arg(ap, int*); + if( id>0 && id<=SQLITE_NTUNE ){ + Tuning(id) = *piValue; + }else if( id<0 && id>=-SQLITE_NTUNE ){ + *piValue = Tuning(-id); + }else{ + rc = SQLITE_NOTFOUND; + } + break; + } +#endif + } + va_end(ap); +#endif /* SQLITE_UNTESTABLE */ + return rc; +} + +/* +** The Pager stores the Database filename, Journal filename, and WAL filename +** consecutively in memory, in that order. The database filename is prefixed +** by four zero bytes. Locate the start of the database filename by searching +** backwards for the first byte following four consecutive zero bytes. +** +** This only works if the filename passed in was obtained from the Pager. +*/ +static const char *databaseName(const char *zName){ + while( zName[-1]!=0 || zName[-2]!=0 || zName[-3]!=0 || zName[-4]!=0 ){ + zName--; + } + return zName; +} + +/* +** Append text z[] to the end of p[]. Return a pointer to the first +** character after then zero terminator on the new text in p[]. +*/ +static char *appendText(char *p, const char *z){ + size_t n = strlen(z); + memcpy(p, z, n+1); + return p+n+1; +} + +/* +** Allocate memory to hold names for a database, journal file, WAL file, +** and query parameters. The pointer returned is valid for use by +** sqlite3_filename_database() and sqlite3_uri_parameter() and related +** functions. +** +** Memory layout must be compatible with that generated by the pager +** and expected by sqlite3_uri_parameter() and databaseName(). +*/ +SQLITE_API const char *sqlite3_create_filename( + const char *zDatabase, + const char *zJournal, + const char *zWal, + int nParam, + const char **azParam +){ + sqlite3_int64 nByte; + int i; + char *pResult, *p; + nByte = strlen(zDatabase) + strlen(zJournal) + strlen(zWal) + 10; + for(i=0; i0 ){ + zFilename += sqlite3Strlen30(zFilename) + 1; + zFilename += sqlite3Strlen30(zFilename) + 1; + } + return zFilename[0] ? zFilename : 0; +} + +/* +** Return a boolean value for a query parameter. +*/ +SQLITE_API int sqlite3_uri_boolean(const char *zFilename, const char *zParam, int bDflt){ + const char *z = sqlite3_uri_parameter(zFilename, zParam); + bDflt = bDflt!=0; + return z ? sqlite3GetBoolean(z, bDflt) : bDflt; +} + +/* +** Return a 64-bit integer value for a query parameter. +*/ +SQLITE_API sqlite3_int64 sqlite3_uri_int64( + const char *zFilename, /* Filename as passed to xOpen */ + const char *zParam, /* URI parameter sought */ + sqlite3_int64 bDflt /* return if parameter is missing */ +){ + const char *z = sqlite3_uri_parameter(zFilename, zParam); + sqlite3_int64 v; + if( z && sqlite3DecOrHexToI64(z, &v)==0 ){ + bDflt = v; + } + return bDflt; +} + +/* +** Translate a filename that was handed to a VFS routine into the corresponding +** database, journal, or WAL file. +** +** It is an error to pass this routine a filename string that was not +** passed into the VFS from the SQLite core. Doing so is similar to +** passing free() a pointer that was not obtained from malloc() - it is +** an error that we cannot easily detect but that will likely cause memory +** corruption. +*/ +SQLITE_API const char *sqlite3_filename_database(const char *zFilename){ + if( zFilename==0 ) return 0; + return databaseName(zFilename); +} +SQLITE_API const char *sqlite3_filename_journal(const char *zFilename){ + if( zFilename==0 ) return 0; + zFilename = databaseName(zFilename); + zFilename += sqlite3Strlen30(zFilename) + 1; + while( ALWAYS(zFilename) && zFilename[0] ){ + zFilename += sqlite3Strlen30(zFilename) + 1; + zFilename += sqlite3Strlen30(zFilename) + 1; + } + return zFilename + 1; +} +SQLITE_API const char *sqlite3_filename_wal(const char *zFilename){ +#ifdef SQLITE_OMIT_WAL + return 0; +#else + zFilename = sqlite3_filename_journal(zFilename); + if( zFilename ) zFilename += sqlite3Strlen30(zFilename) + 1; + return zFilename; +#endif +} + +/* +** Return the Btree pointer identified by zDbName. Return NULL if not found. +*/ +SQLITE_PRIVATE Btree *sqlite3DbNameToBtree(sqlite3 *db, const char *zDbName){ + int iDb = zDbName ? sqlite3FindDbName(db, zDbName) : 0; + return iDb<0 ? 0 : db->aDb[iDb].pBt; +} + +/* +** Return the name of the N-th database schema. Return NULL if N is out +** of range. +*/ +SQLITE_API const char *sqlite3_db_name(sqlite3 *db, int N){ +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + if( N<0 || N>=db->nDb ){ + return 0; + }else{ + return db->aDb[N].zDbSName; + } +} + +/* +** Return the filename of the database associated with a database +** connection. +*/ +SQLITE_API const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName){ + Btree *pBt; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + pBt = sqlite3DbNameToBtree(db, zDbName); + return pBt ? sqlite3BtreeGetFilename(pBt) : 0; +} + +/* +** Return 1 if database is read-only or 0 if read/write. Return -1 if +** no such database exists. +*/ +SQLITE_API int sqlite3_db_readonly(sqlite3 *db, const char *zDbName){ + Btree *pBt; +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + (void)SQLITE_MISUSE_BKPT; + return -1; + } +#endif + pBt = sqlite3DbNameToBtree(db, zDbName); + return pBt ? sqlite3BtreeIsReadonly(pBt) : -1; +} + +#ifdef SQLITE_ENABLE_SNAPSHOT +/* +** Obtain a snapshot handle for the snapshot of database zDb currently +** being read by handle db. +*/ +SQLITE_API int sqlite3_snapshot_get( + sqlite3 *db, + const char *zDb, + sqlite3_snapshot **ppSnapshot +){ + int rc = SQLITE_ERROR; +#ifndef SQLITE_OMIT_WAL + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + return SQLITE_MISUSE_BKPT; + } +#endif + sqlite3_mutex_enter(db->mutex); + + if( db->autoCommit==0 ){ + int iDb = sqlite3FindDbName(db, zDb); + if( iDb==0 || iDb>1 ){ + Btree *pBt = db->aDb[iDb].pBt; + if( SQLITE_TXN_WRITE!=sqlite3BtreeTxnState(pBt) ){ + rc = sqlite3BtreeBeginTrans(pBt, 0, 0); + if( rc==SQLITE_OK ){ + rc = sqlite3PagerSnapshotGet(sqlite3BtreePager(pBt), ppSnapshot); + } + } + } + } + + sqlite3_mutex_leave(db->mutex); +#endif /* SQLITE_OMIT_WAL */ + return rc; +} + +/* +** Open a read-transaction on the snapshot idendified by pSnapshot. +*/ +SQLITE_API int sqlite3_snapshot_open( + sqlite3 *db, + const char *zDb, + sqlite3_snapshot *pSnapshot +){ + int rc = SQLITE_ERROR; +#ifndef SQLITE_OMIT_WAL + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + return SQLITE_MISUSE_BKPT; + } +#endif + sqlite3_mutex_enter(db->mutex); + if( db->autoCommit==0 ){ + int iDb; + iDb = sqlite3FindDbName(db, zDb); + if( iDb==0 || iDb>1 ){ + Btree *pBt = db->aDb[iDb].pBt; + if( sqlite3BtreeTxnState(pBt)!=SQLITE_TXN_WRITE ){ + Pager *pPager = sqlite3BtreePager(pBt); + int bUnlock = 0; + if( sqlite3BtreeTxnState(pBt)!=SQLITE_TXN_NONE ){ + if( db->nVdbeActive==0 ){ + rc = sqlite3PagerSnapshotCheck(pPager, pSnapshot); + if( rc==SQLITE_OK ){ + bUnlock = 1; + rc = sqlite3BtreeCommit(pBt); + } + } + }else{ + rc = SQLITE_OK; + } + if( rc==SQLITE_OK ){ + rc = sqlite3PagerSnapshotOpen(pPager, pSnapshot); + } + if( rc==SQLITE_OK ){ + rc = sqlite3BtreeBeginTrans(pBt, 0, 0); + sqlite3PagerSnapshotOpen(pPager, 0); + } + if( bUnlock ){ + sqlite3PagerSnapshotUnlock(pPager); + } + } + } + } + + sqlite3_mutex_leave(db->mutex); +#endif /* SQLITE_OMIT_WAL */ + return rc; +} + +/* +** Recover as many snapshots as possible from the wal file associated with +** schema zDb of database db. +*/ +SQLITE_API int sqlite3_snapshot_recover(sqlite3 *db, const char *zDb){ + int rc = SQLITE_ERROR; +#ifndef SQLITE_OMIT_WAL + int iDb; + +#ifdef SQLITE_ENABLE_API_ARMOR + if( !sqlite3SafetyCheckOk(db) ){ + return SQLITE_MISUSE_BKPT; + } +#endif + + sqlite3_mutex_enter(db->mutex); + iDb = sqlite3FindDbName(db, zDb); + if( iDb==0 || iDb>1 ){ + Btree *pBt = db->aDb[iDb].pBt; + if( SQLITE_TXN_NONE==sqlite3BtreeTxnState(pBt) ){ + rc = sqlite3BtreeBeginTrans(pBt, 0, 0); + if( rc==SQLITE_OK ){ + rc = sqlite3PagerSnapshotRecover(sqlite3BtreePager(pBt)); + sqlite3BtreeCommit(pBt); + } + } + } + sqlite3_mutex_leave(db->mutex); +#endif /* SQLITE_OMIT_WAL */ + return rc; +} + +/* +** Free a snapshot handle obtained from sqlite3_snapshot_get(). +*/ +SQLITE_API void sqlite3_snapshot_free(sqlite3_snapshot *pSnapshot){ + sqlite3_free(pSnapshot); +} +#endif /* SQLITE_ENABLE_SNAPSHOT */ + +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS +/* +** Given the name of a compile-time option, return true if that option +** was used and false if not. +** +** The name can optionally begin with "SQLITE_" but the "SQLITE_" prefix +** is not required for a match. +*/ +SQLITE_API int sqlite3_compileoption_used(const char *zOptName){ + int i, n; + int nOpt; + const char **azCompileOpt; + +#if SQLITE_ENABLE_API_ARMOR + if( zOptName==0 ){ + (void)SQLITE_MISUSE_BKPT; + return 0; + } +#endif + + azCompileOpt = sqlite3CompileOptions(&nOpt); + + if( sqlite3StrNICmp(zOptName, "SQLITE_", 7)==0 ) zOptName += 7; + n = sqlite3Strlen30(zOptName); + + /* Since nOpt is normally in single digits, a linear search is + ** adequate. No need for a binary search. */ + for(i=0; i=0 && NpNextBlocked){ + int seen = 0; + sqlite3 *p2; + + /* Verify property (1) */ + assert( p->pUnlockConnection || p->pBlockingConnection ); + + /* Verify property (2) */ + for(p2=sqlite3BlockedList; p2!=p; p2=p2->pNextBlocked){ + if( p2->xUnlockNotify==p->xUnlockNotify ) seen = 1; + assert( p2->xUnlockNotify==p->xUnlockNotify || !seen ); + assert( db==0 || p->pUnlockConnection!=db ); + assert( db==0 || p->pBlockingConnection!=db ); + } + } +} +#else +# define checkListProperties(x) +#endif + +/* +** Remove connection db from the blocked connections list. If connection +** db is not currently a part of the list, this function is a no-op. +*/ +static void removeFromBlockedList(sqlite3 *db){ + sqlite3 **pp; + assertMutexHeld(); + for(pp=&sqlite3BlockedList; *pp; pp = &(*pp)->pNextBlocked){ + if( *pp==db ){ + *pp = (*pp)->pNextBlocked; + break; + } + } +} + +/* +** Add connection db to the blocked connections list. It is assumed +** that it is not already a part of the list. +*/ +static void addToBlockedList(sqlite3 *db){ + sqlite3 **pp; + assertMutexHeld(); + for( + pp=&sqlite3BlockedList; + *pp && (*pp)->xUnlockNotify!=db->xUnlockNotify; + pp=&(*pp)->pNextBlocked + ); + db->pNextBlocked = *pp; + *pp = db; +} + +/* +** Obtain the STATIC_MAIN mutex. +*/ +static void enterMutex(void){ + sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN)); + checkListProperties(0); +} + +/* +** Release the STATIC_MAIN mutex. +*/ +static void leaveMutex(void){ + assertMutexHeld(); + checkListProperties(0); + sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN)); +} + +/* +** Register an unlock-notify callback. +** +** This is called after connection "db" has attempted some operation +** but has received an SQLITE_LOCKED error because another connection +** (call it pOther) in the same process was busy using the same shared +** cache. pOther is found by looking at db->pBlockingConnection. +** +** If there is no blocking connection, the callback is invoked immediately, +** before this routine returns. +** +** If pOther is already blocked on db, then report SQLITE_LOCKED, to indicate +** a deadlock. +** +** Otherwise, make arrangements to invoke xNotify when pOther drops +** its locks. +** +** Each call to this routine overrides any prior callbacks registered +** on the same "db". If xNotify==0 then any prior callbacks are immediately +** cancelled. +*/ +SQLITE_API int sqlite3_unlock_notify( + sqlite3 *db, + void (*xNotify)(void **, int), + void *pArg +){ + int rc = SQLITE_OK; + + sqlite3_mutex_enter(db->mutex); + enterMutex(); + + if( xNotify==0 ){ + removeFromBlockedList(db); + db->pBlockingConnection = 0; + db->pUnlockConnection = 0; + db->xUnlockNotify = 0; + db->pUnlockArg = 0; + }else if( 0==db->pBlockingConnection ){ + /* The blocking transaction has been concluded. Or there never was a + ** blocking transaction. In either case, invoke the notify callback + ** immediately. + */ + xNotify(&pArg, 1); + }else{ + sqlite3 *p; + + for(p=db->pBlockingConnection; p && p!=db; p=p->pUnlockConnection){} + if( p ){ + rc = SQLITE_LOCKED; /* Deadlock detected. */ + }else{ + db->pUnlockConnection = db->pBlockingConnection; + db->xUnlockNotify = xNotify; + db->pUnlockArg = pArg; + removeFromBlockedList(db); + addToBlockedList(db); + } + } + + leaveMutex(); + assert( !db->mallocFailed ); + sqlite3ErrorWithMsg(db, rc, (rc?"database is deadlocked":0)); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** This function is called while stepping or preparing a statement +** associated with connection db. The operation will return SQLITE_LOCKED +** to the user because it requires a lock that will not be available +** until connection pBlocker concludes its current transaction. +*/ +SQLITE_PRIVATE void sqlite3ConnectionBlocked(sqlite3 *db, sqlite3 *pBlocker){ + enterMutex(); + if( db->pBlockingConnection==0 && db->pUnlockConnection==0 ){ + addToBlockedList(db); + } + db->pBlockingConnection = pBlocker; + leaveMutex(); +} + +/* +** This function is called when +** the transaction opened by database db has just finished. Locks held +** by database connection db have been released. +** +** This function loops through each entry in the blocked connections +** list and does the following: +** +** 1) If the sqlite3.pBlockingConnection member of a list entry is +** set to db, then set pBlockingConnection=0. +** +** 2) If the sqlite3.pUnlockConnection member of a list entry is +** set to db, then invoke the configured unlock-notify callback and +** set pUnlockConnection=0. +** +** 3) If the two steps above mean that pBlockingConnection==0 and +** pUnlockConnection==0, remove the entry from the blocked connections +** list. +*/ +SQLITE_PRIVATE void sqlite3ConnectionUnlocked(sqlite3 *db){ + void (*xUnlockNotify)(void **, int) = 0; /* Unlock-notify cb to invoke */ + int nArg = 0; /* Number of entries in aArg[] */ + sqlite3 **pp; /* Iterator variable */ + void **aArg; /* Arguments to the unlock callback */ + void **aDyn = 0; /* Dynamically allocated space for aArg[] */ + void *aStatic[16]; /* Starter space for aArg[]. No malloc required */ + + aArg = aStatic; + enterMutex(); /* Enter STATIC_MAIN mutex */ + + /* This loop runs once for each entry in the blocked-connections list. */ + for(pp=&sqlite3BlockedList; *pp; /* no-op */ ){ + sqlite3 *p = *pp; + + /* Step 1. */ + if( p->pBlockingConnection==db ){ + p->pBlockingConnection = 0; + } + + /* Step 2. */ + if( p->pUnlockConnection==db ){ + assert( p->xUnlockNotify ); + if( p->xUnlockNotify!=xUnlockNotify && nArg!=0 ){ + xUnlockNotify(aArg, nArg); + nArg = 0; + } + + sqlite3BeginBenignMalloc(); + assert( aArg==aDyn || (aDyn==0 && aArg==aStatic) ); + assert( nArg<=(int)ArraySize(aStatic) || aArg==aDyn ); + if( (!aDyn && nArg==(int)ArraySize(aStatic)) + || (aDyn && nArg==(int)(sqlite3MallocSize(aDyn)/sizeof(void*))) + ){ + /* The aArg[] array needs to grow. */ + void **pNew = (void **)sqlite3Malloc(nArg*sizeof(void *)*2); + if( pNew ){ + memcpy(pNew, aArg, nArg*sizeof(void *)); + sqlite3_free(aDyn); + aDyn = aArg = pNew; + }else{ + /* This occurs when the array of context pointers that need to + ** be passed to the unlock-notify callback is larger than the + ** aStatic[] array allocated on the stack and the attempt to + ** allocate a larger array from the heap has failed. + ** + ** This is a difficult situation to handle. Returning an error + ** code to the caller is insufficient, as even if an error code + ** is returned the transaction on connection db will still be + ** closed and the unlock-notify callbacks on blocked connections + ** will go unissued. This might cause the application to wait + ** indefinitely for an unlock-notify callback that will never + ** arrive. + ** + ** Instead, invoke the unlock-notify callback with the context + ** array already accumulated. We can then clear the array and + ** begin accumulating any further context pointers without + ** requiring any dynamic allocation. This is sub-optimal because + ** it means that instead of one callback with a large array of + ** context pointers the application will receive two or more + ** callbacks with smaller arrays of context pointers, which will + ** reduce the applications ability to prioritize multiple + ** connections. But it is the best that can be done under the + ** circumstances. + */ + xUnlockNotify(aArg, nArg); + nArg = 0; + } + } + sqlite3EndBenignMalloc(); + + aArg[nArg++] = p->pUnlockArg; + xUnlockNotify = p->xUnlockNotify; + p->pUnlockConnection = 0; + p->xUnlockNotify = 0; + p->pUnlockArg = 0; + } + + /* Step 3. */ + if( p->pBlockingConnection==0 && p->pUnlockConnection==0 ){ + /* Remove connection p from the blocked connections list. */ + *pp = p->pNextBlocked; + p->pNextBlocked = 0; + }else{ + pp = &p->pNextBlocked; + } + } + + if( nArg!=0 ){ + xUnlockNotify(aArg, nArg); + } + sqlite3_free(aDyn); + leaveMutex(); /* Leave STATIC_MAIN mutex */ +} + +/* +** This is called when the database connection passed as an argument is +** being closed. The connection is removed from the blocked list. +*/ +SQLITE_PRIVATE void sqlite3ConnectionClosed(sqlite3 *db){ + sqlite3ConnectionUnlocked(db); + enterMutex(); + removeFromBlockedList(db); + checkListProperties(db); + leaveMutex(); +} +#endif + +/************** End of notify.c **********************************************/ +/************** Begin file fts3.c ********************************************/ +/* +** 2006 Oct 10 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This is an SQLite module implementing full-text search. +*/ + +/* +** The code in this file is only compiled if: +** +** * The FTS3 module is being built as an extension +** (in which case SQLITE_CORE is not defined), or +** +** * The FTS3 module is being built into the core of +** SQLite (in which case SQLITE_ENABLE_FTS3 is defined). +*/ + +/* The full-text index is stored in a series of b+tree (-like) +** structures called segments which map terms to doclists. The +** structures are like b+trees in layout, but are constructed from the +** bottom up in optimal fashion and are not updatable. Since trees +** are built from the bottom up, things will be described from the +** bottom up. +** +** +**** Varints **** +** The basic unit of encoding is a variable-length integer called a +** varint. We encode variable-length integers in little-endian order +** using seven bits * per byte as follows: +** +** KEY: +** A = 0xxxxxxx 7 bits of data and one flag bit +** B = 1xxxxxxx 7 bits of data and one flag bit +** +** 7 bits - A +** 14 bits - BA +** 21 bits - BBA +** and so on. +** +** This is similar in concept to how sqlite encodes "varints" but +** the encoding is not the same. SQLite varints are big-endian +** are are limited to 9 bytes in length whereas FTS3 varints are +** little-endian and can be up to 10 bytes in length (in theory). +** +** Example encodings: +** +** 1: 0x01 +** 127: 0x7f +** 128: 0x81 0x00 +** +** +**** Document lists **** +** A doclist (document list) holds a docid-sorted list of hits for a +** given term. Doclists hold docids and associated token positions. +** A docid is the unique integer identifier for a single document. +** A position is the index of a word within the document. The first +** word of the document has a position of 0. +** +** FTS3 used to optionally store character offsets using a compile-time +** option. But that functionality is no longer supported. +** +** A doclist is stored like this: +** +** array { +** varint docid; (delta from previous doclist) +** array { (position list for column 0) +** varint position; (2 more than the delta from previous position) +** } +** array { +** varint POS_COLUMN; (marks start of position list for new column) +** varint column; (index of new column) +** array { +** varint position; (2 more than the delta from previous position) +** } +** } +** varint POS_END; (marks end of positions for this document. +** } +** +** Here, array { X } means zero or more occurrences of X, adjacent in +** memory. A "position" is an index of a token in the token stream +** generated by the tokenizer. Note that POS_END and POS_COLUMN occur +** in the same logical place as the position element, and act as sentinals +** ending a position list array. POS_END is 0. POS_COLUMN is 1. +** The positions numbers are not stored literally but rather as two more +** than the difference from the prior position, or the just the position plus +** 2 for the first position. Example: +** +** label: A B C D E F G H I J K +** value: 123 5 9 1 1 14 35 0 234 72 0 +** +** The 123 value is the first docid. For column zero in this document +** there are two matches at positions 3 and 10 (5-2 and 9-2+3). The 1 +** at D signals the start of a new column; the 1 at E indicates that the +** new column is column number 1. There are two positions at 12 and 45 +** (14-2 and 35-2+12). The 0 at H indicate the end-of-document. The +** 234 at I is the delta to next docid (357). It has one position 70 +** (72-2) and then terminates with the 0 at K. +** +** A "position-list" is the list of positions for multiple columns for +** a single docid. A "column-list" is the set of positions for a single +** column. Hence, a position-list consists of one or more column-lists, +** a document record consists of a docid followed by a position-list and +** a doclist consists of one or more document records. +** +** A bare doclist omits the position information, becoming an +** array of varint-encoded docids. +** +**** Segment leaf nodes **** +** Segment leaf nodes store terms and doclists, ordered by term. Leaf +** nodes are written using LeafWriter, and read using LeafReader (to +** iterate through a single leaf node's data) and LeavesReader (to +** iterate through a segment's entire leaf layer). Leaf nodes have +** the format: +** +** varint iHeight; (height from leaf level, always 0) +** varint nTerm; (length of first term) +** char pTerm[nTerm]; (content of first term) +** varint nDoclist; (length of term's associated doclist) +** char pDoclist[nDoclist]; (content of doclist) +** array { +** (further terms are delta-encoded) +** varint nPrefix; (length of prefix shared with previous term) +** varint nSuffix; (length of unshared suffix) +** char pTermSuffix[nSuffix];(unshared suffix of next term) +** varint nDoclist; (length of term's associated doclist) +** char pDoclist[nDoclist]; (content of doclist) +** } +** +** Here, array { X } means zero or more occurrences of X, adjacent in +** memory. +** +** Leaf nodes are broken into blocks which are stored contiguously in +** the %_segments table in sorted order. This means that when the end +** of a node is reached, the next term is in the node with the next +** greater node id. +** +** New data is spilled to a new leaf node when the current node +** exceeds LEAF_MAX bytes (default 2048). New data which itself is +** larger than STANDALONE_MIN (default 1024) is placed in a standalone +** node (a leaf node with a single term and doclist). The goal of +** these settings is to pack together groups of small doclists while +** making it efficient to directly access large doclists. The +** assumption is that large doclists represent terms which are more +** likely to be query targets. +** +** TODO(shess) It may be useful for blocking decisions to be more +** dynamic. For instance, it may make more sense to have a 2.5k leaf +** node rather than splitting into 2k and .5k nodes. My intuition is +** that this might extend through 2x or 4x the pagesize. +** +** +**** Segment interior nodes **** +** Segment interior nodes store blockids for subtree nodes and terms +** to describe what data is stored by the each subtree. Interior +** nodes are written using InteriorWriter, and read using +** InteriorReader. InteriorWriters are created as needed when +** SegmentWriter creates new leaf nodes, or when an interior node +** itself grows too big and must be split. The format of interior +** nodes: +** +** varint iHeight; (height from leaf level, always >0) +** varint iBlockid; (block id of node's leftmost subtree) +** optional { +** varint nTerm; (length of first term) +** char pTerm[nTerm]; (content of first term) +** array { +** (further terms are delta-encoded) +** varint nPrefix; (length of shared prefix with previous term) +** varint nSuffix; (length of unshared suffix) +** char pTermSuffix[nSuffix]; (unshared suffix of next term) +** } +** } +** +** Here, optional { X } means an optional element, while array { X } +** means zero or more occurrences of X, adjacent in memory. +** +** An interior node encodes n terms separating n+1 subtrees. The +** subtree blocks are contiguous, so only the first subtree's blockid +** is encoded. The subtree at iBlockid will contain all terms less +** than the first term encoded (or all terms if no term is encoded). +** Otherwise, for terms greater than or equal to pTerm[i] but less +** than pTerm[i+1], the subtree for that term will be rooted at +** iBlockid+i. Interior nodes only store enough term data to +** distinguish adjacent children (if the rightmost term of the left +** child is "something", and the leftmost term of the right child is +** "wicked", only "w" is stored). +** +** New data is spilled to a new interior node at the same height when +** the current node exceeds INTERIOR_MAX bytes (default 2048). +** INTERIOR_MIN_TERMS (default 7) keeps large terms from monopolizing +** interior nodes and making the tree too skinny. The interior nodes +** at a given height are naturally tracked by interior nodes at +** height+1, and so on. +** +** +**** Segment directory **** +** The segment directory in table %_segdir stores meta-information for +** merging and deleting segments, and also the root node of the +** segment's tree. +** +** The root node is the top node of the segment's tree after encoding +** the entire segment, restricted to ROOT_MAX bytes (default 1024). +** This could be either a leaf node or an interior node. If the top +** node requires more than ROOT_MAX bytes, it is flushed to %_segments +** and a new root interior node is generated (which should always fit +** within ROOT_MAX because it only needs space for 2 varints, the +** height and the blockid of the previous root). +** +** The meta-information in the segment directory is: +** level - segment level (see below) +** idx - index within level +** - (level,idx uniquely identify a segment) +** start_block - first leaf node +** leaves_end_block - last leaf node +** end_block - last block (including interior nodes) +** root - contents of root node +** +** If the root node is a leaf node, then start_block, +** leaves_end_block, and end_block are all 0. +** +** +**** Segment merging **** +** To amortize update costs, segments are grouped into levels and +** merged in batches. Each increase in level represents exponentially +** more documents. +** +** New documents (actually, document updates) are tokenized and +** written individually (using LeafWriter) to a level 0 segment, with +** incrementing idx. When idx reaches MERGE_COUNT (default 16), all +** level 0 segments are merged into a single level 1 segment. Level 1 +** is populated like level 0, and eventually MERGE_COUNT level 1 +** segments are merged to a single level 2 segment (representing +** MERGE_COUNT^2 updates), and so on. +** +** A segment merge traverses all segments at a given level in +** parallel, performing a straightforward sorted merge. Since segment +** leaf nodes are written in to the %_segments table in order, this +** merge traverses the underlying sqlite disk structures efficiently. +** After the merge, all segment blocks from the merged level are +** deleted. +** +** MERGE_COUNT controls how often we merge segments. 16 seems to be +** somewhat of a sweet spot for insertion performance. 32 and 64 show +** very similar performance numbers to 16 on insertion, though they're +** a tiny bit slower (perhaps due to more overhead in merge-time +** sorting). 8 is about 20% slower than 16, 4 about 50% slower than +** 16, 2 about 66% slower than 16. +** +** At query time, high MERGE_COUNT increases the number of segments +** which need to be scanned and merged. For instance, with 100k docs +** inserted: +** +** MERGE_COUNT segments +** 16 25 +** 8 12 +** 4 10 +** 2 6 +** +** This appears to have only a moderate impact on queries for very +** frequent terms (which are somewhat dominated by segment merge +** costs), and infrequent and non-existent terms still seem to be fast +** even with many segments. +** +** TODO(shess) That said, it would be nice to have a better query-side +** argument for MERGE_COUNT of 16. Also, it is possible/likely that +** optimizations to things like doclist merging will swing the sweet +** spot around. +** +** +** +**** Handling of deletions and updates **** +** Since we're using a segmented structure, with no docid-oriented +** index into the term index, we clearly cannot simply update the term +** index when a document is deleted or updated. For deletions, we +** write an empty doclist (varint(docid) varint(POS_END)), for updates +** we simply write the new doclist. Segment merges overwrite older +** data for a particular docid with newer data, so deletes or updates +** will eventually overtake the earlier data and knock it out. The +** query logic likewise merges doclists so that newer data knocks out +** older data. +*/ + +/************** Include fts3Int.h in the middle of fts3.c ********************/ +/************** Begin file fts3Int.h *****************************************/ +/* +** 2009 Nov 12 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +*/ +#ifndef _FTSINT_H +#define _FTSINT_H + +#if !defined(NDEBUG) && !defined(SQLITE_DEBUG) +# define NDEBUG 1 +#endif + +/* FTS3/FTS4 require virtual tables */ +#ifdef SQLITE_OMIT_VIRTUALTABLE +# undef SQLITE_ENABLE_FTS3 +# undef SQLITE_ENABLE_FTS4 +#endif + +/* +** FTS4 is really an extension for FTS3. It is enabled using the +** SQLITE_ENABLE_FTS3 macro. But to avoid confusion we also all +** the SQLITE_ENABLE_FTS4 macro to serve as an alisse for SQLITE_ENABLE_FTS3. +*/ +#if defined(SQLITE_ENABLE_FTS4) && !defined(SQLITE_ENABLE_FTS3) +# define SQLITE_ENABLE_FTS3 +#endif + +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* If not building as part of the core, include sqlite3ext.h. */ +#ifndef SQLITE_CORE +/* # include "sqlite3ext.h" */ +SQLITE_EXTENSION_INIT3 +#endif + +/* #include "sqlite3.h" */ +/************** Include fts3_tokenizer.h in the middle of fts3Int.h **********/ +/************** Begin file fts3_tokenizer.h **********************************/ +/* +** 2006 July 10 +** +** The author disclaims copyright to this source code. +** +************************************************************************* +** Defines the interface to tokenizers used by fulltext-search. There +** are three basic components: +** +** sqlite3_tokenizer_module is a singleton defining the tokenizer +** interface functions. This is essentially the class structure for +** tokenizers. +** +** sqlite3_tokenizer is used to define a particular tokenizer, perhaps +** including customization information defined at creation time. +** +** sqlite3_tokenizer_cursor is generated by a tokenizer to generate +** tokens from a particular input. +*/ +#ifndef _FTS3_TOKENIZER_H_ +#define _FTS3_TOKENIZER_H_ + +/* TODO(shess) Only used for SQLITE_OK and SQLITE_DONE at this time. +** If tokenizers are to be allowed to call sqlite3_*() functions, then +** we will need a way to register the API consistently. +*/ +/* #include "sqlite3.h" */ + +/* +** Structures used by the tokenizer interface. When a new tokenizer +** implementation is registered, the caller provides a pointer to +** an sqlite3_tokenizer_module containing pointers to the callback +** functions that make up an implementation. +** +** When an fts3 table is created, it passes any arguments passed to +** the tokenizer clause of the CREATE VIRTUAL TABLE statement to the +** sqlite3_tokenizer_module.xCreate() function of the requested tokenizer +** implementation. The xCreate() function in turn returns an +** sqlite3_tokenizer structure representing the specific tokenizer to +** be used for the fts3 table (customized by the tokenizer clause arguments). +** +** To tokenize an input buffer, the sqlite3_tokenizer_module.xOpen() +** method is called. It returns an sqlite3_tokenizer_cursor object +** that may be used to tokenize a specific input buffer based on +** the tokenization rules supplied by a specific sqlite3_tokenizer +** object. +*/ +typedef struct sqlite3_tokenizer_module sqlite3_tokenizer_module; +typedef struct sqlite3_tokenizer sqlite3_tokenizer; +typedef struct sqlite3_tokenizer_cursor sqlite3_tokenizer_cursor; + +struct sqlite3_tokenizer_module { + + /* + ** Structure version. Should always be set to 0 or 1. + */ + int iVersion; + + /* + ** Create a new tokenizer. The values in the argv[] array are the + ** arguments passed to the "tokenizer" clause of the CREATE VIRTUAL + ** TABLE statement that created the fts3 table. For example, if + ** the following SQL is executed: + ** + ** CREATE .. USING fts3( ... , tokenizer arg1 arg2) + ** + ** then argc is set to 2, and the argv[] array contains pointers + ** to the strings "arg1" and "arg2". + ** + ** This method should return either SQLITE_OK (0), or an SQLite error + ** code. If SQLITE_OK is returned, then *ppTokenizer should be set + ** to point at the newly created tokenizer structure. The generic + ** sqlite3_tokenizer.pModule variable should not be initialized by + ** this callback. The caller will do so. + */ + int (*xCreate)( + int argc, /* Size of argv array */ + const char *const*argv, /* Tokenizer argument strings */ + sqlite3_tokenizer **ppTokenizer /* OUT: Created tokenizer */ + ); + + /* + ** Destroy an existing tokenizer. The fts3 module calls this method + ** exactly once for each successful call to xCreate(). + */ + int (*xDestroy)(sqlite3_tokenizer *pTokenizer); + + /* + ** Create a tokenizer cursor to tokenize an input buffer. The caller + ** is responsible for ensuring that the input buffer remains valid + ** until the cursor is closed (using the xClose() method). + */ + int (*xOpen)( + sqlite3_tokenizer *pTokenizer, /* Tokenizer object */ + const char *pInput, int nBytes, /* Input buffer */ + sqlite3_tokenizer_cursor **ppCursor /* OUT: Created tokenizer cursor */ + ); + + /* + ** Destroy an existing tokenizer cursor. The fts3 module calls this + ** method exactly once for each successful call to xOpen(). + */ + int (*xClose)(sqlite3_tokenizer_cursor *pCursor); + + /* + ** Retrieve the next token from the tokenizer cursor pCursor. This + ** method should either return SQLITE_OK and set the values of the + ** "OUT" variables identified below, or SQLITE_DONE to indicate that + ** the end of the buffer has been reached, or an SQLite error code. + ** + ** *ppToken should be set to point at a buffer containing the + ** normalized version of the token (i.e. after any case-folding and/or + ** stemming has been performed). *pnBytes should be set to the length + ** of this buffer in bytes. The input text that generated the token is + ** identified by the byte offsets returned in *piStartOffset and + ** *piEndOffset. *piStartOffset should be set to the index of the first + ** byte of the token in the input buffer. *piEndOffset should be set + ** to the index of the first byte just past the end of the token in + ** the input buffer. + ** + ** The buffer *ppToken is set to point at is managed by the tokenizer + ** implementation. It is only required to be valid until the next call + ** to xNext() or xClose(). + */ + /* TODO(shess) current implementation requires pInput to be + ** nul-terminated. This should either be fixed, or pInput/nBytes + ** should be converted to zInput. + */ + int (*xNext)( + sqlite3_tokenizer_cursor *pCursor, /* Tokenizer cursor */ + const char **ppToken, int *pnBytes, /* OUT: Normalized text for token */ + int *piStartOffset, /* OUT: Byte offset of token in input buffer */ + int *piEndOffset, /* OUT: Byte offset of end of token in input buffer */ + int *piPosition /* OUT: Number of tokens returned before this one */ + ); + + /*********************************************************************** + ** Methods below this point are only available if iVersion>=1. + */ + + /* + ** Configure the language id of a tokenizer cursor. + */ + int (*xLanguageid)(sqlite3_tokenizer_cursor *pCsr, int iLangid); +}; + +struct sqlite3_tokenizer { + const sqlite3_tokenizer_module *pModule; /* The module for this tokenizer */ + /* Tokenizer implementations will typically add additional fields */ +}; + +struct sqlite3_tokenizer_cursor { + sqlite3_tokenizer *pTokenizer; /* Tokenizer for this cursor. */ + /* Tokenizer implementations will typically add additional fields */ +}; + +int fts3_global_term_cnt(int iTerm, int iCol); +int fts3_term_cnt(int iTerm, int iCol); + + +#endif /* _FTS3_TOKENIZER_H_ */ + +/************** End of fts3_tokenizer.h **************************************/ +/************** Continuing where we left off in fts3Int.h ********************/ +/************** Include fts3_hash.h in the middle of fts3Int.h ***************/ +/************** Begin file fts3_hash.h ***************************************/ +/* +** 2001 September 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This is the header file for the generic hash-table implementation +** used in SQLite. We've modified it slightly to serve as a standalone +** hash table implementation for the full-text indexing module. +** +*/ +#ifndef _FTS3_HASH_H_ +#define _FTS3_HASH_H_ + +/* Forward declarations of structures. */ +typedef struct Fts3Hash Fts3Hash; +typedef struct Fts3HashElem Fts3HashElem; + +/* A complete hash table is an instance of the following structure. +** The internals of this structure are intended to be opaque -- client +** code should not attempt to access or modify the fields of this structure +** directly. Change this structure only by using the routines below. +** However, many of the "procedures" and "functions" for modifying and +** accessing this structure are really macros, so we can't really make +** this structure opaque. +*/ +struct Fts3Hash { + char keyClass; /* HASH_INT, _POINTER, _STRING, _BINARY */ + char copyKey; /* True if copy of key made on insert */ + int count; /* Number of entries in this table */ + Fts3HashElem *first; /* The first element of the array */ + int htsize; /* Number of buckets in the hash table */ + struct _fts3ht { /* the hash table */ + int count; /* Number of entries with this hash */ + Fts3HashElem *chain; /* Pointer to first entry with this hash */ + } *ht; +}; + +/* Each element in the hash table is an instance of the following +** structure. All elements are stored on a single doubly-linked list. +** +** Again, this structure is intended to be opaque, but it can't really +** be opaque because it is used by macros. +*/ +struct Fts3HashElem { + Fts3HashElem *next, *prev; /* Next and previous elements in the table */ + void *data; /* Data associated with this element */ + void *pKey; int nKey; /* Key associated with this element */ +}; + +/* +** There are 2 different modes of operation for a hash table: +** +** FTS3_HASH_STRING pKey points to a string that is nKey bytes long +** (including the null-terminator, if any). Case +** is respected in comparisons. +** +** FTS3_HASH_BINARY pKey points to binary data nKey bytes long. +** memcmp() is used to compare keys. +** +** A copy of the key is made if the copyKey parameter to fts3HashInit is 1. +*/ +#define FTS3_HASH_STRING 1 +#define FTS3_HASH_BINARY 2 + +/* +** Access routines. To delete, insert a NULL pointer. +*/ +SQLITE_PRIVATE void sqlite3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey); +SQLITE_PRIVATE void *sqlite3Fts3HashInsert(Fts3Hash*, const void *pKey, int nKey, void *pData); +SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash*, const void *pKey, int nKey); +SQLITE_PRIVATE void sqlite3Fts3HashClear(Fts3Hash*); +SQLITE_PRIVATE Fts3HashElem *sqlite3Fts3HashFindElem(const Fts3Hash *, const void *, int); + +/* +** Shorthand for the functions above +*/ +#define fts3HashInit sqlite3Fts3HashInit +#define fts3HashInsert sqlite3Fts3HashInsert +#define fts3HashFind sqlite3Fts3HashFind +#define fts3HashClear sqlite3Fts3HashClear +#define fts3HashFindElem sqlite3Fts3HashFindElem + +/* +** Macros for looping over all elements of a hash table. The idiom is +** like this: +** +** Fts3Hash h; +** Fts3HashElem *p; +** ... +** for(p=fts3HashFirst(&h); p; p=fts3HashNext(p)){ +** SomeStructure *pData = fts3HashData(p); +** // do something with pData +** } +*/ +#define fts3HashFirst(H) ((H)->first) +#define fts3HashNext(E) ((E)->next) +#define fts3HashData(E) ((E)->data) +#define fts3HashKey(E) ((E)->pKey) +#define fts3HashKeysize(E) ((E)->nKey) + +/* +** Number of entries in a hash table +*/ +#define fts3HashCount(H) ((H)->count) + +#endif /* _FTS3_HASH_H_ */ + +/************** End of fts3_hash.h *******************************************/ +/************** Continuing where we left off in fts3Int.h ********************/ + +/* +** This constant determines the maximum depth of an FTS expression tree +** that the library will create and use. FTS uses recursion to perform +** various operations on the query tree, so the disadvantage of a large +** limit is that it may allow very large queries to use large amounts +** of stack space (perhaps causing a stack overflow). +*/ +#ifndef SQLITE_FTS3_MAX_EXPR_DEPTH +# define SQLITE_FTS3_MAX_EXPR_DEPTH 12 +#endif + + +/* +** This constant controls how often segments are merged. Once there are +** FTS3_MERGE_COUNT segments of level N, they are merged into a single +** segment of level N+1. +*/ +#define FTS3_MERGE_COUNT 16 + +/* +** This is the maximum amount of data (in bytes) to store in the +** Fts3Table.pendingTerms hash table. Normally, the hash table is +** populated as documents are inserted/updated/deleted in a transaction +** and used to create a new segment when the transaction is committed. +** However if this limit is reached midway through a transaction, a new +** segment is created and the hash table cleared immediately. +*/ +#define FTS3_MAX_PENDING_DATA (1*1024*1024) + +/* +** Macro to return the number of elements in an array. SQLite has a +** similar macro called ArraySize(). Use a different name to avoid +** a collision when building an amalgamation with built-in FTS3. +*/ +#define SizeofArray(X) ((int)(sizeof(X)/sizeof(X[0]))) + + +#ifndef MIN +# define MIN(x,y) ((x)<(y)?(x):(y)) +#endif +#ifndef MAX +# define MAX(x,y) ((x)>(y)?(x):(y)) +#endif + +/* +** Maximum length of a varint encoded integer. The varint format is different +** from that used by SQLite, so the maximum length is 10, not 9. +*/ +#define FTS3_VARINT_MAX 10 + +#define FTS3_BUFFER_PADDING 8 + +/* +** FTS4 virtual tables may maintain multiple indexes - one index of all terms +** in the document set and zero or more prefix indexes. All indexes are stored +** as one or more b+-trees in the %_segments and %_segdir tables. +** +** It is possible to determine which index a b+-tree belongs to based on the +** value stored in the "%_segdir.level" column. Given this value L, the index +** that the b+-tree belongs to is (L<<10). In other words, all b+-trees with +** level values between 0 and 1023 (inclusive) belong to index 0, all levels +** between 1024 and 2047 to index 1, and so on. +** +** It is considered impossible for an index to use more than 1024 levels. In +** theory though this may happen, but only after at least +** (FTS3_MERGE_COUNT^1024) separate flushes of the pending-terms tables. +*/ +#define FTS3_SEGDIR_MAXLEVEL 1024 +#define FTS3_SEGDIR_MAXLEVEL_STR "1024" + +/* +** The testcase() macro is only used by the amalgamation. If undefined, +** make it a no-op. +*/ +#ifndef testcase +# define testcase(X) +#endif + +/* +** Terminator values for position-lists and column-lists. +*/ +#define POS_COLUMN (1) /* Column-list terminator */ +#define POS_END (0) /* Position-list terminator */ + +/* +** The assert_fts3_nc() macro is similar to the assert() macro, except that it +** is used for assert() conditions that are true only if it can be +** guranteed that the database is not corrupt. +*/ +#ifdef SQLITE_DEBUG +SQLITE_API extern int sqlite3_fts3_may_be_corrupt; +# define assert_fts3_nc(x) assert(sqlite3_fts3_may_be_corrupt || (x)) +#else +# define assert_fts3_nc(x) assert(x) +#endif + +/* +** This section provides definitions to allow the +** FTS3 extension to be compiled outside of the +** amalgamation. +*/ +#ifndef SQLITE_AMALGAMATION +/* +** Macros indicating that conditional expressions are always true or +** false. +*/ +#if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST) +# define SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS 1 +#endif +#if defined(SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS) +# define ALWAYS(X) (1) +# define NEVER(X) (0) +#elif !defined(NDEBUG) +# define ALWAYS(X) ((X)?1:(assert(0),0)) +# define NEVER(X) ((X)?(assert(0),1):0) +#else +# define ALWAYS(X) (X) +# define NEVER(X) (X) +#endif + +/* +** Internal types used by SQLite. +*/ +typedef unsigned char u8; /* 1-byte (or larger) unsigned integer */ +typedef short int i16; /* 2-byte (or larger) signed integer */ +typedef unsigned int u32; /* 4-byte unsigned integer */ +typedef sqlite3_uint64 u64; /* 8-byte unsigned integer */ +typedef sqlite3_int64 i64; /* 8-byte signed integer */ + +/* +** Macro used to suppress compiler warnings for unused parameters. +*/ +#define UNUSED_PARAMETER(x) (void)(x) + +/* +** Activate assert() only if SQLITE_TEST is enabled. +*/ +#if !defined(NDEBUG) && !defined(SQLITE_DEBUG) +# define NDEBUG 1 +#endif + +/* +** The TESTONLY macro is used to enclose variable declarations or +** other bits of code that are needed to support the arguments +** within testcase() and assert() macros. +*/ +#if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST) +# define TESTONLY(X) X +#else +# define TESTONLY(X) +#endif + +#define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32)) +#define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64) + +#define deliberate_fall_through + +#endif /* SQLITE_AMALGAMATION */ + +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3Fts3Corrupt(void); +# define FTS_CORRUPT_VTAB sqlite3Fts3Corrupt() +#else +# define FTS_CORRUPT_VTAB SQLITE_CORRUPT_VTAB +#endif + +typedef struct Fts3Table Fts3Table; +typedef struct Fts3Cursor Fts3Cursor; +typedef struct Fts3Expr Fts3Expr; +typedef struct Fts3Phrase Fts3Phrase; +typedef struct Fts3PhraseToken Fts3PhraseToken; + +typedef struct Fts3Doclist Fts3Doclist; +typedef struct Fts3SegFilter Fts3SegFilter; +typedef struct Fts3DeferredToken Fts3DeferredToken; +typedef struct Fts3SegReader Fts3SegReader; +typedef struct Fts3MultiSegReader Fts3MultiSegReader; + +typedef struct MatchinfoBuffer MatchinfoBuffer; + +/* +** A connection to a fulltext index is an instance of the following +** structure. The xCreate and xConnect methods create an instance +** of this structure and xDestroy and xDisconnect free that instance. +** All other methods receive a pointer to the structure as one of their +** arguments. +*/ +struct Fts3Table { + sqlite3_vtab base; /* Base class used by SQLite core */ + sqlite3 *db; /* The database connection */ + const char *zDb; /* logical database name */ + const char *zName; /* virtual table name */ + int nColumn; /* number of named columns in virtual table */ + char **azColumn; /* column names. malloced */ + u8 *abNotindexed; /* True for 'notindexed' columns */ + sqlite3_tokenizer *pTokenizer; /* tokenizer for inserts and queries */ + char *zContentTbl; /* content=xxx option, or NULL */ + char *zLanguageid; /* languageid=xxx option, or NULL */ + int nAutoincrmerge; /* Value configured by 'automerge' */ + u32 nLeafAdd; /* Number of leaf blocks added this trans */ + int bLock; /* Used to prevent recursive content= tbls */ + + /* Precompiled statements used by the implementation. Each of these + ** statements is run and reset within a single virtual table API call. + */ + sqlite3_stmt *aStmt[40]; + sqlite3_stmt *pSeekStmt; /* Cache for fts3CursorSeekStmt() */ + + char *zReadExprlist; + char *zWriteExprlist; + + int nNodeSize; /* Soft limit for node size */ + u8 bFts4; /* True for FTS4, false for FTS3 */ + u8 bHasStat; /* True if %_stat table exists (2==unknown) */ + u8 bHasDocsize; /* True if %_docsize table exists */ + u8 bDescIdx; /* True if doclists are in reverse order */ + u8 bIgnoreSavepoint; /* True to ignore xSavepoint invocations */ + int nPgsz; /* Page size for host database */ + char *zSegmentsTbl; /* Name of %_segments table */ + sqlite3_blob *pSegments; /* Blob handle open on %_segments table */ + + /* + ** The following array of hash tables is used to buffer pending index + ** updates during transactions. All pending updates buffered at any one + ** time must share a common language-id (see the FTS4 langid= feature). + ** The current language id is stored in variable iPrevLangid. + ** + ** A single FTS4 table may have multiple full-text indexes. For each index + ** there is an entry in the aIndex[] array. Index 0 is an index of all the + ** terms that appear in the document set. Each subsequent index in aIndex[] + ** is an index of prefixes of a specific length. + ** + ** Variable nPendingData contains an estimate the memory consumed by the + ** pending data structures, including hash table overhead, but not including + ** malloc overhead. When nPendingData exceeds nMaxPendingData, all hash + ** tables are flushed to disk. Variable iPrevDocid is the docid of the most + ** recently inserted record. + */ + int nIndex; /* Size of aIndex[] */ + struct Fts3Index { + int nPrefix; /* Prefix length (0 for main terms index) */ + Fts3Hash hPending; /* Pending terms table for this index */ + } *aIndex; + int nMaxPendingData; /* Max pending data before flush to disk */ + int nPendingData; /* Current bytes of pending data */ + sqlite_int64 iPrevDocid; /* Docid of most recently inserted document */ + int iPrevLangid; /* Langid of recently inserted document */ + int bPrevDelete; /* True if last operation was a delete */ + +#if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST) + /* State variables used for validating that the transaction control + ** methods of the virtual table are called at appropriate times. These + ** values do not contribute to FTS functionality; they are used for + ** verifying the operation of the SQLite core. + */ + int inTransaction; /* True after xBegin but before xCommit/xRollback */ + int mxSavepoint; /* Largest valid xSavepoint integer */ +#endif + +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + /* True to disable the incremental doclist optimization. This is controled + ** by special insert command 'test-no-incr-doclist'. */ + int bNoIncrDoclist; + + /* Number of segments in a level */ + int nMergeCount; +#endif +}; + +/* Macro to find the number of segments to merge */ +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) +# define MergeCount(P) ((P)->nMergeCount) +#else +# define MergeCount(P) FTS3_MERGE_COUNT +#endif + +/* +** When the core wants to read from the virtual table, it creates a +** virtual table cursor (an instance of the following structure) using +** the xOpen method. Cursors are destroyed using the xClose method. +*/ +struct Fts3Cursor { + sqlite3_vtab_cursor base; /* Base class used by SQLite core */ + i16 eSearch; /* Search strategy (see below) */ + u8 isEof; /* True if at End Of Results */ + u8 isRequireSeek; /* True if must seek pStmt to %_content row */ + u8 bSeekStmt; /* True if pStmt is a seek */ + sqlite3_stmt *pStmt; /* Prepared statement in use by the cursor */ + Fts3Expr *pExpr; /* Parsed MATCH query string */ + int iLangid; /* Language being queried for */ + int nPhrase; /* Number of matchable phrases in query */ + Fts3DeferredToken *pDeferred; /* Deferred search tokens, if any */ + sqlite3_int64 iPrevId; /* Previous id read from aDoclist */ + char *pNextId; /* Pointer into the body of aDoclist */ + char *aDoclist; /* List of docids for full-text queries */ + int nDoclist; /* Size of buffer at aDoclist */ + u8 bDesc; /* True to sort in descending order */ + int eEvalmode; /* An FTS3_EVAL_XX constant */ + int nRowAvg; /* Average size of database rows, in pages */ + sqlite3_int64 nDoc; /* Documents in table */ + i64 iMinDocid; /* Minimum docid to return */ + i64 iMaxDocid; /* Maximum docid to return */ + int isMatchinfoNeeded; /* True when aMatchinfo[] needs filling in */ + MatchinfoBuffer *pMIBuffer; /* Buffer for matchinfo data */ +}; + +#define FTS3_EVAL_FILTER 0 +#define FTS3_EVAL_NEXT 1 +#define FTS3_EVAL_MATCHINFO 2 + +/* +** The Fts3Cursor.eSearch member is always set to one of the following. +** Actualy, Fts3Cursor.eSearch can be greater than or equal to +** FTS3_FULLTEXT_SEARCH. If so, then Fts3Cursor.eSearch - 2 is the index +** of the column to be searched. For example, in +** +** CREATE VIRTUAL TABLE ex1 USING fts3(a,b,c,d); +** SELECT docid FROM ex1 WHERE b MATCH 'one two three'; +** +** Because the LHS of the MATCH operator is 2nd column "b", +** Fts3Cursor.eSearch will be set to FTS3_FULLTEXT_SEARCH+1. (+0 for a, +** +1 for b, +2 for c, +3 for d.) If the LHS of MATCH were "ex1" +** indicating that all columns should be searched, +** then eSearch would be set to FTS3_FULLTEXT_SEARCH+4. +*/ +#define FTS3_FULLSCAN_SEARCH 0 /* Linear scan of %_content table */ +#define FTS3_DOCID_SEARCH 1 /* Lookup by rowid on %_content table */ +#define FTS3_FULLTEXT_SEARCH 2 /* Full-text index search */ + +/* +** The lower 16-bits of the sqlite3_index_info.idxNum value set by +** the xBestIndex() method contains the Fts3Cursor.eSearch value described +** above. The upper 16-bits contain a combination of the following +** bits, used to describe extra constraints on full-text searches. +*/ +#define FTS3_HAVE_LANGID 0x00010000 /* languageid=? */ +#define FTS3_HAVE_DOCID_GE 0x00020000 /* docid>=? */ +#define FTS3_HAVE_DOCID_LE 0x00040000 /* docid<=? */ + +struct Fts3Doclist { + char *aAll; /* Array containing doclist (or NULL) */ + int nAll; /* Size of a[] in bytes */ + char *pNextDocid; /* Pointer to next docid */ + + sqlite3_int64 iDocid; /* Current docid (if pList!=0) */ + int bFreeList; /* True if pList should be sqlite3_free()d */ + char *pList; /* Pointer to position list following iDocid */ + int nList; /* Length of position list */ +}; + +/* +** A "phrase" is a sequence of one or more tokens that must match in +** sequence. A single token is the base case and the most common case. +** For a sequence of tokens contained in double-quotes (i.e. "one two three") +** nToken will be the number of tokens in the string. +*/ +struct Fts3PhraseToken { + char *z; /* Text of the token */ + int n; /* Number of bytes in buffer z */ + int isPrefix; /* True if token ends with a "*" character */ + int bFirst; /* True if token must appear at position 0 */ + + /* Variables above this point are populated when the expression is + ** parsed (by code in fts3_expr.c). Below this point the variables are + ** used when evaluating the expression. */ + Fts3DeferredToken *pDeferred; /* Deferred token object for this token */ + Fts3MultiSegReader *pSegcsr; /* Segment-reader for this token */ +}; + +struct Fts3Phrase { + /* Cache of doclist for this phrase. */ + Fts3Doclist doclist; + int bIncr; /* True if doclist is loaded incrementally */ + int iDoclistToken; + + /* Used by sqlite3Fts3EvalPhrasePoslist() if this is a descendent of an + ** OR condition. */ + char *pOrPoslist; + i64 iOrDocid; + + /* Variables below this point are populated by fts3_expr.c when parsing + ** a MATCH expression. Everything above is part of the evaluation phase. + */ + int nToken; /* Number of tokens in the phrase */ + int iColumn; /* Index of column this phrase must match */ + Fts3PhraseToken aToken[1]; /* One entry for each token in the phrase */ +}; + +/* +** A tree of these objects forms the RHS of a MATCH operator. +** +** If Fts3Expr.eType is FTSQUERY_PHRASE and isLoaded is true, then aDoclist +** points to a malloced buffer, size nDoclist bytes, containing the results +** of this phrase query in FTS3 doclist format. As usual, the initial +** "Length" field found in doclists stored on disk is omitted from this +** buffer. +** +** Variable aMI is used only for FTSQUERY_NEAR nodes to store the global +** matchinfo data. If it is not NULL, it points to an array of size nCol*3, +** where nCol is the number of columns in the queried FTS table. The array +** is populated as follows: +** +** aMI[iCol*3 + 0] = Undefined +** aMI[iCol*3 + 1] = Number of occurrences +** aMI[iCol*3 + 2] = Number of rows containing at least one instance +** +** The aMI array is allocated using sqlite3_malloc(). It should be freed +** when the expression node is. +*/ +struct Fts3Expr { + int eType; /* One of the FTSQUERY_XXX values defined below */ + int nNear; /* Valid if eType==FTSQUERY_NEAR */ + Fts3Expr *pParent; /* pParent->pLeft==this or pParent->pRight==this */ + Fts3Expr *pLeft; /* Left operand */ + Fts3Expr *pRight; /* Right operand */ + Fts3Phrase *pPhrase; /* Valid if eType==FTSQUERY_PHRASE */ + + /* The following are used by the fts3_eval.c module. */ + sqlite3_int64 iDocid; /* Current docid */ + u8 bEof; /* True this expression is at EOF already */ + u8 bStart; /* True if iDocid is valid */ + u8 bDeferred; /* True if this expression is entirely deferred */ + + /* The following are used by the fts3_snippet.c module. */ + int iPhrase; /* Index of this phrase in matchinfo() results */ + u32 *aMI; /* See above */ +}; + +/* +** Candidate values for Fts3Query.eType. Note that the order of the first +** four values is in order of precedence when parsing expressions. For +** example, the following: +** +** "a OR b AND c NOT d NEAR e" +** +** is equivalent to: +** +** "a OR (b AND (c NOT (d NEAR e)))" +*/ +#define FTSQUERY_NEAR 1 +#define FTSQUERY_NOT 2 +#define FTSQUERY_AND 3 +#define FTSQUERY_OR 4 +#define FTSQUERY_PHRASE 5 + + +/* fts3_write.c */ +SQLITE_PRIVATE int sqlite3Fts3UpdateMethod(sqlite3_vtab*,int,sqlite3_value**,sqlite3_int64*); +SQLITE_PRIVATE int sqlite3Fts3PendingTermsFlush(Fts3Table *); +SQLITE_PRIVATE void sqlite3Fts3PendingTermsClear(Fts3Table *); +SQLITE_PRIVATE int sqlite3Fts3Optimize(Fts3Table *); +SQLITE_PRIVATE int sqlite3Fts3SegReaderNew(int, int, sqlite3_int64, + sqlite3_int64, sqlite3_int64, const char *, int, Fts3SegReader**); +SQLITE_PRIVATE int sqlite3Fts3SegReaderPending( + Fts3Table*,int,const char*,int,int,Fts3SegReader**); +SQLITE_PRIVATE void sqlite3Fts3SegReaderFree(Fts3SegReader *); +SQLITE_PRIVATE int sqlite3Fts3AllSegdirs(Fts3Table*, int, int, int, sqlite3_stmt **); +SQLITE_PRIVATE int sqlite3Fts3ReadBlock(Fts3Table*, sqlite3_int64, char **, int*, int*); + +SQLITE_PRIVATE int sqlite3Fts3SelectDoctotal(Fts3Table *, sqlite3_stmt **); +SQLITE_PRIVATE int sqlite3Fts3SelectDocsize(Fts3Table *, sqlite3_int64, sqlite3_stmt **); + +#ifndef SQLITE_DISABLE_FTS4_DEFERRED +SQLITE_PRIVATE void sqlite3Fts3FreeDeferredTokens(Fts3Cursor *); +SQLITE_PRIVATE int sqlite3Fts3DeferToken(Fts3Cursor *, Fts3PhraseToken *, int); +SQLITE_PRIVATE int sqlite3Fts3CacheDeferredDoclists(Fts3Cursor *); +SQLITE_PRIVATE void sqlite3Fts3FreeDeferredDoclists(Fts3Cursor *); +SQLITE_PRIVATE int sqlite3Fts3DeferredTokenList(Fts3DeferredToken *, char **, int *); +#else +# define sqlite3Fts3FreeDeferredTokens(x) +# define sqlite3Fts3DeferToken(x,y,z) SQLITE_OK +# define sqlite3Fts3CacheDeferredDoclists(x) SQLITE_OK +# define sqlite3Fts3FreeDeferredDoclists(x) +# define sqlite3Fts3DeferredTokenList(x,y,z) SQLITE_OK +#endif + +SQLITE_PRIVATE void sqlite3Fts3SegmentsClose(Fts3Table *); +SQLITE_PRIVATE int sqlite3Fts3MaxLevel(Fts3Table *, int *); + +/* Special values interpreted by sqlite3SegReaderCursor() */ +#define FTS3_SEGCURSOR_PENDING -1 +#define FTS3_SEGCURSOR_ALL -2 + +SQLITE_PRIVATE int sqlite3Fts3SegReaderStart(Fts3Table*, Fts3MultiSegReader*, Fts3SegFilter*); +SQLITE_PRIVATE int sqlite3Fts3SegReaderStep(Fts3Table *, Fts3MultiSegReader *); +SQLITE_PRIVATE void sqlite3Fts3SegReaderFinish(Fts3MultiSegReader *); + +SQLITE_PRIVATE int sqlite3Fts3SegReaderCursor(Fts3Table *, + int, int, int, const char *, int, int, int, Fts3MultiSegReader *); + +/* Flags allowed as part of the 4th argument to SegmentReaderIterate() */ +#define FTS3_SEGMENT_REQUIRE_POS 0x00000001 +#define FTS3_SEGMENT_IGNORE_EMPTY 0x00000002 +#define FTS3_SEGMENT_COLUMN_FILTER 0x00000004 +#define FTS3_SEGMENT_PREFIX 0x00000008 +#define FTS3_SEGMENT_SCAN 0x00000010 +#define FTS3_SEGMENT_FIRST 0x00000020 + +/* Type passed as 4th argument to SegmentReaderIterate() */ +struct Fts3SegFilter { + const char *zTerm; + int nTerm; + int iCol; + int flags; +}; + +struct Fts3MultiSegReader { + /* Used internally by sqlite3Fts3SegReaderXXX() calls */ + Fts3SegReader **apSegment; /* Array of Fts3SegReader objects */ + int nSegment; /* Size of apSegment array */ + int nAdvance; /* How many seg-readers to advance */ + Fts3SegFilter *pFilter; /* Pointer to filter object */ + char *aBuffer; /* Buffer to merge doclists in */ + i64 nBuffer; /* Allocated size of aBuffer[] in bytes */ + + int iColFilter; /* If >=0, filter for this column */ + int bRestart; + + /* Used by fts3.c only. */ + int nCost; /* Cost of running iterator */ + int bLookup; /* True if a lookup of a single entry. */ + + /* Output values. Valid only after Fts3SegReaderStep() returns SQLITE_ROW. */ + char *zTerm; /* Pointer to term buffer */ + int nTerm; /* Size of zTerm in bytes */ + char *aDoclist; /* Pointer to doclist buffer */ + int nDoclist; /* Size of aDoclist[] in bytes */ +}; + +SQLITE_PRIVATE int sqlite3Fts3Incrmerge(Fts3Table*,int,int); + +#define fts3GetVarint32(p, piVal) ( \ + (*(u8*)(p)&0x80) ? sqlite3Fts3GetVarint32(p, piVal) : (*piVal=*(u8*)(p), 1) \ +) + +/* fts3.c */ +SQLITE_PRIVATE void sqlite3Fts3ErrMsg(char**,const char*,...); +SQLITE_PRIVATE int sqlite3Fts3PutVarint(char *, sqlite3_int64); +SQLITE_PRIVATE int sqlite3Fts3GetVarint(const char *, sqlite_int64 *); +SQLITE_PRIVATE int sqlite3Fts3GetVarintU(const char *, sqlite_uint64 *); +SQLITE_PRIVATE int sqlite3Fts3GetVarintBounded(const char*,const char*,sqlite3_int64*); +SQLITE_PRIVATE int sqlite3Fts3GetVarint32(const char *, int *); +SQLITE_PRIVATE int sqlite3Fts3VarintLen(sqlite3_uint64); +SQLITE_PRIVATE void sqlite3Fts3Dequote(char *); +SQLITE_PRIVATE void sqlite3Fts3DoclistPrev(int,char*,int,char**,sqlite3_int64*,int*,u8*); +SQLITE_PRIVATE int sqlite3Fts3EvalPhraseStats(Fts3Cursor *, Fts3Expr *, u32 *); +SQLITE_PRIVATE int sqlite3Fts3FirstFilter(sqlite3_int64, char *, int, char *); +SQLITE_PRIVATE void sqlite3Fts3CreateStatTable(int*, Fts3Table*); +SQLITE_PRIVATE int sqlite3Fts3EvalTestDeferred(Fts3Cursor *pCsr, int *pRc); +SQLITE_PRIVATE int sqlite3Fts3ReadInt(const char *z, int *pnOut); + +/* fts3_tokenizer.c */ +SQLITE_PRIVATE const char *sqlite3Fts3NextToken(const char *, int *); +SQLITE_PRIVATE int sqlite3Fts3InitHashTable(sqlite3 *, Fts3Hash *, const char *); +SQLITE_PRIVATE int sqlite3Fts3InitTokenizer(Fts3Hash *pHash, const char *, + sqlite3_tokenizer **, char ** +); +SQLITE_PRIVATE int sqlite3Fts3IsIdChar(char); + +/* fts3_snippet.c */ +SQLITE_PRIVATE void sqlite3Fts3Offsets(sqlite3_context*, Fts3Cursor*); +SQLITE_PRIVATE void sqlite3Fts3Snippet(sqlite3_context *, Fts3Cursor *, const char *, + const char *, const char *, int, int +); +SQLITE_PRIVATE void sqlite3Fts3Matchinfo(sqlite3_context *, Fts3Cursor *, const char *); +SQLITE_PRIVATE void sqlite3Fts3MIBufferFree(MatchinfoBuffer *p); + +/* fts3_expr.c */ +SQLITE_PRIVATE int sqlite3Fts3ExprParse(sqlite3_tokenizer *, int, + char **, int, int, int, const char *, int, Fts3Expr **, char ** +); +SQLITE_PRIVATE void sqlite3Fts3ExprFree(Fts3Expr *); +#ifdef SQLITE_TEST +SQLITE_PRIVATE int sqlite3Fts3ExprInitTestInterface(sqlite3 *db, Fts3Hash*); +SQLITE_PRIVATE int sqlite3Fts3InitTerm(sqlite3 *db); +#endif +SQLITE_PRIVATE void *sqlite3Fts3MallocZero(i64 nByte); + +SQLITE_PRIVATE int sqlite3Fts3OpenTokenizer(sqlite3_tokenizer *, int, const char *, int, + sqlite3_tokenizer_cursor ** +); + +/* fts3_aux.c */ +SQLITE_PRIVATE int sqlite3Fts3InitAux(sqlite3 *db); + +SQLITE_PRIVATE void sqlite3Fts3EvalPhraseCleanup(Fts3Phrase *); + +SQLITE_PRIVATE int sqlite3Fts3MsrIncrStart( + Fts3Table*, Fts3MultiSegReader*, int, const char*, int); +SQLITE_PRIVATE int sqlite3Fts3MsrIncrNext( + Fts3Table *, Fts3MultiSegReader *, sqlite3_int64 *, char **, int *); +SQLITE_PRIVATE int sqlite3Fts3EvalPhrasePoslist(Fts3Cursor *, Fts3Expr *, int iCol, char **); +SQLITE_PRIVATE int sqlite3Fts3MsrOvfl(Fts3Cursor *, Fts3MultiSegReader *, int *); +SQLITE_PRIVATE int sqlite3Fts3MsrIncrRestart(Fts3MultiSegReader *pCsr); + +/* fts3_tokenize_vtab.c */ +SQLITE_PRIVATE int sqlite3Fts3InitTok(sqlite3*, Fts3Hash *, void(*xDestroy)(void*)); + +/* fts3_unicode2.c (functions generated by parsing unicode text files) */ +#ifndef SQLITE_DISABLE_FTS3_UNICODE +SQLITE_PRIVATE int sqlite3FtsUnicodeFold(int, int); +SQLITE_PRIVATE int sqlite3FtsUnicodeIsalnum(int); +SQLITE_PRIVATE int sqlite3FtsUnicodeIsdiacritic(int); +#endif + +SQLITE_PRIVATE int sqlite3Fts3ExprIterate(Fts3Expr*, int (*x)(Fts3Expr*,int,void*), void*); + +#endif /* !SQLITE_CORE || SQLITE_ENABLE_FTS3 */ +#endif /* _FTSINT_H */ + +/************** End of fts3Int.h *********************************************/ +/************** Continuing where we left off in fts3.c ***********************/ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +#if defined(SQLITE_ENABLE_FTS3) && !defined(SQLITE_CORE) +# define SQLITE_CORE 1 +#endif + +/* #include */ +/* #include */ +/* #include */ +/* #include */ +/* #include */ +/* #include */ + +/* #include "fts3.h" */ +#ifndef SQLITE_CORE +/* # include "sqlite3ext.h" */ + SQLITE_EXTENSION_INIT1 +#endif + +typedef struct Fts3HashWrapper Fts3HashWrapper; +struct Fts3HashWrapper { + Fts3Hash hash; /* Hash table */ + int nRef; /* Number of pointers to this object */ +}; + +static int fts3EvalNext(Fts3Cursor *pCsr); +static int fts3EvalStart(Fts3Cursor *pCsr); +static int fts3TermSegReaderCursor( + Fts3Cursor *, const char *, int, int, Fts3MultiSegReader **); + +/* +** This variable is set to false when running tests for which the on disk +** structures should not be corrupt. Otherwise, true. If it is false, extra +** assert() conditions in the fts3 code are activated - conditions that are +** only true if it is guaranteed that the fts3 database is not corrupt. +*/ +#ifdef SQLITE_DEBUG +SQLITE_API int sqlite3_fts3_may_be_corrupt = 1; +#endif + +/* +** Write a 64-bit variable-length integer to memory starting at p[0]. +** The length of data written will be between 1 and FTS3_VARINT_MAX bytes. +** The number of bytes written is returned. +*/ +SQLITE_PRIVATE int sqlite3Fts3PutVarint(char *p, sqlite_int64 v){ + unsigned char *q = (unsigned char *) p; + sqlite_uint64 vu = v; + do{ + *q++ = (unsigned char) ((vu & 0x7f) | 0x80); + vu >>= 7; + }while( vu!=0 ); + q[-1] &= 0x7f; /* turn off high bit in final byte */ + assert( q - (unsigned char *)p <= FTS3_VARINT_MAX ); + return (int) (q - (unsigned char *)p); +} + +#define GETVARINT_STEP(v, ptr, shift, mask1, mask2, var, ret) \ + v = (v & mask1) | ( (*(const unsigned char*)(ptr++)) << shift ); \ + if( (v & mask2)==0 ){ var = v; return ret; } +#define GETVARINT_INIT(v, ptr, shift, mask1, mask2, var, ret) \ + v = (*ptr++); \ + if( (v & mask2)==0 ){ var = v; return ret; } + +SQLITE_PRIVATE int sqlite3Fts3GetVarintU(const char *pBuf, sqlite_uint64 *v){ + const unsigned char *p = (const unsigned char*)pBuf; + const unsigned char *pStart = p; + u32 a; + u64 b; + int shift; + + GETVARINT_INIT(a, p, 0, 0x00, 0x80, *v, 1); + GETVARINT_STEP(a, p, 7, 0x7F, 0x4000, *v, 2); + GETVARINT_STEP(a, p, 14, 0x3FFF, 0x200000, *v, 3); + GETVARINT_STEP(a, p, 21, 0x1FFFFF, 0x10000000, *v, 4); + b = (a & 0x0FFFFFFF ); + + for(shift=28; shift<=63; shift+=7){ + u64 c = *p++; + b += (c&0x7F) << shift; + if( (c & 0x80)==0 ) break; + } + *v = b; + return (int)(p - pStart); +} + +/* +** Read a 64-bit variable-length integer from memory starting at p[0]. +** Return the number of bytes read, or 0 on error. +** The value is stored in *v. +*/ +SQLITE_PRIVATE int sqlite3Fts3GetVarint(const char *pBuf, sqlite_int64 *v){ + return sqlite3Fts3GetVarintU(pBuf, (sqlite3_uint64*)v); +} + +/* +** Read a 64-bit variable-length integer from memory starting at p[0] and +** not extending past pEnd[-1]. +** Return the number of bytes read, or 0 on error. +** The value is stored in *v. +*/ +SQLITE_PRIVATE int sqlite3Fts3GetVarintBounded( + const char *pBuf, + const char *pEnd, + sqlite_int64 *v +){ + const unsigned char *p = (const unsigned char*)pBuf; + const unsigned char *pStart = p; + const unsigned char *pX = (const unsigned char*)pEnd; + u64 b = 0; + int shift; + for(shift=0; shift<=63; shift+=7){ + u64 c = p=0 ); + return 5; +} + +/* +** Return the number of bytes required to encode v as a varint +*/ +SQLITE_PRIVATE int sqlite3Fts3VarintLen(sqlite3_uint64 v){ + int i = 0; + do{ + i++; + v >>= 7; + }while( v!=0 ); + return i; +} + +/* +** Convert an SQL-style quoted string into a normal string by removing +** the quote characters. The conversion is done in-place. If the +** input does not begin with a quote character, then this routine +** is a no-op. +** +** Examples: +** +** "abc" becomes abc +** 'xyz' becomes xyz +** [pqr] becomes pqr +** `mno` becomes mno +** +*/ +SQLITE_PRIVATE void sqlite3Fts3Dequote(char *z){ + char quote; /* Quote character (if any ) */ + + quote = z[0]; + if( quote=='[' || quote=='\'' || quote=='"' || quote=='`' ){ + int iIn = 1; /* Index of next byte to read from input */ + int iOut = 0; /* Index of next byte to write to output */ + + /* If the first byte was a '[', then the close-quote character is a ']' */ + if( quote=='[' ) quote = ']'; + + while( z[iIn] ){ + if( z[iIn]==quote ){ + if( z[iIn+1]!=quote ) break; + z[iOut++] = quote; + iIn += 2; + }else{ + z[iOut++] = z[iIn++]; + } + } + z[iOut] = '\0'; + } +} + +/* +** Read a single varint from the doclist at *pp and advance *pp to point +** to the first byte past the end of the varint. Add the value of the varint +** to *pVal. +*/ +static void fts3GetDeltaVarint(char **pp, sqlite3_int64 *pVal){ + sqlite3_int64 iVal; + *pp += sqlite3Fts3GetVarint(*pp, &iVal); + *pVal += iVal; +} + +/* +** When this function is called, *pp points to the first byte following a +** varint that is part of a doclist (or position-list, or any other list +** of varints). This function moves *pp to point to the start of that varint, +** and sets *pVal by the varint value. +** +** Argument pStart points to the first byte of the doclist that the +** varint is part of. +*/ +static void fts3GetReverseVarint( + char **pp, + char *pStart, + sqlite3_int64 *pVal +){ + sqlite3_int64 iVal; + char *p; + + /* Pointer p now points at the first byte past the varint we are + ** interested in. So, unless the doclist is corrupt, the 0x80 bit is + ** clear on character p[-1]. */ + for(p = (*pp)-2; p>=pStart && *p&0x80; p--); + p++; + *pp = p; + + sqlite3Fts3GetVarint(p, &iVal); + *pVal = iVal; +} + +/* +** The xDisconnect() virtual table method. +*/ +static int fts3DisconnectMethod(sqlite3_vtab *pVtab){ + Fts3Table *p = (Fts3Table *)pVtab; + int i; + + assert( p->nPendingData==0 ); + assert( p->pSegments==0 ); + + /* Free any prepared statements held */ + sqlite3_finalize(p->pSeekStmt); + for(i=0; iaStmt); i++){ + sqlite3_finalize(p->aStmt[i]); + } + sqlite3_free(p->zSegmentsTbl); + sqlite3_free(p->zReadExprlist); + sqlite3_free(p->zWriteExprlist); + sqlite3_free(p->zContentTbl); + sqlite3_free(p->zLanguageid); + + /* Invoke the tokenizer destructor to free the tokenizer. */ + p->pTokenizer->pModule->xDestroy(p->pTokenizer); + + sqlite3_free(p); + return SQLITE_OK; +} + +/* +** Write an error message into *pzErr +*/ +SQLITE_PRIVATE void sqlite3Fts3ErrMsg(char **pzErr, const char *zFormat, ...){ + va_list ap; + sqlite3_free(*pzErr); + va_start(ap, zFormat); + *pzErr = sqlite3_vmprintf(zFormat, ap); + va_end(ap); +} + +/* +** Construct one or more SQL statements from the format string given +** and then evaluate those statements. The success code is written +** into *pRc. +** +** If *pRc is initially non-zero then this routine is a no-op. +*/ +static void fts3DbExec( + int *pRc, /* Success code */ + sqlite3 *db, /* Database in which to run SQL */ + const char *zFormat, /* Format string for SQL */ + ... /* Arguments to the format string */ +){ + va_list ap; + char *zSql; + if( *pRc ) return; + va_start(ap, zFormat); + zSql = sqlite3_vmprintf(zFormat, ap); + va_end(ap); + if( zSql==0 ){ + *pRc = SQLITE_NOMEM; + }else{ + *pRc = sqlite3_exec(db, zSql, 0, 0, 0); + sqlite3_free(zSql); + } +} + +/* +** The xDestroy() virtual table method. +*/ +static int fts3DestroyMethod(sqlite3_vtab *pVtab){ + Fts3Table *p = (Fts3Table *)pVtab; + int rc = SQLITE_OK; /* Return code */ + const char *zDb = p->zDb; /* Name of database (e.g. "main", "temp") */ + sqlite3 *db = p->db; /* Database handle */ + + /* Drop the shadow tables */ + fts3DbExec(&rc, db, + "DROP TABLE IF EXISTS %Q.'%q_segments';" + "DROP TABLE IF EXISTS %Q.'%q_segdir';" + "DROP TABLE IF EXISTS %Q.'%q_docsize';" + "DROP TABLE IF EXISTS %Q.'%q_stat';" + "%s DROP TABLE IF EXISTS %Q.'%q_content';", + zDb, p->zName, + zDb, p->zName, + zDb, p->zName, + zDb, p->zName, + (p->zContentTbl ? "--" : ""), zDb,p->zName + ); + + /* If everything has worked, invoke fts3DisconnectMethod() to free the + ** memory associated with the Fts3Table structure and return SQLITE_OK. + ** Otherwise, return an SQLite error code. + */ + return (rc==SQLITE_OK ? fts3DisconnectMethod(pVtab) : rc); +} + + +/* +** Invoke sqlite3_declare_vtab() to declare the schema for the FTS3 table +** passed as the first argument. This is done as part of the xConnect() +** and xCreate() methods. +** +** If *pRc is non-zero when this function is called, it is a no-op. +** Otherwise, if an error occurs, an SQLite error code is stored in *pRc +** before returning. +*/ +static void fts3DeclareVtab(int *pRc, Fts3Table *p){ + if( *pRc==SQLITE_OK ){ + int i; /* Iterator variable */ + int rc; /* Return code */ + char *zSql; /* SQL statement passed to declare_vtab() */ + char *zCols; /* List of user defined columns */ + const char *zLanguageid; + + zLanguageid = (p->zLanguageid ? p->zLanguageid : "__langid"); + sqlite3_vtab_config(p->db, SQLITE_VTAB_CONSTRAINT_SUPPORT, 1); + + /* Create a list of user columns for the virtual table */ + zCols = sqlite3_mprintf("%Q, ", p->azColumn[0]); + for(i=1; zCols && inColumn; i++){ + zCols = sqlite3_mprintf("%z%Q, ", zCols, p->azColumn[i]); + } + + /* Create the whole "CREATE TABLE" statement to pass to SQLite */ + zSql = sqlite3_mprintf( + "CREATE TABLE x(%s %Q HIDDEN, docid HIDDEN, %Q HIDDEN)", + zCols, p->zName, zLanguageid + ); + if( !zCols || !zSql ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_declare_vtab(p->db, zSql); + } + + sqlite3_free(zSql); + sqlite3_free(zCols); + *pRc = rc; + } +} + +/* +** Create the %_stat table if it does not already exist. +*/ +SQLITE_PRIVATE void sqlite3Fts3CreateStatTable(int *pRc, Fts3Table *p){ + fts3DbExec(pRc, p->db, + "CREATE TABLE IF NOT EXISTS %Q.'%q_stat'" + "(id INTEGER PRIMARY KEY, value BLOB);", + p->zDb, p->zName + ); + if( (*pRc)==SQLITE_OK ) p->bHasStat = 1; +} + +/* +** Create the backing store tables (%_content, %_segments and %_segdir) +** required by the FTS3 table passed as the only argument. This is done +** as part of the vtab xCreate() method. +** +** If the p->bHasDocsize boolean is true (indicating that this is an +** FTS4 table, not an FTS3 table) then also create the %_docsize and +** %_stat tables required by FTS4. +*/ +static int fts3CreateTables(Fts3Table *p){ + int rc = SQLITE_OK; /* Return code */ + int i; /* Iterator variable */ + sqlite3 *db = p->db; /* The database connection */ + + if( p->zContentTbl==0 ){ + const char *zLanguageid = p->zLanguageid; + char *zContentCols; /* Columns of %_content table */ + + /* Create a list of user columns for the content table */ + zContentCols = sqlite3_mprintf("docid INTEGER PRIMARY KEY"); + for(i=0; zContentCols && inColumn; i++){ + char *z = p->azColumn[i]; + zContentCols = sqlite3_mprintf("%z, 'c%d%q'", zContentCols, i, z); + } + if( zLanguageid && zContentCols ){ + zContentCols = sqlite3_mprintf("%z, langid", zContentCols, zLanguageid); + } + if( zContentCols==0 ) rc = SQLITE_NOMEM; + + /* Create the content table */ + fts3DbExec(&rc, db, + "CREATE TABLE %Q.'%q_content'(%s)", + p->zDb, p->zName, zContentCols + ); + sqlite3_free(zContentCols); + } + + /* Create other tables */ + fts3DbExec(&rc, db, + "CREATE TABLE %Q.'%q_segments'(blockid INTEGER PRIMARY KEY, block BLOB);", + p->zDb, p->zName + ); + fts3DbExec(&rc, db, + "CREATE TABLE %Q.'%q_segdir'(" + "level INTEGER," + "idx INTEGER," + "start_block INTEGER," + "leaves_end_block INTEGER," + "end_block INTEGER," + "root BLOB," + "PRIMARY KEY(level, idx)" + ");", + p->zDb, p->zName + ); + if( p->bHasDocsize ){ + fts3DbExec(&rc, db, + "CREATE TABLE %Q.'%q_docsize'(docid INTEGER PRIMARY KEY, size BLOB);", + p->zDb, p->zName + ); + } + assert( p->bHasStat==p->bFts4 ); + if( p->bHasStat ){ + sqlite3Fts3CreateStatTable(&rc, p); + } + return rc; +} + +/* +** Store the current database page-size in bytes in p->nPgsz. +** +** If *pRc is non-zero when this function is called, it is a no-op. +** Otherwise, if an error occurs, an SQLite error code is stored in *pRc +** before returning. +*/ +static void fts3DatabasePageSize(int *pRc, Fts3Table *p){ + if( *pRc==SQLITE_OK ){ + int rc; /* Return code */ + char *zSql; /* SQL text "PRAGMA %Q.page_size" */ + sqlite3_stmt *pStmt; /* Compiled "PRAGMA %Q.page_size" statement */ + + zSql = sqlite3_mprintf("PRAGMA %Q.page_size", p->zDb); + if( !zSql ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0); + if( rc==SQLITE_OK ){ + sqlite3_step(pStmt); + p->nPgsz = sqlite3_column_int(pStmt, 0); + rc = sqlite3_finalize(pStmt); + }else if( rc==SQLITE_AUTH ){ + p->nPgsz = 1024; + rc = SQLITE_OK; + } + } + assert( p->nPgsz>0 || rc!=SQLITE_OK ); + sqlite3_free(zSql); + *pRc = rc; + } +} + +/* +** "Special" FTS4 arguments are column specifications of the following form: +** +** = +** +** There may not be whitespace surrounding the "=" character. The +** term may be quoted, but the may not. +*/ +static int fts3IsSpecialColumn( + const char *z, + int *pnKey, + char **pzValue +){ + char *zValue; + const char *zCsr = z; + + while( *zCsr!='=' ){ + if( *zCsr=='\0' ) return 0; + zCsr++; + } + + *pnKey = (int)(zCsr-z); + zValue = sqlite3_mprintf("%s", &zCsr[1]); + if( zValue ){ + sqlite3Fts3Dequote(zValue); + } + *pzValue = zValue; + return 1; +} + +/* +** Append the output of a printf() style formatting to an existing string. +*/ +static void fts3Appendf( + int *pRc, /* IN/OUT: Error code */ + char **pz, /* IN/OUT: Pointer to string buffer */ + const char *zFormat, /* Printf format string to append */ + ... /* Arguments for printf format string */ +){ + if( *pRc==SQLITE_OK ){ + va_list ap; + char *z; + va_start(ap, zFormat); + z = sqlite3_vmprintf(zFormat, ap); + va_end(ap); + if( z && *pz ){ + char *z2 = sqlite3_mprintf("%s%s", *pz, z); + sqlite3_free(z); + z = z2; + } + if( z==0 ) *pRc = SQLITE_NOMEM; + sqlite3_free(*pz); + *pz = z; + } +} + +/* +** Return a copy of input string zInput enclosed in double-quotes (") and +** with all double quote characters escaped. For example: +** +** fts3QuoteId("un \"zip\"") -> "un \"\"zip\"\"" +** +** The pointer returned points to memory obtained from sqlite3_malloc(). It +** is the callers responsibility to call sqlite3_free() to release this +** memory. +*/ +static char *fts3QuoteId(char const *zInput){ + sqlite3_int64 nRet; + char *zRet; + nRet = 2 + (int)strlen(zInput)*2 + 1; + zRet = sqlite3_malloc64(nRet); + if( zRet ){ + int i; + char *z = zRet; + *(z++) = '"'; + for(i=0; zInput[i]; i++){ + if( zInput[i]=='"' ) *(z++) = '"'; + *(z++) = zInput[i]; + } + *(z++) = '"'; + *(z++) = '\0'; + } + return zRet; +} + +/* +** Return a list of comma separated SQL expressions and a FROM clause that +** could be used in a SELECT statement such as the following: +** +** SELECT FROM %_content AS x ... +** +** to return the docid, followed by each column of text data in order +** from left to write. If parameter zFunc is not NULL, then instead of +** being returned directly each column of text data is passed to an SQL +** function named zFunc first. For example, if zFunc is "unzip" and the +** table has the three user-defined columns "a", "b", and "c", the following +** string is returned: +** +** "docid, unzip(x.'a'), unzip(x.'b'), unzip(x.'c') FROM %_content AS x" +** +** The pointer returned points to a buffer allocated by sqlite3_malloc(). It +** is the responsibility of the caller to eventually free it. +** +** If *pRc is not SQLITE_OK when this function is called, it is a no-op (and +** a NULL pointer is returned). Otherwise, if an OOM error is encountered +** by this function, NULL is returned and *pRc is set to SQLITE_NOMEM. If +** no error occurs, *pRc is left unmodified. +*/ +static char *fts3ReadExprList(Fts3Table *p, const char *zFunc, int *pRc){ + char *zRet = 0; + char *zFree = 0; + char *zFunction; + int i; + + if( p->zContentTbl==0 ){ + if( !zFunc ){ + zFunction = ""; + }else{ + zFree = zFunction = fts3QuoteId(zFunc); + } + fts3Appendf(pRc, &zRet, "docid"); + for(i=0; inColumn; i++){ + fts3Appendf(pRc, &zRet, ",%s(x.'c%d%q')", zFunction, i, p->azColumn[i]); + } + if( p->zLanguageid ){ + fts3Appendf(pRc, &zRet, ", x.%Q", "langid"); + } + sqlite3_free(zFree); + }else{ + fts3Appendf(pRc, &zRet, "rowid"); + for(i=0; inColumn; i++){ + fts3Appendf(pRc, &zRet, ", x.'%q'", p->azColumn[i]); + } + if( p->zLanguageid ){ + fts3Appendf(pRc, &zRet, ", x.%Q", p->zLanguageid); + } + } + fts3Appendf(pRc, &zRet, " FROM '%q'.'%q%s' AS x", + p->zDb, + (p->zContentTbl ? p->zContentTbl : p->zName), + (p->zContentTbl ? "" : "_content") + ); + return zRet; +} + +/* +** Return a list of N comma separated question marks, where N is the number +** of columns in the %_content table (one for the docid plus one for each +** user-defined text column). +** +** If argument zFunc is not NULL, then all but the first question mark +** is preceded by zFunc and an open bracket, and followed by a closed +** bracket. For example, if zFunc is "zip" and the FTS3 table has three +** user-defined text columns, the following string is returned: +** +** "?, zip(?), zip(?), zip(?)" +** +** The pointer returned points to a buffer allocated by sqlite3_malloc(). It +** is the responsibility of the caller to eventually free it. +** +** If *pRc is not SQLITE_OK when this function is called, it is a no-op (and +** a NULL pointer is returned). Otherwise, if an OOM error is encountered +** by this function, NULL is returned and *pRc is set to SQLITE_NOMEM. If +** no error occurs, *pRc is left unmodified. +*/ +static char *fts3WriteExprList(Fts3Table *p, const char *zFunc, int *pRc){ + char *zRet = 0; + char *zFree = 0; + char *zFunction; + int i; + + if( !zFunc ){ + zFunction = ""; + }else{ + zFree = zFunction = fts3QuoteId(zFunc); + } + fts3Appendf(pRc, &zRet, "?"); + for(i=0; inColumn; i++){ + fts3Appendf(pRc, &zRet, ",%s(?)", zFunction); + } + if( p->zLanguageid ){ + fts3Appendf(pRc, &zRet, ", ?"); + } + sqlite3_free(zFree); + return zRet; +} + +/* +** Buffer z contains a positive integer value encoded as utf-8 text. +** Decode this value and store it in *pnOut, returning the number of bytes +** consumed. If an overflow error occurs return a negative value. +*/ +SQLITE_PRIVATE int sqlite3Fts3ReadInt(const char *z, int *pnOut){ + u64 iVal = 0; + int i; + for(i=0; z[i]>='0' && z[i]<='9'; i++){ + iVal = iVal*10 + (z[i] - '0'); + if( iVal>0x7FFFFFFF ) return -1; + } + *pnOut = (int)iVal; + return i; +} + +/* +** This function interprets the string at (*pp) as a non-negative integer +** value. It reads the integer and sets *pnOut to the value read, then +** sets *pp to point to the byte immediately following the last byte of +** the integer value. +** +** Only decimal digits ('0'..'9') may be part of an integer value. +** +** If *pp does not being with a decimal digit SQLITE_ERROR is returned and +** the output value undefined. Otherwise SQLITE_OK is returned. +** +** This function is used when parsing the "prefix=" FTS4 parameter. +*/ +static int fts3GobbleInt(const char **pp, int *pnOut){ + const int MAX_NPREFIX = 10000000; + int nInt = 0; /* Output value */ + int nByte; + nByte = sqlite3Fts3ReadInt(*pp, &nInt); + if( nInt>MAX_NPREFIX ){ + nInt = 0; + } + if( nByte==0 ){ + return SQLITE_ERROR; + } + *pnOut = nInt; + *pp += nByte; + return SQLITE_OK; +} + +/* +** This function is called to allocate an array of Fts3Index structures +** representing the indexes maintained by the current FTS table. FTS tables +** always maintain the main "terms" index, but may also maintain one or +** more "prefix" indexes, depending on the value of the "prefix=" parameter +** (if any) specified as part of the CREATE VIRTUAL TABLE statement. +** +** Argument zParam is passed the value of the "prefix=" option if one was +** specified, or NULL otherwise. +** +** If no error occurs, SQLITE_OK is returned and *apIndex set to point to +** the allocated array. *pnIndex is set to the number of elements in the +** array. If an error does occur, an SQLite error code is returned. +** +** Regardless of whether or not an error is returned, it is the responsibility +** of the caller to call sqlite3_free() on the output array to free it. +*/ +static int fts3PrefixParameter( + const char *zParam, /* ABC in prefix=ABC parameter to parse */ + int *pnIndex, /* OUT: size of *apIndex[] array */ + struct Fts3Index **apIndex /* OUT: Array of indexes for this table */ +){ + struct Fts3Index *aIndex; /* Allocated array */ + int nIndex = 1; /* Number of entries in array */ + + if( zParam && zParam[0] ){ + const char *p; + nIndex++; + for(p=zParam; *p; p++){ + if( *p==',' ) nIndex++; + } + } + + aIndex = sqlite3_malloc64(sizeof(struct Fts3Index) * nIndex); + *apIndex = aIndex; + if( !aIndex ){ + return SQLITE_NOMEM; + } + + memset(aIndex, 0, sizeof(struct Fts3Index) * nIndex); + if( zParam ){ + const char *p = zParam; + int i; + for(i=1; i=0 ); + if( nPrefix==0 ){ + nIndex--; + i--; + }else{ + aIndex[i].nPrefix = nPrefix; + } + p++; + } + } + + *pnIndex = nIndex; + return SQLITE_OK; +} + +/* +** This function is called when initializing an FTS4 table that uses the +** content=xxx option. It determines the number of and names of the columns +** of the new FTS4 table. +** +** The third argument passed to this function is the value passed to the +** config=xxx option (i.e. "xxx"). This function queries the database for +** a table of that name. If found, the output variables are populated +** as follows: +** +** *pnCol: Set to the number of columns table xxx has, +** +** *pnStr: Set to the total amount of space required to store a copy +** of each columns name, including the nul-terminator. +** +** *pazCol: Set to point to an array of *pnCol strings. Each string is +** the name of the corresponding column in table xxx. The array +** and its contents are allocated using a single allocation. It +** is the responsibility of the caller to free this allocation +** by eventually passing the *pazCol value to sqlite3_free(). +** +** If the table cannot be found, an error code is returned and the output +** variables are undefined. Or, if an OOM is encountered, SQLITE_NOMEM is +** returned (and the output variables are undefined). +*/ +static int fts3ContentColumns( + sqlite3 *db, /* Database handle */ + const char *zDb, /* Name of db (i.e. "main", "temp" etc.) */ + const char *zTbl, /* Name of content table */ + const char ***pazCol, /* OUT: Malloc'd array of column names */ + int *pnCol, /* OUT: Size of array *pazCol */ + int *pnStr, /* OUT: Bytes of string content */ + char **pzErr /* OUT: error message */ +){ + int rc = SQLITE_OK; /* Return code */ + char *zSql; /* "SELECT *" statement on zTbl */ + sqlite3_stmt *pStmt = 0; /* Compiled version of zSql */ + + zSql = sqlite3_mprintf("SELECT * FROM %Q.%Q", zDb, zTbl); + if( !zSql ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0); + if( rc!=SQLITE_OK ){ + sqlite3Fts3ErrMsg(pzErr, "%s", sqlite3_errmsg(db)); + } + } + sqlite3_free(zSql); + + if( rc==SQLITE_OK ){ + const char **azCol; /* Output array */ + sqlite3_int64 nStr = 0; /* Size of all column names (incl. 0x00) */ + int nCol; /* Number of table columns */ + int i; /* Used to iterate through columns */ + + /* Loop through the returned columns. Set nStr to the number of bytes of + ** space required to store a copy of each column name, including the + ** nul-terminator byte. */ + nCol = sqlite3_column_count(pStmt); + for(i=0; i module name ("fts3" or "fts4") +** argv[1] -> database name +** argv[2] -> table name +** argv[...] -> "column name" and other module argument fields. +*/ +static int fts3InitVtab( + int isCreate, /* True for xCreate, false for xConnect */ + sqlite3 *db, /* The SQLite database connection */ + void *pAux, /* Hash table containing tokenizers */ + int argc, /* Number of elements in argv array */ + const char * const *argv, /* xCreate/xConnect argument array */ + sqlite3_vtab **ppVTab, /* Write the resulting vtab structure here */ + char **pzErr /* Write any error message here */ +){ + Fts3Hash *pHash = &((Fts3HashWrapper*)pAux)->hash; + Fts3Table *p = 0; /* Pointer to allocated vtab */ + int rc = SQLITE_OK; /* Return code */ + int i; /* Iterator variable */ + sqlite3_int64 nByte; /* Size of allocation used for *p */ + int iCol; /* Column index */ + int nString = 0; /* Bytes required to hold all column names */ + int nCol = 0; /* Number of columns in the FTS table */ + char *zCsr; /* Space for holding column names */ + int nDb; /* Bytes required to hold database name */ + int nName; /* Bytes required to hold table name */ + int isFts4 = (argv[0][3]=='4'); /* True for FTS4, false for FTS3 */ + const char **aCol; /* Array of column names */ + sqlite3_tokenizer *pTokenizer = 0; /* Tokenizer for this table */ + + int nIndex = 0; /* Size of aIndex[] array */ + struct Fts3Index *aIndex = 0; /* Array of indexes for this table */ + + /* The results of parsing supported FTS4 key=value options: */ + int bNoDocsize = 0; /* True to omit %_docsize table */ + int bDescIdx = 0; /* True to store descending indexes */ + char *zPrefix = 0; /* Prefix parameter value (or NULL) */ + char *zCompress = 0; /* compress=? parameter (or NULL) */ + char *zUncompress = 0; /* uncompress=? parameter (or NULL) */ + char *zContent = 0; /* content=? parameter (or NULL) */ + char *zLanguageid = 0; /* languageid=? parameter (or NULL) */ + char **azNotindexed = 0; /* The set of notindexed= columns */ + int nNotindexed = 0; /* Size of azNotindexed[] array */ + + assert( strlen(argv[0])==4 ); + assert( (sqlite3_strnicmp(argv[0], "fts4", 4)==0 && isFts4) + || (sqlite3_strnicmp(argv[0], "fts3", 4)==0 && !isFts4) + ); + + nDb = (int)strlen(argv[1]) + 1; + nName = (int)strlen(argv[2]) + 1; + + nByte = sizeof(const char *) * (argc-2); + aCol = (const char **)sqlite3_malloc64(nByte); + if( aCol ){ + memset((void*)aCol, 0, nByte); + azNotindexed = (char **)sqlite3_malloc64(nByte); + } + if( azNotindexed ){ + memset(azNotindexed, 0, nByte); + } + if( !aCol || !azNotindexed ){ + rc = SQLITE_NOMEM; + goto fts3_init_out; + } + + /* Loop through all of the arguments passed by the user to the FTS3/4 + ** module (i.e. all the column names and special arguments). This loop + ** does the following: + ** + ** + Figures out the number of columns the FTSX table will have, and + ** the number of bytes of space that must be allocated to store copies + ** of the column names. + ** + ** + If there is a tokenizer specification included in the arguments, + ** initializes the tokenizer pTokenizer. + */ + for(i=3; rc==SQLITE_OK && i8 + && 0==sqlite3_strnicmp(z, "tokenize", 8) + && 0==sqlite3Fts3IsIdChar(z[8]) + ){ + rc = sqlite3Fts3InitTokenizer(pHash, &z[9], &pTokenizer, pzErr); + } + + /* Check if it is an FTS4 special argument. */ + else if( isFts4 && fts3IsSpecialColumn(z, &nKey, &zVal) ){ + struct Fts4Option { + const char *zOpt; + int nOpt; + } aFts4Opt[] = { + { "matchinfo", 9 }, /* 0 -> MATCHINFO */ + { "prefix", 6 }, /* 1 -> PREFIX */ + { "compress", 8 }, /* 2 -> COMPRESS */ + { "uncompress", 10 }, /* 3 -> UNCOMPRESS */ + { "order", 5 }, /* 4 -> ORDER */ + { "content", 7 }, /* 5 -> CONTENT */ + { "languageid", 10 }, /* 6 -> LANGUAGEID */ + { "notindexed", 10 } /* 7 -> NOTINDEXED */ + }; + + int iOpt; + if( !zVal ){ + rc = SQLITE_NOMEM; + }else{ + for(iOpt=0; iOptnOpt && !sqlite3_strnicmp(z, pOp->zOpt, pOp->nOpt) ){ + break; + } + } + switch( iOpt ){ + case 0: /* MATCHINFO */ + if( strlen(zVal)!=4 || sqlite3_strnicmp(zVal, "fts3", 4) ){ + sqlite3Fts3ErrMsg(pzErr, "unrecognized matchinfo: %s", zVal); + rc = SQLITE_ERROR; + } + bNoDocsize = 1; + break; + + case 1: /* PREFIX */ + sqlite3_free(zPrefix); + zPrefix = zVal; + zVal = 0; + break; + + case 2: /* COMPRESS */ + sqlite3_free(zCompress); + zCompress = zVal; + zVal = 0; + break; + + case 3: /* UNCOMPRESS */ + sqlite3_free(zUncompress); + zUncompress = zVal; + zVal = 0; + break; + + case 4: /* ORDER */ + if( (strlen(zVal)!=3 || sqlite3_strnicmp(zVal, "asc", 3)) + && (strlen(zVal)!=4 || sqlite3_strnicmp(zVal, "desc", 4)) + ){ + sqlite3Fts3ErrMsg(pzErr, "unrecognized order: %s", zVal); + rc = SQLITE_ERROR; + } + bDescIdx = (zVal[0]=='d' || zVal[0]=='D'); + break; + + case 5: /* CONTENT */ + sqlite3_free(zContent); + zContent = zVal; + zVal = 0; + break; + + case 6: /* LANGUAGEID */ + assert( iOpt==6 ); + sqlite3_free(zLanguageid); + zLanguageid = zVal; + zVal = 0; + break; + + case 7: /* NOTINDEXED */ + azNotindexed[nNotindexed++] = zVal; + zVal = 0; + break; + + default: + assert( iOpt==SizeofArray(aFts4Opt) ); + sqlite3Fts3ErrMsg(pzErr, "unrecognized parameter: %s", z); + rc = SQLITE_ERROR; + break; + } + sqlite3_free(zVal); + } + } + + /* Otherwise, the argument is a column name. */ + else { + nString += (int)(strlen(z) + 1); + aCol[nCol++] = z; + } + } + + /* If a content=xxx option was specified, the following: + ** + ** 1. Ignore any compress= and uncompress= options. + ** + ** 2. If no column names were specified as part of the CREATE VIRTUAL + ** TABLE statement, use all columns from the content table. + */ + if( rc==SQLITE_OK && zContent ){ + sqlite3_free(zCompress); + sqlite3_free(zUncompress); + zCompress = 0; + zUncompress = 0; + if( nCol==0 ){ + sqlite3_free((void*)aCol); + aCol = 0; + rc = fts3ContentColumns(db, argv[1], zContent,&aCol,&nCol,&nString,pzErr); + + /* If a languageid= option was specified, remove the language id + ** column from the aCol[] array. */ + if( rc==SQLITE_OK && zLanguageid ){ + int j; + for(j=0; jdb = db; + p->nColumn = nCol; + p->nPendingData = 0; + p->azColumn = (char **)&p[1]; + p->pTokenizer = pTokenizer; + p->nMaxPendingData = FTS3_MAX_PENDING_DATA; + p->bHasDocsize = (isFts4 && bNoDocsize==0); + p->bHasStat = (u8)isFts4; + p->bFts4 = (u8)isFts4; + p->bDescIdx = (u8)bDescIdx; + p->nAutoincrmerge = 0xff; /* 0xff means setting unknown */ + p->zContentTbl = zContent; + p->zLanguageid = zLanguageid; + zContent = 0; + zLanguageid = 0; + TESTONLY( p->inTransaction = -1 ); + TESTONLY( p->mxSavepoint = -1 ); + + p->aIndex = (struct Fts3Index *)&p->azColumn[nCol]; + memcpy(p->aIndex, aIndex, sizeof(struct Fts3Index) * nIndex); + p->nIndex = nIndex; + for(i=0; iaIndex[i].hPending, FTS3_HASH_STRING, 1); + } + p->abNotindexed = (u8 *)&p->aIndex[nIndex]; + + /* Fill in the zName and zDb fields of the vtab structure. */ + zCsr = (char *)&p->abNotindexed[nCol]; + p->zName = zCsr; + memcpy(zCsr, argv[2], nName); + zCsr += nName; + p->zDb = zCsr; + memcpy(zCsr, argv[1], nDb); + zCsr += nDb; + + /* Fill in the azColumn array */ + for(iCol=0; iCol0 ){ + memcpy(zCsr, z, n); + } + zCsr[n] = '\0'; + sqlite3Fts3Dequote(zCsr); + p->azColumn[iCol] = zCsr; + zCsr += n+1; + assert( zCsr <= &((char *)p)[nByte] ); + } + + /* Fill in the abNotindexed array */ + for(iCol=0; iColazColumn[iCol]); + for(i=0; iazColumn[iCol], zNot, n) + ){ + p->abNotindexed[iCol] = 1; + sqlite3_free(zNot); + azNotindexed[i] = 0; + } + } + } + for(i=0; izReadExprlist = fts3ReadExprList(p, zUncompress, &rc); + p->zWriteExprlist = fts3WriteExprList(p, zCompress, &rc); + if( rc!=SQLITE_OK ) goto fts3_init_out; + + /* If this is an xCreate call, create the underlying tables in the + ** database. TODO: For xConnect(), it could verify that said tables exist. + */ + if( isCreate ){ + rc = fts3CreateTables(p); + } + + /* Check to see if a legacy fts3 table has been "upgraded" by the + ** addition of a %_stat table so that it can use incremental merge. + */ + if( !isFts4 && !isCreate ){ + p->bHasStat = 2; + } + + /* Figure out the page-size for the database. This is required in order to + ** estimate the cost of loading large doclists from the database. */ + fts3DatabasePageSize(&rc, p); + p->nNodeSize = p->nPgsz-35; + +#if defined(SQLITE_DEBUG)||defined(SQLITE_TEST) + p->nMergeCount = FTS3_MERGE_COUNT; +#endif + + /* Declare the table schema to SQLite. */ + fts3DeclareVtab(&rc, p); + +fts3_init_out: + sqlite3_free(zPrefix); + sqlite3_free(aIndex); + sqlite3_free(zCompress); + sqlite3_free(zUncompress); + sqlite3_free(zContent); + sqlite3_free(zLanguageid); + for(i=0; ipModule->xDestroy(pTokenizer); + } + }else{ + assert( p->pSegments==0 ); + *ppVTab = &p->base; + } + return rc; +} + +/* +** The xConnect() and xCreate() methods for the virtual table. All the +** work is done in function fts3InitVtab(). +*/ +static int fts3ConnectMethod( + sqlite3 *db, /* Database connection */ + void *pAux, /* Pointer to tokenizer hash table */ + int argc, /* Number of elements in argv array */ + const char * const *argv, /* xCreate/xConnect argument array */ + sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */ + char **pzErr /* OUT: sqlite3_malloc'd error message */ +){ + return fts3InitVtab(0, db, pAux, argc, argv, ppVtab, pzErr); +} +static int fts3CreateMethod( + sqlite3 *db, /* Database connection */ + void *pAux, /* Pointer to tokenizer hash table */ + int argc, /* Number of elements in argv array */ + const char * const *argv, /* xCreate/xConnect argument array */ + sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */ + char **pzErr /* OUT: sqlite3_malloc'd error message */ +){ + return fts3InitVtab(1, db, pAux, argc, argv, ppVtab, pzErr); +} + +/* +** Set the pIdxInfo->estimatedRows variable to nRow. Unless this +** extension is currently being used by a version of SQLite too old to +** support estimatedRows. In that case this function is a no-op. +*/ +static void fts3SetEstimatedRows(sqlite3_index_info *pIdxInfo, i64 nRow){ +#if SQLITE_VERSION_NUMBER>=3008002 + if( sqlite3_libversion_number()>=3008002 ){ + pIdxInfo->estimatedRows = nRow; + } +#endif +} + +/* +** Set the SQLITE_INDEX_SCAN_UNIQUE flag in pIdxInfo->flags. Unless this +** extension is currently being used by a version of SQLite too old to +** support index-info flags. In that case this function is a no-op. +*/ +static void fts3SetUniqueFlag(sqlite3_index_info *pIdxInfo){ +#if SQLITE_VERSION_NUMBER>=3008012 + if( sqlite3_libversion_number()>=3008012 ){ + pIdxInfo->idxFlags |= SQLITE_INDEX_SCAN_UNIQUE; + } +#endif +} + +/* +** Implementation of the xBestIndex method for FTS3 tables. There +** are three possible strategies, in order of preference: +** +** 1. Direct lookup by rowid or docid. +** 2. Full-text search using a MATCH operator on a non-docid column. +** 3. Linear scan of %_content table. +*/ +static int fts3BestIndexMethod(sqlite3_vtab *pVTab, sqlite3_index_info *pInfo){ + Fts3Table *p = (Fts3Table *)pVTab; + int i; /* Iterator variable */ + int iCons = -1; /* Index of constraint to use */ + + int iLangidCons = -1; /* Index of langid=x constraint, if present */ + int iDocidGe = -1; /* Index of docid>=x constraint, if present */ + int iDocidLe = -1; /* Index of docid<=x constraint, if present */ + int iIdx; + + if( p->bLock ){ + return SQLITE_ERROR; + } + + /* By default use a full table scan. This is an expensive option, + ** so search through the constraints to see if a more efficient + ** strategy is possible. + */ + pInfo->idxNum = FTS3_FULLSCAN_SEARCH; + pInfo->estimatedCost = 5000000; + for(i=0; inConstraint; i++){ + int bDocid; /* True if this constraint is on docid */ + struct sqlite3_index_constraint *pCons = &pInfo->aConstraint[i]; + if( pCons->usable==0 ){ + if( pCons->op==SQLITE_INDEX_CONSTRAINT_MATCH ){ + /* There exists an unusable MATCH constraint. This means that if + ** the planner does elect to use the results of this call as part + ** of the overall query plan the user will see an "unable to use + ** function MATCH in the requested context" error. To discourage + ** this, return a very high cost here. */ + pInfo->idxNum = FTS3_FULLSCAN_SEARCH; + pInfo->estimatedCost = 1e50; + fts3SetEstimatedRows(pInfo, ((sqlite3_int64)1) << 50); + return SQLITE_OK; + } + continue; + } + + bDocid = (pCons->iColumn<0 || pCons->iColumn==p->nColumn+1); + + /* A direct lookup on the rowid or docid column. Assign a cost of 1.0. */ + if( iCons<0 && pCons->op==SQLITE_INDEX_CONSTRAINT_EQ && bDocid ){ + pInfo->idxNum = FTS3_DOCID_SEARCH; + pInfo->estimatedCost = 1.0; + iCons = i; + } + + /* A MATCH constraint. Use a full-text search. + ** + ** If there is more than one MATCH constraint available, use the first + ** one encountered. If there is both a MATCH constraint and a direct + ** rowid/docid lookup, prefer the MATCH strategy. This is done even + ** though the rowid/docid lookup is faster than a MATCH query, selecting + ** it would lead to an "unable to use function MATCH in the requested + ** context" error. + */ + if( pCons->op==SQLITE_INDEX_CONSTRAINT_MATCH + && pCons->iColumn>=0 && pCons->iColumn<=p->nColumn + ){ + pInfo->idxNum = FTS3_FULLTEXT_SEARCH + pCons->iColumn; + pInfo->estimatedCost = 2.0; + iCons = i; + } + + /* Equality constraint on the langid column */ + if( pCons->op==SQLITE_INDEX_CONSTRAINT_EQ + && pCons->iColumn==p->nColumn + 2 + ){ + iLangidCons = i; + } + + if( bDocid ){ + switch( pCons->op ){ + case SQLITE_INDEX_CONSTRAINT_GE: + case SQLITE_INDEX_CONSTRAINT_GT: + iDocidGe = i; + break; + + case SQLITE_INDEX_CONSTRAINT_LE: + case SQLITE_INDEX_CONSTRAINT_LT: + iDocidLe = i; + break; + } + } + } + + /* If using a docid=? or rowid=? strategy, set the UNIQUE flag. */ + if( pInfo->idxNum==FTS3_DOCID_SEARCH ) fts3SetUniqueFlag(pInfo); + + iIdx = 1; + if( iCons>=0 ){ + pInfo->aConstraintUsage[iCons].argvIndex = iIdx++; + pInfo->aConstraintUsage[iCons].omit = 1; + } + if( iLangidCons>=0 ){ + pInfo->idxNum |= FTS3_HAVE_LANGID; + pInfo->aConstraintUsage[iLangidCons].argvIndex = iIdx++; + } + if( iDocidGe>=0 ){ + pInfo->idxNum |= FTS3_HAVE_DOCID_GE; + pInfo->aConstraintUsage[iDocidGe].argvIndex = iIdx++; + } + if( iDocidLe>=0 ){ + pInfo->idxNum |= FTS3_HAVE_DOCID_LE; + pInfo->aConstraintUsage[iDocidLe].argvIndex = iIdx++; + } + + /* Regardless of the strategy selected, FTS can deliver rows in rowid (or + ** docid) order. Both ascending and descending are possible. + */ + if( pInfo->nOrderBy==1 ){ + struct sqlite3_index_orderby *pOrder = &pInfo->aOrderBy[0]; + if( pOrder->iColumn<0 || pOrder->iColumn==p->nColumn+1 ){ + if( pOrder->desc ){ + pInfo->idxStr = "DESC"; + }else{ + pInfo->idxStr = "ASC"; + } + pInfo->orderByConsumed = 1; + } + } + + assert( p->pSegments==0 ); + return SQLITE_OK; +} + +/* +** Implementation of xOpen method. +*/ +static int fts3OpenMethod(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCsr){ + sqlite3_vtab_cursor *pCsr; /* Allocated cursor */ + + UNUSED_PARAMETER(pVTab); + + /* Allocate a buffer large enough for an Fts3Cursor structure. If the + ** allocation succeeds, zero it and return SQLITE_OK. Otherwise, + ** if the allocation fails, return SQLITE_NOMEM. + */ + *ppCsr = pCsr = (sqlite3_vtab_cursor *)sqlite3_malloc(sizeof(Fts3Cursor)); + if( !pCsr ){ + return SQLITE_NOMEM; + } + memset(pCsr, 0, sizeof(Fts3Cursor)); + return SQLITE_OK; +} + +/* +** Finalize the statement handle at pCsr->pStmt. +** +** Or, if that statement handle is one created by fts3CursorSeekStmt(), +** and the Fts3Table.pSeekStmt slot is currently NULL, save the statement +** pointer there instead of finalizing it. +*/ +static void fts3CursorFinalizeStmt(Fts3Cursor *pCsr){ + if( pCsr->bSeekStmt ){ + Fts3Table *p = (Fts3Table *)pCsr->base.pVtab; + if( p->pSeekStmt==0 ){ + p->pSeekStmt = pCsr->pStmt; + sqlite3_reset(pCsr->pStmt); + pCsr->pStmt = 0; + } + pCsr->bSeekStmt = 0; + } + sqlite3_finalize(pCsr->pStmt); +} + +/* +** Free all resources currently held by the cursor passed as the only +** argument. +*/ +static void fts3ClearCursor(Fts3Cursor *pCsr){ + fts3CursorFinalizeStmt(pCsr); + sqlite3Fts3FreeDeferredTokens(pCsr); + sqlite3_free(pCsr->aDoclist); + sqlite3Fts3MIBufferFree(pCsr->pMIBuffer); + sqlite3Fts3ExprFree(pCsr->pExpr); + memset(&(&pCsr->base)[1], 0, sizeof(Fts3Cursor)-sizeof(sqlite3_vtab_cursor)); +} + +/* +** Close the cursor. For additional information see the documentation +** on the xClose method of the virtual table interface. +*/ +static int fts3CloseMethod(sqlite3_vtab_cursor *pCursor){ + Fts3Cursor *pCsr = (Fts3Cursor *)pCursor; + assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 ); + fts3ClearCursor(pCsr); + assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 ); + sqlite3_free(pCsr); + return SQLITE_OK; +} + +/* +** If pCsr->pStmt has not been prepared (i.e. if pCsr->pStmt==0), then +** compose and prepare an SQL statement of the form: +** +** "SELECT FROM %_content WHERE rowid = ?" +** +** (or the equivalent for a content=xxx table) and set pCsr->pStmt to +** it. If an error occurs, return an SQLite error code. +*/ +static int fts3CursorSeekStmt(Fts3Cursor *pCsr){ + int rc = SQLITE_OK; + if( pCsr->pStmt==0 ){ + Fts3Table *p = (Fts3Table *)pCsr->base.pVtab; + char *zSql; + if( p->pSeekStmt ){ + pCsr->pStmt = p->pSeekStmt; + p->pSeekStmt = 0; + }else{ + zSql = sqlite3_mprintf("SELECT %s WHERE rowid = ?", p->zReadExprlist); + if( !zSql ) return SQLITE_NOMEM; + p->bLock++; + rc = sqlite3_prepare_v3( + p->db, zSql,-1,SQLITE_PREPARE_PERSISTENT,&pCsr->pStmt,0 + ); + p->bLock--; + sqlite3_free(zSql); + } + if( rc==SQLITE_OK ) pCsr->bSeekStmt = 1; + } + return rc; +} + +/* +** Position the pCsr->pStmt statement so that it is on the row +** of the %_content table that contains the last match. Return +** SQLITE_OK on success. +*/ +static int fts3CursorSeek(sqlite3_context *pContext, Fts3Cursor *pCsr){ + int rc = SQLITE_OK; + if( pCsr->isRequireSeek ){ + rc = fts3CursorSeekStmt(pCsr); + if( rc==SQLITE_OK ){ + Fts3Table *pTab = (Fts3Table*)pCsr->base.pVtab; + pTab->bLock++; + sqlite3_bind_int64(pCsr->pStmt, 1, pCsr->iPrevId); + pCsr->isRequireSeek = 0; + if( SQLITE_ROW==sqlite3_step(pCsr->pStmt) ){ + pTab->bLock--; + return SQLITE_OK; + }else{ + pTab->bLock--; + rc = sqlite3_reset(pCsr->pStmt); + if( rc==SQLITE_OK && ((Fts3Table *)pCsr->base.pVtab)->zContentTbl==0 ){ + /* If no row was found and no error has occurred, then the %_content + ** table is missing a row that is present in the full-text index. + ** The data structures are corrupt. */ + rc = FTS_CORRUPT_VTAB; + pCsr->isEof = 1; + } + } + } + } + + if( rc!=SQLITE_OK && pContext ){ + sqlite3_result_error_code(pContext, rc); + } + return rc; +} + +/* +** This function is used to process a single interior node when searching +** a b-tree for a term or term prefix. The node data is passed to this +** function via the zNode/nNode parameters. The term to search for is +** passed in zTerm/nTerm. +** +** If piFirst is not NULL, then this function sets *piFirst to the blockid +** of the child node that heads the sub-tree that may contain the term. +** +** If piLast is not NULL, then *piLast is set to the right-most child node +** that heads a sub-tree that may contain a term for which zTerm/nTerm is +** a prefix. +** +** If an OOM error occurs, SQLITE_NOMEM is returned. Otherwise, SQLITE_OK. +*/ +static int fts3ScanInteriorNode( + const char *zTerm, /* Term to select leaves for */ + int nTerm, /* Size of term zTerm in bytes */ + const char *zNode, /* Buffer containing segment interior node */ + int nNode, /* Size of buffer at zNode */ + sqlite3_int64 *piFirst, /* OUT: Selected child node */ + sqlite3_int64 *piLast /* OUT: Selected child node */ +){ + int rc = SQLITE_OK; /* Return code */ + const char *zCsr = zNode; /* Cursor to iterate through node */ + const char *zEnd = &zCsr[nNode];/* End of interior node buffer */ + char *zBuffer = 0; /* Buffer to load terms into */ + i64 nAlloc = 0; /* Size of allocated buffer */ + int isFirstTerm = 1; /* True when processing first term on page */ + u64 iChild; /* Block id of child node to descend to */ + int nBuffer = 0; /* Total term size */ + + /* Skip over the 'height' varint that occurs at the start of every + ** interior node. Then load the blockid of the left-child of the b-tree + ** node into variable iChild. + ** + ** Even if the data structure on disk is corrupted, this (reading two + ** varints from the buffer) does not risk an overread. If zNode is a + ** root node, then the buffer comes from a SELECT statement. SQLite does + ** not make this guarantee explicitly, but in practice there are always + ** either more than 20 bytes of allocated space following the nNode bytes of + ** contents, or two zero bytes. Or, if the node is read from the %_segments + ** table, then there are always 20 bytes of zeroed padding following the + ** nNode bytes of content (see sqlite3Fts3ReadBlock() for details). + */ + zCsr += sqlite3Fts3GetVarintU(zCsr, &iChild); + zCsr += sqlite3Fts3GetVarintU(zCsr, &iChild); + if( zCsr>zEnd ){ + return FTS_CORRUPT_VTAB; + } + + while( zCsrnBuffer ){ + rc = FTS_CORRUPT_VTAB; + goto finish_scan; + } + } + isFirstTerm = 0; + zCsr += fts3GetVarint32(zCsr, &nSuffix); + + assert( nPrefix>=0 && nSuffix>=0 ); + if( nPrefix>zCsr-zNode || nSuffix>zEnd-zCsr || nSuffix==0 ){ + rc = FTS_CORRUPT_VTAB; + goto finish_scan; + } + if( (i64)nPrefix+nSuffix>nAlloc ){ + char *zNew; + nAlloc = ((i64)nPrefix+nSuffix) * 2; + zNew = (char *)sqlite3_realloc64(zBuffer, nAlloc); + if( !zNew ){ + rc = SQLITE_NOMEM; + goto finish_scan; + } + zBuffer = zNew; + } + assert( zBuffer ); + memcpy(&zBuffer[nPrefix], zCsr, nSuffix); + nBuffer = nPrefix + nSuffix; + zCsr += nSuffix; + + /* Compare the term we are searching for with the term just loaded from + ** the interior node. If the specified term is greater than or equal + ** to the term from the interior node, then all terms on the sub-tree + ** headed by node iChild are smaller than zTerm. No need to search + ** iChild. + ** + ** If the interior node term is larger than the specified term, then + ** the tree headed by iChild may contain the specified term. + */ + cmp = memcmp(zTerm, zBuffer, (nBuffer>nTerm ? nTerm : nBuffer)); + if( piFirst && (cmp<0 || (cmp==0 && nBuffer>nTerm)) ){ + *piFirst = (i64)iChild; + piFirst = 0; + } + + if( piLast && cmp<0 ){ + *piLast = (i64)iChild; + piLast = 0; + } + + iChild++; + }; + + if( piFirst ) *piFirst = (i64)iChild; + if( piLast ) *piLast = (i64)iChild; + + finish_scan: + sqlite3_free(zBuffer); + return rc; +} + + +/* +** The buffer pointed to by argument zNode (size nNode bytes) contains an +** interior node of a b-tree segment. The zTerm buffer (size nTerm bytes) +** contains a term. This function searches the sub-tree headed by the zNode +** node for the range of leaf nodes that may contain the specified term +** or terms for which the specified term is a prefix. +** +** If piLeaf is not NULL, then *piLeaf is set to the blockid of the +** left-most leaf node in the tree that may contain the specified term. +** If piLeaf2 is not NULL, then *piLeaf2 is set to the blockid of the +** right-most leaf node that may contain a term for which the specified +** term is a prefix. +** +** It is possible that the range of returned leaf nodes does not contain +** the specified term or any terms for which it is a prefix. However, if the +** segment does contain any such terms, they are stored within the identified +** range. Because this function only inspects interior segment nodes (and +** never loads leaf nodes into memory), it is not possible to be sure. +** +** If an error occurs, an error code other than SQLITE_OK is returned. +*/ +static int fts3SelectLeaf( + Fts3Table *p, /* Virtual table handle */ + const char *zTerm, /* Term to select leaves for */ + int nTerm, /* Size of term zTerm in bytes */ + const char *zNode, /* Buffer containing segment interior node */ + int nNode, /* Size of buffer at zNode */ + sqlite3_int64 *piLeaf, /* Selected leaf node */ + sqlite3_int64 *piLeaf2 /* Selected leaf node */ +){ + int rc = SQLITE_OK; /* Return code */ + int iHeight; /* Height of this node in tree */ + + assert( piLeaf || piLeaf2 ); + + fts3GetVarint32(zNode, &iHeight); + rc = fts3ScanInteriorNode(zTerm, nTerm, zNode, nNode, piLeaf, piLeaf2); + assert_fts3_nc( !piLeaf2 || !piLeaf || rc!=SQLITE_OK || (*piLeaf<=*piLeaf2) ); + + if( rc==SQLITE_OK && iHeight>1 ){ + char *zBlob = 0; /* Blob read from %_segments table */ + int nBlob = 0; /* Size of zBlob in bytes */ + + if( piLeaf && piLeaf2 && (*piLeaf!=*piLeaf2) ){ + rc = sqlite3Fts3ReadBlock(p, *piLeaf, &zBlob, &nBlob, 0); + if( rc==SQLITE_OK ){ + rc = fts3SelectLeaf(p, zTerm, nTerm, zBlob, nBlob, piLeaf, 0); + } + sqlite3_free(zBlob); + piLeaf = 0; + zBlob = 0; + } + + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3ReadBlock(p, piLeaf?*piLeaf:*piLeaf2, &zBlob, &nBlob, 0); + } + if( rc==SQLITE_OK ){ + int iNewHeight = 0; + fts3GetVarint32(zBlob, &iNewHeight); + if( iNewHeight>=iHeight ){ + rc = FTS_CORRUPT_VTAB; + }else{ + rc = fts3SelectLeaf(p, zTerm, nTerm, zBlob, nBlob, piLeaf, piLeaf2); + } + } + sqlite3_free(zBlob); + } + + return rc; +} + +/* +** This function is used to create delta-encoded serialized lists of FTS3 +** varints. Each call to this function appends a single varint to a list. +*/ +static void fts3PutDeltaVarint( + char **pp, /* IN/OUT: Output pointer */ + sqlite3_int64 *piPrev, /* IN/OUT: Previous value written to list */ + sqlite3_int64 iVal /* Write this value to the list */ +){ + assert_fts3_nc( iVal-*piPrev > 0 || (*piPrev==0 && iVal==0) ); + *pp += sqlite3Fts3PutVarint(*pp, iVal-*piPrev); + *piPrev = iVal; +} + +/* +** When this function is called, *ppPoslist is assumed to point to the +** start of a position-list. After it returns, *ppPoslist points to the +** first byte after the position-list. +** +** A position list is list of positions (delta encoded) and columns for +** a single document record of a doclist. So, in other words, this +** routine advances *ppPoslist so that it points to the next docid in +** the doclist, or to the first byte past the end of the doclist. +** +** If pp is not NULL, then the contents of the position list are copied +** to *pp. *pp is set to point to the first byte past the last byte copied +** before this function returns. +*/ +static void fts3PoslistCopy(char **pp, char **ppPoslist){ + char *pEnd = *ppPoslist; + char c = 0; + + /* The end of a position list is marked by a zero encoded as an FTS3 + ** varint. A single POS_END (0) byte. Except, if the 0 byte is preceded by + ** a byte with the 0x80 bit set, then it is not a varint 0, but the tail + ** of some other, multi-byte, value. + ** + ** The following while-loop moves pEnd to point to the first byte that is not + ** immediately preceded by a byte with the 0x80 bit set. Then increments + ** pEnd once more so that it points to the byte immediately following the + ** last byte in the position-list. + */ + while( *pEnd | c ){ + c = *pEnd++ & 0x80; + testcase( c!=0 && (*pEnd)==0 ); + } + pEnd++; /* Advance past the POS_END terminator byte */ + + if( pp ){ + int n = (int)(pEnd - *ppPoslist); + char *p = *pp; + memcpy(p, *ppPoslist, n); + p += n; + *pp = p; + } + *ppPoslist = pEnd; +} + +/* +** When this function is called, *ppPoslist is assumed to point to the +** start of a column-list. After it returns, *ppPoslist points to the +** to the terminator (POS_COLUMN or POS_END) byte of the column-list. +** +** A column-list is list of delta-encoded positions for a single column +** within a single document within a doclist. +** +** The column-list is terminated either by a POS_COLUMN varint (1) or +** a POS_END varint (0). This routine leaves *ppPoslist pointing to +** the POS_COLUMN or POS_END that terminates the column-list. +** +** If pp is not NULL, then the contents of the column-list are copied +** to *pp. *pp is set to point to the first byte past the last byte copied +** before this function returns. The POS_COLUMN or POS_END terminator +** is not copied into *pp. +*/ +static void fts3ColumnlistCopy(char **pp, char **ppPoslist){ + char *pEnd = *ppPoslist; + char c = 0; + + /* A column-list is terminated by either a 0x01 or 0x00 byte that is + ** not part of a multi-byte varint. + */ + while( 0xFE & (*pEnd | c) ){ + c = *pEnd++ & 0x80; + testcase( c!=0 && ((*pEnd)&0xfe)==0 ); + } + if( pp ){ + int n = (int)(pEnd - *ppPoslist); + char *p = *pp; + memcpy(p, *ppPoslist, n); + p += n; + *pp = p; + } + *ppPoslist = pEnd; +} + +/* +** Value used to signify the end of an position-list. This must be +** as large or larger than any value that might appear on the +** position-list, even a position list that has been corrupted. +*/ +#define POSITION_LIST_END LARGEST_INT64 + +/* +** This function is used to help parse position-lists. When this function is +** called, *pp may point to the start of the next varint in the position-list +** being parsed, or it may point to 1 byte past the end of the position-list +** (in which case **pp will be a terminator bytes POS_END (0) or +** (1)). +** +** If *pp points past the end of the current position-list, set *pi to +** POSITION_LIST_END and return. Otherwise, read the next varint from *pp, +** increment the current value of *pi by the value read, and set *pp to +** point to the next value before returning. +** +** Before calling this routine *pi must be initialized to the value of +** the previous position, or zero if we are reading the first position +** in the position-list. Because positions are delta-encoded, the value +** of the previous position is needed in order to compute the value of +** the next position. +*/ +static void fts3ReadNextPos( + char **pp, /* IN/OUT: Pointer into position-list buffer */ + sqlite3_int64 *pi /* IN/OUT: Value read from position-list */ +){ + if( (**pp)&0xFE ){ + int iVal; + *pp += fts3GetVarint32((*pp), &iVal); + *pi += iVal; + *pi -= 2; + }else{ + *pi = POSITION_LIST_END; + } +} + +/* +** If parameter iCol is not 0, write an POS_COLUMN (1) byte followed by +** the value of iCol encoded as a varint to *pp. This will start a new +** column list. +** +** Set *pp to point to the byte just after the last byte written before +** returning (do not modify it if iCol==0). Return the total number of bytes +** written (0 if iCol==0). +*/ +static int fts3PutColNumber(char **pp, int iCol){ + int n = 0; /* Number of bytes written */ + if( iCol ){ + char *p = *pp; /* Output pointer */ + n = 1 + sqlite3Fts3PutVarint(&p[1], iCol); + *p = 0x01; + *pp = &p[n]; + } + return n; +} + +/* +** Compute the union of two position lists. The output written +** into *pp contains all positions of both *pp1 and *pp2 in sorted +** order and with any duplicates removed. All pointers are +** updated appropriately. The caller is responsible for insuring +** that there is enough space in *pp to hold the complete output. +*/ +static int fts3PoslistMerge( + char **pp, /* Output buffer */ + char **pp1, /* Left input list */ + char **pp2 /* Right input list */ +){ + char *p = *pp; + char *p1 = *pp1; + char *p2 = *pp2; + + while( *p1 || *p2 ){ + int iCol1; /* The current column index in pp1 */ + int iCol2; /* The current column index in pp2 */ + + if( *p1==POS_COLUMN ){ + fts3GetVarint32(&p1[1], &iCol1); + if( iCol1==0 ) return FTS_CORRUPT_VTAB; + } + else if( *p1==POS_END ) iCol1 = 0x7fffffff; + else iCol1 = 0; + + if( *p2==POS_COLUMN ){ + fts3GetVarint32(&p2[1], &iCol2); + if( iCol2==0 ) return FTS_CORRUPT_VTAB; + } + else if( *p2==POS_END ) iCol2 = 0x7fffffff; + else iCol2 = 0; + + if( iCol1==iCol2 ){ + sqlite3_int64 i1 = 0; /* Last position from pp1 */ + sqlite3_int64 i2 = 0; /* Last position from pp2 */ + sqlite3_int64 iPrev = 0; + int n = fts3PutColNumber(&p, iCol1); + p1 += n; + p2 += n; + + /* At this point, both p1 and p2 point to the start of column-lists + ** for the same column (the column with index iCol1 and iCol2). + ** A column-list is a list of non-negative delta-encoded varints, each + ** incremented by 2 before being stored. Each list is terminated by a + ** POS_END (0) or POS_COLUMN (1). The following block merges the two lists + ** and writes the results to buffer p. p is left pointing to the byte + ** after the list written. No terminator (POS_END or POS_COLUMN) is + ** written to the output. + */ + fts3GetDeltaVarint(&p1, &i1); + fts3GetDeltaVarint(&p2, &i2); + if( i1<2 || i2<2 ){ + break; + } + do { + fts3PutDeltaVarint(&p, &iPrev, (i1pos(*pp1) && pos(*pp2)-pos(*pp1)<=nToken). i.e. +** when the *pp1 token appears before the *pp2 token, but not more than nToken +** slots before it. +** +** e.g. nToken==1 searches for adjacent positions. +*/ +static int fts3PoslistPhraseMerge( + char **pp, /* IN/OUT: Preallocated output buffer */ + int nToken, /* Maximum difference in token positions */ + int isSaveLeft, /* Save the left position */ + int isExact, /* If *pp1 is exactly nTokens before *pp2 */ + char **pp1, /* IN/OUT: Left input list */ + char **pp2 /* IN/OUT: Right input list */ +){ + char *p = *pp; + char *p1 = *pp1; + char *p2 = *pp2; + int iCol1 = 0; + int iCol2 = 0; + + /* Never set both isSaveLeft and isExact for the same invocation. */ + assert( isSaveLeft==0 || isExact==0 ); + + assert_fts3_nc( p!=0 && *p1!=0 && *p2!=0 ); + if( *p1==POS_COLUMN ){ + p1++; + p1 += fts3GetVarint32(p1, &iCol1); + } + if( *p2==POS_COLUMN ){ + p2++; + p2 += fts3GetVarint32(p2, &iCol2); + } + + while( 1 ){ + if( iCol1==iCol2 ){ + char *pSave = p; + sqlite3_int64 iPrev = 0; + sqlite3_int64 iPos1 = 0; + sqlite3_int64 iPos2 = 0; + + if( iCol1 ){ + *p++ = POS_COLUMN; + p += sqlite3Fts3PutVarint(p, iCol1); + } + + fts3GetDeltaVarint(&p1, &iPos1); iPos1 -= 2; + fts3GetDeltaVarint(&p2, &iPos2); iPos2 -= 2; + if( iPos1<0 || iPos2<0 ) break; + + while( 1 ){ + if( iPos2==iPos1+nToken + || (isExact==0 && iPos2>iPos1 && iPos2<=iPos1+nToken) + ){ + sqlite3_int64 iSave; + iSave = isSaveLeft ? iPos1 : iPos2; + fts3PutDeltaVarint(&p, &iPrev, iSave+2); iPrev -= 2; + pSave = 0; + assert( p ); + } + if( (!isSaveLeft && iPos2<=(iPos1+nToken)) || iPos2<=iPos1 ){ + if( (*p2&0xFE)==0 ) break; + fts3GetDeltaVarint(&p2, &iPos2); iPos2 -= 2; + }else{ + if( (*p1&0xFE)==0 ) break; + fts3GetDeltaVarint(&p1, &iPos1); iPos1 -= 2; + } + } + + if( pSave ){ + assert( pp && p ); + p = pSave; + } + + fts3ColumnlistCopy(0, &p1); + fts3ColumnlistCopy(0, &p2); + assert( (*p1&0xFE)==0 && (*p2&0xFE)==0 ); + if( 0==*p1 || 0==*p2 ) break; + + p1++; + p1 += fts3GetVarint32(p1, &iCol1); + p2++; + p2 += fts3GetVarint32(p2, &iCol2); + } + + /* Advance pointer p1 or p2 (whichever corresponds to the smaller of + ** iCol1 and iCol2) so that it points to either the 0x00 that marks the + ** end of the position list, or the 0x01 that precedes the next + ** column-number in the position list. + */ + else if( iCol1=pEnd ){ + *pp = 0; + }else{ + u64 iVal; + *pp += sqlite3Fts3GetVarintU(*pp, &iVal); + if( bDescIdx ){ + *pVal = (i64)((u64)*pVal - iVal); + }else{ + *pVal = (i64)((u64)*pVal + iVal); + } + } +} + +/* +** This function is used to write a single varint to a buffer. The varint +** is written to *pp. Before returning, *pp is set to point 1 byte past the +** end of the value written. +** +** If *pbFirst is zero when this function is called, the value written to +** the buffer is that of parameter iVal. +** +** If *pbFirst is non-zero when this function is called, then the value +** written is either (iVal-*piPrev) (if bDescIdx is zero) or (*piPrev-iVal) +** (if bDescIdx is non-zero). +** +** Before returning, this function always sets *pbFirst to 1 and *piPrev +** to the value of parameter iVal. +*/ +static void fts3PutDeltaVarint3( + char **pp, /* IN/OUT: Output pointer */ + int bDescIdx, /* True for descending docids */ + sqlite3_int64 *piPrev, /* IN/OUT: Previous value written to list */ + int *pbFirst, /* IN/OUT: True after first int written */ + sqlite3_int64 iVal /* Write this value to the list */ +){ + sqlite3_uint64 iWrite; + if( bDescIdx==0 || *pbFirst==0 ){ + assert_fts3_nc( *pbFirst==0 || iVal>=*piPrev ); + iWrite = (u64)iVal - (u64)*piPrev; + }else{ + assert_fts3_nc( *piPrev>=iVal ); + iWrite = (u64)*piPrev - (u64)iVal; + } + assert( *pbFirst || *piPrev==0 ); + assert_fts3_nc( *pbFirst==0 || iWrite>0 ); + *pp += sqlite3Fts3PutVarint(*pp, iWrite); + *piPrev = iVal; + *pbFirst = 1; +} + + +/* +** This macro is used by various functions that merge doclists. The two +** arguments are 64-bit docid values. If the value of the stack variable +** bDescDoclist is 0 when this macro is invoked, then it returns (i1-i2). +** Otherwise, (i2-i1). +** +** Using this makes it easier to write code that can merge doclists that are +** sorted in either ascending or descending order. +*/ +/* #define DOCID_CMP(i1, i2) ((bDescDoclist?-1:1) * (i64)((u64)i1-i2)) */ +#define DOCID_CMP(i1, i2) ((bDescDoclist?-1:1) * (i1>i2?1:((i1==i2)?0:-1))) + +/* +** This function does an "OR" merge of two doclists (output contains all +** positions contained in either argument doclist). If the docids in the +** input doclists are sorted in ascending order, parameter bDescDoclist +** should be false. If they are sorted in ascending order, it should be +** passed a non-zero value. +** +** If no error occurs, *paOut is set to point at an sqlite3_malloc'd buffer +** containing the output doclist and SQLITE_OK is returned. In this case +** *pnOut is set to the number of bytes in the output doclist. +** +** If an error occurs, an SQLite error code is returned. The output values +** are undefined in this case. +*/ +static int fts3DoclistOrMerge( + int bDescDoclist, /* True if arguments are desc */ + char *a1, int n1, /* First doclist */ + char *a2, int n2, /* Second doclist */ + char **paOut, int *pnOut /* OUT: Malloc'd doclist */ +){ + int rc = SQLITE_OK; + sqlite3_int64 i1 = 0; + sqlite3_int64 i2 = 0; + sqlite3_int64 iPrev = 0; + char *pEnd1 = &a1[n1]; + char *pEnd2 = &a2[n2]; + char *p1 = a1; + char *p2 = a2; + char *p; + char *aOut; + int bFirstOut = 0; + + *paOut = 0; + *pnOut = 0; + + /* Allocate space for the output. Both the input and output doclists + ** are delta encoded. If they are in ascending order (bDescDoclist==0), + ** then the first docid in each list is simply encoded as a varint. For + ** each subsequent docid, the varint stored is the difference between the + ** current and previous docid (a positive number - since the list is in + ** ascending order). + ** + ** The first docid written to the output is therefore encoded using the + ** same number of bytes as it is in whichever of the input lists it is + ** read from. And each subsequent docid read from the same input list + ** consumes either the same or less bytes as it did in the input (since + ** the difference between it and the previous value in the output must + ** be a positive value less than or equal to the delta value read from + ** the input list). The same argument applies to all but the first docid + ** read from the 'other' list. And to the contents of all position lists + ** that will be copied and merged from the input to the output. + ** + ** However, if the first docid copied to the output is a negative number, + ** then the encoding of the first docid from the 'other' input list may + ** be larger in the output than it was in the input (since the delta value + ** may be a larger positive integer than the actual docid). + ** + ** The space required to store the output is therefore the sum of the + ** sizes of the two inputs, plus enough space for exactly one of the input + ** docids to grow. + ** + ** A symetric argument may be made if the doclists are in descending + ** order. + */ + aOut = sqlite3_malloc64((i64)n1+n2+FTS3_VARINT_MAX-1+FTS3_BUFFER_PADDING); + if( !aOut ) return SQLITE_NOMEM; + + p = aOut; + fts3GetDeltaVarint3(&p1, pEnd1, 0, &i1); + fts3GetDeltaVarint3(&p2, pEnd2, 0, &i2); + while( p1 || p2 ){ + sqlite3_int64 iDiff = DOCID_CMP(i1, i2); + + if( p2 && p1 && iDiff==0 ){ + fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i1); + rc = fts3PoslistMerge(&p, &p1, &p2); + if( rc ) break; + fts3GetDeltaVarint3(&p1, pEnd1, bDescDoclist, &i1); + fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2); + }else if( !p2 || (p1 && iDiff<0) ){ + fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i1); + fts3PoslistCopy(&p, &p1); + fts3GetDeltaVarint3(&p1, pEnd1, bDescDoclist, &i1); + }else{ + fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i2); + fts3PoslistCopy(&p, &p2); + fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2); + } + + assert( (p-aOut)<=((p1?(p1-a1):n1)+(p2?(p2-a2):n2)+FTS3_VARINT_MAX-1) ); + } + + if( rc!=SQLITE_OK ){ + sqlite3_free(aOut); + p = aOut = 0; + }else{ + assert( (p-aOut)<=n1+n2+FTS3_VARINT_MAX-1 ); + memset(&aOut[(p-aOut)], 0, FTS3_BUFFER_PADDING); + } + *paOut = aOut; + *pnOut = (int)(p-aOut); + return rc; +} + +/* +** This function does a "phrase" merge of two doclists. In a phrase merge, +** the output contains a copy of each position from the right-hand input +** doclist for which there is a position in the left-hand input doclist +** exactly nDist tokens before it. +** +** If the docids in the input doclists are sorted in ascending order, +** parameter bDescDoclist should be false. If they are sorted in ascending +** order, it should be passed a non-zero value. +** +** The right-hand input doclist is overwritten by this function. +*/ +static int fts3DoclistPhraseMerge( + int bDescDoclist, /* True if arguments are desc */ + int nDist, /* Distance from left to right (1=adjacent) */ + char *aLeft, int nLeft, /* Left doclist */ + char **paRight, int *pnRight /* IN/OUT: Right/output doclist */ +){ + sqlite3_int64 i1 = 0; + sqlite3_int64 i2 = 0; + sqlite3_int64 iPrev = 0; + char *aRight = *paRight; + char *pEnd1 = &aLeft[nLeft]; + char *pEnd2 = &aRight[*pnRight]; + char *p1 = aLeft; + char *p2 = aRight; + char *p; + int bFirstOut = 0; + char *aOut; + + assert( nDist>0 ); + if( bDescDoclist ){ + aOut = sqlite3_malloc64((sqlite3_int64)*pnRight + FTS3_VARINT_MAX); + if( aOut==0 ) return SQLITE_NOMEM; + }else{ + aOut = aRight; + } + p = aOut; + + fts3GetDeltaVarint3(&p1, pEnd1, 0, &i1); + fts3GetDeltaVarint3(&p2, pEnd2, 0, &i2); + + while( p1 && p2 ){ + sqlite3_int64 iDiff = DOCID_CMP(i1, i2); + if( iDiff==0 ){ + char *pSave = p; + sqlite3_int64 iPrevSave = iPrev; + int bFirstOutSave = bFirstOut; + + fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i1); + if( 0==fts3PoslistPhraseMerge(&p, nDist, 0, 1, &p1, &p2) ){ + p = pSave; + iPrev = iPrevSave; + bFirstOut = bFirstOutSave; + } + fts3GetDeltaVarint3(&p1, pEnd1, bDescDoclist, &i1); + fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2); + }else if( iDiff<0 ){ + fts3PoslistCopy(0, &p1); + fts3GetDeltaVarint3(&p1, pEnd1, bDescDoclist, &i1); + }else{ + fts3PoslistCopy(0, &p2); + fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2); + } + } + + *pnRight = (int)(p - aOut); + if( bDescDoclist ){ + sqlite3_free(aRight); + *paRight = aOut; + } + + return SQLITE_OK; +} + +/* +** Argument pList points to a position list nList bytes in size. This +** function checks to see if the position list contains any entries for +** a token in position 0 (of any column). If so, it writes argument iDelta +** to the output buffer pOut, followed by a position list consisting only +** of the entries from pList at position 0, and terminated by an 0x00 byte. +** The value returned is the number of bytes written to pOut (if any). +*/ +SQLITE_PRIVATE int sqlite3Fts3FirstFilter( + sqlite3_int64 iDelta, /* Varint that may be written to pOut */ + char *pList, /* Position list (no 0x00 term) */ + int nList, /* Size of pList in bytes */ + char *pOut /* Write output here */ +){ + int nOut = 0; + int bWritten = 0; /* True once iDelta has been written */ + char *p = pList; + char *pEnd = &pList[nList]; + + if( *p!=0x01 ){ + if( *p==0x02 ){ + nOut += sqlite3Fts3PutVarint(&pOut[nOut], iDelta); + pOut[nOut++] = 0x02; + bWritten = 1; + } + fts3ColumnlistCopy(0, &p); + } + + while( paaOutput); i++){ + if( pTS->aaOutput[i] ){ + if( !aOut ){ + aOut = pTS->aaOutput[i]; + nOut = pTS->anOutput[i]; + pTS->aaOutput[i] = 0; + }else{ + int nNew; + char *aNew; + + int rc = fts3DoclistOrMerge(p->bDescIdx, + pTS->aaOutput[i], pTS->anOutput[i], aOut, nOut, &aNew, &nNew + ); + if( rc!=SQLITE_OK ){ + sqlite3_free(aOut); + return rc; + } + + sqlite3_free(pTS->aaOutput[i]); + sqlite3_free(aOut); + pTS->aaOutput[i] = 0; + aOut = aNew; + nOut = nNew; + } + } + } + + pTS->aaOutput[0] = aOut; + pTS->anOutput[0] = nOut; + return SQLITE_OK; +} + +/* +** Merge the doclist aDoclist/nDoclist into the TermSelect object passed +** as the first argument. The merge is an "OR" merge (see function +** fts3DoclistOrMerge() for details). +** +** This function is called with the doclist for each term that matches +** a queried prefix. It merges all these doclists into one, the doclist +** for the specified prefix. Since there can be a very large number of +** doclists to merge, the merging is done pair-wise using the TermSelect +** object. +** +** This function returns SQLITE_OK if the merge is successful, or an +** SQLite error code (SQLITE_NOMEM) if an error occurs. +*/ +static int fts3TermSelectMerge( + Fts3Table *p, /* FTS table handle */ + TermSelect *pTS, /* TermSelect object to merge into */ + char *aDoclist, /* Pointer to doclist */ + int nDoclist /* Size of aDoclist in bytes */ +){ + if( pTS->aaOutput[0]==0 ){ + /* If this is the first term selected, copy the doclist to the output + ** buffer using memcpy(). + ** + ** Add FTS3_VARINT_MAX bytes of unused space to the end of the + ** allocation. This is so as to ensure that the buffer is big enough + ** to hold the current doclist AND'd with any other doclist. If the + ** doclists are stored in order=ASC order, this padding would not be + ** required (since the size of [doclistA AND doclistB] is always less + ** than or equal to the size of [doclistA] in that case). But this is + ** not true for order=DESC. For example, a doclist containing (1, -1) + ** may be smaller than (-1), as in the first example the -1 may be stored + ** as a single-byte delta, whereas in the second it must be stored as a + ** FTS3_VARINT_MAX byte varint. + ** + ** Similar padding is added in the fts3DoclistOrMerge() function. + */ + pTS->aaOutput[0] = sqlite3_malloc64((i64)nDoclist + FTS3_VARINT_MAX + 1); + pTS->anOutput[0] = nDoclist; + if( pTS->aaOutput[0] ){ + memcpy(pTS->aaOutput[0], aDoclist, nDoclist); + memset(&pTS->aaOutput[0][nDoclist], 0, FTS3_VARINT_MAX); + }else{ + return SQLITE_NOMEM; + } + }else{ + char *aMerge = aDoclist; + int nMerge = nDoclist; + int iOut; + + for(iOut=0; iOutaaOutput); iOut++){ + if( pTS->aaOutput[iOut]==0 ){ + assert( iOut>0 ); + pTS->aaOutput[iOut] = aMerge; + pTS->anOutput[iOut] = nMerge; + break; + }else{ + char *aNew; + int nNew; + + int rc = fts3DoclistOrMerge(p->bDescIdx, aMerge, nMerge, + pTS->aaOutput[iOut], pTS->anOutput[iOut], &aNew, &nNew + ); + if( rc!=SQLITE_OK ){ + if( aMerge!=aDoclist ) sqlite3_free(aMerge); + return rc; + } + + if( aMerge!=aDoclist ) sqlite3_free(aMerge); + sqlite3_free(pTS->aaOutput[iOut]); + pTS->aaOutput[iOut] = 0; + + aMerge = aNew; + nMerge = nNew; + if( (iOut+1)==SizeofArray(pTS->aaOutput) ){ + pTS->aaOutput[iOut] = aMerge; + pTS->anOutput[iOut] = nMerge; + } + } + } + } + return SQLITE_OK; +} + +/* +** Append SegReader object pNew to the end of the pCsr->apSegment[] array. +*/ +static int fts3SegReaderCursorAppend( + Fts3MultiSegReader *pCsr, + Fts3SegReader *pNew +){ + if( (pCsr->nSegment%16)==0 ){ + Fts3SegReader **apNew; + sqlite3_int64 nByte = (pCsr->nSegment + 16)*sizeof(Fts3SegReader*); + apNew = (Fts3SegReader **)sqlite3_realloc64(pCsr->apSegment, nByte); + if( !apNew ){ + sqlite3Fts3SegReaderFree(pNew); + return SQLITE_NOMEM; + } + pCsr->apSegment = apNew; + } + pCsr->apSegment[pCsr->nSegment++] = pNew; + return SQLITE_OK; +} + +/* +** Add seg-reader objects to the Fts3MultiSegReader object passed as the +** 8th argument. +** +** This function returns SQLITE_OK if successful, or an SQLite error code +** otherwise. +*/ +static int fts3SegReaderCursor( + Fts3Table *p, /* FTS3 table handle */ + int iLangid, /* Language id */ + int iIndex, /* Index to search (from 0 to p->nIndex-1) */ + int iLevel, /* Level of segments to scan */ + const char *zTerm, /* Term to query for */ + int nTerm, /* Size of zTerm in bytes */ + int isPrefix, /* True for a prefix search */ + int isScan, /* True to scan from zTerm to EOF */ + Fts3MultiSegReader *pCsr /* Cursor object to populate */ +){ + int rc = SQLITE_OK; /* Error code */ + sqlite3_stmt *pStmt = 0; /* Statement to iterate through segments */ + int rc2; /* Result of sqlite3_reset() */ + + /* If iLevel is less than 0 and this is not a scan, include a seg-reader + ** for the pending-terms. If this is a scan, then this call must be being + ** made by an fts4aux module, not an FTS table. In this case calling + ** Fts3SegReaderPending might segfault, as the data structures used by + ** fts4aux are not completely populated. So it's easiest to filter these + ** calls out here. */ + if( iLevel<0 && p->aIndex && p->iPrevLangid==iLangid ){ + Fts3SegReader *pSeg = 0; + rc = sqlite3Fts3SegReaderPending(p, iIndex, zTerm, nTerm, isPrefix||isScan, &pSeg); + if( rc==SQLITE_OK && pSeg ){ + rc = fts3SegReaderCursorAppend(pCsr, pSeg); + } + } + + if( iLevel!=FTS3_SEGCURSOR_PENDING ){ + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3AllSegdirs(p, iLangid, iIndex, iLevel, &pStmt); + } + + while( rc==SQLITE_OK && SQLITE_ROW==(rc = sqlite3_step(pStmt)) ){ + Fts3SegReader *pSeg = 0; + + /* Read the values returned by the SELECT into local variables. */ + sqlite3_int64 iStartBlock = sqlite3_column_int64(pStmt, 1); + sqlite3_int64 iLeavesEndBlock = sqlite3_column_int64(pStmt, 2); + sqlite3_int64 iEndBlock = sqlite3_column_int64(pStmt, 3); + int nRoot = sqlite3_column_bytes(pStmt, 4); + char const *zRoot = sqlite3_column_blob(pStmt, 4); + + /* If zTerm is not NULL, and this segment is not stored entirely on its + ** root node, the range of leaves scanned can be reduced. Do this. */ + if( iStartBlock && zTerm && zRoot ){ + sqlite3_int64 *pi = (isPrefix ? &iLeavesEndBlock : 0); + rc = fts3SelectLeaf(p, zTerm, nTerm, zRoot, nRoot, &iStartBlock, pi); + if( rc!=SQLITE_OK ) goto finished; + if( isPrefix==0 && isScan==0 ) iLeavesEndBlock = iStartBlock; + } + + rc = sqlite3Fts3SegReaderNew(pCsr->nSegment+1, + (isPrefix==0 && isScan==0), + iStartBlock, iLeavesEndBlock, + iEndBlock, zRoot, nRoot, &pSeg + ); + if( rc!=SQLITE_OK ) goto finished; + rc = fts3SegReaderCursorAppend(pCsr, pSeg); + } + } + + finished: + rc2 = sqlite3_reset(pStmt); + if( rc==SQLITE_DONE ) rc = rc2; + + return rc; +} + +/* +** Set up a cursor object for iterating through a full-text index or a +** single level therein. +*/ +SQLITE_PRIVATE int sqlite3Fts3SegReaderCursor( + Fts3Table *p, /* FTS3 table handle */ + int iLangid, /* Language-id to search */ + int iIndex, /* Index to search (from 0 to p->nIndex-1) */ + int iLevel, /* Level of segments to scan */ + const char *zTerm, /* Term to query for */ + int nTerm, /* Size of zTerm in bytes */ + int isPrefix, /* True for a prefix search */ + int isScan, /* True to scan from zTerm to EOF */ + Fts3MultiSegReader *pCsr /* Cursor object to populate */ +){ + assert( iIndex>=0 && iIndexnIndex ); + assert( iLevel==FTS3_SEGCURSOR_ALL + || iLevel==FTS3_SEGCURSOR_PENDING + || iLevel>=0 + ); + assert( iLevelbase.pVtab; + + if( isPrefix ){ + for(i=1; bFound==0 && inIndex; i++){ + if( p->aIndex[i].nPrefix==nTerm ){ + bFound = 1; + rc = sqlite3Fts3SegReaderCursor(p, pCsr->iLangid, + i, FTS3_SEGCURSOR_ALL, zTerm, nTerm, 0, 0, pSegcsr + ); + pSegcsr->bLookup = 1; + } + } + + for(i=1; bFound==0 && inIndex; i++){ + if( p->aIndex[i].nPrefix==nTerm+1 ){ + bFound = 1; + rc = sqlite3Fts3SegReaderCursor(p, pCsr->iLangid, + i, FTS3_SEGCURSOR_ALL, zTerm, nTerm, 1, 0, pSegcsr + ); + if( rc==SQLITE_OK ){ + rc = fts3SegReaderCursorAddZero( + p, pCsr->iLangid, zTerm, nTerm, pSegcsr + ); + } + } + } + } + + if( bFound==0 ){ + rc = sqlite3Fts3SegReaderCursor(p, pCsr->iLangid, + 0, FTS3_SEGCURSOR_ALL, zTerm, nTerm, isPrefix, 0, pSegcsr + ); + pSegcsr->bLookup = !isPrefix; + } + } + + *ppSegcsr = pSegcsr; + return rc; +} + +/* +** Free an Fts3MultiSegReader allocated by fts3TermSegReaderCursor(). +*/ +static void fts3SegReaderCursorFree(Fts3MultiSegReader *pSegcsr){ + sqlite3Fts3SegReaderFinish(pSegcsr); + sqlite3_free(pSegcsr); +} + +/* +** This function retrieves the doclist for the specified term (or term +** prefix) from the database. +*/ +static int fts3TermSelect( + Fts3Table *p, /* Virtual table handle */ + Fts3PhraseToken *pTok, /* Token to query for */ + int iColumn, /* Column to query (or -ve for all columns) */ + int *pnOut, /* OUT: Size of buffer at *ppOut */ + char **ppOut /* OUT: Malloced result buffer */ +){ + int rc; /* Return code */ + Fts3MultiSegReader *pSegcsr; /* Seg-reader cursor for this term */ + TermSelect tsc; /* Object for pair-wise doclist merging */ + Fts3SegFilter filter; /* Segment term filter configuration */ + + pSegcsr = pTok->pSegcsr; + memset(&tsc, 0, sizeof(TermSelect)); + + filter.flags = FTS3_SEGMENT_IGNORE_EMPTY | FTS3_SEGMENT_REQUIRE_POS + | (pTok->isPrefix ? FTS3_SEGMENT_PREFIX : 0) + | (pTok->bFirst ? FTS3_SEGMENT_FIRST : 0) + | (iColumnnColumn ? FTS3_SEGMENT_COLUMN_FILTER : 0); + filter.iCol = iColumn; + filter.zTerm = pTok->z; + filter.nTerm = pTok->n; + + rc = sqlite3Fts3SegReaderStart(p, pSegcsr, &filter); + while( SQLITE_OK==rc + && SQLITE_ROW==(rc = sqlite3Fts3SegReaderStep(p, pSegcsr)) + ){ + rc = fts3TermSelectMerge(p, &tsc, pSegcsr->aDoclist, pSegcsr->nDoclist); + } + + if( rc==SQLITE_OK ){ + rc = fts3TermSelectFinishMerge(p, &tsc); + } + if( rc==SQLITE_OK ){ + *ppOut = tsc.aaOutput[0]; + *pnOut = tsc.anOutput[0]; + }else{ + int i; + for(i=0; ipSegcsr = 0; + return rc; +} + +/* +** This function counts the total number of docids in the doclist stored +** in buffer aList[], size nList bytes. +** +** If the isPoslist argument is true, then it is assumed that the doclist +** contains a position-list following each docid. Otherwise, it is assumed +** that the doclist is simply a list of docids stored as delta encoded +** varints. +*/ +static int fts3DoclistCountDocids(char *aList, int nList){ + int nDoc = 0; /* Return value */ + if( aList ){ + char *aEnd = &aList[nList]; /* Pointer to one byte after EOF */ + char *p = aList; /* Cursor */ + while( peSearch==FTS3_DOCID_SEARCH || pCsr->eSearch==FTS3_FULLSCAN_SEARCH ){ + Fts3Table *pTab = (Fts3Table*)pCursor->pVtab; + pTab->bLock++; + if( SQLITE_ROW!=sqlite3_step(pCsr->pStmt) ){ + pCsr->isEof = 1; + rc = sqlite3_reset(pCsr->pStmt); + }else{ + pCsr->iPrevId = sqlite3_column_int64(pCsr->pStmt, 0); + rc = SQLITE_OK; + } + pTab->bLock--; + }else{ + rc = fts3EvalNext((Fts3Cursor *)pCursor); + } + assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 ); + return rc; +} + +/* +** If the numeric type of argument pVal is "integer", then return it +** converted to a 64-bit signed integer. Otherwise, return a copy of +** the second parameter, iDefault. +*/ +static sqlite3_int64 fts3DocidRange(sqlite3_value *pVal, i64 iDefault){ + if( pVal ){ + int eType = sqlite3_value_numeric_type(pVal); + if( eType==SQLITE_INTEGER ){ + return sqlite3_value_int64(pVal); + } + } + return iDefault; +} + +/* +** This is the xFilter interface for the virtual table. See +** the virtual table xFilter method documentation for additional +** information. +** +** If idxNum==FTS3_FULLSCAN_SEARCH then do a full table scan against +** the %_content table. +** +** If idxNum==FTS3_DOCID_SEARCH then do a docid lookup for a single entry +** in the %_content table. +** +** If idxNum>=FTS3_FULLTEXT_SEARCH then use the full text index. The +** column on the left-hand side of the MATCH operator is column +** number idxNum-FTS3_FULLTEXT_SEARCH, 0 indexed. argv[0] is the right-hand +** side of the MATCH operator. +*/ +static int fts3FilterMethod( + sqlite3_vtab_cursor *pCursor, /* The cursor used for this query */ + int idxNum, /* Strategy index */ + const char *idxStr, /* Unused */ + int nVal, /* Number of elements in apVal */ + sqlite3_value **apVal /* Arguments for the indexing scheme */ +){ + int rc = SQLITE_OK; + char *zSql; /* SQL statement used to access %_content */ + int eSearch; + Fts3Table *p = (Fts3Table *)pCursor->pVtab; + Fts3Cursor *pCsr = (Fts3Cursor *)pCursor; + + sqlite3_value *pCons = 0; /* The MATCH or rowid constraint, if any */ + sqlite3_value *pLangid = 0; /* The "langid = ?" constraint, if any */ + sqlite3_value *pDocidGe = 0; /* The "docid >= ?" constraint, if any */ + sqlite3_value *pDocidLe = 0; /* The "docid <= ?" constraint, if any */ + int iIdx; + + UNUSED_PARAMETER(idxStr); + UNUSED_PARAMETER(nVal); + + if( p->bLock ){ + return SQLITE_ERROR; + } + + eSearch = (idxNum & 0x0000FFFF); + assert( eSearch>=0 && eSearch<=(FTS3_FULLTEXT_SEARCH+p->nColumn) ); + assert( p->pSegments==0 ); + + /* Collect arguments into local variables */ + iIdx = 0; + if( eSearch!=FTS3_FULLSCAN_SEARCH ) pCons = apVal[iIdx++]; + if( idxNum & FTS3_HAVE_LANGID ) pLangid = apVal[iIdx++]; + if( idxNum & FTS3_HAVE_DOCID_GE ) pDocidGe = apVal[iIdx++]; + if( idxNum & FTS3_HAVE_DOCID_LE ) pDocidLe = apVal[iIdx++]; + assert( iIdx==nVal ); + + /* In case the cursor has been used before, clear it now. */ + fts3ClearCursor(pCsr); + + /* Set the lower and upper bounds on docids to return */ + pCsr->iMinDocid = fts3DocidRange(pDocidGe, SMALLEST_INT64); + pCsr->iMaxDocid = fts3DocidRange(pDocidLe, LARGEST_INT64); + + if( idxStr ){ + pCsr->bDesc = (idxStr[0]=='D'); + }else{ + pCsr->bDesc = p->bDescIdx; + } + pCsr->eSearch = (i16)eSearch; + + if( eSearch!=FTS3_DOCID_SEARCH && eSearch!=FTS3_FULLSCAN_SEARCH ){ + int iCol = eSearch-FTS3_FULLTEXT_SEARCH; + const char *zQuery = (const char *)sqlite3_value_text(pCons); + + if( zQuery==0 && sqlite3_value_type(pCons)!=SQLITE_NULL ){ + return SQLITE_NOMEM; + } + + pCsr->iLangid = 0; + if( pLangid ) pCsr->iLangid = sqlite3_value_int(pLangid); + + assert( p->base.zErrMsg==0 ); + rc = sqlite3Fts3ExprParse(p->pTokenizer, pCsr->iLangid, + p->azColumn, p->bFts4, p->nColumn, iCol, zQuery, -1, &pCsr->pExpr, + &p->base.zErrMsg + ); + if( rc!=SQLITE_OK ){ + return rc; + } + + rc = fts3EvalStart(pCsr); + sqlite3Fts3SegmentsClose(p); + if( rc!=SQLITE_OK ) return rc; + pCsr->pNextId = pCsr->aDoclist; + pCsr->iPrevId = 0; + } + + /* Compile a SELECT statement for this cursor. For a full-table-scan, the + ** statement loops through all rows of the %_content table. For a + ** full-text query or docid lookup, the statement retrieves a single + ** row by docid. + */ + if( eSearch==FTS3_FULLSCAN_SEARCH ){ + if( pDocidGe || pDocidLe ){ + zSql = sqlite3_mprintf( + "SELECT %s WHERE rowid BETWEEN %lld AND %lld ORDER BY rowid %s", + p->zReadExprlist, pCsr->iMinDocid, pCsr->iMaxDocid, + (pCsr->bDesc ? "DESC" : "ASC") + ); + }else{ + zSql = sqlite3_mprintf("SELECT %s ORDER BY rowid %s", + p->zReadExprlist, (pCsr->bDesc ? "DESC" : "ASC") + ); + } + if( zSql ){ + p->bLock++; + rc = sqlite3_prepare_v3( + p->db,zSql,-1,SQLITE_PREPARE_PERSISTENT,&pCsr->pStmt,0 + ); + p->bLock--; + sqlite3_free(zSql); + }else{ + rc = SQLITE_NOMEM; + } + }else if( eSearch==FTS3_DOCID_SEARCH ){ + rc = fts3CursorSeekStmt(pCsr); + if( rc==SQLITE_OK ){ + rc = sqlite3_bind_value(pCsr->pStmt, 1, pCons); + } + } + if( rc!=SQLITE_OK ) return rc; + + return fts3NextMethod(pCursor); +} + +/* +** This is the xEof method of the virtual table. SQLite calls this +** routine to find out if it has reached the end of a result set. +*/ +static int fts3EofMethod(sqlite3_vtab_cursor *pCursor){ + Fts3Cursor *pCsr = (Fts3Cursor*)pCursor; + if( pCsr->isEof ){ + fts3ClearCursor(pCsr); + pCsr->isEof = 1; + } + return pCsr->isEof; +} + +/* +** This is the xRowid method. The SQLite core calls this routine to +** retrieve the rowid for the current row of the result set. fts3 +** exposes %_content.docid as the rowid for the virtual table. The +** rowid should be written to *pRowid. +*/ +static int fts3RowidMethod(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){ + Fts3Cursor *pCsr = (Fts3Cursor *) pCursor; + *pRowid = pCsr->iPrevId; + return SQLITE_OK; +} + +/* +** This is the xColumn method, called by SQLite to request a value from +** the row that the supplied cursor currently points to. +** +** If: +** +** (iCol < p->nColumn) -> The value of the iCol'th user column. +** (iCol == p->nColumn) -> Magic column with the same name as the table. +** (iCol == p->nColumn+1) -> Docid column +** (iCol == p->nColumn+2) -> Langid column +*/ +static int fts3ColumnMethod( + sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */ + sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */ + int iCol /* Index of column to read value from */ +){ + int rc = SQLITE_OK; /* Return Code */ + Fts3Cursor *pCsr = (Fts3Cursor *) pCursor; + Fts3Table *p = (Fts3Table *)pCursor->pVtab; + + /* The column value supplied by SQLite must be in range. */ + assert( iCol>=0 && iCol<=p->nColumn+2 ); + + switch( iCol-p->nColumn ){ + case 0: + /* The special 'table-name' column */ + sqlite3_result_pointer(pCtx, pCsr, "fts3cursor", 0); + break; + + case 1: + /* The docid column */ + sqlite3_result_int64(pCtx, pCsr->iPrevId); + break; + + case 2: + if( pCsr->pExpr ){ + sqlite3_result_int64(pCtx, pCsr->iLangid); + break; + }else if( p->zLanguageid==0 ){ + sqlite3_result_int(pCtx, 0); + break; + }else{ + iCol = p->nColumn; + /* no break */ deliberate_fall_through + } + + default: + /* A user column. Or, if this is a full-table scan, possibly the + ** language-id column. Seek the cursor. */ + rc = fts3CursorSeek(0, pCsr); + if( rc==SQLITE_OK && sqlite3_data_count(pCsr->pStmt)-1>iCol ){ + sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1)); + } + break; + } + + assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 ); + return rc; +} + +/* +** This function is the implementation of the xUpdate callback used by +** FTS3 virtual tables. It is invoked by SQLite each time a row is to be +** inserted, updated or deleted. +*/ +static int fts3UpdateMethod( + sqlite3_vtab *pVtab, /* Virtual table handle */ + int nArg, /* Size of argument array */ + sqlite3_value **apVal, /* Array of arguments */ + sqlite_int64 *pRowid /* OUT: The affected (or effected) rowid */ +){ + return sqlite3Fts3UpdateMethod(pVtab, nArg, apVal, pRowid); +} + +/* +** Implementation of xSync() method. Flush the contents of the pending-terms +** hash-table to the database. +*/ +static int fts3SyncMethod(sqlite3_vtab *pVtab){ + + /* Following an incremental-merge operation, assuming that the input + ** segments are not completely consumed (the usual case), they are updated + ** in place to remove the entries that have already been merged. This + ** involves updating the leaf block that contains the smallest unmerged + ** entry and each block (if any) between the leaf and the root node. So + ** if the height of the input segment b-trees is N, and input segments + ** are merged eight at a time, updating the input segments at the end + ** of an incremental-merge requires writing (8*(1+N)) blocks. N is usually + ** small - often between 0 and 2. So the overhead of the incremental + ** merge is somewhere between 8 and 24 blocks. To avoid this overhead + ** dwarfing the actual productive work accomplished, the incremental merge + ** is only attempted if it will write at least 64 leaf blocks. Hence + ** nMinMerge. + ** + ** Of course, updating the input segments also involves deleting a bunch + ** of blocks from the segments table. But this is not considered overhead + ** as it would also be required by a crisis-merge that used the same input + ** segments. + */ + const u32 nMinMerge = 64; /* Minimum amount of incr-merge work to do */ + + Fts3Table *p = (Fts3Table*)pVtab; + int rc; + i64 iLastRowid = sqlite3_last_insert_rowid(p->db); + + rc = sqlite3Fts3PendingTermsFlush(p); + if( rc==SQLITE_OK + && p->nLeafAdd>(nMinMerge/16) + && p->nAutoincrmerge && p->nAutoincrmerge!=0xff + ){ + int mxLevel = 0; /* Maximum relative level value in db */ + int A; /* Incr-merge parameter A */ + + rc = sqlite3Fts3MaxLevel(p, &mxLevel); + assert( rc==SQLITE_OK || mxLevel==0 ); + A = p->nLeafAdd * mxLevel; + A += (A/2); + if( A>(int)nMinMerge ) rc = sqlite3Fts3Incrmerge(p, A, p->nAutoincrmerge); + } + sqlite3Fts3SegmentsClose(p); + sqlite3_set_last_insert_rowid(p->db, iLastRowid); + return rc; +} + +/* +** If it is currently unknown whether or not the FTS table has an %_stat +** table (if p->bHasStat==2), attempt to determine this (set p->bHasStat +** to 0 or 1). Return SQLITE_OK if successful, or an SQLite error code +** if an error occurs. +*/ +static int fts3SetHasStat(Fts3Table *p){ + int rc = SQLITE_OK; + if( p->bHasStat==2 ){ + char *zTbl = sqlite3_mprintf("%s_stat", p->zName); + if( zTbl ){ + int res = sqlite3_table_column_metadata(p->db, p->zDb, zTbl, 0,0,0,0,0,0); + sqlite3_free(zTbl); + p->bHasStat = (res==SQLITE_OK); + }else{ + rc = SQLITE_NOMEM; + } + } + return rc; +} + +/* +** Implementation of xBegin() method. +*/ +static int fts3BeginMethod(sqlite3_vtab *pVtab){ + Fts3Table *p = (Fts3Table*)pVtab; + int rc; + UNUSED_PARAMETER(pVtab); + assert( p->pSegments==0 ); + assert( p->nPendingData==0 ); + assert( p->inTransaction!=1 ); + p->nLeafAdd = 0; + rc = fts3SetHasStat(p); +#ifdef SQLITE_DEBUG + if( rc==SQLITE_OK ){ + p->inTransaction = 1; + p->mxSavepoint = -1; + } +#endif + return rc; +} + +/* +** Implementation of xCommit() method. This is a no-op. The contents of +** the pending-terms hash-table have already been flushed into the database +** by fts3SyncMethod(). +*/ +static int fts3CommitMethod(sqlite3_vtab *pVtab){ + TESTONLY( Fts3Table *p = (Fts3Table*)pVtab ); + UNUSED_PARAMETER(pVtab); + assert( p->nPendingData==0 ); + assert( p->inTransaction!=0 ); + assert( p->pSegments==0 ); + TESTONLY( p->inTransaction = 0 ); + TESTONLY( p->mxSavepoint = -1; ); + return SQLITE_OK; +} + +/* +** Implementation of xRollback(). Discard the contents of the pending-terms +** hash-table. Any changes made to the database are reverted by SQLite. +*/ +static int fts3RollbackMethod(sqlite3_vtab *pVtab){ + Fts3Table *p = (Fts3Table*)pVtab; + sqlite3Fts3PendingTermsClear(p); + assert( p->inTransaction!=0 ); + TESTONLY( p->inTransaction = 0 ); + TESTONLY( p->mxSavepoint = -1; ); + return SQLITE_OK; +} + +/* +** When called, *ppPoslist must point to the byte immediately following the +** end of a position-list. i.e. ( (*ppPoslist)[-1]==POS_END ). This function +** moves *ppPoslist so that it instead points to the first byte of the +** same position list. +*/ +static void fts3ReversePoslist(char *pStart, char **ppPoslist){ + char *p = &(*ppPoslist)[-2]; + char c = 0; + + /* Skip backwards passed any trailing 0x00 bytes added by NearTrim() */ + while( p>pStart && (c=*p--)==0 ); + + /* Search backwards for a varint with value zero (the end of the previous + ** poslist). This is an 0x00 byte preceded by some byte that does not + ** have the 0x80 bit set. */ + while( p>pStart && (*p & 0x80) | c ){ + c = *p--; + } + assert( p==pStart || c==0 ); + + /* At this point p points to that preceding byte without the 0x80 bit + ** set. So to find the start of the poslist, skip forward 2 bytes then + ** over a varint. + ** + ** Normally. The other case is that p==pStart and the poslist to return + ** is the first in the doclist. In this case do not skip forward 2 bytes. + ** The second part of the if condition (c==0 && *ppPoslist>&p[2]) + ** is required for cases where the first byte of a doclist and the + ** doclist is empty. For example, if the first docid is 10, a doclist + ** that begins with: + ** + ** 0x0A 0x00 + */ + if( p>pStart || (c==0 && *ppPoslist>&p[2]) ){ p = &p[2]; } + while( *p++&0x80 ); + *ppPoslist = p; +} + +/* +** Helper function used by the implementation of the overloaded snippet(), +** offsets() and optimize() SQL functions. +** +** If the value passed as the third argument is a blob of size +** sizeof(Fts3Cursor*), then the blob contents are copied to the +** output variable *ppCsr and SQLITE_OK is returned. Otherwise, an error +** message is written to context pContext and SQLITE_ERROR returned. The +** string passed via zFunc is used as part of the error message. +*/ +static int fts3FunctionArg( + sqlite3_context *pContext, /* SQL function call context */ + const char *zFunc, /* Function name */ + sqlite3_value *pVal, /* argv[0] passed to function */ + Fts3Cursor **ppCsr /* OUT: Store cursor handle here */ +){ + int rc; + *ppCsr = (Fts3Cursor*)sqlite3_value_pointer(pVal, "fts3cursor"); + if( (*ppCsr)!=0 ){ + rc = SQLITE_OK; + }else{ + char *zErr = sqlite3_mprintf("illegal first argument to %s", zFunc); + sqlite3_result_error(pContext, zErr, -1); + sqlite3_free(zErr); + rc = SQLITE_ERROR; + } + return rc; +} + +/* +** Implementation of the snippet() function for FTS3 +*/ +static void fts3SnippetFunc( + sqlite3_context *pContext, /* SQLite function call context */ + int nVal, /* Size of apVal[] array */ + sqlite3_value **apVal /* Array of arguments */ +){ + Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */ + const char *zStart = ""; + const char *zEnd = ""; + const char *zEllipsis = "..."; + int iCol = -1; + int nToken = 15; /* Default number of tokens in snippet */ + + /* There must be at least one argument passed to this function (otherwise + ** the non-overloaded version would have been called instead of this one). + */ + assert( nVal>=1 ); + + if( nVal>6 ){ + sqlite3_result_error(pContext, + "wrong number of arguments to function snippet()", -1); + return; + } + if( fts3FunctionArg(pContext, "snippet", apVal[0], &pCsr) ) return; + + switch( nVal ){ + case 6: nToken = sqlite3_value_int(apVal[5]); + /* no break */ deliberate_fall_through + case 5: iCol = sqlite3_value_int(apVal[4]); + /* no break */ deliberate_fall_through + case 4: zEllipsis = (const char*)sqlite3_value_text(apVal[3]); + /* no break */ deliberate_fall_through + case 3: zEnd = (const char*)sqlite3_value_text(apVal[2]); + /* no break */ deliberate_fall_through + case 2: zStart = (const char*)sqlite3_value_text(apVal[1]); + } + if( !zEllipsis || !zEnd || !zStart ){ + sqlite3_result_error_nomem(pContext); + }else if( nToken==0 ){ + sqlite3_result_text(pContext, "", -1, SQLITE_STATIC); + }else if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){ + sqlite3Fts3Snippet(pContext, pCsr, zStart, zEnd, zEllipsis, iCol, nToken); + } +} + +/* +** Implementation of the offsets() function for FTS3 +*/ +static void fts3OffsetsFunc( + sqlite3_context *pContext, /* SQLite function call context */ + int nVal, /* Size of argument array */ + sqlite3_value **apVal /* Array of arguments */ +){ + Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */ + + UNUSED_PARAMETER(nVal); + + assert( nVal==1 ); + if( fts3FunctionArg(pContext, "offsets", apVal[0], &pCsr) ) return; + assert( pCsr ); + if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){ + sqlite3Fts3Offsets(pContext, pCsr); + } +} + +/* +** Implementation of the special optimize() function for FTS3. This +** function merges all segments in the database to a single segment. +** Example usage is: +** +** SELECT optimize(t) FROM t LIMIT 1; +** +** where 't' is the name of an FTS3 table. +*/ +static void fts3OptimizeFunc( + sqlite3_context *pContext, /* SQLite function call context */ + int nVal, /* Size of argument array */ + sqlite3_value **apVal /* Array of arguments */ +){ + int rc; /* Return code */ + Fts3Table *p; /* Virtual table handle */ + Fts3Cursor *pCursor; /* Cursor handle passed through apVal[0] */ + + UNUSED_PARAMETER(nVal); + + assert( nVal==1 ); + if( fts3FunctionArg(pContext, "optimize", apVal[0], &pCursor) ) return; + p = (Fts3Table *)pCursor->base.pVtab; + assert( p ); + + rc = sqlite3Fts3Optimize(p); + + switch( rc ){ + case SQLITE_OK: + sqlite3_result_text(pContext, "Index optimized", -1, SQLITE_STATIC); + break; + case SQLITE_DONE: + sqlite3_result_text(pContext, "Index already optimal", -1, SQLITE_STATIC); + break; + default: + sqlite3_result_error_code(pContext, rc); + break; + } +} + +/* +** Implementation of the matchinfo() function for FTS3 +*/ +static void fts3MatchinfoFunc( + sqlite3_context *pContext, /* SQLite function call context */ + int nVal, /* Size of argument array */ + sqlite3_value **apVal /* Array of arguments */ +){ + Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */ + assert( nVal==1 || nVal==2 ); + if( SQLITE_OK==fts3FunctionArg(pContext, "matchinfo", apVal[0], &pCsr) ){ + const char *zArg = 0; + if( nVal>1 ){ + zArg = (const char *)sqlite3_value_text(apVal[1]); + } + sqlite3Fts3Matchinfo(pContext, pCsr, zArg); + } +} + +/* +** This routine implements the xFindFunction method for the FTS3 +** virtual table. +*/ +static int fts3FindFunctionMethod( + sqlite3_vtab *pVtab, /* Virtual table handle */ + int nArg, /* Number of SQL function arguments */ + const char *zName, /* Name of SQL function */ + void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), /* OUT: Result */ + void **ppArg /* Unused */ +){ + struct Overloaded { + const char *zName; + void (*xFunc)(sqlite3_context*,int,sqlite3_value**); + } aOverload[] = { + { "snippet", fts3SnippetFunc }, + { "offsets", fts3OffsetsFunc }, + { "optimize", fts3OptimizeFunc }, + { "matchinfo", fts3MatchinfoFunc }, + }; + int i; /* Iterator variable */ + + UNUSED_PARAMETER(pVtab); + UNUSED_PARAMETER(nArg); + UNUSED_PARAMETER(ppArg); + + for(i=0; idb; /* Database connection */ + int rc; /* Return Code */ + + /* At this point it must be known if the %_stat table exists or not. + ** So bHasStat may not be 2. */ + rc = fts3SetHasStat(p); + + /* As it happens, the pending terms table is always empty here. This is + ** because an "ALTER TABLE RENAME TABLE" statement inside a transaction + ** always opens a savepoint transaction. And the xSavepoint() method + ** flushes the pending terms table. But leave the (no-op) call to + ** PendingTermsFlush() in in case that changes. + */ + assert( p->nPendingData==0 ); + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3PendingTermsFlush(p); + } + + if( p->zContentTbl==0 ){ + fts3DbExec(&rc, db, + "ALTER TABLE %Q.'%q_content' RENAME TO '%q_content';", + p->zDb, p->zName, zName + ); + } + + if( p->bHasDocsize ){ + fts3DbExec(&rc, db, + "ALTER TABLE %Q.'%q_docsize' RENAME TO '%q_docsize';", + p->zDb, p->zName, zName + ); + } + if( p->bHasStat ){ + fts3DbExec(&rc, db, + "ALTER TABLE %Q.'%q_stat' RENAME TO '%q_stat';", + p->zDb, p->zName, zName + ); + } + fts3DbExec(&rc, db, + "ALTER TABLE %Q.'%q_segments' RENAME TO '%q_segments';", + p->zDb, p->zName, zName + ); + fts3DbExec(&rc, db, + "ALTER TABLE %Q.'%q_segdir' RENAME TO '%q_segdir';", + p->zDb, p->zName, zName + ); + return rc; +} + +/* +** The xSavepoint() method. +** +** Flush the contents of the pending-terms table to disk. +*/ +static int fts3SavepointMethod(sqlite3_vtab *pVtab, int iSavepoint){ + int rc = SQLITE_OK; + UNUSED_PARAMETER(iSavepoint); + assert( ((Fts3Table *)pVtab)->inTransaction ); + assert( ((Fts3Table *)pVtab)->mxSavepoint <= iSavepoint ); + TESTONLY( ((Fts3Table *)pVtab)->mxSavepoint = iSavepoint ); + if( ((Fts3Table *)pVtab)->bIgnoreSavepoint==0 ){ + rc = fts3SyncMethod(pVtab); + } + return rc; +} + +/* +** The xRelease() method. +** +** This is a no-op. +*/ +static int fts3ReleaseMethod(sqlite3_vtab *pVtab, int iSavepoint){ + TESTONLY( Fts3Table *p = (Fts3Table*)pVtab ); + UNUSED_PARAMETER(iSavepoint); + UNUSED_PARAMETER(pVtab); + assert( p->inTransaction ); + assert( p->mxSavepoint >= iSavepoint ); + TESTONLY( p->mxSavepoint = iSavepoint-1 ); + return SQLITE_OK; +} + +/* +** The xRollbackTo() method. +** +** Discard the contents of the pending terms table. +*/ +static int fts3RollbackToMethod(sqlite3_vtab *pVtab, int iSavepoint){ + Fts3Table *p = (Fts3Table*)pVtab; + UNUSED_PARAMETER(iSavepoint); + assert( p->inTransaction ); + TESTONLY( p->mxSavepoint = iSavepoint ); + sqlite3Fts3PendingTermsClear(p); + return SQLITE_OK; +} + +/* +** Return true if zName is the extension on one of the shadow tables used +** by this module. +*/ +static int fts3ShadowName(const char *zName){ + static const char *azName[] = { + "content", "docsize", "segdir", "segments", "stat", + }; + unsigned int i; + for(i=0; inRef--; + if( pHash->nRef<=0 ){ + sqlite3Fts3HashClear(&pHash->hash); + sqlite3_free(pHash); + } +} + +/* +** The fts3 built-in tokenizers - "simple", "porter" and "icu"- are +** implemented in files fts3_tokenizer1.c, fts3_porter.c and fts3_icu.c +** respectively. The following three forward declarations are for functions +** declared in these files used to retrieve the respective implementations. +** +** Calling sqlite3Fts3SimpleTokenizerModule() sets the value pointed +** to by the argument to point to the "simple" tokenizer implementation. +** And so on. +*/ +SQLITE_PRIVATE void sqlite3Fts3SimpleTokenizerModule(sqlite3_tokenizer_module const**ppModule); +SQLITE_PRIVATE void sqlite3Fts3PorterTokenizerModule(sqlite3_tokenizer_module const**ppModule); +#ifndef SQLITE_DISABLE_FTS3_UNICODE +SQLITE_PRIVATE void sqlite3Fts3UnicodeTokenizer(sqlite3_tokenizer_module const**ppModule); +#endif +#ifdef SQLITE_ENABLE_ICU +SQLITE_PRIVATE void sqlite3Fts3IcuTokenizerModule(sqlite3_tokenizer_module const**ppModule); +#endif + +/* +** Initialize the fts3 extension. If this extension is built as part +** of the sqlite library, then this function is called directly by +** SQLite. If fts3 is built as a dynamically loadable extension, this +** function is called by the sqlite3_extension_init() entry point. +*/ +SQLITE_PRIVATE int sqlite3Fts3Init(sqlite3 *db){ + int rc = SQLITE_OK; + Fts3HashWrapper *pHash = 0; + const sqlite3_tokenizer_module *pSimple = 0; + const sqlite3_tokenizer_module *pPorter = 0; +#ifndef SQLITE_DISABLE_FTS3_UNICODE + const sqlite3_tokenizer_module *pUnicode = 0; +#endif + +#ifdef SQLITE_ENABLE_ICU + const sqlite3_tokenizer_module *pIcu = 0; + sqlite3Fts3IcuTokenizerModule(&pIcu); +#endif + +#ifndef SQLITE_DISABLE_FTS3_UNICODE + sqlite3Fts3UnicodeTokenizer(&pUnicode); +#endif + +#ifdef SQLITE_TEST + rc = sqlite3Fts3InitTerm(db); + if( rc!=SQLITE_OK ) return rc; +#endif + + rc = sqlite3Fts3InitAux(db); + if( rc!=SQLITE_OK ) return rc; + + sqlite3Fts3SimpleTokenizerModule(&pSimple); + sqlite3Fts3PorterTokenizerModule(&pPorter); + + /* Allocate and initialize the hash-table used to store tokenizers. */ + pHash = sqlite3_malloc(sizeof(Fts3HashWrapper)); + if( !pHash ){ + rc = SQLITE_NOMEM; + }else{ + sqlite3Fts3HashInit(&pHash->hash, FTS3_HASH_STRING, 1); + pHash->nRef = 0; + } + + /* Load the built-in tokenizers into the hash table */ + if( rc==SQLITE_OK ){ + if( sqlite3Fts3HashInsert(&pHash->hash, "simple", 7, (void *)pSimple) + || sqlite3Fts3HashInsert(&pHash->hash, "porter", 7, (void *)pPorter) + +#ifndef SQLITE_DISABLE_FTS3_UNICODE + || sqlite3Fts3HashInsert(&pHash->hash, "unicode61", 10, (void *)pUnicode) +#endif +#ifdef SQLITE_ENABLE_ICU + || (pIcu && sqlite3Fts3HashInsert(&pHash->hash, "icu", 4, (void *)pIcu)) +#endif + ){ + rc = SQLITE_NOMEM; + } + } + +#ifdef SQLITE_TEST + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3ExprInitTestInterface(db, &pHash->hash); + } +#endif + + /* Create the virtual table wrapper around the hash-table and overload + ** the four scalar functions. If this is successful, register the + ** module with sqlite. + */ + if( SQLITE_OK==rc + && SQLITE_OK==(rc=sqlite3Fts3InitHashTable(db,&pHash->hash,"fts3_tokenizer")) + && SQLITE_OK==(rc = sqlite3_overload_function(db, "snippet", -1)) + && SQLITE_OK==(rc = sqlite3_overload_function(db, "offsets", 1)) + && SQLITE_OK==(rc = sqlite3_overload_function(db, "matchinfo", 1)) + && SQLITE_OK==(rc = sqlite3_overload_function(db, "matchinfo", 2)) + && SQLITE_OK==(rc = sqlite3_overload_function(db, "optimize", 1)) + ){ + pHash->nRef++; + rc = sqlite3_create_module_v2( + db, "fts3", &fts3Module, (void *)pHash, hashDestroy + ); + if( rc==SQLITE_OK ){ + pHash->nRef++; + rc = sqlite3_create_module_v2( + db, "fts4", &fts3Module, (void *)pHash, hashDestroy + ); + } + if( rc==SQLITE_OK ){ + pHash->nRef++; + rc = sqlite3Fts3InitTok(db, (void *)pHash, hashDestroy); + } + return rc; + } + + + /* An error has occurred. Delete the hash table and return the error code. */ + assert( rc!=SQLITE_OK ); + if( pHash ){ + sqlite3Fts3HashClear(&pHash->hash); + sqlite3_free(pHash); + } + return rc; +} + +/* +** Allocate an Fts3MultiSegReader for each token in the expression headed +** by pExpr. +** +** An Fts3SegReader object is a cursor that can seek or scan a range of +** entries within a single segment b-tree. An Fts3MultiSegReader uses multiple +** Fts3SegReader objects internally to provide an interface to seek or scan +** within the union of all segments of a b-tree. Hence the name. +** +** If the allocated Fts3MultiSegReader just seeks to a single entry in a +** segment b-tree (if the term is not a prefix or it is a prefix for which +** there exists prefix b-tree of the right length) then it may be traversed +** and merged incrementally. Otherwise, it has to be merged into an in-memory +** doclist and then traversed. +*/ +static void fts3EvalAllocateReaders( + Fts3Cursor *pCsr, /* FTS cursor handle */ + Fts3Expr *pExpr, /* Allocate readers for this expression */ + int *pnToken, /* OUT: Total number of tokens in phrase. */ + int *pnOr, /* OUT: Total number of OR nodes in expr. */ + int *pRc /* IN/OUT: Error code */ +){ + if( pExpr && SQLITE_OK==*pRc ){ + if( pExpr->eType==FTSQUERY_PHRASE ){ + int i; + int nToken = pExpr->pPhrase->nToken; + *pnToken += nToken; + for(i=0; ipPhrase->aToken[i]; + int rc = fts3TermSegReaderCursor(pCsr, + pToken->z, pToken->n, pToken->isPrefix, &pToken->pSegcsr + ); + if( rc!=SQLITE_OK ){ + *pRc = rc; + return; + } + } + assert( pExpr->pPhrase->iDoclistToken==0 ); + pExpr->pPhrase->iDoclistToken = -1; + }else{ + *pnOr += (pExpr->eType==FTSQUERY_OR); + fts3EvalAllocateReaders(pCsr, pExpr->pLeft, pnToken, pnOr, pRc); + fts3EvalAllocateReaders(pCsr, pExpr->pRight, pnToken, pnOr, pRc); + } + } +} + +/* +** Arguments pList/nList contain the doclist for token iToken of phrase p. +** It is merged into the main doclist stored in p->doclist.aAll/nAll. +** +** This function assumes that pList points to a buffer allocated using +** sqlite3_malloc(). This function takes responsibility for eventually +** freeing the buffer. +** +** SQLITE_OK is returned if successful, or SQLITE_NOMEM if an error occurs. +*/ +static int fts3EvalPhraseMergeToken( + Fts3Table *pTab, /* FTS Table pointer */ + Fts3Phrase *p, /* Phrase to merge pList/nList into */ + int iToken, /* Token pList/nList corresponds to */ + char *pList, /* Pointer to doclist */ + int nList /* Number of bytes in pList */ +){ + int rc = SQLITE_OK; + assert( iToken!=p->iDoclistToken ); + + if( pList==0 ){ + sqlite3_free(p->doclist.aAll); + p->doclist.aAll = 0; + p->doclist.nAll = 0; + } + + else if( p->iDoclistToken<0 ){ + p->doclist.aAll = pList; + p->doclist.nAll = nList; + } + + else if( p->doclist.aAll==0 ){ + sqlite3_free(pList); + } + + else { + char *pLeft; + char *pRight; + int nLeft; + int nRight; + int nDiff; + + if( p->iDoclistTokendoclist.aAll; + nLeft = p->doclist.nAll; + pRight = pList; + nRight = nList; + nDiff = iToken - p->iDoclistToken; + }else{ + pRight = p->doclist.aAll; + nRight = p->doclist.nAll; + pLeft = pList; + nLeft = nList; + nDiff = p->iDoclistToken - iToken; + } + + rc = fts3DoclistPhraseMerge( + pTab->bDescIdx, nDiff, pLeft, nLeft, &pRight, &nRight + ); + sqlite3_free(pLeft); + p->doclist.aAll = pRight; + p->doclist.nAll = nRight; + } + + if( iToken>p->iDoclistToken ) p->iDoclistToken = iToken; + return rc; +} + +/* +** Load the doclist for phrase p into p->doclist.aAll/nAll. The loaded doclist +** does not take deferred tokens into account. +** +** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code. +*/ +static int fts3EvalPhraseLoad( + Fts3Cursor *pCsr, /* FTS Cursor handle */ + Fts3Phrase *p /* Phrase object */ +){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int iToken; + int rc = SQLITE_OK; + + for(iToken=0; rc==SQLITE_OK && iTokennToken; iToken++){ + Fts3PhraseToken *pToken = &p->aToken[iToken]; + assert( pToken->pDeferred==0 || pToken->pSegcsr==0 ); + + if( pToken->pSegcsr ){ + int nThis = 0; + char *pThis = 0; + rc = fts3TermSelect(pTab, pToken, p->iColumn, &nThis, &pThis); + if( rc==SQLITE_OK ){ + rc = fts3EvalPhraseMergeToken(pTab, p, iToken, pThis, nThis); + } + } + assert( pToken->pSegcsr==0 ); + } + + return rc; +} + +#ifndef SQLITE_DISABLE_FTS4_DEFERRED +/* +** This function is called on each phrase after the position lists for +** any deferred tokens have been loaded into memory. It updates the phrases +** current position list to include only those positions that are really +** instances of the phrase (after considering deferred tokens). If this +** means that the phrase does not appear in the current row, doclist.pList +** and doclist.nList are both zeroed. +** +** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code. +*/ +static int fts3EvalDeferredPhrase(Fts3Cursor *pCsr, Fts3Phrase *pPhrase){ + int iToken; /* Used to iterate through phrase tokens */ + char *aPoslist = 0; /* Position list for deferred tokens */ + int nPoslist = 0; /* Number of bytes in aPoslist */ + int iPrev = -1; /* Token number of previous deferred token */ + char *aFree = (pPhrase->doclist.bFreeList ? pPhrase->doclist.pList : 0); + + for(iToken=0; iTokennToken; iToken++){ + Fts3PhraseToken *pToken = &pPhrase->aToken[iToken]; + Fts3DeferredToken *pDeferred = pToken->pDeferred; + + if( pDeferred ){ + char *pList; + int nList; + int rc = sqlite3Fts3DeferredTokenList(pDeferred, &pList, &nList); + if( rc!=SQLITE_OK ) return rc; + + if( pList==0 ){ + sqlite3_free(aPoslist); + sqlite3_free(aFree); + pPhrase->doclist.pList = 0; + pPhrase->doclist.nList = 0; + return SQLITE_OK; + + }else if( aPoslist==0 ){ + aPoslist = pList; + nPoslist = nList; + + }else{ + char *aOut = pList; + char *p1 = aPoslist; + char *p2 = aOut; + + assert( iPrev>=0 ); + fts3PoslistPhraseMerge(&aOut, iToken-iPrev, 0, 1, &p1, &p2); + sqlite3_free(aPoslist); + aPoslist = pList; + nPoslist = (int)(aOut - aPoslist); + if( nPoslist==0 ){ + sqlite3_free(aPoslist); + sqlite3_free(aFree); + pPhrase->doclist.pList = 0; + pPhrase->doclist.nList = 0; + return SQLITE_OK; + } + } + iPrev = iToken; + } + } + + if( iPrev>=0 ){ + int nMaxUndeferred = pPhrase->iDoclistToken; + if( nMaxUndeferred<0 ){ + pPhrase->doclist.pList = aPoslist; + pPhrase->doclist.nList = nPoslist; + pPhrase->doclist.iDocid = pCsr->iPrevId; + pPhrase->doclist.bFreeList = 1; + }else{ + int nDistance; + char *p1; + char *p2; + char *aOut; + + if( nMaxUndeferred>iPrev ){ + p1 = aPoslist; + p2 = pPhrase->doclist.pList; + nDistance = nMaxUndeferred - iPrev; + }else{ + p1 = pPhrase->doclist.pList; + p2 = aPoslist; + nDistance = iPrev - nMaxUndeferred; + } + + aOut = (char *)sqlite3Fts3MallocZero(nPoslist+FTS3_BUFFER_PADDING); + if( !aOut ){ + sqlite3_free(aPoslist); + return SQLITE_NOMEM; + } + + pPhrase->doclist.pList = aOut; + assert( p1 && p2 ); + if( fts3PoslistPhraseMerge(&aOut, nDistance, 0, 1, &p1, &p2) ){ + pPhrase->doclist.bFreeList = 1; + pPhrase->doclist.nList = (int)(aOut - pPhrase->doclist.pList); + }else{ + sqlite3_free(aOut); + pPhrase->doclist.pList = 0; + pPhrase->doclist.nList = 0; + } + sqlite3_free(aPoslist); + } + } + + if( pPhrase->doclist.pList!=aFree ) sqlite3_free(aFree); + return SQLITE_OK; +} +#endif /* SQLITE_DISABLE_FTS4_DEFERRED */ + +/* +** Maximum number of tokens a phrase may have to be considered for the +** incremental doclists strategy. +*/ +#define MAX_INCR_PHRASE_TOKENS 4 + +/* +** This function is called for each Fts3Phrase in a full-text query +** expression to initialize the mechanism for returning rows. Once this +** function has been called successfully on an Fts3Phrase, it may be +** used with fts3EvalPhraseNext() to iterate through the matching docids. +** +** If parameter bOptOk is true, then the phrase may (or may not) use the +** incremental loading strategy. Otherwise, the entire doclist is loaded into +** memory within this call. +** +** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code. +*/ +static int fts3EvalPhraseStart(Fts3Cursor *pCsr, int bOptOk, Fts3Phrase *p){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int rc = SQLITE_OK; /* Error code */ + int i; + + /* Determine if doclists may be loaded from disk incrementally. This is + ** possible if the bOptOk argument is true, the FTS doclists will be + ** scanned in forward order, and the phrase consists of + ** MAX_INCR_PHRASE_TOKENS or fewer tokens, none of which are are "^first" + ** tokens or prefix tokens that cannot use a prefix-index. */ + int bHaveIncr = 0; + int bIncrOk = (bOptOk + && pCsr->bDesc==pTab->bDescIdx + && p->nToken<=MAX_INCR_PHRASE_TOKENS && p->nToken>0 +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + && pTab->bNoIncrDoclist==0 +#endif + ); + for(i=0; bIncrOk==1 && inToken; i++){ + Fts3PhraseToken *pToken = &p->aToken[i]; + if( pToken->bFirst || (pToken->pSegcsr!=0 && !pToken->pSegcsr->bLookup) ){ + bIncrOk = 0; + } + if( pToken->pSegcsr ) bHaveIncr = 1; + } + + if( bIncrOk && bHaveIncr ){ + /* Use the incremental approach. */ + int iCol = (p->iColumn >= pTab->nColumn ? -1 : p->iColumn); + for(i=0; rc==SQLITE_OK && inToken; i++){ + Fts3PhraseToken *pToken = &p->aToken[i]; + Fts3MultiSegReader *pSegcsr = pToken->pSegcsr; + if( pSegcsr ){ + rc = sqlite3Fts3MsrIncrStart(pTab, pSegcsr, iCol, pToken->z, pToken->n); + } + } + p->bIncr = 1; + }else{ + /* Load the full doclist for the phrase into memory. */ + rc = fts3EvalPhraseLoad(pCsr, p); + p->bIncr = 0; + } + + assert( rc!=SQLITE_OK || p->nToken<1 || p->aToken[0].pSegcsr==0 || p->bIncr ); + return rc; +} + +/* +** This function is used to iterate backwards (from the end to start) +** through doclists. It is used by this module to iterate through phrase +** doclists in reverse and by the fts3_write.c module to iterate through +** pending-terms lists when writing to databases with "order=desc". +** +** The doclist may be sorted in ascending (parameter bDescIdx==0) or +** descending (parameter bDescIdx==1) order of docid. Regardless, this +** function iterates from the end of the doclist to the beginning. +*/ +SQLITE_PRIVATE void sqlite3Fts3DoclistPrev( + int bDescIdx, /* True if the doclist is desc */ + char *aDoclist, /* Pointer to entire doclist */ + int nDoclist, /* Length of aDoclist in bytes */ + char **ppIter, /* IN/OUT: Iterator pointer */ + sqlite3_int64 *piDocid, /* IN/OUT: Docid pointer */ + int *pnList, /* OUT: List length pointer */ + u8 *pbEof /* OUT: End-of-file flag */ +){ + char *p = *ppIter; + + assert( nDoclist>0 ); + assert( *pbEof==0 ); + assert_fts3_nc( p || *piDocid==0 ); + assert( !p || (p>aDoclist && p<&aDoclist[nDoclist]) ); + + if( p==0 ){ + sqlite3_int64 iDocid = 0; + char *pNext = 0; + char *pDocid = aDoclist; + char *pEnd = &aDoclist[nDoclist]; + int iMul = 1; + + while( pDocid0 ); + assert( *pbEof==0 ); + assert_fts3_nc( p || *piDocid==0 ); + assert( !p || (p>=aDoclist && p<=&aDoclist[nDoclist]) ); + + if( p==0 ){ + p = aDoclist; + p += sqlite3Fts3GetVarint(p, piDocid); + }else{ + fts3PoslistCopy(0, &p); + while( p<&aDoclist[nDoclist] && *p==0 ) p++; + if( p>=&aDoclist[nDoclist] ){ + *pbEof = 1; + }else{ + sqlite3_int64 iVar; + p += sqlite3Fts3GetVarint(p, &iVar); + *piDocid += ((bDescIdx ? -1 : 1) * iVar); + } + } + + *ppIter = p; +} + +/* +** Advance the iterator pDL to the next entry in pDL->aAll/nAll. Set *pbEof +** to true if EOF is reached. +*/ +static void fts3EvalDlPhraseNext( + Fts3Table *pTab, + Fts3Doclist *pDL, + u8 *pbEof +){ + char *pIter; /* Used to iterate through aAll */ + char *pEnd; /* 1 byte past end of aAll */ + + if( pDL->pNextDocid ){ + pIter = pDL->pNextDocid; + assert( pDL->aAll!=0 || pIter==0 ); + }else{ + pIter = pDL->aAll; + } + + if( pIter==0 || pIter>=(pEnd = pDL->aAll + pDL->nAll) ){ + /* We have already reached the end of this doclist. EOF. */ + *pbEof = 1; + }else{ + sqlite3_int64 iDelta; + pIter += sqlite3Fts3GetVarint(pIter, &iDelta); + if( pTab->bDescIdx==0 || pDL->pNextDocid==0 ){ + pDL->iDocid += iDelta; + }else{ + pDL->iDocid -= iDelta; + } + pDL->pList = pIter; + fts3PoslistCopy(0, &pIter); + pDL->nList = (int)(pIter - pDL->pList); + + /* pIter now points just past the 0x00 that terminates the position- + ** list for document pDL->iDocid. However, if this position-list was + ** edited in place by fts3EvalNearTrim(), then pIter may not actually + ** point to the start of the next docid value. The following line deals + ** with this case by advancing pIter past the zero-padding added by + ** fts3EvalNearTrim(). */ + while( pIterpNextDocid = pIter; + assert( pIter>=&pDL->aAll[pDL->nAll] || *pIter ); + *pbEof = 0; + } +} + +/* +** Helper type used by fts3EvalIncrPhraseNext() and incrPhraseTokenNext(). +*/ +typedef struct TokenDoclist TokenDoclist; +struct TokenDoclist { + int bIgnore; + sqlite3_int64 iDocid; + char *pList; + int nList; +}; + +/* +** Token pToken is an incrementally loaded token that is part of a +** multi-token phrase. Advance it to the next matching document in the +** database and populate output variable *p with the details of the new +** entry. Or, if the iterator has reached EOF, set *pbEof to true. +** +** If an error occurs, return an SQLite error code. Otherwise, return +** SQLITE_OK. +*/ +static int incrPhraseTokenNext( + Fts3Table *pTab, /* Virtual table handle */ + Fts3Phrase *pPhrase, /* Phrase to advance token of */ + int iToken, /* Specific token to advance */ + TokenDoclist *p, /* OUT: Docid and doclist for new entry */ + u8 *pbEof /* OUT: True if iterator is at EOF */ +){ + int rc = SQLITE_OK; + + if( pPhrase->iDoclistToken==iToken ){ + assert( p->bIgnore==0 ); + assert( pPhrase->aToken[iToken].pSegcsr==0 ); + fts3EvalDlPhraseNext(pTab, &pPhrase->doclist, pbEof); + p->pList = pPhrase->doclist.pList; + p->nList = pPhrase->doclist.nList; + p->iDocid = pPhrase->doclist.iDocid; + }else{ + Fts3PhraseToken *pToken = &pPhrase->aToken[iToken]; + assert( pToken->pDeferred==0 ); + assert( pToken->pSegcsr || pPhrase->iDoclistToken>=0 ); + if( pToken->pSegcsr ){ + assert( p->bIgnore==0 ); + rc = sqlite3Fts3MsrIncrNext( + pTab, pToken->pSegcsr, &p->iDocid, &p->pList, &p->nList + ); + if( p->pList==0 ) *pbEof = 1; + }else{ + p->bIgnore = 1; + } + } + + return rc; +} + + +/* +** The phrase iterator passed as the second argument: +** +** * features at least one token that uses an incremental doclist, and +** +** * does not contain any deferred tokens. +** +** Advance it to the next matching documnent in the database and populate +** the Fts3Doclist.pList and nList fields. +** +** If there is no "next" entry and no error occurs, then *pbEof is set to +** 1 before returning. Otherwise, if no error occurs and the iterator is +** successfully advanced, *pbEof is set to 0. +** +** If an error occurs, return an SQLite error code. Otherwise, return +** SQLITE_OK. +*/ +static int fts3EvalIncrPhraseNext( + Fts3Cursor *pCsr, /* FTS Cursor handle */ + Fts3Phrase *p, /* Phrase object to advance to next docid */ + u8 *pbEof /* OUT: Set to 1 if EOF */ +){ + int rc = SQLITE_OK; + Fts3Doclist *pDL = &p->doclist; + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + u8 bEof = 0; + + /* This is only called if it is guaranteed that the phrase has at least + ** one incremental token. In which case the bIncr flag is set. */ + assert( p->bIncr==1 ); + + if( p->nToken==1 ){ + rc = sqlite3Fts3MsrIncrNext(pTab, p->aToken[0].pSegcsr, + &pDL->iDocid, &pDL->pList, &pDL->nList + ); + if( pDL->pList==0 ) bEof = 1; + }else{ + int bDescDoclist = pCsr->bDesc; + struct TokenDoclist a[MAX_INCR_PHRASE_TOKENS]; + + memset(a, 0, sizeof(a)); + assert( p->nToken<=MAX_INCR_PHRASE_TOKENS ); + assert( p->iDoclistTokennToken && bEof==0; i++){ + rc = incrPhraseTokenNext(pTab, p, i, &a[i], &bEof); + if( a[i].bIgnore==0 && (bMaxSet==0 || DOCID_CMP(iMax, a[i].iDocid)<0) ){ + iMax = a[i].iDocid; + bMaxSet = 1; + } + } + assert( rc!=SQLITE_OK || (p->nToken>=1 && a[p->nToken-1].bIgnore==0) ); + assert( rc!=SQLITE_OK || bMaxSet ); + + /* Keep advancing iterators until they all point to the same document */ + for(i=0; inToken; i++){ + while( rc==SQLITE_OK && bEof==0 + && a[i].bIgnore==0 && DOCID_CMP(a[i].iDocid, iMax)<0 + ){ + rc = incrPhraseTokenNext(pTab, p, i, &a[i], &bEof); + if( DOCID_CMP(a[i].iDocid, iMax)>0 ){ + iMax = a[i].iDocid; + i = 0; + } + } + } + + /* Check if the current entries really are a phrase match */ + if( bEof==0 ){ + int nList = 0; + int nByte = a[p->nToken-1].nList; + char *aDoclist = sqlite3_malloc64((i64)nByte+FTS3_BUFFER_PADDING); + if( !aDoclist ) return SQLITE_NOMEM; + memcpy(aDoclist, a[p->nToken-1].pList, nByte+1); + memset(&aDoclist[nByte], 0, FTS3_BUFFER_PADDING); + + for(i=0; i<(p->nToken-1); i++){ + if( a[i].bIgnore==0 ){ + char *pL = a[i].pList; + char *pR = aDoclist; + char *pOut = aDoclist; + int nDist = p->nToken-1-i; + int res = fts3PoslistPhraseMerge(&pOut, nDist, 0, 1, &pL, &pR); + if( res==0 ) break; + nList = (int)(pOut - aDoclist); + } + } + if( i==(p->nToken-1) ){ + pDL->iDocid = iMax; + pDL->pList = aDoclist; + pDL->nList = nList; + pDL->bFreeList = 1; + break; + } + sqlite3_free(aDoclist); + } + } + } + + *pbEof = bEof; + return rc; +} + +/* +** Attempt to move the phrase iterator to point to the next matching docid. +** If an error occurs, return an SQLite error code. Otherwise, return +** SQLITE_OK. +** +** If there is no "next" entry and no error occurs, then *pbEof is set to +** 1 before returning. Otherwise, if no error occurs and the iterator is +** successfully advanced, *pbEof is set to 0. +*/ +static int fts3EvalPhraseNext( + Fts3Cursor *pCsr, /* FTS Cursor handle */ + Fts3Phrase *p, /* Phrase object to advance to next docid */ + u8 *pbEof /* OUT: Set to 1 if EOF */ +){ + int rc = SQLITE_OK; + Fts3Doclist *pDL = &p->doclist; + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + + if( p->bIncr ){ + rc = fts3EvalIncrPhraseNext(pCsr, p, pbEof); + }else if( pCsr->bDesc!=pTab->bDescIdx && pDL->nAll ){ + sqlite3Fts3DoclistPrev(pTab->bDescIdx, pDL->aAll, pDL->nAll, + &pDL->pNextDocid, &pDL->iDocid, &pDL->nList, pbEof + ); + pDL->pList = pDL->pNextDocid; + }else{ + fts3EvalDlPhraseNext(pTab, pDL, pbEof); + } + + return rc; +} + +/* +** +** If *pRc is not SQLITE_OK when this function is called, it is a no-op. +** Otherwise, fts3EvalPhraseStart() is called on all phrases within the +** expression. Also the Fts3Expr.bDeferred variable is set to true for any +** expressions for which all descendent tokens are deferred. +** +** If parameter bOptOk is zero, then it is guaranteed that the +** Fts3Phrase.doclist.aAll/nAll variables contain the entire doclist for +** each phrase in the expression (subject to deferred token processing). +** Or, if bOptOk is non-zero, then one or more tokens within the expression +** may be loaded incrementally, meaning doclist.aAll/nAll is not available. +** +** If an error occurs within this function, *pRc is set to an SQLite error +** code before returning. +*/ +static void fts3EvalStartReaders( + Fts3Cursor *pCsr, /* FTS Cursor handle */ + Fts3Expr *pExpr, /* Expression to initialize phrases in */ + int *pRc /* IN/OUT: Error code */ +){ + if( pExpr && SQLITE_OK==*pRc ){ + if( pExpr->eType==FTSQUERY_PHRASE ){ + int nToken = pExpr->pPhrase->nToken; + if( nToken ){ + int i; + for(i=0; ipPhrase->aToken[i].pDeferred==0 ) break; + } + pExpr->bDeferred = (i==nToken); + } + *pRc = fts3EvalPhraseStart(pCsr, 1, pExpr->pPhrase); + }else{ + fts3EvalStartReaders(pCsr, pExpr->pLeft, pRc); + fts3EvalStartReaders(pCsr, pExpr->pRight, pRc); + pExpr->bDeferred = (pExpr->pLeft->bDeferred && pExpr->pRight->bDeferred); + } + } +} + +/* +** An array of the following structures is assembled as part of the process +** of selecting tokens to defer before the query starts executing (as part +** of the xFilter() method). There is one element in the array for each +** token in the FTS expression. +** +** Tokens are divided into AND/NEAR clusters. All tokens in a cluster belong +** to phrases that are connected only by AND and NEAR operators (not OR or +** NOT). When determining tokens to defer, each AND/NEAR cluster is considered +** separately. The root of a tokens AND/NEAR cluster is stored in +** Fts3TokenAndCost.pRoot. +*/ +typedef struct Fts3TokenAndCost Fts3TokenAndCost; +struct Fts3TokenAndCost { + Fts3Phrase *pPhrase; /* The phrase the token belongs to */ + int iToken; /* Position of token in phrase */ + Fts3PhraseToken *pToken; /* The token itself */ + Fts3Expr *pRoot; /* Root of NEAR/AND cluster */ + int nOvfl; /* Number of overflow pages to load doclist */ + int iCol; /* The column the token must match */ +}; + +/* +** This function is used to populate an allocated Fts3TokenAndCost array. +** +** If *pRc is not SQLITE_OK when this function is called, it is a no-op. +** Otherwise, if an error occurs during execution, *pRc is set to an +** SQLite error code. +*/ +static void fts3EvalTokenCosts( + Fts3Cursor *pCsr, /* FTS Cursor handle */ + Fts3Expr *pRoot, /* Root of current AND/NEAR cluster */ + Fts3Expr *pExpr, /* Expression to consider */ + Fts3TokenAndCost **ppTC, /* Write new entries to *(*ppTC)++ */ + Fts3Expr ***ppOr, /* Write new OR root to *(*ppOr)++ */ + int *pRc /* IN/OUT: Error code */ +){ + if( *pRc==SQLITE_OK ){ + if( pExpr->eType==FTSQUERY_PHRASE ){ + Fts3Phrase *pPhrase = pExpr->pPhrase; + int i; + for(i=0; *pRc==SQLITE_OK && inToken; i++){ + Fts3TokenAndCost *pTC = (*ppTC)++; + pTC->pPhrase = pPhrase; + pTC->iToken = i; + pTC->pRoot = pRoot; + pTC->pToken = &pPhrase->aToken[i]; + pTC->iCol = pPhrase->iColumn; + *pRc = sqlite3Fts3MsrOvfl(pCsr, pTC->pToken->pSegcsr, &pTC->nOvfl); + } + }else if( pExpr->eType!=FTSQUERY_NOT ){ + assert( pExpr->eType==FTSQUERY_OR + || pExpr->eType==FTSQUERY_AND + || pExpr->eType==FTSQUERY_NEAR + ); + assert( pExpr->pLeft && pExpr->pRight ); + if( pExpr->eType==FTSQUERY_OR ){ + pRoot = pExpr->pLeft; + **ppOr = pRoot; + (*ppOr)++; + } + fts3EvalTokenCosts(pCsr, pRoot, pExpr->pLeft, ppTC, ppOr, pRc); + if( pExpr->eType==FTSQUERY_OR ){ + pRoot = pExpr->pRight; + **ppOr = pRoot; + (*ppOr)++; + } + fts3EvalTokenCosts(pCsr, pRoot, pExpr->pRight, ppTC, ppOr, pRc); + } + } +} + +/* +** Determine the average document (row) size in pages. If successful, +** write this value to *pnPage and return SQLITE_OK. Otherwise, return +** an SQLite error code. +** +** The average document size in pages is calculated by first calculating +** determining the average size in bytes, B. If B is less than the amount +** of data that will fit on a single leaf page of an intkey table in +** this database, then the average docsize is 1. Otherwise, it is 1 plus +** the number of overflow pages consumed by a record B bytes in size. +*/ +static int fts3EvalAverageDocsize(Fts3Cursor *pCsr, int *pnPage){ + int rc = SQLITE_OK; + if( pCsr->nRowAvg==0 ){ + /* The average document size, which is required to calculate the cost + ** of each doclist, has not yet been determined. Read the required + ** data from the %_stat table to calculate it. + ** + ** Entry 0 of the %_stat table is a blob containing (nCol+1) FTS3 + ** varints, where nCol is the number of columns in the FTS3 table. + ** The first varint is the number of documents currently stored in + ** the table. The following nCol varints contain the total amount of + ** data stored in all rows of each column of the table, from left + ** to right. + */ + Fts3Table *p = (Fts3Table*)pCsr->base.pVtab; + sqlite3_stmt *pStmt; + sqlite3_int64 nDoc = 0; + sqlite3_int64 nByte = 0; + const char *pEnd; + const char *a; + + rc = sqlite3Fts3SelectDoctotal(p, &pStmt); + if( rc!=SQLITE_OK ) return rc; + a = sqlite3_column_blob(pStmt, 0); + testcase( a==0 ); /* If %_stat.value set to X'' */ + if( a ){ + pEnd = &a[sqlite3_column_bytes(pStmt, 0)]; + a += sqlite3Fts3GetVarintBounded(a, pEnd, &nDoc); + while( anDoc = nDoc; + pCsr->nRowAvg = (int)(((nByte / nDoc) + p->nPgsz) / p->nPgsz); + assert( pCsr->nRowAvg>0 ); + rc = sqlite3_reset(pStmt); + } + + *pnPage = pCsr->nRowAvg; + return rc; +} + +/* +** This function is called to select the tokens (if any) that will be +** deferred. The array aTC[] has already been populated when this is +** called. +** +** This function is called once for each AND/NEAR cluster in the +** expression. Each invocation determines which tokens to defer within +** the cluster with root node pRoot. See comments above the definition +** of struct Fts3TokenAndCost for more details. +** +** If no error occurs, SQLITE_OK is returned and sqlite3Fts3DeferToken() +** called on each token to defer. Otherwise, an SQLite error code is +** returned. +*/ +static int fts3EvalSelectDeferred( + Fts3Cursor *pCsr, /* FTS Cursor handle */ + Fts3Expr *pRoot, /* Consider tokens with this root node */ + Fts3TokenAndCost *aTC, /* Array of expression tokens and costs */ + int nTC /* Number of entries in aTC[] */ +){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int nDocSize = 0; /* Number of pages per doc loaded */ + int rc = SQLITE_OK; /* Return code */ + int ii; /* Iterator variable for various purposes */ + int nOvfl = 0; /* Total overflow pages used by doclists */ + int nToken = 0; /* Total number of tokens in cluster */ + + int nMinEst = 0; /* The minimum count for any phrase so far. */ + int nLoad4 = 1; /* (Phrases that will be loaded)^4. */ + + /* Tokens are never deferred for FTS tables created using the content=xxx + ** option. The reason being that it is not guaranteed that the content + ** table actually contains the same data as the index. To prevent this from + ** causing any problems, the deferred token optimization is completely + ** disabled for content=xxx tables. */ + if( pTab->zContentTbl ){ + return SQLITE_OK; + } + + /* Count the tokens in this AND/NEAR cluster. If none of the doclists + ** associated with the tokens spill onto overflow pages, or if there is + ** only 1 token, exit early. No tokens to defer in this case. */ + for(ii=0; ii0 ); + + + /* Iterate through all tokens in this AND/NEAR cluster, in ascending order + ** of the number of overflow pages that will be loaded by the pager layer + ** to retrieve the entire doclist for the token from the full-text index. + ** Load the doclists for tokens that are either: + ** + ** a. The cheapest token in the entire query (i.e. the one visited by the + ** first iteration of this loop), or + ** + ** b. Part of a multi-token phrase. + ** + ** After each token doclist is loaded, merge it with the others from the + ** same phrase and count the number of documents that the merged doclist + ** contains. Set variable "nMinEst" to the smallest number of documents in + ** any phrase doclist for which 1 or more token doclists have been loaded. + ** Let nOther be the number of other phrases for which it is certain that + ** one or more tokens will not be deferred. + ** + ** Then, for each token, defer it if loading the doclist would result in + ** loading N or more overflow pages into memory, where N is computed as: + ** + ** (nMinEst + 4^nOther - 1) / (4^nOther) + */ + for(ii=0; iinOvfl) + ){ + pTC = &aTC[iTC]; + } + } + assert( pTC ); + + if( ii && pTC->nOvfl>=((nMinEst+(nLoad4/4)-1)/(nLoad4/4))*nDocSize ){ + /* The number of overflow pages to load for this (and therefore all + ** subsequent) tokens is greater than the estimated number of pages + ** that will be loaded if all subsequent tokens are deferred. + */ + Fts3PhraseToken *pToken = pTC->pToken; + rc = sqlite3Fts3DeferToken(pCsr, pToken, pTC->iCol); + fts3SegReaderCursorFree(pToken->pSegcsr); + pToken->pSegcsr = 0; + }else{ + /* Set nLoad4 to the value of (4^nOther) for the next iteration of the + ** for-loop. Except, limit the value to 2^24 to prevent it from + ** overflowing the 32-bit integer it is stored in. */ + if( ii<12 ) nLoad4 = nLoad4*4; + + if( ii==0 || (pTC->pPhrase->nToken>1 && ii!=nToken-1) ){ + /* Either this is the cheapest token in the entire query, or it is + ** part of a multi-token phrase. Either way, the entire doclist will + ** (eventually) be loaded into memory. It may as well be now. */ + Fts3PhraseToken *pToken = pTC->pToken; + int nList = 0; + char *pList = 0; + rc = fts3TermSelect(pTab, pToken, pTC->iCol, &nList, &pList); + assert( rc==SQLITE_OK || pList==0 ); + if( rc==SQLITE_OK ){ + rc = fts3EvalPhraseMergeToken( + pTab, pTC->pPhrase, pTC->iToken,pList,nList + ); + } + if( rc==SQLITE_OK ){ + int nCount; + nCount = fts3DoclistCountDocids( + pTC->pPhrase->doclist.aAll, pTC->pPhrase->doclist.nAll + ); + if( ii==0 || nCountpToken = 0; + } + + return rc; +} + +/* +** This function is called from within the xFilter method. It initializes +** the full-text query currently stored in pCsr->pExpr. To iterate through +** the results of a query, the caller does: +** +** fts3EvalStart(pCsr); +** while( 1 ){ +** fts3EvalNext(pCsr); +** if( pCsr->bEof ) break; +** ... return row pCsr->iPrevId to the caller ... +** } +*/ +static int fts3EvalStart(Fts3Cursor *pCsr){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int rc = SQLITE_OK; + int nToken = 0; + int nOr = 0; + + /* Allocate a MultiSegReader for each token in the expression. */ + fts3EvalAllocateReaders(pCsr, pCsr->pExpr, &nToken, &nOr, &rc); + + /* Determine which, if any, tokens in the expression should be deferred. */ +#ifndef SQLITE_DISABLE_FTS4_DEFERRED + if( rc==SQLITE_OK && nToken>1 && pTab->bFts4 ){ + Fts3TokenAndCost *aTC; + aTC = (Fts3TokenAndCost *)sqlite3_malloc64( + sizeof(Fts3TokenAndCost) * nToken + + sizeof(Fts3Expr *) * nOr * 2 + ); + + if( !aTC ){ + rc = SQLITE_NOMEM; + }else{ + Fts3Expr **apOr = (Fts3Expr **)&aTC[nToken]; + int ii; + Fts3TokenAndCost *pTC = aTC; + Fts3Expr **ppOr = apOr; + + fts3EvalTokenCosts(pCsr, 0, pCsr->pExpr, &pTC, &ppOr, &rc); + nToken = (int)(pTC-aTC); + nOr = (int)(ppOr-apOr); + + if( rc==SQLITE_OK ){ + rc = fts3EvalSelectDeferred(pCsr, 0, aTC, nToken); + for(ii=0; rc==SQLITE_OK && iipExpr, &rc); + return rc; +} + +/* +** Invalidate the current position list for phrase pPhrase. +*/ +static void fts3EvalInvalidatePoslist(Fts3Phrase *pPhrase){ + if( pPhrase->doclist.bFreeList ){ + sqlite3_free(pPhrase->doclist.pList); + } + pPhrase->doclist.pList = 0; + pPhrase->doclist.nList = 0; + pPhrase->doclist.bFreeList = 0; +} + +/* +** This function is called to edit the position list associated with +** the phrase object passed as the fifth argument according to a NEAR +** condition. For example: +** +** abc NEAR/5 "def ghi" +** +** Parameter nNear is passed the NEAR distance of the expression (5 in +** the example above). When this function is called, *paPoslist points to +** the position list, and *pnToken is the number of phrase tokens in the +** phrase on the other side of the NEAR operator to pPhrase. For example, +** if pPhrase refers to the "def ghi" phrase, then *paPoslist points to +** the position list associated with phrase "abc". +** +** All positions in the pPhrase position list that are not sufficiently +** close to a position in the *paPoslist position list are removed. If this +** leaves 0 positions, zero is returned. Otherwise, non-zero. +** +** Before returning, *paPoslist is set to point to the position lsit +** associated with pPhrase. And *pnToken is set to the number of tokens in +** pPhrase. +*/ +static int fts3EvalNearTrim( + int nNear, /* NEAR distance. As in "NEAR/nNear". */ + char *aTmp, /* Temporary space to use */ + char **paPoslist, /* IN/OUT: Position list */ + int *pnToken, /* IN/OUT: Tokens in phrase of *paPoslist */ + Fts3Phrase *pPhrase /* The phrase object to trim the doclist of */ +){ + int nParam1 = nNear + pPhrase->nToken; + int nParam2 = nNear + *pnToken; + int nNew; + char *p2; + char *pOut; + int res; + + assert( pPhrase->doclist.pList ); + + p2 = pOut = pPhrase->doclist.pList; + res = fts3PoslistNearMerge( + &pOut, aTmp, nParam1, nParam2, paPoslist, &p2 + ); + if( res ){ + nNew = (int)(pOut - pPhrase->doclist.pList) - 1; + assert_fts3_nc( nNew<=pPhrase->doclist.nList && nNew>0 ); + if( nNew>=0 && nNew<=pPhrase->doclist.nList ){ + assert( pPhrase->doclist.pList[nNew]=='\0' ); + memset(&pPhrase->doclist.pList[nNew], 0, pPhrase->doclist.nList - nNew); + pPhrase->doclist.nList = nNew; + } + *paPoslist = pPhrase->doclist.pList; + *pnToken = pPhrase->nToken; + } + + return res; +} + +/* +** This function is a no-op if *pRc is other than SQLITE_OK when it is called. +** Otherwise, it advances the expression passed as the second argument to +** point to the next matching row in the database. Expressions iterate through +** matching rows in docid order. Ascending order if Fts3Cursor.bDesc is zero, +** or descending if it is non-zero. +** +** If an error occurs, *pRc is set to an SQLite error code. Otherwise, if +** successful, the following variables in pExpr are set: +** +** Fts3Expr.bEof (non-zero if EOF - there is no next row) +** Fts3Expr.iDocid (valid if bEof==0. The docid of the next row) +** +** If the expression is of type FTSQUERY_PHRASE, and the expression is not +** at EOF, then the following variables are populated with the position list +** for the phrase for the visited row: +** +** FTs3Expr.pPhrase->doclist.nList (length of pList in bytes) +** FTs3Expr.pPhrase->doclist.pList (pointer to position list) +** +** It says above that this function advances the expression to the next +** matching row. This is usually true, but there are the following exceptions: +** +** 1. Deferred tokens are not taken into account. If a phrase consists +** entirely of deferred tokens, it is assumed to match every row in +** the db. In this case the position-list is not populated at all. +** +** Or, if a phrase contains one or more deferred tokens and one or +** more non-deferred tokens, then the expression is advanced to the +** next possible match, considering only non-deferred tokens. In other +** words, if the phrase is "A B C", and "B" is deferred, the expression +** is advanced to the next row that contains an instance of "A * C", +** where "*" may match any single token. The position list in this case +** is populated as for "A * C" before returning. +** +** 2. NEAR is treated as AND. If the expression is "x NEAR y", it is +** advanced to point to the next row that matches "x AND y". +** +** See sqlite3Fts3EvalTestDeferred() for details on testing if a row is +** really a match, taking into account deferred tokens and NEAR operators. +*/ +static void fts3EvalNextRow( + Fts3Cursor *pCsr, /* FTS Cursor handle */ + Fts3Expr *pExpr, /* Expr. to advance to next matching row */ + int *pRc /* IN/OUT: Error code */ +){ + if( *pRc==SQLITE_OK && pExpr->bEof==0 ){ + int bDescDoclist = pCsr->bDesc; /* Used by DOCID_CMP() macro */ + pExpr->bStart = 1; + + switch( pExpr->eType ){ + case FTSQUERY_NEAR: + case FTSQUERY_AND: { + Fts3Expr *pLeft = pExpr->pLeft; + Fts3Expr *pRight = pExpr->pRight; + assert( !pLeft->bDeferred || !pRight->bDeferred ); + + if( pLeft->bDeferred ){ + /* LHS is entirely deferred. So we assume it matches every row. + ** Advance the RHS iterator to find the next row visited. */ + fts3EvalNextRow(pCsr, pRight, pRc); + pExpr->iDocid = pRight->iDocid; + pExpr->bEof = pRight->bEof; + }else if( pRight->bDeferred ){ + /* RHS is entirely deferred. So we assume it matches every row. + ** Advance the LHS iterator to find the next row visited. */ + fts3EvalNextRow(pCsr, pLeft, pRc); + pExpr->iDocid = pLeft->iDocid; + pExpr->bEof = pLeft->bEof; + }else{ + /* Neither the RHS or LHS are deferred. */ + fts3EvalNextRow(pCsr, pLeft, pRc); + fts3EvalNextRow(pCsr, pRight, pRc); + while( !pLeft->bEof && !pRight->bEof && *pRc==SQLITE_OK ){ + sqlite3_int64 iDiff = DOCID_CMP(pLeft->iDocid, pRight->iDocid); + if( iDiff==0 ) break; + if( iDiff<0 ){ + fts3EvalNextRow(pCsr, pLeft, pRc); + }else{ + fts3EvalNextRow(pCsr, pRight, pRc); + } + } + pExpr->iDocid = pLeft->iDocid; + pExpr->bEof = (pLeft->bEof || pRight->bEof); + if( pExpr->eType==FTSQUERY_NEAR && pExpr->bEof ){ + assert( pRight->eType==FTSQUERY_PHRASE ); + if( pRight->pPhrase->doclist.aAll ){ + Fts3Doclist *pDl = &pRight->pPhrase->doclist; + while( *pRc==SQLITE_OK && pRight->bEof==0 ){ + memset(pDl->pList, 0, pDl->nList); + fts3EvalNextRow(pCsr, pRight, pRc); + } + } + if( pLeft->pPhrase && pLeft->pPhrase->doclist.aAll ){ + Fts3Doclist *pDl = &pLeft->pPhrase->doclist; + while( *pRc==SQLITE_OK && pLeft->bEof==0 ){ + memset(pDl->pList, 0, pDl->nList); + fts3EvalNextRow(pCsr, pLeft, pRc); + } + } + pRight->bEof = pLeft->bEof = 1; + } + } + break; + } + + case FTSQUERY_OR: { + Fts3Expr *pLeft = pExpr->pLeft; + Fts3Expr *pRight = pExpr->pRight; + sqlite3_int64 iCmp = DOCID_CMP(pLeft->iDocid, pRight->iDocid); + + assert_fts3_nc( pLeft->bStart || pLeft->iDocid==pRight->iDocid ); + assert_fts3_nc( pRight->bStart || pLeft->iDocid==pRight->iDocid ); + + if( pRight->bEof || (pLeft->bEof==0 && iCmp<0) ){ + fts3EvalNextRow(pCsr, pLeft, pRc); + }else if( pLeft->bEof || iCmp>0 ){ + fts3EvalNextRow(pCsr, pRight, pRc); + }else{ + fts3EvalNextRow(pCsr, pLeft, pRc); + fts3EvalNextRow(pCsr, pRight, pRc); + } + + pExpr->bEof = (pLeft->bEof && pRight->bEof); + iCmp = DOCID_CMP(pLeft->iDocid, pRight->iDocid); + if( pRight->bEof || (pLeft->bEof==0 && iCmp<0) ){ + pExpr->iDocid = pLeft->iDocid; + }else{ + pExpr->iDocid = pRight->iDocid; + } + + break; + } + + case FTSQUERY_NOT: { + Fts3Expr *pLeft = pExpr->pLeft; + Fts3Expr *pRight = pExpr->pRight; + + if( pRight->bStart==0 ){ + fts3EvalNextRow(pCsr, pRight, pRc); + assert( *pRc!=SQLITE_OK || pRight->bStart ); + } + + fts3EvalNextRow(pCsr, pLeft, pRc); + if( pLeft->bEof==0 ){ + while( !*pRc + && !pRight->bEof + && DOCID_CMP(pLeft->iDocid, pRight->iDocid)>0 + ){ + fts3EvalNextRow(pCsr, pRight, pRc); + } + } + pExpr->iDocid = pLeft->iDocid; + pExpr->bEof = pLeft->bEof; + break; + } + + default: { + Fts3Phrase *pPhrase = pExpr->pPhrase; + fts3EvalInvalidatePoslist(pPhrase); + *pRc = fts3EvalPhraseNext(pCsr, pPhrase, &pExpr->bEof); + pExpr->iDocid = pPhrase->doclist.iDocid; + break; + } + } + } +} + +/* +** If *pRc is not SQLITE_OK, or if pExpr is not the root node of a NEAR +** cluster, then this function returns 1 immediately. +** +** Otherwise, it checks if the current row really does match the NEAR +** expression, using the data currently stored in the position lists +** (Fts3Expr->pPhrase.doclist.pList/nList) for each phrase in the expression. +** +** If the current row is a match, the position list associated with each +** phrase in the NEAR expression is edited in place to contain only those +** phrase instances sufficiently close to their peers to satisfy all NEAR +** constraints. In this case it returns 1. If the NEAR expression does not +** match the current row, 0 is returned. The position lists may or may not +** be edited if 0 is returned. +*/ +static int fts3EvalNearTest(Fts3Expr *pExpr, int *pRc){ + int res = 1; + + /* The following block runs if pExpr is the root of a NEAR query. + ** For example, the query: + ** + ** "w" NEAR "x" NEAR "y" NEAR "z" + ** + ** which is represented in tree form as: + ** + ** | + ** +--NEAR--+ <-- root of NEAR query + ** | | + ** +--NEAR--+ "z" + ** | | + ** +--NEAR--+ "y" + ** | | + ** "w" "x" + ** + ** The right-hand child of a NEAR node is always a phrase. The + ** left-hand child may be either a phrase or a NEAR node. There are + ** no exceptions to this - it's the way the parser in fts3_expr.c works. + */ + if( *pRc==SQLITE_OK + && pExpr->eType==FTSQUERY_NEAR + && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR) + ){ + Fts3Expr *p; + sqlite3_int64 nTmp = 0; /* Bytes of temp space */ + char *aTmp; /* Temp space for PoslistNearMerge() */ + + /* Allocate temporary working space. */ + for(p=pExpr; p->pLeft; p=p->pLeft){ + assert( p->pRight->pPhrase->doclist.nList>0 ); + nTmp += p->pRight->pPhrase->doclist.nList; + } + nTmp += p->pPhrase->doclist.nList; + aTmp = sqlite3_malloc64(nTmp*2); + if( !aTmp ){ + *pRc = SQLITE_NOMEM; + res = 0; + }else{ + char *aPoslist = p->pPhrase->doclist.pList; + int nToken = p->pPhrase->nToken; + + for(p=p->pParent;res && p && p->eType==FTSQUERY_NEAR; p=p->pParent){ + Fts3Phrase *pPhrase = p->pRight->pPhrase; + int nNear = p->nNear; + res = fts3EvalNearTrim(nNear, aTmp, &aPoslist, &nToken, pPhrase); + } + + aPoslist = pExpr->pRight->pPhrase->doclist.pList; + nToken = pExpr->pRight->pPhrase->nToken; + for(p=pExpr->pLeft; p && res; p=p->pLeft){ + int nNear; + Fts3Phrase *pPhrase; + assert( p->pParent && p->pParent->pLeft==p ); + nNear = p->pParent->nNear; + pPhrase = ( + p->eType==FTSQUERY_NEAR ? p->pRight->pPhrase : p->pPhrase + ); + res = fts3EvalNearTrim(nNear, aTmp, &aPoslist, &nToken, pPhrase); + } + } + + sqlite3_free(aTmp); + } + + return res; +} + +/* +** This function is a helper function for sqlite3Fts3EvalTestDeferred(). +** Assuming no error occurs or has occurred, It returns non-zero if the +** expression passed as the second argument matches the row that pCsr +** currently points to, or zero if it does not. +** +** If *pRc is not SQLITE_OK when this function is called, it is a no-op. +** If an error occurs during execution of this function, *pRc is set to +** the appropriate SQLite error code. In this case the returned value is +** undefined. +*/ +static int fts3EvalTestExpr( + Fts3Cursor *pCsr, /* FTS cursor handle */ + Fts3Expr *pExpr, /* Expr to test. May or may not be root. */ + int *pRc /* IN/OUT: Error code */ +){ + int bHit = 1; /* Return value */ + if( *pRc==SQLITE_OK ){ + switch( pExpr->eType ){ + case FTSQUERY_NEAR: + case FTSQUERY_AND: + bHit = ( + fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc) + && fts3EvalTestExpr(pCsr, pExpr->pRight, pRc) + && fts3EvalNearTest(pExpr, pRc) + ); + + /* If the NEAR expression does not match any rows, zero the doclist for + ** all phrases involved in the NEAR. This is because the snippet(), + ** offsets() and matchinfo() functions are not supposed to recognize + ** any instances of phrases that are part of unmatched NEAR queries. + ** For example if this expression: + ** + ** ... MATCH 'a OR (b NEAR c)' + ** + ** is matched against a row containing: + ** + ** 'a b d e' + ** + ** then any snippet() should ony highlight the "a" term, not the "b" + ** (as "b" is part of a non-matching NEAR clause). + */ + if( bHit==0 + && pExpr->eType==FTSQUERY_NEAR + && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR) + ){ + Fts3Expr *p; + for(p=pExpr; p->pPhrase==0; p=p->pLeft){ + if( p->pRight->iDocid==pCsr->iPrevId ){ + fts3EvalInvalidatePoslist(p->pRight->pPhrase); + } + } + if( p->iDocid==pCsr->iPrevId ){ + fts3EvalInvalidatePoslist(p->pPhrase); + } + } + + break; + + case FTSQUERY_OR: { + int bHit1 = fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc); + int bHit2 = fts3EvalTestExpr(pCsr, pExpr->pRight, pRc); + bHit = bHit1 || bHit2; + break; + } + + case FTSQUERY_NOT: + bHit = ( + fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc) + && !fts3EvalTestExpr(pCsr, pExpr->pRight, pRc) + ); + break; + + default: { +#ifndef SQLITE_DISABLE_FTS4_DEFERRED + if( pCsr->pDeferred && (pExpr->bDeferred || ( + pExpr->iDocid==pCsr->iPrevId && pExpr->pPhrase->doclist.pList + ))){ + Fts3Phrase *pPhrase = pExpr->pPhrase; + if( pExpr->bDeferred ){ + fts3EvalInvalidatePoslist(pPhrase); + } + *pRc = fts3EvalDeferredPhrase(pCsr, pPhrase); + bHit = (pPhrase->doclist.pList!=0); + pExpr->iDocid = pCsr->iPrevId; + }else +#endif + { + bHit = ( + pExpr->bEof==0 && pExpr->iDocid==pCsr->iPrevId + && pExpr->pPhrase->doclist.nList>0 + ); + } + break; + } + } + } + return bHit; +} + +/* +** This function is called as the second part of each xNext operation when +** iterating through the results of a full-text query. At this point the +** cursor points to a row that matches the query expression, with the +** following caveats: +** +** * Up until this point, "NEAR" operators in the expression have been +** treated as "AND". +** +** * Deferred tokens have not yet been considered. +** +** If *pRc is not SQLITE_OK when this function is called, it immediately +** returns 0. Otherwise, it tests whether or not after considering NEAR +** operators and deferred tokens the current row is still a match for the +** expression. It returns 1 if both of the following are true: +** +** 1. *pRc is SQLITE_OK when this function returns, and +** +** 2. After scanning the current FTS table row for the deferred tokens, +** it is determined that the row does *not* match the query. +** +** Or, if no error occurs and it seems the current row does match the FTS +** query, return 0. +*/ +SQLITE_PRIVATE int sqlite3Fts3EvalTestDeferred(Fts3Cursor *pCsr, int *pRc){ + int rc = *pRc; + int bMiss = 0; + if( rc==SQLITE_OK ){ + + /* If there are one or more deferred tokens, load the current row into + ** memory and scan it to determine the position list for each deferred + ** token. Then, see if this row is really a match, considering deferred + ** tokens and NEAR operators (neither of which were taken into account + ** earlier, by fts3EvalNextRow()). + */ + if( pCsr->pDeferred ){ + rc = fts3CursorSeek(0, pCsr); + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3CacheDeferredDoclists(pCsr); + } + } + bMiss = (0==fts3EvalTestExpr(pCsr, pCsr->pExpr, &rc)); + + /* Free the position-lists accumulated for each deferred token above. */ + sqlite3Fts3FreeDeferredDoclists(pCsr); + *pRc = rc; + } + return (rc==SQLITE_OK && bMiss); +} + +/* +** Advance to the next document that matches the FTS expression in +** Fts3Cursor.pExpr. +*/ +static int fts3EvalNext(Fts3Cursor *pCsr){ + int rc = SQLITE_OK; /* Return Code */ + Fts3Expr *pExpr = pCsr->pExpr; + assert( pCsr->isEof==0 ); + if( pExpr==0 ){ + pCsr->isEof = 1; + }else{ + do { + if( pCsr->isRequireSeek==0 ){ + sqlite3_reset(pCsr->pStmt); + } + assert( sqlite3_data_count(pCsr->pStmt)==0 ); + fts3EvalNextRow(pCsr, pExpr, &rc); + pCsr->isEof = pExpr->bEof; + pCsr->isRequireSeek = 1; + pCsr->isMatchinfoNeeded = 1; + pCsr->iPrevId = pExpr->iDocid; + }while( pCsr->isEof==0 && sqlite3Fts3EvalTestDeferred(pCsr, &rc) ); + } + + /* Check if the cursor is past the end of the docid range specified + ** by Fts3Cursor.iMinDocid/iMaxDocid. If so, set the EOF flag. */ + if( rc==SQLITE_OK && ( + (pCsr->bDesc==0 && pCsr->iPrevId>pCsr->iMaxDocid) + || (pCsr->bDesc!=0 && pCsr->iPrevIdiMinDocid) + )){ + pCsr->isEof = 1; + } + + return rc; +} + +/* +** Restart interation for expression pExpr so that the next call to +** fts3EvalNext() visits the first row. Do not allow incremental +** loading or merging of phrase doclists for this iteration. +** +** If *pRc is other than SQLITE_OK when this function is called, it is +** a no-op. If an error occurs within this function, *pRc is set to an +** SQLite error code before returning. +*/ +static void fts3EvalRestart( + Fts3Cursor *pCsr, + Fts3Expr *pExpr, + int *pRc +){ + if( pExpr && *pRc==SQLITE_OK ){ + Fts3Phrase *pPhrase = pExpr->pPhrase; + + if( pPhrase ){ + fts3EvalInvalidatePoslist(pPhrase); + if( pPhrase->bIncr ){ + int i; + for(i=0; inToken; i++){ + Fts3PhraseToken *pToken = &pPhrase->aToken[i]; + assert( pToken->pDeferred==0 ); + if( pToken->pSegcsr ){ + sqlite3Fts3MsrIncrRestart(pToken->pSegcsr); + } + } + *pRc = fts3EvalPhraseStart(pCsr, 0, pPhrase); + } + pPhrase->doclist.pNextDocid = 0; + pPhrase->doclist.iDocid = 0; + pPhrase->pOrPoslist = 0; + } + + pExpr->iDocid = 0; + pExpr->bEof = 0; + pExpr->bStart = 0; + + fts3EvalRestart(pCsr, pExpr->pLeft, pRc); + fts3EvalRestart(pCsr, pExpr->pRight, pRc); + } +} + +/* +** After allocating the Fts3Expr.aMI[] array for each phrase in the +** expression rooted at pExpr, the cursor iterates through all rows matched +** by pExpr, calling this function for each row. This function increments +** the values in Fts3Expr.aMI[] according to the position-list currently +** found in Fts3Expr.pPhrase->doclist.pList for each of the phrase +** expression nodes. +*/ +static void fts3EvalUpdateCounts(Fts3Expr *pExpr, int nCol){ + if( pExpr ){ + Fts3Phrase *pPhrase = pExpr->pPhrase; + if( pPhrase && pPhrase->doclist.pList ){ + int iCol = 0; + char *p = pPhrase->doclist.pList; + + do{ + u8 c = 0; + int iCnt = 0; + while( 0xFE & (*p | c) ){ + if( (c&0x80)==0 ) iCnt++; + c = *p++ & 0x80; + } + + /* aMI[iCol*3 + 1] = Number of occurrences + ** aMI[iCol*3 + 2] = Number of rows containing at least one instance + */ + pExpr->aMI[iCol*3 + 1] += iCnt; + pExpr->aMI[iCol*3 + 2] += (iCnt>0); + if( *p==0x00 ) break; + p++; + p += fts3GetVarint32(p, &iCol); + }while( iColpLeft, nCol); + fts3EvalUpdateCounts(pExpr->pRight, nCol); + } +} + +/* +** This is an sqlite3Fts3ExprIterate() callback. If the Fts3Expr.aMI[] array +** has not yet been allocated, allocate and zero it. Otherwise, just zero +** it. +*/ +static int fts3AllocateMSI(Fts3Expr *pExpr, int iPhrase, void *pCtx){ + Fts3Table *pTab = (Fts3Table*)pCtx; + UNUSED_PARAMETER(iPhrase); + if( pExpr->aMI==0 ){ + pExpr->aMI = (u32 *)sqlite3_malloc64(pTab->nColumn * 3 * sizeof(u32)); + if( pExpr->aMI==0 ) return SQLITE_NOMEM; + } + memset(pExpr->aMI, 0, pTab->nColumn * 3 * sizeof(u32)); + return SQLITE_OK; +} + +/* +** Expression pExpr must be of type FTSQUERY_PHRASE. +** +** If it is not already allocated and populated, this function allocates and +** populates the Fts3Expr.aMI[] array for expression pExpr. If pExpr is part +** of a NEAR expression, then it also allocates and populates the same array +** for all other phrases that are part of the NEAR expression. +** +** SQLITE_OK is returned if the aMI[] array is successfully allocated and +** populated. Otherwise, if an error occurs, an SQLite error code is returned. +*/ +static int fts3EvalGatherStats( + Fts3Cursor *pCsr, /* Cursor object */ + Fts3Expr *pExpr /* FTSQUERY_PHRASE expression */ +){ + int rc = SQLITE_OK; /* Return code */ + + assert( pExpr->eType==FTSQUERY_PHRASE ); + if( pExpr->aMI==0 ){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + Fts3Expr *pRoot; /* Root of NEAR expression */ + + sqlite3_int64 iPrevId = pCsr->iPrevId; + sqlite3_int64 iDocid; + u8 bEof; + + /* Find the root of the NEAR expression */ + pRoot = pExpr; + while( pRoot->pParent + && (pRoot->pParent->eType==FTSQUERY_NEAR || pRoot->bDeferred) + ){ + pRoot = pRoot->pParent; + } + iDocid = pRoot->iDocid; + bEof = pRoot->bEof; + assert( pRoot->bStart ); + + /* Allocate space for the aMSI[] array of each FTSQUERY_PHRASE node */ + rc = sqlite3Fts3ExprIterate(pRoot, fts3AllocateMSI, (void*)pTab); + if( rc!=SQLITE_OK ) return rc; + fts3EvalRestart(pCsr, pRoot, &rc); + + while( pCsr->isEof==0 && rc==SQLITE_OK ){ + + do { + /* Ensure the %_content statement is reset. */ + if( pCsr->isRequireSeek==0 ) sqlite3_reset(pCsr->pStmt); + assert( sqlite3_data_count(pCsr->pStmt)==0 ); + + /* Advance to the next document */ + fts3EvalNextRow(pCsr, pRoot, &rc); + pCsr->isEof = pRoot->bEof; + pCsr->isRequireSeek = 1; + pCsr->isMatchinfoNeeded = 1; + pCsr->iPrevId = pRoot->iDocid; + }while( pCsr->isEof==0 + && pRoot->eType==FTSQUERY_NEAR + && sqlite3Fts3EvalTestDeferred(pCsr, &rc) + ); + + if( rc==SQLITE_OK && pCsr->isEof==0 ){ + fts3EvalUpdateCounts(pRoot, pTab->nColumn); + } + } + + pCsr->isEof = 0; + pCsr->iPrevId = iPrevId; + + if( bEof ){ + pRoot->bEof = bEof; + }else{ + /* Caution: pRoot may iterate through docids in ascending or descending + ** order. For this reason, even though it seems more defensive, the + ** do loop can not be written: + ** + ** do {...} while( pRoot->iDocidbEof==0 ); + if( pRoot->bEof ) rc = FTS_CORRUPT_VTAB; + }while( pRoot->iDocid!=iDocid && rc==SQLITE_OK ); + } + } + return rc; +} + +/* +** This function is used by the matchinfo() module to query a phrase +** expression node for the following information: +** +** 1. The total number of occurrences of the phrase in each column of +** the FTS table (considering all rows), and +** +** 2. For each column, the number of rows in the table for which the +** column contains at least one instance of the phrase. +** +** If no error occurs, SQLITE_OK is returned and the values for each column +** written into the array aiOut as follows: +** +** aiOut[iCol*3 + 1] = Number of occurrences +** aiOut[iCol*3 + 2] = Number of rows containing at least one instance +** +** Caveats: +** +** * If a phrase consists entirely of deferred tokens, then all output +** values are set to the number of documents in the table. In other +** words we assume that very common tokens occur exactly once in each +** column of each row of the table. +** +** * If a phrase contains some deferred tokens (and some non-deferred +** tokens), count the potential occurrence identified by considering +** the non-deferred tokens instead of actual phrase occurrences. +** +** * If the phrase is part of a NEAR expression, then only phrase instances +** that meet the NEAR constraint are included in the counts. +*/ +SQLITE_PRIVATE int sqlite3Fts3EvalPhraseStats( + Fts3Cursor *pCsr, /* FTS cursor handle */ + Fts3Expr *pExpr, /* Phrase expression */ + u32 *aiOut /* Array to write results into (see above) */ +){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int rc = SQLITE_OK; + int iCol; + + if( pExpr->bDeferred && pExpr->pParent->eType!=FTSQUERY_NEAR ){ + assert( pCsr->nDoc>0 ); + for(iCol=0; iColnColumn; iCol++){ + aiOut[iCol*3 + 1] = (u32)pCsr->nDoc; + aiOut[iCol*3 + 2] = (u32)pCsr->nDoc; + } + }else{ + rc = fts3EvalGatherStats(pCsr, pExpr); + if( rc==SQLITE_OK ){ + assert( pExpr->aMI ); + for(iCol=0; iColnColumn; iCol++){ + aiOut[iCol*3 + 1] = pExpr->aMI[iCol*3 + 1]; + aiOut[iCol*3 + 2] = pExpr->aMI[iCol*3 + 2]; + } + } + } + + return rc; +} + +/* +** The expression pExpr passed as the second argument to this function +** must be of type FTSQUERY_PHRASE. +** +** The returned value is either NULL or a pointer to a buffer containing +** a position-list indicating the occurrences of the phrase in column iCol +** of the current row. +** +** More specifically, the returned buffer contains 1 varint for each +** occurrence of the phrase in the column, stored using the normal (delta+2) +** compression and is terminated by either an 0x01 or 0x00 byte. For example, +** if the requested column contains "a b X c d X X" and the position-list +** for 'X' is requested, the buffer returned may contain: +** +** 0x04 0x05 0x03 0x01 or 0x04 0x05 0x03 0x00 +** +** This function works regardless of whether or not the phrase is deferred, +** incremental, or neither. +*/ +SQLITE_PRIVATE int sqlite3Fts3EvalPhrasePoslist( + Fts3Cursor *pCsr, /* FTS3 cursor object */ + Fts3Expr *pExpr, /* Phrase to return doclist for */ + int iCol, /* Column to return position list for */ + char **ppOut /* OUT: Pointer to position list */ +){ + Fts3Phrase *pPhrase = pExpr->pPhrase; + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + char *pIter; + int iThis; + sqlite3_int64 iDocid; + + /* If this phrase is applies specifically to some column other than + ** column iCol, return a NULL pointer. */ + *ppOut = 0; + assert( iCol>=0 && iColnColumn ); + if( (pPhrase->iColumnnColumn && pPhrase->iColumn!=iCol) ){ + return SQLITE_OK; + } + + iDocid = pExpr->iDocid; + pIter = pPhrase->doclist.pList; + if( iDocid!=pCsr->iPrevId || pExpr->bEof ){ + int rc = SQLITE_OK; + int bDescDoclist = pTab->bDescIdx; /* For DOCID_CMP macro */ + int bOr = 0; + u8 bTreeEof = 0; + Fts3Expr *p; /* Used to iterate from pExpr to root */ + Fts3Expr *pNear; /* Most senior NEAR ancestor (or pExpr) */ + Fts3Expr *pRun; /* Closest non-deferred ancestor of pNear */ + int bMatch; + + /* Check if this phrase descends from an OR expression node. If not, + ** return NULL. Otherwise, the entry that corresponds to docid + ** pCsr->iPrevId may lie earlier in the doclist buffer. Or, if the + ** tree that the node is part of has been marked as EOF, but the node + ** itself is not EOF, then it may point to an earlier entry. */ + pNear = pExpr; + for(p=pExpr->pParent; p; p=p->pParent){ + if( p->eType==FTSQUERY_OR ) bOr = 1; + if( p->eType==FTSQUERY_NEAR ) pNear = p; + if( p->bEof ) bTreeEof = 1; + } + if( bOr==0 ) return SQLITE_OK; + pRun = pNear; + while( pRun->bDeferred ){ + assert( pRun->pParent ); + pRun = pRun->pParent; + } + + /* This is the descendent of an OR node. In this case we cannot use + ** an incremental phrase. Load the entire doclist for the phrase + ** into memory in this case. */ + if( pPhrase->bIncr ){ + int bEofSave = pRun->bEof; + fts3EvalRestart(pCsr, pRun, &rc); + while( rc==SQLITE_OK && !pRun->bEof ){ + fts3EvalNextRow(pCsr, pRun, &rc); + if( bEofSave==0 && pRun->iDocid==iDocid ) break; + } + assert( rc!=SQLITE_OK || pPhrase->bIncr==0 ); + if( rc==SQLITE_OK && pRun->bEof!=bEofSave ){ + rc = FTS_CORRUPT_VTAB; + } + } + if( bTreeEof ){ + while( rc==SQLITE_OK && !pRun->bEof ){ + fts3EvalNextRow(pCsr, pRun, &rc); + } + } + if( rc!=SQLITE_OK ) return rc; + + bMatch = 1; + for(p=pNear; p; p=p->pLeft){ + u8 bEof = 0; + Fts3Expr *pTest = p; + Fts3Phrase *pPh; + assert( pTest->eType==FTSQUERY_NEAR || pTest->eType==FTSQUERY_PHRASE ); + if( pTest->eType==FTSQUERY_NEAR ) pTest = pTest->pRight; + assert( pTest->eType==FTSQUERY_PHRASE ); + pPh = pTest->pPhrase; + + pIter = pPh->pOrPoslist; + iDocid = pPh->iOrDocid; + if( pCsr->bDesc==bDescDoclist ){ + bEof = !pPh->doclist.nAll || + (pIter >= (pPh->doclist.aAll + pPh->doclist.nAll)); + while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)<0 ) && bEof==0 ){ + sqlite3Fts3DoclistNext( + bDescDoclist, pPh->doclist.aAll, pPh->doclist.nAll, + &pIter, &iDocid, &bEof + ); + } + }else{ + bEof = !pPh->doclist.nAll || (pIter && pIter<=pPh->doclist.aAll); + while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)>0 ) && bEof==0 ){ + int dummy; + sqlite3Fts3DoclistPrev( + bDescDoclist, pPh->doclist.aAll, pPh->doclist.nAll, + &pIter, &iDocid, &dummy, &bEof + ); + } + } + pPh->pOrPoslist = pIter; + pPh->iOrDocid = iDocid; + if( bEof || iDocid!=pCsr->iPrevId ) bMatch = 0; + } + + if( bMatch ){ + pIter = pPhrase->pOrPoslist; + }else{ + pIter = 0; + } + } + if( pIter==0 ) return SQLITE_OK; + + if( *pIter==0x01 ){ + pIter++; + pIter += fts3GetVarint32(pIter, &iThis); + }else{ + iThis = 0; + } + while( iThisdoclist, and +** * any Fts3MultiSegReader objects held by phrase tokens. +*/ +SQLITE_PRIVATE void sqlite3Fts3EvalPhraseCleanup(Fts3Phrase *pPhrase){ + if( pPhrase ){ + int i; + sqlite3_free(pPhrase->doclist.aAll); + fts3EvalInvalidatePoslist(pPhrase); + memset(&pPhrase->doclist, 0, sizeof(Fts3Doclist)); + for(i=0; inToken; i++){ + fts3SegReaderCursorFree(pPhrase->aToken[i].pSegcsr); + pPhrase->aToken[i].pSegcsr = 0; + } + } +} + + +/* +** Return SQLITE_CORRUPT_VTAB. +*/ +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3Fts3Corrupt(){ + return SQLITE_CORRUPT_VTAB; +} +#endif + +#if !SQLITE_CORE +/* +** Initialize API pointer table, if required. +*/ +#ifdef _WIN32 +__declspec(dllexport) +#endif +SQLITE_API int sqlite3_fts3_init( + sqlite3 *db, + char **pzErrMsg, + const sqlite3_api_routines *pApi +){ + SQLITE_EXTENSION_INIT2(pApi) + return sqlite3Fts3Init(db); +} +#endif + +#endif + +/************** End of fts3.c ************************************************/ +/************** Begin file fts3_aux.c ****************************************/ +/* +** 2011 Jan 27 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ + +typedef struct Fts3auxTable Fts3auxTable; +typedef struct Fts3auxCursor Fts3auxCursor; + +struct Fts3auxTable { + sqlite3_vtab base; /* Base class used by SQLite core */ + Fts3Table *pFts3Tab; +}; + +struct Fts3auxCursor { + sqlite3_vtab_cursor base; /* Base class used by SQLite core */ + Fts3MultiSegReader csr; /* Must be right after "base" */ + Fts3SegFilter filter; + char *zStop; + int nStop; /* Byte-length of string zStop */ + int iLangid; /* Language id to query */ + int isEof; /* True if cursor is at EOF */ + sqlite3_int64 iRowid; /* Current rowid */ + + int iCol; /* Current value of 'col' column */ + int nStat; /* Size of aStat[] array */ + struct Fts3auxColstats { + sqlite3_int64 nDoc; /* 'documents' values for current csr row */ + sqlite3_int64 nOcc; /* 'occurrences' values for current csr row */ + } *aStat; +}; + +/* +** Schema of the terms table. +*/ +#define FTS3_AUX_SCHEMA \ + "CREATE TABLE x(term, col, documents, occurrences, languageid HIDDEN)" + +/* +** This function does all the work for both the xConnect and xCreate methods. +** These tables have no persistent representation of their own, so xConnect +** and xCreate are identical operations. +*/ +static int fts3auxConnectMethod( + sqlite3 *db, /* Database connection */ + void *pUnused, /* Unused */ + int argc, /* Number of elements in argv array */ + const char * const *argv, /* xCreate/xConnect argument array */ + sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */ + char **pzErr /* OUT: sqlite3_malloc'd error message */ +){ + char const *zDb; /* Name of database (e.g. "main") */ + char const *zFts3; /* Name of fts3 table */ + int nDb; /* Result of strlen(zDb) */ + int nFts3; /* Result of strlen(zFts3) */ + sqlite3_int64 nByte; /* Bytes of space to allocate here */ + int rc; /* value returned by declare_vtab() */ + Fts3auxTable *p; /* Virtual table object to return */ + + UNUSED_PARAMETER(pUnused); + + /* The user should invoke this in one of two forms: + ** + ** CREATE VIRTUAL TABLE xxx USING fts4aux(fts4-table); + ** CREATE VIRTUAL TABLE xxx USING fts4aux(fts4-table-db, fts4-table); + */ + if( argc!=4 && argc!=5 ) goto bad_args; + + zDb = argv[1]; + nDb = (int)strlen(zDb); + if( argc==5 ){ + if( nDb==4 && 0==sqlite3_strnicmp("temp", zDb, 4) ){ + zDb = argv[3]; + nDb = (int)strlen(zDb); + zFts3 = argv[4]; + }else{ + goto bad_args; + } + }else{ + zFts3 = argv[3]; + } + nFts3 = (int)strlen(zFts3); + + rc = sqlite3_declare_vtab(db, FTS3_AUX_SCHEMA); + if( rc!=SQLITE_OK ) return rc; + + nByte = sizeof(Fts3auxTable) + sizeof(Fts3Table) + nDb + nFts3 + 2; + p = (Fts3auxTable *)sqlite3_malloc64(nByte); + if( !p ) return SQLITE_NOMEM; + memset(p, 0, nByte); + + p->pFts3Tab = (Fts3Table *)&p[1]; + p->pFts3Tab->zDb = (char *)&p->pFts3Tab[1]; + p->pFts3Tab->zName = &p->pFts3Tab->zDb[nDb+1]; + p->pFts3Tab->db = db; + p->pFts3Tab->nIndex = 1; + + memcpy((char *)p->pFts3Tab->zDb, zDb, nDb); + memcpy((char *)p->pFts3Tab->zName, zFts3, nFts3); + sqlite3Fts3Dequote((char *)p->pFts3Tab->zName); + + *ppVtab = (sqlite3_vtab *)p; + return SQLITE_OK; + + bad_args: + sqlite3Fts3ErrMsg(pzErr, "invalid arguments to fts4aux constructor"); + return SQLITE_ERROR; +} + +/* +** This function does the work for both the xDisconnect and xDestroy methods. +** These tables have no persistent representation of their own, so xDisconnect +** and xDestroy are identical operations. +*/ +static int fts3auxDisconnectMethod(sqlite3_vtab *pVtab){ + Fts3auxTable *p = (Fts3auxTable *)pVtab; + Fts3Table *pFts3 = p->pFts3Tab; + int i; + + /* Free any prepared statements held */ + for(i=0; iaStmt); i++){ + sqlite3_finalize(pFts3->aStmt[i]); + } + sqlite3_free(pFts3->zSegmentsTbl); + sqlite3_free(p); + return SQLITE_OK; +} + +#define FTS4AUX_EQ_CONSTRAINT 1 +#define FTS4AUX_GE_CONSTRAINT 2 +#define FTS4AUX_LE_CONSTRAINT 4 + +/* +** xBestIndex - Analyze a WHERE and ORDER BY clause. +*/ +static int fts3auxBestIndexMethod( + sqlite3_vtab *pVTab, + sqlite3_index_info *pInfo +){ + int i; + int iEq = -1; + int iGe = -1; + int iLe = -1; + int iLangid = -1; + int iNext = 1; /* Next free argvIndex value */ + + UNUSED_PARAMETER(pVTab); + + /* This vtab delivers always results in "ORDER BY term ASC" order. */ + if( pInfo->nOrderBy==1 + && pInfo->aOrderBy[0].iColumn==0 + && pInfo->aOrderBy[0].desc==0 + ){ + pInfo->orderByConsumed = 1; + } + + /* Search for equality and range constraints on the "term" column. + ** And equality constraints on the hidden "languageid" column. */ + for(i=0; inConstraint; i++){ + if( pInfo->aConstraint[i].usable ){ + int op = pInfo->aConstraint[i].op; + int iCol = pInfo->aConstraint[i].iColumn; + + if( iCol==0 ){ + if( op==SQLITE_INDEX_CONSTRAINT_EQ ) iEq = i; + if( op==SQLITE_INDEX_CONSTRAINT_LT ) iLe = i; + if( op==SQLITE_INDEX_CONSTRAINT_LE ) iLe = i; + if( op==SQLITE_INDEX_CONSTRAINT_GT ) iGe = i; + if( op==SQLITE_INDEX_CONSTRAINT_GE ) iGe = i; + } + if( iCol==4 ){ + if( op==SQLITE_INDEX_CONSTRAINT_EQ ) iLangid = i; + } + } + } + + if( iEq>=0 ){ + pInfo->idxNum = FTS4AUX_EQ_CONSTRAINT; + pInfo->aConstraintUsage[iEq].argvIndex = iNext++; + pInfo->estimatedCost = 5; + }else{ + pInfo->idxNum = 0; + pInfo->estimatedCost = 20000; + if( iGe>=0 ){ + pInfo->idxNum += FTS4AUX_GE_CONSTRAINT; + pInfo->aConstraintUsage[iGe].argvIndex = iNext++; + pInfo->estimatedCost /= 2; + } + if( iLe>=0 ){ + pInfo->idxNum += FTS4AUX_LE_CONSTRAINT; + pInfo->aConstraintUsage[iLe].argvIndex = iNext++; + pInfo->estimatedCost /= 2; + } + } + if( iLangid>=0 ){ + pInfo->aConstraintUsage[iLangid].argvIndex = iNext++; + pInfo->estimatedCost--; + } + + return SQLITE_OK; +} + +/* +** xOpen - Open a cursor. +*/ +static int fts3auxOpenMethod(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCsr){ + Fts3auxCursor *pCsr; /* Pointer to cursor object to return */ + + UNUSED_PARAMETER(pVTab); + + pCsr = (Fts3auxCursor *)sqlite3_malloc(sizeof(Fts3auxCursor)); + if( !pCsr ) return SQLITE_NOMEM; + memset(pCsr, 0, sizeof(Fts3auxCursor)); + + *ppCsr = (sqlite3_vtab_cursor *)pCsr; + return SQLITE_OK; +} + +/* +** xClose - Close a cursor. +*/ +static int fts3auxCloseMethod(sqlite3_vtab_cursor *pCursor){ + Fts3Table *pFts3 = ((Fts3auxTable *)pCursor->pVtab)->pFts3Tab; + Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor; + + sqlite3Fts3SegmentsClose(pFts3); + sqlite3Fts3SegReaderFinish(&pCsr->csr); + sqlite3_free((void *)pCsr->filter.zTerm); + sqlite3_free(pCsr->zStop); + sqlite3_free(pCsr->aStat); + sqlite3_free(pCsr); + return SQLITE_OK; +} + +static int fts3auxGrowStatArray(Fts3auxCursor *pCsr, int nSize){ + if( nSize>pCsr->nStat ){ + struct Fts3auxColstats *aNew; + aNew = (struct Fts3auxColstats *)sqlite3_realloc64(pCsr->aStat, + sizeof(struct Fts3auxColstats) * nSize + ); + if( aNew==0 ) return SQLITE_NOMEM; + memset(&aNew[pCsr->nStat], 0, + sizeof(struct Fts3auxColstats) * (nSize - pCsr->nStat) + ); + pCsr->aStat = aNew; + pCsr->nStat = nSize; + } + return SQLITE_OK; +} + +/* +** xNext - Advance the cursor to the next row, if any. +*/ +static int fts3auxNextMethod(sqlite3_vtab_cursor *pCursor){ + Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor; + Fts3Table *pFts3 = ((Fts3auxTable *)pCursor->pVtab)->pFts3Tab; + int rc; + + /* Increment our pretend rowid value. */ + pCsr->iRowid++; + + for(pCsr->iCol++; pCsr->iColnStat; pCsr->iCol++){ + if( pCsr->aStat[pCsr->iCol].nDoc>0 ) return SQLITE_OK; + } + + rc = sqlite3Fts3SegReaderStep(pFts3, &pCsr->csr); + if( rc==SQLITE_ROW ){ + int i = 0; + int nDoclist = pCsr->csr.nDoclist; + char *aDoclist = pCsr->csr.aDoclist; + int iCol; + + int eState = 0; + + if( pCsr->zStop ){ + int n = (pCsr->nStopcsr.nTerm) ? pCsr->nStop : pCsr->csr.nTerm; + int mc = memcmp(pCsr->zStop, pCsr->csr.zTerm, n); + if( mc<0 || (mc==0 && pCsr->csr.nTerm>pCsr->nStop) ){ + pCsr->isEof = 1; + return SQLITE_OK; + } + } + + if( fts3auxGrowStatArray(pCsr, 2) ) return SQLITE_NOMEM; + memset(pCsr->aStat, 0, sizeof(struct Fts3auxColstats) * pCsr->nStat); + iCol = 0; + rc = SQLITE_OK; + + while( iaStat[0].nDoc++; + eState = 1; + iCol = 0; + break; + + /* State 1. In this state we are expecting either a 1, indicating + ** that the following integer will be a column number, or the + ** start of a position list for column 0. + ** + ** The only difference between state 1 and state 2 is that if the + ** integer encountered in state 1 is not 0 or 1, then we need to + ** increment the column 0 "nDoc" count for this term. + */ + case 1: + assert( iCol==0 ); + if( v>1 ){ + pCsr->aStat[1].nDoc++; + } + eState = 2; + /* fall through */ + + case 2: + if( v==0 ){ /* 0x00. Next integer will be a docid. */ + eState = 0; + }else if( v==1 ){ /* 0x01. Next integer will be a column number. */ + eState = 3; + }else{ /* 2 or greater. A position. */ + pCsr->aStat[iCol+1].nOcc++; + pCsr->aStat[0].nOcc++; + } + break; + + /* State 3. The integer just read is a column number. */ + default: assert( eState==3 ); + iCol = (int)v; + if( iCol<1 ){ + rc = SQLITE_CORRUPT_VTAB; + break; + } + if( fts3auxGrowStatArray(pCsr, iCol+2) ) return SQLITE_NOMEM; + pCsr->aStat[iCol+1].nDoc++; + eState = 2; + break; + } + } + + pCsr->iCol = 0; + }else{ + pCsr->isEof = 1; + } + return rc; +} + +/* +** xFilter - Initialize a cursor to point at the start of its data. +*/ +static int fts3auxFilterMethod( + sqlite3_vtab_cursor *pCursor, /* The cursor used for this query */ + int idxNum, /* Strategy index */ + const char *idxStr, /* Unused */ + int nVal, /* Number of elements in apVal */ + sqlite3_value **apVal /* Arguments for the indexing scheme */ +){ + Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor; + Fts3Table *pFts3 = ((Fts3auxTable *)pCursor->pVtab)->pFts3Tab; + int rc; + int isScan = 0; + int iLangVal = 0; /* Language id to query */ + + int iEq = -1; /* Index of term=? value in apVal */ + int iGe = -1; /* Index of term>=? value in apVal */ + int iLe = -1; /* Index of term<=? value in apVal */ + int iLangid = -1; /* Index of languageid=? value in apVal */ + int iNext = 0; + + UNUSED_PARAMETER(nVal); + UNUSED_PARAMETER(idxStr); + + assert( idxStr==0 ); + assert( idxNum==FTS4AUX_EQ_CONSTRAINT || idxNum==0 + || idxNum==FTS4AUX_LE_CONSTRAINT || idxNum==FTS4AUX_GE_CONSTRAINT + || idxNum==(FTS4AUX_LE_CONSTRAINT|FTS4AUX_GE_CONSTRAINT) + ); + + if( idxNum==FTS4AUX_EQ_CONSTRAINT ){ + iEq = iNext++; + }else{ + isScan = 1; + if( idxNum & FTS4AUX_GE_CONSTRAINT ){ + iGe = iNext++; + } + if( idxNum & FTS4AUX_LE_CONSTRAINT ){ + iLe = iNext++; + } + } + if( iNextfilter.zTerm); + sqlite3Fts3SegReaderFinish(&pCsr->csr); + sqlite3_free((void *)pCsr->filter.zTerm); + sqlite3_free(pCsr->aStat); + sqlite3_free(pCsr->zStop); + memset(&pCsr->csr, 0, ((u8*)&pCsr[1]) - (u8*)&pCsr->csr); + + pCsr->filter.flags = FTS3_SEGMENT_REQUIRE_POS|FTS3_SEGMENT_IGNORE_EMPTY; + if( isScan ) pCsr->filter.flags |= FTS3_SEGMENT_SCAN; + + if( iEq>=0 || iGe>=0 ){ + const unsigned char *zStr = sqlite3_value_text(apVal[0]); + assert( (iEq==0 && iGe==-1) || (iEq==-1 && iGe==0) ); + if( zStr ){ + pCsr->filter.zTerm = sqlite3_mprintf("%s", zStr); + if( pCsr->filter.zTerm==0 ) return SQLITE_NOMEM; + pCsr->filter.nTerm = (int)strlen(pCsr->filter.zTerm); + } + } + + if( iLe>=0 ){ + pCsr->zStop = sqlite3_mprintf("%s", sqlite3_value_text(apVal[iLe])); + if( pCsr->zStop==0 ) return SQLITE_NOMEM; + pCsr->nStop = (int)strlen(pCsr->zStop); + } + + if( iLangid>=0 ){ + iLangVal = sqlite3_value_int(apVal[iLangid]); + + /* If the user specified a negative value for the languageid, use zero + ** instead. This works, as the "languageid=?" constraint will also + ** be tested by the VDBE layer. The test will always be false (since + ** this module will not return a row with a negative languageid), and + ** so the overall query will return zero rows. */ + if( iLangVal<0 ) iLangVal = 0; + } + pCsr->iLangid = iLangVal; + + rc = sqlite3Fts3SegReaderCursor(pFts3, iLangVal, 0, FTS3_SEGCURSOR_ALL, + pCsr->filter.zTerm, pCsr->filter.nTerm, 0, isScan, &pCsr->csr + ); + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3SegReaderStart(pFts3, &pCsr->csr, &pCsr->filter); + } + + if( rc==SQLITE_OK ) rc = fts3auxNextMethod(pCursor); + return rc; +} + +/* +** xEof - Return true if the cursor is at EOF, or false otherwise. +*/ +static int fts3auxEofMethod(sqlite3_vtab_cursor *pCursor){ + Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor; + return pCsr->isEof; +} + +/* +** xColumn - Return a column value. +*/ +static int fts3auxColumnMethod( + sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */ + sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */ + int iCol /* Index of column to read value from */ +){ + Fts3auxCursor *p = (Fts3auxCursor *)pCursor; + + assert( p->isEof==0 ); + switch( iCol ){ + case 0: /* term */ + sqlite3_result_text(pCtx, p->csr.zTerm, p->csr.nTerm, SQLITE_TRANSIENT); + break; + + case 1: /* col */ + if( p->iCol ){ + sqlite3_result_int(pCtx, p->iCol-1); + }else{ + sqlite3_result_text(pCtx, "*", -1, SQLITE_STATIC); + } + break; + + case 2: /* documents */ + sqlite3_result_int64(pCtx, p->aStat[p->iCol].nDoc); + break; + + case 3: /* occurrences */ + sqlite3_result_int64(pCtx, p->aStat[p->iCol].nOcc); + break; + + default: /* languageid */ + assert( iCol==4 ); + sqlite3_result_int(pCtx, p->iLangid); + break; + } + + return SQLITE_OK; +} + +/* +** xRowid - Return the current rowid for the cursor. +*/ +static int fts3auxRowidMethod( + sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */ + sqlite_int64 *pRowid /* OUT: Rowid value */ +){ + Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor; + *pRowid = pCsr->iRowid; + return SQLITE_OK; +} + +/* +** Register the fts3aux module with database connection db. Return SQLITE_OK +** if successful or an error code if sqlite3_create_module() fails. +*/ +SQLITE_PRIVATE int sqlite3Fts3InitAux(sqlite3 *db){ + static const sqlite3_module fts3aux_module = { + 0, /* iVersion */ + fts3auxConnectMethod, /* xCreate */ + fts3auxConnectMethod, /* xConnect */ + fts3auxBestIndexMethod, /* xBestIndex */ + fts3auxDisconnectMethod, /* xDisconnect */ + fts3auxDisconnectMethod, /* xDestroy */ + fts3auxOpenMethod, /* xOpen */ + fts3auxCloseMethod, /* xClose */ + fts3auxFilterMethod, /* xFilter */ + fts3auxNextMethod, /* xNext */ + fts3auxEofMethod, /* xEof */ + fts3auxColumnMethod, /* xColumn */ + fts3auxRowidMethod, /* xRowid */ + 0, /* xUpdate */ + 0, /* xBegin */ + 0, /* xSync */ + 0, /* xCommit */ + 0, /* xRollback */ + 0, /* xFindFunction */ + 0, /* xRename */ + 0, /* xSavepoint */ + 0, /* xRelease */ + 0, /* xRollbackTo */ + 0 /* xShadowName */ + }; + int rc; /* Return code */ + + rc = sqlite3_create_module(db, "fts4aux", &fts3aux_module, 0); + return rc; +} + +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_aux.c ********************************************/ +/************** Begin file fts3_expr.c ***************************************/ +/* +** 2008 Nov 28 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This module contains code that implements a parser for fts3 query strings +** (the right-hand argument to the MATCH operator). Because the supported +** syntax is relatively simple, the whole tokenizer/parser system is +** hand-coded. +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* +** By default, this module parses the legacy syntax that has been +** traditionally used by fts3. Or, if SQLITE_ENABLE_FTS3_PARENTHESIS +** is defined, then it uses the new syntax. The differences between +** the new and the old syntaxes are: +** +** a) The new syntax supports parenthesis. The old does not. +** +** b) The new syntax supports the AND and NOT operators. The old does not. +** +** c) The old syntax supports the "-" token qualifier. This is not +** supported by the new syntax (it is replaced by the NOT operator). +** +** d) When using the old syntax, the OR operator has a greater precedence +** than an implicit AND. When using the new, both implicity and explicit +** AND operators have a higher precedence than OR. +** +** If compiled with SQLITE_TEST defined, then this module exports the +** symbol "int sqlite3_fts3_enable_parentheses". Setting this variable +** to zero causes the module to use the old syntax. If it is set to +** non-zero the new syntax is activated. This is so both syntaxes can +** be tested using a single build of testfixture. +** +** The following describes the syntax supported by the fts3 MATCH +** operator in a similar format to that used by the lemon parser +** generator. This module does not use actually lemon, it uses a +** custom parser. +** +** query ::= andexpr (OR andexpr)*. +** +** andexpr ::= notexpr (AND? notexpr)*. +** +** notexpr ::= nearexpr (NOT nearexpr|-TOKEN)*. +** notexpr ::= LP query RP. +** +** nearexpr ::= phrase (NEAR distance_opt nearexpr)*. +** +** distance_opt ::= . +** distance_opt ::= / INTEGER. +** +** phrase ::= TOKEN. +** phrase ::= COLUMN:TOKEN. +** phrase ::= "TOKEN TOKEN TOKEN...". +*/ + +#ifdef SQLITE_TEST +SQLITE_API int sqlite3_fts3_enable_parentheses = 0; +#else +# ifdef SQLITE_ENABLE_FTS3_PARENTHESIS +# define sqlite3_fts3_enable_parentheses 1 +# else +# define sqlite3_fts3_enable_parentheses 0 +# endif +#endif + +/* +** Default span for NEAR operators. +*/ +#define SQLITE_FTS3_DEFAULT_NEAR_PARAM 10 + +/* #include */ +/* #include */ + +/* +** isNot: +** This variable is used by function getNextNode(). When getNextNode() is +** called, it sets ParseContext.isNot to true if the 'next node' is a +** FTSQUERY_PHRASE with a unary "-" attached to it. i.e. "mysql" in the +** FTS3 query "sqlite -mysql". Otherwise, ParseContext.isNot is set to +** zero. +*/ +typedef struct ParseContext ParseContext; +struct ParseContext { + sqlite3_tokenizer *pTokenizer; /* Tokenizer module */ + int iLangid; /* Language id used with tokenizer */ + const char **azCol; /* Array of column names for fts3 table */ + int bFts4; /* True to allow FTS4-only syntax */ + int nCol; /* Number of entries in azCol[] */ + int iDefaultCol; /* Default column to query */ + int isNot; /* True if getNextNode() sees a unary - */ + sqlite3_context *pCtx; /* Write error message here */ + int nNest; /* Number of nested brackets */ +}; + +/* +** This function is equivalent to the standard isspace() function. +** +** The standard isspace() can be awkward to use safely, because although it +** is defined to accept an argument of type int, its behavior when passed +** an integer that falls outside of the range of the unsigned char type +** is undefined (and sometimes, "undefined" means segfault). This wrapper +** is defined to accept an argument of type char, and always returns 0 for +** any values that fall outside of the range of the unsigned char type (i.e. +** negative values). +*/ +static int fts3isspace(char c){ + return c==' ' || c=='\t' || c=='\n' || c=='\r' || c=='\v' || c=='\f'; +} + +/* +** Allocate nByte bytes of memory using sqlite3_malloc(). If successful, +** zero the memory before returning a pointer to it. If unsuccessful, +** return NULL. +*/ +SQLITE_PRIVATE void *sqlite3Fts3MallocZero(sqlite3_int64 nByte){ + void *pRet = sqlite3_malloc64(nByte); + if( pRet ) memset(pRet, 0, nByte); + return pRet; +} + +SQLITE_PRIVATE int sqlite3Fts3OpenTokenizer( + sqlite3_tokenizer *pTokenizer, + int iLangid, + const char *z, + int n, + sqlite3_tokenizer_cursor **ppCsr +){ + sqlite3_tokenizer_module const *pModule = pTokenizer->pModule; + sqlite3_tokenizer_cursor *pCsr = 0; + int rc; + + rc = pModule->xOpen(pTokenizer, z, n, &pCsr); + assert( rc==SQLITE_OK || pCsr==0 ); + if( rc==SQLITE_OK ){ + pCsr->pTokenizer = pTokenizer; + if( pModule->iVersion>=1 ){ + rc = pModule->xLanguageid(pCsr, iLangid); + if( rc!=SQLITE_OK ){ + pModule->xClose(pCsr); + pCsr = 0; + } + } + } + *ppCsr = pCsr; + return rc; +} + +/* +** Function getNextNode(), which is called by fts3ExprParse(), may itself +** call fts3ExprParse(). So this forward declaration is required. +*/ +static int fts3ExprParse(ParseContext *, const char *, int, Fts3Expr **, int *); + +/* +** Extract the next token from buffer z (length n) using the tokenizer +** and other information (column names etc.) in pParse. Create an Fts3Expr +** structure of type FTSQUERY_PHRASE containing a phrase consisting of this +** single token and set *ppExpr to point to it. If the end of the buffer is +** reached before a token is found, set *ppExpr to zero. It is the +** responsibility of the caller to eventually deallocate the allocated +** Fts3Expr structure (if any) by passing it to sqlite3_free(). +** +** Return SQLITE_OK if successful, or SQLITE_NOMEM if a memory allocation +** fails. +*/ +static int getNextToken( + ParseContext *pParse, /* fts3 query parse context */ + int iCol, /* Value for Fts3Phrase.iColumn */ + const char *z, int n, /* Input string */ + Fts3Expr **ppExpr, /* OUT: expression */ + int *pnConsumed /* OUT: Number of bytes consumed */ +){ + sqlite3_tokenizer *pTokenizer = pParse->pTokenizer; + sqlite3_tokenizer_module const *pModule = pTokenizer->pModule; + int rc; + sqlite3_tokenizer_cursor *pCursor; + Fts3Expr *pRet = 0; + int i = 0; + + /* Set variable i to the maximum number of bytes of input to tokenize. */ + for(i=0; iiLangid, z, i, &pCursor); + if( rc==SQLITE_OK ){ + const char *zToken; + int nToken = 0, iStart = 0, iEnd = 0, iPosition = 0; + sqlite3_int64 nByte; /* total space to allocate */ + + rc = pModule->xNext(pCursor, &zToken, &nToken, &iStart, &iEnd, &iPosition); + if( rc==SQLITE_OK ){ + nByte = sizeof(Fts3Expr) + sizeof(Fts3Phrase) + nToken; + pRet = (Fts3Expr *)sqlite3Fts3MallocZero(nByte); + if( !pRet ){ + rc = SQLITE_NOMEM; + }else{ + pRet->eType = FTSQUERY_PHRASE; + pRet->pPhrase = (Fts3Phrase *)&pRet[1]; + pRet->pPhrase->nToken = 1; + pRet->pPhrase->iColumn = iCol; + pRet->pPhrase->aToken[0].n = nToken; + pRet->pPhrase->aToken[0].z = (char *)&pRet->pPhrase[1]; + memcpy(pRet->pPhrase->aToken[0].z, zToken, nToken); + + if( iEndpPhrase->aToken[0].isPrefix = 1; + iEnd++; + } + + while( 1 ){ + if( !sqlite3_fts3_enable_parentheses + && iStart>0 && z[iStart-1]=='-' + ){ + pParse->isNot = 1; + iStart--; + }else if( pParse->bFts4 && iStart>0 && z[iStart-1]=='^' ){ + pRet->pPhrase->aToken[0].bFirst = 1; + iStart--; + }else{ + break; + } + } + + } + *pnConsumed = iEnd; + }else if( i && rc==SQLITE_DONE ){ + rc = SQLITE_OK; + } + + pModule->xClose(pCursor); + } + + *ppExpr = pRet; + return rc; +} + + +/* +** Enlarge a memory allocation. If an out-of-memory allocation occurs, +** then free the old allocation. +*/ +static void *fts3ReallocOrFree(void *pOrig, sqlite3_int64 nNew){ + void *pRet = sqlite3_realloc64(pOrig, nNew); + if( !pRet ){ + sqlite3_free(pOrig); + } + return pRet; +} + +/* +** Buffer zInput, length nInput, contains the contents of a quoted string +** that appeared as part of an fts3 query expression. Neither quote character +** is included in the buffer. This function attempts to tokenize the entire +** input buffer and create an Fts3Expr structure of type FTSQUERY_PHRASE +** containing the results. +** +** If successful, SQLITE_OK is returned and *ppExpr set to point at the +** allocated Fts3Expr structure. Otherwise, either SQLITE_NOMEM (out of memory +** error) or SQLITE_ERROR (tokenization error) is returned and *ppExpr set +** to 0. +*/ +static int getNextString( + ParseContext *pParse, /* fts3 query parse context */ + const char *zInput, int nInput, /* Input string */ + Fts3Expr **ppExpr /* OUT: expression */ +){ + sqlite3_tokenizer *pTokenizer = pParse->pTokenizer; + sqlite3_tokenizer_module const *pModule = pTokenizer->pModule; + int rc; + Fts3Expr *p = 0; + sqlite3_tokenizer_cursor *pCursor = 0; + char *zTemp = 0; + int nTemp = 0; + + const int nSpace = sizeof(Fts3Expr) + sizeof(Fts3Phrase); + int nToken = 0; + + /* The final Fts3Expr data structure, including the Fts3Phrase, + ** Fts3PhraseToken structures token buffers are all stored as a single + ** allocation so that the expression can be freed with a single call to + ** sqlite3_free(). Setting this up requires a two pass approach. + ** + ** The first pass, in the block below, uses a tokenizer cursor to iterate + ** through the tokens in the expression. This pass uses fts3ReallocOrFree() + ** to assemble data in two dynamic buffers: + ** + ** Buffer p: Points to the Fts3Expr structure, followed by the Fts3Phrase + ** structure, followed by the array of Fts3PhraseToken + ** structures. This pass only populates the Fts3PhraseToken array. + ** + ** Buffer zTemp: Contains copies of all tokens. + ** + ** The second pass, in the block that begins "if( rc==SQLITE_DONE )" below, + ** appends buffer zTemp to buffer p, and fills in the Fts3Expr and Fts3Phrase + ** structures. + */ + rc = sqlite3Fts3OpenTokenizer( + pTokenizer, pParse->iLangid, zInput, nInput, &pCursor); + if( rc==SQLITE_OK ){ + int ii; + for(ii=0; rc==SQLITE_OK; ii++){ + const char *zByte; + int nByte = 0, iBegin = 0, iEnd = 0, iPos = 0; + rc = pModule->xNext(pCursor, &zByte, &nByte, &iBegin, &iEnd, &iPos); + if( rc==SQLITE_OK ){ + Fts3PhraseToken *pToken; + + p = fts3ReallocOrFree(p, nSpace + ii*sizeof(Fts3PhraseToken)); + if( !p ) goto no_mem; + + zTemp = fts3ReallocOrFree(zTemp, nTemp + nByte); + if( !zTemp ) goto no_mem; + + assert( nToken==ii ); + pToken = &((Fts3Phrase *)(&p[1]))->aToken[ii]; + memset(pToken, 0, sizeof(Fts3PhraseToken)); + + memcpy(&zTemp[nTemp], zByte, nByte); + nTemp += nByte; + + pToken->n = nByte; + pToken->isPrefix = (iEndbFirst = (iBegin>0 && zInput[iBegin-1]=='^'); + nToken = ii+1; + } + } + + pModule->xClose(pCursor); + pCursor = 0; + } + + if( rc==SQLITE_DONE ){ + int jj; + char *zBuf = 0; + + p = fts3ReallocOrFree(p, nSpace + nToken*sizeof(Fts3PhraseToken) + nTemp); + if( !p ) goto no_mem; + memset(p, 0, (char *)&(((Fts3Phrase *)&p[1])->aToken[0])-(char *)p); + p->eType = FTSQUERY_PHRASE; + p->pPhrase = (Fts3Phrase *)&p[1]; + p->pPhrase->iColumn = pParse->iDefaultCol; + p->pPhrase->nToken = nToken; + + zBuf = (char *)&p->pPhrase->aToken[nToken]; + if( zTemp ){ + memcpy(zBuf, zTemp, nTemp); + sqlite3_free(zTemp); + }else{ + assert( nTemp==0 ); + } + + for(jj=0; jjpPhrase->nToken; jj++){ + p->pPhrase->aToken[jj].z = zBuf; + zBuf += p->pPhrase->aToken[jj].n; + } + rc = SQLITE_OK; + } + + *ppExpr = p; + return rc; +no_mem: + + if( pCursor ){ + pModule->xClose(pCursor); + } + sqlite3_free(zTemp); + sqlite3_free(p); + *ppExpr = 0; + return SQLITE_NOMEM; +} + +/* +** The output variable *ppExpr is populated with an allocated Fts3Expr +** structure, or set to 0 if the end of the input buffer is reached. +** +** Returns an SQLite error code. SQLITE_OK if everything works, SQLITE_NOMEM +** if a malloc failure occurs, or SQLITE_ERROR if a parse error is encountered. +** If SQLITE_ERROR is returned, pContext is populated with an error message. +*/ +static int getNextNode( + ParseContext *pParse, /* fts3 query parse context */ + const char *z, int n, /* Input string */ + Fts3Expr **ppExpr, /* OUT: expression */ + int *pnConsumed /* OUT: Number of bytes consumed */ +){ + static const struct Fts3Keyword { + char *z; /* Keyword text */ + unsigned char n; /* Length of the keyword */ + unsigned char parenOnly; /* Only valid in paren mode */ + unsigned char eType; /* Keyword code */ + } aKeyword[] = { + { "OR" , 2, 0, FTSQUERY_OR }, + { "AND", 3, 1, FTSQUERY_AND }, + { "NOT", 3, 1, FTSQUERY_NOT }, + { "NEAR", 4, 0, FTSQUERY_NEAR } + }; + int ii; + int iCol; + int iColLen; + int rc; + Fts3Expr *pRet = 0; + + const char *zInput = z; + int nInput = n; + + pParse->isNot = 0; + + /* Skip over any whitespace before checking for a keyword, an open or + ** close bracket, or a quoted string. + */ + while( nInput>0 && fts3isspace(*zInput) ){ + nInput--; + zInput++; + } + if( nInput==0 ){ + return SQLITE_DONE; + } + + /* See if we are dealing with a keyword. */ + for(ii=0; ii<(int)(sizeof(aKeyword)/sizeof(struct Fts3Keyword)); ii++){ + const struct Fts3Keyword *pKey = &aKeyword[ii]; + + if( (pKey->parenOnly & ~sqlite3_fts3_enable_parentheses)!=0 ){ + continue; + } + + if( nInput>=pKey->n && 0==memcmp(zInput, pKey->z, pKey->n) ){ + int nNear = SQLITE_FTS3_DEFAULT_NEAR_PARAM; + int nKey = pKey->n; + char cNext; + + /* If this is a "NEAR" keyword, check for an explicit nearness. */ + if( pKey->eType==FTSQUERY_NEAR ){ + assert( nKey==4 ); + if( zInput[4]=='/' && zInput[5]>='0' && zInput[5]<='9' ){ + nKey += 1+sqlite3Fts3ReadInt(&zInput[nKey+1], &nNear); + } + } + + /* At this point this is probably a keyword. But for that to be true, + ** the next byte must contain either whitespace, an open or close + ** parenthesis, a quote character, or EOF. + */ + cNext = zInput[nKey]; + if( fts3isspace(cNext) + || cNext=='"' || cNext=='(' || cNext==')' || cNext==0 + ){ + pRet = (Fts3Expr *)sqlite3Fts3MallocZero(sizeof(Fts3Expr)); + if( !pRet ){ + return SQLITE_NOMEM; + } + pRet->eType = pKey->eType; + pRet->nNear = nNear; + *ppExpr = pRet; + *pnConsumed = (int)((zInput - z) + nKey); + return SQLITE_OK; + } + + /* Turns out that wasn't a keyword after all. This happens if the + ** user has supplied a token such as "ORacle". Continue. + */ + } + } + + /* See if we are dealing with a quoted phrase. If this is the case, then + ** search for the closing quote and pass the whole string to getNextString() + ** for processing. This is easy to do, as fts3 has no syntax for escaping + ** a quote character embedded in a string. + */ + if( *zInput=='"' ){ + for(ii=1; iinNest++; +#if !defined(SQLITE_MAX_EXPR_DEPTH) + if( pParse->nNest>1000 ) return SQLITE_ERROR; +#elif SQLITE_MAX_EXPR_DEPTH>0 + if( pParse->nNest>SQLITE_MAX_EXPR_DEPTH ) return SQLITE_ERROR; +#endif + rc = fts3ExprParse(pParse, zInput+1, nInput-1, ppExpr, &nConsumed); + *pnConsumed = (int)(zInput - z) + 1 + nConsumed; + return rc; + }else if( *zInput==')' ){ + pParse->nNest--; + *pnConsumed = (int)((zInput - z) + 1); + *ppExpr = 0; + return SQLITE_DONE; + } + } + + /* If control flows to this point, this must be a regular token, or + ** the end of the input. Read a regular token using the sqlite3_tokenizer + ** interface. Before doing so, figure out if there is an explicit + ** column specifier for the token. + ** + ** TODO: Strangely, it is not possible to associate a column specifier + ** with a quoted phrase, only with a single token. Not sure if this was + ** an implementation artifact or an intentional decision when fts3 was + ** first implemented. Whichever it was, this module duplicates the + ** limitation. + */ + iCol = pParse->iDefaultCol; + iColLen = 0; + for(ii=0; iinCol; ii++){ + const char *zStr = pParse->azCol[ii]; + int nStr = (int)strlen(zStr); + if( nInput>nStr && zInput[nStr]==':' + && sqlite3_strnicmp(zStr, zInput, nStr)==0 + ){ + iCol = ii; + iColLen = (int)((zInput - z) + nStr + 1); + break; + } + } + rc = getNextToken(pParse, iCol, &z[iColLen], n-iColLen, ppExpr, pnConsumed); + *pnConsumed += iColLen; + return rc; +} + +/* +** The argument is an Fts3Expr structure for a binary operator (any type +** except an FTSQUERY_PHRASE). Return an integer value representing the +** precedence of the operator. Lower values have a higher precedence (i.e. +** group more tightly). For example, in the C language, the == operator +** groups more tightly than ||, and would therefore have a higher precedence. +** +** When using the new fts3 query syntax (when SQLITE_ENABLE_FTS3_PARENTHESIS +** is defined), the order of the operators in precedence from highest to +** lowest is: +** +** NEAR +** NOT +** AND (including implicit ANDs) +** OR +** +** Note that when using the old query syntax, the OR operator has a higher +** precedence than the AND operator. +*/ +static int opPrecedence(Fts3Expr *p){ + assert( p->eType!=FTSQUERY_PHRASE ); + if( sqlite3_fts3_enable_parentheses ){ + return p->eType; + }else if( p->eType==FTSQUERY_NEAR ){ + return 1; + }else if( p->eType==FTSQUERY_OR ){ + return 2; + } + assert( p->eType==FTSQUERY_AND ); + return 3; +} + +/* +** Argument ppHead contains a pointer to the current head of a query +** expression tree being parsed. pPrev is the expression node most recently +** inserted into the tree. This function adds pNew, which is always a binary +** operator node, into the expression tree based on the relative precedence +** of pNew and the existing nodes of the tree. This may result in the head +** of the tree changing, in which case *ppHead is set to the new root node. +*/ +static void insertBinaryOperator( + Fts3Expr **ppHead, /* Pointer to the root node of a tree */ + Fts3Expr *pPrev, /* Node most recently inserted into the tree */ + Fts3Expr *pNew /* New binary node to insert into expression tree */ +){ + Fts3Expr *pSplit = pPrev; + while( pSplit->pParent && opPrecedence(pSplit->pParent)<=opPrecedence(pNew) ){ + pSplit = pSplit->pParent; + } + + if( pSplit->pParent ){ + assert( pSplit->pParent->pRight==pSplit ); + pSplit->pParent->pRight = pNew; + pNew->pParent = pSplit->pParent; + }else{ + *ppHead = pNew; + } + pNew->pLeft = pSplit; + pSplit->pParent = pNew; +} + +/* +** Parse the fts3 query expression found in buffer z, length n. This function +** returns either when the end of the buffer is reached or an unmatched +** closing bracket - ')' - is encountered. +** +** If successful, SQLITE_OK is returned, *ppExpr is set to point to the +** parsed form of the expression and *pnConsumed is set to the number of +** bytes read from buffer z. Otherwise, *ppExpr is set to 0 and SQLITE_NOMEM +** (out of memory error) or SQLITE_ERROR (parse error) is returned. +*/ +static int fts3ExprParse( + ParseContext *pParse, /* fts3 query parse context */ + const char *z, int n, /* Text of MATCH query */ + Fts3Expr **ppExpr, /* OUT: Parsed query structure */ + int *pnConsumed /* OUT: Number of bytes consumed */ +){ + Fts3Expr *pRet = 0; + Fts3Expr *pPrev = 0; + Fts3Expr *pNotBranch = 0; /* Only used in legacy parse mode */ + int nIn = n; + const char *zIn = z; + int rc = SQLITE_OK; + int isRequirePhrase = 1; + + while( rc==SQLITE_OK ){ + Fts3Expr *p = 0; + int nByte = 0; + + rc = getNextNode(pParse, zIn, nIn, &p, &nByte); + assert( nByte>0 || (rc!=SQLITE_OK && p==0) ); + if( rc==SQLITE_OK ){ + if( p ){ + int isPhrase; + + if( !sqlite3_fts3_enable_parentheses + && p->eType==FTSQUERY_PHRASE && pParse->isNot + ){ + /* Create an implicit NOT operator. */ + Fts3Expr *pNot = sqlite3Fts3MallocZero(sizeof(Fts3Expr)); + if( !pNot ){ + sqlite3Fts3ExprFree(p); + rc = SQLITE_NOMEM; + goto exprparse_out; + } + pNot->eType = FTSQUERY_NOT; + pNot->pRight = p; + p->pParent = pNot; + if( pNotBranch ){ + pNot->pLeft = pNotBranch; + pNotBranch->pParent = pNot; + } + pNotBranch = pNot; + p = pPrev; + }else{ + int eType = p->eType; + isPhrase = (eType==FTSQUERY_PHRASE || p->pLeft); + + /* The isRequirePhrase variable is set to true if a phrase or + ** an expression contained in parenthesis is required. If a + ** binary operator (AND, OR, NOT or NEAR) is encounted when + ** isRequirePhrase is set, this is a syntax error. + */ + if( !isPhrase && isRequirePhrase ){ + sqlite3Fts3ExprFree(p); + rc = SQLITE_ERROR; + goto exprparse_out; + } + + if( isPhrase && !isRequirePhrase ){ + /* Insert an implicit AND operator. */ + Fts3Expr *pAnd; + assert( pRet && pPrev ); + pAnd = sqlite3Fts3MallocZero(sizeof(Fts3Expr)); + if( !pAnd ){ + sqlite3Fts3ExprFree(p); + rc = SQLITE_NOMEM; + goto exprparse_out; + } + pAnd->eType = FTSQUERY_AND; + insertBinaryOperator(&pRet, pPrev, pAnd); + pPrev = pAnd; + } + + /* This test catches attempts to make either operand of a NEAR + ** operator something other than a phrase. For example, either of + ** the following: + ** + ** (bracketed expression) NEAR phrase + ** phrase NEAR (bracketed expression) + ** + ** Return an error in either case. + */ + if( pPrev && ( + (eType==FTSQUERY_NEAR && !isPhrase && pPrev->eType!=FTSQUERY_PHRASE) + || (eType!=FTSQUERY_PHRASE && isPhrase && pPrev->eType==FTSQUERY_NEAR) + )){ + sqlite3Fts3ExprFree(p); + rc = SQLITE_ERROR; + goto exprparse_out; + } + + if( isPhrase ){ + if( pRet ){ + assert( pPrev && pPrev->pLeft && pPrev->pRight==0 ); + pPrev->pRight = p; + p->pParent = pPrev; + }else{ + pRet = p; + } + }else{ + insertBinaryOperator(&pRet, pPrev, p); + } + isRequirePhrase = !isPhrase; + } + pPrev = p; + } + assert( nByte>0 ); + } + assert( rc!=SQLITE_OK || (nByte>0 && nByte<=nIn) ); + nIn -= nByte; + zIn += nByte; + } + + if( rc==SQLITE_DONE && pRet && isRequirePhrase ){ + rc = SQLITE_ERROR; + } + + if( rc==SQLITE_DONE ){ + rc = SQLITE_OK; + if( !sqlite3_fts3_enable_parentheses && pNotBranch ){ + if( !pRet ){ + rc = SQLITE_ERROR; + }else{ + Fts3Expr *pIter = pNotBranch; + while( pIter->pLeft ){ + pIter = pIter->pLeft; + } + pIter->pLeft = pRet; + pRet->pParent = pIter; + pRet = pNotBranch; + } + } + } + *pnConsumed = n - nIn; + +exprparse_out: + if( rc!=SQLITE_OK ){ + sqlite3Fts3ExprFree(pRet); + sqlite3Fts3ExprFree(pNotBranch); + pRet = 0; + } + *ppExpr = pRet; + return rc; +} + +/* +** Return SQLITE_ERROR if the maximum depth of the expression tree passed +** as the only argument is more than nMaxDepth. +*/ +static int fts3ExprCheckDepth(Fts3Expr *p, int nMaxDepth){ + int rc = SQLITE_OK; + if( p ){ + if( nMaxDepth<0 ){ + rc = SQLITE_TOOBIG; + }else{ + rc = fts3ExprCheckDepth(p->pLeft, nMaxDepth-1); + if( rc==SQLITE_OK ){ + rc = fts3ExprCheckDepth(p->pRight, nMaxDepth-1); + } + } + } + return rc; +} + +/* +** This function attempts to transform the expression tree at (*pp) to +** an equivalent but more balanced form. The tree is modified in place. +** If successful, SQLITE_OK is returned and (*pp) set to point to the +** new root expression node. +** +** nMaxDepth is the maximum allowable depth of the balanced sub-tree. +** +** Otherwise, if an error occurs, an SQLite error code is returned and +** expression (*pp) freed. +*/ +static int fts3ExprBalance(Fts3Expr **pp, int nMaxDepth){ + int rc = SQLITE_OK; /* Return code */ + Fts3Expr *pRoot = *pp; /* Initial root node */ + Fts3Expr *pFree = 0; /* List of free nodes. Linked by pParent. */ + int eType = pRoot->eType; /* Type of node in this tree */ + + if( nMaxDepth==0 ){ + rc = SQLITE_ERROR; + } + + if( rc==SQLITE_OK ){ + if( (eType==FTSQUERY_AND || eType==FTSQUERY_OR) ){ + Fts3Expr **apLeaf; + apLeaf = (Fts3Expr **)sqlite3_malloc64(sizeof(Fts3Expr *) * nMaxDepth); + if( 0==apLeaf ){ + rc = SQLITE_NOMEM; + }else{ + memset(apLeaf, 0, sizeof(Fts3Expr *) * nMaxDepth); + } + + if( rc==SQLITE_OK ){ + int i; + Fts3Expr *p; + + /* Set $p to point to the left-most leaf in the tree of eType nodes. */ + for(p=pRoot; p->eType==eType; p=p->pLeft){ + assert( p->pParent==0 || p->pParent->pLeft==p ); + assert( p->pLeft && p->pRight ); + } + + /* This loop runs once for each leaf in the tree of eType nodes. */ + while( 1 ){ + int iLvl; + Fts3Expr *pParent = p->pParent; /* Current parent of p */ + + assert( pParent==0 || pParent->pLeft==p ); + p->pParent = 0; + if( pParent ){ + pParent->pLeft = 0; + }else{ + pRoot = 0; + } + rc = fts3ExprBalance(&p, nMaxDepth-1); + if( rc!=SQLITE_OK ) break; + + for(iLvl=0; p && iLvlpLeft = apLeaf[iLvl]; + pFree->pRight = p; + pFree->pLeft->pParent = pFree; + pFree->pRight->pParent = pFree; + + p = pFree; + pFree = pFree->pParent; + p->pParent = 0; + apLeaf[iLvl] = 0; + } + } + if( p ){ + sqlite3Fts3ExprFree(p); + rc = SQLITE_TOOBIG; + break; + } + + /* If that was the last leaf node, break out of the loop */ + if( pParent==0 ) break; + + /* Set $p to point to the next leaf in the tree of eType nodes */ + for(p=pParent->pRight; p->eType==eType; p=p->pLeft); + + /* Remove pParent from the original tree. */ + assert( pParent->pParent==0 || pParent->pParent->pLeft==pParent ); + pParent->pRight->pParent = pParent->pParent; + if( pParent->pParent ){ + pParent->pParent->pLeft = pParent->pRight; + }else{ + assert( pParent==pRoot ); + pRoot = pParent->pRight; + } + + /* Link pParent into the free node list. It will be used as an + ** internal node of the new tree. */ + pParent->pParent = pFree; + pFree = pParent; + } + + if( rc==SQLITE_OK ){ + p = 0; + for(i=0; ipParent = 0; + }else{ + assert( pFree!=0 ); + pFree->pRight = p; + pFree->pLeft = apLeaf[i]; + pFree->pLeft->pParent = pFree; + pFree->pRight->pParent = pFree; + + p = pFree; + pFree = pFree->pParent; + p->pParent = 0; + } + } + } + pRoot = p; + }else{ + /* An error occurred. Delete the contents of the apLeaf[] array + ** and pFree list. Everything else is cleaned up by the call to + ** sqlite3Fts3ExprFree(pRoot) below. */ + Fts3Expr *pDel; + for(i=0; ipParent; + sqlite3_free(pDel); + } + } + + assert( pFree==0 ); + sqlite3_free( apLeaf ); + } + }else if( eType==FTSQUERY_NOT ){ + Fts3Expr *pLeft = pRoot->pLeft; + Fts3Expr *pRight = pRoot->pRight; + + pRoot->pLeft = 0; + pRoot->pRight = 0; + pLeft->pParent = 0; + pRight->pParent = 0; + + rc = fts3ExprBalance(&pLeft, nMaxDepth-1); + if( rc==SQLITE_OK ){ + rc = fts3ExprBalance(&pRight, nMaxDepth-1); + } + + if( rc!=SQLITE_OK ){ + sqlite3Fts3ExprFree(pRight); + sqlite3Fts3ExprFree(pLeft); + }else{ + assert( pLeft && pRight ); + pRoot->pLeft = pLeft; + pLeft->pParent = pRoot; + pRoot->pRight = pRight; + pRight->pParent = pRoot; + } + } + } + + if( rc!=SQLITE_OK ){ + sqlite3Fts3ExprFree(pRoot); + pRoot = 0; + } + *pp = pRoot; + return rc; +} + +/* +** This function is similar to sqlite3Fts3ExprParse(), with the following +** differences: +** +** 1. It does not do expression rebalancing. +** 2. It does not check that the expression does not exceed the +** maximum allowable depth. +** 3. Even if it fails, *ppExpr may still be set to point to an +** expression tree. It should be deleted using sqlite3Fts3ExprFree() +** in this case. +*/ +static int fts3ExprParseUnbalanced( + sqlite3_tokenizer *pTokenizer, /* Tokenizer module */ + int iLangid, /* Language id for tokenizer */ + char **azCol, /* Array of column names for fts3 table */ + int bFts4, /* True to allow FTS4-only syntax */ + int nCol, /* Number of entries in azCol[] */ + int iDefaultCol, /* Default column to query */ + const char *z, int n, /* Text of MATCH query */ + Fts3Expr **ppExpr /* OUT: Parsed query structure */ +){ + int nParsed; + int rc; + ParseContext sParse; + + memset(&sParse, 0, sizeof(ParseContext)); + sParse.pTokenizer = pTokenizer; + sParse.iLangid = iLangid; + sParse.azCol = (const char **)azCol; + sParse.nCol = nCol; + sParse.iDefaultCol = iDefaultCol; + sParse.bFts4 = bFts4; + if( z==0 ){ + *ppExpr = 0; + return SQLITE_OK; + } + if( n<0 ){ + n = (int)strlen(z); + } + rc = fts3ExprParse(&sParse, z, n, ppExpr, &nParsed); + assert( rc==SQLITE_OK || *ppExpr==0 ); + + /* Check for mismatched parenthesis */ + if( rc==SQLITE_OK && sParse.nNest ){ + rc = SQLITE_ERROR; + } + + return rc; +} + +/* +** Parameters z and n contain a pointer to and length of a buffer containing +** an fts3 query expression, respectively. This function attempts to parse the +** query expression and create a tree of Fts3Expr structures representing the +** parsed expression. If successful, *ppExpr is set to point to the head +** of the parsed expression tree and SQLITE_OK is returned. If an error +** occurs, either SQLITE_NOMEM (out-of-memory error) or SQLITE_ERROR (parse +** error) is returned and *ppExpr is set to 0. +** +** If parameter n is a negative number, then z is assumed to point to a +** nul-terminated string and the length is determined using strlen(). +** +** The first parameter, pTokenizer, is passed the fts3 tokenizer module to +** use to normalize query tokens while parsing the expression. The azCol[] +** array, which is assumed to contain nCol entries, should contain the names +** of each column in the target fts3 table, in order from left to right. +** Column names must be nul-terminated strings. +** +** The iDefaultCol parameter should be passed the index of the table column +** that appears on the left-hand-side of the MATCH operator (the default +** column to match against for tokens for which a column name is not explicitly +** specified as part of the query string), or -1 if tokens may by default +** match any table column. +*/ +SQLITE_PRIVATE int sqlite3Fts3ExprParse( + sqlite3_tokenizer *pTokenizer, /* Tokenizer module */ + int iLangid, /* Language id for tokenizer */ + char **azCol, /* Array of column names for fts3 table */ + int bFts4, /* True to allow FTS4-only syntax */ + int nCol, /* Number of entries in azCol[] */ + int iDefaultCol, /* Default column to query */ + const char *z, int n, /* Text of MATCH query */ + Fts3Expr **ppExpr, /* OUT: Parsed query structure */ + char **pzErr /* OUT: Error message (sqlite3_malloc) */ +){ + int rc = fts3ExprParseUnbalanced( + pTokenizer, iLangid, azCol, bFts4, nCol, iDefaultCol, z, n, ppExpr + ); + + /* Rebalance the expression. And check that its depth does not exceed + ** SQLITE_FTS3_MAX_EXPR_DEPTH. */ + if( rc==SQLITE_OK && *ppExpr ){ + rc = fts3ExprBalance(ppExpr, SQLITE_FTS3_MAX_EXPR_DEPTH); + if( rc==SQLITE_OK ){ + rc = fts3ExprCheckDepth(*ppExpr, SQLITE_FTS3_MAX_EXPR_DEPTH); + } + } + + if( rc!=SQLITE_OK ){ + sqlite3Fts3ExprFree(*ppExpr); + *ppExpr = 0; + if( rc==SQLITE_TOOBIG ){ + sqlite3Fts3ErrMsg(pzErr, + "FTS expression tree is too large (maximum depth %d)", + SQLITE_FTS3_MAX_EXPR_DEPTH + ); + rc = SQLITE_ERROR; + }else if( rc==SQLITE_ERROR ){ + sqlite3Fts3ErrMsg(pzErr, "malformed MATCH expression: [%s]", z); + } + } + + return rc; +} + +/* +** Free a single node of an expression tree. +*/ +static void fts3FreeExprNode(Fts3Expr *p){ + assert( p->eType==FTSQUERY_PHRASE || p->pPhrase==0 ); + sqlite3Fts3EvalPhraseCleanup(p->pPhrase); + sqlite3_free(p->aMI); + sqlite3_free(p); +} + +/* +** Free a parsed fts3 query expression allocated by sqlite3Fts3ExprParse(). +** +** This function would be simpler if it recursively called itself. But +** that would mean passing a sufficiently large expression to ExprParse() +** could cause a stack overflow. +*/ +SQLITE_PRIVATE void sqlite3Fts3ExprFree(Fts3Expr *pDel){ + Fts3Expr *p; + assert( pDel==0 || pDel->pParent==0 ); + for(p=pDel; p && (p->pLeft||p->pRight); p=(p->pLeft ? p->pLeft : p->pRight)){ + assert( p->pParent==0 || p==p->pParent->pRight || p==p->pParent->pLeft ); + } + while( p ){ + Fts3Expr *pParent = p->pParent; + fts3FreeExprNode(p); + if( pParent && p==pParent->pLeft && pParent->pRight ){ + p = pParent->pRight; + while( p && (p->pLeft || p->pRight) ){ + assert( p==p->pParent->pRight || p==p->pParent->pLeft ); + p = (p->pLeft ? p->pLeft : p->pRight); + } + }else{ + p = pParent; + } + } +} + +/**************************************************************************** +***************************************************************************** +** Everything after this point is just test code. +*/ + +#ifdef SQLITE_TEST + +/* #include */ + +/* +** Return a pointer to a buffer containing a text representation of the +** expression passed as the first argument. The buffer is obtained from +** sqlite3_malloc(). It is the responsibility of the caller to use +** sqlite3_free() to release the memory. If an OOM condition is encountered, +** NULL is returned. +** +** If the second argument is not NULL, then its contents are prepended to +** the returned expression text and then freed using sqlite3_free(). +*/ +static char *exprToString(Fts3Expr *pExpr, char *zBuf){ + if( pExpr==0 ){ + return sqlite3_mprintf(""); + } + switch( pExpr->eType ){ + case FTSQUERY_PHRASE: { + Fts3Phrase *pPhrase = pExpr->pPhrase; + int i; + zBuf = sqlite3_mprintf( + "%zPHRASE %d 0", zBuf, pPhrase->iColumn); + for(i=0; zBuf && inToken; i++){ + zBuf = sqlite3_mprintf("%z %.*s%s", zBuf, + pPhrase->aToken[i].n, pPhrase->aToken[i].z, + (pPhrase->aToken[i].isPrefix?"+":"") + ); + } + return zBuf; + } + + case FTSQUERY_NEAR: + zBuf = sqlite3_mprintf("%zNEAR/%d ", zBuf, pExpr->nNear); + break; + case FTSQUERY_NOT: + zBuf = sqlite3_mprintf("%zNOT ", zBuf); + break; + case FTSQUERY_AND: + zBuf = sqlite3_mprintf("%zAND ", zBuf); + break; + case FTSQUERY_OR: + zBuf = sqlite3_mprintf("%zOR ", zBuf); + break; + } + + if( zBuf ) zBuf = sqlite3_mprintf("%z{", zBuf); + if( zBuf ) zBuf = exprToString(pExpr->pLeft, zBuf); + if( zBuf ) zBuf = sqlite3_mprintf("%z} {", zBuf); + + if( zBuf ) zBuf = exprToString(pExpr->pRight, zBuf); + if( zBuf ) zBuf = sqlite3_mprintf("%z}", zBuf); + + return zBuf; +} + +/* +** This is the implementation of a scalar SQL function used to test the +** expression parser. It should be called as follows: +** +** fts3_exprtest(, , , ...); +** +** The first argument, , is the name of the fts3 tokenizer used +** to parse the query expression (see README.tokenizers). The second argument +** is the query expression to parse. Each subsequent argument is the name +** of a column of the fts3 table that the query expression may refer to. +** For example: +** +** SELECT fts3_exprtest('simple', 'Bill col2:Bloggs', 'col1', 'col2'); +*/ +static void fts3ExprTestCommon( + int bRebalance, + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + sqlite3_tokenizer *pTokenizer = 0; + int rc; + char **azCol = 0; + const char *zExpr; + int nExpr; + int nCol; + int ii; + Fts3Expr *pExpr; + char *zBuf = 0; + Fts3Hash *pHash = (Fts3Hash*)sqlite3_user_data(context); + const char *zTokenizer = 0; + char *zErr = 0; + + if( argc<3 ){ + sqlite3_result_error(context, + "Usage: fts3_exprtest(tokenizer, expr, col1, ...", -1 + ); + return; + } + + zTokenizer = (const char*)sqlite3_value_text(argv[0]); + rc = sqlite3Fts3InitTokenizer(pHash, zTokenizer, &pTokenizer, &zErr); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_NOMEM ){ + sqlite3_result_error_nomem(context); + }else{ + sqlite3_result_error(context, zErr, -1); + } + sqlite3_free(zErr); + return; + } + + zExpr = (const char *)sqlite3_value_text(argv[1]); + nExpr = sqlite3_value_bytes(argv[1]); + nCol = argc-2; + azCol = (char **)sqlite3_malloc64(nCol*sizeof(char *)); + if( !azCol ){ + sqlite3_result_error_nomem(context); + goto exprtest_out; + } + for(ii=0; iipModule->xDestroy(pTokenizer); + } + sqlite3_free(azCol); +} + +static void fts3ExprTest( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + fts3ExprTestCommon(0, context, argc, argv); +} +static void fts3ExprTestRebalance( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + fts3ExprTestCommon(1, context, argc, argv); +} + +/* +** Register the query expression parser test function fts3_exprtest() +** with database connection db. +*/ +SQLITE_PRIVATE int sqlite3Fts3ExprInitTestInterface(sqlite3 *db, Fts3Hash *pHash){ + int rc = sqlite3_create_function( + db, "fts3_exprtest", -1, SQLITE_UTF8, (void*)pHash, fts3ExprTest, 0, 0 + ); + if( rc==SQLITE_OK ){ + rc = sqlite3_create_function(db, "fts3_exprtest_rebalance", + -1, SQLITE_UTF8, (void*)pHash, fts3ExprTestRebalance, 0, 0 + ); + } + return rc; +} + +#endif +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_expr.c *******************************************/ +/************** Begin file fts3_hash.c ***************************************/ +/* +** 2001 September 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This is the implementation of generic hash-tables used in SQLite. +** We've modified it slightly to serve as a standalone hash table +** implementation for the full-text indexing module. +*/ + +/* +** The code in this file is only compiled if: +** +** * The FTS3 module is being built as an extension +** (in which case SQLITE_CORE is not defined), or +** +** * The FTS3 module is being built into the core of +** SQLite (in which case SQLITE_ENABLE_FTS3 is defined). +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ +/* #include */ + +/* #include "fts3_hash.h" */ + +/* +** Malloc and Free functions +*/ +static void *fts3HashMalloc(sqlite3_int64 n){ + void *p = sqlite3_malloc64(n); + if( p ){ + memset(p, 0, n); + } + return p; +} +static void fts3HashFree(void *p){ + sqlite3_free(p); +} + +/* Turn bulk memory into a hash table object by initializing the +** fields of the Hash structure. +** +** "pNew" is a pointer to the hash table that is to be initialized. +** keyClass is one of the constants +** FTS3_HASH_BINARY or FTS3_HASH_STRING. The value of keyClass +** determines what kind of key the hash table will use. "copyKey" is +** true if the hash table should make its own private copy of keys and +** false if it should just use the supplied pointer. +*/ +SQLITE_PRIVATE void sqlite3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey){ + assert( pNew!=0 ); + assert( keyClass>=FTS3_HASH_STRING && keyClass<=FTS3_HASH_BINARY ); + pNew->keyClass = keyClass; + pNew->copyKey = copyKey; + pNew->first = 0; + pNew->count = 0; + pNew->htsize = 0; + pNew->ht = 0; +} + +/* Remove all entries from a hash table. Reclaim all memory. +** Call this routine to delete a hash table or to reset a hash table +** to the empty state. +*/ +SQLITE_PRIVATE void sqlite3Fts3HashClear(Fts3Hash *pH){ + Fts3HashElem *elem; /* For looping over all elements of the table */ + + assert( pH!=0 ); + elem = pH->first; + pH->first = 0; + fts3HashFree(pH->ht); + pH->ht = 0; + pH->htsize = 0; + while( elem ){ + Fts3HashElem *next_elem = elem->next; + if( pH->copyKey && elem->pKey ){ + fts3HashFree(elem->pKey); + } + fts3HashFree(elem); + elem = next_elem; + } + pH->count = 0; +} + +/* +** Hash and comparison functions when the mode is FTS3_HASH_STRING +*/ +static int fts3StrHash(const void *pKey, int nKey){ + const char *z = (const char *)pKey; + unsigned h = 0; + if( nKey<=0 ) nKey = (int) strlen(z); + while( nKey > 0 ){ + h = (h<<3) ^ h ^ *z++; + nKey--; + } + return (int)(h & 0x7fffffff); +} +static int fts3StrCompare(const void *pKey1, int n1, const void *pKey2, int n2){ + if( n1!=n2 ) return 1; + return strncmp((const char*)pKey1,(const char*)pKey2,n1); +} + +/* +** Hash and comparison functions when the mode is FTS3_HASH_BINARY +*/ +static int fts3BinHash(const void *pKey, int nKey){ + int h = 0; + const char *z = (const char *)pKey; + while( nKey-- > 0 ){ + h = (h<<3) ^ h ^ *(z++); + } + return h & 0x7fffffff; +} +static int fts3BinCompare(const void *pKey1, int n1, const void *pKey2, int n2){ + if( n1!=n2 ) return 1; + return memcmp(pKey1,pKey2,n1); +} + +/* +** Return a pointer to the appropriate hash function given the key class. +** +** The C syntax in this function definition may be unfamilar to some +** programmers, so we provide the following additional explanation: +** +** The name of the function is "ftsHashFunction". The function takes a +** single parameter "keyClass". The return value of ftsHashFunction() +** is a pointer to another function. Specifically, the return value +** of ftsHashFunction() is a pointer to a function that takes two parameters +** with types "const void*" and "int" and returns an "int". +*/ +static int (*ftsHashFunction(int keyClass))(const void*,int){ + if( keyClass==FTS3_HASH_STRING ){ + return &fts3StrHash; + }else{ + assert( keyClass==FTS3_HASH_BINARY ); + return &fts3BinHash; + } +} + +/* +** Return a pointer to the appropriate hash function given the key class. +** +** For help in interpreted the obscure C code in the function definition, +** see the header comment on the previous function. +*/ +static int (*ftsCompareFunction(int keyClass))(const void*,int,const void*,int){ + if( keyClass==FTS3_HASH_STRING ){ + return &fts3StrCompare; + }else{ + assert( keyClass==FTS3_HASH_BINARY ); + return &fts3BinCompare; + } +} + +/* Link an element into the hash table +*/ +static void fts3HashInsertElement( + Fts3Hash *pH, /* The complete hash table */ + struct _fts3ht *pEntry, /* The entry into which pNew is inserted */ + Fts3HashElem *pNew /* The element to be inserted */ +){ + Fts3HashElem *pHead; /* First element already in pEntry */ + pHead = pEntry->chain; + if( pHead ){ + pNew->next = pHead; + pNew->prev = pHead->prev; + if( pHead->prev ){ pHead->prev->next = pNew; } + else { pH->first = pNew; } + pHead->prev = pNew; + }else{ + pNew->next = pH->first; + if( pH->first ){ pH->first->prev = pNew; } + pNew->prev = 0; + pH->first = pNew; + } + pEntry->count++; + pEntry->chain = pNew; +} + + +/* Resize the hash table so that it cantains "new_size" buckets. +** "new_size" must be a power of 2. The hash table might fail +** to resize if sqliteMalloc() fails. +** +** Return non-zero if a memory allocation error occurs. +*/ +static int fts3Rehash(Fts3Hash *pH, int new_size){ + struct _fts3ht *new_ht; /* The new hash table */ + Fts3HashElem *elem, *next_elem; /* For looping over existing elements */ + int (*xHash)(const void*,int); /* The hash function */ + + assert( (new_size & (new_size-1))==0 ); + new_ht = (struct _fts3ht *)fts3HashMalloc( new_size*sizeof(struct _fts3ht) ); + if( new_ht==0 ) return 1; + fts3HashFree(pH->ht); + pH->ht = new_ht; + pH->htsize = new_size; + xHash = ftsHashFunction(pH->keyClass); + for(elem=pH->first, pH->first=0; elem; elem = next_elem){ + int h = (*xHash)(elem->pKey, elem->nKey) & (new_size-1); + next_elem = elem->next; + fts3HashInsertElement(pH, &new_ht[h], elem); + } + return 0; +} + +/* This function (for internal use only) locates an element in an +** hash table that matches the given key. The hash for this key has +** already been computed and is passed as the 4th parameter. +*/ +static Fts3HashElem *fts3FindElementByHash( + const Fts3Hash *pH, /* The pH to be searched */ + const void *pKey, /* The key we are searching for */ + int nKey, + int h /* The hash for this key. */ +){ + Fts3HashElem *elem; /* Used to loop thru the element list */ + int count; /* Number of elements left to test */ + int (*xCompare)(const void*,int,const void*,int); /* comparison function */ + + if( pH->ht ){ + struct _fts3ht *pEntry = &pH->ht[h]; + elem = pEntry->chain; + count = pEntry->count; + xCompare = ftsCompareFunction(pH->keyClass); + while( count-- && elem ){ + if( (*xCompare)(elem->pKey,elem->nKey,pKey,nKey)==0 ){ + return elem; + } + elem = elem->next; + } + } + return 0; +} + +/* Remove a single entry from the hash table given a pointer to that +** element and a hash on the element's key. +*/ +static void fts3RemoveElementByHash( + Fts3Hash *pH, /* The pH containing "elem" */ + Fts3HashElem* elem, /* The element to be removed from the pH */ + int h /* Hash value for the element */ +){ + struct _fts3ht *pEntry; + if( elem->prev ){ + elem->prev->next = elem->next; + }else{ + pH->first = elem->next; + } + if( elem->next ){ + elem->next->prev = elem->prev; + } + pEntry = &pH->ht[h]; + if( pEntry->chain==elem ){ + pEntry->chain = elem->next; + } + pEntry->count--; + if( pEntry->count<=0 ){ + pEntry->chain = 0; + } + if( pH->copyKey && elem->pKey ){ + fts3HashFree(elem->pKey); + } + fts3HashFree( elem ); + pH->count--; + if( pH->count<=0 ){ + assert( pH->first==0 ); + assert( pH->count==0 ); + fts3HashClear(pH); + } +} + +SQLITE_PRIVATE Fts3HashElem *sqlite3Fts3HashFindElem( + const Fts3Hash *pH, + const void *pKey, + int nKey +){ + int h; /* A hash on key */ + int (*xHash)(const void*,int); /* The hash function */ + + if( pH==0 || pH->ht==0 ) return 0; + xHash = ftsHashFunction(pH->keyClass); + assert( xHash!=0 ); + h = (*xHash)(pKey,nKey); + assert( (pH->htsize & (pH->htsize-1))==0 ); + return fts3FindElementByHash(pH,pKey,nKey, h & (pH->htsize-1)); +} + +/* +** Attempt to locate an element of the hash table pH with a key +** that matches pKey,nKey. Return the data for this element if it is +** found, or NULL if there is no match. +*/ +SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash *pH, const void *pKey, int nKey){ + Fts3HashElem *pElem; /* The element that matches key (if any) */ + + pElem = sqlite3Fts3HashFindElem(pH, pKey, nKey); + return pElem ? pElem->data : 0; +} + +/* Insert an element into the hash table pH. The key is pKey,nKey +** and the data is "data". +** +** If no element exists with a matching key, then a new +** element is created. A copy of the key is made if the copyKey +** flag is set. NULL is returned. +** +** If another element already exists with the same key, then the +** new data replaces the old data and the old data is returned. +** The key is not copied in this instance. If a malloc fails, then +** the new data is returned and the hash table is unchanged. +** +** If the "data" parameter to this function is NULL, then the +** element corresponding to "key" is removed from the hash table. +*/ +SQLITE_PRIVATE void *sqlite3Fts3HashInsert( + Fts3Hash *pH, /* The hash table to insert into */ + const void *pKey, /* The key */ + int nKey, /* Number of bytes in the key */ + void *data /* The data */ +){ + int hraw; /* Raw hash value of the key */ + int h; /* the hash of the key modulo hash table size */ + Fts3HashElem *elem; /* Used to loop thru the element list */ + Fts3HashElem *new_elem; /* New element added to the pH */ + int (*xHash)(const void*,int); /* The hash function */ + + assert( pH!=0 ); + xHash = ftsHashFunction(pH->keyClass); + assert( xHash!=0 ); + hraw = (*xHash)(pKey, nKey); + assert( (pH->htsize & (pH->htsize-1))==0 ); + h = hraw & (pH->htsize-1); + elem = fts3FindElementByHash(pH,pKey,nKey,h); + if( elem ){ + void *old_data = elem->data; + if( data==0 ){ + fts3RemoveElementByHash(pH,elem,h); + }else{ + elem->data = data; + } + return old_data; + } + if( data==0 ) return 0; + if( (pH->htsize==0 && fts3Rehash(pH,8)) + || (pH->count>=pH->htsize && fts3Rehash(pH, pH->htsize*2)) + ){ + pH->count = 0; + return data; + } + assert( pH->htsize>0 ); + new_elem = (Fts3HashElem*)fts3HashMalloc( sizeof(Fts3HashElem) ); + if( new_elem==0 ) return data; + if( pH->copyKey && pKey!=0 ){ + new_elem->pKey = fts3HashMalloc( nKey ); + if( new_elem->pKey==0 ){ + fts3HashFree(new_elem); + return data; + } + memcpy((void*)new_elem->pKey, pKey, nKey); + }else{ + new_elem->pKey = (void*)pKey; + } + new_elem->nKey = nKey; + pH->count++; + assert( pH->htsize>0 ); + assert( (pH->htsize & (pH->htsize-1))==0 ); + h = hraw & (pH->htsize-1); + fts3HashInsertElement(pH, &pH->ht[h], new_elem); + new_elem->data = data; + return 0; +} + +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_hash.c *******************************************/ +/************** Begin file fts3_porter.c *************************************/ +/* +** 2006 September 30 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** Implementation of the full-text-search tokenizer that implements +** a Porter stemmer. +*/ + +/* +** The code in this file is only compiled if: +** +** * The FTS3 module is being built as an extension +** (in which case SQLITE_CORE is not defined), or +** +** * The FTS3 module is being built into the core of +** SQLite (in which case SQLITE_ENABLE_FTS3 is defined). +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ +/* #include */ +/* #include */ + +/* #include "fts3_tokenizer.h" */ + +/* +** Class derived from sqlite3_tokenizer +*/ +typedef struct porter_tokenizer { + sqlite3_tokenizer base; /* Base class */ +} porter_tokenizer; + +/* +** Class derived from sqlite3_tokenizer_cursor +*/ +typedef struct porter_tokenizer_cursor { + sqlite3_tokenizer_cursor base; + const char *zInput; /* input we are tokenizing */ + int nInput; /* size of the input */ + int iOffset; /* current position in zInput */ + int iToken; /* index of next token to be returned */ + char *zToken; /* storage for current token */ + int nAllocated; /* space allocated to zToken buffer */ +} porter_tokenizer_cursor; + + +/* +** Create a new tokenizer instance. +*/ +static int porterCreate( + int argc, const char * const *argv, + sqlite3_tokenizer **ppTokenizer +){ + porter_tokenizer *t; + + UNUSED_PARAMETER(argc); + UNUSED_PARAMETER(argv); + + t = (porter_tokenizer *) sqlite3_malloc(sizeof(*t)); + if( t==NULL ) return SQLITE_NOMEM; + memset(t, 0, sizeof(*t)); + *ppTokenizer = &t->base; + return SQLITE_OK; +} + +/* +** Destroy a tokenizer +*/ +static int porterDestroy(sqlite3_tokenizer *pTokenizer){ + sqlite3_free(pTokenizer); + return SQLITE_OK; +} + +/* +** Prepare to begin tokenizing a particular string. The input +** string to be tokenized is zInput[0..nInput-1]. A cursor +** used to incrementally tokenize this string is returned in +** *ppCursor. +*/ +static int porterOpen( + sqlite3_tokenizer *pTokenizer, /* The tokenizer */ + const char *zInput, int nInput, /* String to be tokenized */ + sqlite3_tokenizer_cursor **ppCursor /* OUT: Tokenization cursor */ +){ + porter_tokenizer_cursor *c; + + UNUSED_PARAMETER(pTokenizer); + + c = (porter_tokenizer_cursor *) sqlite3_malloc(sizeof(*c)); + if( c==NULL ) return SQLITE_NOMEM; + + c->zInput = zInput; + if( zInput==0 ){ + c->nInput = 0; + }else if( nInput<0 ){ + c->nInput = (int)strlen(zInput); + }else{ + c->nInput = nInput; + } + c->iOffset = 0; /* start tokenizing at the beginning */ + c->iToken = 0; + c->zToken = NULL; /* no space allocated, yet. */ + c->nAllocated = 0; + + *ppCursor = &c->base; + return SQLITE_OK; +} + +/* +** Close a tokenization cursor previously opened by a call to +** porterOpen() above. +*/ +static int porterClose(sqlite3_tokenizer_cursor *pCursor){ + porter_tokenizer_cursor *c = (porter_tokenizer_cursor *) pCursor; + sqlite3_free(c->zToken); + sqlite3_free(c); + return SQLITE_OK; +} +/* +** Vowel or consonant +*/ +static const char cType[] = { + 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, + 1, 1, 1, 2, 1 +}; + +/* +** isConsonant() and isVowel() determine if their first character in +** the string they point to is a consonant or a vowel, according +** to Porter ruls. +** +** A consonate is any letter other than 'a', 'e', 'i', 'o', or 'u'. +** 'Y' is a consonant unless it follows another consonant, +** in which case it is a vowel. +** +** In these routine, the letters are in reverse order. So the 'y' rule +** is that 'y' is a consonant unless it is followed by another +** consonent. +*/ +static int isVowel(const char*); +static int isConsonant(const char *z){ + int j; + char x = *z; + if( x==0 ) return 0; + assert( x>='a' && x<='z' ); + j = cType[x-'a']; + if( j<2 ) return j; + return z[1]==0 || isVowel(z + 1); +} +static int isVowel(const char *z){ + int j; + char x = *z; + if( x==0 ) return 0; + assert( x>='a' && x<='z' ); + j = cType[x-'a']; + if( j<2 ) return 1-j; + return isConsonant(z + 1); +} + +/* +** Let any sequence of one or more vowels be represented by V and let +** C be sequence of one or more consonants. Then every word can be +** represented as: +** +** [C] (VC){m} [V] +** +** In prose: A word is an optional consonant followed by zero or +** vowel-consonant pairs followed by an optional vowel. "m" is the +** number of vowel consonant pairs. This routine computes the value +** of m for the first i bytes of a word. +** +** Return true if the m-value for z is 1 or more. In other words, +** return true if z contains at least one vowel that is followed +** by a consonant. +** +** In this routine z[] is in reverse order. So we are really looking +** for an instance of a consonant followed by a vowel. +*/ +static int m_gt_0(const char *z){ + while( isVowel(z) ){ z++; } + if( *z==0 ) return 0; + while( isConsonant(z) ){ z++; } + return *z!=0; +} + +/* Like mgt0 above except we are looking for a value of m which is +** exactly 1 +*/ +static int m_eq_1(const char *z){ + while( isVowel(z) ){ z++; } + if( *z==0 ) return 0; + while( isConsonant(z) ){ z++; } + if( *z==0 ) return 0; + while( isVowel(z) ){ z++; } + if( *z==0 ) return 1; + while( isConsonant(z) ){ z++; } + return *z==0; +} + +/* Like mgt0 above except we are looking for a value of m>1 instead +** or m>0 +*/ +static int m_gt_1(const char *z){ + while( isVowel(z) ){ z++; } + if( *z==0 ) return 0; + while( isConsonant(z) ){ z++; } + if( *z==0 ) return 0; + while( isVowel(z) ){ z++; } + if( *z==0 ) return 0; + while( isConsonant(z) ){ z++; } + return *z!=0; +} + +/* +** Return TRUE if there is a vowel anywhere within z[0..n-1] +*/ +static int hasVowel(const char *z){ + while( isConsonant(z) ){ z++; } + return *z!=0; +} + +/* +** Return TRUE if the word ends in a double consonant. +** +** The text is reversed here. So we are really looking at +** the first two characters of z[]. +*/ +static int doubleConsonant(const char *z){ + return isConsonant(z) && z[0]==z[1]; +} + +/* +** Return TRUE if the word ends with three letters which +** are consonant-vowel-consonent and where the final consonant +** is not 'w', 'x', or 'y'. +** +** The word is reversed here. So we are really checking the +** first three letters and the first one cannot be in [wxy]. +*/ +static int star_oh(const char *z){ + return + isConsonant(z) && + z[0]!='w' && z[0]!='x' && z[0]!='y' && + isVowel(z+1) && + isConsonant(z+2); +} + +/* +** If the word ends with zFrom and xCond() is true for the stem +** of the word that preceeds the zFrom ending, then change the +** ending to zTo. +** +** The input word *pz and zFrom are both in reverse order. zTo +** is in normal order. +** +** Return TRUE if zFrom matches. Return FALSE if zFrom does not +** match. Not that TRUE is returned even if xCond() fails and +** no substitution occurs. +*/ +static int stem( + char **pz, /* The word being stemmed (Reversed) */ + const char *zFrom, /* If the ending matches this... (Reversed) */ + const char *zTo, /* ... change the ending to this (not reversed) */ + int (*xCond)(const char*) /* Condition that must be true */ +){ + char *z = *pz; + while( *zFrom && *zFrom==*z ){ z++; zFrom++; } + if( *zFrom!=0 ) return 0; + if( xCond && !xCond(z) ) return 1; + while( *zTo ){ + *(--z) = *(zTo++); + } + *pz = z; + return 1; +} + +/* +** This is the fallback stemmer used when the porter stemmer is +** inappropriate. The input word is copied into the output with +** US-ASCII case folding. If the input word is too long (more +** than 20 bytes if it contains no digits or more than 6 bytes if +** it contains digits) then word is truncated to 20 or 6 bytes +** by taking 10 or 3 bytes from the beginning and end. +*/ +static void copy_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){ + int i, mx, j; + int hasDigit = 0; + for(i=0; i='A' && c<='Z' ){ + zOut[i] = c - 'A' + 'a'; + }else{ + if( c>='0' && c<='9' ) hasDigit = 1; + zOut[i] = c; + } + } + mx = hasDigit ? 3 : 10; + if( nIn>mx*2 ){ + for(j=mx, i=nIn-mx; i=(int)sizeof(zReverse)-7 ){ + /* The word is too big or too small for the porter stemmer. + ** Fallback to the copy stemmer */ + copy_stemmer(zIn, nIn, zOut, pnOut); + return; + } + for(i=0, j=sizeof(zReverse)-6; i='A' && c<='Z' ){ + zReverse[j] = c + 'a' - 'A'; + }else if( c>='a' && c<='z' ){ + zReverse[j] = c; + }else{ + /* The use of a character not in [a-zA-Z] means that we fallback + ** to the copy stemmer */ + copy_stemmer(zIn, nIn, zOut, pnOut); + return; + } + } + memset(&zReverse[sizeof(zReverse)-5], 0, 5); + z = &zReverse[j+1]; + + + /* Step 1a */ + if( z[0]=='s' ){ + if( + !stem(&z, "sess", "ss", 0) && + !stem(&z, "sei", "i", 0) && + !stem(&z, "ss", "ss", 0) + ){ + z++; + } + } + + /* Step 1b */ + z2 = z; + if( stem(&z, "dee", "ee", m_gt_0) ){ + /* Do nothing. The work was all in the test */ + }else if( + (stem(&z, "gni", "", hasVowel) || stem(&z, "de", "", hasVowel)) + && z!=z2 + ){ + if( stem(&z, "ta", "ate", 0) || + stem(&z, "lb", "ble", 0) || + stem(&z, "zi", "ize", 0) ){ + /* Do nothing. The work was all in the test */ + }else if( doubleConsonant(z) && (*z!='l' && *z!='s' && *z!='z') ){ + z++; + }else if( m_eq_1(z) && star_oh(z) ){ + *(--z) = 'e'; + } + } + + /* Step 1c */ + if( z[0]=='y' && hasVowel(z+1) ){ + z[0] = 'i'; + } + + /* Step 2 */ + switch( z[1] ){ + case 'a': + if( !stem(&z, "lanoita", "ate", m_gt_0) ){ + stem(&z, "lanoit", "tion", m_gt_0); + } + break; + case 'c': + if( !stem(&z, "icne", "ence", m_gt_0) ){ + stem(&z, "icna", "ance", m_gt_0); + } + break; + case 'e': + stem(&z, "rezi", "ize", m_gt_0); + break; + case 'g': + stem(&z, "igol", "log", m_gt_0); + break; + case 'l': + if( !stem(&z, "ilb", "ble", m_gt_0) + && !stem(&z, "illa", "al", m_gt_0) + && !stem(&z, "iltne", "ent", m_gt_0) + && !stem(&z, "ile", "e", m_gt_0) + ){ + stem(&z, "ilsuo", "ous", m_gt_0); + } + break; + case 'o': + if( !stem(&z, "noitazi", "ize", m_gt_0) + && !stem(&z, "noita", "ate", m_gt_0) + ){ + stem(&z, "rota", "ate", m_gt_0); + } + break; + case 's': + if( !stem(&z, "msila", "al", m_gt_0) + && !stem(&z, "ssenevi", "ive", m_gt_0) + && !stem(&z, "ssenluf", "ful", m_gt_0) + ){ + stem(&z, "ssensuo", "ous", m_gt_0); + } + break; + case 't': + if( !stem(&z, "itila", "al", m_gt_0) + && !stem(&z, "itivi", "ive", m_gt_0) + ){ + stem(&z, "itilib", "ble", m_gt_0); + } + break; + } + + /* Step 3 */ + switch( z[0] ){ + case 'e': + if( !stem(&z, "etaci", "ic", m_gt_0) + && !stem(&z, "evita", "", m_gt_0) + ){ + stem(&z, "ezila", "al", m_gt_0); + } + break; + case 'i': + stem(&z, "itici", "ic", m_gt_0); + break; + case 'l': + if( !stem(&z, "laci", "ic", m_gt_0) ){ + stem(&z, "luf", "", m_gt_0); + } + break; + case 's': + stem(&z, "ssen", "", m_gt_0); + break; + } + + /* Step 4 */ + switch( z[1] ){ + case 'a': + if( z[0]=='l' && m_gt_1(z+2) ){ + z += 2; + } + break; + case 'c': + if( z[0]=='e' && z[2]=='n' && (z[3]=='a' || z[3]=='e') && m_gt_1(z+4) ){ + z += 4; + } + break; + case 'e': + if( z[0]=='r' && m_gt_1(z+2) ){ + z += 2; + } + break; + case 'i': + if( z[0]=='c' && m_gt_1(z+2) ){ + z += 2; + } + break; + case 'l': + if( z[0]=='e' && z[2]=='b' && (z[3]=='a' || z[3]=='i') && m_gt_1(z+4) ){ + z += 4; + } + break; + case 'n': + if( z[0]=='t' ){ + if( z[2]=='a' ){ + if( m_gt_1(z+3) ){ + z += 3; + } + }else if( z[2]=='e' ){ + if( !stem(&z, "tneme", "", m_gt_1) + && !stem(&z, "tnem", "", m_gt_1) + ){ + stem(&z, "tne", "", m_gt_1); + } + } + } + break; + case 'o': + if( z[0]=='u' ){ + if( m_gt_1(z+2) ){ + z += 2; + } + }else if( z[3]=='s' || z[3]=='t' ){ + stem(&z, "noi", "", m_gt_1); + } + break; + case 's': + if( z[0]=='m' && z[2]=='i' && m_gt_1(z+3) ){ + z += 3; + } + break; + case 't': + if( !stem(&z, "eta", "", m_gt_1) ){ + stem(&z, "iti", "", m_gt_1); + } + break; + case 'u': + if( z[0]=='s' && z[2]=='o' && m_gt_1(z+3) ){ + z += 3; + } + break; + case 'v': + case 'z': + if( z[0]=='e' && z[2]=='i' && m_gt_1(z+3) ){ + z += 3; + } + break; + } + + /* Step 5a */ + if( z[0]=='e' ){ + if( m_gt_1(z+1) ){ + z++; + }else if( m_eq_1(z+1) && !star_oh(z+1) ){ + z++; + } + } + + /* Step 5b */ + if( m_gt_1(z) && z[0]=='l' && z[1]=='l' ){ + z++; + } + + /* z[] is now the stemmed word in reverse order. Flip it back + ** around into forward order and return. + */ + *pnOut = i = (int)strlen(z); + zOut[i] = 0; + while( *z ){ + zOut[--i] = *(z++); + } +} + +/* +** Characters that can be part of a token. We assume any character +** whose value is greater than 0x80 (any UTF character) can be +** part of a token. In other words, delimiters all must have +** values of 0x7f or lower. +*/ +static const char porterIdChar[] = { +/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 3x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 4x */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, /* 5x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 6x */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 7x */ +}; +#define isDelim(C) (((ch=C)&0x80)==0 && (ch<0x30 || !porterIdChar[ch-0x30])) + +/* +** Extract the next token from a tokenization cursor. The cursor must +** have been opened by a prior call to porterOpen(). +*/ +static int porterNext( + sqlite3_tokenizer_cursor *pCursor, /* Cursor returned by porterOpen */ + const char **pzToken, /* OUT: *pzToken is the token text */ + int *pnBytes, /* OUT: Number of bytes in token */ + int *piStartOffset, /* OUT: Starting offset of token */ + int *piEndOffset, /* OUT: Ending offset of token */ + int *piPosition /* OUT: Position integer of token */ +){ + porter_tokenizer_cursor *c = (porter_tokenizer_cursor *) pCursor; + const char *z = c->zInput; + + while( c->iOffsetnInput ){ + int iStartOffset, ch; + + /* Scan past delimiter characters */ + while( c->iOffsetnInput && isDelim(z[c->iOffset]) ){ + c->iOffset++; + } + + /* Count non-delimiter characters. */ + iStartOffset = c->iOffset; + while( c->iOffsetnInput && !isDelim(z[c->iOffset]) ){ + c->iOffset++; + } + + if( c->iOffset>iStartOffset ){ + int n = c->iOffset-iStartOffset; + if( n>c->nAllocated ){ + char *pNew; + c->nAllocated = n+20; + pNew = sqlite3_realloc64(c->zToken, c->nAllocated); + if( !pNew ) return SQLITE_NOMEM; + c->zToken = pNew; + } + porter_stemmer(&z[iStartOffset], n, c->zToken, pnBytes); + *pzToken = c->zToken; + *piStartOffset = iStartOffset; + *piEndOffset = c->iOffset; + *piPosition = c->iToken++; + return SQLITE_OK; + } + } + return SQLITE_DONE; +} + +/* +** The set of routines that implement the porter-stemmer tokenizer +*/ +static const sqlite3_tokenizer_module porterTokenizerModule = { + 0, + porterCreate, + porterDestroy, + porterOpen, + porterClose, + porterNext, + 0 +}; + +/* +** Allocate a new porter tokenizer. Return a pointer to the new +** tokenizer in *ppModule +*/ +SQLITE_PRIVATE void sqlite3Fts3PorterTokenizerModule( + sqlite3_tokenizer_module const**ppModule +){ + *ppModule = &porterTokenizerModule; +} + +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_porter.c *****************************************/ +/************** Begin file fts3_tokenizer.c **********************************/ +/* +** 2007 June 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This is part of an SQLite module implementing full-text search. +** This particular file implements the generic tokenizer interface. +*/ + +/* +** The code in this file is only compiled if: +** +** * The FTS3 module is being built as an extension +** (in which case SQLITE_CORE is not defined), or +** +** * The FTS3 module is being built into the core of +** SQLite (in which case SQLITE_ENABLE_FTS3 is defined). +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ + +/* +** Return true if the two-argument version of fts3_tokenizer() +** has been activated via a prior call to sqlite3_db_config(db, +** SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, 1, 0); +*/ +static int fts3TokenizerEnabled(sqlite3_context *context){ + sqlite3 *db = sqlite3_context_db_handle(context); + int isEnabled = 0; + sqlite3_db_config(db,SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER,-1,&isEnabled); + return isEnabled; +} + +/* +** Implementation of the SQL scalar function for accessing the underlying +** hash table. This function may be called as follows: +** +** SELECT (); +** SELECT (, ); +** +** where is the name passed as the second argument +** to the sqlite3Fts3InitHashTable() function (e.g. 'fts3_tokenizer'). +** +** If the argument is specified, it must be a blob value +** containing a pointer to be stored as the hash data corresponding +** to the string . If is not specified, then +** the string must already exist in the has table. Otherwise, +** an error is returned. +** +** Whether or not the argument is specified, the value returned +** is a blob containing the pointer stored as the hash data corresponding +** to string (after the hash-table is updated, if applicable). +*/ +static void fts3TokenizerFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + Fts3Hash *pHash; + void *pPtr = 0; + const unsigned char *zName; + int nName; + + assert( argc==1 || argc==2 ); + + pHash = (Fts3Hash *)sqlite3_user_data(context); + + zName = sqlite3_value_text(argv[0]); + nName = sqlite3_value_bytes(argv[0])+1; + + if( argc==2 ){ + if( fts3TokenizerEnabled(context) || sqlite3_value_frombind(argv[1]) ){ + void *pOld; + int n = sqlite3_value_bytes(argv[1]); + if( zName==0 || n!=sizeof(pPtr) ){ + sqlite3_result_error(context, "argument type mismatch", -1); + return; + } + pPtr = *(void **)sqlite3_value_blob(argv[1]); + pOld = sqlite3Fts3HashInsert(pHash, (void *)zName, nName, pPtr); + if( pOld==pPtr ){ + sqlite3_result_error(context, "out of memory", -1); + } + }else{ + sqlite3_result_error(context, "fts3tokenize disabled", -1); + return; + } + }else{ + if( zName ){ + pPtr = sqlite3Fts3HashFind(pHash, zName, nName); + } + if( !pPtr ){ + char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName); + sqlite3_result_error(context, zErr, -1); + sqlite3_free(zErr); + return; + } + } + if( fts3TokenizerEnabled(context) || sqlite3_value_frombind(argv[0]) ){ + sqlite3_result_blob(context, (void *)&pPtr, sizeof(pPtr), SQLITE_TRANSIENT); + } +} + +SQLITE_PRIVATE int sqlite3Fts3IsIdChar(char c){ + static const char isFtsIdChar[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 1x */ + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 2x */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 3x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 4x */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, /* 5x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 6x */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 7x */ + }; + return (c&0x80 || isFtsIdChar[(int)(c)]); +} + +SQLITE_PRIVATE const char *sqlite3Fts3NextToken(const char *zStr, int *pn){ + const char *z1; + const char *z2 = 0; + + /* Find the start of the next token. */ + z1 = zStr; + while( z2==0 ){ + char c = *z1; + switch( c ){ + case '\0': return 0; /* No more tokens here */ + case '\'': + case '"': + case '`': { + z2 = z1; + while( *++z2 && (*z2!=c || *++z2==c) ); + break; + } + case '[': + z2 = &z1[1]; + while( *z2 && z2[0]!=']' ) z2++; + if( *z2 ) z2++; + break; + + default: + if( sqlite3Fts3IsIdChar(*z1) ){ + z2 = &z1[1]; + while( sqlite3Fts3IsIdChar(*z2) ) z2++; + }else{ + z1++; + } + } + } + + *pn = (int)(z2-z1); + return z1; +} + +SQLITE_PRIVATE int sqlite3Fts3InitTokenizer( + Fts3Hash *pHash, /* Tokenizer hash table */ + const char *zArg, /* Tokenizer name */ + sqlite3_tokenizer **ppTok, /* OUT: Tokenizer (if applicable) */ + char **pzErr /* OUT: Set to malloced error message */ +){ + int rc; + char *z = (char *)zArg; + int n = 0; + char *zCopy; + char *zEnd; /* Pointer to nul-term of zCopy */ + sqlite3_tokenizer_module *m; + + zCopy = sqlite3_mprintf("%s", zArg); + if( !zCopy ) return SQLITE_NOMEM; + zEnd = &zCopy[strlen(zCopy)]; + + z = (char *)sqlite3Fts3NextToken(zCopy, &n); + if( z==0 ){ + assert( n==0 ); + z = zCopy; + } + z[n] = '\0'; + sqlite3Fts3Dequote(z); + + m = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash,z,(int)strlen(z)+1); + if( !m ){ + sqlite3Fts3ErrMsg(pzErr, "unknown tokenizer: %s", z); + rc = SQLITE_ERROR; + }else{ + char const **aArg = 0; + int iArg = 0; + z = &z[n+1]; + while( zxCreate(iArg, aArg, ppTok); + assert( rc!=SQLITE_OK || *ppTok ); + if( rc!=SQLITE_OK ){ + sqlite3Fts3ErrMsg(pzErr, "unknown tokenizer"); + }else{ + (*ppTok)->pModule = m; + } + sqlite3_free((void *)aArg); + } + + sqlite3_free(zCopy); + return rc; +} + + +#ifdef SQLITE_TEST + +#if defined(INCLUDE_SQLITE_TCL_H) +# include "sqlite_tcl.h" +#else +# include "tcl.h" +#endif +/* #include */ + +/* +** Implementation of a special SQL scalar function for testing tokenizers +** designed to be used in concert with the Tcl testing framework. This +** function must be called with two or more arguments: +** +** SELECT (, ..., ); +** +** where is the name passed as the second argument +** to the sqlite3Fts3InitHashTable() function (e.g. 'fts3_tokenizer') +** concatenated with the string '_test' (e.g. 'fts3_tokenizer_test'). +** +** The return value is a string that may be interpreted as a Tcl +** list. For each token in the , three elements are +** added to the returned list. The first is the token position, the +** second is the token text (folded, stemmed, etc.) and the third is the +** substring of associated with the token. For example, +** using the built-in "simple" tokenizer: +** +** SELECT fts_tokenizer_test('simple', 'I don't see how'); +** +** will return the string: +** +** "{0 i I 1 dont don't 2 see see 3 how how}" +** +*/ +static void testFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + Fts3Hash *pHash; + sqlite3_tokenizer_module *p; + sqlite3_tokenizer *pTokenizer = 0; + sqlite3_tokenizer_cursor *pCsr = 0; + + const char *zErr = 0; + + const char *zName; + int nName; + const char *zInput; + int nInput; + + const char *azArg[64]; + + const char *zToken; + int nToken = 0; + int iStart = 0; + int iEnd = 0; + int iPos = 0; + int i; + + Tcl_Obj *pRet; + + if( argc<2 ){ + sqlite3_result_error(context, "insufficient arguments", -1); + return; + } + + nName = sqlite3_value_bytes(argv[0]); + zName = (const char *)sqlite3_value_text(argv[0]); + nInput = sqlite3_value_bytes(argv[argc-1]); + zInput = (const char *)sqlite3_value_text(argv[argc-1]); + + pHash = (Fts3Hash *)sqlite3_user_data(context); + p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1); + + if( !p ){ + char *zErr2 = sqlite3_mprintf("unknown tokenizer: %s", zName); + sqlite3_result_error(context, zErr2, -1); + sqlite3_free(zErr2); + return; + } + + pRet = Tcl_NewObj(); + Tcl_IncrRefCount(pRet); + + for(i=1; ixCreate(argc-2, azArg, &pTokenizer) ){ + zErr = "error in xCreate()"; + goto finish; + } + pTokenizer->pModule = p; + if( sqlite3Fts3OpenTokenizer(pTokenizer, 0, zInput, nInput, &pCsr) ){ + zErr = "error in xOpen()"; + goto finish; + } + + while( SQLITE_OK==p->xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos) ){ + Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(iPos)); + Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zToken, nToken)); + zToken = &zInput[iStart]; + nToken = iEnd-iStart; + Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zToken, nToken)); + } + + if( SQLITE_OK!=p->xClose(pCsr) ){ + zErr = "error in xClose()"; + goto finish; + } + if( SQLITE_OK!=p->xDestroy(pTokenizer) ){ + zErr = "error in xDestroy()"; + goto finish; + } + +finish: + if( zErr ){ + sqlite3_result_error(context, zErr, -1); + }else{ + sqlite3_result_text(context, Tcl_GetString(pRet), -1, SQLITE_TRANSIENT); + } + Tcl_DecrRefCount(pRet); +} + +static +int registerTokenizer( + sqlite3 *db, + char *zName, + const sqlite3_tokenizer_module *p +){ + int rc; + sqlite3_stmt *pStmt; + const char zSql[] = "SELECT fts3_tokenizer(?, ?)"; + + rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + + sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC); + sqlite3_bind_blob(pStmt, 2, &p, sizeof(p), SQLITE_STATIC); + sqlite3_step(pStmt); + + return sqlite3_finalize(pStmt); +} + + +static +int queryTokenizer( + sqlite3 *db, + char *zName, + const sqlite3_tokenizer_module **pp +){ + int rc; + sqlite3_stmt *pStmt; + const char zSql[] = "SELECT fts3_tokenizer(?)"; + + *pp = 0; + rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + + sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC); + if( SQLITE_ROW==sqlite3_step(pStmt) ){ + if( sqlite3_column_type(pStmt, 0)==SQLITE_BLOB + && sqlite3_column_bytes(pStmt, 0)==sizeof(*pp) + ){ + memcpy((void *)pp, sqlite3_column_blob(pStmt, 0), sizeof(*pp)); + } + } + + return sqlite3_finalize(pStmt); +} + +SQLITE_PRIVATE void sqlite3Fts3SimpleTokenizerModule(sqlite3_tokenizer_module const**ppModule); + +/* +** Implementation of the scalar function fts3_tokenizer_internal_test(). +** This function is used for testing only, it is not included in the +** build unless SQLITE_TEST is defined. +** +** The purpose of this is to test that the fts3_tokenizer() function +** can be used as designed by the C-code in the queryTokenizer and +** registerTokenizer() functions above. These two functions are repeated +** in the README.tokenizer file as an example, so it is important to +** test them. +** +** To run the tests, evaluate the fts3_tokenizer_internal_test() scalar +** function with no arguments. An assert() will fail if a problem is +** detected. i.e.: +** +** SELECT fts3_tokenizer_internal_test(); +** +*/ +static void intTestFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int rc; + const sqlite3_tokenizer_module *p1; + const sqlite3_tokenizer_module *p2; + sqlite3 *db = (sqlite3 *)sqlite3_user_data(context); + + UNUSED_PARAMETER(argc); + UNUSED_PARAMETER(argv); + + /* Test the query function */ + sqlite3Fts3SimpleTokenizerModule(&p1); + rc = queryTokenizer(db, "simple", &p2); + assert( rc==SQLITE_OK ); + assert( p1==p2 ); + rc = queryTokenizer(db, "nosuchtokenizer", &p2); + assert( rc==SQLITE_ERROR ); + assert( p2==0 ); + assert( 0==strcmp(sqlite3_errmsg(db), "unknown tokenizer: nosuchtokenizer") ); + + /* Test the storage function */ + if( fts3TokenizerEnabled(context) ){ + rc = registerTokenizer(db, "nosuchtokenizer", p1); + assert( rc==SQLITE_OK ); + rc = queryTokenizer(db, "nosuchtokenizer", &p2); + assert( rc==SQLITE_OK ); + assert( p2==p1 ); + } + + sqlite3_result_text(context, "ok", -1, SQLITE_STATIC); +} + +#endif + +/* +** Set up SQL objects in database db used to access the contents of +** the hash table pointed to by argument pHash. The hash table must +** been initialized to use string keys, and to take a private copy +** of the key when a value is inserted. i.e. by a call similar to: +** +** sqlite3Fts3HashInit(pHash, FTS3_HASH_STRING, 1); +** +** This function adds a scalar function (see header comment above +** fts3TokenizerFunc() in this file for details) and, if ENABLE_TABLE is +** defined at compilation time, a temporary virtual table (see header +** comment above struct HashTableVtab) to the database schema. Both +** provide read/write access to the contents of *pHash. +** +** The third argument to this function, zName, is used as the name +** of both the scalar and, if created, the virtual table. +*/ +SQLITE_PRIVATE int sqlite3Fts3InitHashTable( + sqlite3 *db, + Fts3Hash *pHash, + const char *zName +){ + int rc = SQLITE_OK; + void *p = (void *)pHash; + const int any = SQLITE_UTF8|SQLITE_DIRECTONLY; + +#ifdef SQLITE_TEST + char *zTest = 0; + char *zTest2 = 0; + void *pdb = (void *)db; + zTest = sqlite3_mprintf("%s_test", zName); + zTest2 = sqlite3_mprintf("%s_internal_test", zName); + if( !zTest || !zTest2 ){ + rc = SQLITE_NOMEM; + } +#endif + + if( SQLITE_OK==rc ){ + rc = sqlite3_create_function(db, zName, 1, any, p, fts3TokenizerFunc, 0, 0); + } + if( SQLITE_OK==rc ){ + rc = sqlite3_create_function(db, zName, 2, any, p, fts3TokenizerFunc, 0, 0); + } +#ifdef SQLITE_TEST + if( SQLITE_OK==rc ){ + rc = sqlite3_create_function(db, zTest, -1, any, p, testFunc, 0, 0); + } + if( SQLITE_OK==rc ){ + rc = sqlite3_create_function(db, zTest2, 0, any, pdb, intTestFunc, 0, 0); + } +#endif + +#ifdef SQLITE_TEST + sqlite3_free(zTest); + sqlite3_free(zTest2); +#endif + + return rc; +} + +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_tokenizer.c **************************************/ +/************** Begin file fts3_tokenizer1.c *********************************/ +/* +** 2006 Oct 10 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** Implementation of the "simple" full-text-search tokenizer. +*/ + +/* +** The code in this file is only compiled if: +** +** * The FTS3 module is being built as an extension +** (in which case SQLITE_CORE is not defined), or +** +** * The FTS3 module is being built into the core of +** SQLite (in which case SQLITE_ENABLE_FTS3 is defined). +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ +/* #include */ +/* #include */ + +/* #include "fts3_tokenizer.h" */ + +typedef struct simple_tokenizer { + sqlite3_tokenizer base; + char delim[128]; /* flag ASCII delimiters */ +} simple_tokenizer; + +typedef struct simple_tokenizer_cursor { + sqlite3_tokenizer_cursor base; + const char *pInput; /* input we are tokenizing */ + int nBytes; /* size of the input */ + int iOffset; /* current position in pInput */ + int iToken; /* index of next token to be returned */ + char *pToken; /* storage for current token */ + int nTokenAllocated; /* space allocated to zToken buffer */ +} simple_tokenizer_cursor; + + +static int simpleDelim(simple_tokenizer *t, unsigned char c){ + return c<0x80 && t->delim[c]; +} +static int fts3_isalnum(int x){ + return (x>='0' && x<='9') || (x>='A' && x<='Z') || (x>='a' && x<='z'); +} + +/* +** Create a new tokenizer instance. +*/ +static int simpleCreate( + int argc, const char * const *argv, + sqlite3_tokenizer **ppTokenizer +){ + simple_tokenizer *t; + + t = (simple_tokenizer *) sqlite3_malloc(sizeof(*t)); + if( t==NULL ) return SQLITE_NOMEM; + memset(t, 0, sizeof(*t)); + + /* TODO(shess) Delimiters need to remain the same from run to run, + ** else we need to reindex. One solution would be a meta-table to + ** track such information in the database, then we'd only want this + ** information on the initial create. + */ + if( argc>1 ){ + int i, n = (int)strlen(argv[1]); + for(i=0; i=0x80 ){ + sqlite3_free(t); + return SQLITE_ERROR; + } + t->delim[ch] = 1; + } + } else { + /* Mark non-alphanumeric ASCII characters as delimiters */ + int i; + for(i=1; i<0x80; i++){ + t->delim[i] = !fts3_isalnum(i) ? -1 : 0; + } + } + + *ppTokenizer = &t->base; + return SQLITE_OK; +} + +/* +** Destroy a tokenizer +*/ +static int simpleDestroy(sqlite3_tokenizer *pTokenizer){ + sqlite3_free(pTokenizer); + return SQLITE_OK; +} + +/* +** Prepare to begin tokenizing a particular string. The input +** string to be tokenized is pInput[0..nBytes-1]. A cursor +** used to incrementally tokenize this string is returned in +** *ppCursor. +*/ +static int simpleOpen( + sqlite3_tokenizer *pTokenizer, /* The tokenizer */ + const char *pInput, int nBytes, /* String to be tokenized */ + sqlite3_tokenizer_cursor **ppCursor /* OUT: Tokenization cursor */ +){ + simple_tokenizer_cursor *c; + + UNUSED_PARAMETER(pTokenizer); + + c = (simple_tokenizer_cursor *) sqlite3_malloc(sizeof(*c)); + if( c==NULL ) return SQLITE_NOMEM; + + c->pInput = pInput; + if( pInput==0 ){ + c->nBytes = 0; + }else if( nBytes<0 ){ + c->nBytes = (int)strlen(pInput); + }else{ + c->nBytes = nBytes; + } + c->iOffset = 0; /* start tokenizing at the beginning */ + c->iToken = 0; + c->pToken = NULL; /* no space allocated, yet. */ + c->nTokenAllocated = 0; + + *ppCursor = &c->base; + return SQLITE_OK; +} + +/* +** Close a tokenization cursor previously opened by a call to +** simpleOpen() above. +*/ +static int simpleClose(sqlite3_tokenizer_cursor *pCursor){ + simple_tokenizer_cursor *c = (simple_tokenizer_cursor *) pCursor; + sqlite3_free(c->pToken); + sqlite3_free(c); + return SQLITE_OK; +} + +/* +** Extract the next token from a tokenization cursor. The cursor must +** have been opened by a prior call to simpleOpen(). +*/ +static int simpleNext( + sqlite3_tokenizer_cursor *pCursor, /* Cursor returned by simpleOpen */ + const char **ppToken, /* OUT: *ppToken is the token text */ + int *pnBytes, /* OUT: Number of bytes in token */ + int *piStartOffset, /* OUT: Starting offset of token */ + int *piEndOffset, /* OUT: Ending offset of token */ + int *piPosition /* OUT: Position integer of token */ +){ + simple_tokenizer_cursor *c = (simple_tokenizer_cursor *) pCursor; + simple_tokenizer *t = (simple_tokenizer *) pCursor->pTokenizer; + unsigned char *p = (unsigned char *)c->pInput; + + while( c->iOffsetnBytes ){ + int iStartOffset; + + /* Scan past delimiter characters */ + while( c->iOffsetnBytes && simpleDelim(t, p[c->iOffset]) ){ + c->iOffset++; + } + + /* Count non-delimiter characters. */ + iStartOffset = c->iOffset; + while( c->iOffsetnBytes && !simpleDelim(t, p[c->iOffset]) ){ + c->iOffset++; + } + + if( c->iOffset>iStartOffset ){ + int i, n = c->iOffset-iStartOffset; + if( n>c->nTokenAllocated ){ + char *pNew; + c->nTokenAllocated = n+20; + pNew = sqlite3_realloc64(c->pToken, c->nTokenAllocated); + if( !pNew ) return SQLITE_NOMEM; + c->pToken = pNew; + } + for(i=0; ipToken[i] = (char)((ch>='A' && ch<='Z') ? ch-'A'+'a' : ch); + } + *ppToken = c->pToken; + *pnBytes = n; + *piStartOffset = iStartOffset; + *piEndOffset = c->iOffset; + *piPosition = c->iToken++; + + return SQLITE_OK; + } + } + return SQLITE_DONE; +} + +/* +** The set of routines that implement the simple tokenizer +*/ +static const sqlite3_tokenizer_module simpleTokenizerModule = { + 0, + simpleCreate, + simpleDestroy, + simpleOpen, + simpleClose, + simpleNext, + 0, +}; + +/* +** Allocate a new simple tokenizer. Return a pointer to the new +** tokenizer in *ppModule +*/ +SQLITE_PRIVATE void sqlite3Fts3SimpleTokenizerModule( + sqlite3_tokenizer_module const**ppModule +){ + *ppModule = &simpleTokenizerModule; +} + +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_tokenizer1.c *************************************/ +/************** Begin file fts3_tokenize_vtab.c ******************************/ +/* +** 2013 Apr 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains code for the "fts3tokenize" virtual table module. +** An fts3tokenize virtual table is created as follows: +** +** CREATE VIRTUAL TABLE USING fts3tokenize( +** , , ... +** ); +** +** The table created has the following schema: +** +** CREATE TABLE (input, token, start, end, position) +** +** When queried, the query must include a WHERE clause of type: +** +** input = +** +** The virtual table module tokenizes this , using the FTS3 +** tokenizer specified by the arguments to the CREATE VIRTUAL TABLE +** statement and returns one row for each token in the result. With +** fields set as follows: +** +** input: Always set to a copy of +** token: A token from the input. +** start: Byte offset of the token within the input . +** end: Byte offset of the byte immediately following the end of the +** token within the input string. +** pos: Token offset of token within input. +** +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ + +typedef struct Fts3tokTable Fts3tokTable; +typedef struct Fts3tokCursor Fts3tokCursor; + +/* +** Virtual table structure. +*/ +struct Fts3tokTable { + sqlite3_vtab base; /* Base class used by SQLite core */ + const sqlite3_tokenizer_module *pMod; + sqlite3_tokenizer *pTok; +}; + +/* +** Virtual table cursor structure. +*/ +struct Fts3tokCursor { + sqlite3_vtab_cursor base; /* Base class used by SQLite core */ + char *zInput; /* Input string */ + sqlite3_tokenizer_cursor *pCsr; /* Cursor to iterate through zInput */ + int iRowid; /* Current 'rowid' value */ + const char *zToken; /* Current 'token' value */ + int nToken; /* Size of zToken in bytes */ + int iStart; /* Current 'start' value */ + int iEnd; /* Current 'end' value */ + int iPos; /* Current 'pos' value */ +}; + +/* +** Query FTS for the tokenizer implementation named zName. +*/ +static int fts3tokQueryTokenizer( + Fts3Hash *pHash, + const char *zName, + const sqlite3_tokenizer_module **pp, + char **pzErr +){ + sqlite3_tokenizer_module *p; + int nName = (int)strlen(zName); + + p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1); + if( !p ){ + sqlite3Fts3ErrMsg(pzErr, "unknown tokenizer: %s", zName); + return SQLITE_ERROR; + } + + *pp = p; + return SQLITE_OK; +} + +/* +** The second argument, argv[], is an array of pointers to nul-terminated +** strings. This function makes a copy of the array and strings into a +** single block of memory. It then dequotes any of the strings that appear +** to be quoted. +** +** If successful, output parameter *pazDequote is set to point at the +** array of dequoted strings and SQLITE_OK is returned. The caller is +** responsible for eventually calling sqlite3_free() to free the array +** in this case. Or, if an error occurs, an SQLite error code is returned. +** The final value of *pazDequote is undefined in this case. +*/ +static int fts3tokDequoteArray( + int argc, /* Number of elements in argv[] */ + const char * const *argv, /* Input array */ + char ***pazDequote /* Output array */ +){ + int rc = SQLITE_OK; /* Return code */ + if( argc==0 ){ + *pazDequote = 0; + }else{ + int i; + int nByte = 0; + char **azDequote; + + for(i=0; i1 ) azArg = (const char * const *)&azDequote[1]; + rc = pMod->xCreate((nDequote>1 ? nDequote-1 : 0), azArg, &pTok); + } + + if( rc==SQLITE_OK ){ + pTab = (Fts3tokTable *)sqlite3_malloc(sizeof(Fts3tokTable)); + if( pTab==0 ){ + rc = SQLITE_NOMEM; + } + } + + if( rc==SQLITE_OK ){ + memset(pTab, 0, sizeof(Fts3tokTable)); + pTab->pMod = pMod; + pTab->pTok = pTok; + *ppVtab = &pTab->base; + }else{ + if( pTok ){ + pMod->xDestroy(pTok); + } + } + + sqlite3_free(azDequote); + return rc; +} + +/* +** This function does the work for both the xDisconnect and xDestroy methods. +** These tables have no persistent representation of their own, so xDisconnect +** and xDestroy are identical operations. +*/ +static int fts3tokDisconnectMethod(sqlite3_vtab *pVtab){ + Fts3tokTable *pTab = (Fts3tokTable *)pVtab; + + pTab->pMod->xDestroy(pTab->pTok); + sqlite3_free(pTab); + return SQLITE_OK; +} + +/* +** xBestIndex - Analyze a WHERE and ORDER BY clause. +*/ +static int fts3tokBestIndexMethod( + sqlite3_vtab *pVTab, + sqlite3_index_info *pInfo +){ + int i; + UNUSED_PARAMETER(pVTab); + + for(i=0; inConstraint; i++){ + if( pInfo->aConstraint[i].usable + && pInfo->aConstraint[i].iColumn==0 + && pInfo->aConstraint[i].op==SQLITE_INDEX_CONSTRAINT_EQ + ){ + pInfo->idxNum = 1; + pInfo->aConstraintUsage[i].argvIndex = 1; + pInfo->aConstraintUsage[i].omit = 1; + pInfo->estimatedCost = 1; + return SQLITE_OK; + } + } + + pInfo->idxNum = 0; + assert( pInfo->estimatedCost>1000000.0 ); + + return SQLITE_OK; +} + +/* +** xOpen - Open a cursor. +*/ +static int fts3tokOpenMethod(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCsr){ + Fts3tokCursor *pCsr; + UNUSED_PARAMETER(pVTab); + + pCsr = (Fts3tokCursor *)sqlite3_malloc(sizeof(Fts3tokCursor)); + if( pCsr==0 ){ + return SQLITE_NOMEM; + } + memset(pCsr, 0, sizeof(Fts3tokCursor)); + + *ppCsr = (sqlite3_vtab_cursor *)pCsr; + return SQLITE_OK; +} + +/* +** Reset the tokenizer cursor passed as the only argument. As if it had +** just been returned by fts3tokOpenMethod(). +*/ +static void fts3tokResetCursor(Fts3tokCursor *pCsr){ + if( pCsr->pCsr ){ + Fts3tokTable *pTab = (Fts3tokTable *)(pCsr->base.pVtab); + pTab->pMod->xClose(pCsr->pCsr); + pCsr->pCsr = 0; + } + sqlite3_free(pCsr->zInput); + pCsr->zInput = 0; + pCsr->zToken = 0; + pCsr->nToken = 0; + pCsr->iStart = 0; + pCsr->iEnd = 0; + pCsr->iPos = 0; + pCsr->iRowid = 0; +} + +/* +** xClose - Close a cursor. +*/ +static int fts3tokCloseMethod(sqlite3_vtab_cursor *pCursor){ + Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor; + + fts3tokResetCursor(pCsr); + sqlite3_free(pCsr); + return SQLITE_OK; +} + +/* +** xNext - Advance the cursor to the next row, if any. +*/ +static int fts3tokNextMethod(sqlite3_vtab_cursor *pCursor){ + Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor; + Fts3tokTable *pTab = (Fts3tokTable *)(pCursor->pVtab); + int rc; /* Return code */ + + pCsr->iRowid++; + rc = pTab->pMod->xNext(pCsr->pCsr, + &pCsr->zToken, &pCsr->nToken, + &pCsr->iStart, &pCsr->iEnd, &pCsr->iPos + ); + + if( rc!=SQLITE_OK ){ + fts3tokResetCursor(pCsr); + if( rc==SQLITE_DONE ) rc = SQLITE_OK; + } + + return rc; +} + +/* +** xFilter - Initialize a cursor to point at the start of its data. +*/ +static int fts3tokFilterMethod( + sqlite3_vtab_cursor *pCursor, /* The cursor used for this query */ + int idxNum, /* Strategy index */ + const char *idxStr, /* Unused */ + int nVal, /* Number of elements in apVal */ + sqlite3_value **apVal /* Arguments for the indexing scheme */ +){ + int rc = SQLITE_ERROR; + Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor; + Fts3tokTable *pTab = (Fts3tokTable *)(pCursor->pVtab); + UNUSED_PARAMETER(idxStr); + UNUSED_PARAMETER(nVal); + + fts3tokResetCursor(pCsr); + if( idxNum==1 ){ + const char *zByte = (const char *)sqlite3_value_text(apVal[0]); + int nByte = sqlite3_value_bytes(apVal[0]); + pCsr->zInput = sqlite3_malloc64(nByte+1); + if( pCsr->zInput==0 ){ + rc = SQLITE_NOMEM; + }else{ + if( nByte>0 ) memcpy(pCsr->zInput, zByte, nByte); + pCsr->zInput[nByte] = 0; + rc = pTab->pMod->xOpen(pTab->pTok, pCsr->zInput, nByte, &pCsr->pCsr); + if( rc==SQLITE_OK ){ + pCsr->pCsr->pTokenizer = pTab->pTok; + } + } + } + + if( rc!=SQLITE_OK ) return rc; + return fts3tokNextMethod(pCursor); +} + +/* +** xEof - Return true if the cursor is at EOF, or false otherwise. +*/ +static int fts3tokEofMethod(sqlite3_vtab_cursor *pCursor){ + Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor; + return (pCsr->zToken==0); +} + +/* +** xColumn - Return a column value. +*/ +static int fts3tokColumnMethod( + sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */ + sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */ + int iCol /* Index of column to read value from */ +){ + Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor; + + /* CREATE TABLE x(input, token, start, end, position) */ + switch( iCol ){ + case 0: + sqlite3_result_text(pCtx, pCsr->zInput, -1, SQLITE_TRANSIENT); + break; + case 1: + sqlite3_result_text(pCtx, pCsr->zToken, pCsr->nToken, SQLITE_TRANSIENT); + break; + case 2: + sqlite3_result_int(pCtx, pCsr->iStart); + break; + case 3: + sqlite3_result_int(pCtx, pCsr->iEnd); + break; + default: + assert( iCol==4 ); + sqlite3_result_int(pCtx, pCsr->iPos); + break; + } + return SQLITE_OK; +} + +/* +** xRowid - Return the current rowid for the cursor. +*/ +static int fts3tokRowidMethod( + sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */ + sqlite_int64 *pRowid /* OUT: Rowid value */ +){ + Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor; + *pRowid = (sqlite3_int64)pCsr->iRowid; + return SQLITE_OK; +} + +/* +** Register the fts3tok module with database connection db. Return SQLITE_OK +** if successful or an error code if sqlite3_create_module() fails. +*/ +SQLITE_PRIVATE int sqlite3Fts3InitTok(sqlite3 *db, Fts3Hash *pHash, void(*xDestroy)(void*)){ + static const sqlite3_module fts3tok_module = { + 0, /* iVersion */ + fts3tokConnectMethod, /* xCreate */ + fts3tokConnectMethod, /* xConnect */ + fts3tokBestIndexMethod, /* xBestIndex */ + fts3tokDisconnectMethod, /* xDisconnect */ + fts3tokDisconnectMethod, /* xDestroy */ + fts3tokOpenMethod, /* xOpen */ + fts3tokCloseMethod, /* xClose */ + fts3tokFilterMethod, /* xFilter */ + fts3tokNextMethod, /* xNext */ + fts3tokEofMethod, /* xEof */ + fts3tokColumnMethod, /* xColumn */ + fts3tokRowidMethod, /* xRowid */ + 0, /* xUpdate */ + 0, /* xBegin */ + 0, /* xSync */ + 0, /* xCommit */ + 0, /* xRollback */ + 0, /* xFindFunction */ + 0, /* xRename */ + 0, /* xSavepoint */ + 0, /* xRelease */ + 0, /* xRollbackTo */ + 0 /* xShadowName */ + }; + int rc; /* Return code */ + + rc = sqlite3_create_module_v2( + db, "fts3tokenize", &fts3tok_module, (void*)pHash, xDestroy + ); + return rc; +} + +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_tokenize_vtab.c **********************************/ +/************** Begin file fts3_write.c **************************************/ +/* +** 2009 Oct 23 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file is part of the SQLite FTS3 extension module. Specifically, +** this file contains code to insert, update and delete rows from FTS3 +** tables. It also contains code to merge FTS3 b-tree segments. Some +** of the sub-routines used to merge segments are also used by the query +** code in fts3.c. +*/ + +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ +/* #include */ +/* #include */ + +#define FTS_MAX_APPENDABLE_HEIGHT 16 + +/* +** When full-text index nodes are loaded from disk, the buffer that they +** are loaded into has the following number of bytes of padding at the end +** of it. i.e. if a full-text index node is 900 bytes in size, then a buffer +** of 920 bytes is allocated for it. +** +** This means that if we have a pointer into a buffer containing node data, +** it is always safe to read up to two varints from it without risking an +** overread, even if the node data is corrupted. +*/ +#define FTS3_NODE_PADDING (FTS3_VARINT_MAX*2) + +/* +** Under certain circumstances, b-tree nodes (doclists) can be loaded into +** memory incrementally instead of all at once. This can be a big performance +** win (reduced IO and CPU) if SQLite stops calling the virtual table xNext() +** method before retrieving all query results (as may happen, for example, +** if a query has a LIMIT clause). +** +** Incremental loading is used for b-tree nodes FTS3_NODE_CHUNK_THRESHOLD +** bytes and larger. Nodes are loaded in chunks of FTS3_NODE_CHUNKSIZE bytes. +** The code is written so that the hard lower-limit for each of these values +** is 1. Clearly such small values would be inefficient, but can be useful +** for testing purposes. +** +** If this module is built with SQLITE_TEST defined, these constants may +** be overridden at runtime for testing purposes. File fts3_test.c contains +** a Tcl interface to read and write the values. +*/ +#ifdef SQLITE_TEST +int test_fts3_node_chunksize = (4*1024); +int test_fts3_node_chunk_threshold = (4*1024)*4; +# define FTS3_NODE_CHUNKSIZE test_fts3_node_chunksize +# define FTS3_NODE_CHUNK_THRESHOLD test_fts3_node_chunk_threshold +#else +# define FTS3_NODE_CHUNKSIZE (4*1024) +# define FTS3_NODE_CHUNK_THRESHOLD (FTS3_NODE_CHUNKSIZE*4) +#endif + +/* +** The values that may be meaningfully bound to the :1 parameter in +** statements SQL_REPLACE_STAT and SQL_SELECT_STAT. +*/ +#define FTS_STAT_DOCTOTAL 0 +#define FTS_STAT_INCRMERGEHINT 1 +#define FTS_STAT_AUTOINCRMERGE 2 + +/* +** If FTS_LOG_MERGES is defined, call sqlite3_log() to report each automatic +** and incremental merge operation that takes place. This is used for +** debugging FTS only, it should not usually be turned on in production +** systems. +*/ +#ifdef FTS3_LOG_MERGES +static void fts3LogMerge(int nMerge, sqlite3_int64 iAbsLevel){ + sqlite3_log(SQLITE_OK, "%d-way merge from level %d", nMerge, (int)iAbsLevel); +} +#else +#define fts3LogMerge(x, y) +#endif + + +typedef struct PendingList PendingList; +typedef struct SegmentNode SegmentNode; +typedef struct SegmentWriter SegmentWriter; + +/* +** An instance of the following data structure is used to build doclists +** incrementally. See function fts3PendingListAppend() for details. +*/ +struct PendingList { + int nData; + char *aData; + int nSpace; + sqlite3_int64 iLastDocid; + sqlite3_int64 iLastCol; + sqlite3_int64 iLastPos; +}; + + +/* +** Each cursor has a (possibly empty) linked list of the following objects. +*/ +struct Fts3DeferredToken { + Fts3PhraseToken *pToken; /* Pointer to corresponding expr token */ + int iCol; /* Column token must occur in */ + Fts3DeferredToken *pNext; /* Next in list of deferred tokens */ + PendingList *pList; /* Doclist is assembled here */ +}; + +/* +** An instance of this structure is used to iterate through the terms on +** a contiguous set of segment b-tree leaf nodes. Although the details of +** this structure are only manipulated by code in this file, opaque handles +** of type Fts3SegReader* are also used by code in fts3.c to iterate through +** terms when querying the full-text index. See functions: +** +** sqlite3Fts3SegReaderNew() +** sqlite3Fts3SegReaderFree() +** sqlite3Fts3SegReaderIterate() +** +** Methods used to manipulate Fts3SegReader structures: +** +** fts3SegReaderNext() +** fts3SegReaderFirstDocid() +** fts3SegReaderNextDocid() +*/ +struct Fts3SegReader { + int iIdx; /* Index within level, or 0x7FFFFFFF for PT */ + u8 bLookup; /* True for a lookup only */ + u8 rootOnly; /* True for a root-only reader */ + + sqlite3_int64 iStartBlock; /* Rowid of first leaf block to traverse */ + sqlite3_int64 iLeafEndBlock; /* Rowid of final leaf block to traverse */ + sqlite3_int64 iEndBlock; /* Rowid of final block in segment (or 0) */ + sqlite3_int64 iCurrentBlock; /* Current leaf block (or 0) */ + + char *aNode; /* Pointer to node data (or NULL) */ + int nNode; /* Size of buffer at aNode (or 0) */ + int nPopulate; /* If >0, bytes of buffer aNode[] loaded */ + sqlite3_blob *pBlob; /* If not NULL, blob handle to read node */ + + Fts3HashElem **ppNextElem; + + /* Variables set by fts3SegReaderNext(). These may be read directly + ** by the caller. They are valid from the time SegmentReaderNew() returns + ** until SegmentReaderNext() returns something other than SQLITE_OK + ** (i.e. SQLITE_DONE). + */ + int nTerm; /* Number of bytes in current term */ + char *zTerm; /* Pointer to current term */ + int nTermAlloc; /* Allocated size of zTerm buffer */ + char *aDoclist; /* Pointer to doclist of current entry */ + int nDoclist; /* Size of doclist in current entry */ + + /* The following variables are used by fts3SegReaderNextDocid() to iterate + ** through the current doclist (aDoclist/nDoclist). + */ + char *pOffsetList; + int nOffsetList; /* For descending pending seg-readers only */ + sqlite3_int64 iDocid; +}; + +#define fts3SegReaderIsPending(p) ((p)->ppNextElem!=0) +#define fts3SegReaderIsRootOnly(p) ((p)->rootOnly!=0) + +/* +** An instance of this structure is used to create a segment b-tree in the +** database. The internal details of this type are only accessed by the +** following functions: +** +** fts3SegWriterAdd() +** fts3SegWriterFlush() +** fts3SegWriterFree() +*/ +struct SegmentWriter { + SegmentNode *pTree; /* Pointer to interior tree structure */ + sqlite3_int64 iFirst; /* First slot in %_segments written */ + sqlite3_int64 iFree; /* Next free slot in %_segments */ + char *zTerm; /* Pointer to previous term buffer */ + int nTerm; /* Number of bytes in zTerm */ + int nMalloc; /* Size of malloc'd buffer at zMalloc */ + char *zMalloc; /* Malloc'd space (possibly) used for zTerm */ + int nSize; /* Size of allocation at aData */ + int nData; /* Bytes of data in aData */ + char *aData; /* Pointer to block from malloc() */ + i64 nLeafData; /* Number of bytes of leaf data written */ +}; + +/* +** Type SegmentNode is used by the following three functions to create +** the interior part of the segment b+-tree structures (everything except +** the leaf nodes). These functions and type are only ever used by code +** within the fts3SegWriterXXX() family of functions described above. +** +** fts3NodeAddTerm() +** fts3NodeWrite() +** fts3NodeFree() +** +** When a b+tree is written to the database (either as a result of a merge +** or the pending-terms table being flushed), leaves are written into the +** database file as soon as they are completely populated. The interior of +** the tree is assembled in memory and written out only once all leaves have +** been populated and stored. This is Ok, as the b+-tree fanout is usually +** very large, meaning that the interior of the tree consumes relatively +** little memory. +*/ +struct SegmentNode { + SegmentNode *pParent; /* Parent node (or NULL for root node) */ + SegmentNode *pRight; /* Pointer to right-sibling */ + SegmentNode *pLeftmost; /* Pointer to left-most node of this depth */ + int nEntry; /* Number of terms written to node so far */ + char *zTerm; /* Pointer to previous term buffer */ + int nTerm; /* Number of bytes in zTerm */ + int nMalloc; /* Size of malloc'd buffer at zMalloc */ + char *zMalloc; /* Malloc'd space (possibly) used for zTerm */ + int nData; /* Bytes of valid data so far */ + char *aData; /* Node data */ +}; + +/* +** Valid values for the second argument to fts3SqlStmt(). +*/ +#define SQL_DELETE_CONTENT 0 +#define SQL_IS_EMPTY 1 +#define SQL_DELETE_ALL_CONTENT 2 +#define SQL_DELETE_ALL_SEGMENTS 3 +#define SQL_DELETE_ALL_SEGDIR 4 +#define SQL_DELETE_ALL_DOCSIZE 5 +#define SQL_DELETE_ALL_STAT 6 +#define SQL_SELECT_CONTENT_BY_ROWID 7 +#define SQL_NEXT_SEGMENT_INDEX 8 +#define SQL_INSERT_SEGMENTS 9 +#define SQL_NEXT_SEGMENTS_ID 10 +#define SQL_INSERT_SEGDIR 11 +#define SQL_SELECT_LEVEL 12 +#define SQL_SELECT_LEVEL_RANGE 13 +#define SQL_SELECT_LEVEL_COUNT 14 +#define SQL_SELECT_SEGDIR_MAX_LEVEL 15 +#define SQL_DELETE_SEGDIR_LEVEL 16 +#define SQL_DELETE_SEGMENTS_RANGE 17 +#define SQL_CONTENT_INSERT 18 +#define SQL_DELETE_DOCSIZE 19 +#define SQL_REPLACE_DOCSIZE 20 +#define SQL_SELECT_DOCSIZE 21 +#define SQL_SELECT_STAT 22 +#define SQL_REPLACE_STAT 23 + +#define SQL_SELECT_ALL_PREFIX_LEVEL 24 +#define SQL_DELETE_ALL_TERMS_SEGDIR 25 +#define SQL_DELETE_SEGDIR_RANGE 26 +#define SQL_SELECT_ALL_LANGID 27 +#define SQL_FIND_MERGE_LEVEL 28 +#define SQL_MAX_LEAF_NODE_ESTIMATE 29 +#define SQL_DELETE_SEGDIR_ENTRY 30 +#define SQL_SHIFT_SEGDIR_ENTRY 31 +#define SQL_SELECT_SEGDIR 32 +#define SQL_CHOMP_SEGDIR 33 +#define SQL_SEGMENT_IS_APPENDABLE 34 +#define SQL_SELECT_INDEXES 35 +#define SQL_SELECT_MXLEVEL 36 + +#define SQL_SELECT_LEVEL_RANGE2 37 +#define SQL_UPDATE_LEVEL_IDX 38 +#define SQL_UPDATE_LEVEL 39 + +/* +** This function is used to obtain an SQLite prepared statement handle +** for the statement identified by the second argument. If successful, +** *pp is set to the requested statement handle and SQLITE_OK returned. +** Otherwise, an SQLite error code is returned and *pp is set to 0. +** +** If argument apVal is not NULL, then it must point to an array with +** at least as many entries as the requested statement has bound +** parameters. The values are bound to the statements parameters before +** returning. +*/ +static int fts3SqlStmt( + Fts3Table *p, /* Virtual table handle */ + int eStmt, /* One of the SQL_XXX constants above */ + sqlite3_stmt **pp, /* OUT: Statement handle */ + sqlite3_value **apVal /* Values to bind to statement */ +){ + const char *azSql[] = { +/* 0 */ "DELETE FROM %Q.'%q_content' WHERE rowid = ?", +/* 1 */ "SELECT NOT EXISTS(SELECT docid FROM %Q.'%q_content' WHERE rowid!=?)", +/* 2 */ "DELETE FROM %Q.'%q_content'", +/* 3 */ "DELETE FROM %Q.'%q_segments'", +/* 4 */ "DELETE FROM %Q.'%q_segdir'", +/* 5 */ "DELETE FROM %Q.'%q_docsize'", +/* 6 */ "DELETE FROM %Q.'%q_stat'", +/* 7 */ "SELECT %s WHERE rowid=?", +/* 8 */ "SELECT (SELECT max(idx) FROM %Q.'%q_segdir' WHERE level = ?) + 1", +/* 9 */ "REPLACE INTO %Q.'%q_segments'(blockid, block) VALUES(?, ?)", +/* 10 */ "SELECT coalesce((SELECT max(blockid) FROM %Q.'%q_segments') + 1, 1)", +/* 11 */ "REPLACE INTO %Q.'%q_segdir' VALUES(?,?,?,?,?,?)", + + /* Return segments in order from oldest to newest.*/ +/* 12 */ "SELECT idx, start_block, leaves_end_block, end_block, root " + "FROM %Q.'%q_segdir' WHERE level = ? ORDER BY idx ASC", +/* 13 */ "SELECT idx, start_block, leaves_end_block, end_block, root " + "FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ?" + "ORDER BY level DESC, idx ASC", + +/* 14 */ "SELECT count(*) FROM %Q.'%q_segdir' WHERE level = ?", +/* 15 */ "SELECT max(level) FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ?", + +/* 16 */ "DELETE FROM %Q.'%q_segdir' WHERE level = ?", +/* 17 */ "DELETE FROM %Q.'%q_segments' WHERE blockid BETWEEN ? AND ?", +/* 18 */ "INSERT INTO %Q.'%q_content' VALUES(%s)", +/* 19 */ "DELETE FROM %Q.'%q_docsize' WHERE docid = ?", +/* 20 */ "REPLACE INTO %Q.'%q_docsize' VALUES(?,?)", +/* 21 */ "SELECT size FROM %Q.'%q_docsize' WHERE docid=?", +/* 22 */ "SELECT value FROM %Q.'%q_stat' WHERE id=?", +/* 23 */ "REPLACE INTO %Q.'%q_stat' VALUES(?,?)", +/* 24 */ "", +/* 25 */ "", + +/* 26 */ "DELETE FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ?", +/* 27 */ "SELECT ? UNION SELECT level / (1024 * ?) FROM %Q.'%q_segdir'", + +/* This statement is used to determine which level to read the input from +** when performing an incremental merge. It returns the absolute level number +** of the oldest level in the db that contains at least ? segments. Or, +** if no level in the FTS index contains more than ? segments, the statement +** returns zero rows. */ +/* 28 */ "SELECT level, count(*) AS cnt FROM %Q.'%q_segdir' " + " GROUP BY level HAVING cnt>=?" + " ORDER BY (level %% 1024) ASC, 2 DESC LIMIT 1", + +/* Estimate the upper limit on the number of leaf nodes in a new segment +** created by merging the oldest :2 segments from absolute level :1. See +** function sqlite3Fts3Incrmerge() for details. */ +/* 29 */ "SELECT 2 * total(1 + leaves_end_block - start_block) " + " FROM (SELECT * FROM %Q.'%q_segdir' " + " WHERE level = ? ORDER BY idx ASC LIMIT ?" + " )", + +/* SQL_DELETE_SEGDIR_ENTRY +** Delete the %_segdir entry on absolute level :1 with index :2. */ +/* 30 */ "DELETE FROM %Q.'%q_segdir' WHERE level = ? AND idx = ?", + +/* SQL_SHIFT_SEGDIR_ENTRY +** Modify the idx value for the segment with idx=:3 on absolute level :2 +** to :1. */ +/* 31 */ "UPDATE %Q.'%q_segdir' SET idx = ? WHERE level=? AND idx=?", + +/* SQL_SELECT_SEGDIR +** Read a single entry from the %_segdir table. The entry from absolute +** level :1 with index value :2. */ +/* 32 */ "SELECT idx, start_block, leaves_end_block, end_block, root " + "FROM %Q.'%q_segdir' WHERE level = ? AND idx = ?", + +/* SQL_CHOMP_SEGDIR +** Update the start_block (:1) and root (:2) fields of the %_segdir +** entry located on absolute level :3 with index :4. */ +/* 33 */ "UPDATE %Q.'%q_segdir' SET start_block = ?, root = ?" + "WHERE level = ? AND idx = ?", + +/* SQL_SEGMENT_IS_APPENDABLE +** Return a single row if the segment with end_block=? is appendable. Or +** no rows otherwise. */ +/* 34 */ "SELECT 1 FROM %Q.'%q_segments' WHERE blockid=? AND block IS NULL", + +/* SQL_SELECT_INDEXES +** Return the list of valid segment indexes for absolute level ? */ +/* 35 */ "SELECT idx FROM %Q.'%q_segdir' WHERE level=? ORDER BY 1 ASC", + +/* SQL_SELECT_MXLEVEL +** Return the largest relative level in the FTS index or indexes. */ +/* 36 */ "SELECT max( level %% 1024 ) FROM %Q.'%q_segdir'", + + /* Return segments in order from oldest to newest.*/ +/* 37 */ "SELECT level, idx, end_block " + "FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ? " + "ORDER BY level DESC, idx ASC", + + /* Update statements used while promoting segments */ +/* 38 */ "UPDATE OR FAIL %Q.'%q_segdir' SET level=-1,idx=? " + "WHERE level=? AND idx=?", +/* 39 */ "UPDATE OR FAIL %Q.'%q_segdir' SET level=? WHERE level=-1" + + }; + int rc = SQLITE_OK; + sqlite3_stmt *pStmt; + + assert( SizeofArray(azSql)==SizeofArray(p->aStmt) ); + assert( eStmt=0 ); + + pStmt = p->aStmt[eStmt]; + if( !pStmt ){ + int f = SQLITE_PREPARE_PERSISTENT|SQLITE_PREPARE_NO_VTAB; + char *zSql; + if( eStmt==SQL_CONTENT_INSERT ){ + zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName, p->zWriteExprlist); + }else if( eStmt==SQL_SELECT_CONTENT_BY_ROWID ){ + f &= ~SQLITE_PREPARE_NO_VTAB; + zSql = sqlite3_mprintf(azSql[eStmt], p->zReadExprlist); + }else{ + zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName); + } + if( !zSql ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare_v3(p->db, zSql, -1, f, &pStmt, NULL); + sqlite3_free(zSql); + assert( rc==SQLITE_OK || pStmt==0 ); + p->aStmt[eStmt] = pStmt; + } + } + if( apVal ){ + int i; + int nParam = sqlite3_bind_parameter_count(pStmt); + for(i=0; rc==SQLITE_OK && inPendingData==0 ){ + sqlite3_stmt *pStmt; + rc = fts3SqlStmt(p, SQL_DELETE_SEGDIR_LEVEL, &pStmt, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_null(pStmt, 1); + sqlite3_step(pStmt); + rc = sqlite3_reset(pStmt); + } + } + + return rc; +} + +/* +** FTS maintains a separate indexes for each language-id (a 32-bit integer). +** Within each language id, a separate index is maintained to store the +** document terms, and each configured prefix size (configured the FTS +** "prefix=" option). And each index consists of multiple levels ("relative +** levels"). +** +** All three of these values (the language id, the specific index and the +** level within the index) are encoded in 64-bit integer values stored +** in the %_segdir table on disk. This function is used to convert three +** separate component values into the single 64-bit integer value that +** can be used to query the %_segdir table. +** +** Specifically, each language-id/index combination is allocated 1024 +** 64-bit integer level values ("absolute levels"). The main terms index +** for language-id 0 is allocate values 0-1023. The first prefix index +** (if any) for language-id 0 is allocated values 1024-2047. And so on. +** Language 1 indexes are allocated immediately following language 0. +** +** So, for a system with nPrefix prefix indexes configured, the block of +** absolute levels that corresponds to language-id iLangid and index +** iIndex starts at absolute level ((iLangid * (nPrefix+1) + iIndex) * 1024). +*/ +static sqlite3_int64 getAbsoluteLevel( + Fts3Table *p, /* FTS3 table handle */ + int iLangid, /* Language id */ + int iIndex, /* Index in p->aIndex[] */ + int iLevel /* Level of segments */ +){ + sqlite3_int64 iBase; /* First absolute level for iLangid/iIndex */ + assert_fts3_nc( iLangid>=0 ); + assert( p->nIndex>0 ); + assert( iIndex>=0 && iIndexnIndex ); + + iBase = ((sqlite3_int64)iLangid * p->nIndex + iIndex) * FTS3_SEGDIR_MAXLEVEL; + return iBase + iLevel; +} + +/* +** Set *ppStmt to a statement handle that may be used to iterate through +** all rows in the %_segdir table, from oldest to newest. If successful, +** return SQLITE_OK. If an error occurs while preparing the statement, +** return an SQLite error code. +** +** There is only ever one instance of this SQL statement compiled for +** each FTS3 table. +** +** The statement returns the following columns from the %_segdir table: +** +** 0: idx +** 1: start_block +** 2: leaves_end_block +** 3: end_block +** 4: root +*/ +SQLITE_PRIVATE int sqlite3Fts3AllSegdirs( + Fts3Table *p, /* FTS3 table */ + int iLangid, /* Language being queried */ + int iIndex, /* Index for p->aIndex[] */ + int iLevel, /* Level to select (relative level) */ + sqlite3_stmt **ppStmt /* OUT: Compiled statement */ +){ + int rc; + sqlite3_stmt *pStmt = 0; + + assert( iLevel==FTS3_SEGCURSOR_ALL || iLevel>=0 ); + assert( iLevel=0 && iIndexnIndex ); + + if( iLevel<0 ){ + /* "SELECT * FROM %_segdir WHERE level BETWEEN ? AND ? ORDER BY ..." */ + rc = fts3SqlStmt(p, SQL_SELECT_LEVEL_RANGE, &pStmt, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pStmt, 1, getAbsoluteLevel(p, iLangid, iIndex, 0)); + sqlite3_bind_int64(pStmt, 2, + getAbsoluteLevel(p, iLangid, iIndex, FTS3_SEGDIR_MAXLEVEL-1) + ); + } + }else{ + /* "SELECT * FROM %_segdir WHERE level = ? ORDER BY ..." */ + rc = fts3SqlStmt(p, SQL_SELECT_LEVEL, &pStmt, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pStmt, 1, getAbsoluteLevel(p, iLangid, iIndex,iLevel)); + } + } + *ppStmt = pStmt; + return rc; +} + + +/* +** Append a single varint to a PendingList buffer. SQLITE_OK is returned +** if successful, or an SQLite error code otherwise. +** +** This function also serves to allocate the PendingList structure itself. +** For example, to create a new PendingList structure containing two +** varints: +** +** PendingList *p = 0; +** fts3PendingListAppendVarint(&p, 1); +** fts3PendingListAppendVarint(&p, 2); +*/ +static int fts3PendingListAppendVarint( + PendingList **pp, /* IN/OUT: Pointer to PendingList struct */ + sqlite3_int64 i /* Value to append to data */ +){ + PendingList *p = *pp; + + /* Allocate or grow the PendingList as required. */ + if( !p ){ + p = sqlite3_malloc64(sizeof(*p) + 100); + if( !p ){ + return SQLITE_NOMEM; + } + p->nSpace = 100; + p->aData = (char *)&p[1]; + p->nData = 0; + } + else if( p->nData+FTS3_VARINT_MAX+1>p->nSpace ){ + i64 nNew = p->nSpace * 2; + p = sqlite3_realloc64(p, sizeof(*p) + nNew); + if( !p ){ + sqlite3_free(*pp); + *pp = 0; + return SQLITE_NOMEM; + } + p->nSpace = (int)nNew; + p->aData = (char *)&p[1]; + } + + /* Append the new serialized varint to the end of the list. */ + p->nData += sqlite3Fts3PutVarint(&p->aData[p->nData], i); + p->aData[p->nData] = '\0'; + *pp = p; + return SQLITE_OK; +} + +/* +** Add a docid/column/position entry to a PendingList structure. Non-zero +** is returned if the structure is sqlite3_realloced as part of adding +** the entry. Otherwise, zero. +** +** If an OOM error occurs, *pRc is set to SQLITE_NOMEM before returning. +** Zero is always returned in this case. Otherwise, if no OOM error occurs, +** it is set to SQLITE_OK. +*/ +static int fts3PendingListAppend( + PendingList **pp, /* IN/OUT: PendingList structure */ + sqlite3_int64 iDocid, /* Docid for entry to add */ + sqlite3_int64 iCol, /* Column for entry to add */ + sqlite3_int64 iPos, /* Position of term for entry to add */ + int *pRc /* OUT: Return code */ +){ + PendingList *p = *pp; + int rc = SQLITE_OK; + + assert( !p || p->iLastDocid<=iDocid ); + + if( !p || p->iLastDocid!=iDocid ){ + u64 iDelta = (u64)iDocid - (u64)(p ? p->iLastDocid : 0); + if( p ){ + assert( p->nDatanSpace ); + assert( p->aData[p->nData]==0 ); + p->nData++; + } + if( SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iDelta)) ){ + goto pendinglistappend_out; + } + p->iLastCol = -1; + p->iLastPos = 0; + p->iLastDocid = iDocid; + } + if( iCol>0 && p->iLastCol!=iCol ){ + if( SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, 1)) + || SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iCol)) + ){ + goto pendinglistappend_out; + } + p->iLastCol = iCol; + p->iLastPos = 0; + } + if( iCol>=0 ){ + assert( iPos>p->iLastPos || (iPos==0 && p->iLastPos==0) ); + rc = fts3PendingListAppendVarint(&p, 2+iPos-p->iLastPos); + if( rc==SQLITE_OK ){ + p->iLastPos = iPos; + } + } + + pendinglistappend_out: + *pRc = rc; + if( p!=*pp ){ + *pp = p; + return 1; + } + return 0; +} + +/* +** Free a PendingList object allocated by fts3PendingListAppend(). +*/ +static void fts3PendingListDelete(PendingList *pList){ + sqlite3_free(pList); +} + +/* +** Add an entry to one of the pending-terms hash tables. +*/ +static int fts3PendingTermsAddOne( + Fts3Table *p, + int iCol, + int iPos, + Fts3Hash *pHash, /* Pending terms hash table to add entry to */ + const char *zToken, + int nToken +){ + PendingList *pList; + int rc = SQLITE_OK; + + pList = (PendingList *)fts3HashFind(pHash, zToken, nToken); + if( pList ){ + p->nPendingData -= (pList->nData + nToken + sizeof(Fts3HashElem)); + } + if( fts3PendingListAppend(&pList, p->iPrevDocid, iCol, iPos, &rc) ){ + if( pList==fts3HashInsert(pHash, zToken, nToken, pList) ){ + /* Malloc failed while inserting the new entry. This can only + ** happen if there was no previous entry for this token. + */ + assert( 0==fts3HashFind(pHash, zToken, nToken) ); + sqlite3_free(pList); + rc = SQLITE_NOMEM; + } + } + if( rc==SQLITE_OK ){ + p->nPendingData += (pList->nData + nToken + sizeof(Fts3HashElem)); + } + return rc; +} + +/* +** Tokenize the nul-terminated string zText and add all tokens to the +** pending-terms hash-table. The docid used is that currently stored in +** p->iPrevDocid, and the column is specified by argument iCol. +** +** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code. +*/ +static int fts3PendingTermsAdd( + Fts3Table *p, /* Table into which text will be inserted */ + int iLangid, /* Language id to use */ + const char *zText, /* Text of document to be inserted */ + int iCol, /* Column into which text is being inserted */ + u32 *pnWord /* IN/OUT: Incr. by number tokens inserted */ +){ + int rc; + int iStart = 0; + int iEnd = 0; + int iPos = 0; + int nWord = 0; + + char const *zToken; + int nToken = 0; + + sqlite3_tokenizer *pTokenizer = p->pTokenizer; + sqlite3_tokenizer_module const *pModule = pTokenizer->pModule; + sqlite3_tokenizer_cursor *pCsr; + int (*xNext)(sqlite3_tokenizer_cursor *pCursor, + const char**,int*,int*,int*,int*); + + assert( pTokenizer && pModule ); + + /* If the user has inserted a NULL value, this function may be called with + ** zText==0. In this case, add zero token entries to the hash table and + ** return early. */ + if( zText==0 ){ + *pnWord = 0; + return SQLITE_OK; + } + + rc = sqlite3Fts3OpenTokenizer(pTokenizer, iLangid, zText, -1, &pCsr); + if( rc!=SQLITE_OK ){ + return rc; + } + + xNext = pModule->xNext; + while( SQLITE_OK==rc + && SQLITE_OK==(rc = xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos)) + ){ + int i; + if( iPos>=nWord ) nWord = iPos+1; + + /* Positions cannot be negative; we use -1 as a terminator internally. + ** Tokens must have a non-zero length. + */ + if( iPos<0 || !zToken || nToken<=0 ){ + rc = SQLITE_ERROR; + break; + } + + /* Add the term to the terms index */ + rc = fts3PendingTermsAddOne( + p, iCol, iPos, &p->aIndex[0].hPending, zToken, nToken + ); + + /* Add the term to each of the prefix indexes that it is not too + ** short for. */ + for(i=1; rc==SQLITE_OK && inIndex; i++){ + struct Fts3Index *pIndex = &p->aIndex[i]; + if( nTokennPrefix ) continue; + rc = fts3PendingTermsAddOne( + p, iCol, iPos, &pIndex->hPending, zToken, pIndex->nPrefix + ); + } + } + + pModule->xClose(pCsr); + *pnWord += nWord; + return (rc==SQLITE_DONE ? SQLITE_OK : rc); +} + +/* +** Calling this function indicates that subsequent calls to +** fts3PendingTermsAdd() are to add term/position-list pairs for the +** contents of the document with docid iDocid. +*/ +static int fts3PendingTermsDocid( + Fts3Table *p, /* Full-text table handle */ + int bDelete, /* True if this op is a delete */ + int iLangid, /* Language id of row being written */ + sqlite_int64 iDocid /* Docid of row being written */ +){ + assert( iLangid>=0 ); + assert( bDelete==1 || bDelete==0 ); + + /* TODO(shess) Explore whether partially flushing the buffer on + ** forced-flush would provide better performance. I suspect that if + ** we ordered the doclists by size and flushed the largest until the + ** buffer was half empty, that would let the less frequent terms + ** generate longer doclists. + */ + if( iDocidiPrevDocid + || (iDocid==p->iPrevDocid && p->bPrevDelete==0) + || p->iPrevLangid!=iLangid + || p->nPendingData>p->nMaxPendingData + ){ + int rc = sqlite3Fts3PendingTermsFlush(p); + if( rc!=SQLITE_OK ) return rc; + } + p->iPrevDocid = iDocid; + p->iPrevLangid = iLangid; + p->bPrevDelete = bDelete; + return SQLITE_OK; +} + +/* +** Discard the contents of the pending-terms hash tables. +*/ +SQLITE_PRIVATE void sqlite3Fts3PendingTermsClear(Fts3Table *p){ + int i; + for(i=0; inIndex; i++){ + Fts3HashElem *pElem; + Fts3Hash *pHash = &p->aIndex[i].hPending; + for(pElem=fts3HashFirst(pHash); pElem; pElem=fts3HashNext(pElem)){ + PendingList *pList = (PendingList *)fts3HashData(pElem); + fts3PendingListDelete(pList); + } + fts3HashClear(pHash); + } + p->nPendingData = 0; +} + +/* +** This function is called by the xUpdate() method as part of an INSERT +** operation. It adds entries for each term in the new record to the +** pendingTerms hash table. +** +** Argument apVal is the same as the similarly named argument passed to +** fts3InsertData(). Parameter iDocid is the docid of the new row. +*/ +static int fts3InsertTerms( + Fts3Table *p, + int iLangid, + sqlite3_value **apVal, + u32 *aSz +){ + int i; /* Iterator variable */ + for(i=2; inColumn+2; i++){ + int iCol = i-2; + if( p->abNotindexed[iCol]==0 ){ + const char *zText = (const char *)sqlite3_value_text(apVal[i]); + int rc = fts3PendingTermsAdd(p, iLangid, zText, iCol, &aSz[iCol]); + if( rc!=SQLITE_OK ){ + return rc; + } + aSz[p->nColumn] += sqlite3_value_bytes(apVal[i]); + } + } + return SQLITE_OK; +} + +/* +** This function is called by the xUpdate() method for an INSERT operation. +** The apVal parameter is passed a copy of the apVal argument passed by +** SQLite to the xUpdate() method. i.e: +** +** apVal[0] Not used for INSERT. +** apVal[1] rowid +** apVal[2] Left-most user-defined column +** ... +** apVal[p->nColumn+1] Right-most user-defined column +** apVal[p->nColumn+2] Hidden column with same name as table +** apVal[p->nColumn+3] Hidden "docid" column (alias for rowid) +** apVal[p->nColumn+4] Hidden languageid column +*/ +static int fts3InsertData( + Fts3Table *p, /* Full-text table */ + sqlite3_value **apVal, /* Array of values to insert */ + sqlite3_int64 *piDocid /* OUT: Docid for row just inserted */ +){ + int rc; /* Return code */ + sqlite3_stmt *pContentInsert; /* INSERT INTO %_content VALUES(...) */ + + if( p->zContentTbl ){ + sqlite3_value *pRowid = apVal[p->nColumn+3]; + if( sqlite3_value_type(pRowid)==SQLITE_NULL ){ + pRowid = apVal[1]; + } + if( sqlite3_value_type(pRowid)!=SQLITE_INTEGER ){ + return SQLITE_CONSTRAINT; + } + *piDocid = sqlite3_value_int64(pRowid); + return SQLITE_OK; + } + + /* Locate the statement handle used to insert data into the %_content + ** table. The SQL for this statement is: + ** + ** INSERT INTO %_content VALUES(?, ?, ?, ...) + ** + ** The statement features N '?' variables, where N is the number of user + ** defined columns in the FTS3 table, plus one for the docid field. + */ + rc = fts3SqlStmt(p, SQL_CONTENT_INSERT, &pContentInsert, &apVal[1]); + if( rc==SQLITE_OK && p->zLanguageid ){ + rc = sqlite3_bind_int( + pContentInsert, p->nColumn+2, + sqlite3_value_int(apVal[p->nColumn+4]) + ); + } + if( rc!=SQLITE_OK ) return rc; + + /* There is a quirk here. The users INSERT statement may have specified + ** a value for the "rowid" field, for the "docid" field, or for both. + ** Which is a problem, since "rowid" and "docid" are aliases for the + ** same value. For example: + ** + ** INSERT INTO fts3tbl(rowid, docid) VALUES(1, 2); + ** + ** In FTS3, this is an error. It is an error to specify non-NULL values + ** for both docid and some other rowid alias. + */ + if( SQLITE_NULL!=sqlite3_value_type(apVal[3+p->nColumn]) ){ + if( SQLITE_NULL==sqlite3_value_type(apVal[0]) + && SQLITE_NULL!=sqlite3_value_type(apVal[1]) + ){ + /* A rowid/docid conflict. */ + return SQLITE_ERROR; + } + rc = sqlite3_bind_value(pContentInsert, 1, apVal[3+p->nColumn]); + if( rc!=SQLITE_OK ) return rc; + } + + /* Execute the statement to insert the record. Set *piDocid to the + ** new docid value. + */ + sqlite3_step(pContentInsert); + rc = sqlite3_reset(pContentInsert); + + *piDocid = sqlite3_last_insert_rowid(p->db); + return rc; +} + + + +/* +** Remove all data from the FTS3 table. Clear the hash table containing +** pending terms. +*/ +static int fts3DeleteAll(Fts3Table *p, int bContent){ + int rc = SQLITE_OK; /* Return code */ + + /* Discard the contents of the pending-terms hash table. */ + sqlite3Fts3PendingTermsClear(p); + + /* Delete everything from the shadow tables. Except, leave %_content as + ** is if bContent is false. */ + assert( p->zContentTbl==0 || bContent==0 ); + if( bContent ) fts3SqlExec(&rc, p, SQL_DELETE_ALL_CONTENT, 0); + fts3SqlExec(&rc, p, SQL_DELETE_ALL_SEGMENTS, 0); + fts3SqlExec(&rc, p, SQL_DELETE_ALL_SEGDIR, 0); + if( p->bHasDocsize ){ + fts3SqlExec(&rc, p, SQL_DELETE_ALL_DOCSIZE, 0); + } + if( p->bHasStat ){ + fts3SqlExec(&rc, p, SQL_DELETE_ALL_STAT, 0); + } + return rc; +} + +/* +** +*/ +static int langidFromSelect(Fts3Table *p, sqlite3_stmt *pSelect){ + int iLangid = 0; + if( p->zLanguageid ) iLangid = sqlite3_column_int(pSelect, p->nColumn+1); + return iLangid; +} + +/* +** The first element in the apVal[] array is assumed to contain the docid +** (an integer) of a row about to be deleted. Remove all terms from the +** full-text index. +*/ +static void fts3DeleteTerms( + int *pRC, /* Result code */ + Fts3Table *p, /* The FTS table to delete from */ + sqlite3_value *pRowid, /* The docid to be deleted */ + u32 *aSz, /* Sizes of deleted document written here */ + int *pbFound /* OUT: Set to true if row really does exist */ +){ + int rc; + sqlite3_stmt *pSelect; + + assert( *pbFound==0 ); + if( *pRC ) return; + rc = fts3SqlStmt(p, SQL_SELECT_CONTENT_BY_ROWID, &pSelect, &pRowid); + if( rc==SQLITE_OK ){ + if( SQLITE_ROW==sqlite3_step(pSelect) ){ + int i; + int iLangid = langidFromSelect(p, pSelect); + i64 iDocid = sqlite3_column_int64(pSelect, 0); + rc = fts3PendingTermsDocid(p, 1, iLangid, iDocid); + for(i=1; rc==SQLITE_OK && i<=p->nColumn; i++){ + int iCol = i-1; + if( p->abNotindexed[iCol]==0 ){ + const char *zText = (const char *)sqlite3_column_text(pSelect, i); + rc = fts3PendingTermsAdd(p, iLangid, zText, -1, &aSz[iCol]); + aSz[p->nColumn] += sqlite3_column_bytes(pSelect, i); + } + } + if( rc!=SQLITE_OK ){ + sqlite3_reset(pSelect); + *pRC = rc; + return; + } + *pbFound = 1; + } + rc = sqlite3_reset(pSelect); + }else{ + sqlite3_reset(pSelect); + } + *pRC = rc; +} + +/* +** Forward declaration to account for the circular dependency between +** functions fts3SegmentMerge() and fts3AllocateSegdirIdx(). +*/ +static int fts3SegmentMerge(Fts3Table *, int, int, int); + +/* +** This function allocates a new level iLevel index in the segdir table. +** Usually, indexes are allocated within a level sequentially starting +** with 0, so the allocated index is one greater than the value returned +** by: +** +** SELECT max(idx) FROM %_segdir WHERE level = :iLevel +** +** However, if there are already FTS3_MERGE_COUNT indexes at the requested +** level, they are merged into a single level (iLevel+1) segment and the +** allocated index is 0. +** +** If successful, *piIdx is set to the allocated index slot and SQLITE_OK +** returned. Otherwise, an SQLite error code is returned. +*/ +static int fts3AllocateSegdirIdx( + Fts3Table *p, + int iLangid, /* Language id */ + int iIndex, /* Index for p->aIndex */ + int iLevel, + int *piIdx +){ + int rc; /* Return Code */ + sqlite3_stmt *pNextIdx; /* Query for next idx at level iLevel */ + int iNext = 0; /* Result of query pNextIdx */ + + assert( iLangid>=0 ); + assert( p->nIndex>=1 ); + + /* Set variable iNext to the next available segdir index at level iLevel. */ + rc = fts3SqlStmt(p, SQL_NEXT_SEGMENT_INDEX, &pNextIdx, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64( + pNextIdx, 1, getAbsoluteLevel(p, iLangid, iIndex, iLevel) + ); + if( SQLITE_ROW==sqlite3_step(pNextIdx) ){ + iNext = sqlite3_column_int(pNextIdx, 0); + } + rc = sqlite3_reset(pNextIdx); + } + + if( rc==SQLITE_OK ){ + /* If iNext is FTS3_MERGE_COUNT, indicating that level iLevel is already + ** full, merge all segments in level iLevel into a single iLevel+1 + ** segment and allocate (newly freed) index 0 at level iLevel. Otherwise, + ** if iNext is less than FTS3_MERGE_COUNT, allocate index iNext. + */ + if( iNext>=MergeCount(p) ){ + fts3LogMerge(16, getAbsoluteLevel(p, iLangid, iIndex, iLevel)); + rc = fts3SegmentMerge(p, iLangid, iIndex, iLevel); + *piIdx = 0; + }else{ + *piIdx = iNext; + } + } + + return rc; +} + +/* +** The %_segments table is declared as follows: +** +** CREATE TABLE %_segments(blockid INTEGER PRIMARY KEY, block BLOB) +** +** This function reads data from a single row of the %_segments table. The +** specific row is identified by the iBlockid parameter. If paBlob is not +** NULL, then a buffer is allocated using sqlite3_malloc() and populated +** with the contents of the blob stored in the "block" column of the +** identified table row is. Whether or not paBlob is NULL, *pnBlob is set +** to the size of the blob in bytes before returning. +** +** If an error occurs, or the table does not contain the specified row, +** an SQLite error code is returned. Otherwise, SQLITE_OK is returned. If +** paBlob is non-NULL, then it is the responsibility of the caller to +** eventually free the returned buffer. +** +** This function may leave an open sqlite3_blob* handle in the +** Fts3Table.pSegments variable. This handle is reused by subsequent calls +** to this function. The handle may be closed by calling the +** sqlite3Fts3SegmentsClose() function. Reusing a blob handle is a handy +** performance improvement, but the blob handle should always be closed +** before control is returned to the user (to prevent a lock being held +** on the database file for longer than necessary). Thus, any virtual table +** method (xFilter etc.) that may directly or indirectly call this function +** must call sqlite3Fts3SegmentsClose() before returning. +*/ +SQLITE_PRIVATE int sqlite3Fts3ReadBlock( + Fts3Table *p, /* FTS3 table handle */ + sqlite3_int64 iBlockid, /* Access the row with blockid=$iBlockid */ + char **paBlob, /* OUT: Blob data in malloc'd buffer */ + int *pnBlob, /* OUT: Size of blob data */ + int *pnLoad /* OUT: Bytes actually loaded */ +){ + int rc; /* Return code */ + + /* pnBlob must be non-NULL. paBlob may be NULL or non-NULL. */ + assert( pnBlob ); + + if( p->pSegments ){ + rc = sqlite3_blob_reopen(p->pSegments, iBlockid); + }else{ + if( 0==p->zSegmentsTbl ){ + p->zSegmentsTbl = sqlite3_mprintf("%s_segments", p->zName); + if( 0==p->zSegmentsTbl ) return SQLITE_NOMEM; + } + rc = sqlite3_blob_open( + p->db, p->zDb, p->zSegmentsTbl, "block", iBlockid, 0, &p->pSegments + ); + } + + if( rc==SQLITE_OK ){ + int nByte = sqlite3_blob_bytes(p->pSegments); + *pnBlob = nByte; + if( paBlob ){ + char *aByte = sqlite3_malloc64((i64)nByte + FTS3_NODE_PADDING); + if( !aByte ){ + rc = SQLITE_NOMEM; + }else{ + if( pnLoad && nByte>(FTS3_NODE_CHUNK_THRESHOLD) ){ + nByte = FTS3_NODE_CHUNKSIZE; + *pnLoad = nByte; + } + rc = sqlite3_blob_read(p->pSegments, aByte, nByte, 0); + memset(&aByte[nByte], 0, FTS3_NODE_PADDING); + if( rc!=SQLITE_OK ){ + sqlite3_free(aByte); + aByte = 0; + } + } + *paBlob = aByte; + } + }else if( rc==SQLITE_ERROR ){ + rc = FTS_CORRUPT_VTAB; + } + + return rc; +} + +/* +** Close the blob handle at p->pSegments, if it is open. See comments above +** the sqlite3Fts3ReadBlock() function for details. +*/ +SQLITE_PRIVATE void sqlite3Fts3SegmentsClose(Fts3Table *p){ + sqlite3_blob_close(p->pSegments); + p->pSegments = 0; +} + +static int fts3SegReaderIncrRead(Fts3SegReader *pReader){ + int nRead; /* Number of bytes to read */ + int rc; /* Return code */ + + nRead = MIN(pReader->nNode - pReader->nPopulate, FTS3_NODE_CHUNKSIZE); + rc = sqlite3_blob_read( + pReader->pBlob, + &pReader->aNode[pReader->nPopulate], + nRead, + pReader->nPopulate + ); + + if( rc==SQLITE_OK ){ + pReader->nPopulate += nRead; + memset(&pReader->aNode[pReader->nPopulate], 0, FTS3_NODE_PADDING); + if( pReader->nPopulate==pReader->nNode ){ + sqlite3_blob_close(pReader->pBlob); + pReader->pBlob = 0; + pReader->nPopulate = 0; + } + } + return rc; +} + +static int fts3SegReaderRequire(Fts3SegReader *pReader, char *pFrom, int nByte){ + int rc = SQLITE_OK; + assert( !pReader->pBlob + || (pFrom>=pReader->aNode && pFrom<&pReader->aNode[pReader->nNode]) + ); + while( pReader->pBlob && rc==SQLITE_OK + && (pFrom - pReader->aNode + nByte)>pReader->nPopulate + ){ + rc = fts3SegReaderIncrRead(pReader); + } + return rc; +} + +/* +** Set an Fts3SegReader cursor to point at EOF. +*/ +static void fts3SegReaderSetEof(Fts3SegReader *pSeg){ + if( !fts3SegReaderIsRootOnly(pSeg) ){ + sqlite3_free(pSeg->aNode); + sqlite3_blob_close(pSeg->pBlob); + pSeg->pBlob = 0; + } + pSeg->aNode = 0; +} + +/* +** Move the iterator passed as the first argument to the next term in the +** segment. If successful, SQLITE_OK is returned. If there is no next term, +** SQLITE_DONE. Otherwise, an SQLite error code. +*/ +static int fts3SegReaderNext( + Fts3Table *p, + Fts3SegReader *pReader, + int bIncr +){ + int rc; /* Return code of various sub-routines */ + char *pNext; /* Cursor variable */ + int nPrefix; /* Number of bytes in term prefix */ + int nSuffix; /* Number of bytes in term suffix */ + + if( !pReader->aDoclist ){ + pNext = pReader->aNode; + }else{ + pNext = &pReader->aDoclist[pReader->nDoclist]; + } + + if( !pNext || pNext>=&pReader->aNode[pReader->nNode] ){ + + if( fts3SegReaderIsPending(pReader) ){ + Fts3HashElem *pElem = *(pReader->ppNextElem); + sqlite3_free(pReader->aNode); + pReader->aNode = 0; + if( pElem ){ + char *aCopy; + PendingList *pList = (PendingList *)fts3HashData(pElem); + int nCopy = pList->nData+1; + + int nTerm = fts3HashKeysize(pElem); + if( (nTerm+1)>pReader->nTermAlloc ){ + sqlite3_free(pReader->zTerm); + pReader->zTerm = (char*)sqlite3_malloc64(((i64)nTerm+1)*2); + if( !pReader->zTerm ) return SQLITE_NOMEM; + pReader->nTermAlloc = (nTerm+1)*2; + } + memcpy(pReader->zTerm, fts3HashKey(pElem), nTerm); + pReader->zTerm[nTerm] = '\0'; + pReader->nTerm = nTerm; + + aCopy = (char*)sqlite3_malloc64(nCopy); + if( !aCopy ) return SQLITE_NOMEM; + memcpy(aCopy, pList->aData, nCopy); + pReader->nNode = pReader->nDoclist = nCopy; + pReader->aNode = pReader->aDoclist = aCopy; + pReader->ppNextElem++; + assert( pReader->aNode ); + } + return SQLITE_OK; + } + + fts3SegReaderSetEof(pReader); + + /* If iCurrentBlock>=iLeafEndBlock, this is an EOF condition. All leaf + ** blocks have already been traversed. */ +#ifdef CORRUPT_DB + assert( pReader->iCurrentBlock<=pReader->iLeafEndBlock || CORRUPT_DB ); +#endif + if( pReader->iCurrentBlock>=pReader->iLeafEndBlock ){ + return SQLITE_OK; + } + + rc = sqlite3Fts3ReadBlock( + p, ++pReader->iCurrentBlock, &pReader->aNode, &pReader->nNode, + (bIncr ? &pReader->nPopulate : 0) + ); + if( rc!=SQLITE_OK ) return rc; + assert( pReader->pBlob==0 ); + if( bIncr && pReader->nPopulatenNode ){ + pReader->pBlob = p->pSegments; + p->pSegments = 0; + } + pNext = pReader->aNode; + } + + assert( !fts3SegReaderIsPending(pReader) ); + + rc = fts3SegReaderRequire(pReader, pNext, FTS3_VARINT_MAX*2); + if( rc!=SQLITE_OK ) return rc; + + /* Because of the FTS3_NODE_PADDING bytes of padding, the following is + ** safe (no risk of overread) even if the node data is corrupted. */ + pNext += fts3GetVarint32(pNext, &nPrefix); + pNext += fts3GetVarint32(pNext, &nSuffix); + if( nSuffix<=0 + || (&pReader->aNode[pReader->nNode] - pNext)pReader->nTerm + ){ + return FTS_CORRUPT_VTAB; + } + + /* Both nPrefix and nSuffix were read by fts3GetVarint32() and so are + ** between 0 and 0x7FFFFFFF. But the sum of the two may cause integer + ** overflow - hence the (i64) casts. */ + if( (i64)nPrefix+nSuffix>(i64)pReader->nTermAlloc ){ + i64 nNew = ((i64)nPrefix+nSuffix)*2; + char *zNew = sqlite3_realloc64(pReader->zTerm, nNew); + if( !zNew ){ + return SQLITE_NOMEM; + } + pReader->zTerm = zNew; + pReader->nTermAlloc = nNew; + } + + rc = fts3SegReaderRequire(pReader, pNext, nSuffix+FTS3_VARINT_MAX); + if( rc!=SQLITE_OK ) return rc; + + memcpy(&pReader->zTerm[nPrefix], pNext, nSuffix); + pReader->nTerm = nPrefix+nSuffix; + pNext += nSuffix; + pNext += fts3GetVarint32(pNext, &pReader->nDoclist); + pReader->aDoclist = pNext; + pReader->pOffsetList = 0; + + /* Check that the doclist does not appear to extend past the end of the + ** b-tree node. And that the final byte of the doclist is 0x00. If either + ** of these statements is untrue, then the data structure is corrupt. + */ + if( pReader->nDoclist > pReader->nNode-(pReader->aDoclist-pReader->aNode) + || (pReader->nPopulate==0 && pReader->aDoclist[pReader->nDoclist-1]) + || pReader->nDoclist==0 + ){ + return FTS_CORRUPT_VTAB; + } + return SQLITE_OK; +} + +/* +** Set the SegReader to point to the first docid in the doclist associated +** with the current term. +*/ +static int fts3SegReaderFirstDocid(Fts3Table *pTab, Fts3SegReader *pReader){ + int rc = SQLITE_OK; + assert( pReader->aDoclist ); + assert( !pReader->pOffsetList ); + if( pTab->bDescIdx && fts3SegReaderIsPending(pReader) ){ + u8 bEof = 0; + pReader->iDocid = 0; + pReader->nOffsetList = 0; + sqlite3Fts3DoclistPrev(0, + pReader->aDoclist, pReader->nDoclist, &pReader->pOffsetList, + &pReader->iDocid, &pReader->nOffsetList, &bEof + ); + }else{ + rc = fts3SegReaderRequire(pReader, pReader->aDoclist, FTS3_VARINT_MAX); + if( rc==SQLITE_OK ){ + int n = sqlite3Fts3GetVarint(pReader->aDoclist, &pReader->iDocid); + pReader->pOffsetList = &pReader->aDoclist[n]; + } + } + return rc; +} + +/* +** Advance the SegReader to point to the next docid in the doclist +** associated with the current term. +** +** If arguments ppOffsetList and pnOffsetList are not NULL, then +** *ppOffsetList is set to point to the first column-offset list +** in the doclist entry (i.e. immediately past the docid varint). +** *pnOffsetList is set to the length of the set of column-offset +** lists, not including the nul-terminator byte. For example: +*/ +static int fts3SegReaderNextDocid( + Fts3Table *pTab, + Fts3SegReader *pReader, /* Reader to advance to next docid */ + char **ppOffsetList, /* OUT: Pointer to current position-list */ + int *pnOffsetList /* OUT: Length of *ppOffsetList in bytes */ +){ + int rc = SQLITE_OK; + char *p = pReader->pOffsetList; + char c = 0; + + assert( p ); + + if( pTab->bDescIdx && fts3SegReaderIsPending(pReader) ){ + /* A pending-terms seg-reader for an FTS4 table that uses order=desc. + ** Pending-terms doclists are always built up in ascending order, so + ** we have to iterate through them backwards here. */ + u8 bEof = 0; + if( ppOffsetList ){ + *ppOffsetList = pReader->pOffsetList; + *pnOffsetList = pReader->nOffsetList - 1; + } + sqlite3Fts3DoclistPrev(0, + pReader->aDoclist, pReader->nDoclist, &p, &pReader->iDocid, + &pReader->nOffsetList, &bEof + ); + if( bEof ){ + pReader->pOffsetList = 0; + }else{ + pReader->pOffsetList = p; + } + }else{ + char *pEnd = &pReader->aDoclist[pReader->nDoclist]; + + /* Pointer p currently points at the first byte of an offset list. The + ** following block advances it to point one byte past the end of + ** the same offset list. */ + while( 1 ){ + + /* The following line of code (and the "p++" below the while() loop) is + ** normally all that is required to move pointer p to the desired + ** position. The exception is if this node is being loaded from disk + ** incrementally and pointer "p" now points to the first byte past + ** the populated part of pReader->aNode[]. + */ + while( *p | c ) c = *p++ & 0x80; + assert( *p==0 ); + + if( pReader->pBlob==0 || p<&pReader->aNode[pReader->nPopulate] ) break; + rc = fts3SegReaderIncrRead(pReader); + if( rc!=SQLITE_OK ) return rc; + } + p++; + + /* If required, populate the output variables with a pointer to and the + ** size of the previous offset-list. + */ + if( ppOffsetList ){ + *ppOffsetList = pReader->pOffsetList; + *pnOffsetList = (int)(p - pReader->pOffsetList - 1); + } + + /* List may have been edited in place by fts3EvalNearTrim() */ + while( p=pEnd ){ + pReader->pOffsetList = 0; + }else{ + rc = fts3SegReaderRequire(pReader, p, FTS3_VARINT_MAX); + if( rc==SQLITE_OK ){ + u64 iDelta; + pReader->pOffsetList = p + sqlite3Fts3GetVarintU(p, &iDelta); + if( pTab->bDescIdx ){ + pReader->iDocid = (i64)((u64)pReader->iDocid - iDelta); + }else{ + pReader->iDocid = (i64)((u64)pReader->iDocid + iDelta); + } + } + } + } + + return rc; +} + + +SQLITE_PRIVATE int sqlite3Fts3MsrOvfl( + Fts3Cursor *pCsr, + Fts3MultiSegReader *pMsr, + int *pnOvfl +){ + Fts3Table *p = (Fts3Table*)pCsr->base.pVtab; + int nOvfl = 0; + int ii; + int rc = SQLITE_OK; + int pgsz = p->nPgsz; + + assert( p->bFts4 ); + assert( pgsz>0 ); + + for(ii=0; rc==SQLITE_OK && iinSegment; ii++){ + Fts3SegReader *pReader = pMsr->apSegment[ii]; + if( !fts3SegReaderIsPending(pReader) + && !fts3SegReaderIsRootOnly(pReader) + ){ + sqlite3_int64 jj; + for(jj=pReader->iStartBlock; jj<=pReader->iLeafEndBlock; jj++){ + int nBlob; + rc = sqlite3Fts3ReadBlock(p, jj, 0, &nBlob, 0); + if( rc!=SQLITE_OK ) break; + if( (nBlob+35)>pgsz ){ + nOvfl += (nBlob + 34)/pgsz; + } + } + } + } + *pnOvfl = nOvfl; + return rc; +} + +/* +** Free all allocations associated with the iterator passed as the +** second argument. +*/ +SQLITE_PRIVATE void sqlite3Fts3SegReaderFree(Fts3SegReader *pReader){ + if( pReader ){ + sqlite3_free(pReader->zTerm); + if( !fts3SegReaderIsRootOnly(pReader) ){ + sqlite3_free(pReader->aNode); + } + sqlite3_blob_close(pReader->pBlob); + } + sqlite3_free(pReader); +} + +/* +** Allocate a new SegReader object. +*/ +SQLITE_PRIVATE int sqlite3Fts3SegReaderNew( + int iAge, /* Segment "age". */ + int bLookup, /* True for a lookup only */ + sqlite3_int64 iStartLeaf, /* First leaf to traverse */ + sqlite3_int64 iEndLeaf, /* Final leaf to traverse */ + sqlite3_int64 iEndBlock, /* Final block of segment */ + const char *zRoot, /* Buffer containing root node */ + int nRoot, /* Size of buffer containing root node */ + Fts3SegReader **ppReader /* OUT: Allocated Fts3SegReader */ +){ + Fts3SegReader *pReader; /* Newly allocated SegReader object */ + int nExtra = 0; /* Bytes to allocate segment root node */ + + assert( zRoot!=0 || nRoot==0 ); +#ifdef CORRUPT_DB + assert( zRoot!=0 || CORRUPT_DB ); +#endif + + if( iStartLeaf==0 ){ + if( iEndLeaf!=0 ) return FTS_CORRUPT_VTAB; + nExtra = nRoot + FTS3_NODE_PADDING; + } + + pReader = (Fts3SegReader *)sqlite3_malloc64(sizeof(Fts3SegReader) + nExtra); + if( !pReader ){ + return SQLITE_NOMEM; + } + memset(pReader, 0, sizeof(Fts3SegReader)); + pReader->iIdx = iAge; + pReader->bLookup = bLookup!=0; + pReader->iStartBlock = iStartLeaf; + pReader->iLeafEndBlock = iEndLeaf; + pReader->iEndBlock = iEndBlock; + + if( nExtra ){ + /* The entire segment is stored in the root node. */ + pReader->aNode = (char *)&pReader[1]; + pReader->rootOnly = 1; + pReader->nNode = nRoot; + if( nRoot ) memcpy(pReader->aNode, zRoot, nRoot); + memset(&pReader->aNode[nRoot], 0, FTS3_NODE_PADDING); + }else{ + pReader->iCurrentBlock = iStartLeaf-1; + } + *ppReader = pReader; + return SQLITE_OK; +} + +/* +** This is a comparison function used as a qsort() callback when sorting +** an array of pending terms by term. This occurs as part of flushing +** the contents of the pending-terms hash table to the database. +*/ +static int SQLITE_CDECL fts3CompareElemByTerm( + const void *lhs, + const void *rhs +){ + char *z1 = fts3HashKey(*(Fts3HashElem **)lhs); + char *z2 = fts3HashKey(*(Fts3HashElem **)rhs); + int n1 = fts3HashKeysize(*(Fts3HashElem **)lhs); + int n2 = fts3HashKeysize(*(Fts3HashElem **)rhs); + + int n = (n1aIndex */ + const char *zTerm, /* Term to search for */ + int nTerm, /* Size of buffer zTerm */ + int bPrefix, /* True for a prefix iterator */ + Fts3SegReader **ppReader /* OUT: SegReader for pending-terms */ +){ + Fts3SegReader *pReader = 0; /* Fts3SegReader object to return */ + Fts3HashElem *pE; /* Iterator variable */ + Fts3HashElem **aElem = 0; /* Array of term hash entries to scan */ + int nElem = 0; /* Size of array at aElem */ + int rc = SQLITE_OK; /* Return Code */ + Fts3Hash *pHash; + + pHash = &p->aIndex[iIndex].hPending; + if( bPrefix ){ + int nAlloc = 0; /* Size of allocated array at aElem */ + + for(pE=fts3HashFirst(pHash); pE; pE=fts3HashNext(pE)){ + char *zKey = (char *)fts3HashKey(pE); + int nKey = fts3HashKeysize(pE); + if( nTerm==0 || (nKey>=nTerm && 0==memcmp(zKey, zTerm, nTerm)) ){ + if( nElem==nAlloc ){ + Fts3HashElem **aElem2; + nAlloc += 16; + aElem2 = (Fts3HashElem **)sqlite3_realloc64( + aElem, nAlloc*sizeof(Fts3HashElem *) + ); + if( !aElem2 ){ + rc = SQLITE_NOMEM; + nElem = 0; + break; + } + aElem = aElem2; + } + + aElem[nElem++] = pE; + } + } + + /* If more than one term matches the prefix, sort the Fts3HashElem + ** objects in term order using qsort(). This uses the same comparison + ** callback as is used when flushing terms to disk. + */ + if( nElem>1 ){ + qsort(aElem, nElem, sizeof(Fts3HashElem *), fts3CompareElemByTerm); + } + + }else{ + /* The query is a simple term lookup that matches at most one term in + ** the index. All that is required is a straight hash-lookup. + ** + ** Because the stack address of pE may be accessed via the aElem pointer + ** below, the "Fts3HashElem *pE" must be declared so that it is valid + ** within this entire function, not just this "else{...}" block. + */ + pE = fts3HashFindElem(pHash, zTerm, nTerm); + if( pE ){ + aElem = &pE; + nElem = 1; + } + } + + if( nElem>0 ){ + sqlite3_int64 nByte; + nByte = sizeof(Fts3SegReader) + (nElem+1)*sizeof(Fts3HashElem *); + pReader = (Fts3SegReader *)sqlite3_malloc64(nByte); + if( !pReader ){ + rc = SQLITE_NOMEM; + }else{ + memset(pReader, 0, nByte); + pReader->iIdx = 0x7FFFFFFF; + pReader->ppNextElem = (Fts3HashElem **)&pReader[1]; + memcpy(pReader->ppNextElem, aElem, nElem*sizeof(Fts3HashElem *)); + } + } + + if( bPrefix ){ + sqlite3_free(aElem); + } + *ppReader = pReader; + return rc; +} + +/* +** Compare the entries pointed to by two Fts3SegReader structures. +** Comparison is as follows: +** +** 1) EOF is greater than not EOF. +** +** 2) The current terms (if any) are compared using memcmp(). If one +** term is a prefix of another, the longer term is considered the +** larger. +** +** 3) By segment age. An older segment is considered larger. +*/ +static int fts3SegReaderCmp(Fts3SegReader *pLhs, Fts3SegReader *pRhs){ + int rc; + if( pLhs->aNode && pRhs->aNode ){ + int rc2 = pLhs->nTerm - pRhs->nTerm; + if( rc2<0 ){ + rc = memcmp(pLhs->zTerm, pRhs->zTerm, pLhs->nTerm); + }else{ + rc = memcmp(pLhs->zTerm, pRhs->zTerm, pRhs->nTerm); + } + if( rc==0 ){ + rc = rc2; + } + }else{ + rc = (pLhs->aNode==0) - (pRhs->aNode==0); + } + if( rc==0 ){ + rc = pRhs->iIdx - pLhs->iIdx; + } + assert_fts3_nc( rc!=0 ); + return rc; +} + +/* +** A different comparison function for SegReader structures. In this +** version, it is assumed that each SegReader points to an entry in +** a doclist for identical terms. Comparison is made as follows: +** +** 1) EOF (end of doclist in this case) is greater than not EOF. +** +** 2) By current docid. +** +** 3) By segment age. An older segment is considered larger. +*/ +static int fts3SegReaderDoclistCmp(Fts3SegReader *pLhs, Fts3SegReader *pRhs){ + int rc = (pLhs->pOffsetList==0)-(pRhs->pOffsetList==0); + if( rc==0 ){ + if( pLhs->iDocid==pRhs->iDocid ){ + rc = pRhs->iIdx - pLhs->iIdx; + }else{ + rc = (pLhs->iDocid > pRhs->iDocid) ? 1 : -1; + } + } + assert( pLhs->aNode && pRhs->aNode ); + return rc; +} +static int fts3SegReaderDoclistCmpRev(Fts3SegReader *pLhs, Fts3SegReader *pRhs){ + int rc = (pLhs->pOffsetList==0)-(pRhs->pOffsetList==0); + if( rc==0 ){ + if( pLhs->iDocid==pRhs->iDocid ){ + rc = pRhs->iIdx - pLhs->iIdx; + }else{ + rc = (pLhs->iDocid < pRhs->iDocid) ? 1 : -1; + } + } + assert( pLhs->aNode && pRhs->aNode ); + return rc; +} + +/* +** Compare the term that the Fts3SegReader object passed as the first argument +** points to with the term specified by arguments zTerm and nTerm. +** +** If the pSeg iterator is already at EOF, return 0. Otherwise, return +** -ve if the pSeg term is less than zTerm/nTerm, 0 if the two terms are +** equal, or +ve if the pSeg term is greater than zTerm/nTerm. +*/ +static int fts3SegReaderTermCmp( + Fts3SegReader *pSeg, /* Segment reader object */ + const char *zTerm, /* Term to compare to */ + int nTerm /* Size of term zTerm in bytes */ +){ + int res = 0; + if( pSeg->aNode ){ + if( pSeg->nTerm>nTerm ){ + res = memcmp(pSeg->zTerm, zTerm, nTerm); + }else{ + res = memcmp(pSeg->zTerm, zTerm, pSeg->nTerm); + } + if( res==0 ){ + res = pSeg->nTerm-nTerm; + } + } + return res; +} + +/* +** Argument apSegment is an array of nSegment elements. It is known that +** the final (nSegment-nSuspect) members are already in sorted order +** (according to the comparison function provided). This function shuffles +** the array around until all entries are in sorted order. +*/ +static void fts3SegReaderSort( + Fts3SegReader **apSegment, /* Array to sort entries of */ + int nSegment, /* Size of apSegment array */ + int nSuspect, /* Unsorted entry count */ + int (*xCmp)(Fts3SegReader *, Fts3SegReader *) /* Comparison function */ +){ + int i; /* Iterator variable */ + + assert( nSuspect<=nSegment ); + + if( nSuspect==nSegment ) nSuspect--; + for(i=nSuspect-1; i>=0; i--){ + int j; + for(j=i; j<(nSegment-1); j++){ + Fts3SegReader *pTmp; + if( xCmp(apSegment[j], apSegment[j+1])<0 ) break; + pTmp = apSegment[j+1]; + apSegment[j+1] = apSegment[j]; + apSegment[j] = pTmp; + } + } + +#ifndef NDEBUG + /* Check that the list really is sorted now. */ + for(i=0; i<(nSuspect-1); i++){ + assert( xCmp(apSegment[i], apSegment[i+1])<0 ); + } +#endif +} + +/* +** Insert a record into the %_segments table. +*/ +static int fts3WriteSegment( + Fts3Table *p, /* Virtual table handle */ + sqlite3_int64 iBlock, /* Block id for new block */ + char *z, /* Pointer to buffer containing block data */ + int n /* Size of buffer z in bytes */ +){ + sqlite3_stmt *pStmt; + int rc = fts3SqlStmt(p, SQL_INSERT_SEGMENTS, &pStmt, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pStmt, 1, iBlock); + sqlite3_bind_blob(pStmt, 2, z, n, SQLITE_STATIC); + sqlite3_step(pStmt); + rc = sqlite3_reset(pStmt); + sqlite3_bind_null(pStmt, 2); + } + return rc; +} + +/* +** Find the largest relative level number in the table. If successful, set +** *pnMax to this value and return SQLITE_OK. Otherwise, if an error occurs, +** set *pnMax to zero and return an SQLite error code. +*/ +SQLITE_PRIVATE int sqlite3Fts3MaxLevel(Fts3Table *p, int *pnMax){ + int rc; + int mxLevel = 0; + sqlite3_stmt *pStmt = 0; + + rc = fts3SqlStmt(p, SQL_SELECT_MXLEVEL, &pStmt, 0); + if( rc==SQLITE_OK ){ + if( SQLITE_ROW==sqlite3_step(pStmt) ){ + mxLevel = sqlite3_column_int(pStmt, 0); + } + rc = sqlite3_reset(pStmt); + } + *pnMax = mxLevel; + return rc; +} + +/* +** Insert a record into the %_segdir table. +*/ +static int fts3WriteSegdir( + Fts3Table *p, /* Virtual table handle */ + sqlite3_int64 iLevel, /* Value for "level" field (absolute level) */ + int iIdx, /* Value for "idx" field */ + sqlite3_int64 iStartBlock, /* Value for "start_block" field */ + sqlite3_int64 iLeafEndBlock, /* Value for "leaves_end_block" field */ + sqlite3_int64 iEndBlock, /* Value for "end_block" field */ + sqlite3_int64 nLeafData, /* Bytes of leaf data in segment */ + char *zRoot, /* Blob value for "root" field */ + int nRoot /* Number of bytes in buffer zRoot */ +){ + sqlite3_stmt *pStmt; + int rc = fts3SqlStmt(p, SQL_INSERT_SEGDIR, &pStmt, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pStmt, 1, iLevel); + sqlite3_bind_int(pStmt, 2, iIdx); + sqlite3_bind_int64(pStmt, 3, iStartBlock); + sqlite3_bind_int64(pStmt, 4, iLeafEndBlock); + if( nLeafData==0 ){ + sqlite3_bind_int64(pStmt, 5, iEndBlock); + }else{ + char *zEnd = sqlite3_mprintf("%lld %lld", iEndBlock, nLeafData); + if( !zEnd ) return SQLITE_NOMEM; + sqlite3_bind_text(pStmt, 5, zEnd, -1, sqlite3_free); + } + sqlite3_bind_blob(pStmt, 6, zRoot, nRoot, SQLITE_STATIC); + sqlite3_step(pStmt); + rc = sqlite3_reset(pStmt); + sqlite3_bind_null(pStmt, 6); + } + return rc; +} + +/* +** Return the size of the common prefix (if any) shared by zPrev and +** zNext, in bytes. For example, +** +** fts3PrefixCompress("abc", 3, "abcdef", 6) // returns 3 +** fts3PrefixCompress("abX", 3, "abcdef", 6) // returns 2 +** fts3PrefixCompress("abX", 3, "Xbcdef", 6) // returns 0 +*/ +static int fts3PrefixCompress( + const char *zPrev, /* Buffer containing previous term */ + int nPrev, /* Size of buffer zPrev in bytes */ + const char *zNext, /* Buffer containing next term */ + int nNext /* Size of buffer zNext in bytes */ +){ + int n; + for(n=0; nnData; /* Current size of node in bytes */ + int nReq = nData; /* Required space after adding zTerm */ + int nPrefix; /* Number of bytes of prefix compression */ + int nSuffix; /* Suffix length */ + + nPrefix = fts3PrefixCompress(pTree->zTerm, pTree->nTerm, zTerm, nTerm); + nSuffix = nTerm-nPrefix; + + /* If nSuffix is zero or less, then zTerm/nTerm must be a prefix of + ** pWriter->zTerm/pWriter->nTerm. i.e. must be equal to or less than when + ** compared with BINARY collation. This indicates corruption. */ + if( nSuffix<=0 ) return FTS_CORRUPT_VTAB; + + nReq += sqlite3Fts3VarintLen(nPrefix)+sqlite3Fts3VarintLen(nSuffix)+nSuffix; + if( nReq<=p->nNodeSize || !pTree->zTerm ){ + + if( nReq>p->nNodeSize ){ + /* An unusual case: this is the first term to be added to the node + ** and the static node buffer (p->nNodeSize bytes) is not large + ** enough. Use a separately malloced buffer instead This wastes + ** p->nNodeSize bytes, but since this scenario only comes about when + ** the database contain two terms that share a prefix of almost 2KB, + ** this is not expected to be a serious problem. + */ + assert( pTree->aData==(char *)&pTree[1] ); + pTree->aData = (char *)sqlite3_malloc64(nReq); + if( !pTree->aData ){ + return SQLITE_NOMEM; + } + } + + if( pTree->zTerm ){ + /* There is no prefix-length field for first term in a node */ + nData += sqlite3Fts3PutVarint(&pTree->aData[nData], nPrefix); + } + + nData += sqlite3Fts3PutVarint(&pTree->aData[nData], nSuffix); + memcpy(&pTree->aData[nData], &zTerm[nPrefix], nSuffix); + pTree->nData = nData + nSuffix; + pTree->nEntry++; + + if( isCopyTerm ){ + if( pTree->nMalloczMalloc, (i64)nTerm*2); + if( !zNew ){ + return SQLITE_NOMEM; + } + pTree->nMalloc = nTerm*2; + pTree->zMalloc = zNew; + } + pTree->zTerm = pTree->zMalloc; + memcpy(pTree->zTerm, zTerm, nTerm); + pTree->nTerm = nTerm; + }else{ + pTree->zTerm = (char *)zTerm; + pTree->nTerm = nTerm; + } + return SQLITE_OK; + } + } + + /* If control flows to here, it was not possible to append zTerm to the + ** current node. Create a new node (a right-sibling of the current node). + ** If this is the first node in the tree, the term is added to it. + ** + ** Otherwise, the term is not added to the new node, it is left empty for + ** now. Instead, the term is inserted into the parent of pTree. If pTree + ** has no parent, one is created here. + */ + pNew = (SegmentNode *)sqlite3_malloc64(sizeof(SegmentNode) + p->nNodeSize); + if( !pNew ){ + return SQLITE_NOMEM; + } + memset(pNew, 0, sizeof(SegmentNode)); + pNew->nData = 1 + FTS3_VARINT_MAX; + pNew->aData = (char *)&pNew[1]; + + if( pTree ){ + SegmentNode *pParent = pTree->pParent; + rc = fts3NodeAddTerm(p, &pParent, isCopyTerm, zTerm, nTerm); + if( pTree->pParent==0 ){ + pTree->pParent = pParent; + } + pTree->pRight = pNew; + pNew->pLeftmost = pTree->pLeftmost; + pNew->pParent = pParent; + pNew->zMalloc = pTree->zMalloc; + pNew->nMalloc = pTree->nMalloc; + pTree->zMalloc = 0; + }else{ + pNew->pLeftmost = pNew; + rc = fts3NodeAddTerm(p, &pNew, isCopyTerm, zTerm, nTerm); + } + + *ppTree = pNew; + return rc; +} + +/* +** Helper function for fts3NodeWrite(). +*/ +static int fts3TreeFinishNode( + SegmentNode *pTree, + int iHeight, + sqlite3_int64 iLeftChild +){ + int nStart; + assert( iHeight>=1 && iHeight<128 ); + nStart = FTS3_VARINT_MAX - sqlite3Fts3VarintLen(iLeftChild); + pTree->aData[nStart] = (char)iHeight; + sqlite3Fts3PutVarint(&pTree->aData[nStart+1], iLeftChild); + return nStart; +} + +/* +** Write the buffer for the segment node pTree and all of its peers to the +** database. Then call this function recursively to write the parent of +** pTree and its peers to the database. +** +** Except, if pTree is a root node, do not write it to the database. Instead, +** set output variables *paRoot and *pnRoot to contain the root node. +** +** If successful, SQLITE_OK is returned and output variable *piLast is +** set to the largest blockid written to the database (or zero if no +** blocks were written to the db). Otherwise, an SQLite error code is +** returned. +*/ +static int fts3NodeWrite( + Fts3Table *p, /* Virtual table handle */ + SegmentNode *pTree, /* SegmentNode handle */ + int iHeight, /* Height of this node in tree */ + sqlite3_int64 iLeaf, /* Block id of first leaf node */ + sqlite3_int64 iFree, /* Block id of next free slot in %_segments */ + sqlite3_int64 *piLast, /* OUT: Block id of last entry written */ + char **paRoot, /* OUT: Data for root node */ + int *pnRoot /* OUT: Size of root node in bytes */ +){ + int rc = SQLITE_OK; + + if( !pTree->pParent ){ + /* Root node of the tree. */ + int nStart = fts3TreeFinishNode(pTree, iHeight, iLeaf); + *piLast = iFree-1; + *pnRoot = pTree->nData - nStart; + *paRoot = &pTree->aData[nStart]; + }else{ + SegmentNode *pIter; + sqlite3_int64 iNextFree = iFree; + sqlite3_int64 iNextLeaf = iLeaf; + for(pIter=pTree->pLeftmost; pIter && rc==SQLITE_OK; pIter=pIter->pRight){ + int nStart = fts3TreeFinishNode(pIter, iHeight, iNextLeaf); + int nWrite = pIter->nData - nStart; + + rc = fts3WriteSegment(p, iNextFree, &pIter->aData[nStart], nWrite); + iNextFree++; + iNextLeaf += (pIter->nEntry+1); + } + if( rc==SQLITE_OK ){ + assert( iNextLeaf==iFree ); + rc = fts3NodeWrite( + p, pTree->pParent, iHeight+1, iFree, iNextFree, piLast, paRoot, pnRoot + ); + } + } + + return rc; +} + +/* +** Free all memory allocations associated with the tree pTree. +*/ +static void fts3NodeFree(SegmentNode *pTree){ + if( pTree ){ + SegmentNode *p = pTree->pLeftmost; + fts3NodeFree(p->pParent); + while( p ){ + SegmentNode *pRight = p->pRight; + if( p->aData!=(char *)&p[1] ){ + sqlite3_free(p->aData); + } + assert( pRight==0 || p->zMalloc==0 ); + sqlite3_free(p->zMalloc); + sqlite3_free(p); + p = pRight; + } + } +} + +/* +** Add a term to the segment being constructed by the SegmentWriter object +** *ppWriter. When adding the first term to a segment, *ppWriter should +** be passed NULL. This function will allocate a new SegmentWriter object +** and return it via the input/output variable *ppWriter in this case. +** +** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code. +*/ +static int fts3SegWriterAdd( + Fts3Table *p, /* Virtual table handle */ + SegmentWriter **ppWriter, /* IN/OUT: SegmentWriter handle */ + int isCopyTerm, /* True if buffer zTerm must be copied */ + const char *zTerm, /* Pointer to buffer containing term */ + int nTerm, /* Size of term in bytes */ + const char *aDoclist, /* Pointer to buffer containing doclist */ + int nDoclist /* Size of doclist in bytes */ +){ + int nPrefix; /* Size of term prefix in bytes */ + int nSuffix; /* Size of term suffix in bytes */ + i64 nReq; /* Number of bytes required on leaf page */ + int nData; + SegmentWriter *pWriter = *ppWriter; + + if( !pWriter ){ + int rc; + sqlite3_stmt *pStmt; + + /* Allocate the SegmentWriter structure */ + pWriter = (SegmentWriter *)sqlite3_malloc64(sizeof(SegmentWriter)); + if( !pWriter ) return SQLITE_NOMEM; + memset(pWriter, 0, sizeof(SegmentWriter)); + *ppWriter = pWriter; + + /* Allocate a buffer in which to accumulate data */ + pWriter->aData = (char *)sqlite3_malloc64(p->nNodeSize); + if( !pWriter->aData ) return SQLITE_NOMEM; + pWriter->nSize = p->nNodeSize; + + /* Find the next free blockid in the %_segments table */ + rc = fts3SqlStmt(p, SQL_NEXT_SEGMENTS_ID, &pStmt, 0); + if( rc!=SQLITE_OK ) return rc; + if( SQLITE_ROW==sqlite3_step(pStmt) ){ + pWriter->iFree = sqlite3_column_int64(pStmt, 0); + pWriter->iFirst = pWriter->iFree; + } + rc = sqlite3_reset(pStmt); + if( rc!=SQLITE_OK ) return rc; + } + nData = pWriter->nData; + + nPrefix = fts3PrefixCompress(pWriter->zTerm, pWriter->nTerm, zTerm, nTerm); + nSuffix = nTerm-nPrefix; + + /* If nSuffix is zero or less, then zTerm/nTerm must be a prefix of + ** pWriter->zTerm/pWriter->nTerm. i.e. must be equal to or less than when + ** compared with BINARY collation. This indicates corruption. */ + if( nSuffix<=0 ) return FTS_CORRUPT_VTAB; + + /* Figure out how many bytes are required by this new entry */ + nReq = sqlite3Fts3VarintLen(nPrefix) + /* varint containing prefix size */ + sqlite3Fts3VarintLen(nSuffix) + /* varint containing suffix size */ + nSuffix + /* Term suffix */ + sqlite3Fts3VarintLen(nDoclist) + /* Size of doclist */ + nDoclist; /* Doclist data */ + + if( nData>0 && nData+nReq>p->nNodeSize ){ + int rc; + + /* The current leaf node is full. Write it out to the database. */ + if( pWriter->iFree==LARGEST_INT64 ) return FTS_CORRUPT_VTAB; + rc = fts3WriteSegment(p, pWriter->iFree++, pWriter->aData, nData); + if( rc!=SQLITE_OK ) return rc; + p->nLeafAdd++; + + /* Add the current term to the interior node tree. The term added to + ** the interior tree must: + ** + ** a) be greater than the largest term on the leaf node just written + ** to the database (still available in pWriter->zTerm), and + ** + ** b) be less than or equal to the term about to be added to the new + ** leaf node (zTerm/nTerm). + ** + ** In other words, it must be the prefix of zTerm 1 byte longer than + ** the common prefix (if any) of zTerm and pWriter->zTerm. + */ + assert( nPrefixpTree, isCopyTerm, zTerm, nPrefix+1); + if( rc!=SQLITE_OK ) return rc; + + nData = 0; + pWriter->nTerm = 0; + + nPrefix = 0; + nSuffix = nTerm; + nReq = 1 + /* varint containing prefix size */ + sqlite3Fts3VarintLen(nTerm) + /* varint containing suffix size */ + nTerm + /* Term suffix */ + sqlite3Fts3VarintLen(nDoclist) + /* Size of doclist */ + nDoclist; /* Doclist data */ + } + + /* Increase the total number of bytes written to account for the new entry. */ + pWriter->nLeafData += nReq; + + /* If the buffer currently allocated is too small for this entry, realloc + ** the buffer to make it large enough. + */ + if( nReq>pWriter->nSize ){ + char *aNew = sqlite3_realloc64(pWriter->aData, nReq); + if( !aNew ) return SQLITE_NOMEM; + pWriter->aData = aNew; + pWriter->nSize = nReq; + } + assert( nData+nReq<=pWriter->nSize ); + + /* Append the prefix-compressed term and doclist to the buffer. */ + nData += sqlite3Fts3PutVarint(&pWriter->aData[nData], nPrefix); + nData += sqlite3Fts3PutVarint(&pWriter->aData[nData], nSuffix); + assert( nSuffix>0 ); + memcpy(&pWriter->aData[nData], &zTerm[nPrefix], nSuffix); + nData += nSuffix; + nData += sqlite3Fts3PutVarint(&pWriter->aData[nData], nDoclist); + assert( nDoclist>0 ); + memcpy(&pWriter->aData[nData], aDoclist, nDoclist); + pWriter->nData = nData + nDoclist; + + /* Save the current term so that it can be used to prefix-compress the next. + ** If the isCopyTerm parameter is true, then the buffer pointed to by + ** zTerm is transient, so take a copy of the term data. Otherwise, just + ** store a copy of the pointer. + */ + if( isCopyTerm ){ + if( nTerm>pWriter->nMalloc ){ + char *zNew = sqlite3_realloc64(pWriter->zMalloc, (i64)nTerm*2); + if( !zNew ){ + return SQLITE_NOMEM; + } + pWriter->nMalloc = nTerm*2; + pWriter->zMalloc = zNew; + pWriter->zTerm = zNew; + } + assert( pWriter->zTerm==pWriter->zMalloc ); + assert( nTerm>0 ); + memcpy(pWriter->zTerm, zTerm, nTerm); + }else{ + pWriter->zTerm = (char *)zTerm; + } + pWriter->nTerm = nTerm; + + return SQLITE_OK; +} + +/* +** Flush all data associated with the SegmentWriter object pWriter to the +** database. This function must be called after all terms have been added +** to the segment using fts3SegWriterAdd(). If successful, SQLITE_OK is +** returned. Otherwise, an SQLite error code. +*/ +static int fts3SegWriterFlush( + Fts3Table *p, /* Virtual table handle */ + SegmentWriter *pWriter, /* SegmentWriter to flush to the db */ + sqlite3_int64 iLevel, /* Value for 'level' column of %_segdir */ + int iIdx /* Value for 'idx' column of %_segdir */ +){ + int rc; /* Return code */ + if( pWriter->pTree ){ + sqlite3_int64 iLast = 0; /* Largest block id written to database */ + sqlite3_int64 iLastLeaf; /* Largest leaf block id written to db */ + char *zRoot = NULL; /* Pointer to buffer containing root node */ + int nRoot = 0; /* Size of buffer zRoot */ + + iLastLeaf = pWriter->iFree; + rc = fts3WriteSegment(p, pWriter->iFree++, pWriter->aData, pWriter->nData); + if( rc==SQLITE_OK ){ + rc = fts3NodeWrite(p, pWriter->pTree, 1, + pWriter->iFirst, pWriter->iFree, &iLast, &zRoot, &nRoot); + } + if( rc==SQLITE_OK ){ + rc = fts3WriteSegdir(p, iLevel, iIdx, + pWriter->iFirst, iLastLeaf, iLast, pWriter->nLeafData, zRoot, nRoot); + } + }else{ + /* The entire tree fits on the root node. Write it to the segdir table. */ + rc = fts3WriteSegdir(p, iLevel, iIdx, + 0, 0, 0, pWriter->nLeafData, pWriter->aData, pWriter->nData); + } + p->nLeafAdd++; + return rc; +} + +/* +** Release all memory held by the SegmentWriter object passed as the +** first argument. +*/ +static void fts3SegWriterFree(SegmentWriter *pWriter){ + if( pWriter ){ + sqlite3_free(pWriter->aData); + sqlite3_free(pWriter->zMalloc); + fts3NodeFree(pWriter->pTree); + sqlite3_free(pWriter); + } +} + +/* +** The first value in the apVal[] array is assumed to contain an integer. +** This function tests if there exist any documents with docid values that +** are different from that integer. i.e. if deleting the document with docid +** pRowid would mean the FTS3 table were empty. +** +** If successful, *pisEmpty is set to true if the table is empty except for +** document pRowid, or false otherwise, and SQLITE_OK is returned. If an +** error occurs, an SQLite error code is returned. +*/ +static int fts3IsEmpty(Fts3Table *p, sqlite3_value *pRowid, int *pisEmpty){ + sqlite3_stmt *pStmt; + int rc; + if( p->zContentTbl ){ + /* If using the content=xxx option, assume the table is never empty */ + *pisEmpty = 0; + rc = SQLITE_OK; + }else{ + rc = fts3SqlStmt(p, SQL_IS_EMPTY, &pStmt, &pRowid); + if( rc==SQLITE_OK ){ + if( SQLITE_ROW==sqlite3_step(pStmt) ){ + *pisEmpty = sqlite3_column_int(pStmt, 0); + } + rc = sqlite3_reset(pStmt); + } + } + return rc; +} + +/* +** Set *pnMax to the largest segment level in the database for the index +** iIndex. +** +** Segment levels are stored in the 'level' column of the %_segdir table. +** +** Return SQLITE_OK if successful, or an SQLite error code if not. +*/ +static int fts3SegmentMaxLevel( + Fts3Table *p, + int iLangid, + int iIndex, + sqlite3_int64 *pnMax +){ + sqlite3_stmt *pStmt; + int rc; + assert( iIndex>=0 && iIndexnIndex ); + + /* Set pStmt to the compiled version of: + ** + ** SELECT max(level) FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ? + ** + ** (1024 is actually the value of macro FTS3_SEGDIR_PREFIXLEVEL_STR). + */ + rc = fts3SqlStmt(p, SQL_SELECT_SEGDIR_MAX_LEVEL, &pStmt, 0); + if( rc!=SQLITE_OK ) return rc; + sqlite3_bind_int64(pStmt, 1, getAbsoluteLevel(p, iLangid, iIndex, 0)); + sqlite3_bind_int64(pStmt, 2, + getAbsoluteLevel(p, iLangid, iIndex, FTS3_SEGDIR_MAXLEVEL-1) + ); + if( SQLITE_ROW==sqlite3_step(pStmt) ){ + *pnMax = sqlite3_column_int64(pStmt, 0); + } + return sqlite3_reset(pStmt); +} + +/* +** iAbsLevel is an absolute level that may be assumed to exist within +** the database. This function checks if it is the largest level number +** within its index. Assuming no error occurs, *pbMax is set to 1 if +** iAbsLevel is indeed the largest level, or 0 otherwise, and SQLITE_OK +** is returned. If an error occurs, an error code is returned and the +** final value of *pbMax is undefined. +*/ +static int fts3SegmentIsMaxLevel(Fts3Table *p, i64 iAbsLevel, int *pbMax){ + + /* Set pStmt to the compiled version of: + ** + ** SELECT max(level) FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ? + ** + ** (1024 is actually the value of macro FTS3_SEGDIR_PREFIXLEVEL_STR). + */ + sqlite3_stmt *pStmt; + int rc = fts3SqlStmt(p, SQL_SELECT_SEGDIR_MAX_LEVEL, &pStmt, 0); + if( rc!=SQLITE_OK ) return rc; + sqlite3_bind_int64(pStmt, 1, iAbsLevel+1); + sqlite3_bind_int64(pStmt, 2, + (((u64)iAbsLevel/FTS3_SEGDIR_MAXLEVEL)+1) * FTS3_SEGDIR_MAXLEVEL + ); + + *pbMax = 0; + if( SQLITE_ROW==sqlite3_step(pStmt) ){ + *pbMax = sqlite3_column_type(pStmt, 0)==SQLITE_NULL; + } + return sqlite3_reset(pStmt); +} + +/* +** Delete all entries in the %_segments table associated with the segment +** opened with seg-reader pSeg. This function does not affect the contents +** of the %_segdir table. +*/ +static int fts3DeleteSegment( + Fts3Table *p, /* FTS table handle */ + Fts3SegReader *pSeg /* Segment to delete */ +){ + int rc = SQLITE_OK; /* Return code */ + if( pSeg->iStartBlock ){ + sqlite3_stmt *pDelete; /* SQL statement to delete rows */ + rc = fts3SqlStmt(p, SQL_DELETE_SEGMENTS_RANGE, &pDelete, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pDelete, 1, pSeg->iStartBlock); + sqlite3_bind_int64(pDelete, 2, pSeg->iEndBlock); + sqlite3_step(pDelete); + rc = sqlite3_reset(pDelete); + } + } + return rc; +} + +/* +** This function is used after merging multiple segments into a single large +** segment to delete the old, now redundant, segment b-trees. Specifically, +** it: +** +** 1) Deletes all %_segments entries for the segments associated with +** each of the SegReader objects in the array passed as the third +** argument, and +** +** 2) deletes all %_segdir entries with level iLevel, or all %_segdir +** entries regardless of level if (iLevel<0). +** +** SQLITE_OK is returned if successful, otherwise an SQLite error code. +*/ +static int fts3DeleteSegdir( + Fts3Table *p, /* Virtual table handle */ + int iLangid, /* Language id */ + int iIndex, /* Index for p->aIndex */ + int iLevel, /* Level of %_segdir entries to delete */ + Fts3SegReader **apSegment, /* Array of SegReader objects */ + int nReader /* Size of array apSegment */ +){ + int rc = SQLITE_OK; /* Return Code */ + int i; /* Iterator variable */ + sqlite3_stmt *pDelete = 0; /* SQL statement to delete rows */ + + for(i=0; rc==SQLITE_OK && i=0 || iLevel==FTS3_SEGCURSOR_ALL ); + if( iLevel==FTS3_SEGCURSOR_ALL ){ + rc = fts3SqlStmt(p, SQL_DELETE_SEGDIR_RANGE, &pDelete, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pDelete, 1, getAbsoluteLevel(p, iLangid, iIndex, 0)); + sqlite3_bind_int64(pDelete, 2, + getAbsoluteLevel(p, iLangid, iIndex, FTS3_SEGDIR_MAXLEVEL-1) + ); + } + }else{ + rc = fts3SqlStmt(p, SQL_DELETE_SEGDIR_LEVEL, &pDelete, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64( + pDelete, 1, getAbsoluteLevel(p, iLangid, iIndex, iLevel) + ); + } + } + + if( rc==SQLITE_OK ){ + sqlite3_step(pDelete); + rc = sqlite3_reset(pDelete); + } + + return rc; +} + +/* +** When this function is called, buffer *ppList (size *pnList bytes) contains +** a position list that may (or may not) feature multiple columns. This +** function adjusts the pointer *ppList and the length *pnList so that they +** identify the subset of the position list that corresponds to column iCol. +** +** If there are no entries in the input position list for column iCol, then +** *pnList is set to zero before returning. +** +** If parameter bZero is non-zero, then any part of the input list following +** the end of the output list is zeroed before returning. +*/ +static void fts3ColumnFilter( + int iCol, /* Column to filter on */ + int bZero, /* Zero out anything following *ppList */ + char **ppList, /* IN/OUT: Pointer to position list */ + int *pnList /* IN/OUT: Size of buffer *ppList in bytes */ +){ + char *pList = *ppList; + int nList = *pnList; + char *pEnd = &pList[nList]; + int iCurrent = 0; + char *p = pList; + + assert( iCol>=0 ); + while( 1 ){ + char c = 0; + while( p0){ + memset(&pList[nList], 0, pEnd - &pList[nList]); + } + *ppList = pList; + *pnList = nList; +} + +/* +** Cache data in the Fts3MultiSegReader.aBuffer[] buffer (overwriting any +** existing data). Grow the buffer if required. +** +** If successful, return SQLITE_OK. Otherwise, if an OOM error is encountered +** trying to resize the buffer, return SQLITE_NOMEM. +*/ +static int fts3MsrBufferData( + Fts3MultiSegReader *pMsr, /* Multi-segment-reader handle */ + char *pList, + i64 nList +){ + if( (nList+FTS3_NODE_PADDING)>pMsr->nBuffer ){ + char *pNew; + int nNew = nList*2 + FTS3_NODE_PADDING; + pNew = (char *)sqlite3_realloc64(pMsr->aBuffer, nNew); + if( !pNew ) return SQLITE_NOMEM; + pMsr->aBuffer = pNew; + pMsr->nBuffer = nNew; + } + + assert( nList>0 ); + memcpy(pMsr->aBuffer, pList, nList); + memset(&pMsr->aBuffer[nList], 0, FTS3_NODE_PADDING); + return SQLITE_OK; +} + +SQLITE_PRIVATE int sqlite3Fts3MsrIncrNext( + Fts3Table *p, /* Virtual table handle */ + Fts3MultiSegReader *pMsr, /* Multi-segment-reader handle */ + sqlite3_int64 *piDocid, /* OUT: Docid value */ + char **paPoslist, /* OUT: Pointer to position list */ + int *pnPoslist /* OUT: Size of position list in bytes */ +){ + int nMerge = pMsr->nAdvance; + Fts3SegReader **apSegment = pMsr->apSegment; + int (*xCmp)(Fts3SegReader *, Fts3SegReader *) = ( + p->bDescIdx ? fts3SegReaderDoclistCmpRev : fts3SegReaderDoclistCmp + ); + + if( nMerge==0 ){ + *paPoslist = 0; + return SQLITE_OK; + } + + while( 1 ){ + Fts3SegReader *pSeg; + pSeg = pMsr->apSegment[0]; + + if( pSeg->pOffsetList==0 ){ + *paPoslist = 0; + break; + }else{ + int rc; + char *pList; + int nList; + int j; + sqlite3_int64 iDocid = apSegment[0]->iDocid; + + rc = fts3SegReaderNextDocid(p, apSegment[0], &pList, &nList); + j = 1; + while( rc==SQLITE_OK + && jpOffsetList + && apSegment[j]->iDocid==iDocid + ){ + rc = fts3SegReaderNextDocid(p, apSegment[j], 0, 0); + j++; + } + if( rc!=SQLITE_OK ) return rc; + fts3SegReaderSort(pMsr->apSegment, nMerge, j, xCmp); + + if( nList>0 && fts3SegReaderIsPending(apSegment[0]) ){ + rc = fts3MsrBufferData(pMsr, pList, (i64)nList+1); + if( rc!=SQLITE_OK ) return rc; + assert( (pMsr->aBuffer[nList] & 0xFE)==0x00 ); + pList = pMsr->aBuffer; + } + + if( pMsr->iColFilter>=0 ){ + fts3ColumnFilter(pMsr->iColFilter, 1, &pList, &nList); + } + + if( nList>0 ){ + *paPoslist = pList; + *piDocid = iDocid; + *pnPoslist = nList; + break; + } + } + } + + return SQLITE_OK; +} + +static int fts3SegReaderStart( + Fts3Table *p, /* Virtual table handle */ + Fts3MultiSegReader *pCsr, /* Cursor object */ + const char *zTerm, /* Term searched for (or NULL) */ + int nTerm /* Length of zTerm in bytes */ +){ + int i; + int nSeg = pCsr->nSegment; + + /* If the Fts3SegFilter defines a specific term (or term prefix) to search + ** for, then advance each segment iterator until it points to a term of + ** equal or greater value than the specified term. This prevents many + ** unnecessary merge/sort operations for the case where single segment + ** b-tree leaf nodes contain more than one term. + */ + for(i=0; pCsr->bRestart==0 && inSegment; i++){ + int res = 0; + Fts3SegReader *pSeg = pCsr->apSegment[i]; + do { + int rc = fts3SegReaderNext(p, pSeg, 0); + if( rc!=SQLITE_OK ) return rc; + }while( zTerm && (res = fts3SegReaderTermCmp(pSeg, zTerm, nTerm))<0 ); + + if( pSeg->bLookup && res!=0 ){ + fts3SegReaderSetEof(pSeg); + } + } + fts3SegReaderSort(pCsr->apSegment, nSeg, nSeg, fts3SegReaderCmp); + + return SQLITE_OK; +} + +SQLITE_PRIVATE int sqlite3Fts3SegReaderStart( + Fts3Table *p, /* Virtual table handle */ + Fts3MultiSegReader *pCsr, /* Cursor object */ + Fts3SegFilter *pFilter /* Restrictions on range of iteration */ +){ + pCsr->pFilter = pFilter; + return fts3SegReaderStart(p, pCsr, pFilter->zTerm, pFilter->nTerm); +} + +SQLITE_PRIVATE int sqlite3Fts3MsrIncrStart( + Fts3Table *p, /* Virtual table handle */ + Fts3MultiSegReader *pCsr, /* Cursor object */ + int iCol, /* Column to match on. */ + const char *zTerm, /* Term to iterate through a doclist for */ + int nTerm /* Number of bytes in zTerm */ +){ + int i; + int rc; + int nSegment = pCsr->nSegment; + int (*xCmp)(Fts3SegReader *, Fts3SegReader *) = ( + p->bDescIdx ? fts3SegReaderDoclistCmpRev : fts3SegReaderDoclistCmp + ); + + assert( pCsr->pFilter==0 ); + assert( zTerm && nTerm>0 ); + + /* Advance each segment iterator until it points to the term zTerm/nTerm. */ + rc = fts3SegReaderStart(p, pCsr, zTerm, nTerm); + if( rc!=SQLITE_OK ) return rc; + + /* Determine how many of the segments actually point to zTerm/nTerm. */ + for(i=0; iapSegment[i]; + if( !pSeg->aNode || fts3SegReaderTermCmp(pSeg, zTerm, nTerm) ){ + break; + } + } + pCsr->nAdvance = i; + + /* Advance each of the segments to point to the first docid. */ + for(i=0; inAdvance; i++){ + rc = fts3SegReaderFirstDocid(p, pCsr->apSegment[i]); + if( rc!=SQLITE_OK ) return rc; + } + fts3SegReaderSort(pCsr->apSegment, i, i, xCmp); + + assert( iCol<0 || iColnColumn ); + pCsr->iColFilter = iCol; + + return SQLITE_OK; +} + +/* +** This function is called on a MultiSegReader that has been started using +** sqlite3Fts3MsrIncrStart(). One or more calls to MsrIncrNext() may also +** have been made. Calling this function puts the MultiSegReader in such +** a state that if the next two calls are: +** +** sqlite3Fts3SegReaderStart() +** sqlite3Fts3SegReaderStep() +** +** then the entire doclist for the term is available in +** MultiSegReader.aDoclist/nDoclist. +*/ +SQLITE_PRIVATE int sqlite3Fts3MsrIncrRestart(Fts3MultiSegReader *pCsr){ + int i; /* Used to iterate through segment-readers */ + + assert( pCsr->zTerm==0 ); + assert( pCsr->nTerm==0 ); + assert( pCsr->aDoclist==0 ); + assert( pCsr->nDoclist==0 ); + + pCsr->nAdvance = 0; + pCsr->bRestart = 1; + for(i=0; inSegment; i++){ + pCsr->apSegment[i]->pOffsetList = 0; + pCsr->apSegment[i]->nOffsetList = 0; + pCsr->apSegment[i]->iDocid = 0; + } + + return SQLITE_OK; +} + +static int fts3GrowSegReaderBuffer(Fts3MultiSegReader *pCsr, i64 nReq){ + if( nReq>pCsr->nBuffer ){ + char *aNew; + pCsr->nBuffer = nReq*2; + aNew = sqlite3_realloc64(pCsr->aBuffer, pCsr->nBuffer); + if( !aNew ){ + return SQLITE_NOMEM; + } + pCsr->aBuffer = aNew; + } + return SQLITE_OK; +} + + +SQLITE_PRIVATE int sqlite3Fts3SegReaderStep( + Fts3Table *p, /* Virtual table handle */ + Fts3MultiSegReader *pCsr /* Cursor object */ +){ + int rc = SQLITE_OK; + + int isIgnoreEmpty = (pCsr->pFilter->flags & FTS3_SEGMENT_IGNORE_EMPTY); + int isRequirePos = (pCsr->pFilter->flags & FTS3_SEGMENT_REQUIRE_POS); + int isColFilter = (pCsr->pFilter->flags & FTS3_SEGMENT_COLUMN_FILTER); + int isPrefix = (pCsr->pFilter->flags & FTS3_SEGMENT_PREFIX); + int isScan = (pCsr->pFilter->flags & FTS3_SEGMENT_SCAN); + int isFirst = (pCsr->pFilter->flags & FTS3_SEGMENT_FIRST); + + Fts3SegReader **apSegment = pCsr->apSegment; + int nSegment = pCsr->nSegment; + Fts3SegFilter *pFilter = pCsr->pFilter; + int (*xCmp)(Fts3SegReader *, Fts3SegReader *) = ( + p->bDescIdx ? fts3SegReaderDoclistCmpRev : fts3SegReaderDoclistCmp + ); + + if( pCsr->nSegment==0 ) return SQLITE_OK; + + do { + int nMerge; + int i; + + /* Advance the first pCsr->nAdvance entries in the apSegment[] array + ** forward. Then sort the list in order of current term again. + */ + for(i=0; inAdvance; i++){ + Fts3SegReader *pSeg = apSegment[i]; + if( pSeg->bLookup ){ + fts3SegReaderSetEof(pSeg); + }else{ + rc = fts3SegReaderNext(p, pSeg, 0); + } + if( rc!=SQLITE_OK ) return rc; + } + fts3SegReaderSort(apSegment, nSegment, pCsr->nAdvance, fts3SegReaderCmp); + pCsr->nAdvance = 0; + + /* If all the seg-readers are at EOF, we're finished. return SQLITE_OK. */ + assert( rc==SQLITE_OK ); + if( apSegment[0]->aNode==0 ) break; + + pCsr->nTerm = apSegment[0]->nTerm; + pCsr->zTerm = apSegment[0]->zTerm; + + /* If this is a prefix-search, and if the term that apSegment[0] points + ** to does not share a suffix with pFilter->zTerm/nTerm, then all + ** required callbacks have been made. In this case exit early. + ** + ** Similarly, if this is a search for an exact match, and the first term + ** of segment apSegment[0] is not a match, exit early. + */ + if( pFilter->zTerm && !isScan ){ + if( pCsr->nTermnTerm + || (!isPrefix && pCsr->nTerm>pFilter->nTerm) + || memcmp(pCsr->zTerm, pFilter->zTerm, pFilter->nTerm) + ){ + break; + } + } + + nMerge = 1; + while( nMergeaNode + && apSegment[nMerge]->nTerm==pCsr->nTerm + && 0==memcmp(pCsr->zTerm, apSegment[nMerge]->zTerm, pCsr->nTerm) + ){ + nMerge++; + } + + assert( isIgnoreEmpty || (isRequirePos && !isColFilter) ); + if( nMerge==1 + && !isIgnoreEmpty + && !isFirst + && (p->bDescIdx==0 || fts3SegReaderIsPending(apSegment[0])==0) + ){ + pCsr->nDoclist = apSegment[0]->nDoclist; + if( fts3SegReaderIsPending(apSegment[0]) ){ + rc = fts3MsrBufferData(pCsr, apSegment[0]->aDoclist, + (i64)pCsr->nDoclist); + pCsr->aDoclist = pCsr->aBuffer; + }else{ + pCsr->aDoclist = apSegment[0]->aDoclist; + } + if( rc==SQLITE_OK ) rc = SQLITE_ROW; + }else{ + int nDoclist = 0; /* Size of doclist */ + sqlite3_int64 iPrev = 0; /* Previous docid stored in doclist */ + + /* The current term of the first nMerge entries in the array + ** of Fts3SegReader objects is the same. The doclists must be merged + ** and a single term returned with the merged doclist. + */ + for(i=0; ipOffsetList ){ + int j; /* Number of segments that share a docid */ + char *pList = 0; + int nList = 0; + int nByte; + sqlite3_int64 iDocid = apSegment[0]->iDocid; + fts3SegReaderNextDocid(p, apSegment[0], &pList, &nList); + j = 1; + while( jpOffsetList + && apSegment[j]->iDocid==iDocid + ){ + fts3SegReaderNextDocid(p, apSegment[j], 0, 0); + j++; + } + + if( isColFilter ){ + fts3ColumnFilter(pFilter->iCol, 0, &pList, &nList); + } + + if( !isIgnoreEmpty || nList>0 ){ + + /* Calculate the 'docid' delta value to write into the merged + ** doclist. */ + sqlite3_int64 iDelta; + if( p->bDescIdx && nDoclist>0 ){ + if( iPrev<=iDocid ) return FTS_CORRUPT_VTAB; + iDelta = (i64)((u64)iPrev - (u64)iDocid); + }else{ + if( nDoclist>0 && iPrev>=iDocid ) return FTS_CORRUPT_VTAB; + iDelta = (i64)((u64)iDocid - (u64)iPrev); + } + + nByte = sqlite3Fts3VarintLen(iDelta) + (isRequirePos?nList+1:0); + + rc = fts3GrowSegReaderBuffer(pCsr, + (i64)nByte+nDoclist+FTS3_NODE_PADDING); + if( rc ) return rc; + + if( isFirst ){ + char *a = &pCsr->aBuffer[nDoclist]; + int nWrite; + + nWrite = sqlite3Fts3FirstFilter(iDelta, pList, nList, a); + if( nWrite ){ + iPrev = iDocid; + nDoclist += nWrite; + } + }else{ + nDoclist += sqlite3Fts3PutVarint(&pCsr->aBuffer[nDoclist], iDelta); + iPrev = iDocid; + if( isRequirePos ){ + memcpy(&pCsr->aBuffer[nDoclist], pList, nList); + nDoclist += nList; + pCsr->aBuffer[nDoclist++] = '\0'; + } + } + } + + fts3SegReaderSort(apSegment, nMerge, j, xCmp); + } + if( nDoclist>0 ){ + rc = fts3GrowSegReaderBuffer(pCsr, (i64)nDoclist+FTS3_NODE_PADDING); + if( rc ) return rc; + memset(&pCsr->aBuffer[nDoclist], 0, FTS3_NODE_PADDING); + pCsr->aDoclist = pCsr->aBuffer; + pCsr->nDoclist = nDoclist; + rc = SQLITE_ROW; + } + } + pCsr->nAdvance = nMerge; + }while( rc==SQLITE_OK ); + + return rc; +} + + +SQLITE_PRIVATE void sqlite3Fts3SegReaderFinish( + Fts3MultiSegReader *pCsr /* Cursor object */ +){ + if( pCsr ){ + int i; + for(i=0; inSegment; i++){ + sqlite3Fts3SegReaderFree(pCsr->apSegment[i]); + } + sqlite3_free(pCsr->apSegment); + sqlite3_free(pCsr->aBuffer); + + pCsr->nSegment = 0; + pCsr->apSegment = 0; + pCsr->aBuffer = 0; + } +} + +/* +** Decode the "end_block" field, selected by column iCol of the SELECT +** statement passed as the first argument. +** +** The "end_block" field may contain either an integer, or a text field +** containing the text representation of two non-negative integers separated +** by one or more space (0x20) characters. In the first case, set *piEndBlock +** to the integer value and *pnByte to zero before returning. In the second, +** set *piEndBlock to the first value and *pnByte to the second. +*/ +static void fts3ReadEndBlockField( + sqlite3_stmt *pStmt, + int iCol, + i64 *piEndBlock, + i64 *pnByte +){ + const unsigned char *zText = sqlite3_column_text(pStmt, iCol); + if( zText ){ + int i; + int iMul = 1; + u64 iVal = 0; + for(i=0; zText[i]>='0' && zText[i]<='9'; i++){ + iVal = iVal*10 + (zText[i] - '0'); + } + *piEndBlock = (i64)iVal; + while( zText[i]==' ' ) i++; + iVal = 0; + if( zText[i]=='-' ){ + i++; + iMul = -1; + } + for(/* no-op */; zText[i]>='0' && zText[i]<='9'; i++){ + iVal = iVal*10 + (zText[i] - '0'); + } + *pnByte = ((i64)iVal * (i64)iMul); + } +} + + +/* +** A segment of size nByte bytes has just been written to absolute level +** iAbsLevel. Promote any segments that should be promoted as a result. +*/ +static int fts3PromoteSegments( + Fts3Table *p, /* FTS table handle */ + sqlite3_int64 iAbsLevel, /* Absolute level just updated */ + sqlite3_int64 nByte /* Size of new segment at iAbsLevel */ +){ + int rc = SQLITE_OK; + sqlite3_stmt *pRange; + + rc = fts3SqlStmt(p, SQL_SELECT_LEVEL_RANGE2, &pRange, 0); + + if( rc==SQLITE_OK ){ + int bOk = 0; + i64 iLast = (iAbsLevel/FTS3_SEGDIR_MAXLEVEL + 1) * FTS3_SEGDIR_MAXLEVEL - 1; + i64 nLimit = (nByte*3)/2; + + /* Loop through all entries in the %_segdir table corresponding to + ** segments in this index on levels greater than iAbsLevel. If there is + ** at least one such segment, and it is possible to determine that all + ** such segments are smaller than nLimit bytes in size, they will be + ** promoted to level iAbsLevel. */ + sqlite3_bind_int64(pRange, 1, iAbsLevel+1); + sqlite3_bind_int64(pRange, 2, iLast); + while( SQLITE_ROW==sqlite3_step(pRange) ){ + i64 nSize = 0, dummy; + fts3ReadEndBlockField(pRange, 2, &dummy, &nSize); + if( nSize<=0 || nSize>nLimit ){ + /* If nSize==0, then the %_segdir.end_block field does not not + ** contain a size value. This happens if it was written by an + ** old version of FTS. In this case it is not possible to determine + ** the size of the segment, and so segment promotion does not + ** take place. */ + bOk = 0; + break; + } + bOk = 1; + } + rc = sqlite3_reset(pRange); + + if( bOk ){ + int iIdx = 0; + sqlite3_stmt *pUpdate1 = 0; + sqlite3_stmt *pUpdate2 = 0; + + if( rc==SQLITE_OK ){ + rc = fts3SqlStmt(p, SQL_UPDATE_LEVEL_IDX, &pUpdate1, 0); + } + if( rc==SQLITE_OK ){ + rc = fts3SqlStmt(p, SQL_UPDATE_LEVEL, &pUpdate2, 0); + } + + if( rc==SQLITE_OK ){ + + /* Loop through all %_segdir entries for segments in this index with + ** levels equal to or greater than iAbsLevel. As each entry is visited, + ** updated it to set (level = -1) and (idx = N), where N is 0 for the + ** oldest segment in the range, 1 for the next oldest, and so on. + ** + ** In other words, move all segments being promoted to level -1, + ** setting the "idx" fields as appropriate to keep them in the same + ** order. The contents of level -1 (which is never used, except + ** transiently here), will be moved back to level iAbsLevel below. */ + sqlite3_bind_int64(pRange, 1, iAbsLevel); + while( SQLITE_ROW==sqlite3_step(pRange) ){ + sqlite3_bind_int(pUpdate1, 1, iIdx++); + sqlite3_bind_int(pUpdate1, 2, sqlite3_column_int(pRange, 0)); + sqlite3_bind_int(pUpdate1, 3, sqlite3_column_int(pRange, 1)); + sqlite3_step(pUpdate1); + rc = sqlite3_reset(pUpdate1); + if( rc!=SQLITE_OK ){ + sqlite3_reset(pRange); + break; + } + } + } + if( rc==SQLITE_OK ){ + rc = sqlite3_reset(pRange); + } + + /* Move level -1 to level iAbsLevel */ + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pUpdate2, 1, iAbsLevel); + sqlite3_step(pUpdate2); + rc = sqlite3_reset(pUpdate2); + } + } + } + + + return rc; +} + +/* +** Merge all level iLevel segments in the database into a single +** iLevel+1 segment. Or, if iLevel<0, merge all segments into a +** single segment with a level equal to the numerically largest level +** currently present in the database. +** +** If this function is called with iLevel<0, but there is only one +** segment in the database, SQLITE_DONE is returned immediately. +** Otherwise, if successful, SQLITE_OK is returned. If an error occurs, +** an SQLite error code is returned. +*/ +static int fts3SegmentMerge( + Fts3Table *p, + int iLangid, /* Language id to merge */ + int iIndex, /* Index in p->aIndex[] to merge */ + int iLevel /* Level to merge */ +){ + int rc; /* Return code */ + int iIdx = 0; /* Index of new segment */ + sqlite3_int64 iNewLevel = 0; /* Level/index to create new segment at */ + SegmentWriter *pWriter = 0; /* Used to write the new, merged, segment */ + Fts3SegFilter filter; /* Segment term filter condition */ + Fts3MultiSegReader csr; /* Cursor to iterate through level(s) */ + int bIgnoreEmpty = 0; /* True to ignore empty segments */ + i64 iMaxLevel = 0; /* Max level number for this index/langid */ + + assert( iLevel==FTS3_SEGCURSOR_ALL + || iLevel==FTS3_SEGCURSOR_PENDING + || iLevel>=0 + ); + assert( iLevel=0 && iIndexnIndex ); + + rc = sqlite3Fts3SegReaderCursor(p, iLangid, iIndex, iLevel, 0, 0, 1, 0, &csr); + if( rc!=SQLITE_OK || csr.nSegment==0 ) goto finished; + + if( iLevel!=FTS3_SEGCURSOR_PENDING ){ + rc = fts3SegmentMaxLevel(p, iLangid, iIndex, &iMaxLevel); + if( rc!=SQLITE_OK ) goto finished; + } + + if( iLevel==FTS3_SEGCURSOR_ALL ){ + /* This call is to merge all segments in the database to a single + ** segment. The level of the new segment is equal to the numerically + ** greatest segment level currently present in the database for this + ** index. The idx of the new segment is always 0. */ + if( csr.nSegment==1 && 0==fts3SegReaderIsPending(csr.apSegment[0]) ){ + rc = SQLITE_DONE; + goto finished; + } + iNewLevel = iMaxLevel; + bIgnoreEmpty = 1; + + }else{ + /* This call is to merge all segments at level iLevel. find the next + ** available segment index at level iLevel+1. The call to + ** fts3AllocateSegdirIdx() will merge the segments at level iLevel+1 to + ** a single iLevel+2 segment if necessary. */ + assert( FTS3_SEGCURSOR_PENDING==-1 ); + iNewLevel = getAbsoluteLevel(p, iLangid, iIndex, iLevel+1); + rc = fts3AllocateSegdirIdx(p, iLangid, iIndex, iLevel+1, &iIdx); + bIgnoreEmpty = (iLevel!=FTS3_SEGCURSOR_PENDING) && (iNewLevel>iMaxLevel); + } + if( rc!=SQLITE_OK ) goto finished; + + assert( csr.nSegment>0 ); + assert_fts3_nc( iNewLevel>=getAbsoluteLevel(p, iLangid, iIndex, 0) ); + assert_fts3_nc( + iNewLevelnLeafData); + } + } + } + + finished: + fts3SegWriterFree(pWriter); + sqlite3Fts3SegReaderFinish(&csr); + return rc; +} + + +/* +** Flush the contents of pendingTerms to level 0 segments. +*/ +SQLITE_PRIVATE int sqlite3Fts3PendingTermsFlush(Fts3Table *p){ + int rc = SQLITE_OK; + int i; + + for(i=0; rc==SQLITE_OK && inIndex; i++){ + rc = fts3SegmentMerge(p, p->iPrevLangid, i, FTS3_SEGCURSOR_PENDING); + if( rc==SQLITE_DONE ) rc = SQLITE_OK; + } + sqlite3Fts3PendingTermsClear(p); + + /* Determine the auto-incr-merge setting if unknown. If enabled, + ** estimate the number of leaf blocks of content to be written + */ + if( rc==SQLITE_OK && p->bHasStat + && p->nAutoincrmerge==0xff && p->nLeafAdd>0 + ){ + sqlite3_stmt *pStmt = 0; + rc = fts3SqlStmt(p, SQL_SELECT_STAT, &pStmt, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int(pStmt, 1, FTS_STAT_AUTOINCRMERGE); + rc = sqlite3_step(pStmt); + if( rc==SQLITE_ROW ){ + p->nAutoincrmerge = sqlite3_column_int(pStmt, 0); + if( p->nAutoincrmerge==1 ) p->nAutoincrmerge = 8; + }else if( rc==SQLITE_DONE ){ + p->nAutoincrmerge = 0; + } + rc = sqlite3_reset(pStmt); + } + } + return rc; +} + +/* +** Encode N integers as varints into a blob. +*/ +static void fts3EncodeIntArray( + int N, /* The number of integers to encode */ + u32 *a, /* The integer values */ + char *zBuf, /* Write the BLOB here */ + int *pNBuf /* Write number of bytes if zBuf[] used here */ +){ + int i, j; + for(i=j=0; iiPrevDocid. The sizes are encoded as +** a blob of varints. +*/ +static void fts3InsertDocsize( + int *pRC, /* Result code */ + Fts3Table *p, /* Table into which to insert */ + u32 *aSz /* Sizes of each column, in tokens */ +){ + char *pBlob; /* The BLOB encoding of the document size */ + int nBlob; /* Number of bytes in the BLOB */ + sqlite3_stmt *pStmt; /* Statement used to insert the encoding */ + int rc; /* Result code from subfunctions */ + + if( *pRC ) return; + pBlob = sqlite3_malloc64( 10*(sqlite3_int64)p->nColumn ); + if( pBlob==0 ){ + *pRC = SQLITE_NOMEM; + return; + } + fts3EncodeIntArray(p->nColumn, aSz, pBlob, &nBlob); + rc = fts3SqlStmt(p, SQL_REPLACE_DOCSIZE, &pStmt, 0); + if( rc ){ + sqlite3_free(pBlob); + *pRC = rc; + return; + } + sqlite3_bind_int64(pStmt, 1, p->iPrevDocid); + sqlite3_bind_blob(pStmt, 2, pBlob, nBlob, sqlite3_free); + sqlite3_step(pStmt); + *pRC = sqlite3_reset(pStmt); +} + +/* +** Record 0 of the %_stat table contains a blob consisting of N varints, +** where N is the number of user defined columns in the fts3 table plus +** two. If nCol is the number of user defined columns, then values of the +** varints are set as follows: +** +** Varint 0: Total number of rows in the table. +** +** Varint 1..nCol: For each column, the total number of tokens stored in +** the column for all rows of the table. +** +** Varint 1+nCol: The total size, in bytes, of all text values in all +** columns of all rows of the table. +** +*/ +static void fts3UpdateDocTotals( + int *pRC, /* The result code */ + Fts3Table *p, /* Table being updated */ + u32 *aSzIns, /* Size increases */ + u32 *aSzDel, /* Size decreases */ + int nChng /* Change in the number of documents */ +){ + char *pBlob; /* Storage for BLOB written into %_stat */ + int nBlob; /* Size of BLOB written into %_stat */ + u32 *a; /* Array of integers that becomes the BLOB */ + sqlite3_stmt *pStmt; /* Statement for reading and writing */ + int i; /* Loop counter */ + int rc; /* Result code from subfunctions */ + + const int nStat = p->nColumn+2; + + if( *pRC ) return; + a = sqlite3_malloc64( (sizeof(u32)+10)*(sqlite3_int64)nStat ); + if( a==0 ){ + *pRC = SQLITE_NOMEM; + return; + } + pBlob = (char*)&a[nStat]; + rc = fts3SqlStmt(p, SQL_SELECT_STAT, &pStmt, 0); + if( rc ){ + sqlite3_free(a); + *pRC = rc; + return; + } + sqlite3_bind_int(pStmt, 1, FTS_STAT_DOCTOTAL); + if( sqlite3_step(pStmt)==SQLITE_ROW ){ + fts3DecodeIntArray(nStat, a, + sqlite3_column_blob(pStmt, 0), + sqlite3_column_bytes(pStmt, 0)); + }else{ + memset(a, 0, sizeof(u32)*(nStat) ); + } + rc = sqlite3_reset(pStmt); + if( rc!=SQLITE_OK ){ + sqlite3_free(a); + *pRC = rc; + return; + } + if( nChng<0 && a[0]<(u32)(-nChng) ){ + a[0] = 0; + }else{ + a[0] += nChng; + } + for(i=0; inColumn+1; i++){ + u32 x = a[i+1]; + if( x+aSzIns[i] < aSzDel[i] ){ + x = 0; + }else{ + x = x + aSzIns[i] - aSzDel[i]; + } + a[i+1] = x; + } + fts3EncodeIntArray(nStat, a, pBlob, &nBlob); + rc = fts3SqlStmt(p, SQL_REPLACE_STAT, &pStmt, 0); + if( rc ){ + sqlite3_free(a); + *pRC = rc; + return; + } + sqlite3_bind_int(pStmt, 1, FTS_STAT_DOCTOTAL); + sqlite3_bind_blob(pStmt, 2, pBlob, nBlob, SQLITE_STATIC); + sqlite3_step(pStmt); + *pRC = sqlite3_reset(pStmt); + sqlite3_bind_null(pStmt, 2); + sqlite3_free(a); +} + +/* +** Merge the entire database so that there is one segment for each +** iIndex/iLangid combination. +*/ +static int fts3DoOptimize(Fts3Table *p, int bReturnDone){ + int bSeenDone = 0; + int rc; + sqlite3_stmt *pAllLangid = 0; + + rc = sqlite3Fts3PendingTermsFlush(p); + if( rc==SQLITE_OK ){ + rc = fts3SqlStmt(p, SQL_SELECT_ALL_LANGID, &pAllLangid, 0); + } + if( rc==SQLITE_OK ){ + int rc2; + sqlite3_bind_int(pAllLangid, 1, p->iPrevLangid); + sqlite3_bind_int(pAllLangid, 2, p->nIndex); + while( sqlite3_step(pAllLangid)==SQLITE_ROW ){ + int i; + int iLangid = sqlite3_column_int(pAllLangid, 0); + for(i=0; rc==SQLITE_OK && inIndex; i++){ + rc = fts3SegmentMerge(p, iLangid, i, FTS3_SEGCURSOR_ALL); + if( rc==SQLITE_DONE ){ + bSeenDone = 1; + rc = SQLITE_OK; + } + } + } + rc2 = sqlite3_reset(pAllLangid); + if( rc==SQLITE_OK ) rc = rc2; + } + + sqlite3Fts3SegmentsClose(p); + + return (rc==SQLITE_OK && bReturnDone && bSeenDone) ? SQLITE_DONE : rc; +} + +/* +** This function is called when the user executes the following statement: +** +** INSERT INTO () VALUES('rebuild'); +** +** The entire FTS index is discarded and rebuilt. If the table is one +** created using the content=xxx option, then the new index is based on +** the current contents of the xxx table. Otherwise, it is rebuilt based +** on the contents of the %_content table. +*/ +static int fts3DoRebuild(Fts3Table *p){ + int rc; /* Return Code */ + + rc = fts3DeleteAll(p, 0); + if( rc==SQLITE_OK ){ + u32 *aSz = 0; + u32 *aSzIns = 0; + u32 *aSzDel = 0; + sqlite3_stmt *pStmt = 0; + int nEntry = 0; + + /* Compose and prepare an SQL statement to loop through the content table */ + char *zSql = sqlite3_mprintf("SELECT %s" , p->zReadExprlist); + if( !zSql ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); + sqlite3_free(zSql); + } + + if( rc==SQLITE_OK ){ + sqlite3_int64 nByte = sizeof(u32) * ((sqlite3_int64)p->nColumn+1)*3; + aSz = (u32 *)sqlite3_malloc64(nByte); + if( aSz==0 ){ + rc = SQLITE_NOMEM; + }else{ + memset(aSz, 0, nByte); + aSzIns = &aSz[p->nColumn+1]; + aSzDel = &aSzIns[p->nColumn+1]; + } + } + + while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ + int iCol; + int iLangid = langidFromSelect(p, pStmt); + rc = fts3PendingTermsDocid(p, 0, iLangid, sqlite3_column_int64(pStmt, 0)); + memset(aSz, 0, sizeof(aSz[0]) * (p->nColumn+1)); + for(iCol=0; rc==SQLITE_OK && iColnColumn; iCol++){ + if( p->abNotindexed[iCol]==0 ){ + const char *z = (const char *) sqlite3_column_text(pStmt, iCol+1); + rc = fts3PendingTermsAdd(p, iLangid, z, iCol, &aSz[iCol]); + aSz[p->nColumn] += sqlite3_column_bytes(pStmt, iCol+1); + } + } + if( p->bHasDocsize ){ + fts3InsertDocsize(&rc, p, aSz); + } + if( rc!=SQLITE_OK ){ + sqlite3_finalize(pStmt); + pStmt = 0; + }else{ + nEntry++; + for(iCol=0; iCol<=p->nColumn; iCol++){ + aSzIns[iCol] += aSz[iCol]; + } + } + } + if( p->bFts4 ){ + fts3UpdateDocTotals(&rc, p, aSzIns, aSzDel, nEntry); + } + sqlite3_free(aSz); + + if( pStmt ){ + int rc2 = sqlite3_finalize(pStmt); + if( rc==SQLITE_OK ){ + rc = rc2; + } + } + } + + return rc; +} + + +/* +** This function opens a cursor used to read the input data for an +** incremental merge operation. Specifically, it opens a cursor to scan +** the oldest nSeg segments (idx=0 through idx=(nSeg-1)) in absolute +** level iAbsLevel. +*/ +static int fts3IncrmergeCsr( + Fts3Table *p, /* FTS3 table handle */ + sqlite3_int64 iAbsLevel, /* Absolute level to open */ + int nSeg, /* Number of segments to merge */ + Fts3MultiSegReader *pCsr /* Cursor object to populate */ +){ + int rc; /* Return Code */ + sqlite3_stmt *pStmt = 0; /* Statement used to read %_segdir entry */ + sqlite3_int64 nByte; /* Bytes allocated at pCsr->apSegment[] */ + + /* Allocate space for the Fts3MultiSegReader.aCsr[] array */ + memset(pCsr, 0, sizeof(*pCsr)); + nByte = sizeof(Fts3SegReader *) * nSeg; + pCsr->apSegment = (Fts3SegReader **)sqlite3_malloc64(nByte); + + if( pCsr->apSegment==0 ){ + rc = SQLITE_NOMEM; + }else{ + memset(pCsr->apSegment, 0, nByte); + rc = fts3SqlStmt(p, SQL_SELECT_LEVEL, &pStmt, 0); + } + if( rc==SQLITE_OK ){ + int i; + int rc2; + sqlite3_bind_int64(pStmt, 1, iAbsLevel); + assert( pCsr->nSegment==0 ); + for(i=0; rc==SQLITE_OK && sqlite3_step(pStmt)==SQLITE_ROW && iapSegment[i] + ); + pCsr->nSegment++; + } + rc2 = sqlite3_reset(pStmt); + if( rc==SQLITE_OK ) rc = rc2; + } + + return rc; +} + +typedef struct IncrmergeWriter IncrmergeWriter; +typedef struct NodeWriter NodeWriter; +typedef struct Blob Blob; +typedef struct NodeReader NodeReader; + +/* +** An instance of the following structure is used as a dynamic buffer +** to build up nodes or other blobs of data in. +** +** The function blobGrowBuffer() is used to extend the allocation. +*/ +struct Blob { + char *a; /* Pointer to allocation */ + int n; /* Number of valid bytes of data in a[] */ + int nAlloc; /* Allocated size of a[] (nAlloc>=n) */ +}; + +/* +** This structure is used to build up buffers containing segment b-tree +** nodes (blocks). +*/ +struct NodeWriter { + sqlite3_int64 iBlock; /* Current block id */ + Blob key; /* Last key written to the current block */ + Blob block; /* Current block image */ +}; + +/* +** An object of this type contains the state required to create or append +** to an appendable b-tree segment. +*/ +struct IncrmergeWriter { + int nLeafEst; /* Space allocated for leaf blocks */ + int nWork; /* Number of leaf pages flushed */ + sqlite3_int64 iAbsLevel; /* Absolute level of input segments */ + int iIdx; /* Index of *output* segment in iAbsLevel+1 */ + sqlite3_int64 iStart; /* Block number of first allocated block */ + sqlite3_int64 iEnd; /* Block number of last allocated block */ + sqlite3_int64 nLeafData; /* Bytes of leaf page data so far */ + u8 bNoLeafData; /* If true, store 0 for segment size */ + NodeWriter aNodeWriter[FTS_MAX_APPENDABLE_HEIGHT]; +}; + +/* +** An object of the following type is used to read data from a single +** FTS segment node. See the following functions: +** +** nodeReaderInit() +** nodeReaderNext() +** nodeReaderRelease() +*/ +struct NodeReader { + const char *aNode; + int nNode; + int iOff; /* Current offset within aNode[] */ + + /* Output variables. Containing the current node entry. */ + sqlite3_int64 iChild; /* Pointer to child node */ + Blob term; /* Current term */ + const char *aDoclist; /* Pointer to doclist */ + int nDoclist; /* Size of doclist in bytes */ +}; + +/* +** If *pRc is not SQLITE_OK when this function is called, it is a no-op. +** Otherwise, if the allocation at pBlob->a is not already at least nMin +** bytes in size, extend (realloc) it to be so. +** +** If an OOM error occurs, set *pRc to SQLITE_NOMEM and leave pBlob->a +** unmodified. Otherwise, if the allocation succeeds, update pBlob->nAlloc +** to reflect the new size of the pBlob->a[] buffer. +*/ +static void blobGrowBuffer(Blob *pBlob, int nMin, int *pRc){ + if( *pRc==SQLITE_OK && nMin>pBlob->nAlloc ){ + int nAlloc = nMin; + char *a = (char *)sqlite3_realloc64(pBlob->a, nAlloc); + if( a ){ + pBlob->nAlloc = nAlloc; + pBlob->a = a; + }else{ + *pRc = SQLITE_NOMEM; + } + } +} + +/* +** Attempt to advance the node-reader object passed as the first argument to +** the next entry on the node. +** +** Return an error code if an error occurs (SQLITE_NOMEM is possible). +** Otherwise return SQLITE_OK. If there is no next entry on the node +** (e.g. because the current entry is the last) set NodeReader->aNode to +** NULL to indicate EOF. Otherwise, populate the NodeReader structure output +** variables for the new entry. +*/ +static int nodeReaderNext(NodeReader *p){ + int bFirst = (p->term.n==0); /* True for first term on the node */ + int nPrefix = 0; /* Bytes to copy from previous term */ + int nSuffix = 0; /* Bytes to append to the prefix */ + int rc = SQLITE_OK; /* Return code */ + + assert( p->aNode ); + if( p->iChild && bFirst==0 ) p->iChild++; + if( p->iOff>=p->nNode ){ + /* EOF */ + p->aNode = 0; + }else{ + if( bFirst==0 ){ + p->iOff += fts3GetVarint32(&p->aNode[p->iOff], &nPrefix); + } + p->iOff += fts3GetVarint32(&p->aNode[p->iOff], &nSuffix); + + if( nPrefix>p->term.n || nSuffix>p->nNode-p->iOff || nSuffix==0 ){ + return FTS_CORRUPT_VTAB; + } + blobGrowBuffer(&p->term, nPrefix+nSuffix, &rc); + if( rc==SQLITE_OK && ALWAYS(p->term.a!=0) ){ + memcpy(&p->term.a[nPrefix], &p->aNode[p->iOff], nSuffix); + p->term.n = nPrefix+nSuffix; + p->iOff += nSuffix; + if( p->iChild==0 ){ + p->iOff += fts3GetVarint32(&p->aNode[p->iOff], &p->nDoclist); + if( (p->nNode-p->iOff)nDoclist ){ + return FTS_CORRUPT_VTAB; + } + p->aDoclist = &p->aNode[p->iOff]; + p->iOff += p->nDoclist; + } + } + } + + assert_fts3_nc( p->iOff<=p->nNode ); + return rc; +} + +/* +** Release all dynamic resources held by node-reader object *p. +*/ +static void nodeReaderRelease(NodeReader *p){ + sqlite3_free(p->term.a); +} + +/* +** Initialize a node-reader object to read the node in buffer aNode/nNode. +** +** If successful, SQLITE_OK is returned and the NodeReader object set to +** point to the first entry on the node (if any). Otherwise, an SQLite +** error code is returned. +*/ +static int nodeReaderInit(NodeReader *p, const char *aNode, int nNode){ + memset(p, 0, sizeof(NodeReader)); + p->aNode = aNode; + p->nNode = nNode; + + /* Figure out if this is a leaf or an internal node. */ + if( aNode && aNode[0] ){ + /* An internal node. */ + p->iOff = 1 + sqlite3Fts3GetVarint(&p->aNode[1], &p->iChild); + }else{ + p->iOff = 1; + } + + return aNode ? nodeReaderNext(p) : SQLITE_OK; +} + +/* +** This function is called while writing an FTS segment each time a leaf o +** node is finished and written to disk. The key (zTerm/nTerm) is guaranteed +** to be greater than the largest key on the node just written, but smaller +** than or equal to the first key that will be written to the next leaf +** node. +** +** The block id of the leaf node just written to disk may be found in +** (pWriter->aNodeWriter[0].iBlock) when this function is called. +*/ +static int fts3IncrmergePush( + Fts3Table *p, /* Fts3 table handle */ + IncrmergeWriter *pWriter, /* Writer object */ + const char *zTerm, /* Term to write to internal node */ + int nTerm /* Bytes at zTerm */ +){ + sqlite3_int64 iPtr = pWriter->aNodeWriter[0].iBlock; + int iLayer; + + assert( nTerm>0 ); + for(iLayer=1; ALWAYS(iLayeraNodeWriter[iLayer]; + int rc = SQLITE_OK; + int nPrefix; + int nSuffix; + int nSpace; + + /* Figure out how much space the key will consume if it is written to + ** the current node of layer iLayer. Due to the prefix compression, + ** the space required changes depending on which node the key is to + ** be added to. */ + nPrefix = fts3PrefixCompress(pNode->key.a, pNode->key.n, zTerm, nTerm); + nSuffix = nTerm - nPrefix; + if(nSuffix<=0 ) return FTS_CORRUPT_VTAB; + nSpace = sqlite3Fts3VarintLen(nPrefix); + nSpace += sqlite3Fts3VarintLen(nSuffix) + nSuffix; + + if( pNode->key.n==0 || (pNode->block.n + nSpace)<=p->nNodeSize ){ + /* If the current node of layer iLayer contains zero keys, or if adding + ** the key to it will not cause it to grow to larger than nNodeSize + ** bytes in size, write the key here. */ + + Blob *pBlk = &pNode->block; + if( pBlk->n==0 ){ + blobGrowBuffer(pBlk, p->nNodeSize, &rc); + if( rc==SQLITE_OK ){ + pBlk->a[0] = (char)iLayer; + pBlk->n = 1 + sqlite3Fts3PutVarint(&pBlk->a[1], iPtr); + } + } + blobGrowBuffer(pBlk, pBlk->n + nSpace, &rc); + blobGrowBuffer(&pNode->key, nTerm, &rc); + + if( rc==SQLITE_OK ){ + if( pNode->key.n ){ + pBlk->n += sqlite3Fts3PutVarint(&pBlk->a[pBlk->n], nPrefix); + } + pBlk->n += sqlite3Fts3PutVarint(&pBlk->a[pBlk->n], nSuffix); + assert( nPrefix+nSuffix<=nTerm ); + assert( nPrefix>=0 ); + memcpy(&pBlk->a[pBlk->n], &zTerm[nPrefix], nSuffix); + pBlk->n += nSuffix; + + memcpy(pNode->key.a, zTerm, nTerm); + pNode->key.n = nTerm; + } + }else{ + /* Otherwise, flush the current node of layer iLayer to disk. + ** Then allocate a new, empty sibling node. The key will be written + ** into the parent of this node. */ + rc = fts3WriteSegment(p, pNode->iBlock, pNode->block.a, pNode->block.n); + + assert( pNode->block.nAlloc>=p->nNodeSize ); + pNode->block.a[0] = (char)iLayer; + pNode->block.n = 1 + sqlite3Fts3PutVarint(&pNode->block.a[1], iPtr+1); + + iNextPtr = pNode->iBlock; + pNode->iBlock++; + pNode->key.n = 0; + } + + if( rc!=SQLITE_OK || iNextPtr==0 ) return rc; + iPtr = iNextPtr; + } + + assert( 0 ); + return 0; +} + +/* +** Append a term and (optionally) doclist to the FTS segment node currently +** stored in blob *pNode. The node need not contain any terms, but the +** header must be written before this function is called. +** +** A node header is a single 0x00 byte for a leaf node, or a height varint +** followed by the left-hand-child varint for an internal node. +** +** The term to be appended is passed via arguments zTerm/nTerm. For a +** leaf node, the doclist is passed as aDoclist/nDoclist. For an internal +** node, both aDoclist and nDoclist must be passed 0. +** +** If the size of the value in blob pPrev is zero, then this is the first +** term written to the node. Otherwise, pPrev contains a copy of the +** previous term. Before this function returns, it is updated to contain a +** copy of zTerm/nTerm. +** +** It is assumed that the buffer associated with pNode is already large +** enough to accommodate the new entry. The buffer associated with pPrev +** is extended by this function if requrired. +** +** If an error (i.e. OOM condition) occurs, an SQLite error code is +** returned. Otherwise, SQLITE_OK. +*/ +static int fts3AppendToNode( + Blob *pNode, /* Current node image to append to */ + Blob *pPrev, /* Buffer containing previous term written */ + const char *zTerm, /* New term to write */ + int nTerm, /* Size of zTerm in bytes */ + const char *aDoclist, /* Doclist (or NULL) to write */ + int nDoclist /* Size of aDoclist in bytes */ +){ + int rc = SQLITE_OK; /* Return code */ + int bFirst = (pPrev->n==0); /* True if this is the first term written */ + int nPrefix; /* Size of term prefix in bytes */ + int nSuffix; /* Size of term suffix in bytes */ + + /* Node must have already been started. There must be a doclist for a + ** leaf node, and there must not be a doclist for an internal node. */ + assert( pNode->n>0 ); + assert_fts3_nc( (pNode->a[0]=='\0')==(aDoclist!=0) ); + + blobGrowBuffer(pPrev, nTerm, &rc); + if( rc!=SQLITE_OK ) return rc; + + nPrefix = fts3PrefixCompress(pPrev->a, pPrev->n, zTerm, nTerm); + nSuffix = nTerm - nPrefix; + if( nSuffix<=0 ) return FTS_CORRUPT_VTAB; + memcpy(pPrev->a, zTerm, nTerm); + pPrev->n = nTerm; + + if( bFirst==0 ){ + pNode->n += sqlite3Fts3PutVarint(&pNode->a[pNode->n], nPrefix); + } + pNode->n += sqlite3Fts3PutVarint(&pNode->a[pNode->n], nSuffix); + memcpy(&pNode->a[pNode->n], &zTerm[nPrefix], nSuffix); + pNode->n += nSuffix; + + if( aDoclist ){ + pNode->n += sqlite3Fts3PutVarint(&pNode->a[pNode->n], nDoclist); + memcpy(&pNode->a[pNode->n], aDoclist, nDoclist); + pNode->n += nDoclist; + } + + assert( pNode->n<=pNode->nAlloc ); + + return SQLITE_OK; +} + +/* +** Append the current term and doclist pointed to by cursor pCsr to the +** appendable b-tree segment opened for writing by pWriter. +** +** Return SQLITE_OK if successful, or an SQLite error code otherwise. +*/ +static int fts3IncrmergeAppend( + Fts3Table *p, /* Fts3 table handle */ + IncrmergeWriter *pWriter, /* Writer object */ + Fts3MultiSegReader *pCsr /* Cursor containing term and doclist */ +){ + const char *zTerm = pCsr->zTerm; + int nTerm = pCsr->nTerm; + const char *aDoclist = pCsr->aDoclist; + int nDoclist = pCsr->nDoclist; + int rc = SQLITE_OK; /* Return code */ + int nSpace; /* Total space in bytes required on leaf */ + int nPrefix; /* Size of prefix shared with previous term */ + int nSuffix; /* Size of suffix (nTerm - nPrefix) */ + NodeWriter *pLeaf; /* Object used to write leaf nodes */ + + pLeaf = &pWriter->aNodeWriter[0]; + nPrefix = fts3PrefixCompress(pLeaf->key.a, pLeaf->key.n, zTerm, nTerm); + nSuffix = nTerm - nPrefix; + if(nSuffix<=0 ) return FTS_CORRUPT_VTAB; + + nSpace = sqlite3Fts3VarintLen(nPrefix); + nSpace += sqlite3Fts3VarintLen(nSuffix) + nSuffix; + nSpace += sqlite3Fts3VarintLen(nDoclist) + nDoclist; + + /* If the current block is not empty, and if adding this term/doclist + ** to the current block would make it larger than Fts3Table.nNodeSize + ** bytes, write this block out to the database. */ + if( pLeaf->block.n>0 && (pLeaf->block.n + nSpace)>p->nNodeSize ){ + rc = fts3WriteSegment(p, pLeaf->iBlock, pLeaf->block.a, pLeaf->block.n); + pWriter->nWork++; + + /* Add the current term to the parent node. The term added to the + ** parent must: + ** + ** a) be greater than the largest term on the leaf node just written + ** to the database (still available in pLeaf->key), and + ** + ** b) be less than or equal to the term about to be added to the new + ** leaf node (zTerm/nTerm). + ** + ** In other words, it must be the prefix of zTerm 1 byte longer than + ** the common prefix (if any) of zTerm and pWriter->zTerm. + */ + if( rc==SQLITE_OK ){ + rc = fts3IncrmergePush(p, pWriter, zTerm, nPrefix+1); + } + + /* Advance to the next output block */ + pLeaf->iBlock++; + pLeaf->key.n = 0; + pLeaf->block.n = 0; + + nSuffix = nTerm; + nSpace = 1; + nSpace += sqlite3Fts3VarintLen(nSuffix) + nSuffix; + nSpace += sqlite3Fts3VarintLen(nDoclist) + nDoclist; + } + + pWriter->nLeafData += nSpace; + blobGrowBuffer(&pLeaf->block, pLeaf->block.n + nSpace, &rc); + if( rc==SQLITE_OK ){ + if( pLeaf->block.n==0 ){ + pLeaf->block.n = 1; + pLeaf->block.a[0] = '\0'; + } + rc = fts3AppendToNode( + &pLeaf->block, &pLeaf->key, zTerm, nTerm, aDoclist, nDoclist + ); + } + + return rc; +} + +/* +** This function is called to release all dynamic resources held by the +** merge-writer object pWriter, and if no error has occurred, to flush +** all outstanding node buffers held by pWriter to disk. +** +** If *pRc is not SQLITE_OK when this function is called, then no attempt +** is made to write any data to disk. Instead, this function serves only +** to release outstanding resources. +** +** Otherwise, if *pRc is initially SQLITE_OK and an error occurs while +** flushing buffers to disk, *pRc is set to an SQLite error code before +** returning. +*/ +static void fts3IncrmergeRelease( + Fts3Table *p, /* FTS3 table handle */ + IncrmergeWriter *pWriter, /* Merge-writer object */ + int *pRc /* IN/OUT: Error code */ +){ + int i; /* Used to iterate through non-root layers */ + int iRoot; /* Index of root in pWriter->aNodeWriter */ + NodeWriter *pRoot; /* NodeWriter for root node */ + int rc = *pRc; /* Error code */ + + /* Set iRoot to the index in pWriter->aNodeWriter[] of the output segment + ** root node. If the segment fits entirely on a single leaf node, iRoot + ** will be set to 0. If the root node is the parent of the leaves, iRoot + ** will be 1. And so on. */ + for(iRoot=FTS_MAX_APPENDABLE_HEIGHT-1; iRoot>=0; iRoot--){ + NodeWriter *pNode = &pWriter->aNodeWriter[iRoot]; + if( pNode->block.n>0 ) break; + assert( *pRc || pNode->block.nAlloc==0 ); + assert( *pRc || pNode->key.nAlloc==0 ); + sqlite3_free(pNode->block.a); + sqlite3_free(pNode->key.a); + } + + /* Empty output segment. This is a no-op. */ + if( iRoot<0 ) return; + + /* The entire output segment fits on a single node. Normally, this means + ** the node would be stored as a blob in the "root" column of the %_segdir + ** table. However, this is not permitted in this case. The problem is that + ** space has already been reserved in the %_segments table, and so the + ** start_block and end_block fields of the %_segdir table must be populated. + ** And, by design or by accident, released versions of FTS cannot handle + ** segments that fit entirely on the root node with start_block!=0. + ** + ** Instead, create a synthetic root node that contains nothing but a + ** pointer to the single content node. So that the segment consists of a + ** single leaf and a single interior (root) node. + ** + ** Todo: Better might be to defer allocating space in the %_segments + ** table until we are sure it is needed. + */ + if( iRoot==0 ){ + Blob *pBlock = &pWriter->aNodeWriter[1].block; + blobGrowBuffer(pBlock, 1 + FTS3_VARINT_MAX, &rc); + if( rc==SQLITE_OK ){ + pBlock->a[0] = 0x01; + pBlock->n = 1 + sqlite3Fts3PutVarint( + &pBlock->a[1], pWriter->aNodeWriter[0].iBlock + ); + } + iRoot = 1; + } + pRoot = &pWriter->aNodeWriter[iRoot]; + + /* Flush all currently outstanding nodes to disk. */ + for(i=0; iaNodeWriter[i]; + if( pNode->block.n>0 && rc==SQLITE_OK ){ + rc = fts3WriteSegment(p, pNode->iBlock, pNode->block.a, pNode->block.n); + } + sqlite3_free(pNode->block.a); + sqlite3_free(pNode->key.a); + } + + /* Write the %_segdir record. */ + if( rc==SQLITE_OK ){ + rc = fts3WriteSegdir(p, + pWriter->iAbsLevel+1, /* level */ + pWriter->iIdx, /* idx */ + pWriter->iStart, /* start_block */ + pWriter->aNodeWriter[0].iBlock, /* leaves_end_block */ + pWriter->iEnd, /* end_block */ + (pWriter->bNoLeafData==0 ? pWriter->nLeafData : 0), /* end_block */ + pRoot->block.a, pRoot->block.n /* root */ + ); + } + sqlite3_free(pRoot->block.a); + sqlite3_free(pRoot->key.a); + + *pRc = rc; +} + +/* +** Compare the term in buffer zLhs (size in bytes nLhs) with that in +** zRhs (size in bytes nRhs) using memcmp. If one term is a prefix of +** the other, it is considered to be smaller than the other. +** +** Return -ve if zLhs is smaller than zRhs, 0 if it is equal, or +ve +** if it is greater. +*/ +static int fts3TermCmp( + const char *zLhs, int nLhs, /* LHS of comparison */ + const char *zRhs, int nRhs /* RHS of comparison */ +){ + int nCmp = MIN(nLhs, nRhs); + int res; + + if( nCmp && ALWAYS(zLhs) && ALWAYS(zRhs) ){ + res = memcmp(zLhs, zRhs, nCmp); + }else{ + res = 0; + } + if( res==0 ) res = nLhs - nRhs; + + return res; +} + + +/* +** Query to see if the entry in the %_segments table with blockid iEnd is +** NULL. If no error occurs and the entry is NULL, set *pbRes 1 before +** returning. Otherwise, set *pbRes to 0. +** +** Or, if an error occurs while querying the database, return an SQLite +** error code. The final value of *pbRes is undefined in this case. +** +** This is used to test if a segment is an "appendable" segment. If it +** is, then a NULL entry has been inserted into the %_segments table +** with blockid %_segdir.end_block. +*/ +static int fts3IsAppendable(Fts3Table *p, sqlite3_int64 iEnd, int *pbRes){ + int bRes = 0; /* Result to set *pbRes to */ + sqlite3_stmt *pCheck = 0; /* Statement to query database with */ + int rc; /* Return code */ + + rc = fts3SqlStmt(p, SQL_SEGMENT_IS_APPENDABLE, &pCheck, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pCheck, 1, iEnd); + if( SQLITE_ROW==sqlite3_step(pCheck) ) bRes = 1; + rc = sqlite3_reset(pCheck); + } + + *pbRes = bRes; + return rc; +} + +/* +** This function is called when initializing an incremental-merge operation. +** It checks if the existing segment with index value iIdx at absolute level +** (iAbsLevel+1) can be appended to by the incremental merge. If it can, the +** merge-writer object *pWriter is initialized to write to it. +** +** An existing segment can be appended to by an incremental merge if: +** +** * It was initially created as an appendable segment (with all required +** space pre-allocated), and +** +** * The first key read from the input (arguments zKey and nKey) is +** greater than the largest key currently stored in the potential +** output segment. +*/ +static int fts3IncrmergeLoad( + Fts3Table *p, /* Fts3 table handle */ + sqlite3_int64 iAbsLevel, /* Absolute level of input segments */ + int iIdx, /* Index of candidate output segment */ + const char *zKey, /* First key to write */ + int nKey, /* Number of bytes in nKey */ + IncrmergeWriter *pWriter /* Populate this object */ +){ + int rc; /* Return code */ + sqlite3_stmt *pSelect = 0; /* SELECT to read %_segdir entry */ + + rc = fts3SqlStmt(p, SQL_SELECT_SEGDIR, &pSelect, 0); + if( rc==SQLITE_OK ){ + sqlite3_int64 iStart = 0; /* Value of %_segdir.start_block */ + sqlite3_int64 iLeafEnd = 0; /* Value of %_segdir.leaves_end_block */ + sqlite3_int64 iEnd = 0; /* Value of %_segdir.end_block */ + const char *aRoot = 0; /* Pointer to %_segdir.root buffer */ + int nRoot = 0; /* Size of aRoot[] in bytes */ + int rc2; /* Return code from sqlite3_reset() */ + int bAppendable = 0; /* Set to true if segment is appendable */ + + /* Read the %_segdir entry for index iIdx absolute level (iAbsLevel+1) */ + sqlite3_bind_int64(pSelect, 1, iAbsLevel+1); + sqlite3_bind_int(pSelect, 2, iIdx); + if( sqlite3_step(pSelect)==SQLITE_ROW ){ + iStart = sqlite3_column_int64(pSelect, 1); + iLeafEnd = sqlite3_column_int64(pSelect, 2); + fts3ReadEndBlockField(pSelect, 3, &iEnd, &pWriter->nLeafData); + if( pWriter->nLeafData<0 ){ + pWriter->nLeafData = pWriter->nLeafData * -1; + } + pWriter->bNoLeafData = (pWriter->nLeafData==0); + nRoot = sqlite3_column_bytes(pSelect, 4); + aRoot = sqlite3_column_blob(pSelect, 4); + if( aRoot==0 ){ + sqlite3_reset(pSelect); + return nRoot ? SQLITE_NOMEM : FTS_CORRUPT_VTAB; + } + }else{ + return sqlite3_reset(pSelect); + } + + /* Check for the zero-length marker in the %_segments table */ + rc = fts3IsAppendable(p, iEnd, &bAppendable); + + /* Check that zKey/nKey is larger than the largest key the candidate */ + if( rc==SQLITE_OK && bAppendable ){ + char *aLeaf = 0; + int nLeaf = 0; + + rc = sqlite3Fts3ReadBlock(p, iLeafEnd, &aLeaf, &nLeaf, 0); + if( rc==SQLITE_OK ){ + NodeReader reader; + for(rc = nodeReaderInit(&reader, aLeaf, nLeaf); + rc==SQLITE_OK && reader.aNode; + rc = nodeReaderNext(&reader) + ){ + assert( reader.aNode ); + } + if( fts3TermCmp(zKey, nKey, reader.term.a, reader.term.n)<=0 ){ + bAppendable = 0; + } + nodeReaderRelease(&reader); + } + sqlite3_free(aLeaf); + } + + if( rc==SQLITE_OK && bAppendable ){ + /* It is possible to append to this segment. Set up the IncrmergeWriter + ** object to do so. */ + int i; + int nHeight = (int)aRoot[0]; + NodeWriter *pNode; + if( nHeight<1 || nHeight>=FTS_MAX_APPENDABLE_HEIGHT ){ + sqlite3_reset(pSelect); + return FTS_CORRUPT_VTAB; + } + + pWriter->nLeafEst = (int)((iEnd - iStart) + 1)/FTS_MAX_APPENDABLE_HEIGHT; + pWriter->iStart = iStart; + pWriter->iEnd = iEnd; + pWriter->iAbsLevel = iAbsLevel; + pWriter->iIdx = iIdx; + + for(i=nHeight+1; iaNodeWriter[i].iBlock = pWriter->iStart + i*pWriter->nLeafEst; + } + + pNode = &pWriter->aNodeWriter[nHeight]; + pNode->iBlock = pWriter->iStart + pWriter->nLeafEst*nHeight; + blobGrowBuffer(&pNode->block, + MAX(nRoot, p->nNodeSize)+FTS3_NODE_PADDING, &rc + ); + if( rc==SQLITE_OK ){ + memcpy(pNode->block.a, aRoot, nRoot); + pNode->block.n = nRoot; + memset(&pNode->block.a[nRoot], 0, FTS3_NODE_PADDING); + } + + for(i=nHeight; i>=0 && rc==SQLITE_OK; i--){ + NodeReader reader; + pNode = &pWriter->aNodeWriter[i]; + + if( pNode->block.a){ + rc = nodeReaderInit(&reader, pNode->block.a, pNode->block.n); + while( reader.aNode && rc==SQLITE_OK ) rc = nodeReaderNext(&reader); + blobGrowBuffer(&pNode->key, reader.term.n, &rc); + if( rc==SQLITE_OK ){ + assert_fts3_nc( reader.term.n>0 || reader.aNode==0 ); + if( reader.term.n>0 ){ + memcpy(pNode->key.a, reader.term.a, reader.term.n); + } + pNode->key.n = reader.term.n; + if( i>0 ){ + char *aBlock = 0; + int nBlock = 0; + pNode = &pWriter->aNodeWriter[i-1]; + pNode->iBlock = reader.iChild; + rc = sqlite3Fts3ReadBlock(p, reader.iChild, &aBlock, &nBlock,0); + blobGrowBuffer(&pNode->block, + MAX(nBlock, p->nNodeSize)+FTS3_NODE_PADDING, &rc + ); + if( rc==SQLITE_OK ){ + memcpy(pNode->block.a, aBlock, nBlock); + pNode->block.n = nBlock; + memset(&pNode->block.a[nBlock], 0, FTS3_NODE_PADDING); + } + sqlite3_free(aBlock); + } + } + } + nodeReaderRelease(&reader); + } + } + + rc2 = sqlite3_reset(pSelect); + if( rc==SQLITE_OK ) rc = rc2; + } + + return rc; +} + +/* +** Determine the largest segment index value that exists within absolute +** level iAbsLevel+1. If no error occurs, set *piIdx to this value plus +** one before returning SQLITE_OK. Or, if there are no segments at all +** within level iAbsLevel, set *piIdx to zero. +** +** If an error occurs, return an SQLite error code. The final value of +** *piIdx is undefined in this case. +*/ +static int fts3IncrmergeOutputIdx( + Fts3Table *p, /* FTS Table handle */ + sqlite3_int64 iAbsLevel, /* Absolute index of input segments */ + int *piIdx /* OUT: Next free index at iAbsLevel+1 */ +){ + int rc; + sqlite3_stmt *pOutputIdx = 0; /* SQL used to find output index */ + + rc = fts3SqlStmt(p, SQL_NEXT_SEGMENT_INDEX, &pOutputIdx, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pOutputIdx, 1, iAbsLevel+1); + sqlite3_step(pOutputIdx); + *piIdx = sqlite3_column_int(pOutputIdx, 0); + rc = sqlite3_reset(pOutputIdx); + } + + return rc; +} + +/* +** Allocate an appendable output segment on absolute level iAbsLevel+1 +** with idx value iIdx. +** +** In the %_segdir table, a segment is defined by the values in three +** columns: +** +** start_block +** leaves_end_block +** end_block +** +** When an appendable segment is allocated, it is estimated that the +** maximum number of leaf blocks that may be required is the sum of the +** number of leaf blocks consumed by the input segments, plus the number +** of input segments, multiplied by two. This value is stored in stack +** variable nLeafEst. +** +** A total of 16*nLeafEst blocks are allocated when an appendable segment +** is created ((1 + end_block - start_block)==16*nLeafEst). The contiguous +** array of leaf nodes starts at the first block allocated. The array +** of interior nodes that are parents of the leaf nodes start at block +** (start_block + (1 + end_block - start_block) / 16). And so on. +** +** In the actual code below, the value "16" is replaced with the +** pre-processor macro FTS_MAX_APPENDABLE_HEIGHT. +*/ +static int fts3IncrmergeWriter( + Fts3Table *p, /* Fts3 table handle */ + sqlite3_int64 iAbsLevel, /* Absolute level of input segments */ + int iIdx, /* Index of new output segment */ + Fts3MultiSegReader *pCsr, /* Cursor that data will be read from */ + IncrmergeWriter *pWriter /* Populate this object */ +){ + int rc; /* Return Code */ + int i; /* Iterator variable */ + int nLeafEst = 0; /* Blocks allocated for leaf nodes */ + sqlite3_stmt *pLeafEst = 0; /* SQL used to determine nLeafEst */ + sqlite3_stmt *pFirstBlock = 0; /* SQL used to determine first block */ + + /* Calculate nLeafEst. */ + rc = fts3SqlStmt(p, SQL_MAX_LEAF_NODE_ESTIMATE, &pLeafEst, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pLeafEst, 1, iAbsLevel); + sqlite3_bind_int64(pLeafEst, 2, pCsr->nSegment); + if( SQLITE_ROW==sqlite3_step(pLeafEst) ){ + nLeafEst = sqlite3_column_int(pLeafEst, 0); + } + rc = sqlite3_reset(pLeafEst); + } + if( rc!=SQLITE_OK ) return rc; + + /* Calculate the first block to use in the output segment */ + rc = fts3SqlStmt(p, SQL_NEXT_SEGMENTS_ID, &pFirstBlock, 0); + if( rc==SQLITE_OK ){ + if( SQLITE_ROW==sqlite3_step(pFirstBlock) ){ + pWriter->iStart = sqlite3_column_int64(pFirstBlock, 0); + pWriter->iEnd = pWriter->iStart - 1; + pWriter->iEnd += nLeafEst * FTS_MAX_APPENDABLE_HEIGHT; + } + rc = sqlite3_reset(pFirstBlock); + } + if( rc!=SQLITE_OK ) return rc; + + /* Insert the marker in the %_segments table to make sure nobody tries + ** to steal the space just allocated. This is also used to identify + ** appendable segments. */ + rc = fts3WriteSegment(p, pWriter->iEnd, 0, 0); + if( rc!=SQLITE_OK ) return rc; + + pWriter->iAbsLevel = iAbsLevel; + pWriter->nLeafEst = nLeafEst; + pWriter->iIdx = iIdx; + + /* Set up the array of NodeWriter objects */ + for(i=0; iaNodeWriter[i].iBlock = pWriter->iStart + i*pWriter->nLeafEst; + } + return SQLITE_OK; +} + +/* +** Remove an entry from the %_segdir table. This involves running the +** following two statements: +** +** DELETE FROM %_segdir WHERE level = :iAbsLevel AND idx = :iIdx +** UPDATE %_segdir SET idx = idx - 1 WHERE level = :iAbsLevel AND idx > :iIdx +** +** The DELETE statement removes the specific %_segdir level. The UPDATE +** statement ensures that the remaining segments have contiguously allocated +** idx values. +*/ +static int fts3RemoveSegdirEntry( + Fts3Table *p, /* FTS3 table handle */ + sqlite3_int64 iAbsLevel, /* Absolute level to delete from */ + int iIdx /* Index of %_segdir entry to delete */ +){ + int rc; /* Return code */ + sqlite3_stmt *pDelete = 0; /* DELETE statement */ + + rc = fts3SqlStmt(p, SQL_DELETE_SEGDIR_ENTRY, &pDelete, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pDelete, 1, iAbsLevel); + sqlite3_bind_int(pDelete, 2, iIdx); + sqlite3_step(pDelete); + rc = sqlite3_reset(pDelete); + } + + return rc; +} + +/* +** One or more segments have just been removed from absolute level iAbsLevel. +** Update the 'idx' values of the remaining segments in the level so that +** the idx values are a contiguous sequence starting from 0. +*/ +static int fts3RepackSegdirLevel( + Fts3Table *p, /* FTS3 table handle */ + sqlite3_int64 iAbsLevel /* Absolute level to repack */ +){ + int rc; /* Return code */ + int *aIdx = 0; /* Array of remaining idx values */ + int nIdx = 0; /* Valid entries in aIdx[] */ + int nAlloc = 0; /* Allocated size of aIdx[] */ + int i; /* Iterator variable */ + sqlite3_stmt *pSelect = 0; /* Select statement to read idx values */ + sqlite3_stmt *pUpdate = 0; /* Update statement to modify idx values */ + + rc = fts3SqlStmt(p, SQL_SELECT_INDEXES, &pSelect, 0); + if( rc==SQLITE_OK ){ + int rc2; + sqlite3_bind_int64(pSelect, 1, iAbsLevel); + while( SQLITE_ROW==sqlite3_step(pSelect) ){ + if( nIdx>=nAlloc ){ + int *aNew; + nAlloc += 16; + aNew = sqlite3_realloc64(aIdx, nAlloc*sizeof(int)); + if( !aNew ){ + rc = SQLITE_NOMEM; + break; + } + aIdx = aNew; + } + aIdx[nIdx++] = sqlite3_column_int(pSelect, 0); + } + rc2 = sqlite3_reset(pSelect); + if( rc==SQLITE_OK ) rc = rc2; + } + + if( rc==SQLITE_OK ){ + rc = fts3SqlStmt(p, SQL_SHIFT_SEGDIR_ENTRY, &pUpdate, 0); + } + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pUpdate, 2, iAbsLevel); + } + + assert( p->bIgnoreSavepoint==0 ); + p->bIgnoreSavepoint = 1; + for(i=0; rc==SQLITE_OK && ibIgnoreSavepoint = 0; + + sqlite3_free(aIdx); + return rc; +} + +static void fts3StartNode(Blob *pNode, int iHeight, sqlite3_int64 iChild){ + pNode->a[0] = (char)iHeight; + if( iChild ){ + assert( pNode->nAlloc>=1+sqlite3Fts3VarintLen(iChild) ); + pNode->n = 1 + sqlite3Fts3PutVarint(&pNode->a[1], iChild); + }else{ + assert( pNode->nAlloc>=1 ); + pNode->n = 1; + } +} + +/* +** The first two arguments are a pointer to and the size of a segment b-tree +** node. The node may be a leaf or an internal node. +** +** This function creates a new node image in blob object *pNew by copying +** all terms that are greater than or equal to zTerm/nTerm (for leaf nodes) +** or greater than zTerm/nTerm (for internal nodes) from aNode/nNode. +*/ +static int fts3TruncateNode( + const char *aNode, /* Current node image */ + int nNode, /* Size of aNode in bytes */ + Blob *pNew, /* OUT: Write new node image here */ + const char *zTerm, /* Omit all terms smaller than this */ + int nTerm, /* Size of zTerm in bytes */ + sqlite3_int64 *piBlock /* OUT: Block number in next layer down */ +){ + NodeReader reader; /* Reader object */ + Blob prev = {0, 0, 0}; /* Previous term written to new node */ + int rc = SQLITE_OK; /* Return code */ + int bLeaf; /* True for a leaf node */ + + if( nNode<1 ) return FTS_CORRUPT_VTAB; + bLeaf = aNode[0]=='\0'; + + /* Allocate required output space */ + blobGrowBuffer(pNew, nNode, &rc); + if( rc!=SQLITE_OK ) return rc; + pNew->n = 0; + + /* Populate new node buffer */ + for(rc = nodeReaderInit(&reader, aNode, nNode); + rc==SQLITE_OK && reader.aNode; + rc = nodeReaderNext(&reader) + ){ + if( pNew->n==0 ){ + int res = fts3TermCmp(reader.term.a, reader.term.n, zTerm, nTerm); + if( res<0 || (bLeaf==0 && res==0) ) continue; + fts3StartNode(pNew, (int)aNode[0], reader.iChild); + *piBlock = reader.iChild; + } + rc = fts3AppendToNode( + pNew, &prev, reader.term.a, reader.term.n, + reader.aDoclist, reader.nDoclist + ); + if( rc!=SQLITE_OK ) break; + } + if( pNew->n==0 ){ + fts3StartNode(pNew, (int)aNode[0], reader.iChild); + *piBlock = reader.iChild; + } + assert( pNew->n<=pNew->nAlloc ); + + nodeReaderRelease(&reader); + sqlite3_free(prev.a); + return rc; +} + +/* +** Remove all terms smaller than zTerm/nTerm from segment iIdx in absolute +** level iAbsLevel. This may involve deleting entries from the %_segments +** table, and modifying existing entries in both the %_segments and %_segdir +** tables. +** +** SQLITE_OK is returned if the segment is updated successfully. Or an +** SQLite error code otherwise. +*/ +static int fts3TruncateSegment( + Fts3Table *p, /* FTS3 table handle */ + sqlite3_int64 iAbsLevel, /* Absolute level of segment to modify */ + int iIdx, /* Index within level of segment to modify */ + const char *zTerm, /* Remove terms smaller than this */ + int nTerm /* Number of bytes in buffer zTerm */ +){ + int rc = SQLITE_OK; /* Return code */ + Blob root = {0,0,0}; /* New root page image */ + Blob block = {0,0,0}; /* Buffer used for any other block */ + sqlite3_int64 iBlock = 0; /* Block id */ + sqlite3_int64 iNewStart = 0; /* New value for iStartBlock */ + sqlite3_int64 iOldStart = 0; /* Old value for iStartBlock */ + sqlite3_stmt *pFetch = 0; /* Statement used to fetch segdir */ + + rc = fts3SqlStmt(p, SQL_SELECT_SEGDIR, &pFetch, 0); + if( rc==SQLITE_OK ){ + int rc2; /* sqlite3_reset() return code */ + sqlite3_bind_int64(pFetch, 1, iAbsLevel); + sqlite3_bind_int(pFetch, 2, iIdx); + if( SQLITE_ROW==sqlite3_step(pFetch) ){ + const char *aRoot = sqlite3_column_blob(pFetch, 4); + int nRoot = sqlite3_column_bytes(pFetch, 4); + iOldStart = sqlite3_column_int64(pFetch, 1); + rc = fts3TruncateNode(aRoot, nRoot, &root, zTerm, nTerm, &iBlock); + } + rc2 = sqlite3_reset(pFetch); + if( rc==SQLITE_OK ) rc = rc2; + } + + while( rc==SQLITE_OK && iBlock ){ + char *aBlock = 0; + int nBlock = 0; + iNewStart = iBlock; + + rc = sqlite3Fts3ReadBlock(p, iBlock, &aBlock, &nBlock, 0); + if( rc==SQLITE_OK ){ + rc = fts3TruncateNode(aBlock, nBlock, &block, zTerm, nTerm, &iBlock); + } + if( rc==SQLITE_OK ){ + rc = fts3WriteSegment(p, iNewStart, block.a, block.n); + } + sqlite3_free(aBlock); + } + + /* Variable iNewStart now contains the first valid leaf node. */ + if( rc==SQLITE_OK && iNewStart ){ + sqlite3_stmt *pDel = 0; + rc = fts3SqlStmt(p, SQL_DELETE_SEGMENTS_RANGE, &pDel, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pDel, 1, iOldStart); + sqlite3_bind_int64(pDel, 2, iNewStart-1); + sqlite3_step(pDel); + rc = sqlite3_reset(pDel); + } + } + + if( rc==SQLITE_OK ){ + sqlite3_stmt *pChomp = 0; + rc = fts3SqlStmt(p, SQL_CHOMP_SEGDIR, &pChomp, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pChomp, 1, iNewStart); + sqlite3_bind_blob(pChomp, 2, root.a, root.n, SQLITE_STATIC); + sqlite3_bind_int64(pChomp, 3, iAbsLevel); + sqlite3_bind_int(pChomp, 4, iIdx); + sqlite3_step(pChomp); + rc = sqlite3_reset(pChomp); + sqlite3_bind_null(pChomp, 2); + } + } + + sqlite3_free(root.a); + sqlite3_free(block.a); + return rc; +} + +/* +** This function is called after an incrmental-merge operation has run to +** merge (or partially merge) two or more segments from absolute level +** iAbsLevel. +** +** Each input segment is either removed from the db completely (if all of +** its data was copied to the output segment by the incrmerge operation) +** or modified in place so that it no longer contains those entries that +** have been duplicated in the output segment. +*/ +static int fts3IncrmergeChomp( + Fts3Table *p, /* FTS table handle */ + sqlite3_int64 iAbsLevel, /* Absolute level containing segments */ + Fts3MultiSegReader *pCsr, /* Chomp all segments opened by this cursor */ + int *pnRem /* Number of segments not deleted */ +){ + int i; + int nRem = 0; + int rc = SQLITE_OK; + + for(i=pCsr->nSegment-1; i>=0 && rc==SQLITE_OK; i--){ + Fts3SegReader *pSeg = 0; + int j; + + /* Find the Fts3SegReader object with Fts3SegReader.iIdx==i. It is hiding + ** somewhere in the pCsr->apSegment[] array. */ + for(j=0; ALWAYS(jnSegment); j++){ + pSeg = pCsr->apSegment[j]; + if( pSeg->iIdx==i ) break; + } + assert( jnSegment && pSeg->iIdx==i ); + + if( pSeg->aNode==0 ){ + /* Seg-reader is at EOF. Remove the entire input segment. */ + rc = fts3DeleteSegment(p, pSeg); + if( rc==SQLITE_OK ){ + rc = fts3RemoveSegdirEntry(p, iAbsLevel, pSeg->iIdx); + } + *pnRem = 0; + }else{ + /* The incremental merge did not copy all the data from this + ** segment to the upper level. The segment is modified in place + ** so that it contains no keys smaller than zTerm/nTerm. */ + const char *zTerm = pSeg->zTerm; + int nTerm = pSeg->nTerm; + rc = fts3TruncateSegment(p, iAbsLevel, pSeg->iIdx, zTerm, nTerm); + nRem++; + } + } + + if( rc==SQLITE_OK && nRem!=pCsr->nSegment ){ + rc = fts3RepackSegdirLevel(p, iAbsLevel); + } + + *pnRem = nRem; + return rc; +} + +/* +** Store an incr-merge hint in the database. +*/ +static int fts3IncrmergeHintStore(Fts3Table *p, Blob *pHint){ + sqlite3_stmt *pReplace = 0; + int rc; /* Return code */ + + rc = fts3SqlStmt(p, SQL_REPLACE_STAT, &pReplace, 0); + if( rc==SQLITE_OK ){ + sqlite3_bind_int(pReplace, 1, FTS_STAT_INCRMERGEHINT); + sqlite3_bind_blob(pReplace, 2, pHint->a, pHint->n, SQLITE_STATIC); + sqlite3_step(pReplace); + rc = sqlite3_reset(pReplace); + sqlite3_bind_null(pReplace, 2); + } + + return rc; +} + +/* +** Load an incr-merge hint from the database. The incr-merge hint, if one +** exists, is stored in the rowid==1 row of the %_stat table. +** +** If successful, populate blob *pHint with the value read from the %_stat +** table and return SQLITE_OK. Otherwise, if an error occurs, return an +** SQLite error code. +*/ +static int fts3IncrmergeHintLoad(Fts3Table *p, Blob *pHint){ + sqlite3_stmt *pSelect = 0; + int rc; + + pHint->n = 0; + rc = fts3SqlStmt(p, SQL_SELECT_STAT, &pSelect, 0); + if( rc==SQLITE_OK ){ + int rc2; + sqlite3_bind_int(pSelect, 1, FTS_STAT_INCRMERGEHINT); + if( SQLITE_ROW==sqlite3_step(pSelect) ){ + const char *aHint = sqlite3_column_blob(pSelect, 0); + int nHint = sqlite3_column_bytes(pSelect, 0); + if( aHint ){ + blobGrowBuffer(pHint, nHint, &rc); + if( rc==SQLITE_OK ){ + if( ALWAYS(pHint->a!=0) ) memcpy(pHint->a, aHint, nHint); + pHint->n = nHint; + } + } + } + rc2 = sqlite3_reset(pSelect); + if( rc==SQLITE_OK ) rc = rc2; + } + + return rc; +} + +/* +** If *pRc is not SQLITE_OK when this function is called, it is a no-op. +** Otherwise, append an entry to the hint stored in blob *pHint. Each entry +** consists of two varints, the absolute level number of the input segments +** and the number of input segments. +** +** If successful, leave *pRc set to SQLITE_OK and return. If an error occurs, +** set *pRc to an SQLite error code before returning. +*/ +static void fts3IncrmergeHintPush( + Blob *pHint, /* Hint blob to append to */ + i64 iAbsLevel, /* First varint to store in hint */ + int nInput, /* Second varint to store in hint */ + int *pRc /* IN/OUT: Error code */ +){ + blobGrowBuffer(pHint, pHint->n + 2*FTS3_VARINT_MAX, pRc); + if( *pRc==SQLITE_OK ){ + pHint->n += sqlite3Fts3PutVarint(&pHint->a[pHint->n], iAbsLevel); + pHint->n += sqlite3Fts3PutVarint(&pHint->a[pHint->n], (i64)nInput); + } +} + +/* +** Read the last entry (most recently pushed) from the hint blob *pHint +** and then remove the entry. Write the two values read to *piAbsLevel and +** *pnInput before returning. +** +** If no error occurs, return SQLITE_OK. If the hint blob in *pHint does +** not contain at least two valid varints, return SQLITE_CORRUPT_VTAB. +*/ +static int fts3IncrmergeHintPop(Blob *pHint, i64 *piAbsLevel, int *pnInput){ + const int nHint = pHint->n; + int i; + + i = pHint->n-1; + if( (pHint->a[i] & 0x80) ) return FTS_CORRUPT_VTAB; + while( i>0 && (pHint->a[i-1] & 0x80) ) i--; + if( i==0 ) return FTS_CORRUPT_VTAB; + i--; + while( i>0 && (pHint->a[i-1] & 0x80) ) i--; + + pHint->n = i; + i += sqlite3Fts3GetVarint(&pHint->a[i], piAbsLevel); + i += fts3GetVarint32(&pHint->a[i], pnInput); + assert( i<=nHint ); + if( i!=nHint ) return FTS_CORRUPT_VTAB; + + return SQLITE_OK; +} + + +/* +** Attempt an incremental merge that writes nMerge leaf blocks. +** +** Incremental merges happen nMin segments at a time. The segments +** to be merged are the nMin oldest segments (the ones with the smallest +** values for the _segdir.idx field) in the highest level that contains +** at least nMin segments. Multiple merges might occur in an attempt to +** write the quota of nMerge leaf blocks. +*/ +SQLITE_PRIVATE int sqlite3Fts3Incrmerge(Fts3Table *p, int nMerge, int nMin){ + int rc; /* Return code */ + int nRem = nMerge; /* Number of leaf pages yet to be written */ + Fts3MultiSegReader *pCsr; /* Cursor used to read input data */ + Fts3SegFilter *pFilter; /* Filter used with cursor pCsr */ + IncrmergeWriter *pWriter; /* Writer object */ + int nSeg = 0; /* Number of input segments */ + sqlite3_int64 iAbsLevel = 0; /* Absolute level number to work on */ + Blob hint = {0, 0, 0}; /* Hint read from %_stat table */ + int bDirtyHint = 0; /* True if blob 'hint' has been modified */ + + /* Allocate space for the cursor, filter and writer objects */ + const int nAlloc = sizeof(*pCsr) + sizeof(*pFilter) + sizeof(*pWriter); + pWriter = (IncrmergeWriter *)sqlite3_malloc64(nAlloc); + if( !pWriter ) return SQLITE_NOMEM; + pFilter = (Fts3SegFilter *)&pWriter[1]; + pCsr = (Fts3MultiSegReader *)&pFilter[1]; + + rc = fts3IncrmergeHintLoad(p, &hint); + while( rc==SQLITE_OK && nRem>0 ){ + const i64 nMod = FTS3_SEGDIR_MAXLEVEL * p->nIndex; + sqlite3_stmt *pFindLevel = 0; /* SQL used to determine iAbsLevel */ + int bUseHint = 0; /* True if attempting to append */ + int iIdx = 0; /* Largest idx in level (iAbsLevel+1) */ + + /* Search the %_segdir table for the absolute level with the smallest + ** relative level number that contains at least nMin segments, if any. + ** If one is found, set iAbsLevel to the absolute level number and + ** nSeg to nMin. If no level with at least nMin segments can be found, + ** set nSeg to -1. + */ + rc = fts3SqlStmt(p, SQL_FIND_MERGE_LEVEL, &pFindLevel, 0); + sqlite3_bind_int(pFindLevel, 1, MAX(2, nMin)); + if( sqlite3_step(pFindLevel)==SQLITE_ROW ){ + iAbsLevel = sqlite3_column_int64(pFindLevel, 0); + nSeg = sqlite3_column_int(pFindLevel, 1); + assert( nSeg>=2 ); + }else{ + nSeg = -1; + } + rc = sqlite3_reset(pFindLevel); + + /* If the hint read from the %_stat table is not empty, check if the + ** last entry in it specifies a relative level smaller than or equal + ** to the level identified by the block above (if any). If so, this + ** iteration of the loop will work on merging at the hinted level. + */ + if( rc==SQLITE_OK && hint.n ){ + int nHint = hint.n; + sqlite3_int64 iHintAbsLevel = 0; /* Hint level */ + int nHintSeg = 0; /* Hint number of segments */ + + rc = fts3IncrmergeHintPop(&hint, &iHintAbsLevel, &nHintSeg); + if( nSeg<0 || (iAbsLevel % nMod) >= (iHintAbsLevel % nMod) ){ + /* Based on the scan in the block above, it is known that there + ** are no levels with a relative level smaller than that of + ** iAbsLevel with more than nSeg segments, or if nSeg is -1, + ** no levels with more than nMin segments. Use this to limit the + ** value of nHintSeg to avoid a large memory allocation in case the + ** merge-hint is corrupt*/ + iAbsLevel = iHintAbsLevel; + nSeg = MIN(MAX(nMin,nSeg), nHintSeg); + bUseHint = 1; + bDirtyHint = 1; + }else{ + /* This undoes the effect of the HintPop() above - so that no entry + ** is removed from the hint blob. */ + hint.n = nHint; + } + } + + /* If nSeg is less that zero, then there is no level with at least + ** nMin segments and no hint in the %_stat table. No work to do. + ** Exit early in this case. */ + if( nSeg<=0 ) break; + + assert( nMod<=0x7FFFFFFF ); + if( iAbsLevel<0 || iAbsLevel>(nMod<<32) ){ + rc = FTS_CORRUPT_VTAB; + break; + } + + /* Open a cursor to iterate through the contents of the oldest nSeg + ** indexes of absolute level iAbsLevel. If this cursor is opened using + ** the 'hint' parameters, it is possible that there are less than nSeg + ** segments available in level iAbsLevel. In this case, no work is + ** done on iAbsLevel - fall through to the next iteration of the loop + ** to start work on some other level. */ + memset(pWriter, 0, nAlloc); + pFilter->flags = FTS3_SEGMENT_REQUIRE_POS; + + if( rc==SQLITE_OK ){ + rc = fts3IncrmergeOutputIdx(p, iAbsLevel, &iIdx); + assert( bUseHint==1 || bUseHint==0 ); + if( iIdx==0 || (bUseHint && iIdx==1) ){ + int bIgnore = 0; + rc = fts3SegmentIsMaxLevel(p, iAbsLevel+1, &bIgnore); + if( bIgnore ){ + pFilter->flags |= FTS3_SEGMENT_IGNORE_EMPTY; + } + } + } + + if( rc==SQLITE_OK ){ + rc = fts3IncrmergeCsr(p, iAbsLevel, nSeg, pCsr); + } + if( SQLITE_OK==rc && pCsr->nSegment==nSeg + && SQLITE_OK==(rc = sqlite3Fts3SegReaderStart(p, pCsr, pFilter)) + ){ + int bEmpty = 0; + rc = sqlite3Fts3SegReaderStep(p, pCsr); + if( rc==SQLITE_OK ){ + bEmpty = 1; + }else if( rc!=SQLITE_ROW ){ + sqlite3Fts3SegReaderFinish(pCsr); + break; + } + if( bUseHint && iIdx>0 ){ + const char *zKey = pCsr->zTerm; + int nKey = pCsr->nTerm; + rc = fts3IncrmergeLoad(p, iAbsLevel, iIdx-1, zKey, nKey, pWriter); + }else{ + rc = fts3IncrmergeWriter(p, iAbsLevel, iIdx, pCsr, pWriter); + } + + if( rc==SQLITE_OK && pWriter->nLeafEst ){ + fts3LogMerge(nSeg, iAbsLevel); + if( bEmpty==0 ){ + do { + rc = fts3IncrmergeAppend(p, pWriter, pCsr); + if( rc==SQLITE_OK ) rc = sqlite3Fts3SegReaderStep(p, pCsr); + if( pWriter->nWork>=nRem && rc==SQLITE_ROW ) rc = SQLITE_OK; + }while( rc==SQLITE_ROW ); + } + + /* Update or delete the input segments */ + if( rc==SQLITE_OK ){ + nRem -= (1 + pWriter->nWork); + rc = fts3IncrmergeChomp(p, iAbsLevel, pCsr, &nSeg); + if( nSeg!=0 ){ + bDirtyHint = 1; + fts3IncrmergeHintPush(&hint, iAbsLevel, nSeg, &rc); + } + } + } + + if( nSeg!=0 ){ + pWriter->nLeafData = pWriter->nLeafData * -1; + } + fts3IncrmergeRelease(p, pWriter, &rc); + if( nSeg==0 && pWriter->bNoLeafData==0 ){ + fts3PromoteSegments(p, iAbsLevel+1, pWriter->nLeafData); + } + } + + sqlite3Fts3SegReaderFinish(pCsr); + } + + /* Write the hint values into the %_stat table for the next incr-merger */ + if( bDirtyHint && rc==SQLITE_OK ){ + rc = fts3IncrmergeHintStore(p, &hint); + } + + sqlite3_free(pWriter); + sqlite3_free(hint.a); + return rc; +} + +/* +** Convert the text beginning at *pz into an integer and return +** its value. Advance *pz to point to the first character past +** the integer. +** +** This function used for parameters to merge= and incrmerge= +** commands. +*/ +static int fts3Getint(const char **pz){ + const char *z = *pz; + int i = 0; + while( (*z)>='0' && (*z)<='9' && i<214748363 ) i = 10*i + *(z++) - '0'; + *pz = z; + return i; +} + +/* +** Process statements of the form: +** +** INSERT INTO table(table) VALUES('merge=A,B'); +** +** A and B are integers that decode to be the number of leaf pages +** written for the merge, and the minimum number of segments on a level +** before it will be selected for a merge, respectively. +*/ +static int fts3DoIncrmerge( + Fts3Table *p, /* FTS3 table handle */ + const char *zParam /* Nul-terminated string containing "A,B" */ +){ + int rc; + int nMin = (MergeCount(p) / 2); + int nMerge = 0; + const char *z = zParam; + + /* Read the first integer value */ + nMerge = fts3Getint(&z); + + /* If the first integer value is followed by a ',', read the second + ** integer value. */ + if( z[0]==',' && z[1]!='\0' ){ + z++; + nMin = fts3Getint(&z); + } + + if( z[0]!='\0' || nMin<2 ){ + rc = SQLITE_ERROR; + }else{ + rc = SQLITE_OK; + if( !p->bHasStat ){ + assert( p->bFts4==0 ); + sqlite3Fts3CreateStatTable(&rc, p); + } + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3Incrmerge(p, nMerge, nMin); + } + sqlite3Fts3SegmentsClose(p); + } + return rc; +} + +/* +** Process statements of the form: +** +** INSERT INTO table(table) VALUES('automerge=X'); +** +** where X is an integer. X==0 means to turn automerge off. X!=0 means +** turn it on. The setting is persistent. +*/ +static int fts3DoAutoincrmerge( + Fts3Table *p, /* FTS3 table handle */ + const char *zParam /* Nul-terminated string containing boolean */ +){ + int rc = SQLITE_OK; + sqlite3_stmt *pStmt = 0; + p->nAutoincrmerge = fts3Getint(&zParam); + if( p->nAutoincrmerge==1 || p->nAutoincrmerge>MergeCount(p) ){ + p->nAutoincrmerge = 8; + } + if( !p->bHasStat ){ + assert( p->bFts4==0 ); + sqlite3Fts3CreateStatTable(&rc, p); + if( rc ) return rc; + } + rc = fts3SqlStmt(p, SQL_REPLACE_STAT, &pStmt, 0); + if( rc ) return rc; + sqlite3_bind_int(pStmt, 1, FTS_STAT_AUTOINCRMERGE); + sqlite3_bind_int(pStmt, 2, p->nAutoincrmerge); + sqlite3_step(pStmt); + rc = sqlite3_reset(pStmt); + return rc; +} + +/* +** Return a 64-bit checksum for the FTS index entry specified by the +** arguments to this function. +*/ +static u64 fts3ChecksumEntry( + const char *zTerm, /* Pointer to buffer containing term */ + int nTerm, /* Size of zTerm in bytes */ + int iLangid, /* Language id for current row */ + int iIndex, /* Index (0..Fts3Table.nIndex-1) */ + i64 iDocid, /* Docid for current row. */ + int iCol, /* Column number */ + int iPos /* Position */ +){ + int i; + u64 ret = (u64)iDocid; + + ret += (ret<<3) + iLangid; + ret += (ret<<3) + iIndex; + ret += (ret<<3) + iCol; + ret += (ret<<3) + iPos; + for(i=0; inIndex-1) */ + int *pRc /* OUT: Return code */ +){ + Fts3SegFilter filter; + Fts3MultiSegReader csr; + int rc; + u64 cksum = 0; + + assert( *pRc==SQLITE_OK ); + + memset(&filter, 0, sizeof(filter)); + memset(&csr, 0, sizeof(csr)); + filter.flags = FTS3_SEGMENT_REQUIRE_POS|FTS3_SEGMENT_IGNORE_EMPTY; + filter.flags |= FTS3_SEGMENT_SCAN; + + rc = sqlite3Fts3SegReaderCursor( + p, iLangid, iIndex, FTS3_SEGCURSOR_ALL, 0, 0, 0, 1,&csr + ); + if( rc==SQLITE_OK ){ + rc = sqlite3Fts3SegReaderStart(p, &csr, &filter); + } + + if( rc==SQLITE_OK ){ + while( SQLITE_ROW==(rc = sqlite3Fts3SegReaderStep(p, &csr)) ){ + char *pCsr = csr.aDoclist; + char *pEnd = &pCsr[csr.nDoclist]; + + i64 iDocid = 0; + i64 iCol = 0; + u64 iPos = 0; + + pCsr += sqlite3Fts3GetVarint(pCsr, &iDocid); + while( pCsrbDescIdx ){ + iDocid = (i64)((u64)iDocid - iVal); + }else{ + iDocid = (i64)((u64)iDocid + iVal); + } + } + }else{ + iPos += (iVal - 2); + cksum = cksum ^ fts3ChecksumEntry( + csr.zTerm, csr.nTerm, iLangid, iIndex, iDocid, + (int)iCol, (int)iPos + ); + } + } + } + } + } + sqlite3Fts3SegReaderFinish(&csr); + + *pRc = rc; + return cksum; +} + +/* +** Check if the contents of the FTS index match the current contents of the +** content table. If no error occurs and the contents do match, set *pbOk +** to true and return SQLITE_OK. Or if the contents do not match, set *pbOk +** to false before returning. +** +** If an error occurs (e.g. an OOM or IO error), return an SQLite error +** code. The final value of *pbOk is undefined in this case. +*/ +static int fts3IntegrityCheck(Fts3Table *p, int *pbOk){ + int rc = SQLITE_OK; /* Return code */ + u64 cksum1 = 0; /* Checksum based on FTS index contents */ + u64 cksum2 = 0; /* Checksum based on %_content contents */ + sqlite3_stmt *pAllLangid = 0; /* Statement to return all language-ids */ + + /* This block calculates the checksum according to the FTS index. */ + rc = fts3SqlStmt(p, SQL_SELECT_ALL_LANGID, &pAllLangid, 0); + if( rc==SQLITE_OK ){ + int rc2; + sqlite3_bind_int(pAllLangid, 1, p->iPrevLangid); + sqlite3_bind_int(pAllLangid, 2, p->nIndex); + while( rc==SQLITE_OK && sqlite3_step(pAllLangid)==SQLITE_ROW ){ + int iLangid = sqlite3_column_int(pAllLangid, 0); + int i; + for(i=0; inIndex; i++){ + cksum1 = cksum1 ^ fts3ChecksumIndex(p, iLangid, i, &rc); + } + } + rc2 = sqlite3_reset(pAllLangid); + if( rc==SQLITE_OK ) rc = rc2; + } + + /* This block calculates the checksum according to the %_content table */ + if( rc==SQLITE_OK ){ + sqlite3_tokenizer_module const *pModule = p->pTokenizer->pModule; + sqlite3_stmt *pStmt = 0; + char *zSql; + + zSql = sqlite3_mprintf("SELECT %s" , p->zReadExprlist); + if( !zSql ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0); + sqlite3_free(zSql); + } + + while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ + i64 iDocid = sqlite3_column_int64(pStmt, 0); + int iLang = langidFromSelect(p, pStmt); + int iCol; + + for(iCol=0; rc==SQLITE_OK && iColnColumn; iCol++){ + if( p->abNotindexed[iCol]==0 ){ + const char *zText = (const char *)sqlite3_column_text(pStmt, iCol+1); + sqlite3_tokenizer_cursor *pT = 0; + + rc = sqlite3Fts3OpenTokenizer(p->pTokenizer, iLang, zText, -1, &pT); + while( rc==SQLITE_OK ){ + char const *zToken; /* Buffer containing token */ + int nToken = 0; /* Number of bytes in token */ + int iDum1 = 0, iDum2 = 0; /* Dummy variables */ + int iPos = 0; /* Position of token in zText */ + + rc = pModule->xNext(pT, &zToken, &nToken, &iDum1, &iDum2, &iPos); + if( rc==SQLITE_OK ){ + int i; + cksum2 = cksum2 ^ fts3ChecksumEntry( + zToken, nToken, iLang, 0, iDocid, iCol, iPos + ); + for(i=1; inIndex; i++){ + if( p->aIndex[i].nPrefix<=nToken ){ + cksum2 = cksum2 ^ fts3ChecksumEntry( + zToken, p->aIndex[i].nPrefix, iLang, i, iDocid, iCol, iPos + ); + } + } + } + } + if( pT ) pModule->xClose(pT); + if( rc==SQLITE_DONE ) rc = SQLITE_OK; + } + } + } + + sqlite3_finalize(pStmt); + } + + *pbOk = (cksum1==cksum2); + return rc; +} + +/* +** Run the integrity-check. If no error occurs and the current contents of +** the FTS index are correct, return SQLITE_OK. Or, if the contents of the +** FTS index are incorrect, return SQLITE_CORRUPT_VTAB. +** +** Or, if an error (e.g. an OOM or IO error) occurs, return an SQLite +** error code. +** +** The integrity-check works as follows. For each token and indexed token +** prefix in the document set, a 64-bit checksum is calculated (by code +** in fts3ChecksumEntry()) based on the following: +** +** + The index number (0 for the main index, 1 for the first prefix +** index etc.), +** + The token (or token prefix) text itself, +** + The language-id of the row it appears in, +** + The docid of the row it appears in, +** + The column it appears in, and +** + The tokens position within that column. +** +** The checksums for all entries in the index are XORed together to create +** a single checksum for the entire index. +** +** The integrity-check code calculates the same checksum in two ways: +** +** 1. By scanning the contents of the FTS index, and +** 2. By scanning and tokenizing the content table. +** +** If the two checksums are identical, the integrity-check is deemed to have +** passed. +*/ +static int fts3DoIntegrityCheck( + Fts3Table *p /* FTS3 table handle */ +){ + int rc; + int bOk = 0; + rc = fts3IntegrityCheck(p, &bOk); + if( rc==SQLITE_OK && bOk==0 ) rc = FTS_CORRUPT_VTAB; + return rc; +} + +/* +** Handle a 'special' INSERT of the form: +** +** "INSERT INTO tbl(tbl) VALUES()" +** +** Argument pVal contains the result of . Currently the only +** meaningful value to insert is the text 'optimize'. +*/ +static int fts3SpecialInsert(Fts3Table *p, sqlite3_value *pVal){ + int rc = SQLITE_ERROR; /* Return Code */ + const char *zVal = (const char *)sqlite3_value_text(pVal); + int nVal = sqlite3_value_bytes(pVal); + + if( !zVal ){ + return SQLITE_NOMEM; + }else if( nVal==8 && 0==sqlite3_strnicmp(zVal, "optimize", 8) ){ + rc = fts3DoOptimize(p, 0); + }else if( nVal==7 && 0==sqlite3_strnicmp(zVal, "rebuild", 7) ){ + rc = fts3DoRebuild(p); + }else if( nVal==15 && 0==sqlite3_strnicmp(zVal, "integrity-check", 15) ){ + rc = fts3DoIntegrityCheck(p); + }else if( nVal>6 && 0==sqlite3_strnicmp(zVal, "merge=", 6) ){ + rc = fts3DoIncrmerge(p, &zVal[6]); + }else if( nVal>10 && 0==sqlite3_strnicmp(zVal, "automerge=", 10) ){ + rc = fts3DoAutoincrmerge(p, &zVal[10]); +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + }else{ + int v; + if( nVal>9 && 0==sqlite3_strnicmp(zVal, "nodesize=", 9) ){ + v = atoi(&zVal[9]); + if( v>=24 && v<=p->nPgsz-35 ) p->nNodeSize = v; + rc = SQLITE_OK; + }else if( nVal>11 && 0==sqlite3_strnicmp(zVal, "maxpending=", 9) ){ + v = atoi(&zVal[11]); + if( v>=64 && v<=FTS3_MAX_PENDING_DATA ) p->nMaxPendingData = v; + rc = SQLITE_OK; + }else if( nVal>21 && 0==sqlite3_strnicmp(zVal,"test-no-incr-doclist=",21) ){ + p->bNoIncrDoclist = atoi(&zVal[21]); + rc = SQLITE_OK; + }else if( nVal>11 && 0==sqlite3_strnicmp(zVal,"mergecount=",11) ){ + v = atoi(&zVal[11]); + if( v>=4 && v<=FTS3_MERGE_COUNT && (v&1)==0 ) p->nMergeCount = v; + rc = SQLITE_OK; + } +#endif + } + return rc; +} + +#ifndef SQLITE_DISABLE_FTS4_DEFERRED +/* +** Delete all cached deferred doclists. Deferred doclists are cached +** (allocated) by the sqlite3Fts3CacheDeferredDoclists() function. +*/ +SQLITE_PRIVATE void sqlite3Fts3FreeDeferredDoclists(Fts3Cursor *pCsr){ + Fts3DeferredToken *pDef; + for(pDef=pCsr->pDeferred; pDef; pDef=pDef->pNext){ + fts3PendingListDelete(pDef->pList); + pDef->pList = 0; + } +} + +/* +** Free all entries in the pCsr->pDeffered list. Entries are added to +** this list using sqlite3Fts3DeferToken(). +*/ +SQLITE_PRIVATE void sqlite3Fts3FreeDeferredTokens(Fts3Cursor *pCsr){ + Fts3DeferredToken *pDef; + Fts3DeferredToken *pNext; + for(pDef=pCsr->pDeferred; pDef; pDef=pNext){ + pNext = pDef->pNext; + fts3PendingListDelete(pDef->pList); + sqlite3_free(pDef); + } + pCsr->pDeferred = 0; +} + +/* +** Generate deferred-doclists for all tokens in the pCsr->pDeferred list +** based on the row that pCsr currently points to. +** +** A deferred-doclist is like any other doclist with position information +** included, except that it only contains entries for a single row of the +** table, not for all rows. +*/ +SQLITE_PRIVATE int sqlite3Fts3CacheDeferredDoclists(Fts3Cursor *pCsr){ + int rc = SQLITE_OK; /* Return code */ + if( pCsr->pDeferred ){ + int i; /* Used to iterate through table columns */ + sqlite3_int64 iDocid; /* Docid of the row pCsr points to */ + Fts3DeferredToken *pDef; /* Used to iterate through deferred tokens */ + + Fts3Table *p = (Fts3Table *)pCsr->base.pVtab; + sqlite3_tokenizer *pT = p->pTokenizer; + sqlite3_tokenizer_module const *pModule = pT->pModule; + + assert( pCsr->isRequireSeek==0 ); + iDocid = sqlite3_column_int64(pCsr->pStmt, 0); + + for(i=0; inColumn && rc==SQLITE_OK; i++){ + if( p->abNotindexed[i]==0 ){ + const char *zText = (const char *)sqlite3_column_text(pCsr->pStmt, i+1); + sqlite3_tokenizer_cursor *pTC = 0; + + rc = sqlite3Fts3OpenTokenizer(pT, pCsr->iLangid, zText, -1, &pTC); + while( rc==SQLITE_OK ){ + char const *zToken; /* Buffer containing token */ + int nToken = 0; /* Number of bytes in token */ + int iDum1 = 0, iDum2 = 0; /* Dummy variables */ + int iPos = 0; /* Position of token in zText */ + + rc = pModule->xNext(pTC, &zToken, &nToken, &iDum1, &iDum2, &iPos); + for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){ + Fts3PhraseToken *pPT = pDef->pToken; + if( (pDef->iCol>=p->nColumn || pDef->iCol==i) + && (pPT->bFirst==0 || iPos==0) + && (pPT->n==nToken || (pPT->isPrefix && pPT->nz, pPT->n)) + ){ + fts3PendingListAppend(&pDef->pList, iDocid, i, iPos, &rc); + } + } + } + if( pTC ) pModule->xClose(pTC); + if( rc==SQLITE_DONE ) rc = SQLITE_OK; + } + } + + for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){ + if( pDef->pList ){ + rc = fts3PendingListAppendVarint(&pDef->pList, 0); + } + } + } + + return rc; +} + +SQLITE_PRIVATE int sqlite3Fts3DeferredTokenList( + Fts3DeferredToken *p, + char **ppData, + int *pnData +){ + char *pRet; + int nSkip; + sqlite3_int64 dummy; + + *ppData = 0; + *pnData = 0; + + if( p->pList==0 ){ + return SQLITE_OK; + } + + pRet = (char *)sqlite3_malloc64(p->pList->nData); + if( !pRet ) return SQLITE_NOMEM; + + nSkip = sqlite3Fts3GetVarint(p->pList->aData, &dummy); + *pnData = p->pList->nData - nSkip; + *ppData = pRet; + + memcpy(pRet, &p->pList->aData[nSkip], *pnData); + return SQLITE_OK; +} + +/* +** Add an entry for token pToken to the pCsr->pDeferred list. +*/ +SQLITE_PRIVATE int sqlite3Fts3DeferToken( + Fts3Cursor *pCsr, /* Fts3 table cursor */ + Fts3PhraseToken *pToken, /* Token to defer */ + int iCol /* Column that token must appear in (or -1) */ +){ + Fts3DeferredToken *pDeferred; + pDeferred = sqlite3_malloc64(sizeof(*pDeferred)); + if( !pDeferred ){ + return SQLITE_NOMEM; + } + memset(pDeferred, 0, sizeof(*pDeferred)); + pDeferred->pToken = pToken; + pDeferred->pNext = pCsr->pDeferred; + pDeferred->iCol = iCol; + pCsr->pDeferred = pDeferred; + + assert( pToken->pDeferred==0 ); + pToken->pDeferred = pDeferred; + + return SQLITE_OK; +} +#endif + +/* +** SQLite value pRowid contains the rowid of a row that may or may not be +** present in the FTS3 table. If it is, delete it and adjust the contents +** of subsiduary data structures accordingly. +*/ +static int fts3DeleteByRowid( + Fts3Table *p, + sqlite3_value *pRowid, + int *pnChng, /* IN/OUT: Decrement if row is deleted */ + u32 *aSzDel +){ + int rc = SQLITE_OK; /* Return code */ + int bFound = 0; /* True if *pRowid really is in the table */ + + fts3DeleteTerms(&rc, p, pRowid, aSzDel, &bFound); + if( bFound && rc==SQLITE_OK ){ + int isEmpty = 0; /* Deleting *pRowid leaves the table empty */ + rc = fts3IsEmpty(p, pRowid, &isEmpty); + if( rc==SQLITE_OK ){ + if( isEmpty ){ + /* Deleting this row means the whole table is empty. In this case + ** delete the contents of all three tables and throw away any + ** data in the pendingTerms hash table. */ + rc = fts3DeleteAll(p, 1); + *pnChng = 0; + memset(aSzDel, 0, sizeof(u32) * (p->nColumn+1) * 2); + }else{ + *pnChng = *pnChng - 1; + if( p->zContentTbl==0 ){ + fts3SqlExec(&rc, p, SQL_DELETE_CONTENT, &pRowid); + } + if( p->bHasDocsize ){ + fts3SqlExec(&rc, p, SQL_DELETE_DOCSIZE, &pRowid); + } + } + } + } + + return rc; +} + +/* +** This function does the work for the xUpdate method of FTS3 virtual +** tables. The schema of the virtual table being: +** +** CREATE TABLE
( +** , +**
HIDDEN, +** docid HIDDEN, +** HIDDEN +** ); +** +** +*/ +SQLITE_PRIVATE int sqlite3Fts3UpdateMethod( + sqlite3_vtab *pVtab, /* FTS3 vtab object */ + int nArg, /* Size of argument array */ + sqlite3_value **apVal, /* Array of arguments */ + sqlite_int64 *pRowid /* OUT: The affected (or effected) rowid */ +){ + Fts3Table *p = (Fts3Table *)pVtab; + int rc = SQLITE_OK; /* Return Code */ + u32 *aSzIns = 0; /* Sizes of inserted documents */ + u32 *aSzDel = 0; /* Sizes of deleted documents */ + int nChng = 0; /* Net change in number of documents */ + int bInsertDone = 0; + + /* At this point it must be known if the %_stat table exists or not. + ** So bHasStat may not be 2. */ + assert( p->bHasStat==0 || p->bHasStat==1 ); + + assert( p->pSegments==0 ); + assert( + nArg==1 /* DELETE operations */ + || nArg==(2 + p->nColumn + 3) /* INSERT or UPDATE operations */ + ); + + /* Check for a "special" INSERT operation. One of the form: + ** + ** INSERT INTO xyz(xyz) VALUES('command'); + */ + if( nArg>1 + && sqlite3_value_type(apVal[0])==SQLITE_NULL + && sqlite3_value_type(apVal[p->nColumn+2])!=SQLITE_NULL + ){ + rc = fts3SpecialInsert(p, apVal[p->nColumn+2]); + goto update_out; + } + + if( nArg>1 && sqlite3_value_int(apVal[2 + p->nColumn + 2])<0 ){ + rc = SQLITE_CONSTRAINT; + goto update_out; + } + + /* Allocate space to hold the change in document sizes */ + aSzDel = sqlite3_malloc64(sizeof(aSzDel[0])*((sqlite3_int64)p->nColumn+1)*2); + if( aSzDel==0 ){ + rc = SQLITE_NOMEM; + goto update_out; + } + aSzIns = &aSzDel[p->nColumn+1]; + memset(aSzDel, 0, sizeof(aSzDel[0])*(p->nColumn+1)*2); + + rc = fts3Writelock(p); + if( rc!=SQLITE_OK ) goto update_out; + + /* If this is an INSERT operation, or an UPDATE that modifies the rowid + ** value, then this operation requires constraint handling. + ** + ** If the on-conflict mode is REPLACE, this means that the existing row + ** should be deleted from the database before inserting the new row. Or, + ** if the on-conflict mode is other than REPLACE, then this method must + ** detect the conflict and return SQLITE_CONSTRAINT before beginning to + ** modify the database file. + */ + if( nArg>1 && p->zContentTbl==0 ){ + /* Find the value object that holds the new rowid value. */ + sqlite3_value *pNewRowid = apVal[3+p->nColumn]; + if( sqlite3_value_type(pNewRowid)==SQLITE_NULL ){ + pNewRowid = apVal[1]; + } + + if( sqlite3_value_type(pNewRowid)!=SQLITE_NULL && ( + sqlite3_value_type(apVal[0])==SQLITE_NULL + || sqlite3_value_int64(apVal[0])!=sqlite3_value_int64(pNewRowid) + )){ + /* The new rowid is not NULL (in this case the rowid will be + ** automatically assigned and there is no chance of a conflict), and + ** the statement is either an INSERT or an UPDATE that modifies the + ** rowid column. So if the conflict mode is REPLACE, then delete any + ** existing row with rowid=pNewRowid. + ** + ** Or, if the conflict mode is not REPLACE, insert the new record into + ** the %_content table. If we hit the duplicate rowid constraint (or any + ** other error) while doing so, return immediately. + ** + ** This branch may also run if pNewRowid contains a value that cannot + ** be losslessly converted to an integer. In this case, the eventual + ** call to fts3InsertData() (either just below or further on in this + ** function) will return SQLITE_MISMATCH. If fts3DeleteByRowid is + ** invoked, it will delete zero rows (since no row will have + ** docid=$pNewRowid if $pNewRowid is not an integer value). + */ + if( sqlite3_vtab_on_conflict(p->db)==SQLITE_REPLACE ){ + rc = fts3DeleteByRowid(p, pNewRowid, &nChng, aSzDel); + }else{ + rc = fts3InsertData(p, apVal, pRowid); + bInsertDone = 1; + } + } + } + if( rc!=SQLITE_OK ){ + goto update_out; + } + + /* If this is a DELETE or UPDATE operation, remove the old record. */ + if( sqlite3_value_type(apVal[0])!=SQLITE_NULL ){ + assert( sqlite3_value_type(apVal[0])==SQLITE_INTEGER ); + rc = fts3DeleteByRowid(p, apVal[0], &nChng, aSzDel); + } + + /* If this is an INSERT or UPDATE operation, insert the new record. */ + if( nArg>1 && rc==SQLITE_OK ){ + int iLangid = sqlite3_value_int(apVal[2 + p->nColumn + 2]); + if( bInsertDone==0 ){ + rc = fts3InsertData(p, apVal, pRowid); + if( rc==SQLITE_CONSTRAINT && p->zContentTbl==0 ){ + rc = FTS_CORRUPT_VTAB; + } + } + if( rc==SQLITE_OK ){ + rc = fts3PendingTermsDocid(p, 0, iLangid, *pRowid); + } + if( rc==SQLITE_OK ){ + assert( p->iPrevDocid==*pRowid ); + rc = fts3InsertTerms(p, iLangid, apVal, aSzIns); + } + if( p->bHasDocsize ){ + fts3InsertDocsize(&rc, p, aSzIns); + } + nChng++; + } + + if( p->bFts4 ){ + fts3UpdateDocTotals(&rc, p, aSzIns, aSzDel, nChng); + } + + update_out: + sqlite3_free(aSzDel); + sqlite3Fts3SegmentsClose(p); + return rc; +} + +/* +** Flush any data in the pending-terms hash table to disk. If successful, +** merge all segments in the database (including the new segment, if +** there was any data to flush) into a single segment. +*/ +SQLITE_PRIVATE int sqlite3Fts3Optimize(Fts3Table *p){ + int rc; + rc = sqlite3_exec(p->db, "SAVEPOINT fts3", 0, 0, 0); + if( rc==SQLITE_OK ){ + rc = fts3DoOptimize(p, 1); + if( rc==SQLITE_OK || rc==SQLITE_DONE ){ + int rc2 = sqlite3_exec(p->db, "RELEASE fts3", 0, 0, 0); + if( rc2!=SQLITE_OK ) rc = rc2; + }else{ + sqlite3_exec(p->db, "ROLLBACK TO fts3", 0, 0, 0); + sqlite3_exec(p->db, "RELEASE fts3", 0, 0, 0); + } + } + sqlite3Fts3SegmentsClose(p); + return rc; +} + +#endif + +/************** End of fts3_write.c ******************************************/ +/************** Begin file fts3_snippet.c ************************************/ +/* +** 2009 Oct 23 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +*/ + +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ + +#ifndef SQLITE_AMALGAMATION +typedef sqlite3_int64 i64; +#endif + +/* +** Characters that may appear in the second argument to matchinfo(). +*/ +#define FTS3_MATCHINFO_NPHRASE 'p' /* 1 value */ +#define FTS3_MATCHINFO_NCOL 'c' /* 1 value */ +#define FTS3_MATCHINFO_NDOC 'n' /* 1 value */ +#define FTS3_MATCHINFO_AVGLENGTH 'a' /* nCol values */ +#define FTS3_MATCHINFO_LENGTH 'l' /* nCol values */ +#define FTS3_MATCHINFO_LCS 's' /* nCol values */ +#define FTS3_MATCHINFO_HITS 'x' /* 3*nCol*nPhrase values */ +#define FTS3_MATCHINFO_LHITS 'y' /* nCol*nPhrase values */ +#define FTS3_MATCHINFO_LHITS_BM 'b' /* nCol*nPhrase values */ + +/* +** The default value for the second argument to matchinfo(). +*/ +#define FTS3_MATCHINFO_DEFAULT "pcx" + + +/* +** Used as an sqlite3Fts3ExprIterate() context when loading phrase doclists to +** Fts3Expr.aDoclist[]/nDoclist. +*/ +typedef struct LoadDoclistCtx LoadDoclistCtx; +struct LoadDoclistCtx { + Fts3Cursor *pCsr; /* FTS3 Cursor */ + int nPhrase; /* Number of phrases seen so far */ + int nToken; /* Number of tokens seen so far */ +}; + +/* +** The following types are used as part of the implementation of the +** fts3BestSnippet() routine. +*/ +typedef struct SnippetIter SnippetIter; +typedef struct SnippetPhrase SnippetPhrase; +typedef struct SnippetFragment SnippetFragment; + +struct SnippetIter { + Fts3Cursor *pCsr; /* Cursor snippet is being generated from */ + int iCol; /* Extract snippet from this column */ + int nSnippet; /* Requested snippet length (in tokens) */ + int nPhrase; /* Number of phrases in query */ + SnippetPhrase *aPhrase; /* Array of size nPhrase */ + int iCurrent; /* First token of current snippet */ +}; + +struct SnippetPhrase { + int nToken; /* Number of tokens in phrase */ + char *pList; /* Pointer to start of phrase position list */ + i64 iHead; /* Next value in position list */ + char *pHead; /* Position list data following iHead */ + i64 iTail; /* Next value in trailing position list */ + char *pTail; /* Position list data following iTail */ +}; + +struct SnippetFragment { + int iCol; /* Column snippet is extracted from */ + int iPos; /* Index of first token in snippet */ + u64 covered; /* Mask of query phrases covered */ + u64 hlmask; /* Mask of snippet terms to highlight */ +}; + +/* +** This type is used as an sqlite3Fts3ExprIterate() context object while +** accumulating the data returned by the matchinfo() function. +*/ +typedef struct MatchInfo MatchInfo; +struct MatchInfo { + Fts3Cursor *pCursor; /* FTS3 Cursor */ + int nCol; /* Number of columns in table */ + int nPhrase; /* Number of matchable phrases in query */ + sqlite3_int64 nDoc; /* Number of docs in database */ + char flag; + u32 *aMatchinfo; /* Pre-allocated buffer */ +}; + +/* +** An instance of this structure is used to manage a pair of buffers, each +** (nElem * sizeof(u32)) bytes in size. See the MatchinfoBuffer code below +** for details. +*/ +struct MatchinfoBuffer { + u8 aRef[3]; + int nElem; + int bGlobal; /* Set if global data is loaded */ + char *zMatchinfo; + u32 aMatchinfo[1]; +}; + + +/* +** The snippet() and offsets() functions both return text values. An instance +** of the following structure is used to accumulate those values while the +** functions are running. See fts3StringAppend() for details. +*/ +typedef struct StrBuffer StrBuffer; +struct StrBuffer { + char *z; /* Pointer to buffer containing string */ + int n; /* Length of z in bytes (excl. nul-term) */ + int nAlloc; /* Allocated size of buffer z in bytes */ +}; + + +/************************************************************************* +** Start of MatchinfoBuffer code. +*/ + +/* +** Allocate a two-slot MatchinfoBuffer object. +*/ +static MatchinfoBuffer *fts3MIBufferNew(size_t nElem, const char *zMatchinfo){ + MatchinfoBuffer *pRet; + sqlite3_int64 nByte = sizeof(u32) * (2*(sqlite3_int64)nElem + 1) + + sizeof(MatchinfoBuffer); + sqlite3_int64 nStr = strlen(zMatchinfo); + + pRet = sqlite3Fts3MallocZero(nByte + nStr+1); + if( pRet ){ + pRet->aMatchinfo[0] = (u8*)(&pRet->aMatchinfo[1]) - (u8*)pRet; + pRet->aMatchinfo[1+nElem] = pRet->aMatchinfo[0] + + sizeof(u32)*((int)nElem+1); + pRet->nElem = (int)nElem; + pRet->zMatchinfo = ((char*)pRet) + nByte; + memcpy(pRet->zMatchinfo, zMatchinfo, nStr+1); + pRet->aRef[0] = 1; + } + + return pRet; +} + +static void fts3MIBufferFree(void *p){ + MatchinfoBuffer *pBuf = (MatchinfoBuffer*)((u8*)p - ((u32*)p)[-1]); + + assert( (u32*)p==&pBuf->aMatchinfo[1] + || (u32*)p==&pBuf->aMatchinfo[pBuf->nElem+2] + ); + if( (u32*)p==&pBuf->aMatchinfo[1] ){ + pBuf->aRef[1] = 0; + }else{ + pBuf->aRef[2] = 0; + } + + if( pBuf->aRef[0]==0 && pBuf->aRef[1]==0 && pBuf->aRef[2]==0 ){ + sqlite3_free(pBuf); + } +} + +static void (*fts3MIBufferAlloc(MatchinfoBuffer *p, u32 **paOut))(void*){ + void (*xRet)(void*) = 0; + u32 *aOut = 0; + + if( p->aRef[1]==0 ){ + p->aRef[1] = 1; + aOut = &p->aMatchinfo[1]; + xRet = fts3MIBufferFree; + } + else if( p->aRef[2]==0 ){ + p->aRef[2] = 1; + aOut = &p->aMatchinfo[p->nElem+2]; + xRet = fts3MIBufferFree; + }else{ + aOut = (u32*)sqlite3_malloc64(p->nElem * sizeof(u32)); + if( aOut ){ + xRet = sqlite3_free; + if( p->bGlobal ) memcpy(aOut, &p->aMatchinfo[1], p->nElem*sizeof(u32)); + } + } + + *paOut = aOut; + return xRet; +} + +static void fts3MIBufferSetGlobal(MatchinfoBuffer *p){ + p->bGlobal = 1; + memcpy(&p->aMatchinfo[2+p->nElem], &p->aMatchinfo[1], p->nElem*sizeof(u32)); +} + +/* +** Free a MatchinfoBuffer object allocated using fts3MIBufferNew() +*/ +SQLITE_PRIVATE void sqlite3Fts3MIBufferFree(MatchinfoBuffer *p){ + if( p ){ + assert( p->aRef[0]==1 ); + p->aRef[0] = 0; + if( p->aRef[0]==0 && p->aRef[1]==0 && p->aRef[2]==0 ){ + sqlite3_free(p); + } + } +} + +/* +** End of MatchinfoBuffer code. +*************************************************************************/ + + +/* +** This function is used to help iterate through a position-list. A position +** list is a list of unique integers, sorted from smallest to largest. Each +** element of the list is represented by an FTS3 varint that takes the value +** of the difference between the current element and the previous one plus +** two. For example, to store the position-list: +** +** 4 9 113 +** +** the three varints: +** +** 6 7 106 +** +** are encoded. +** +** When this function is called, *pp points to the start of an element of +** the list. *piPos contains the value of the previous entry in the list. +** After it returns, *piPos contains the value of the next element of the +** list and *pp is advanced to the following varint. +*/ +static void fts3GetDeltaPosition(char **pp, i64 *piPos){ + int iVal; + *pp += fts3GetVarint32(*pp, &iVal); + *piPos += (iVal-2); +} + +/* +** Helper function for sqlite3Fts3ExprIterate() (see below). +*/ +static int fts3ExprIterate2( + Fts3Expr *pExpr, /* Expression to iterate phrases of */ + int *piPhrase, /* Pointer to phrase counter */ + int (*x)(Fts3Expr*,int,void*), /* Callback function to invoke for phrases */ + void *pCtx /* Second argument to pass to callback */ +){ + int rc; /* Return code */ + int eType = pExpr->eType; /* Type of expression node pExpr */ + + if( eType!=FTSQUERY_PHRASE ){ + assert( pExpr->pLeft && pExpr->pRight ); + rc = fts3ExprIterate2(pExpr->pLeft, piPhrase, x, pCtx); + if( rc==SQLITE_OK && eType!=FTSQUERY_NOT ){ + rc = fts3ExprIterate2(pExpr->pRight, piPhrase, x, pCtx); + } + }else{ + rc = x(pExpr, *piPhrase, pCtx); + (*piPhrase)++; + } + return rc; +} + +/* +** Iterate through all phrase nodes in an FTS3 query, except those that +** are part of a sub-tree that is the right-hand-side of a NOT operator. +** For each phrase node found, the supplied callback function is invoked. +** +** If the callback function returns anything other than SQLITE_OK, +** the iteration is abandoned and the error code returned immediately. +** Otherwise, SQLITE_OK is returned after a callback has been made for +** all eligible phrase nodes. +*/ +SQLITE_PRIVATE int sqlite3Fts3ExprIterate( + Fts3Expr *pExpr, /* Expression to iterate phrases of */ + int (*x)(Fts3Expr*,int,void*), /* Callback function to invoke for phrases */ + void *pCtx /* Second argument to pass to callback */ +){ + int iPhrase = 0; /* Variable used as the phrase counter */ + return fts3ExprIterate2(pExpr, &iPhrase, x, pCtx); +} + +/* +** This is an sqlite3Fts3ExprIterate() callback used while loading the +** doclists for each phrase into Fts3Expr.aDoclist[]/nDoclist. See also +** fts3ExprLoadDoclists(). +*/ +static int fts3ExprLoadDoclistsCb(Fts3Expr *pExpr, int iPhrase, void *ctx){ + int rc = SQLITE_OK; + Fts3Phrase *pPhrase = pExpr->pPhrase; + LoadDoclistCtx *p = (LoadDoclistCtx *)ctx; + + UNUSED_PARAMETER(iPhrase); + + p->nPhrase++; + p->nToken += pPhrase->nToken; + + return rc; +} + +/* +** Load the doclists for each phrase in the query associated with FTS3 cursor +** pCsr. +** +** If pnPhrase is not NULL, then *pnPhrase is set to the number of matchable +** phrases in the expression (all phrases except those directly or +** indirectly descended from the right-hand-side of a NOT operator). If +** pnToken is not NULL, then it is set to the number of tokens in all +** matchable phrases of the expression. +*/ +static int fts3ExprLoadDoclists( + Fts3Cursor *pCsr, /* Fts3 cursor for current query */ + int *pnPhrase, /* OUT: Number of phrases in query */ + int *pnToken /* OUT: Number of tokens in query */ +){ + int rc; /* Return Code */ + LoadDoclistCtx sCtx = {0,0,0}; /* Context for sqlite3Fts3ExprIterate() */ + sCtx.pCsr = pCsr; + rc = sqlite3Fts3ExprIterate(pCsr->pExpr,fts3ExprLoadDoclistsCb,(void*)&sCtx); + if( pnPhrase ) *pnPhrase = sCtx.nPhrase; + if( pnToken ) *pnToken = sCtx.nToken; + return rc; +} + +static int fts3ExprPhraseCountCb(Fts3Expr *pExpr, int iPhrase, void *ctx){ + (*(int *)ctx)++; + pExpr->iPhrase = iPhrase; + return SQLITE_OK; +} +static int fts3ExprPhraseCount(Fts3Expr *pExpr){ + int nPhrase = 0; + (void)sqlite3Fts3ExprIterate(pExpr, fts3ExprPhraseCountCb, (void *)&nPhrase); + return nPhrase; +} + +/* +** Advance the position list iterator specified by the first two +** arguments so that it points to the first element with a value greater +** than or equal to parameter iNext. +*/ +static void fts3SnippetAdvance(char **ppIter, i64 *piIter, int iNext){ + char *pIter = *ppIter; + if( pIter ){ + i64 iIter = *piIter; + + while( iIteriCurrent<0 ){ + /* The SnippetIter object has just been initialized. The first snippet + ** candidate always starts at offset 0 (even if this candidate has a + ** score of 0.0). + */ + pIter->iCurrent = 0; + + /* Advance the 'head' iterator of each phrase to the first offset that + ** is greater than or equal to (iNext+nSnippet). + */ + for(i=0; inPhrase; i++){ + SnippetPhrase *pPhrase = &pIter->aPhrase[i]; + fts3SnippetAdvance(&pPhrase->pHead, &pPhrase->iHead, pIter->nSnippet); + } + }else{ + int iStart; + int iEnd = 0x7FFFFFFF; + + for(i=0; inPhrase; i++){ + SnippetPhrase *pPhrase = &pIter->aPhrase[i]; + if( pPhrase->pHead && pPhrase->iHeadiHead; + } + } + if( iEnd==0x7FFFFFFF ){ + return 1; + } + + pIter->iCurrent = iStart = iEnd - pIter->nSnippet + 1; + for(i=0; inPhrase; i++){ + SnippetPhrase *pPhrase = &pIter->aPhrase[i]; + fts3SnippetAdvance(&pPhrase->pHead, &pPhrase->iHead, iEnd+1); + fts3SnippetAdvance(&pPhrase->pTail, &pPhrase->iTail, iStart); + } + } + + return 0; +} + +/* +** Retrieve information about the current candidate snippet of snippet +** iterator pIter. +*/ +static void fts3SnippetDetails( + SnippetIter *pIter, /* Snippet iterator */ + u64 mCovered, /* Bitmask of phrases already covered */ + int *piToken, /* OUT: First token of proposed snippet */ + int *piScore, /* OUT: "Score" for this snippet */ + u64 *pmCover, /* OUT: Bitmask of phrases covered */ + u64 *pmHighlight /* OUT: Bitmask of terms to highlight */ +){ + int iStart = pIter->iCurrent; /* First token of snippet */ + int iScore = 0; /* Score of this snippet */ + int i; /* Loop counter */ + u64 mCover = 0; /* Mask of phrases covered by this snippet */ + u64 mHighlight = 0; /* Mask of tokens to highlight in snippet */ + + for(i=0; inPhrase; i++){ + SnippetPhrase *pPhrase = &pIter->aPhrase[i]; + if( pPhrase->pTail ){ + char *pCsr = pPhrase->pTail; + i64 iCsr = pPhrase->iTail; + + while( iCsr<(iStart+pIter->nSnippet) && iCsr>=iStart ){ + int j; + u64 mPhrase = (u64)1 << (i%64); + u64 mPos = (u64)1 << (iCsr - iStart); + assert( iCsr>=iStart && (iCsr - iStart)<=64 ); + assert( i>=0 ); + if( (mCover|mCovered)&mPhrase ){ + iScore++; + }else{ + iScore += 1000; + } + mCover |= mPhrase; + + for(j=0; jnToken; j++){ + mHighlight |= (mPos>>j); + } + + if( 0==(*pCsr & 0x0FE) ) break; + fts3GetDeltaPosition(&pCsr, &iCsr); + } + } + } + + /* Set the output variables before returning. */ + *piToken = iStart; + *piScore = iScore; + *pmCover = mCover; + *pmHighlight = mHighlight; +} + +/* +** This function is an sqlite3Fts3ExprIterate() callback used by +** fts3BestSnippet(). Each invocation populates an element of the +** SnippetIter.aPhrase[] array. +*/ +static int fts3SnippetFindPositions(Fts3Expr *pExpr, int iPhrase, void *ctx){ + SnippetIter *p = (SnippetIter *)ctx; + SnippetPhrase *pPhrase = &p->aPhrase[iPhrase]; + char *pCsr; + int rc; + + pPhrase->nToken = pExpr->pPhrase->nToken; + rc = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol, &pCsr); + assert( rc==SQLITE_OK || pCsr==0 ); + if( pCsr ){ + i64 iFirst = 0; + pPhrase->pList = pCsr; + fts3GetDeltaPosition(&pCsr, &iFirst); + if( iFirst<0 ){ + rc = FTS_CORRUPT_VTAB; + }else{ + pPhrase->pHead = pCsr; + pPhrase->pTail = pCsr; + pPhrase->iHead = iFirst; + pPhrase->iTail = iFirst; + } + }else{ + assert( rc!=SQLITE_OK || ( + pPhrase->pList==0 && pPhrase->pHead==0 && pPhrase->pTail==0 + )); + } + + return rc; +} + +/* +** Select the fragment of text consisting of nFragment contiguous tokens +** from column iCol that represent the "best" snippet. The best snippet +** is the snippet with the highest score, where scores are calculated +** by adding: +** +** (a) +1 point for each occurrence of a matchable phrase in the snippet. +** +** (b) +1000 points for the first occurrence of each matchable phrase in +** the snippet for which the corresponding mCovered bit is not set. +** +** The selected snippet parameters are stored in structure *pFragment before +** returning. The score of the selected snippet is stored in *piScore +** before returning. +*/ +static int fts3BestSnippet( + int nSnippet, /* Desired snippet length */ + Fts3Cursor *pCsr, /* Cursor to create snippet for */ + int iCol, /* Index of column to create snippet from */ + u64 mCovered, /* Mask of phrases already covered */ + u64 *pmSeen, /* IN/OUT: Mask of phrases seen */ + SnippetFragment *pFragment, /* OUT: Best snippet found */ + int *piScore /* OUT: Score of snippet pFragment */ +){ + int rc; /* Return Code */ + int nList; /* Number of phrases in expression */ + SnippetIter sIter; /* Iterates through snippet candidates */ + sqlite3_int64 nByte; /* Number of bytes of space to allocate */ + int iBestScore = -1; /* Best snippet score found so far */ + int i; /* Loop counter */ + + memset(&sIter, 0, sizeof(sIter)); + + /* Iterate through the phrases in the expression to count them. The same + ** callback makes sure the doclists are loaded for each phrase. + */ + rc = fts3ExprLoadDoclists(pCsr, &nList, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + + /* Now that it is known how many phrases there are, allocate and zero + ** the required space using malloc(). + */ + nByte = sizeof(SnippetPhrase) * nList; + sIter.aPhrase = (SnippetPhrase *)sqlite3Fts3MallocZero(nByte); + if( !sIter.aPhrase ){ + return SQLITE_NOMEM; + } + + /* Initialize the contents of the SnippetIter object. Then iterate through + ** the set of phrases in the expression to populate the aPhrase[] array. + */ + sIter.pCsr = pCsr; + sIter.iCol = iCol; + sIter.nSnippet = nSnippet; + sIter.nPhrase = nList; + sIter.iCurrent = -1; + rc = sqlite3Fts3ExprIterate( + pCsr->pExpr, fts3SnippetFindPositions, (void*)&sIter + ); + if( rc==SQLITE_OK ){ + + /* Set the *pmSeen output variable. */ + for(i=0; iiCol = iCol; + while( !fts3SnippetNextCandidate(&sIter) ){ + int iPos; + int iScore; + u64 mCover; + u64 mHighlite; + fts3SnippetDetails(&sIter, mCovered, &iPos, &iScore, &mCover,&mHighlite); + assert( iScore>=0 ); + if( iScore>iBestScore ){ + pFragment->iPos = iPos; + pFragment->hlmask = mHighlite; + pFragment->covered = mCover; + iBestScore = iScore; + } + } + + *piScore = iBestScore; + } + sqlite3_free(sIter.aPhrase); + return rc; +} + + +/* +** Append a string to the string-buffer passed as the first argument. +** +** If nAppend is negative, then the length of the string zAppend is +** determined using strlen(). +*/ +static int fts3StringAppend( + StrBuffer *pStr, /* Buffer to append to */ + const char *zAppend, /* Pointer to data to append to buffer */ + int nAppend /* Size of zAppend in bytes (or -1) */ +){ + if( nAppend<0 ){ + nAppend = (int)strlen(zAppend); + } + + /* If there is insufficient space allocated at StrBuffer.z, use realloc() + ** to grow the buffer until so that it is big enough to accomadate the + ** appended data. + */ + if( pStr->n+nAppend+1>=pStr->nAlloc ){ + sqlite3_int64 nAlloc = pStr->nAlloc+(sqlite3_int64)nAppend+100; + char *zNew = sqlite3_realloc64(pStr->z, nAlloc); + if( !zNew ){ + return SQLITE_NOMEM; + } + pStr->z = zNew; + pStr->nAlloc = nAlloc; + } + assert( pStr->z!=0 && (pStr->nAlloc >= pStr->n+nAppend+1) ); + + /* Append the data to the string buffer. */ + memcpy(&pStr->z[pStr->n], zAppend, nAppend); + pStr->n += nAppend; + pStr->z[pStr->n] = '\0'; + + return SQLITE_OK; +} + +/* +** The fts3BestSnippet() function often selects snippets that end with a +** query term. That is, the final term of the snippet is always a term +** that requires highlighting. For example, if 'X' is a highlighted term +** and '.' is a non-highlighted term, BestSnippet() may select: +** +** ........X.....X +** +** This function "shifts" the beginning of the snippet forward in the +** document so that there are approximately the same number of +** non-highlighted terms to the right of the final highlighted term as there +** are to the left of the first highlighted term. For example, to this: +** +** ....X.....X.... +** +** This is done as part of extracting the snippet text, not when selecting +** the snippet. Snippet selection is done based on doclists only, so there +** is no way for fts3BestSnippet() to know whether or not the document +** actually contains terms that follow the final highlighted term. +*/ +static int fts3SnippetShift( + Fts3Table *pTab, /* FTS3 table snippet comes from */ + int iLangid, /* Language id to use in tokenizing */ + int nSnippet, /* Number of tokens desired for snippet */ + const char *zDoc, /* Document text to extract snippet from */ + int nDoc, /* Size of buffer zDoc in bytes */ + int *piPos, /* IN/OUT: First token of snippet */ + u64 *pHlmask /* IN/OUT: Mask of tokens to highlight */ +){ + u64 hlmask = *pHlmask; /* Local copy of initial highlight-mask */ + + if( hlmask ){ + int nLeft; /* Tokens to the left of first highlight */ + int nRight; /* Tokens to the right of last highlight */ + int nDesired; /* Ideal number of tokens to shift forward */ + + for(nLeft=0; !(hlmask & ((u64)1 << nLeft)); nLeft++); + for(nRight=0; !(hlmask & ((u64)1 << (nSnippet-1-nRight))); nRight++); + assert( (nSnippet-1-nRight)<=63 && (nSnippet-1-nRight)>=0 ); + nDesired = (nLeft-nRight)/2; + + /* Ideally, the start of the snippet should be pushed forward in the + ** document nDesired tokens. This block checks if there are actually + ** nDesired tokens to the right of the snippet. If so, *piPos and + ** *pHlMask are updated to shift the snippet nDesired tokens to the + ** right. Otherwise, the snippet is shifted by the number of tokens + ** available. + */ + if( nDesired>0 ){ + int nShift; /* Number of tokens to shift snippet by */ + int iCurrent = 0; /* Token counter */ + int rc; /* Return Code */ + sqlite3_tokenizer_module *pMod; + sqlite3_tokenizer_cursor *pC; + pMod = (sqlite3_tokenizer_module *)pTab->pTokenizer->pModule; + + /* Open a cursor on zDoc/nDoc. Check if there are (nSnippet+nDesired) + ** or more tokens in zDoc/nDoc. + */ + rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, iLangid, zDoc, nDoc, &pC); + if( rc!=SQLITE_OK ){ + return rc; + } + while( rc==SQLITE_OK && iCurrent<(nSnippet+nDesired) ){ + const char *ZDUMMY; int DUMMY1 = 0, DUMMY2 = 0, DUMMY3 = 0; + rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &DUMMY2, &DUMMY3, &iCurrent); + } + pMod->xClose(pC); + if( rc!=SQLITE_OK && rc!=SQLITE_DONE ){ return rc; } + + nShift = (rc==SQLITE_DONE)+iCurrent-nSnippet; + assert( nShift<=nDesired ); + if( nShift>0 ){ + *piPos += nShift; + *pHlmask = hlmask >> nShift; + } + } + } + return SQLITE_OK; +} + +/* +** Extract the snippet text for fragment pFragment from cursor pCsr and +** append it to string buffer pOut. +*/ +static int fts3SnippetText( + Fts3Cursor *pCsr, /* FTS3 Cursor */ + SnippetFragment *pFragment, /* Snippet to extract */ + int iFragment, /* Fragment number */ + int isLast, /* True for final fragment in snippet */ + int nSnippet, /* Number of tokens in extracted snippet */ + const char *zOpen, /* String inserted before highlighted term */ + const char *zClose, /* String inserted after highlighted term */ + const char *zEllipsis, /* String inserted between snippets */ + StrBuffer *pOut /* Write output here */ +){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int rc; /* Return code */ + const char *zDoc; /* Document text to extract snippet from */ + int nDoc; /* Size of zDoc in bytes */ + int iCurrent = 0; /* Current token number of document */ + int iEnd = 0; /* Byte offset of end of current token */ + int isShiftDone = 0; /* True after snippet is shifted */ + int iPos = pFragment->iPos; /* First token of snippet */ + u64 hlmask = pFragment->hlmask; /* Highlight-mask for snippet */ + int iCol = pFragment->iCol+1; /* Query column to extract text from */ + sqlite3_tokenizer_module *pMod; /* Tokenizer module methods object */ + sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor open on zDoc/nDoc */ + + zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol); + if( zDoc==0 ){ + if( sqlite3_column_type(pCsr->pStmt, iCol)!=SQLITE_NULL ){ + return SQLITE_NOMEM; + } + return SQLITE_OK; + } + nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol); + + /* Open a token cursor on the document. */ + pMod = (sqlite3_tokenizer_module *)pTab->pTokenizer->pModule; + rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid, zDoc,nDoc,&pC); + if( rc!=SQLITE_OK ){ + return rc; + } + + while( rc==SQLITE_OK ){ + const char *ZDUMMY; /* Dummy argument used with tokenizer */ + int DUMMY1 = -1; /* Dummy argument used with tokenizer */ + int iBegin = 0; /* Offset in zDoc of start of token */ + int iFin = 0; /* Offset in zDoc of end of token */ + int isHighlight = 0; /* True for highlighted terms */ + + /* Variable DUMMY1 is initialized to a negative value above. Elsewhere + ** in the FTS code the variable that the third argument to xNext points to + ** is initialized to zero before the first (*but not necessarily + ** subsequent*) call to xNext(). This is done for a particular application + ** that needs to know whether or not the tokenizer is being used for + ** snippet generation or for some other purpose. + ** + ** Extreme care is required when writing code to depend on this + ** initialization. It is not a documented part of the tokenizer interface. + ** If a tokenizer is used directly by any code outside of FTS, this + ** convention might not be respected. */ + rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &iBegin, &iFin, &iCurrent); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_DONE ){ + /* Special case - the last token of the snippet is also the last token + ** of the column. Append any punctuation that occurred between the end + ** of the previous token and the end of the document to the output. + ** Then break out of the loop. */ + rc = fts3StringAppend(pOut, &zDoc[iEnd], -1); + } + break; + } + if( iCurrentiLangid, nSnippet, &zDoc[iBegin], n, &iPos, &hlmask + ); + isShiftDone = 1; + + /* Now that the shift has been done, check if the initial "..." are + ** required. They are required if (a) this is not the first fragment, + ** or (b) this fragment does not begin at position 0 of its column. + */ + if( rc==SQLITE_OK ){ + if( iPos>0 || iFragment>0 ){ + rc = fts3StringAppend(pOut, zEllipsis, -1); + }else if( iBegin ){ + rc = fts3StringAppend(pOut, zDoc, iBegin); + } + } + if( rc!=SQLITE_OK || iCurrent=(iPos+nSnippet) ){ + if( isLast ){ + rc = fts3StringAppend(pOut, zEllipsis, -1); + } + break; + } + + /* Set isHighlight to true if this term should be highlighted. */ + isHighlight = (hlmask & ((u64)1 << (iCurrent-iPos)))!=0; + + if( iCurrent>iPos ) rc = fts3StringAppend(pOut, &zDoc[iEnd], iBegin-iEnd); + if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zOpen, -1); + if( rc==SQLITE_OK ) rc = fts3StringAppend(pOut, &zDoc[iBegin], iFin-iBegin); + if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zClose, -1); + + iEnd = iFin; + } + + pMod->xClose(pC); + return rc; +} + + +/* +** This function is used to count the entries in a column-list (a +** delta-encoded list of term offsets within a single column of a single +** row). When this function is called, *ppCollist should point to the +** beginning of the first varint in the column-list (the varint that +** contains the position of the first matching term in the column data). +** Before returning, *ppCollist is set to point to the first byte after +** the last varint in the column-list (either the 0x00 signifying the end +** of the position-list, or the 0x01 that precedes the column number of +** the next column in the position-list). +** +** The number of elements in the column-list is returned. +*/ +static int fts3ColumnlistCount(char **ppCollist){ + char *pEnd = *ppCollist; + char c = 0; + int nEntry = 0; + + /* A column-list is terminated by either a 0x01 or 0x00. */ + while( 0xFE & (*pEnd | c) ){ + c = *pEnd++ & 0x80; + if( !c ) nEntry++; + } + + *ppCollist = pEnd; + return nEntry; +} + +/* +** This function gathers 'y' or 'b' data for a single phrase. +*/ +static int fts3ExprLHits( + Fts3Expr *pExpr, /* Phrase expression node */ + MatchInfo *p /* Matchinfo context */ +){ + Fts3Table *pTab = (Fts3Table *)p->pCursor->base.pVtab; + int iStart; + Fts3Phrase *pPhrase = pExpr->pPhrase; + char *pIter = pPhrase->doclist.pList; + int iCol = 0; + + assert( p->flag==FTS3_MATCHINFO_LHITS_BM || p->flag==FTS3_MATCHINFO_LHITS ); + if( p->flag==FTS3_MATCHINFO_LHITS ){ + iStart = pExpr->iPhrase * p->nCol; + }else{ + iStart = pExpr->iPhrase * ((p->nCol + 31) / 32); + } + + if( pIter ) while( 1 ){ + int nHit = fts3ColumnlistCount(&pIter); + if( (pPhrase->iColumn>=pTab->nColumn || pPhrase->iColumn==iCol) ){ + if( p->flag==FTS3_MATCHINFO_LHITS ){ + p->aMatchinfo[iStart + iCol] = (u32)nHit; + }else if( nHit ){ + p->aMatchinfo[iStart + (iCol+1)/32] |= (1 << (iCol&0x1F)); + } + } + assert( *pIter==0x00 || *pIter==0x01 ); + if( *pIter!=0x01 ) break; + pIter++; + pIter += fts3GetVarint32(pIter, &iCol); + if( iCol>=p->nCol ) return FTS_CORRUPT_VTAB; + } + return SQLITE_OK; +} + +/* +** Gather the results for matchinfo directives 'y' and 'b'. +*/ +static int fts3ExprLHitGather( + Fts3Expr *pExpr, + MatchInfo *p +){ + int rc = SQLITE_OK; + assert( (pExpr->pLeft==0)==(pExpr->pRight==0) ); + if( pExpr->bEof==0 && pExpr->iDocid==p->pCursor->iPrevId ){ + if( pExpr->pLeft ){ + rc = fts3ExprLHitGather(pExpr->pLeft, p); + if( rc==SQLITE_OK ) rc = fts3ExprLHitGather(pExpr->pRight, p); + }else{ + rc = fts3ExprLHits(pExpr, p); + } + } + return rc; +} + +/* +** sqlite3Fts3ExprIterate() callback used to collect the "global" matchinfo +** stats for a single query. +** +** sqlite3Fts3ExprIterate() callback to load the 'global' elements of a +** FTS3_MATCHINFO_HITS matchinfo array. The global stats are those elements +** of the matchinfo array that are constant for all rows returned by the +** current query. +** +** Argument pCtx is actually a pointer to a struct of type MatchInfo. This +** function populates Matchinfo.aMatchinfo[] as follows: +** +** for(iCol=0; iColpCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol] + ); +} + +/* +** sqlite3Fts3ExprIterate() callback used to collect the "local" part of the +** FTS3_MATCHINFO_HITS array. The local stats are those elements of the +** array that are different for each row returned by the query. +*/ +static int fts3ExprLocalHitsCb( + Fts3Expr *pExpr, /* Phrase expression node */ + int iPhrase, /* Phrase number */ + void *pCtx /* Pointer to MatchInfo structure */ +){ + int rc = SQLITE_OK; + MatchInfo *p = (MatchInfo *)pCtx; + int iStart = iPhrase * p->nCol * 3; + int i; + + for(i=0; inCol && rc==SQLITE_OK; i++){ + char *pCsr; + rc = sqlite3Fts3EvalPhrasePoslist(p->pCursor, pExpr, i, &pCsr); + if( pCsr ){ + p->aMatchinfo[iStart+i*3] = fts3ColumnlistCount(&pCsr); + }else{ + p->aMatchinfo[iStart+i*3] = 0; + } + } + + return rc; +} + +static int fts3MatchinfoCheck( + Fts3Table *pTab, + char cArg, + char **pzErr +){ + if( (cArg==FTS3_MATCHINFO_NPHRASE) + || (cArg==FTS3_MATCHINFO_NCOL) + || (cArg==FTS3_MATCHINFO_NDOC && pTab->bFts4) + || (cArg==FTS3_MATCHINFO_AVGLENGTH && pTab->bFts4) + || (cArg==FTS3_MATCHINFO_LENGTH && pTab->bHasDocsize) + || (cArg==FTS3_MATCHINFO_LCS) + || (cArg==FTS3_MATCHINFO_HITS) + || (cArg==FTS3_MATCHINFO_LHITS) + || (cArg==FTS3_MATCHINFO_LHITS_BM) + ){ + return SQLITE_OK; + } + sqlite3Fts3ErrMsg(pzErr, "unrecognized matchinfo request: %c", cArg); + return SQLITE_ERROR; +} + +static size_t fts3MatchinfoSize(MatchInfo *pInfo, char cArg){ + size_t nVal; /* Number of integers output by cArg */ + + switch( cArg ){ + case FTS3_MATCHINFO_NDOC: + case FTS3_MATCHINFO_NPHRASE: + case FTS3_MATCHINFO_NCOL: + nVal = 1; + break; + + case FTS3_MATCHINFO_AVGLENGTH: + case FTS3_MATCHINFO_LENGTH: + case FTS3_MATCHINFO_LCS: + nVal = pInfo->nCol; + break; + + case FTS3_MATCHINFO_LHITS: + nVal = pInfo->nCol * pInfo->nPhrase; + break; + + case FTS3_MATCHINFO_LHITS_BM: + nVal = pInfo->nPhrase * ((pInfo->nCol + 31) / 32); + break; + + default: + assert( cArg==FTS3_MATCHINFO_HITS ); + nVal = pInfo->nCol * pInfo->nPhrase * 3; + break; + } + + return nVal; +} + +static int fts3MatchinfoSelectDoctotal( + Fts3Table *pTab, + sqlite3_stmt **ppStmt, + sqlite3_int64 *pnDoc, + const char **paLen, + const char **ppEnd +){ + sqlite3_stmt *pStmt; + const char *a; + const char *pEnd; + sqlite3_int64 nDoc; + int n; + + + if( !*ppStmt ){ + int rc = sqlite3Fts3SelectDoctotal(pTab, ppStmt); + if( rc!=SQLITE_OK ) return rc; + } + pStmt = *ppStmt; + assert( sqlite3_data_count(pStmt)==1 ); + + n = sqlite3_column_bytes(pStmt, 0); + a = sqlite3_column_blob(pStmt, 0); + if( a==0 ){ + return FTS_CORRUPT_VTAB; + } + pEnd = a + n; + a += sqlite3Fts3GetVarintBounded(a, pEnd, &nDoc); + if( nDoc<=0 || a>pEnd ){ + return FTS_CORRUPT_VTAB; + } + *pnDoc = nDoc; + + if( paLen ) *paLen = a; + if( ppEnd ) *ppEnd = pEnd; + return SQLITE_OK; +} + +/* +** An instance of the following structure is used to store state while +** iterating through a multi-column position-list corresponding to the +** hits for a single phrase on a single row in order to calculate the +** values for a matchinfo() FTS3_MATCHINFO_LCS request. +*/ +typedef struct LcsIterator LcsIterator; +struct LcsIterator { + Fts3Expr *pExpr; /* Pointer to phrase expression */ + int iPosOffset; /* Tokens count up to end of this phrase */ + char *pRead; /* Cursor used to iterate through aDoclist */ + int iPos; /* Current position */ +}; + +/* +** If LcsIterator.iCol is set to the following value, the iterator has +** finished iterating through all offsets for all columns. +*/ +#define LCS_ITERATOR_FINISHED 0x7FFFFFFF; + +static int fts3MatchinfoLcsCb( + Fts3Expr *pExpr, /* Phrase expression node */ + int iPhrase, /* Phrase number (numbered from zero) */ + void *pCtx /* Pointer to MatchInfo structure */ +){ + LcsIterator *aIter = (LcsIterator *)pCtx; + aIter[iPhrase].pExpr = pExpr; + return SQLITE_OK; +} + +/* +** Advance the iterator passed as an argument to the next position. Return +** 1 if the iterator is at EOF or if it now points to the start of the +** position list for the next column. +*/ +static int fts3LcsIteratorAdvance(LcsIterator *pIter){ + char *pRead; + sqlite3_int64 iRead; + int rc = 0; + + if( NEVER(pIter==0) ) return 1; + pRead = pIter->pRead; + pRead += sqlite3Fts3GetVarint(pRead, &iRead); + if( iRead==0 || iRead==1 ){ + pRead = 0; + rc = 1; + }else{ + pIter->iPos += (int)(iRead-2); + } + + pIter->pRead = pRead; + return rc; +} + +/* +** This function implements the FTS3_MATCHINFO_LCS matchinfo() flag. +** +** If the call is successful, the longest-common-substring lengths for each +** column are written into the first nCol elements of the pInfo->aMatchinfo[] +** array before returning. SQLITE_OK is returned in this case. +** +** Otherwise, if an error occurs, an SQLite error code is returned and the +** data written to the first nCol elements of pInfo->aMatchinfo[] is +** undefined. +*/ +static int fts3MatchinfoLcs(Fts3Cursor *pCsr, MatchInfo *pInfo){ + LcsIterator *aIter; + int i; + int iCol; + int nToken = 0; + int rc = SQLITE_OK; + + /* Allocate and populate the array of LcsIterator objects. The array + ** contains one element for each matchable phrase in the query. + **/ + aIter = sqlite3Fts3MallocZero(sizeof(LcsIterator) * pCsr->nPhrase); + if( !aIter ) return SQLITE_NOMEM; + (void)sqlite3Fts3ExprIterate(pCsr->pExpr, fts3MatchinfoLcsCb, (void*)aIter); + + for(i=0; inPhrase; i++){ + LcsIterator *pIter = &aIter[i]; + nToken -= pIter->pExpr->pPhrase->nToken; + pIter->iPosOffset = nToken; + } + + for(iCol=0; iColnCol; iCol++){ + int nLcs = 0; /* LCS value for this column */ + int nLive = 0; /* Number of iterators in aIter not at EOF */ + + for(i=0; inPhrase; i++){ + LcsIterator *pIt = &aIter[i]; + rc = sqlite3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol, &pIt->pRead); + if( rc!=SQLITE_OK ) goto matchinfo_lcs_out; + if( pIt->pRead ){ + pIt->iPos = pIt->iPosOffset; + fts3LcsIteratorAdvance(pIt); + if( pIt->pRead==0 ){ + rc = FTS_CORRUPT_VTAB; + goto matchinfo_lcs_out; + } + nLive++; + } + } + + while( nLive>0 ){ + LcsIterator *pAdv = 0; /* The iterator to advance by one position */ + int nThisLcs = 0; /* LCS for the current iterator positions */ + + for(i=0; inPhrase; i++){ + LcsIterator *pIter = &aIter[i]; + if( pIter->pRead==0 ){ + /* This iterator is already at EOF for this column. */ + nThisLcs = 0; + }else{ + if( pAdv==0 || pIter->iPosiPos ){ + pAdv = pIter; + } + if( nThisLcs==0 || pIter->iPos==pIter[-1].iPos ){ + nThisLcs++; + }else{ + nThisLcs = 1; + } + if( nThisLcs>nLcs ) nLcs = nThisLcs; + } + } + if( fts3LcsIteratorAdvance(pAdv) ) nLive--; + } + + pInfo->aMatchinfo[iCol] = nLcs; + } + + matchinfo_lcs_out: + sqlite3_free(aIter); + return rc; +} + +/* +** Populate the buffer pInfo->aMatchinfo[] with an array of integers to +** be returned by the matchinfo() function. Argument zArg contains the +** format string passed as the second argument to matchinfo (or the +** default value "pcx" if no second argument was specified). The format +** string has already been validated and the pInfo->aMatchinfo[] array +** is guaranteed to be large enough for the output. +** +** If bGlobal is true, then populate all fields of the matchinfo() output. +** If it is false, then assume that those fields that do not change between +** rows (i.e. FTS3_MATCHINFO_NPHRASE, NCOL, NDOC, AVGLENGTH and part of HITS) +** have already been populated. +** +** Return SQLITE_OK if successful, or an SQLite error code if an error +** occurs. If a value other than SQLITE_OK is returned, the state the +** pInfo->aMatchinfo[] buffer is left in is undefined. +*/ +static int fts3MatchinfoValues( + Fts3Cursor *pCsr, /* FTS3 cursor object */ + int bGlobal, /* True to grab the global stats */ + MatchInfo *pInfo, /* Matchinfo context object */ + const char *zArg /* Matchinfo format string */ +){ + int rc = SQLITE_OK; + int i; + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + sqlite3_stmt *pSelect = 0; + + for(i=0; rc==SQLITE_OK && zArg[i]; i++){ + pInfo->flag = zArg[i]; + switch( zArg[i] ){ + case FTS3_MATCHINFO_NPHRASE: + if( bGlobal ) pInfo->aMatchinfo[0] = pInfo->nPhrase; + break; + + case FTS3_MATCHINFO_NCOL: + if( bGlobal ) pInfo->aMatchinfo[0] = pInfo->nCol; + break; + + case FTS3_MATCHINFO_NDOC: + if( bGlobal ){ + sqlite3_int64 nDoc = 0; + rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &nDoc, 0, 0); + pInfo->aMatchinfo[0] = (u32)nDoc; + } + break; + + case FTS3_MATCHINFO_AVGLENGTH: + if( bGlobal ){ + sqlite3_int64 nDoc; /* Number of rows in table */ + const char *a; /* Aggregate column length array */ + const char *pEnd; /* First byte past end of length array */ + + rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &nDoc, &a, &pEnd); + if( rc==SQLITE_OK ){ + int iCol; + for(iCol=0; iColnCol; iCol++){ + u32 iVal; + sqlite3_int64 nToken; + a += sqlite3Fts3GetVarint(a, &nToken); + if( a>pEnd ){ + rc = SQLITE_CORRUPT_VTAB; + break; + } + iVal = (u32)(((u32)(nToken&0xffffffff)+nDoc/2)/nDoc); + pInfo->aMatchinfo[iCol] = iVal; + } + } + } + break; + + case FTS3_MATCHINFO_LENGTH: { + sqlite3_stmt *pSelectDocsize = 0; + rc = sqlite3Fts3SelectDocsize(pTab, pCsr->iPrevId, &pSelectDocsize); + if( rc==SQLITE_OK ){ + int iCol; + const char *a = sqlite3_column_blob(pSelectDocsize, 0); + const char *pEnd = a + sqlite3_column_bytes(pSelectDocsize, 0); + for(iCol=0; iColnCol; iCol++){ + sqlite3_int64 nToken; + a += sqlite3Fts3GetVarintBounded(a, pEnd, &nToken); + if( a>pEnd ){ + rc = SQLITE_CORRUPT_VTAB; + break; + } + pInfo->aMatchinfo[iCol] = (u32)nToken; + } + } + sqlite3_reset(pSelectDocsize); + break; + } + + case FTS3_MATCHINFO_LCS: + rc = fts3ExprLoadDoclists(pCsr, 0, 0); + if( rc==SQLITE_OK ){ + rc = fts3MatchinfoLcs(pCsr, pInfo); + } + break; + + case FTS3_MATCHINFO_LHITS_BM: + case FTS3_MATCHINFO_LHITS: { + size_t nZero = fts3MatchinfoSize(pInfo, zArg[i]) * sizeof(u32); + memset(pInfo->aMatchinfo, 0, nZero); + rc = fts3ExprLHitGather(pCsr->pExpr, pInfo); + break; + } + + default: { + Fts3Expr *pExpr; + assert( zArg[i]==FTS3_MATCHINFO_HITS ); + pExpr = pCsr->pExpr; + rc = fts3ExprLoadDoclists(pCsr, 0, 0); + if( rc!=SQLITE_OK ) break; + if( bGlobal ){ + if( pCsr->pDeferred ){ + rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &pInfo->nDoc,0,0); + if( rc!=SQLITE_OK ) break; + } + rc = sqlite3Fts3ExprIterate(pExpr, fts3ExprGlobalHitsCb,(void*)pInfo); + sqlite3Fts3EvalTestDeferred(pCsr, &rc); + if( rc!=SQLITE_OK ) break; + } + (void)sqlite3Fts3ExprIterate(pExpr, fts3ExprLocalHitsCb,(void*)pInfo); + break; + } + } + + pInfo->aMatchinfo += fts3MatchinfoSize(pInfo, zArg[i]); + } + + sqlite3_reset(pSelect); + return rc; +} + + +/* +** Populate pCsr->aMatchinfo[] with data for the current row. The +** 'matchinfo' data is an array of 32-bit unsigned integers (C type u32). +*/ +static void fts3GetMatchinfo( + sqlite3_context *pCtx, /* Return results here */ + Fts3Cursor *pCsr, /* FTS3 Cursor object */ + const char *zArg /* Second argument to matchinfo() function */ +){ + MatchInfo sInfo; + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int rc = SQLITE_OK; + int bGlobal = 0; /* Collect 'global' stats as well as local */ + + u32 *aOut = 0; + void (*xDestroyOut)(void*) = 0; + + memset(&sInfo, 0, sizeof(MatchInfo)); + sInfo.pCursor = pCsr; + sInfo.nCol = pTab->nColumn; + + /* If there is cached matchinfo() data, but the format string for the + ** cache does not match the format string for this request, discard + ** the cached data. */ + if( pCsr->pMIBuffer && strcmp(pCsr->pMIBuffer->zMatchinfo, zArg) ){ + sqlite3Fts3MIBufferFree(pCsr->pMIBuffer); + pCsr->pMIBuffer = 0; + } + + /* If Fts3Cursor.pMIBuffer is NULL, then this is the first time the + ** matchinfo function has been called for this query. In this case + ** allocate the array used to accumulate the matchinfo data and + ** initialize those elements that are constant for every row. + */ + if( pCsr->pMIBuffer==0 ){ + size_t nMatchinfo = 0; /* Number of u32 elements in match-info */ + int i; /* Used to iterate through zArg */ + + /* Determine the number of phrases in the query */ + pCsr->nPhrase = fts3ExprPhraseCount(pCsr->pExpr); + sInfo.nPhrase = pCsr->nPhrase; + + /* Determine the number of integers in the buffer returned by this call. */ + for(i=0; zArg[i]; i++){ + char *zErr = 0; + if( fts3MatchinfoCheck(pTab, zArg[i], &zErr) ){ + sqlite3_result_error(pCtx, zErr, -1); + sqlite3_free(zErr); + return; + } + nMatchinfo += fts3MatchinfoSize(&sInfo, zArg[i]); + } + + /* Allocate space for Fts3Cursor.aMatchinfo[] and Fts3Cursor.zMatchinfo. */ + pCsr->pMIBuffer = fts3MIBufferNew(nMatchinfo, zArg); + if( !pCsr->pMIBuffer ) rc = SQLITE_NOMEM; + + pCsr->isMatchinfoNeeded = 1; + bGlobal = 1; + } + + if( rc==SQLITE_OK ){ + xDestroyOut = fts3MIBufferAlloc(pCsr->pMIBuffer, &aOut); + if( xDestroyOut==0 ){ + rc = SQLITE_NOMEM; + } + } + + if( rc==SQLITE_OK ){ + sInfo.aMatchinfo = aOut; + sInfo.nPhrase = pCsr->nPhrase; + rc = fts3MatchinfoValues(pCsr, bGlobal, &sInfo, zArg); + if( bGlobal ){ + fts3MIBufferSetGlobal(pCsr->pMIBuffer); + } + } + + if( rc!=SQLITE_OK ){ + sqlite3_result_error_code(pCtx, rc); + if( xDestroyOut ) xDestroyOut(aOut); + }else{ + int n = pCsr->pMIBuffer->nElem * sizeof(u32); + sqlite3_result_blob(pCtx, aOut, n, xDestroyOut); + } +} + +/* +** Implementation of snippet() function. +*/ +SQLITE_PRIVATE void sqlite3Fts3Snippet( + sqlite3_context *pCtx, /* SQLite function call context */ + Fts3Cursor *pCsr, /* Cursor object */ + const char *zStart, /* Snippet start text - "" */ + const char *zEnd, /* Snippet end text - "" */ + const char *zEllipsis, /* Snippet ellipsis text - "..." */ + int iCol, /* Extract snippet from this column */ + int nToken /* Approximate number of tokens in snippet */ +){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + int rc = SQLITE_OK; + int i; + StrBuffer res = {0, 0, 0}; + + /* The returned text includes up to four fragments of text extracted from + ** the data in the current row. The first iteration of the for(...) loop + ** below attempts to locate a single fragment of text nToken tokens in + ** size that contains at least one instance of all phrases in the query + ** expression that appear in the current row. If such a fragment of text + ** cannot be found, the second iteration of the loop attempts to locate + ** a pair of fragments, and so on. + */ + int nSnippet = 0; /* Number of fragments in this snippet */ + SnippetFragment aSnippet[4]; /* Maximum of 4 fragments per snippet */ + int nFToken = -1; /* Number of tokens in each fragment */ + + if( !pCsr->pExpr ){ + sqlite3_result_text(pCtx, "", 0, SQLITE_STATIC); + return; + } + + /* Limit the snippet length to 64 tokens. */ + if( nToken<-64 ) nToken = -64; + if( nToken>+64 ) nToken = +64; + + for(nSnippet=1; 1; nSnippet++){ + + int iSnip; /* Loop counter 0..nSnippet-1 */ + u64 mCovered = 0; /* Bitmask of phrases covered by snippet */ + u64 mSeen = 0; /* Bitmask of phrases seen by BestSnippet() */ + + if( nToken>=0 ){ + nFToken = (nToken+nSnippet-1) / nSnippet; + }else{ + nFToken = -1 * nToken; + } + + for(iSnip=0; iSnipnColumn; iRead++){ + SnippetFragment sF = {0, 0, 0, 0}; + int iS = 0; + if( iCol>=0 && iRead!=iCol ) continue; + + /* Find the best snippet of nFToken tokens in column iRead. */ + rc = fts3BestSnippet(nFToken, pCsr, iRead, mCovered, &mSeen, &sF, &iS); + if( rc!=SQLITE_OK ){ + goto snippet_out; + } + if( iS>iBestScore ){ + *pFragment = sF; + iBestScore = iS; + } + } + + mCovered |= pFragment->covered; + } + + /* If all query phrases seen by fts3BestSnippet() are present in at least + ** one of the nSnippet snippet fragments, break out of the loop. + */ + assert( (mCovered&mSeen)==mCovered ); + if( mSeen==mCovered || nSnippet==SizeofArray(aSnippet) ) break; + } + + assert( nFToken>0 ); + + for(i=0; ipCsr, pExpr, p->iCol, &pList); + nTerm = pExpr->pPhrase->nToken; + if( pList ){ + fts3GetDeltaPosition(&pList, &iPos); + assert_fts3_nc( iPos>=0 ); + } + + for(iTerm=0; iTermaTerm[p->iTerm++]; + pT->iOff = nTerm-iTerm-1; + pT->pList = pList; + pT->iPos = iPos; + } + + return rc; +} + +/* +** Implementation of offsets() function. +*/ +SQLITE_PRIVATE void sqlite3Fts3Offsets( + sqlite3_context *pCtx, /* SQLite function call context */ + Fts3Cursor *pCsr /* Cursor object */ +){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + sqlite3_tokenizer_module const *pMod = pTab->pTokenizer->pModule; + int rc; /* Return Code */ + int nToken; /* Number of tokens in query */ + int iCol; /* Column currently being processed */ + StrBuffer res = {0, 0, 0}; /* Result string */ + TermOffsetCtx sCtx; /* Context for fts3ExprTermOffsetInit() */ + + if( !pCsr->pExpr ){ + sqlite3_result_text(pCtx, "", 0, SQLITE_STATIC); + return; + } + + memset(&sCtx, 0, sizeof(sCtx)); + assert( pCsr->isRequireSeek==0 ); + + /* Count the number of terms in the query */ + rc = fts3ExprLoadDoclists(pCsr, 0, &nToken); + if( rc!=SQLITE_OK ) goto offsets_out; + + /* Allocate the array of TermOffset iterators. */ + sCtx.aTerm = (TermOffset *)sqlite3Fts3MallocZero(sizeof(TermOffset)*nToken); + if( 0==sCtx.aTerm ){ + rc = SQLITE_NOMEM; + goto offsets_out; + } + sCtx.iDocid = pCsr->iPrevId; + sCtx.pCsr = pCsr; + + /* Loop through the table columns, appending offset information to + ** string-buffer res for each column. + */ + for(iCol=0; iColnColumn; iCol++){ + sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor */ + const char *ZDUMMY; /* Dummy argument used with xNext() */ + int NDUMMY = 0; /* Dummy argument used with xNext() */ + int iStart = 0; + int iEnd = 0; + int iCurrent = 0; + const char *zDoc; + int nDoc; + + /* Initialize the contents of sCtx.aTerm[] for column iCol. This + ** operation may fail if the database contains corrupt records. + */ + sCtx.iCol = iCol; + sCtx.iTerm = 0; + rc = sqlite3Fts3ExprIterate( + pCsr->pExpr, fts3ExprTermOffsetInit, (void*)&sCtx + ); + if( rc!=SQLITE_OK ) goto offsets_out; + + /* Retreive the text stored in column iCol. If an SQL NULL is stored + ** in column iCol, jump immediately to the next iteration of the loop. + ** If an OOM occurs while retrieving the data (this can happen if SQLite + ** needs to transform the data from utf-16 to utf-8), return SQLITE_NOMEM + ** to the caller. + */ + zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol+1); + nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol+1); + if( zDoc==0 ){ + if( sqlite3_column_type(pCsr->pStmt, iCol+1)==SQLITE_NULL ){ + continue; + } + rc = SQLITE_NOMEM; + goto offsets_out; + } + + /* Initialize a tokenizer iterator to iterate through column iCol. */ + rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid, + zDoc, nDoc, &pC + ); + if( rc!=SQLITE_OK ) goto offsets_out; + + rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent); + while( rc==SQLITE_OK ){ + int i; /* Used to loop through terms */ + int iMinPos = 0x7FFFFFFF; /* Position of next token */ + TermOffset *pTerm = 0; /* TermOffset associated with next token */ + + for(i=0; ipList && (pT->iPos-pT->iOff)iPos-pT->iOff; + pTerm = pT; + } + } + + if( !pTerm ){ + /* All offsets for this column have been gathered. */ + rc = SQLITE_DONE; + }else{ + assert_fts3_nc( iCurrent<=iMinPos ); + if( 0==(0xFE&*pTerm->pList) ){ + pTerm->pList = 0; + }else{ + fts3GetDeltaPosition(&pTerm->pList, &pTerm->iPos); + } + while( rc==SQLITE_OK && iCurrentxNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent); + } + if( rc==SQLITE_OK ){ + char aBuffer[64]; + sqlite3_snprintf(sizeof(aBuffer), aBuffer, + "%d %d %d %d ", iCol, pTerm-sCtx.aTerm, iStart, iEnd-iStart + ); + rc = fts3StringAppend(&res, aBuffer, -1); + }else if( rc==SQLITE_DONE && pTab->zContentTbl==0 ){ + rc = FTS_CORRUPT_VTAB; + } + } + } + if( rc==SQLITE_DONE ){ + rc = SQLITE_OK; + } + + pMod->xClose(pC); + if( rc!=SQLITE_OK ) goto offsets_out; + } + + offsets_out: + sqlite3_free(sCtx.aTerm); + assert( rc!=SQLITE_DONE ); + sqlite3Fts3SegmentsClose(pTab); + if( rc!=SQLITE_OK ){ + sqlite3_result_error_code(pCtx, rc); + sqlite3_free(res.z); + }else{ + sqlite3_result_text(pCtx, res.z, res.n-1, sqlite3_free); + } + return; +} + +/* +** Implementation of matchinfo() function. +*/ +SQLITE_PRIVATE void sqlite3Fts3Matchinfo( + sqlite3_context *pContext, /* Function call context */ + Fts3Cursor *pCsr, /* FTS3 table cursor */ + const char *zArg /* Second arg to matchinfo() function */ +){ + Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab; + const char *zFormat; + + if( zArg ){ + zFormat = zArg; + }else{ + zFormat = FTS3_MATCHINFO_DEFAULT; + } + + if( !pCsr->pExpr ){ + sqlite3_result_blob(pContext, "", 0, SQLITE_STATIC); + return; + }else{ + /* Retrieve matchinfo() data. */ + fts3GetMatchinfo(pContext, pCsr, zFormat); + sqlite3Fts3SegmentsClose(pTab); + } +} + +#endif + +/************** End of fts3_snippet.c ****************************************/ +/************** Begin file fts3_unicode.c ************************************/ +/* +** 2012 May 24 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** Implementation of the "unicode" full-text-search tokenizer. +*/ + +#ifndef SQLITE_DISABLE_FTS3_UNICODE + +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) + +/* #include */ +/* #include */ +/* #include */ +/* #include */ + +/* #include "fts3_tokenizer.h" */ + +/* +** The following two macros - READ_UTF8 and WRITE_UTF8 - have been copied +** from the sqlite3 source file utf.c. If this file is compiled as part +** of the amalgamation, they are not required. +*/ +#ifndef SQLITE_AMALGAMATION + +static const unsigned char sqlite3Utf8Trans1[] = { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x00, 0x00, +}; + +#define READ_UTF8(zIn, zTerm, c) \ + c = *(zIn++); \ + if( c>=0xc0 ){ \ + c = sqlite3Utf8Trans1[c-0xc0]; \ + while( zIn!=zTerm && (*zIn & 0xc0)==0x80 ){ \ + c = (c<<6) + (0x3f & *(zIn++)); \ + } \ + if( c<0x80 \ + || (c&0xFFFFF800)==0xD800 \ + || (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; } \ + } + +#define WRITE_UTF8(zOut, c) { \ + if( c<0x00080 ){ \ + *zOut++ = (u8)(c&0xFF); \ + } \ + else if( c<0x00800 ){ \ + *zOut++ = 0xC0 + (u8)((c>>6)&0x1F); \ + *zOut++ = 0x80 + (u8)(c & 0x3F); \ + } \ + else if( c<0x10000 ){ \ + *zOut++ = 0xE0 + (u8)((c>>12)&0x0F); \ + *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \ + *zOut++ = 0x80 + (u8)(c & 0x3F); \ + }else{ \ + *zOut++ = 0xF0 + (u8)((c>>18) & 0x07); \ + *zOut++ = 0x80 + (u8)((c>>12) & 0x3F); \ + *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \ + *zOut++ = 0x80 + (u8)(c & 0x3F); \ + } \ +} + +#endif /* ifndef SQLITE_AMALGAMATION */ + +typedef struct unicode_tokenizer unicode_tokenizer; +typedef struct unicode_cursor unicode_cursor; + +struct unicode_tokenizer { + sqlite3_tokenizer base; + int eRemoveDiacritic; + int nException; + int *aiException; +}; + +struct unicode_cursor { + sqlite3_tokenizer_cursor base; + const unsigned char *aInput; /* Input text being tokenized */ + int nInput; /* Size of aInput[] in bytes */ + int iOff; /* Current offset within aInput[] */ + int iToken; /* Index of next token to be returned */ + char *zToken; /* storage for current token */ + int nAlloc; /* space allocated at zToken */ +}; + + +/* +** Destroy a tokenizer allocated by unicodeCreate(). +*/ +static int unicodeDestroy(sqlite3_tokenizer *pTokenizer){ + if( pTokenizer ){ + unicode_tokenizer *p = (unicode_tokenizer *)pTokenizer; + sqlite3_free(p->aiException); + sqlite3_free(p); + } + return SQLITE_OK; +} + +/* +** As part of a tokenchars= or separators= option, the CREATE VIRTUAL TABLE +** statement has specified that the tokenizer for this table shall consider +** all characters in string zIn/nIn to be separators (if bAlnum==0) or +** token characters (if bAlnum==1). +** +** For each codepoint in the zIn/nIn string, this function checks if the +** sqlite3FtsUnicodeIsalnum() function already returns the desired result. +** If so, no action is taken. Otherwise, the codepoint is added to the +** unicode_tokenizer.aiException[] array. For the purposes of tokenization, +** the return value of sqlite3FtsUnicodeIsalnum() is inverted for all +** codepoints in the aiException[] array. +** +** If a standalone diacritic mark (one that sqlite3FtsUnicodeIsdiacritic() +** identifies as a diacritic) occurs in the zIn/nIn string it is ignored. +** It is not possible to change the behavior of the tokenizer with respect +** to these codepoints. +*/ +static int unicodeAddExceptions( + unicode_tokenizer *p, /* Tokenizer to add exceptions to */ + int bAlnum, /* Replace Isalnum() return value with this */ + const char *zIn, /* Array of characters to make exceptions */ + int nIn /* Length of z in bytes */ +){ + const unsigned char *z = (const unsigned char *)zIn; + const unsigned char *zTerm = &z[nIn]; + unsigned int iCode; + int nEntry = 0; + + assert( bAlnum==0 || bAlnum==1 ); + + while( zaiException,(p->nException+nEntry)*sizeof(int)); + if( aNew==0 ) return SQLITE_NOMEM; + nNew = p->nException; + + z = (const unsigned char *)zIn; + while( zi; j--) aNew[j] = aNew[j-1]; + aNew[i] = (int)iCode; + nNew++; + } + } + p->aiException = aNew; + p->nException = nNew; + } + + return SQLITE_OK; +} + +/* +** Return true if the p->aiException[] array contains the value iCode. +*/ +static int unicodeIsException(unicode_tokenizer *p, int iCode){ + if( p->nException>0 ){ + int *a = p->aiException; + int iLo = 0; + int iHi = p->nException-1; + + while( iHi>=iLo ){ + int iTest = (iHi + iLo) / 2; + if( iCode==a[iTest] ){ + return 1; + }else if( iCode>a[iTest] ){ + iLo = iTest+1; + }else{ + iHi = iTest-1; + } + } + } + + return 0; +} + +/* +** Return true if, for the purposes of tokenization, codepoint iCode is +** considered a token character (not a separator). +*/ +static int unicodeIsAlnum(unicode_tokenizer *p, int iCode){ + assert( (sqlite3FtsUnicodeIsalnum(iCode) & 0xFFFFFFFE)==0 ); + return sqlite3FtsUnicodeIsalnum(iCode) ^ unicodeIsException(p, iCode); +} + +/* +** Create a new tokenizer instance. +*/ +static int unicodeCreate( + int nArg, /* Size of array argv[] */ + const char * const *azArg, /* Tokenizer creation arguments */ + sqlite3_tokenizer **pp /* OUT: New tokenizer handle */ +){ + unicode_tokenizer *pNew; /* New tokenizer object */ + int i; + int rc = SQLITE_OK; + + pNew = (unicode_tokenizer *) sqlite3_malloc(sizeof(unicode_tokenizer)); + if( pNew==NULL ) return SQLITE_NOMEM; + memset(pNew, 0, sizeof(unicode_tokenizer)); + pNew->eRemoveDiacritic = 1; + + for(i=0; rc==SQLITE_OK && ieRemoveDiacritic = 1; + } + else if( n==19 && memcmp("remove_diacritics=0", z, 19)==0 ){ + pNew->eRemoveDiacritic = 0; + } + else if( n==19 && memcmp("remove_diacritics=2", z, 19)==0 ){ + pNew->eRemoveDiacritic = 2; + } + else if( n>=11 && memcmp("tokenchars=", z, 11)==0 ){ + rc = unicodeAddExceptions(pNew, 1, &z[11], n-11); + } + else if( n>=11 && memcmp("separators=", z, 11)==0 ){ + rc = unicodeAddExceptions(pNew, 0, &z[11], n-11); + } + else{ + /* Unrecognized argument */ + rc = SQLITE_ERROR; + } + } + + if( rc!=SQLITE_OK ){ + unicodeDestroy((sqlite3_tokenizer *)pNew); + pNew = 0; + } + *pp = (sqlite3_tokenizer *)pNew; + return rc; +} + +/* +** Prepare to begin tokenizing a particular string. The input +** string to be tokenized is pInput[0..nBytes-1]. A cursor +** used to incrementally tokenize this string is returned in +** *ppCursor. +*/ +static int unicodeOpen( + sqlite3_tokenizer *p, /* The tokenizer */ + const char *aInput, /* Input string */ + int nInput, /* Size of string aInput in bytes */ + sqlite3_tokenizer_cursor **pp /* OUT: New cursor object */ +){ + unicode_cursor *pCsr; + + pCsr = (unicode_cursor *)sqlite3_malloc(sizeof(unicode_cursor)); + if( pCsr==0 ){ + return SQLITE_NOMEM; + } + memset(pCsr, 0, sizeof(unicode_cursor)); + + pCsr->aInput = (const unsigned char *)aInput; + if( aInput==0 ){ + pCsr->nInput = 0; + pCsr->aInput = (const unsigned char*)""; + }else if( nInput<0 ){ + pCsr->nInput = (int)strlen(aInput); + }else{ + pCsr->nInput = nInput; + } + + *pp = &pCsr->base; + UNUSED_PARAMETER(p); + return SQLITE_OK; +} + +/* +** Close a tokenization cursor previously opened by a call to +** simpleOpen() above. +*/ +static int unicodeClose(sqlite3_tokenizer_cursor *pCursor){ + unicode_cursor *pCsr = (unicode_cursor *) pCursor; + sqlite3_free(pCsr->zToken); + sqlite3_free(pCsr); + return SQLITE_OK; +} + +/* +** Extract the next token from a tokenization cursor. The cursor must +** have been opened by a prior call to simpleOpen(). +*/ +static int unicodeNext( + sqlite3_tokenizer_cursor *pC, /* Cursor returned by simpleOpen */ + const char **paToken, /* OUT: Token text */ + int *pnToken, /* OUT: Number of bytes at *paToken */ + int *piStart, /* OUT: Starting offset of token */ + int *piEnd, /* OUT: Ending offset of token */ + int *piPos /* OUT: Position integer of token */ +){ + unicode_cursor *pCsr = (unicode_cursor *)pC; + unicode_tokenizer *p = ((unicode_tokenizer *)pCsr->base.pTokenizer); + unsigned int iCode = 0; + char *zOut; + const unsigned char *z = &pCsr->aInput[pCsr->iOff]; + const unsigned char *zStart = z; + const unsigned char *zEnd; + const unsigned char *zTerm = &pCsr->aInput[pCsr->nInput]; + + /* Scan past any delimiter characters before the start of the next token. + ** Return SQLITE_DONE early if this takes us all the way to the end of + ** the input. */ + while( z=zTerm ) return SQLITE_DONE; + + zOut = pCsr->zToken; + do { + int iOut; + + /* Grow the output buffer if required. */ + if( (zOut-pCsr->zToken)>=(pCsr->nAlloc-4) ){ + char *zNew = sqlite3_realloc64(pCsr->zToken, pCsr->nAlloc+64); + if( !zNew ) return SQLITE_NOMEM; + zOut = &zNew[zOut - pCsr->zToken]; + pCsr->zToken = zNew; + pCsr->nAlloc += 64; + } + + /* Write the folded case of the last character read to the output */ + zEnd = z; + iOut = sqlite3FtsUnicodeFold((int)iCode, p->eRemoveDiacritic); + if( iOut ){ + WRITE_UTF8(zOut, iOut); + } + + /* If the cursor is not at EOF, read the next character */ + if( z>=zTerm ) break; + READ_UTF8(z, zTerm, iCode); + }while( unicodeIsAlnum(p, (int)iCode) + || sqlite3FtsUnicodeIsdiacritic((int)iCode) + ); + + /* Set the output variables and return. */ + pCsr->iOff = (int)(z - pCsr->aInput); + *paToken = pCsr->zToken; + *pnToken = (int)(zOut - pCsr->zToken); + *piStart = (int)(zStart - pCsr->aInput); + *piEnd = (int)(zEnd - pCsr->aInput); + *piPos = pCsr->iToken++; + return SQLITE_OK; +} + +/* +** Set *ppModule to a pointer to the sqlite3_tokenizer_module +** structure for the unicode tokenizer. +*/ +SQLITE_PRIVATE void sqlite3Fts3UnicodeTokenizer(sqlite3_tokenizer_module const **ppModule){ + static const sqlite3_tokenizer_module module = { + 0, + unicodeCreate, + unicodeDestroy, + unicodeOpen, + unicodeClose, + unicodeNext, + 0, + }; + *ppModule = &module; +} + +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ +#endif /* ifndef SQLITE_DISABLE_FTS3_UNICODE */ + +/************** End of fts3_unicode.c ****************************************/ +/************** Begin file fts3_unicode2.c ***********************************/ +/* +** 2012-05-25 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +*/ + +/* +** DO NOT EDIT THIS MACHINE GENERATED FILE. +*/ + +#ifndef SQLITE_DISABLE_FTS3_UNICODE +#if defined(SQLITE_ENABLE_FTS3) || defined(SQLITE_ENABLE_FTS4) + +/* #include */ + +/* +** Return true if the argument corresponds to a unicode codepoint +** classified as either a letter or a number. Otherwise false. +** +** The results are undefined if the value passed to this function +** is less than zero. +*/ +SQLITE_PRIVATE int sqlite3FtsUnicodeIsalnum(int c){ + /* Each unsigned integer in the following array corresponds to a contiguous + ** range of unicode codepoints that are not either letters or numbers (i.e. + ** codepoints for which this function should return 0). + ** + ** The most significant 22 bits in each 32-bit value contain the first + ** codepoint in the range. The least significant 10 bits are used to store + ** the size of the range (always at least 1). In other words, the value + ** ((C<<22) + N) represents a range of N codepoints starting with codepoint + ** C. It is not possible to represent a range larger than 1023 codepoints + ** using this format. + */ + static const unsigned int aEntry[] = { + 0x00000030, 0x0000E807, 0x00016C06, 0x0001EC2F, 0x0002AC07, + 0x0002D001, 0x0002D803, 0x0002EC01, 0x0002FC01, 0x00035C01, + 0x0003DC01, 0x000B0804, 0x000B480E, 0x000B9407, 0x000BB401, + 0x000BBC81, 0x000DD401, 0x000DF801, 0x000E1002, 0x000E1C01, + 0x000FD801, 0x00120808, 0x00156806, 0x00162402, 0x00163C01, + 0x00164437, 0x0017CC02, 0x00180005, 0x00181816, 0x00187802, + 0x00192C15, 0x0019A804, 0x0019C001, 0x001B5001, 0x001B580F, + 0x001B9C07, 0x001BF402, 0x001C000E, 0x001C3C01, 0x001C4401, + 0x001CC01B, 0x001E980B, 0x001FAC09, 0x001FD804, 0x00205804, + 0x00206C09, 0x00209403, 0x0020A405, 0x0020C00F, 0x00216403, + 0x00217801, 0x0023901B, 0x00240004, 0x0024E803, 0x0024F812, + 0x00254407, 0x00258804, 0x0025C001, 0x00260403, 0x0026F001, + 0x0026F807, 0x00271C02, 0x00272C03, 0x00275C01, 0x00278802, + 0x0027C802, 0x0027E802, 0x00280403, 0x0028F001, 0x0028F805, + 0x00291C02, 0x00292C03, 0x00294401, 0x0029C002, 0x0029D401, + 0x002A0403, 0x002AF001, 0x002AF808, 0x002B1C03, 0x002B2C03, + 0x002B8802, 0x002BC002, 0x002C0403, 0x002CF001, 0x002CF807, + 0x002D1C02, 0x002D2C03, 0x002D5802, 0x002D8802, 0x002DC001, + 0x002E0801, 0x002EF805, 0x002F1803, 0x002F2804, 0x002F5C01, + 0x002FCC08, 0x00300403, 0x0030F807, 0x00311803, 0x00312804, + 0x00315402, 0x00318802, 0x0031FC01, 0x00320802, 0x0032F001, + 0x0032F807, 0x00331803, 0x00332804, 0x00335402, 0x00338802, + 0x00340802, 0x0034F807, 0x00351803, 0x00352804, 0x00355C01, + 0x00358802, 0x0035E401, 0x00360802, 0x00372801, 0x00373C06, + 0x00375801, 0x00376008, 0x0037C803, 0x0038C401, 0x0038D007, + 0x0038FC01, 0x00391C09, 0x00396802, 0x003AC401, 0x003AD006, + 0x003AEC02, 0x003B2006, 0x003C041F, 0x003CD00C, 0x003DC417, + 0x003E340B, 0x003E6424, 0x003EF80F, 0x003F380D, 0x0040AC14, + 0x00412806, 0x00415804, 0x00417803, 0x00418803, 0x00419C07, + 0x0041C404, 0x0042080C, 0x00423C01, 0x00426806, 0x0043EC01, + 0x004D740C, 0x004E400A, 0x00500001, 0x0059B402, 0x005A0001, + 0x005A6C02, 0x005BAC03, 0x005C4803, 0x005CC805, 0x005D4802, + 0x005DC802, 0x005ED023, 0x005F6004, 0x005F7401, 0x0060000F, + 0x0062A401, 0x0064800C, 0x0064C00C, 0x00650001, 0x00651002, + 0x0066C011, 0x00672002, 0x00677822, 0x00685C05, 0x00687802, + 0x0069540A, 0x0069801D, 0x0069FC01, 0x006A8007, 0x006AA006, + 0x006C0005, 0x006CD011, 0x006D6823, 0x006E0003, 0x006E840D, + 0x006F980E, 0x006FF004, 0x00709014, 0x0070EC05, 0x0071F802, + 0x00730008, 0x00734019, 0x0073B401, 0x0073C803, 0x00770027, + 0x0077F004, 0x007EF401, 0x007EFC03, 0x007F3403, 0x007F7403, + 0x007FB403, 0x007FF402, 0x00800065, 0x0081A806, 0x0081E805, + 0x00822805, 0x0082801A, 0x00834021, 0x00840002, 0x00840C04, + 0x00842002, 0x00845001, 0x00845803, 0x00847806, 0x00849401, + 0x00849C01, 0x0084A401, 0x0084B801, 0x0084E802, 0x00850005, + 0x00852804, 0x00853C01, 0x00864264, 0x00900027, 0x0091000B, + 0x0092704E, 0x00940200, 0x009C0475, 0x009E53B9, 0x00AD400A, + 0x00B39406, 0x00B3BC03, 0x00B3E404, 0x00B3F802, 0x00B5C001, + 0x00B5FC01, 0x00B7804F, 0x00B8C00C, 0x00BA001A, 0x00BA6C59, + 0x00BC00D6, 0x00BFC00C, 0x00C00005, 0x00C02019, 0x00C0A807, + 0x00C0D802, 0x00C0F403, 0x00C26404, 0x00C28001, 0x00C3EC01, + 0x00C64002, 0x00C6580A, 0x00C70024, 0x00C8001F, 0x00C8A81E, + 0x00C94001, 0x00C98020, 0x00CA2827, 0x00CB003F, 0x00CC0100, + 0x01370040, 0x02924037, 0x0293F802, 0x02983403, 0x0299BC10, + 0x029A7C01, 0x029BC008, 0x029C0017, 0x029C8002, 0x029E2402, + 0x02A00801, 0x02A01801, 0x02A02C01, 0x02A08C09, 0x02A0D804, + 0x02A1D004, 0x02A20002, 0x02A2D011, 0x02A33802, 0x02A38012, + 0x02A3E003, 0x02A4980A, 0x02A51C0D, 0x02A57C01, 0x02A60004, + 0x02A6CC1B, 0x02A77802, 0x02A8A40E, 0x02A90C01, 0x02A93002, + 0x02A97004, 0x02A9DC03, 0x02A9EC01, 0x02AAC001, 0x02AAC803, + 0x02AADC02, 0x02AAF802, 0x02AB0401, 0x02AB7802, 0x02ABAC07, + 0x02ABD402, 0x02AF8C0B, 0x03600001, 0x036DFC02, 0x036FFC02, + 0x037FFC01, 0x03EC7801, 0x03ECA401, 0x03EEC810, 0x03F4F802, + 0x03F7F002, 0x03F8001A, 0x03F88007, 0x03F8C023, 0x03F95013, + 0x03F9A004, 0x03FBFC01, 0x03FC040F, 0x03FC6807, 0x03FCEC06, + 0x03FD6C0B, 0x03FF8007, 0x03FFA007, 0x03FFE405, 0x04040003, + 0x0404DC09, 0x0405E411, 0x0406400C, 0x0407402E, 0x040E7C01, + 0x040F4001, 0x04215C01, 0x04247C01, 0x0424FC01, 0x04280403, + 0x04281402, 0x04283004, 0x0428E003, 0x0428FC01, 0x04294009, + 0x0429FC01, 0x042CE407, 0x04400003, 0x0440E016, 0x04420003, + 0x0442C012, 0x04440003, 0x04449C0E, 0x04450004, 0x04460003, + 0x0446CC0E, 0x04471404, 0x045AAC0D, 0x0491C004, 0x05BD442E, + 0x05BE3C04, 0x074000F6, 0x07440027, 0x0744A4B5, 0x07480046, + 0x074C0057, 0x075B0401, 0x075B6C01, 0x075BEC01, 0x075C5401, + 0x075CD401, 0x075D3C01, 0x075DBC01, 0x075E2401, 0x075EA401, + 0x075F0C01, 0x07BBC002, 0x07C0002C, 0x07C0C064, 0x07C2800F, + 0x07C2C40E, 0x07C3040F, 0x07C3440F, 0x07C4401F, 0x07C4C03C, + 0x07C5C02B, 0x07C7981D, 0x07C8402B, 0x07C90009, 0x07C94002, + 0x07CC0021, 0x07CCC006, 0x07CCDC46, 0x07CE0014, 0x07CE8025, + 0x07CF1805, 0x07CF8011, 0x07D0003F, 0x07D10001, 0x07D108B6, + 0x07D3E404, 0x07D4003E, 0x07D50004, 0x07D54018, 0x07D7EC46, + 0x07D9140B, 0x07DA0046, 0x07DC0074, 0x38000401, 0x38008060, + 0x380400F0, + }; + static const unsigned int aAscii[4] = { + 0xFFFFFFFF, 0xFC00FFFF, 0xF8000001, 0xF8000001, + }; + + if( (unsigned int)c<128 ){ + return ( (aAscii[c >> 5] & ((unsigned int)1 << (c & 0x001F)))==0 ); + }else if( (unsigned int)c<(1<<22) ){ + unsigned int key = (((unsigned int)c)<<10) | 0x000003FF; + int iRes = 0; + int iHi = sizeof(aEntry)/sizeof(aEntry[0]) - 1; + int iLo = 0; + while( iHi>=iLo ){ + int iTest = (iHi + iLo) / 2; + if( key >= aEntry[iTest] ){ + iRes = iTest; + iLo = iTest+1; + }else{ + iHi = iTest-1; + } + } + assert( aEntry[0]=aEntry[iRes] ); + return (((unsigned int)c) >= ((aEntry[iRes]>>10) + (aEntry[iRes]&0x3FF))); + } + return 1; +} + + +/* +** If the argument is a codepoint corresponding to a lowercase letter +** in the ASCII range with a diacritic added, return the codepoint +** of the ASCII letter only. For example, if passed 235 - "LATIN +** SMALL LETTER E WITH DIAERESIS" - return 65 ("LATIN SMALL LETTER +** E"). The resuls of passing a codepoint that corresponds to an +** uppercase letter are undefined. +*/ +static int remove_diacritic(int c, int bComplex){ + unsigned short aDia[] = { + 0, 1797, 1848, 1859, 1891, 1928, 1940, 1995, + 2024, 2040, 2060, 2110, 2168, 2206, 2264, 2286, + 2344, 2383, 2472, 2488, 2516, 2596, 2668, 2732, + 2782, 2842, 2894, 2954, 2984, 3000, 3028, 3336, + 3456, 3696, 3712, 3728, 3744, 3766, 3832, 3896, + 3912, 3928, 3944, 3968, 4008, 4040, 4056, 4106, + 4138, 4170, 4202, 4234, 4266, 4296, 4312, 4344, + 4408, 4424, 4442, 4472, 4488, 4504, 6148, 6198, + 6264, 6280, 6360, 6429, 6505, 6529, 61448, 61468, + 61512, 61534, 61592, 61610, 61642, 61672, 61688, 61704, + 61726, 61784, 61800, 61816, 61836, 61880, 61896, 61914, + 61948, 61998, 62062, 62122, 62154, 62184, 62200, 62218, + 62252, 62302, 62364, 62410, 62442, 62478, 62536, 62554, + 62584, 62604, 62640, 62648, 62656, 62664, 62730, 62766, + 62830, 62890, 62924, 62974, 63032, 63050, 63082, 63118, + 63182, 63242, 63274, 63310, 63368, 63390, + }; +#define HIBIT ((unsigned char)0x80) + unsigned char aChar[] = { + '\0', 'a', 'c', 'e', 'i', 'n', + 'o', 'u', 'y', 'y', 'a', 'c', + 'd', 'e', 'e', 'g', 'h', 'i', + 'j', 'k', 'l', 'n', 'o', 'r', + 's', 't', 'u', 'u', 'w', 'y', + 'z', 'o', 'u', 'a', 'i', 'o', + 'u', 'u'|HIBIT, 'a'|HIBIT, 'g', 'k', 'o', + 'o'|HIBIT, 'j', 'g', 'n', 'a'|HIBIT, 'a', + 'e', 'i', 'o', 'r', 'u', 's', + 't', 'h', 'a', 'e', 'o'|HIBIT, 'o', + 'o'|HIBIT, 'y', '\0', '\0', '\0', '\0', + '\0', '\0', '\0', '\0', 'a', 'b', + 'c'|HIBIT, 'd', 'd', 'e'|HIBIT, 'e', 'e'|HIBIT, + 'f', 'g', 'h', 'h', 'i', 'i'|HIBIT, + 'k', 'l', 'l'|HIBIT, 'l', 'm', 'n', + 'o'|HIBIT, 'p', 'r', 'r'|HIBIT, 'r', 's', + 's'|HIBIT, 't', 'u', 'u'|HIBIT, 'v', 'w', + 'w', 'x', 'y', 'z', 'h', 't', + 'w', 'y', 'a', 'a'|HIBIT, 'a'|HIBIT, 'a'|HIBIT, + 'e', 'e'|HIBIT, 'e'|HIBIT, 'i', 'o', 'o'|HIBIT, + 'o'|HIBIT, 'o'|HIBIT, 'u', 'u'|HIBIT, 'u'|HIBIT, 'y', + }; + + unsigned int key = (((unsigned int)c)<<3) | 0x00000007; + int iRes = 0; + int iHi = sizeof(aDia)/sizeof(aDia[0]) - 1; + int iLo = 0; + while( iHi>=iLo ){ + int iTest = (iHi + iLo) / 2; + if( key >= aDia[iTest] ){ + iRes = iTest; + iLo = iTest+1; + }else{ + iHi = iTest-1; + } + } + assert( key>=aDia[iRes] ); + if( bComplex==0 && (aChar[iRes] & 0x80) ) return c; + return (c > (aDia[iRes]>>3) + (aDia[iRes]&0x07)) ? c : ((int)aChar[iRes] & 0x7F); +} + + +/* +** Return true if the argument interpreted as a unicode codepoint +** is a diacritical modifier character. +*/ +SQLITE_PRIVATE int sqlite3FtsUnicodeIsdiacritic(int c){ + unsigned int mask0 = 0x08029FDF; + unsigned int mask1 = 0x000361F8; + if( c<768 || c>817 ) return 0; + return (c < 768+32) ? + (mask0 & ((unsigned int)1 << (c-768))) : + (mask1 & ((unsigned int)1 << (c-768-32))); +} + + +/* +** Interpret the argument as a unicode codepoint. If the codepoint +** is an upper case character that has a lower case equivalent, +** return the codepoint corresponding to the lower case version. +** Otherwise, return a copy of the argument. +** +** The results are undefined if the value passed to this function +** is less than zero. +*/ +SQLITE_PRIVATE int sqlite3FtsUnicodeFold(int c, int eRemoveDiacritic){ + /* Each entry in the following array defines a rule for folding a range + ** of codepoints to lower case. The rule applies to a range of nRange + ** codepoints starting at codepoint iCode. + ** + ** If the least significant bit in flags is clear, then the rule applies + ** to all nRange codepoints (i.e. all nRange codepoints are upper case and + ** need to be folded). Or, if it is set, then the rule only applies to + ** every second codepoint in the range, starting with codepoint C. + ** + ** The 7 most significant bits in flags are an index into the aiOff[] + ** array. If a specific codepoint C does require folding, then its lower + ** case equivalent is ((C + aiOff[flags>>1]) & 0xFFFF). + ** + ** The contents of this array are generated by parsing the CaseFolding.txt + ** file distributed as part of the "Unicode Character Database". See + ** http://www.unicode.org for details. + */ + static const struct TableEntry { + unsigned short iCode; + unsigned char flags; + unsigned char nRange; + } aEntry[] = { + {65, 14, 26}, {181, 64, 1}, {192, 14, 23}, + {216, 14, 7}, {256, 1, 48}, {306, 1, 6}, + {313, 1, 16}, {330, 1, 46}, {376, 116, 1}, + {377, 1, 6}, {383, 104, 1}, {385, 50, 1}, + {386, 1, 4}, {390, 44, 1}, {391, 0, 1}, + {393, 42, 2}, {395, 0, 1}, {398, 32, 1}, + {399, 38, 1}, {400, 40, 1}, {401, 0, 1}, + {403, 42, 1}, {404, 46, 1}, {406, 52, 1}, + {407, 48, 1}, {408, 0, 1}, {412, 52, 1}, + {413, 54, 1}, {415, 56, 1}, {416, 1, 6}, + {422, 60, 1}, {423, 0, 1}, {425, 60, 1}, + {428, 0, 1}, {430, 60, 1}, {431, 0, 1}, + {433, 58, 2}, {435, 1, 4}, {439, 62, 1}, + {440, 0, 1}, {444, 0, 1}, {452, 2, 1}, + {453, 0, 1}, {455, 2, 1}, {456, 0, 1}, + {458, 2, 1}, {459, 1, 18}, {478, 1, 18}, + {497, 2, 1}, {498, 1, 4}, {502, 122, 1}, + {503, 134, 1}, {504, 1, 40}, {544, 110, 1}, + {546, 1, 18}, {570, 70, 1}, {571, 0, 1}, + {573, 108, 1}, {574, 68, 1}, {577, 0, 1}, + {579, 106, 1}, {580, 28, 1}, {581, 30, 1}, + {582, 1, 10}, {837, 36, 1}, {880, 1, 4}, + {886, 0, 1}, {902, 18, 1}, {904, 16, 3}, + {908, 26, 1}, {910, 24, 2}, {913, 14, 17}, + {931, 14, 9}, {962, 0, 1}, {975, 4, 1}, + {976, 140, 1}, {977, 142, 1}, {981, 146, 1}, + {982, 144, 1}, {984, 1, 24}, {1008, 136, 1}, + {1009, 138, 1}, {1012, 130, 1}, {1013, 128, 1}, + {1015, 0, 1}, {1017, 152, 1}, {1018, 0, 1}, + {1021, 110, 3}, {1024, 34, 16}, {1040, 14, 32}, + {1120, 1, 34}, {1162, 1, 54}, {1216, 6, 1}, + {1217, 1, 14}, {1232, 1, 88}, {1329, 22, 38}, + {4256, 66, 38}, {4295, 66, 1}, {4301, 66, 1}, + {7680, 1, 150}, {7835, 132, 1}, {7838, 96, 1}, + {7840, 1, 96}, {7944, 150, 8}, {7960, 150, 6}, + {7976, 150, 8}, {7992, 150, 8}, {8008, 150, 6}, + {8025, 151, 8}, {8040, 150, 8}, {8072, 150, 8}, + {8088, 150, 8}, {8104, 150, 8}, {8120, 150, 2}, + {8122, 126, 2}, {8124, 148, 1}, {8126, 100, 1}, + {8136, 124, 4}, {8140, 148, 1}, {8152, 150, 2}, + {8154, 120, 2}, {8168, 150, 2}, {8170, 118, 2}, + {8172, 152, 1}, {8184, 112, 2}, {8186, 114, 2}, + {8188, 148, 1}, {8486, 98, 1}, {8490, 92, 1}, + {8491, 94, 1}, {8498, 12, 1}, {8544, 8, 16}, + {8579, 0, 1}, {9398, 10, 26}, {11264, 22, 47}, + {11360, 0, 1}, {11362, 88, 1}, {11363, 102, 1}, + {11364, 90, 1}, {11367, 1, 6}, {11373, 84, 1}, + {11374, 86, 1}, {11375, 80, 1}, {11376, 82, 1}, + {11378, 0, 1}, {11381, 0, 1}, {11390, 78, 2}, + {11392, 1, 100}, {11499, 1, 4}, {11506, 0, 1}, + {42560, 1, 46}, {42624, 1, 24}, {42786, 1, 14}, + {42802, 1, 62}, {42873, 1, 4}, {42877, 76, 1}, + {42878, 1, 10}, {42891, 0, 1}, {42893, 74, 1}, + {42896, 1, 4}, {42912, 1, 10}, {42922, 72, 1}, + {65313, 14, 26}, + }; + static const unsigned short aiOff[] = { + 1, 2, 8, 15, 16, 26, 28, 32, + 37, 38, 40, 48, 63, 64, 69, 71, + 79, 80, 116, 202, 203, 205, 206, 207, + 209, 210, 211, 213, 214, 217, 218, 219, + 775, 7264, 10792, 10795, 23228, 23256, 30204, 54721, + 54753, 54754, 54756, 54787, 54793, 54809, 57153, 57274, + 57921, 58019, 58363, 61722, 65268, 65341, 65373, 65406, + 65408, 65410, 65415, 65424, 65436, 65439, 65450, 65462, + 65472, 65476, 65478, 65480, 65482, 65488, 65506, 65511, + 65514, 65521, 65527, 65528, 65529, + }; + + int ret = c; + + assert( sizeof(unsigned short)==2 && sizeof(unsigned char)==1 ); + + if( c<128 ){ + if( c>='A' && c<='Z' ) ret = c + ('a' - 'A'); + }else if( c<65536 ){ + const struct TableEntry *p; + int iHi = sizeof(aEntry)/sizeof(aEntry[0]) - 1; + int iLo = 0; + int iRes = -1; + + assert( c>aEntry[0].iCode ); + while( iHi>=iLo ){ + int iTest = (iHi + iLo) / 2; + int cmp = (c - aEntry[iTest].iCode); + if( cmp>=0 ){ + iRes = iTest; + iLo = iTest+1; + }else{ + iHi = iTest-1; + } + } + + assert( iRes>=0 && c>=aEntry[iRes].iCode ); + p = &aEntry[iRes]; + if( c<(p->iCode + p->nRange) && 0==(0x01 & p->flags & (p->iCode ^ c)) ){ + ret = (c + (aiOff[p->flags>>1])) & 0x0000FFFF; + assert( ret>0 ); + } + + if( eRemoveDiacritic ){ + ret = remove_diacritic(ret, eRemoveDiacritic==2); + } + } + + else if( c>=66560 && c<66600 ){ + ret = c + 40; + } + + return ret; +} +#endif /* defined(SQLITE_ENABLE_FTS3) || defined(SQLITE_ENABLE_FTS4) */ +#endif /* !defined(SQLITE_DISABLE_FTS3_UNICODE) */ + +/************** End of fts3_unicode2.c ***************************************/ +/************** Begin file json.c ********************************************/ +/* +** 2015-08-12 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This SQLite JSON functions. +** +** This file began as an extension in ext/misc/json1.c in 2015. That +** extension proved so useful that it has now been moved into the core. +** +** For the time being, all JSON is stored as pure text. (We might add +** a JSONB type in the future which stores a binary encoding of JSON in +** a BLOB, but there is no support for JSONB in the current implementation. +** This implementation parses JSON text at 250 MB/s, so it is hard to see +** how JSONB might improve on that.) +*/ +#ifndef SQLITE_OMIT_JSON +/* #include "sqliteInt.h" */ + +/* +** Growing our own isspace() routine this way is twice as fast as +** the library isspace() function, resulting in a 7% overall performance +** increase for the parser. (Ubuntu14.10 gcc 4.8.4 x64 with -Os). +*/ +static const char jsonIsSpace[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +}; +#define fast_isspace(x) (jsonIsSpace[(unsigned char)x]) + +#if !defined(SQLITE_DEBUG) && !defined(SQLITE_COVERAGE_TEST) +# define VVA(X) +#else +# define VVA(X) X +#endif + +/* Objects */ +typedef struct JsonString JsonString; +typedef struct JsonNode JsonNode; +typedef struct JsonParse JsonParse; + +/* An instance of this object represents a JSON string +** under construction. Really, this is a generic string accumulator +** that can be and is used to create strings other than JSON. +*/ +struct JsonString { + sqlite3_context *pCtx; /* Function context - put error messages here */ + char *zBuf; /* Append JSON content here */ + u64 nAlloc; /* Bytes of storage available in zBuf[] */ + u64 nUsed; /* Bytes of zBuf[] currently used */ + u8 bStatic; /* True if zBuf is static space */ + u8 bErr; /* True if an error has been encountered */ + char zSpace[100]; /* Initial static space */ +}; + +/* JSON type values +*/ +#define JSON_NULL 0 +#define JSON_TRUE 1 +#define JSON_FALSE 2 +#define JSON_INT 3 +#define JSON_REAL 4 +#define JSON_STRING 5 +#define JSON_ARRAY 6 +#define JSON_OBJECT 7 + +/* The "subtype" set for JSON values */ +#define JSON_SUBTYPE 74 /* Ascii for "J" */ + +/* +** Names of the various JSON types: +*/ +static const char * const jsonType[] = { + "null", "true", "false", "integer", "real", "text", "array", "object" +}; + +/* Bit values for the JsonNode.jnFlag field +*/ +#define JNODE_RAW 0x01 /* Content is raw, not JSON encoded */ +#define JNODE_ESCAPE 0x02 /* Content is text with \ escapes */ +#define JNODE_REMOVE 0x04 /* Do not output */ +#define JNODE_REPLACE 0x08 /* Replace with JsonNode.u.iReplace */ +#define JNODE_PATCH 0x10 /* Patch with JsonNode.u.pPatch */ +#define JNODE_APPEND 0x20 /* More ARRAY/OBJECT entries at u.iAppend */ +#define JNODE_LABEL 0x40 /* Is a label of an object */ +#define JNODE_JSON5 0x80 /* Node contains JSON5 enhancements */ + + +/* A single node of parsed JSON +*/ +struct JsonNode { + u8 eType; /* One of the JSON_ type values */ + u8 jnFlags; /* JNODE flags */ + u8 eU; /* Which union element to use */ + u32 n; /* Bytes of content, or number of sub-nodes */ + union { + const char *zJContent; /* 1: Content for INT, REAL, and STRING */ + u32 iAppend; /* 2: More terms for ARRAY and OBJECT */ + u32 iKey; /* 3: Key for ARRAY objects in json_tree() */ + u32 iReplace; /* 4: Replacement content for JNODE_REPLACE */ + JsonNode *pPatch; /* 5: Node chain of patch for JNODE_PATCH */ + } u; +}; + +/* A completely parsed JSON string +*/ +struct JsonParse { + u32 nNode; /* Number of slots of aNode[] used */ + u32 nAlloc; /* Number of slots of aNode[] allocated */ + JsonNode *aNode; /* Array of nodes containing the parse */ + const char *zJson; /* Original JSON string */ + u32 *aUp; /* Index of parent of each node */ + u16 iDepth; /* Nesting depth */ + u8 nErr; /* Number of errors seen */ + u8 oom; /* Set to true if out of memory */ + u8 hasNonstd; /* True if input uses non-standard features like JSON5 */ + int nJson; /* Length of the zJson string in bytes */ + u32 iErr; /* Error location in zJson[] */ + u32 iHold; /* Replace cache line with the lowest iHold value */ +}; + +/* +** Maximum nesting depth of JSON for this implementation. +** +** This limit is needed to avoid a stack overflow in the recursive +** descent parser. A depth of 1000 is far deeper than any sane JSON +** should go. Historical note: This limit was 2000 prior to version 3.42.0 +*/ +#define JSON_MAX_DEPTH 1000 + +/************************************************************************** +** Utility routines for dealing with JsonString objects +**************************************************************************/ + +/* Set the JsonString object to an empty string +*/ +static void jsonZero(JsonString *p){ + p->zBuf = p->zSpace; + p->nAlloc = sizeof(p->zSpace); + p->nUsed = 0; + p->bStatic = 1; +} + +/* Initialize the JsonString object +*/ +static void jsonInit(JsonString *p, sqlite3_context *pCtx){ + p->pCtx = pCtx; + p->bErr = 0; + jsonZero(p); +} + + +/* Free all allocated memory and reset the JsonString object back to its +** initial state. +*/ +static void jsonReset(JsonString *p){ + if( !p->bStatic ) sqlite3_free(p->zBuf); + jsonZero(p); +} + + +/* Report an out-of-memory (OOM) condition +*/ +static void jsonOom(JsonString *p){ + p->bErr = 1; + sqlite3_result_error_nomem(p->pCtx); + jsonReset(p); +} + +/* Enlarge pJson->zBuf so that it can hold at least N more bytes. +** Return zero on success. Return non-zero on an OOM error +*/ +static int jsonGrow(JsonString *p, u32 N){ + u64 nTotal = NnAlloc ? p->nAlloc*2 : p->nAlloc+N+10; + char *zNew; + if( p->bStatic ){ + if( p->bErr ) return 1; + zNew = sqlite3_malloc64(nTotal); + if( zNew==0 ){ + jsonOom(p); + return SQLITE_NOMEM; + } + memcpy(zNew, p->zBuf, (size_t)p->nUsed); + p->zBuf = zNew; + p->bStatic = 0; + }else{ + zNew = sqlite3_realloc64(p->zBuf, nTotal); + if( zNew==0 ){ + jsonOom(p); + return SQLITE_NOMEM; + } + p->zBuf = zNew; + } + p->nAlloc = nTotal; + return SQLITE_OK; +} + +/* Append N bytes from zIn onto the end of the JsonString string. +*/ +static void jsonAppendRaw(JsonString *p, const char *zIn, u32 N){ + if( N==0 ) return; + if( (N+p->nUsed >= p->nAlloc) && jsonGrow(p,N)!=0 ) return; + memcpy(p->zBuf+p->nUsed, zIn, N); + p->nUsed += N; +} + +/* Append formatted text (not to exceed N bytes) to the JsonString. +*/ +static void jsonPrintf(int N, JsonString *p, const char *zFormat, ...){ + va_list ap; + if( (p->nUsed + N >= p->nAlloc) && jsonGrow(p, N) ) return; + va_start(ap, zFormat); + sqlite3_vsnprintf(N, p->zBuf+p->nUsed, zFormat, ap); + va_end(ap); + p->nUsed += (int)strlen(p->zBuf+p->nUsed); +} + +/* Append a single character +*/ +static void jsonAppendChar(JsonString *p, char c){ + if( p->nUsed>=p->nAlloc && jsonGrow(p,1)!=0 ) return; + p->zBuf[p->nUsed++] = c; +} + +/* Append a comma separator to the output buffer, if the previous +** character is not '[' or '{'. +*/ +static void jsonAppendSeparator(JsonString *p){ + char c; + if( p->nUsed==0 ) return; + c = p->zBuf[p->nUsed-1]; + if( c!='[' && c!='{' ) jsonAppendChar(p, ','); +} + +/* Append the N-byte string in zIn to the end of the JsonString string +** under construction. Enclose the string in "..." and escape +** any double-quotes or backslash characters contained within the +** string. +*/ +static void jsonAppendString(JsonString *p, const char *zIn, u32 N){ + u32 i; + if( zIn==0 || ((N+p->nUsed+2 >= p->nAlloc) && jsonGrow(p,N+2)!=0) ) return; + p->zBuf[p->nUsed++] = '"'; + for(i=0; inUsed+N+3-i > p->nAlloc) && jsonGrow(p,N+3-i)!=0 ) return; + p->zBuf[p->nUsed++] = '\\'; + }else if( c<=0x1f ){ + static const char aSpecial[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 'b', 't', 'n', 0, 'f', 'r', 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }; + assert( sizeof(aSpecial)==32 ); + assert( aSpecial['\b']=='b' ); + assert( aSpecial['\f']=='f' ); + assert( aSpecial['\n']=='n' ); + assert( aSpecial['\r']=='r' ); + assert( aSpecial['\t']=='t' ); + if( aSpecial[c] ){ + c = aSpecial[c]; + goto json_simple_escape; + } + if( (p->nUsed+N+7+i > p->nAlloc) && jsonGrow(p,N+7-i)!=0 ) return; + p->zBuf[p->nUsed++] = '\\'; + p->zBuf[p->nUsed++] = 'u'; + p->zBuf[p->nUsed++] = '0'; + p->zBuf[p->nUsed++] = '0'; + p->zBuf[p->nUsed++] = '0' + (c>>4); + c = "0123456789abcdef"[c&0xf]; + } + p->zBuf[p->nUsed++] = c; + } + p->zBuf[p->nUsed++] = '"'; + assert( p->nUsednAlloc ); +} + +/* +** The zIn[0..N] string is a JSON5 string literal. Append to p a translation +** of the string literal that standard JSON and that omits all JSON5 +** features. +*/ +static void jsonAppendNormalizedString(JsonString *p, const char *zIn, u32 N){ + u32 i; + jsonAppendChar(p, '"'); + zIn++; + N -= 2; + while( N>0 ){ + for(i=0; i0 ){ + jsonAppendRaw(p, zIn, i); + zIn += i; + N -= i; + if( N==0 ) break; + } + assert( zIn[0]=='\\' ); + switch( (u8)zIn[1] ){ + case '\'': + jsonAppendChar(p, '\''); + break; + case 'v': + jsonAppendRaw(p, "\\u0009", 6); + break; + case 'x': + jsonAppendRaw(p, "\\u00", 4); + jsonAppendRaw(p, &zIn[2], 2); + zIn += 2; + N -= 2; + break; + case '0': + jsonAppendRaw(p, "\\u0000", 6); + break; + case '\r': + if( zIn[2]=='\n' ){ + zIn++; + N--; + } + break; + case '\n': + break; + case 0xe2: + assert( N>=4 ); + assert( 0x80==(u8)zIn[2] ); + assert( 0xa8==(u8)zIn[3] || 0xa9==(u8)zIn[3] ); + zIn += 2; + N -= 2; + break; + default: + jsonAppendRaw(p, zIn, 2); + break; + } + zIn += 2; + N -= 2; + } + jsonAppendChar(p, '"'); +} + +/* +** The zIn[0..N] string is a JSON5 integer literal. Append to p a translation +** of the string literal that standard JSON and that omits all JSON5 +** features. +*/ +static void jsonAppendNormalizedInt(JsonString *p, const char *zIn, u32 N){ + if( zIn[0]=='+' ){ + zIn++; + N--; + }else if( zIn[0]=='-' ){ + jsonAppendChar(p, '-'); + zIn++; + N--; + } + if( zIn[0]=='0' && (zIn[1]=='x' || zIn[1]=='X') ){ + sqlite3_int64 i = 0; + int rc = sqlite3DecOrHexToI64(zIn, &i); + if( rc<=1 ){ + jsonPrintf(100,p,"%lld",i); + }else{ + assert( rc==2 ); + jsonAppendRaw(p, "9.0e999", 7); + } + return; + } + jsonAppendRaw(p, zIn, N); +} + +/* +** The zIn[0..N] string is a JSON5 real literal. Append to p a translation +** of the string literal that standard JSON and that omits all JSON5 +** features. +*/ +static void jsonAppendNormalizedReal(JsonString *p, const char *zIn, u32 N){ + u32 i; + if( zIn[0]=='+' ){ + zIn++; + N--; + }else if( zIn[0]=='-' ){ + jsonAppendChar(p, '-'); + zIn++; + N--; + } + if( zIn[0]=='.' ){ + jsonAppendChar(p, '0'); + } + for(i=0; i0 ){ + jsonAppendRaw(p, zIn, N); + } +} + + + +/* +** Append a function parameter value to the JSON string under +** construction. +*/ +static void jsonAppendValue( + JsonString *p, /* Append to this JSON string */ + sqlite3_value *pValue /* Value to append */ +){ + switch( sqlite3_value_type(pValue) ){ + case SQLITE_NULL: { + jsonAppendRaw(p, "null", 4); + break; + } + case SQLITE_FLOAT: { + jsonPrintf(100, p, "%!0.15g", sqlite3_value_double(pValue)); + break; + } + case SQLITE_INTEGER: { + const char *z = (const char*)sqlite3_value_text(pValue); + u32 n = (u32)sqlite3_value_bytes(pValue); + jsonAppendRaw(p, z, n); + break; + } + case SQLITE_TEXT: { + const char *z = (const char*)sqlite3_value_text(pValue); + u32 n = (u32)sqlite3_value_bytes(pValue); + if( sqlite3_value_subtype(pValue)==JSON_SUBTYPE ){ + jsonAppendRaw(p, z, n); + }else{ + jsonAppendString(p, z, n); + } + break; + } + default: { + if( p->bErr==0 ){ + sqlite3_result_error(p->pCtx, "JSON cannot hold BLOB values", -1); + p->bErr = 2; + jsonReset(p); + } + break; + } + } +} + + +/* Make the JSON in p the result of the SQL function. +*/ +static void jsonResult(JsonString *p){ + if( p->bErr==0 ){ + sqlite3_result_text64(p->pCtx, p->zBuf, p->nUsed, + p->bStatic ? SQLITE_TRANSIENT : sqlite3_free, + SQLITE_UTF8); + jsonZero(p); + } + assert( p->bStatic ); +} + +/************************************************************************** +** Utility routines for dealing with JsonNode and JsonParse objects +**************************************************************************/ + +/* +** Return the number of consecutive JsonNode slots need to represent +** the parsed JSON at pNode. The minimum answer is 1. For ARRAY and +** OBJECT types, the number might be larger. +** +** Appended elements are not counted. The value returned is the number +** by which the JsonNode counter should increment in order to go to the +** next peer value. +*/ +static u32 jsonNodeSize(JsonNode *pNode){ + return pNode->eType>=JSON_ARRAY ? pNode->n+1 : 1; +} + +/* +** Reclaim all memory allocated by a JsonParse object. But do not +** delete the JsonParse object itself. +*/ +static void jsonParseReset(JsonParse *pParse){ + sqlite3_free(pParse->aNode); + pParse->aNode = 0; + pParse->nNode = 0; + pParse->nAlloc = 0; + sqlite3_free(pParse->aUp); + pParse->aUp = 0; +} + +/* +** Free a JsonParse object that was obtained from sqlite3_malloc(). +*/ +static void jsonParseFree(JsonParse *pParse){ + jsonParseReset(pParse); + sqlite3_free(pParse); +} + +/* +** Convert the JsonNode pNode into a pure JSON string and +** append to pOut. Subsubstructure is also included. Return +** the number of JsonNode objects that are encoded. +*/ +static void jsonRenderNode( + JsonNode *pNode, /* The node to render */ + JsonString *pOut, /* Write JSON here */ + sqlite3_value **aReplace /* Replacement values */ +){ + assert( pNode!=0 ); + if( pNode->jnFlags & (JNODE_REPLACE|JNODE_PATCH) ){ + if( (pNode->jnFlags & JNODE_REPLACE)!=0 && ALWAYS(aReplace!=0) ){ + assert( pNode->eU==4 ); + jsonAppendValue(pOut, aReplace[pNode->u.iReplace]); + return; + } + assert( pNode->eU==5 ); + pNode = pNode->u.pPatch; + } + switch( pNode->eType ){ + default: { + assert( pNode->eType==JSON_NULL ); + jsonAppendRaw(pOut, "null", 4); + break; + } + case JSON_TRUE: { + jsonAppendRaw(pOut, "true", 4); + break; + } + case JSON_FALSE: { + jsonAppendRaw(pOut, "false", 5); + break; + } + case JSON_STRING: { + assert( pNode->eU==1 ); + if( pNode->jnFlags & JNODE_RAW ){ + if( pNode->jnFlags & JNODE_LABEL ){ + jsonAppendChar(pOut, '"'); + jsonAppendRaw(pOut, pNode->u.zJContent, pNode->n); + jsonAppendChar(pOut, '"'); + }else{ + jsonAppendString(pOut, pNode->u.zJContent, pNode->n); + } + }else if( pNode->jnFlags & JNODE_JSON5 ){ + jsonAppendNormalizedString(pOut, pNode->u.zJContent, pNode->n); + }else{ + jsonAppendRaw(pOut, pNode->u.zJContent, pNode->n); + } + break; + } + case JSON_REAL: { + assert( pNode->eU==1 ); + if( pNode->jnFlags & JNODE_JSON5 ){ + jsonAppendNormalizedReal(pOut, pNode->u.zJContent, pNode->n); + }else{ + jsonAppendRaw(pOut, pNode->u.zJContent, pNode->n); + } + break; + } + case JSON_INT: { + assert( pNode->eU==1 ); + if( pNode->jnFlags & JNODE_JSON5 ){ + jsonAppendNormalizedInt(pOut, pNode->u.zJContent, pNode->n); + }else{ + jsonAppendRaw(pOut, pNode->u.zJContent, pNode->n); + } + break; + } + case JSON_ARRAY: { + u32 j = 1; + jsonAppendChar(pOut, '['); + for(;;){ + while( j<=pNode->n ){ + if( (pNode[j].jnFlags & JNODE_REMOVE)==0 ){ + jsonAppendSeparator(pOut); + jsonRenderNode(&pNode[j], pOut, aReplace); + } + j += jsonNodeSize(&pNode[j]); + } + if( (pNode->jnFlags & JNODE_APPEND)==0 ) break; + assert( pNode->eU==2 ); + pNode = &pNode[pNode->u.iAppend]; + j = 1; + } + jsonAppendChar(pOut, ']'); + break; + } + case JSON_OBJECT: { + u32 j = 1; + jsonAppendChar(pOut, '{'); + for(;;){ + while( j<=pNode->n ){ + if( (pNode[j+1].jnFlags & JNODE_REMOVE)==0 ){ + jsonAppendSeparator(pOut); + jsonRenderNode(&pNode[j], pOut, aReplace); + jsonAppendChar(pOut, ':'); + jsonRenderNode(&pNode[j+1], pOut, aReplace); + } + j += 1 + jsonNodeSize(&pNode[j+1]); + } + if( (pNode->jnFlags & JNODE_APPEND)==0 ) break; + assert( pNode->eU==2 ); + pNode = &pNode[pNode->u.iAppend]; + j = 1; + } + jsonAppendChar(pOut, '}'); + break; + } + } +} + +/* +** Return a JsonNode and all its descendents as a JSON string. +*/ +static void jsonReturnJson( + JsonNode *pNode, /* Node to return */ + sqlite3_context *pCtx, /* Return value for this function */ + sqlite3_value **aReplace /* Array of replacement values */ +){ + JsonString s; + jsonInit(&s, pCtx); + jsonRenderNode(pNode, &s, aReplace); + jsonResult(&s); + sqlite3_result_subtype(pCtx, JSON_SUBTYPE); +} + +/* +** Translate a single byte of Hex into an integer. +** This routine only works if h really is a valid hexadecimal +** character: 0..9a..fA..F +*/ +static u8 jsonHexToInt(int h){ + assert( (h>='0' && h<='9') || (h>='a' && h<='f') || (h>='A' && h<='F') ); +#ifdef SQLITE_EBCDIC + h += 9*(1&~(h>>4)); +#else + h += 9*(1&(h>>6)); +#endif + return (u8)(h & 0xf); +} + +/* +** Convert a 4-byte hex string into an integer +*/ +static u32 jsonHexToInt4(const char *z){ + u32 v; + assert( sqlite3Isxdigit(z[0]) ); + assert( sqlite3Isxdigit(z[1]) ); + assert( sqlite3Isxdigit(z[2]) ); + assert( sqlite3Isxdigit(z[3]) ); + v = (jsonHexToInt(z[0])<<12) + + (jsonHexToInt(z[1])<<8) + + (jsonHexToInt(z[2])<<4) + + jsonHexToInt(z[3]); + return v; +} + +/* +** Make the JsonNode the return value of the function. +*/ +static void jsonReturn( + JsonNode *pNode, /* Node to return */ + sqlite3_context *pCtx, /* Return value for this function */ + sqlite3_value **aReplace /* Array of replacement values */ +){ + switch( pNode->eType ){ + default: { + assert( pNode->eType==JSON_NULL ); + sqlite3_result_null(pCtx); + break; + } + case JSON_TRUE: { + sqlite3_result_int(pCtx, 1); + break; + } + case JSON_FALSE: { + sqlite3_result_int(pCtx, 0); + break; + } + case JSON_INT: { + sqlite3_int64 i = 0; + int rc; + int bNeg = 0; + const char *z; + + + assert( pNode->eU==1 ); + z = pNode->u.zJContent; + if( z[0]=='-' ){ z++; bNeg = 1; } + else if( z[0]=='+' ){ z++; } + rc = sqlite3DecOrHexToI64(z, &i); + if( rc<=1 ){ + sqlite3_result_int64(pCtx, bNeg ? -i : i); + }else if( rc==3 && bNeg ){ + sqlite3_result_int64(pCtx, SMALLEST_INT64); + }else{ + goto to_double; + } + break; + } + case JSON_REAL: { + double r; + const char *z; + assert( pNode->eU==1 ); + to_double: + z = pNode->u.zJContent; + sqlite3AtoF(z, &r, sqlite3Strlen30(z), SQLITE_UTF8); + sqlite3_result_double(pCtx, r); + break; + } + case JSON_STRING: { + if( pNode->jnFlags & JNODE_RAW ){ + assert( pNode->eU==1 ); + sqlite3_result_text(pCtx, pNode->u.zJContent, pNode->n, + SQLITE_TRANSIENT); + }else if( (pNode->jnFlags & JNODE_ESCAPE)==0 ){ + /* JSON formatted without any backslash-escapes */ + assert( pNode->eU==1 ); + sqlite3_result_text(pCtx, pNode->u.zJContent+1, pNode->n-2, + SQLITE_TRANSIENT); + }else{ + /* Translate JSON formatted string into raw text */ + u32 i; + u32 n = pNode->n; + const char *z; + char *zOut; + u32 j; + u32 nOut = n; + assert( pNode->eU==1 ); + z = pNode->u.zJContent; + zOut = sqlite3_malloc( nOut+1 ); + if( zOut==0 ){ + sqlite3_result_error_nomem(pCtx); + break; + } + for(i=1, j=0; i>6)); + zOut[j++] = 0x80 | (v&0x3f); + }else{ + u32 vlo; + if( (v&0xfc00)==0xd800 + && i>18); + zOut[j++] = 0x80 | ((v>>12)&0x3f); + zOut[j++] = 0x80 | ((v>>6)&0x3f); + zOut[j++] = 0x80 | (v&0x3f); + }else{ + zOut[j++] = 0xe0 | (v>>12); + zOut[j++] = 0x80 | ((v>>6)&0x3f); + zOut[j++] = 0x80 | (v&0x3f); + } + } + continue; + }else if( c=='b' ){ + c = '\b'; + }else if( c=='f' ){ + c = '\f'; + }else if( c=='n' ){ + c = '\n'; + }else if( c=='r' ){ + c = '\r'; + }else if( c=='t' ){ + c = '\t'; + }else if( c=='v' ){ + c = '\v'; + }else if( c=='\'' || c=='"' || c=='/' || c=='\\' ){ + /* pass through unchanged */ + }else if( c=='0' ){ + c = 0; + }else if( c=='x' ){ + c = (jsonHexToInt(z[i+1])<<4) | jsonHexToInt(z[i+2]); + i += 2; + }else if( c=='\r' && z[i+1]=='\n' ){ + i++; + continue; + }else if( 0xe2==(u8)c ){ + assert( 0x80==(u8)z[i+1] ); + assert( 0xa8==(u8)z[i+2] || 0xa9==(u8)z[i+2] ); + i += 2; + continue; + }else{ + continue; + } + } /* end if( c=='\\' ) */ + zOut[j++] = c; + } /* end for() */ + zOut[j] = 0; + sqlite3_result_text(pCtx, zOut, j, sqlite3_free); + } + break; + } + case JSON_ARRAY: + case JSON_OBJECT: { + jsonReturnJson(pNode, pCtx, aReplace); + break; + } + } +} + +/* Forward reference */ +static int jsonParseAddNode(JsonParse*,u32,u32,const char*); + +/* +** A macro to hint to the compiler that a function should not be +** inlined. +*/ +#if defined(__GNUC__) +# define JSON_NOINLINE __attribute__((noinline)) +#elif defined(_MSC_VER) && _MSC_VER>=1310 +# define JSON_NOINLINE __declspec(noinline) +#else +# define JSON_NOINLINE +#endif + + +static JSON_NOINLINE int jsonParseAddNodeExpand( + JsonParse *pParse, /* Append the node to this object */ + u32 eType, /* Node type */ + u32 n, /* Content size or sub-node count */ + const char *zContent /* Content */ +){ + u32 nNew; + JsonNode *pNew; + assert( pParse->nNode>=pParse->nAlloc ); + if( pParse->oom ) return -1; + nNew = pParse->nAlloc*2 + 10; + pNew = sqlite3_realloc64(pParse->aNode, sizeof(JsonNode)*nNew); + if( pNew==0 ){ + pParse->oom = 1; + return -1; + } + pParse->nAlloc = nNew; + pParse->aNode = pNew; + assert( pParse->nNodenAlloc ); + return jsonParseAddNode(pParse, eType, n, zContent); +} + +/* +** Create a new JsonNode instance based on the arguments and append that +** instance to the JsonParse. Return the index in pParse->aNode[] of the +** new node, or -1 if a memory allocation fails. +*/ +static int jsonParseAddNode( + JsonParse *pParse, /* Append the node to this object */ + u32 eType, /* Node type */ + u32 n, /* Content size or sub-node count */ + const char *zContent /* Content */ +){ + JsonNode *p; + if( pParse->aNode==0 || pParse->nNode>=pParse->nAlloc ){ + return jsonParseAddNodeExpand(pParse, eType, n, zContent); + } + p = &pParse->aNode[pParse->nNode]; + p->eType = (u8)(eType & 0xff); + p->jnFlags = (u8)(eType >> 8); + VVA( p->eU = zContent ? 1 : 0 ); + p->n = n; + p->u.zJContent = zContent; + return pParse->nNode++; +} + +/* +** Return true if z[] begins with 2 (or more) hexadecimal digits +*/ +static int jsonIs2Hex(const char *z){ + return sqlite3Isxdigit(z[0]) && sqlite3Isxdigit(z[1]); +} + +/* +** Return true if z[] begins with 4 (or more) hexadecimal digits +*/ +static int jsonIs4Hex(const char *z){ + return jsonIs2Hex(z) && jsonIs2Hex(&z[2]); +} + +/* +** Return the number of bytes of JSON5 whitespace at the beginning of +** the input string z[]. +** +** JSON5 whitespace consists of any of the following characters: +** +** Unicode UTF-8 Name +** U+0009 09 horizontal tab +** U+000a 0a line feed +** U+000b 0b vertical tab +** U+000c 0c form feed +** U+000d 0d carriage return +** U+0020 20 space +** U+00a0 c2 a0 non-breaking space +** U+1680 e1 9a 80 ogham space mark +** U+2000 e2 80 80 en quad +** U+2001 e2 80 81 em quad +** U+2002 e2 80 82 en space +** U+2003 e2 80 83 em space +** U+2004 e2 80 84 three-per-em space +** U+2005 e2 80 85 four-per-em space +** U+2006 e2 80 86 six-per-em space +** U+2007 e2 80 87 figure space +** U+2008 e2 80 88 punctuation space +** U+2009 e2 80 89 thin space +** U+200a e2 80 8a hair space +** U+2028 e2 80 a8 line separator +** U+2029 e2 80 a9 paragraph separator +** U+202f e2 80 af narrow no-break space (NNBSP) +** U+205f e2 81 9f medium mathematical space (MMSP) +** U+3000 e3 80 80 ideographical space +** U+FEFF ef bb bf byte order mark +** +** In addition, comments between '/', '*' and '*', '/' and +** from '/', '/' to end-of-line are also considered to be whitespace. +*/ +static int json5Whitespace(const char *zIn){ + int n = 0; + const u8 *z = (u8*)zIn; + while( 1 /*exit by "goto whitespace_done"*/ ){ + switch( z[n] ){ + case 0x09: + case 0x0a: + case 0x0b: + case 0x0c: + case 0x0d: + case 0x20: { + n++; + break; + } + case '/': { + if( z[n+1]=='*' && z[n+2]!=0 ){ + int j; + for(j=n+3; z[j]!='/' || z[j-1]!='*'; j++){ + if( z[j]==0 ) goto whitespace_done; + } + n = j+1; + break; + }else if( z[n+1]=='/' ){ + int j; + char c; + for(j=n+2; (c = z[j])!=0; j++){ + if( c=='\n' || c=='\r' ) break; + if( 0xe2==(u8)c && 0x80==(u8)z[j+1] + && (0xa8==(u8)z[j+2] || 0xa9==(u8)z[j+2]) + ){ + j += 2; + break; + } + } + n = j; + if( z[n] ) n++; + break; + } + goto whitespace_done; + } + case 0xc2: { + if( z[n+1]==0xa0 ){ + n += 2; + break; + } + goto whitespace_done; + } + case 0xe1: { + if( z[n+1]==0x9a && z[n+2]==0x80 ){ + n += 3; + break; + } + goto whitespace_done; + } + case 0xe2: { + if( z[n+1]==0x80 ){ + u8 c = z[n+2]; + if( c<0x80 ) goto whitespace_done; + if( c<=0x8a || c==0xa8 || c==0xa9 || c==0xaf ){ + n += 3; + break; + } + }else if( z[n+1]==0x81 && z[n+2]==0x9f ){ + n += 3; + break; + } + goto whitespace_done; + } + case 0xe3: { + if( z[n+1]==0x80 && z[n+2]==0x80 ){ + n += 3; + break; + } + goto whitespace_done; + } + case 0xef: { + if( z[n+1]==0xbb && z[n+2]==0xbf ){ + n += 3; + break; + } + goto whitespace_done; + } + default: { + goto whitespace_done; + } + } + } + whitespace_done: + return n; +} + +/* +** Extra floating-point literals to allow in JSON. +*/ +static const struct NanInfName { + char c1; + char c2; + char n; + char eType; + char nRepl; + char *zMatch; + char *zRepl; +} aNanInfName[] = { + { 'i', 'I', 3, JSON_REAL, 7, "inf", "9.0e999" }, + { 'i', 'I', 8, JSON_REAL, 7, "infinity", "9.0e999" }, + { 'n', 'N', 3, JSON_NULL, 4, "NaN", "null" }, + { 'q', 'Q', 4, JSON_NULL, 4, "QNaN", "null" }, + { 's', 'S', 4, JSON_NULL, 4, "SNaN", "null" }, +}; + +/* +** Parse a single JSON value which begins at pParse->zJson[i]. Return the +** index of the first character past the end of the value parsed. +** +** Special return values: +** +** 0 End if input +** -1 Syntax error +** -2 '}' seen +** -3 ']' seen +** -4 ',' seen +** -5 ':' seen +*/ +static int jsonParseValue(JsonParse *pParse, u32 i){ + char c; + u32 j; + int iThis; + int x; + JsonNode *pNode; + const char *z = pParse->zJson; +json_parse_restart: + switch( (u8)z[i] ){ + case '{': { + /* Parse object */ + iThis = jsonParseAddNode(pParse, JSON_OBJECT, 0, 0); + if( iThis<0 ) return -1; + if( ++pParse->iDepth > JSON_MAX_DEPTH ){ + pParse->iErr = i; + return -1; + } + for(j=i+1;;j++){ + u32 nNode = pParse->nNode; + x = jsonParseValue(pParse, j); + if( x<=0 ){ + if( x==(-2) ){ + j = pParse->iErr; + if( pParse->nNode!=(u32)iThis+1 ) pParse->hasNonstd = 1; + break; + } + j += json5Whitespace(&z[j]); + if( sqlite3JsonId1(z[j]) + || (z[j]=='\\' && z[j+1]=='u' && jsonIs4Hex(&z[j+2])) + ){ + int k = j+1; + while( (sqlite3JsonId2(z[k]) && json5Whitespace(&z[k])==0) + || (z[k]=='\\' && z[k+1]=='u' && jsonIs4Hex(&z[k+2])) + ){ + k++; + } + jsonParseAddNode(pParse, JSON_STRING | (JNODE_RAW<<8), k-j, &z[j]); + pParse->hasNonstd = 1; + x = k; + }else{ + if( x!=-1 ) pParse->iErr = j; + return -1; + } + } + if( pParse->oom ) return -1; + pNode = &pParse->aNode[nNode]; + if( pNode->eType!=JSON_STRING ){ + pParse->iErr = j; + return -1; + } + pNode->jnFlags |= JNODE_LABEL; + j = x; + if( z[j]==':' ){ + j++; + }else{ + if( fast_isspace(z[j]) ){ + do{ j++; }while( fast_isspace(z[j]) ); + if( z[j]==':' ){ + j++; + goto parse_object_value; + } + } + x = jsonParseValue(pParse, j); + if( x!=(-5) ){ + if( x!=(-1) ) pParse->iErr = j; + return -1; + } + j = pParse->iErr+1; + } + parse_object_value: + x = jsonParseValue(pParse, j); + if( x<=0 ){ + if( x!=(-1) ) pParse->iErr = j; + return -1; + } + j = x; + if( z[j]==',' ){ + continue; + }else if( z[j]=='}' ){ + break; + }else{ + if( fast_isspace(z[j]) ){ + do{ j++; }while( fast_isspace(z[j]) ); + if( z[j]==',' ){ + continue; + }else if( z[j]=='}' ){ + break; + } + } + x = jsonParseValue(pParse, j); + if( x==(-4) ){ + j = pParse->iErr; + continue; + } + if( x==(-2) ){ + j = pParse->iErr; + break; + } + } + pParse->iErr = j; + return -1; + } + pParse->aNode[iThis].n = pParse->nNode - (u32)iThis - 1; + pParse->iDepth--; + return j+1; + } + case '[': { + /* Parse array */ + iThis = jsonParseAddNode(pParse, JSON_ARRAY, 0, 0); + if( iThis<0 ) return -1; + if( ++pParse->iDepth > JSON_MAX_DEPTH ){ + pParse->iErr = i; + return -1; + } + memset(&pParse->aNode[iThis].u, 0, sizeof(pParse->aNode[iThis].u)); + for(j=i+1;;j++){ + x = jsonParseValue(pParse, j); + if( x<=0 ){ + if( x==(-3) ){ + j = pParse->iErr; + if( pParse->nNode!=(u32)iThis+1 ) pParse->hasNonstd = 1; + break; + } + if( x!=(-1) ) pParse->iErr = j; + return -1; + } + j = x; + if( z[j]==',' ){ + continue; + }else if( z[j]==']' ){ + break; + }else{ + if( fast_isspace(z[j]) ){ + do{ j++; }while( fast_isspace(z[j]) ); + if( z[j]==',' ){ + continue; + }else if( z[j]==']' ){ + break; + } + } + x = jsonParseValue(pParse, j); + if( x==(-4) ){ + j = pParse->iErr; + continue; + } + if( x==(-3) ){ + j = pParse->iErr; + break; + } + } + pParse->iErr = j; + return -1; + } + pParse->aNode[iThis].n = pParse->nNode - (u32)iThis - 1; + pParse->iDepth--; + return j+1; + } + case '\'': { + u8 jnFlags; + char cDelim; + pParse->hasNonstd = 1; + jnFlags = JNODE_JSON5; + goto parse_string; + case '"': + /* Parse string */ + jnFlags = 0; + parse_string: + cDelim = z[i]; + j = i+1; + for(;;){ + c = z[j]; + if( (c & ~0x1f)==0 ){ + /* Control characters are not allowed in strings */ + pParse->iErr = j; + return -1; + } + if( c=='\\' ){ + c = z[++j]; + if( c=='"' || c=='\\' || c=='/' || c=='b' || c=='f' + || c=='n' || c=='r' || c=='t' + || (c=='u' && jsonIs4Hex(&z[j+1])) ){ + jnFlags |= JNODE_ESCAPE; + }else if( c=='\'' || c=='0' || c=='v' || c=='\n' + || (0xe2==(u8)c && 0x80==(u8)z[j+1] + && (0xa8==(u8)z[j+2] || 0xa9==(u8)z[j+2])) + || (c=='x' && jsonIs2Hex(&z[j+1])) ){ + jnFlags |= (JNODE_ESCAPE|JNODE_JSON5); + pParse->hasNonstd = 1; + }else if( c=='\r' ){ + if( z[j+1]=='\n' ) j++; + jnFlags |= (JNODE_ESCAPE|JNODE_JSON5); + pParse->hasNonstd = 1; + }else{ + pParse->iErr = j; + return -1; + } + }else if( c==cDelim ){ + break; + } + j++; + } + jsonParseAddNode(pParse, JSON_STRING | (jnFlags<<8), j+1-i, &z[i]); + return j+1; + } + case 't': { + if( strncmp(z+i,"true",4)==0 && !sqlite3Isalnum(z[i+4]) ){ + jsonParseAddNode(pParse, JSON_TRUE, 0, 0); + return i+4; + } + pParse->iErr = i; + return -1; + } + case 'f': { + if( strncmp(z+i,"false",5)==0 && !sqlite3Isalnum(z[i+5]) ){ + jsonParseAddNode(pParse, JSON_FALSE, 0, 0); + return i+5; + } + pParse->iErr = i; + return -1; + } + case '+': { + u8 seenDP, seenE, jnFlags; + pParse->hasNonstd = 1; + jnFlags = JNODE_JSON5; + goto parse_number; + case '.': + if( sqlite3Isdigit(z[i+1]) ){ + pParse->hasNonstd = 1; + jnFlags = JNODE_JSON5; + seenE = 0; + seenDP = JSON_REAL; + goto parse_number_2; + } + pParse->iErr = i; + return -1; + case '-': + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + /* Parse number */ + jnFlags = 0; + parse_number: + seenDP = JSON_INT; + seenE = 0; + assert( '-' < '0' ); + assert( '+' < '0' ); + assert( '.' < '0' ); + c = z[i]; + + if( c<='0' ){ + if( c=='0' ){ + if( (z[i+1]=='x' || z[i+1]=='X') && sqlite3Isxdigit(z[i+2]) ){ + assert( seenDP==JSON_INT ); + pParse->hasNonstd = 1; + jnFlags |= JNODE_JSON5; + for(j=i+3; sqlite3Isxdigit(z[j]); j++){} + goto parse_number_finish; + }else if( sqlite3Isdigit(z[i+1]) ){ + pParse->iErr = i+1; + return -1; + } + }else{ + if( !sqlite3Isdigit(z[i+1]) ){ + /* JSON5 allows for "+Infinity" and "-Infinity" using exactly + ** that case. SQLite also allows these in any case and it allows + ** "+inf" and "-inf". */ + if( (z[i+1]=='I' || z[i+1]=='i') + && sqlite3StrNICmp(&z[i+1], "inf",3)==0 + ){ + pParse->hasNonstd = 1; + if( z[i]=='-' ){ + jsonParseAddNode(pParse, JSON_REAL, 8, "-9.0e999"); + }else{ + jsonParseAddNode(pParse, JSON_REAL, 7, "9.0e999"); + } + return i + (sqlite3StrNICmp(&z[i+4],"inity",5)==0 ? 9 : 4); + } + if( z[i+1]=='.' ){ + pParse->hasNonstd = 1; + jnFlags |= JNODE_JSON5; + goto parse_number_2; + } + pParse->iErr = i; + return -1; + } + if( z[i+1]=='0' ){ + if( sqlite3Isdigit(z[i+2]) ){ + pParse->iErr = i+1; + return -1; + }else if( (z[i+2]=='x' || z[i+2]=='X') && sqlite3Isxdigit(z[i+3]) ){ + pParse->hasNonstd = 1; + jnFlags |= JNODE_JSON5; + for(j=i+4; sqlite3Isxdigit(z[j]); j++){} + goto parse_number_finish; + } + } + } + } + parse_number_2: + for(j=i+1;; j++){ + c = z[j]; + if( sqlite3Isdigit(c) ) continue; + if( c=='.' ){ + if( seenDP==JSON_REAL ){ + pParse->iErr = j; + return -1; + } + seenDP = JSON_REAL; + continue; + } + if( c=='e' || c=='E' ){ + if( z[j-1]<'0' ){ + if( ALWAYS(z[j-1]=='.') && ALWAYS(j-2>=i) && sqlite3Isdigit(z[j-2]) ){ + pParse->hasNonstd = 1; + jnFlags |= JNODE_JSON5; + }else{ + pParse->iErr = j; + return -1; + } + } + if( seenE ){ + pParse->iErr = j; + return -1; + } + seenDP = JSON_REAL; + seenE = 1; + c = z[j+1]; + if( c=='+' || c=='-' ){ + j++; + c = z[j+1]; + } + if( c<'0' || c>'9' ){ + pParse->iErr = j; + return -1; + } + continue; + } + break; + } + if( z[j-1]<'0' ){ + if( ALWAYS(z[j-1]=='.') && ALWAYS(j-2>=i) && sqlite3Isdigit(z[j-2]) ){ + pParse->hasNonstd = 1; + jnFlags |= JNODE_JSON5; + }else{ + pParse->iErr = j; + return -1; + } + } + parse_number_finish: + jsonParseAddNode(pParse, seenDP | (jnFlags<<8), j - i, &z[i]); + return j; + } + case '}': { + pParse->iErr = i; + return -2; /* End of {...} */ + } + case ']': { + pParse->iErr = i; + return -3; /* End of [...] */ + } + case ',': { + pParse->iErr = i; + return -4; /* List separator */ + } + case ':': { + pParse->iErr = i; + return -5; /* Object label/value separator */ + } + case 0: { + return 0; /* End of file */ + } + case 0x09: + case 0x0a: + case 0x0d: + case 0x20: { + do{ + i++; + }while( fast_isspace(z[i]) ); + goto json_parse_restart; + } + case 0x0b: + case 0x0c: + case '/': + case 0xc2: + case 0xe1: + case 0xe2: + case 0xe3: + case 0xef: { + j = json5Whitespace(&z[i]); + if( j>0 ){ + i += j; + pParse->hasNonstd = 1; + goto json_parse_restart; + } + pParse->iErr = i; + return -1; + } + case 'n': { + if( strncmp(z+i,"null",4)==0 && !sqlite3Isalnum(z[i+4]) ){ + jsonParseAddNode(pParse, JSON_NULL, 0, 0); + return i+4; + } + /* fall-through into the default case that checks for NaN */ + } + default: { + u32 k; + int nn; + c = z[i]; + for(k=0; khasNonstd = 1; + return i + nn; + } + pParse->iErr = i; + return -1; /* Syntax error */ + } + } /* End switch(z[i]) */ +} + +/* +** Parse a complete JSON string. Return 0 on success or non-zero if there +** are any errors. If an error occurs, free all memory associated with +** pParse. +** +** pParse is uninitialized when this routine is called. +*/ +static int jsonParse( + JsonParse *pParse, /* Initialize and fill this JsonParse object */ + sqlite3_context *pCtx, /* Report errors here */ + const char *zJson /* Input JSON text to be parsed */ +){ + int i; + memset(pParse, 0, sizeof(*pParse)); + if( zJson==0 ) return 1; + pParse->zJson = zJson; + i = jsonParseValue(pParse, 0); + if( pParse->oom ) i = -1; + if( i>0 ){ + assert( pParse->iDepth==0 ); + while( fast_isspace(zJson[i]) ) i++; + if( zJson[i] ){ + i += json5Whitespace(&zJson[i]); + if( zJson[i] ){ + jsonParseReset(pParse); + return 1; + } + pParse->hasNonstd = 1; + } + } + if( i<=0 ){ + if( pCtx!=0 ){ + if( pParse->oom ){ + sqlite3_result_error_nomem(pCtx); + }else{ + sqlite3_result_error(pCtx, "malformed JSON", -1); + } + } + jsonParseReset(pParse); + return 1; + } + return 0; +} + +/* Mark node i of pParse as being a child of iParent. Call recursively +** to fill in all the descendants of node i. +*/ +static void jsonParseFillInParentage(JsonParse *pParse, u32 i, u32 iParent){ + JsonNode *pNode = &pParse->aNode[i]; + u32 j; + pParse->aUp[i] = iParent; + switch( pNode->eType ){ + case JSON_ARRAY: { + for(j=1; j<=pNode->n; j += jsonNodeSize(pNode+j)){ + jsonParseFillInParentage(pParse, i+j, i); + } + break; + } + case JSON_OBJECT: { + for(j=1; j<=pNode->n; j += jsonNodeSize(pNode+j+1)+1){ + pParse->aUp[i+j] = i; + jsonParseFillInParentage(pParse, i+j+1, i); + } + break; + } + default: { + break; + } + } +} + +/* +** Compute the parentage of all nodes in a completed parse. +*/ +static int jsonParseFindParents(JsonParse *pParse){ + u32 *aUp; + assert( pParse->aUp==0 ); + aUp = pParse->aUp = sqlite3_malloc64( sizeof(u32)*pParse->nNode ); + if( aUp==0 ){ + pParse->oom = 1; + return SQLITE_NOMEM; + } + jsonParseFillInParentage(pParse, 0, 0); + return SQLITE_OK; +} + +/* +** Magic number used for the JSON parse cache in sqlite3_get_auxdata() +*/ +#define JSON_CACHE_ID (-429938) /* First cache entry */ +#define JSON_CACHE_SZ 4 /* Max number of cache entries */ + +/* +** Obtain a complete parse of the JSON found in the first argument +** of the argv array. Use the sqlite3_get_auxdata() cache for this +** parse if it is available. If the cache is not available or if it +** is no longer valid, parse the JSON again and return the new parse, +** and also register the new parse so that it will be available for +** future sqlite3_get_auxdata() calls. +** +** If an error occurs and pErrCtx!=0 then report the error on pErrCtx +** and return NULL. +** +** If an error occurs and pErrCtx==0 then return the Parse object with +** JsonParse.nErr non-zero. If the caller invokes this routine with +** pErrCtx==0 and it gets back a JsonParse with nErr!=0, then the caller +** is responsible for invoking jsonParseFree() on the returned value. +** But the caller may invoke jsonParseFree() *only* if pParse->nErr!=0. +*/ +static JsonParse *jsonParseCached( + sqlite3_context *pCtx, + sqlite3_value **argv, + sqlite3_context *pErrCtx +){ + const char *zJson = (const char*)sqlite3_value_text(argv[0]); + int nJson = sqlite3_value_bytes(argv[0]); + JsonParse *p; + JsonParse *pMatch = 0; + int iKey; + int iMinKey = 0; + u32 iMinHold = 0xffffffff; + u32 iMaxHold = 0; + if( zJson==0 ) return 0; + for(iKey=0; iKeynJson==nJson + && memcmp(p->zJson,zJson,nJson)==0 + ){ + p->nErr = 0; + pMatch = p; + }else if( p->iHoldiHold; + iMinKey = iKey; + } + if( p->iHold>iMaxHold ){ + iMaxHold = p->iHold; + } + } + if( pMatch ){ + pMatch->nErr = 0; + pMatch->iHold = iMaxHold+1; + return pMatch; + } + p = sqlite3_malloc64( sizeof(*p) + nJson + 1 ); + if( p==0 ){ + sqlite3_result_error_nomem(pCtx); + return 0; + } + memset(p, 0, sizeof(*p)); + p->zJson = (char*)&p[1]; + memcpy((char*)p->zJson, zJson, nJson+1); + if( jsonParse(p, pErrCtx, p->zJson) ){ + if( pErrCtx==0 ){ + p->nErr = 1; + return p; + } + sqlite3_free(p); + return 0; + } + p->nJson = nJson; + p->iHold = iMaxHold+1; + sqlite3_set_auxdata(pCtx, JSON_CACHE_ID+iMinKey, p, + (void(*)(void*))jsonParseFree); + return (JsonParse*)sqlite3_get_auxdata(pCtx, JSON_CACHE_ID+iMinKey); +} + +/* +** Compare the OBJECT label at pNode against zKey,nKey. Return true on +** a match. +*/ +static int jsonLabelCompare(const JsonNode *pNode, const char *zKey, u32 nKey){ + assert( pNode->eU==1 ); + if( pNode->jnFlags & JNODE_RAW ){ + if( pNode->n!=nKey ) return 0; + return strncmp(pNode->u.zJContent, zKey, nKey)==0; + }else{ + if( pNode->n!=nKey+2 ) return 0; + return strncmp(pNode->u.zJContent+1, zKey, nKey)==0; + } +} +static int jsonSameLabel(const JsonNode *p1, const JsonNode *p2){ + if( p1->jnFlags & JNODE_RAW ){ + return jsonLabelCompare(p2, p1->u.zJContent, p1->n); + }else if( p2->jnFlags & JNODE_RAW ){ + return jsonLabelCompare(p1, p2->u.zJContent, p2->n); + }else{ + return p1->n==p2->n && strncmp(p1->u.zJContent,p2->u.zJContent,p1->n)==0; + } +} + +/* forward declaration */ +static JsonNode *jsonLookupAppend(JsonParse*,const char*,int*,const char**); + +/* +** Search along zPath to find the node specified. Return a pointer +** to that node, or NULL if zPath is malformed or if there is no such +** node. +** +** If pApnd!=0, then try to append new nodes to complete zPath if it is +** possible to do so and if no existing node corresponds to zPath. If +** new nodes are appended *pApnd is set to 1. +*/ +static JsonNode *jsonLookupStep( + JsonParse *pParse, /* The JSON to search */ + u32 iRoot, /* Begin the search at this node */ + const char *zPath, /* The path to search */ + int *pApnd, /* Append nodes to complete path if not NULL */ + const char **pzErr /* Make *pzErr point to any syntax error in zPath */ +){ + u32 i, j, nKey; + const char *zKey; + JsonNode *pRoot = &pParse->aNode[iRoot]; + if( zPath[0]==0 ) return pRoot; + if( pRoot->jnFlags & JNODE_REPLACE ) return 0; + if( zPath[0]=='.' ){ + if( pRoot->eType!=JSON_OBJECT ) return 0; + zPath++; + if( zPath[0]=='"' ){ + zKey = zPath + 1; + for(i=1; zPath[i] && zPath[i]!='"'; i++){} + nKey = i-1; + if( zPath[i] ){ + i++; + }else{ + *pzErr = zPath; + return 0; + } + testcase( nKey==0 ); + }else{ + zKey = zPath; + for(i=0; zPath[i] && zPath[i]!='.' && zPath[i]!='['; i++){} + nKey = i; + if( nKey==0 ){ + *pzErr = zPath; + return 0; + } + } + j = 1; + for(;;){ + while( j<=pRoot->n ){ + if( jsonLabelCompare(pRoot+j, zKey, nKey) ){ + return jsonLookupStep(pParse, iRoot+j+1, &zPath[i], pApnd, pzErr); + } + j++; + j += jsonNodeSize(&pRoot[j]); + } + if( (pRoot->jnFlags & JNODE_APPEND)==0 ) break; + assert( pRoot->eU==2 ); + iRoot += pRoot->u.iAppend; + pRoot = &pParse->aNode[iRoot]; + j = 1; + } + if( pApnd ){ + u32 iStart, iLabel; + JsonNode *pNode; + iStart = jsonParseAddNode(pParse, JSON_OBJECT, 2, 0); + iLabel = jsonParseAddNode(pParse, JSON_STRING, nKey, zKey); + zPath += i; + pNode = jsonLookupAppend(pParse, zPath, pApnd, pzErr); + if( pParse->oom ) return 0; + if( pNode ){ + pRoot = &pParse->aNode[iRoot]; + assert( pRoot->eU==0 ); + pRoot->u.iAppend = iStart - iRoot; + pRoot->jnFlags |= JNODE_APPEND; + VVA( pRoot->eU = 2 ); + pParse->aNode[iLabel].jnFlags |= JNODE_RAW; + } + return pNode; + } + }else if( zPath[0]=='[' ){ + i = 0; + j = 1; + while( sqlite3Isdigit(zPath[j]) ){ + i = i*10 + zPath[j] - '0'; + j++; + } + if( j<2 || zPath[j]!=']' ){ + if( zPath[1]=='#' ){ + JsonNode *pBase = pRoot; + int iBase = iRoot; + if( pRoot->eType!=JSON_ARRAY ) return 0; + for(;;){ + while( j<=pBase->n ){ + if( (pBase[j].jnFlags & JNODE_REMOVE)==0 ) i++; + j += jsonNodeSize(&pBase[j]); + } + if( (pBase->jnFlags & JNODE_APPEND)==0 ) break; + assert( pBase->eU==2 ); + iBase += pBase->u.iAppend; + pBase = &pParse->aNode[iBase]; + j = 1; + } + j = 2; + if( zPath[2]=='-' && sqlite3Isdigit(zPath[3]) ){ + unsigned int x = 0; + j = 3; + do{ + x = x*10 + zPath[j] - '0'; + j++; + }while( sqlite3Isdigit(zPath[j]) ); + if( x>i ) return 0; + i -= x; + } + if( zPath[j]!=']' ){ + *pzErr = zPath; + return 0; + } + }else{ + *pzErr = zPath; + return 0; + } + } + if( pRoot->eType!=JSON_ARRAY ) return 0; + zPath += j + 1; + j = 1; + for(;;){ + while( j<=pRoot->n && (i>0 || (pRoot[j].jnFlags & JNODE_REMOVE)!=0) ){ + if( (pRoot[j].jnFlags & JNODE_REMOVE)==0 ) i--; + j += jsonNodeSize(&pRoot[j]); + } + if( (pRoot->jnFlags & JNODE_APPEND)==0 ) break; + assert( pRoot->eU==2 ); + iRoot += pRoot->u.iAppend; + pRoot = &pParse->aNode[iRoot]; + j = 1; + } + if( j<=pRoot->n ){ + return jsonLookupStep(pParse, iRoot+j, zPath, pApnd, pzErr); + } + if( i==0 && pApnd ){ + u32 iStart; + JsonNode *pNode; + iStart = jsonParseAddNode(pParse, JSON_ARRAY, 1, 0); + pNode = jsonLookupAppend(pParse, zPath, pApnd, pzErr); + if( pParse->oom ) return 0; + if( pNode ){ + pRoot = &pParse->aNode[iRoot]; + assert( pRoot->eU==0 ); + pRoot->u.iAppend = iStart - iRoot; + pRoot->jnFlags |= JNODE_APPEND; + VVA( pRoot->eU = 2 ); + } + return pNode; + } + }else{ + *pzErr = zPath; + } + return 0; +} + +/* +** Append content to pParse that will complete zPath. Return a pointer +** to the inserted node, or return NULL if the append fails. +*/ +static JsonNode *jsonLookupAppend( + JsonParse *pParse, /* Append content to the JSON parse */ + const char *zPath, /* Description of content to append */ + int *pApnd, /* Set this flag to 1 */ + const char **pzErr /* Make this point to any syntax error */ +){ + *pApnd = 1; + if( zPath[0]==0 ){ + jsonParseAddNode(pParse, JSON_NULL, 0, 0); + return pParse->oom ? 0 : &pParse->aNode[pParse->nNode-1]; + } + if( zPath[0]=='.' ){ + jsonParseAddNode(pParse, JSON_OBJECT, 0, 0); + }else if( strncmp(zPath,"[0]",3)==0 ){ + jsonParseAddNode(pParse, JSON_ARRAY, 0, 0); + }else{ + return 0; + } + if( pParse->oom ) return 0; + return jsonLookupStep(pParse, pParse->nNode-1, zPath, pApnd, pzErr); +} + +/* +** Return the text of a syntax error message on a JSON path. Space is +** obtained from sqlite3_malloc(). +*/ +static char *jsonPathSyntaxError(const char *zErr){ + return sqlite3_mprintf("JSON path error near '%q'", zErr); +} + +/* +** Do a node lookup using zPath. Return a pointer to the node on success. +** Return NULL if not found or if there is an error. +** +** On an error, write an error message into pCtx and increment the +** pParse->nErr counter. +** +** If pApnd!=NULL then try to append missing nodes and set *pApnd = 1 if +** nodes are appended. +*/ +static JsonNode *jsonLookup( + JsonParse *pParse, /* The JSON to search */ + const char *zPath, /* The path to search */ + int *pApnd, /* Append nodes to complete path if not NULL */ + sqlite3_context *pCtx /* Report errors here, if not NULL */ +){ + const char *zErr = 0; + JsonNode *pNode = 0; + char *zMsg; + + if( zPath==0 ) return 0; + if( zPath[0]!='$' ){ + zErr = zPath; + goto lookup_err; + } + zPath++; + pNode = jsonLookupStep(pParse, 0, zPath, pApnd, &zErr); + if( zErr==0 ) return pNode; + +lookup_err: + pParse->nErr++; + assert( zErr!=0 && pCtx!=0 ); + zMsg = jsonPathSyntaxError(zErr); + if( zMsg ){ + sqlite3_result_error(pCtx, zMsg, -1); + sqlite3_free(zMsg); + }else{ + sqlite3_result_error_nomem(pCtx); + } + return 0; +} + + +/* +** Report the wrong number of arguments for json_insert(), json_replace() +** or json_set(). +*/ +static void jsonWrongNumArgs( + sqlite3_context *pCtx, + const char *zFuncName +){ + char *zMsg = sqlite3_mprintf("json_%s() needs an odd number of arguments", + zFuncName); + sqlite3_result_error(pCtx, zMsg, -1); + sqlite3_free(zMsg); +} + +/* +** Mark all NULL entries in the Object passed in as JNODE_REMOVE. +*/ +static void jsonRemoveAllNulls(JsonNode *pNode){ + int i, n; + assert( pNode->eType==JSON_OBJECT ); + n = pNode->n; + for(i=2; i<=n; i += jsonNodeSize(&pNode[i])+1){ + switch( pNode[i].eType ){ + case JSON_NULL: + pNode[i].jnFlags |= JNODE_REMOVE; + break; + case JSON_OBJECT: + jsonRemoveAllNulls(&pNode[i]); + break; + } + } +} + + +/**************************************************************************** +** SQL functions used for testing and debugging +****************************************************************************/ + +#ifdef SQLITE_DEBUG +/* +** The json_parse(JSON) function returns a string which describes +** a parse of the JSON provided. Or it returns NULL if JSON is not +** well-formed. +*/ +static void jsonParseFunc( + sqlite3_context *ctx, + int argc, + sqlite3_value **argv +){ + JsonString s; /* Output string - not real JSON */ + JsonParse x; /* The parse */ + u32 i; + + assert( argc==1 ); + if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return; + jsonParseFindParents(&x); + jsonInit(&s, ctx); + for(i=0; inNode ); + if( argc==2 ){ + const char *zPath = (const char*)sqlite3_value_text(argv[1]); + pNode = jsonLookup(p, zPath, 0, ctx); + }else{ + pNode = p->aNode; + } + if( pNode==0 ){ + return; + } + if( pNode->eType==JSON_ARRAY ){ + assert( (pNode->jnFlags & JNODE_APPEND)==0 ); + for(i=1; i<=pNode->n; n++){ + i += jsonNodeSize(&pNode[i]); + } + } + sqlite3_result_int64(ctx, n); +} + +/* +** Bit values for the flags passed into jsonExtractFunc() or +** jsonSetFunc() via the user-data value. +*/ +#define JSON_JSON 0x01 /* Result is always JSON */ +#define JSON_SQL 0x02 /* Result is always SQL */ +#define JSON_ABPATH 0x03 /* Allow abbreviated JSON path specs */ +#define JSON_ISSET 0x04 /* json_set(), not json_insert() */ + +/* +** json_extract(JSON, PATH, ...) +** "->"(JSON,PATH) +** "->>"(JSON,PATH) +** +** Return the element described by PATH. Return NULL if that PATH element +** is not found. +** +** If JSON_JSON is set or if more that one PATH argument is supplied then +** always return a JSON representation of the result. If JSON_SQL is set, +** then always return an SQL representation of the result. If neither flag +** is present and argc==2, then return JSON for objects and arrays and SQL +** for all other values. +** +** When multiple PATH arguments are supplied, the result is a JSON array +** containing the result of each PATH. +** +** Abbreviated JSON path expressions are allows if JSON_ABPATH, for +** compatibility with PG. +*/ +static void jsonExtractFunc( + sqlite3_context *ctx, + int argc, + sqlite3_value **argv +){ + JsonParse *p; /* The parse */ + JsonNode *pNode; + const char *zPath; + int flags = SQLITE_PTR_TO_INT(sqlite3_user_data(ctx)); + JsonString jx; + + if( argc<2 ) return; + p = jsonParseCached(ctx, argv, ctx); + if( p==0 ) return; + if( argc==2 ){ + /* With a single PATH argument */ + zPath = (const char*)sqlite3_value_text(argv[1]); + if( zPath==0 ) return; + if( flags & JSON_ABPATH ){ + if( zPath[0]!='$' || (zPath[1]!='.' && zPath[1]!='[' && zPath[1]!=0) ){ + /* The -> and ->> operators accept abbreviated PATH arguments. This + ** is mostly for compatibility with PostgreSQL, but also for + ** convenience. + ** + ** NUMBER ==> $[NUMBER] // PG compatible + ** LABEL ==> $.LABEL // PG compatible + ** [NUMBER] ==> $[NUMBER] // Not PG. Purely for convenience + */ + jsonInit(&jx, ctx); + if( sqlite3Isdigit(zPath[0]) ){ + jsonAppendRaw(&jx, "$[", 2); + jsonAppendRaw(&jx, zPath, (int)strlen(zPath)); + jsonAppendRaw(&jx, "]", 2); + }else{ + jsonAppendRaw(&jx, "$.", 1 + (zPath[0]!='[')); + jsonAppendRaw(&jx, zPath, (int)strlen(zPath)); + jsonAppendChar(&jx, 0); + } + pNode = jx.bErr ? 0 : jsonLookup(p, jx.zBuf, 0, ctx); + jsonReset(&jx); + }else{ + pNode = jsonLookup(p, zPath, 0, ctx); + } + if( pNode ){ + if( flags & JSON_JSON ){ + jsonReturnJson(pNode, ctx, 0); + }else{ + jsonReturn(pNode, ctx, 0); + sqlite3_result_subtype(ctx, 0); + } + } + }else{ + pNode = jsonLookup(p, zPath, 0, ctx); + if( p->nErr==0 && pNode ) jsonReturn(pNode, ctx, 0); + } + }else{ + /* Two or more PATH arguments results in a JSON array with each + ** element of the array being the value selected by one of the PATHs */ + int i; + jsonInit(&jx, ctx); + jsonAppendChar(&jx, '['); + for(i=1; inErr ) break; + jsonAppendSeparator(&jx); + if( pNode ){ + jsonRenderNode(pNode, &jx, 0); + }else{ + jsonAppendRaw(&jx, "null", 4); + } + } + if( i==argc ){ + jsonAppendChar(&jx, ']'); + jsonResult(&jx); + sqlite3_result_subtype(ctx, JSON_SUBTYPE); + } + jsonReset(&jx); + } +} + +/* This is the RFC 7396 MergePatch algorithm. +*/ +static JsonNode *jsonMergePatch( + JsonParse *pParse, /* The JSON parser that contains the TARGET */ + u32 iTarget, /* Node of the TARGET in pParse */ + JsonNode *pPatch /* The PATCH */ +){ + u32 i, j; + u32 iRoot; + JsonNode *pTarget; + if( pPatch->eType!=JSON_OBJECT ){ + return pPatch; + } + assert( iTargetnNode ); + pTarget = &pParse->aNode[iTarget]; + assert( (pPatch->jnFlags & JNODE_APPEND)==0 ); + if( pTarget->eType!=JSON_OBJECT ){ + jsonRemoveAllNulls(pPatch); + return pPatch; + } + iRoot = iTarget; + for(i=1; in; i += jsonNodeSize(&pPatch[i+1])+1){ + u32 nKey; + const char *zKey; + assert( pPatch[i].eType==JSON_STRING ); + assert( pPatch[i].jnFlags & JNODE_LABEL ); + assert( pPatch[i].eU==1 ); + nKey = pPatch[i].n; + zKey = pPatch[i].u.zJContent; + for(j=1; jn; j += jsonNodeSize(&pTarget[j+1])+1 ){ + assert( pTarget[j].eType==JSON_STRING ); + assert( pTarget[j].jnFlags & JNODE_LABEL ); + if( jsonSameLabel(&pPatch[i], &pTarget[j]) ){ + if( pTarget[j+1].jnFlags & (JNODE_REMOVE|JNODE_PATCH) ) break; + if( pPatch[i+1].eType==JSON_NULL ){ + pTarget[j+1].jnFlags |= JNODE_REMOVE; + }else{ + JsonNode *pNew = jsonMergePatch(pParse, iTarget+j+1, &pPatch[i+1]); + if( pNew==0 ) return 0; + pTarget = &pParse->aNode[iTarget]; + if( pNew!=&pTarget[j+1] ){ + assert( pTarget[j+1].eU==0 + || pTarget[j+1].eU==1 + || pTarget[j+1].eU==2 ); + testcase( pTarget[j+1].eU==1 ); + testcase( pTarget[j+1].eU==2 ); + VVA( pTarget[j+1].eU = 5 ); + pTarget[j+1].u.pPatch = pNew; + pTarget[j+1].jnFlags |= JNODE_PATCH; + } + } + break; + } + } + if( j>=pTarget->n && pPatch[i+1].eType!=JSON_NULL ){ + int iStart, iPatch; + iStart = jsonParseAddNode(pParse, JSON_OBJECT, 2, 0); + jsonParseAddNode(pParse, JSON_STRING, nKey, zKey); + iPatch = jsonParseAddNode(pParse, JSON_TRUE, 0, 0); + if( pParse->oom ) return 0; + jsonRemoveAllNulls(pPatch); + pTarget = &pParse->aNode[iTarget]; + assert( pParse->aNode[iRoot].eU==0 || pParse->aNode[iRoot].eU==2 ); + testcase( pParse->aNode[iRoot].eU==2 ); + pParse->aNode[iRoot].jnFlags |= JNODE_APPEND; + VVA( pParse->aNode[iRoot].eU = 2 ); + pParse->aNode[iRoot].u.iAppend = iStart - iRoot; + iRoot = iStart; + assert( pParse->aNode[iPatch].eU==0 ); + VVA( pParse->aNode[iPatch].eU = 5 ); + pParse->aNode[iPatch].jnFlags |= JNODE_PATCH; + pParse->aNode[iPatch].u.pPatch = &pPatch[i+1]; + } + } + return pTarget; +} + +/* +** Implementation of the json_mergepatch(JSON1,JSON2) function. Return a JSON +** object that is the result of running the RFC 7396 MergePatch() algorithm +** on the two arguments. +*/ +static void jsonPatchFunc( + sqlite3_context *ctx, + int argc, + sqlite3_value **argv +){ + JsonParse x; /* The JSON that is being patched */ + JsonParse y; /* The patch */ + JsonNode *pResult; /* The result of the merge */ + + UNUSED_PARAMETER(argc); + if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return; + if( jsonParse(&y, ctx, (const char*)sqlite3_value_text(argv[1])) ){ + jsonParseReset(&x); + return; + } + pResult = jsonMergePatch(&x, 0, y.aNode); + assert( pResult!=0 || x.oom ); + if( pResult ){ + jsonReturnJson(pResult, ctx, 0); + }else{ + sqlite3_result_error_nomem(ctx); + } + jsonParseReset(&x); + jsonParseReset(&y); +} + + +/* +** Implementation of the json_object(NAME,VALUE,...) function. Return a JSON +** object that contains all name/value given in arguments. Or if any name +** is not a string or if any value is a BLOB, throw an error. +*/ +static void jsonObjectFunc( + sqlite3_context *ctx, + int argc, + sqlite3_value **argv +){ + int i; + JsonString jx; + const char *z; + u32 n; + + if( argc&1 ){ + sqlite3_result_error(ctx, "json_object() requires an even number " + "of arguments", -1); + return; + } + jsonInit(&jx, ctx); + jsonAppendChar(&jx, '{'); + for(i=0; ijnFlags |= JNODE_REMOVE; + } + if( (x.aNode[0].jnFlags & JNODE_REMOVE)==0 ){ + jsonReturnJson(x.aNode, ctx, 0); + } +remove_done: + jsonParseReset(&x); +} + +/* +** json_replace(JSON, PATH, VALUE, ...) +** +** Replace the value at PATH with VALUE. If PATH does not already exist, +** this routine is a no-op. If JSON or PATH is malformed, throw an error. +*/ +static void jsonReplaceFunc( + sqlite3_context *ctx, + int argc, + sqlite3_value **argv +){ + JsonParse x; /* The parse */ + JsonNode *pNode; + const char *zPath; + u32 i; + + if( argc<1 ) return; + if( (argc&1)==0 ) { + jsonWrongNumArgs(ctx, "replace"); + return; + } + if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return; + assert( x.nNode ); + for(i=1; i<(u32)argc; i+=2){ + zPath = (const char*)sqlite3_value_text(argv[i]); + pNode = jsonLookup(&x, zPath, 0, ctx); + if( x.nErr ) goto replace_err; + if( pNode ){ + assert( pNode->eU==0 || pNode->eU==1 || pNode->eU==4 ); + testcase( pNode->eU!=0 && pNode->eU!=1 ); + pNode->jnFlags |= (u8)JNODE_REPLACE; + VVA( pNode->eU = 4 ); + pNode->u.iReplace = i + 1; + } + } + if( x.aNode[0].jnFlags & JNODE_REPLACE ){ + assert( x.aNode[0].eU==4 ); + sqlite3_result_value(ctx, argv[x.aNode[0].u.iReplace]); + }else{ + jsonReturnJson(x.aNode, ctx, argv); + } +replace_err: + jsonParseReset(&x); +} + + +/* +** json_set(JSON, PATH, VALUE, ...) +** +** Set the value at PATH to VALUE. Create the PATH if it does not already +** exist. Overwrite existing values that do exist. +** If JSON or PATH is malformed, throw an error. +** +** json_insert(JSON, PATH, VALUE, ...) +** +** Create PATH and initialize it to VALUE. If PATH already exists, this +** routine is a no-op. If JSON or PATH is malformed, throw an error. +*/ +static void jsonSetFunc( + sqlite3_context *ctx, + int argc, + sqlite3_value **argv +){ + JsonParse x; /* The parse */ + JsonNode *pNode; + const char *zPath; + u32 i; + int bApnd; + int bIsSet = sqlite3_user_data(ctx)!=0; + + if( argc<1 ) return; + if( (argc&1)==0 ) { + jsonWrongNumArgs(ctx, bIsSet ? "set" : "insert"); + return; + } + if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return; + assert( x.nNode ); + for(i=1; i<(u32)argc; i+=2){ + zPath = (const char*)sqlite3_value_text(argv[i]); + bApnd = 0; + pNode = jsonLookup(&x, zPath, &bApnd, ctx); + if( x.oom ){ + sqlite3_result_error_nomem(ctx); + goto jsonSetDone; + }else if( x.nErr ){ + goto jsonSetDone; + }else if( pNode && (bApnd || bIsSet) ){ + testcase( pNode->eU!=0 && pNode->eU!=1 ); + assert( pNode->eU!=3 && pNode->eU!=5 ); + VVA( pNode->eU = 4 ); + pNode->jnFlags |= (u8)JNODE_REPLACE; + pNode->u.iReplace = i + 1; + } + } + if( x.aNode[0].jnFlags & JNODE_REPLACE ){ + assert( x.aNode[0].eU==4 ); + sqlite3_result_value(ctx, argv[x.aNode[0].u.iReplace]); + }else{ + jsonReturnJson(x.aNode, ctx, argv); + } +jsonSetDone: + jsonParseReset(&x); +} + +/* +** json_type(JSON) +** json_type(JSON, PATH) +** +** Return the top-level "type" of a JSON string. json_type() raises an +** error if either the JSON or PATH inputs are not well-formed. +*/ +static void jsonTypeFunc( + sqlite3_context *ctx, + int argc, + sqlite3_value **argv +){ + JsonParse *p; /* The parse */ + const char *zPath; + JsonNode *pNode; + + p = jsonParseCached(ctx, argv, ctx); + if( p==0 ) return; + if( argc==2 ){ + zPath = (const char*)sqlite3_value_text(argv[1]); + pNode = jsonLookup(p, zPath, 0, ctx); + }else{ + pNode = p->aNode; + } + if( pNode ){ + sqlite3_result_text(ctx, jsonType[pNode->eType], -1, SQLITE_STATIC); + } +} + +/* +** json_valid(JSON) +** +** Return 1 if JSON is a well-formed canonical JSON string according +** to RFC-7159. Return 0 otherwise. +*/ +static void jsonValidFunc( + sqlite3_context *ctx, + int argc, + sqlite3_value **argv +){ + JsonParse *p; /* The parse */ + UNUSED_PARAMETER(argc); + if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; + p = jsonParseCached(ctx, argv, 0); + if( p==0 || p->oom ){ + sqlite3_result_error_nomem(ctx); + sqlite3_free(p); + }else{ + sqlite3_result_int(ctx, p->nErr==0 && p->hasNonstd==0); + if( p->nErr ) jsonParseFree(p); + } +} + +/* +** json_error_position(JSON) +** +** If the argument is not an interpretable JSON string, then return the 1-based +** character position at which the parser first recognized that the input +** was in error. The left-most character is 1. If the string is valid +** JSON, then return 0. +** +** Note that json_valid() is only true for strictly conforming canonical JSON. +** But this routine returns zero if the input contains extension. Thus: +** +** (1) If the input X is strictly conforming canonical JSON: +** +** json_valid(X) returns true +** json_error_position(X) returns 0 +** +** (2) If the input X is JSON but it includes extension (such as JSON5) that +** are not part of RFC-8259: +** +** json_valid(X) returns false +** json_error_position(X) return 0 +** +** (3) If the input X cannot be interpreted as JSON even taking extensions +** into account: +** +** json_valid(X) return false +** json_error_position(X) returns 1 or more +*/ +static void jsonErrorFunc( + sqlite3_context *ctx, + int argc, + sqlite3_value **argv +){ + JsonParse *p; /* The parse */ + UNUSED_PARAMETER(argc); + if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; + p = jsonParseCached(ctx, argv, 0); + if( p==0 || p->oom ){ + sqlite3_result_error_nomem(ctx); + sqlite3_free(p); + }else if( p->nErr==0 ){ + sqlite3_result_int(ctx, 0); + }else{ + int n = 1; + u32 i; + const char *z = p->zJson; + for(i=0; iiErr && ALWAYS(z[i]); i++){ + if( (z[i]&0xc0)!=0x80 ) n++; + } + sqlite3_result_int(ctx, n); + jsonParseFree(p); + } +} + + +/**************************************************************************** +** Aggregate SQL function implementations +****************************************************************************/ +/* +** json_group_array(VALUE) +** +** Return a JSON array composed of all values in the aggregate. +*/ +static void jsonArrayStep( + sqlite3_context *ctx, + int argc, + sqlite3_value **argv +){ + JsonString *pStr; + UNUSED_PARAMETER(argc); + pStr = (JsonString*)sqlite3_aggregate_context(ctx, sizeof(*pStr)); + if( pStr ){ + if( pStr->zBuf==0 ){ + jsonInit(pStr, ctx); + jsonAppendChar(pStr, '['); + }else if( pStr->nUsed>1 ){ + jsonAppendChar(pStr, ','); + } + pStr->pCtx = ctx; + jsonAppendValue(pStr, argv[0]); + } +} +static void jsonArrayCompute(sqlite3_context *ctx, int isFinal){ + JsonString *pStr; + pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0); + if( pStr ){ + pStr->pCtx = ctx; + jsonAppendChar(pStr, ']'); + if( pStr->bErr ){ + if( pStr->bErr==1 ) sqlite3_result_error_nomem(ctx); + assert( pStr->bStatic ); + }else if( isFinal ){ + sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed, + pStr->bStatic ? SQLITE_TRANSIENT : sqlite3_free); + pStr->bStatic = 1; + }else{ + sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed, SQLITE_TRANSIENT); + pStr->nUsed--; + } + }else{ + sqlite3_result_text(ctx, "[]", 2, SQLITE_STATIC); + } + sqlite3_result_subtype(ctx, JSON_SUBTYPE); +} +static void jsonArrayValue(sqlite3_context *ctx){ + jsonArrayCompute(ctx, 0); +} +static void jsonArrayFinal(sqlite3_context *ctx){ + jsonArrayCompute(ctx, 1); +} + +#ifndef SQLITE_OMIT_WINDOWFUNC +/* +** This method works for both json_group_array() and json_group_object(). +** It works by removing the first element of the group by searching forward +** to the first comma (",") that is not within a string and deleting all +** text through that comma. +*/ +static void jsonGroupInverse( + sqlite3_context *ctx, + int argc, + sqlite3_value **argv +){ + unsigned int i; + int inStr = 0; + int nNest = 0; + char *z; + char c; + JsonString *pStr; + UNUSED_PARAMETER(argc); + UNUSED_PARAMETER(argv); + pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0); +#ifdef NEVER + /* pStr is always non-NULL since jsonArrayStep() or jsonObjectStep() will + ** always have been called to initalize it */ + if( NEVER(!pStr) ) return; +#endif + z = pStr->zBuf; + for(i=1; inUsed && ((c = z[i])!=',' || inStr || nNest); i++){ + if( c=='"' ){ + inStr = !inStr; + }else if( c=='\\' ){ + i++; + }else if( !inStr ){ + if( c=='{' || c=='[' ) nNest++; + if( c=='}' || c==']' ) nNest--; + } + } + if( inUsed ){ + pStr->nUsed -= i; + memmove(&z[1], &z[i+1], (size_t)pStr->nUsed-1); + z[pStr->nUsed] = 0; + }else{ + pStr->nUsed = 1; + } +} +#else +# define jsonGroupInverse 0 +#endif + + +/* +** json_group_obj(NAME,VALUE) +** +** Return a JSON object composed of all names and values in the aggregate. +*/ +static void jsonObjectStep( + sqlite3_context *ctx, + int argc, + sqlite3_value **argv +){ + JsonString *pStr; + const char *z; + u32 n; + UNUSED_PARAMETER(argc); + pStr = (JsonString*)sqlite3_aggregate_context(ctx, sizeof(*pStr)); + if( pStr ){ + if( pStr->zBuf==0 ){ + jsonInit(pStr, ctx); + jsonAppendChar(pStr, '{'); + }else if( pStr->nUsed>1 ){ + jsonAppendChar(pStr, ','); + } + pStr->pCtx = ctx; + z = (const char*)sqlite3_value_text(argv[0]); + n = (u32)sqlite3_value_bytes(argv[0]); + jsonAppendString(pStr, z, n); + jsonAppendChar(pStr, ':'); + jsonAppendValue(pStr, argv[1]); + } +} +static void jsonObjectCompute(sqlite3_context *ctx, int isFinal){ + JsonString *pStr; + pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0); + if( pStr ){ + jsonAppendChar(pStr, '}'); + if( pStr->bErr ){ + if( pStr->bErr==1 ) sqlite3_result_error_nomem(ctx); + assert( pStr->bStatic ); + }else if( isFinal ){ + sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed, + pStr->bStatic ? SQLITE_TRANSIENT : sqlite3_free); + pStr->bStatic = 1; + }else{ + sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed, SQLITE_TRANSIENT); + pStr->nUsed--; + } + }else{ + sqlite3_result_text(ctx, "{}", 2, SQLITE_STATIC); + } + sqlite3_result_subtype(ctx, JSON_SUBTYPE); +} +static void jsonObjectValue(sqlite3_context *ctx){ + jsonObjectCompute(ctx, 0); +} +static void jsonObjectFinal(sqlite3_context *ctx){ + jsonObjectCompute(ctx, 1); +} + + + +#ifndef SQLITE_OMIT_VIRTUALTABLE +/**************************************************************************** +** The json_each virtual table +****************************************************************************/ +typedef struct JsonEachCursor JsonEachCursor; +struct JsonEachCursor { + sqlite3_vtab_cursor base; /* Base class - must be first */ + u32 iRowid; /* The rowid */ + u32 iBegin; /* The first node of the scan */ + u32 i; /* Index in sParse.aNode[] of current row */ + u32 iEnd; /* EOF when i equals or exceeds this value */ + u8 eType; /* Type of top-level element */ + u8 bRecursive; /* True for json_tree(). False for json_each() */ + char *zJson; /* Input JSON */ + char *zRoot; /* Path by which to filter zJson */ + JsonParse sParse; /* Parse of the input JSON */ +}; + +/* Constructor for the json_each virtual table */ +static int jsonEachConnect( + sqlite3 *db, + void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVtab, + char **pzErr +){ + sqlite3_vtab *pNew; + int rc; + +/* Column numbers */ +#define JEACH_KEY 0 +#define JEACH_VALUE 1 +#define JEACH_TYPE 2 +#define JEACH_ATOM 3 +#define JEACH_ID 4 +#define JEACH_PARENT 5 +#define JEACH_FULLKEY 6 +#define JEACH_PATH 7 +/* The xBestIndex method assumes that the JSON and ROOT columns are +** the last two columns in the table. Should this ever changes, be +** sure to update the xBestIndex method. */ +#define JEACH_JSON 8 +#define JEACH_ROOT 9 + + UNUSED_PARAMETER(pzErr); + UNUSED_PARAMETER(argv); + UNUSED_PARAMETER(argc); + UNUSED_PARAMETER(pAux); + rc = sqlite3_declare_vtab(db, + "CREATE TABLE x(key,value,type,atom,id,parent,fullkey,path," + "json HIDDEN,root HIDDEN)"); + if( rc==SQLITE_OK ){ + pNew = *ppVtab = sqlite3_malloc( sizeof(*pNew) ); + if( pNew==0 ) return SQLITE_NOMEM; + memset(pNew, 0, sizeof(*pNew)); + sqlite3_vtab_config(db, SQLITE_VTAB_INNOCUOUS); + } + return rc; +} + +/* destructor for json_each virtual table */ +static int jsonEachDisconnect(sqlite3_vtab *pVtab){ + sqlite3_free(pVtab); + return SQLITE_OK; +} + +/* constructor for a JsonEachCursor object for json_each(). */ +static int jsonEachOpenEach(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){ + JsonEachCursor *pCur; + + UNUSED_PARAMETER(p); + pCur = sqlite3_malloc( sizeof(*pCur) ); + if( pCur==0 ) return SQLITE_NOMEM; + memset(pCur, 0, sizeof(*pCur)); + *ppCursor = &pCur->base; + return SQLITE_OK; +} + +/* constructor for a JsonEachCursor object for json_tree(). */ +static int jsonEachOpenTree(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){ + int rc = jsonEachOpenEach(p, ppCursor); + if( rc==SQLITE_OK ){ + JsonEachCursor *pCur = (JsonEachCursor*)*ppCursor; + pCur->bRecursive = 1; + } + return rc; +} + +/* Reset a JsonEachCursor back to its original state. Free any memory +** held. */ +static void jsonEachCursorReset(JsonEachCursor *p){ + sqlite3_free(p->zJson); + sqlite3_free(p->zRoot); + jsonParseReset(&p->sParse); + p->iRowid = 0; + p->i = 0; + p->iEnd = 0; + p->eType = 0; + p->zJson = 0; + p->zRoot = 0; +} + +/* Destructor for a jsonEachCursor object */ +static int jsonEachClose(sqlite3_vtab_cursor *cur){ + JsonEachCursor *p = (JsonEachCursor*)cur; + jsonEachCursorReset(p); + sqlite3_free(cur); + return SQLITE_OK; +} + +/* Return TRUE if the jsonEachCursor object has been advanced off the end +** of the JSON object */ +static int jsonEachEof(sqlite3_vtab_cursor *cur){ + JsonEachCursor *p = (JsonEachCursor*)cur; + return p->i >= p->iEnd; +} + +/* Advance the cursor to the next element for json_tree() */ +static int jsonEachNext(sqlite3_vtab_cursor *cur){ + JsonEachCursor *p = (JsonEachCursor*)cur; + if( p->bRecursive ){ + if( p->sParse.aNode[p->i].jnFlags & JNODE_LABEL ) p->i++; + p->i++; + p->iRowid++; + if( p->iiEnd ){ + u32 iUp = p->sParse.aUp[p->i]; + JsonNode *pUp = &p->sParse.aNode[iUp]; + p->eType = pUp->eType; + if( pUp->eType==JSON_ARRAY ){ + assert( pUp->eU==0 || pUp->eU==3 ); + testcase( pUp->eU==3 ); + VVA( pUp->eU = 3 ); + if( iUp==p->i-1 ){ + pUp->u.iKey = 0; + }else{ + pUp->u.iKey++; + } + } + } + }else{ + switch( p->eType ){ + case JSON_ARRAY: { + p->i += jsonNodeSize(&p->sParse.aNode[p->i]); + p->iRowid++; + break; + } + case JSON_OBJECT: { + p->i += 1 + jsonNodeSize(&p->sParse.aNode[p->i+1]); + p->iRowid++; + break; + } + default: { + p->i = p->iEnd; + break; + } + } + } + return SQLITE_OK; +} + +/* Append an object label to the JSON Path being constructed +** in pStr. +*/ +static void jsonAppendObjectPathElement( + JsonString *pStr, + JsonNode *pNode +){ + int jj, nn; + const char *z; + assert( pNode->eType==JSON_STRING ); + assert( pNode->jnFlags & JNODE_LABEL ); + assert( pNode->eU==1 ); + z = pNode->u.zJContent; + nn = pNode->n; + if( (pNode->jnFlags & JNODE_RAW)==0 ){ + assert( nn>=2 ); + assert( z[0]=='"' || z[0]=='\'' ); + assert( z[nn-1]=='"' || z[0]=='\'' ); + if( nn>2 && sqlite3Isalpha(z[1]) ){ + for(jj=2; jjsParse.aUp[i]; + jsonEachComputePath(p, pStr, iUp); + pNode = &p->sParse.aNode[i]; + pUp = &p->sParse.aNode[iUp]; + if( pUp->eType==JSON_ARRAY ){ + assert( pUp->eU==3 || (pUp->eU==0 && pUp->u.iKey==0) ); + testcase( pUp->eU==0 ); + jsonPrintf(30, pStr, "[%d]", pUp->u.iKey); + }else{ + assert( pUp->eType==JSON_OBJECT ); + if( (pNode->jnFlags & JNODE_LABEL)==0 ) pNode--; + jsonAppendObjectPathElement(pStr, pNode); + } +} + +/* Return the value of a column */ +static int jsonEachColumn( + sqlite3_vtab_cursor *cur, /* The cursor */ + sqlite3_context *ctx, /* First argument to sqlite3_result_...() */ + int i /* Which column to return */ +){ + JsonEachCursor *p = (JsonEachCursor*)cur; + JsonNode *pThis = &p->sParse.aNode[p->i]; + switch( i ){ + case JEACH_KEY: { + if( p->i==0 ) break; + if( p->eType==JSON_OBJECT ){ + jsonReturn(pThis, ctx, 0); + }else if( p->eType==JSON_ARRAY ){ + u32 iKey; + if( p->bRecursive ){ + if( p->iRowid==0 ) break; + assert( p->sParse.aNode[p->sParse.aUp[p->i]].eU==3 ); + iKey = p->sParse.aNode[p->sParse.aUp[p->i]].u.iKey; + }else{ + iKey = p->iRowid; + } + sqlite3_result_int64(ctx, (sqlite3_int64)iKey); + } + break; + } + case JEACH_VALUE: { + if( pThis->jnFlags & JNODE_LABEL ) pThis++; + jsonReturn(pThis, ctx, 0); + break; + } + case JEACH_TYPE: { + if( pThis->jnFlags & JNODE_LABEL ) pThis++; + sqlite3_result_text(ctx, jsonType[pThis->eType], -1, SQLITE_STATIC); + break; + } + case JEACH_ATOM: { + if( pThis->jnFlags & JNODE_LABEL ) pThis++; + if( pThis->eType>=JSON_ARRAY ) break; + jsonReturn(pThis, ctx, 0); + break; + } + case JEACH_ID: { + sqlite3_result_int64(ctx, + (sqlite3_int64)p->i + ((pThis->jnFlags & JNODE_LABEL)!=0)); + break; + } + case JEACH_PARENT: { + if( p->i>p->iBegin && p->bRecursive ){ + sqlite3_result_int64(ctx, (sqlite3_int64)p->sParse.aUp[p->i]); + } + break; + } + case JEACH_FULLKEY: { + JsonString x; + jsonInit(&x, ctx); + if( p->bRecursive ){ + jsonEachComputePath(p, &x, p->i); + }else{ + if( p->zRoot ){ + jsonAppendRaw(&x, p->zRoot, (int)strlen(p->zRoot)); + }else{ + jsonAppendChar(&x, '$'); + } + if( p->eType==JSON_ARRAY ){ + jsonPrintf(30, &x, "[%d]", p->iRowid); + }else if( p->eType==JSON_OBJECT ){ + jsonAppendObjectPathElement(&x, pThis); + } + } + jsonResult(&x); + break; + } + case JEACH_PATH: { + if( p->bRecursive ){ + JsonString x; + jsonInit(&x, ctx); + jsonEachComputePath(p, &x, p->sParse.aUp[p->i]); + jsonResult(&x); + break; + } + /* For json_each() path and root are the same so fall through + ** into the root case */ + /* no break */ deliberate_fall_through + } + default: { + const char *zRoot = p->zRoot; + if( zRoot==0 ) zRoot = "$"; + sqlite3_result_text(ctx, zRoot, -1, SQLITE_STATIC); + break; + } + case JEACH_JSON: { + assert( i==JEACH_JSON ); + sqlite3_result_text(ctx, p->sParse.zJson, -1, SQLITE_STATIC); + break; + } + } + return SQLITE_OK; +} + +/* Return the current rowid value */ +static int jsonEachRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){ + JsonEachCursor *p = (JsonEachCursor*)cur; + *pRowid = p->iRowid; + return SQLITE_OK; +} + +/* The query strategy is to look for an equality constraint on the json +** column. Without such a constraint, the table cannot operate. idxNum is +** 1 if the constraint is found, 3 if the constraint and zRoot are found, +** and 0 otherwise. +*/ +static int jsonEachBestIndex( + sqlite3_vtab *tab, + sqlite3_index_info *pIdxInfo +){ + int i; /* Loop counter or computed array index */ + int aIdx[2]; /* Index of constraints for JSON and ROOT */ + int unusableMask = 0; /* Mask of unusable JSON and ROOT constraints */ + int idxMask = 0; /* Mask of usable == constraints JSON and ROOT */ + const struct sqlite3_index_constraint *pConstraint; + + /* This implementation assumes that JSON and ROOT are the last two + ** columns in the table */ + assert( JEACH_ROOT == JEACH_JSON+1 ); + UNUSED_PARAMETER(tab); + aIdx[0] = aIdx[1] = -1; + pConstraint = pIdxInfo->aConstraint; + for(i=0; inConstraint; i++, pConstraint++){ + int iCol; + int iMask; + if( pConstraint->iColumn < JEACH_JSON ) continue; + iCol = pConstraint->iColumn - JEACH_JSON; + assert( iCol==0 || iCol==1 ); + testcase( iCol==0 ); + iMask = 1 << iCol; + if( pConstraint->usable==0 ){ + unusableMask |= iMask; + }else if( pConstraint->op==SQLITE_INDEX_CONSTRAINT_EQ ){ + aIdx[iCol] = i; + idxMask |= iMask; + } + } + if( pIdxInfo->nOrderBy>0 + && pIdxInfo->aOrderBy[0].iColumn<0 + && pIdxInfo->aOrderBy[0].desc==0 + ){ + pIdxInfo->orderByConsumed = 1; + } + + if( (unusableMask & ~idxMask)!=0 ){ + /* If there are any unusable constraints on JSON or ROOT, then reject + ** this entire plan */ + return SQLITE_CONSTRAINT; + } + if( aIdx[0]<0 ){ + /* No JSON input. Leave estimatedCost at the huge value that it was + ** initialized to to discourage the query planner from selecting this + ** plan. */ + pIdxInfo->idxNum = 0; + }else{ + pIdxInfo->estimatedCost = 1.0; + i = aIdx[0]; + pIdxInfo->aConstraintUsage[i].argvIndex = 1; + pIdxInfo->aConstraintUsage[i].omit = 1; + if( aIdx[1]<0 ){ + pIdxInfo->idxNum = 1; /* Only JSON supplied. Plan 1 */ + }else{ + i = aIdx[1]; + pIdxInfo->aConstraintUsage[i].argvIndex = 2; + pIdxInfo->aConstraintUsage[i].omit = 1; + pIdxInfo->idxNum = 3; /* Both JSON and ROOT are supplied. Plan 3 */ + } + } + return SQLITE_OK; +} + +/* Start a search on a new JSON string */ +static int jsonEachFilter( + sqlite3_vtab_cursor *cur, + int idxNum, const char *idxStr, + int argc, sqlite3_value **argv +){ + JsonEachCursor *p = (JsonEachCursor*)cur; + const char *z; + const char *zRoot = 0; + sqlite3_int64 n; + + UNUSED_PARAMETER(idxStr); + UNUSED_PARAMETER(argc); + jsonEachCursorReset(p); + if( idxNum==0 ) return SQLITE_OK; + z = (const char*)sqlite3_value_text(argv[0]); + if( z==0 ) return SQLITE_OK; + n = sqlite3_value_bytes(argv[0]); + p->zJson = sqlite3_malloc64( n+1 ); + if( p->zJson==0 ) return SQLITE_NOMEM; + memcpy(p->zJson, z, (size_t)n+1); + if( jsonParse(&p->sParse, 0, p->zJson) ){ + int rc = SQLITE_NOMEM; + if( p->sParse.oom==0 ){ + sqlite3_free(cur->pVtab->zErrMsg); + cur->pVtab->zErrMsg = sqlite3_mprintf("malformed JSON"); + if( cur->pVtab->zErrMsg ) rc = SQLITE_ERROR; + } + jsonEachCursorReset(p); + return rc; + }else if( p->bRecursive && jsonParseFindParents(&p->sParse) ){ + jsonEachCursorReset(p); + return SQLITE_NOMEM; + }else{ + JsonNode *pNode = 0; + if( idxNum==3 ){ + const char *zErr = 0; + zRoot = (const char*)sqlite3_value_text(argv[1]); + if( zRoot==0 ) return SQLITE_OK; + n = sqlite3_value_bytes(argv[1]); + p->zRoot = sqlite3_malloc64( n+1 ); + if( p->zRoot==0 ) return SQLITE_NOMEM; + memcpy(p->zRoot, zRoot, (size_t)n+1); + if( zRoot[0]!='$' ){ + zErr = zRoot; + }else{ + pNode = jsonLookupStep(&p->sParse, 0, p->zRoot+1, 0, &zErr); + } + if( zErr ){ + sqlite3_free(cur->pVtab->zErrMsg); + cur->pVtab->zErrMsg = jsonPathSyntaxError(zErr); + jsonEachCursorReset(p); + return cur->pVtab->zErrMsg ? SQLITE_ERROR : SQLITE_NOMEM; + }else if( pNode==0 ){ + return SQLITE_OK; + } + }else{ + pNode = p->sParse.aNode; + } + p->iBegin = p->i = (int)(pNode - p->sParse.aNode); + p->eType = pNode->eType; + if( p->eType>=JSON_ARRAY ){ + assert( pNode->eU==0 ); + VVA( pNode->eU = 3 ); + pNode->u.iKey = 0; + p->iEnd = p->i + pNode->n + 1; + if( p->bRecursive ){ + p->eType = p->sParse.aNode[p->sParse.aUp[p->i]].eType; + if( p->i>0 && (p->sParse.aNode[p->i-1].jnFlags & JNODE_LABEL)!=0 ){ + p->i--; + } + }else{ + p->i++; + } + }else{ + p->iEnd = p->i+1; + } + } + return SQLITE_OK; +} + +/* The methods of the json_each virtual table */ +static sqlite3_module jsonEachModule = { + 0, /* iVersion */ + 0, /* xCreate */ + jsonEachConnect, /* xConnect */ + jsonEachBestIndex, /* xBestIndex */ + jsonEachDisconnect, /* xDisconnect */ + 0, /* xDestroy */ + jsonEachOpenEach, /* xOpen - open a cursor */ + jsonEachClose, /* xClose - close a cursor */ + jsonEachFilter, /* xFilter - configure scan constraints */ + jsonEachNext, /* xNext - advance a cursor */ + jsonEachEof, /* xEof - check for end of scan */ + jsonEachColumn, /* xColumn - read data */ + jsonEachRowid, /* xRowid - read data */ + 0, /* xUpdate */ + 0, /* xBegin */ + 0, /* xSync */ + 0, /* xCommit */ + 0, /* xRollback */ + 0, /* xFindMethod */ + 0, /* xRename */ + 0, /* xSavepoint */ + 0, /* xRelease */ + 0, /* xRollbackTo */ + 0 /* xShadowName */ +}; + +/* The methods of the json_tree virtual table. */ +static sqlite3_module jsonTreeModule = { + 0, /* iVersion */ + 0, /* xCreate */ + jsonEachConnect, /* xConnect */ + jsonEachBestIndex, /* xBestIndex */ + jsonEachDisconnect, /* xDisconnect */ + 0, /* xDestroy */ + jsonEachOpenTree, /* xOpen - open a cursor */ + jsonEachClose, /* xClose - close a cursor */ + jsonEachFilter, /* xFilter - configure scan constraints */ + jsonEachNext, /* xNext - advance a cursor */ + jsonEachEof, /* xEof - check for end of scan */ + jsonEachColumn, /* xColumn - read data */ + jsonEachRowid, /* xRowid - read data */ + 0, /* xUpdate */ + 0, /* xBegin */ + 0, /* xSync */ + 0, /* xCommit */ + 0, /* xRollback */ + 0, /* xFindMethod */ + 0, /* xRename */ + 0, /* xSavepoint */ + 0, /* xRelease */ + 0, /* xRollbackTo */ + 0 /* xShadowName */ +}; +#endif /* SQLITE_OMIT_VIRTUALTABLE */ +#endif /* !defined(SQLITE_OMIT_JSON) */ + +/* +** Register JSON functions. +*/ +SQLITE_PRIVATE void sqlite3RegisterJsonFunctions(void){ +#ifndef SQLITE_OMIT_JSON + static FuncDef aJsonFunc[] = { + JFUNCTION(json, 1, 0, jsonRemoveFunc), + JFUNCTION(json_array, -1, 0, jsonArrayFunc), + JFUNCTION(json_array_length, 1, 0, jsonArrayLengthFunc), + JFUNCTION(json_array_length, 2, 0, jsonArrayLengthFunc), + JFUNCTION(json_error_position,1, 0, jsonErrorFunc), + JFUNCTION(json_extract, -1, 0, jsonExtractFunc), + JFUNCTION(->, 2, JSON_JSON, jsonExtractFunc), + JFUNCTION(->>, 2, JSON_SQL, jsonExtractFunc), + JFUNCTION(json_insert, -1, 0, jsonSetFunc), + JFUNCTION(json_object, -1, 0, jsonObjectFunc), + JFUNCTION(json_patch, 2, 0, jsonPatchFunc), + JFUNCTION(json_quote, 1, 0, jsonQuoteFunc), + JFUNCTION(json_remove, -1, 0, jsonRemoveFunc), + JFUNCTION(json_replace, -1, 0, jsonReplaceFunc), + JFUNCTION(json_set, -1, JSON_ISSET, jsonSetFunc), + JFUNCTION(json_type, 1, 0, jsonTypeFunc), + JFUNCTION(json_type, 2, 0, jsonTypeFunc), + JFUNCTION(json_valid, 1, 0, jsonValidFunc), +#if SQLITE_DEBUG + JFUNCTION(json_parse, 1, 0, jsonParseFunc), + JFUNCTION(json_test1, 1, 0, jsonTest1Func), +#endif + WAGGREGATE(json_group_array, 1, 0, 0, + jsonArrayStep, jsonArrayFinal, jsonArrayValue, jsonGroupInverse, + SQLITE_SUBTYPE|SQLITE_UTF8|SQLITE_DETERMINISTIC), + WAGGREGATE(json_group_object, 2, 0, 0, + jsonObjectStep, jsonObjectFinal, jsonObjectValue, jsonGroupInverse, + SQLITE_SUBTYPE|SQLITE_UTF8|SQLITE_DETERMINISTIC) + }; + sqlite3InsertBuiltinFuncs(aJsonFunc, ArraySize(aJsonFunc)); +#endif +} + +#if !defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_JSON) +/* +** Register the JSON table-valued functions +*/ +SQLITE_PRIVATE int sqlite3JsonTableFunctions(sqlite3 *db){ + int rc = SQLITE_OK; + static const struct { + const char *zName; + sqlite3_module *pModule; + } aMod[] = { + { "json_each", &jsonEachModule }, + { "json_tree", &jsonTreeModule }, + }; + unsigned int i; + for(i=0; i */ +/* #include */ +/* #include */ +/* #include */ + +/* The following macro is used to suppress compiler warnings. +*/ +#ifndef UNUSED_PARAMETER +# define UNUSED_PARAMETER(x) (void)(x) +#endif + +typedef struct Rtree Rtree; +typedef struct RtreeCursor RtreeCursor; +typedef struct RtreeNode RtreeNode; +typedef struct RtreeCell RtreeCell; +typedef struct RtreeConstraint RtreeConstraint; +typedef struct RtreeMatchArg RtreeMatchArg; +typedef struct RtreeGeomCallback RtreeGeomCallback; +typedef union RtreeCoord RtreeCoord; +typedef struct RtreeSearchPoint RtreeSearchPoint; + +/* The rtree may have between 1 and RTREE_MAX_DIMENSIONS dimensions. */ +#define RTREE_MAX_DIMENSIONS 5 + +/* Maximum number of auxiliary columns */ +#define RTREE_MAX_AUX_COLUMN 100 + +/* Size of hash table Rtree.aHash. This hash table is not expected to +** ever contain very many entries, so a fixed number of buckets is +** used. +*/ +#define HASHSIZE 97 + +/* The xBestIndex method of this virtual table requires an estimate of +** the number of rows in the virtual table to calculate the costs of +** various strategies. If possible, this estimate is loaded from the +** sqlite_stat1 table (with RTREE_MIN_ROWEST as a hard-coded minimum). +** Otherwise, if no sqlite_stat1 entry is available, use +** RTREE_DEFAULT_ROWEST. +*/ +#define RTREE_DEFAULT_ROWEST 1048576 +#define RTREE_MIN_ROWEST 100 + +/* +** An rtree virtual-table object. +*/ +struct Rtree { + sqlite3_vtab base; /* Base class. Must be first */ + sqlite3 *db; /* Host database connection */ + int iNodeSize; /* Size in bytes of each node in the node table */ + u8 nDim; /* Number of dimensions */ + u8 nDim2; /* Twice the number of dimensions */ + u8 eCoordType; /* RTREE_COORD_REAL32 or RTREE_COORD_INT32 */ + u8 nBytesPerCell; /* Bytes consumed per cell */ + u8 inWrTrans; /* True if inside write transaction */ + u8 nAux; /* # of auxiliary columns in %_rowid */ +#ifdef SQLITE_ENABLE_GEOPOLY + u8 nAuxNotNull; /* Number of initial not-null aux columns */ +#endif +#ifdef SQLITE_DEBUG + u8 bCorrupt; /* Shadow table corruption detected */ +#endif + int iDepth; /* Current depth of the r-tree structure */ + char *zDb; /* Name of database containing r-tree table */ + char *zName; /* Name of r-tree table */ + u32 nBusy; /* Current number of users of this structure */ + i64 nRowEst; /* Estimated number of rows in this table */ + u32 nCursor; /* Number of open cursors */ + u32 nNodeRef; /* Number RtreeNodes with positive nRef */ + char *zReadAuxSql; /* SQL for statement to read aux data */ + + /* List of nodes removed during a CondenseTree operation. List is + ** linked together via the pointer normally used for hash chains - + ** RtreeNode.pNext. RtreeNode.iNode stores the depth of the sub-tree + ** headed by the node (leaf nodes have RtreeNode.iNode==0). + */ + RtreeNode *pDeleted; + int iReinsertHeight; /* Height of sub-trees Reinsert() has run on */ + + /* Blob I/O on xxx_node */ + sqlite3_blob *pNodeBlob; + + /* Statements to read/write/delete a record from xxx_node */ + sqlite3_stmt *pWriteNode; + sqlite3_stmt *pDeleteNode; + + /* Statements to read/write/delete a record from xxx_rowid */ + sqlite3_stmt *pReadRowid; + sqlite3_stmt *pWriteRowid; + sqlite3_stmt *pDeleteRowid; + + /* Statements to read/write/delete a record from xxx_parent */ + sqlite3_stmt *pReadParent; + sqlite3_stmt *pWriteParent; + sqlite3_stmt *pDeleteParent; + + /* Statement for writing to the "aux:" fields, if there are any */ + sqlite3_stmt *pWriteAux; + + RtreeNode *aHash[HASHSIZE]; /* Hash table of in-memory nodes. */ +}; + +/* Possible values for Rtree.eCoordType: */ +#define RTREE_COORD_REAL32 0 +#define RTREE_COORD_INT32 1 + +/* +** If SQLITE_RTREE_INT_ONLY is defined, then this virtual table will +** only deal with integer coordinates. No floating point operations +** will be done. +*/ +#ifdef SQLITE_RTREE_INT_ONLY + typedef sqlite3_int64 RtreeDValue; /* High accuracy coordinate */ + typedef int RtreeValue; /* Low accuracy coordinate */ +# define RTREE_ZERO 0 +#else + typedef double RtreeDValue; /* High accuracy coordinate */ + typedef float RtreeValue; /* Low accuracy coordinate */ +# define RTREE_ZERO 0.0 +#endif + +/* +** Set the Rtree.bCorrupt flag +*/ +#ifdef SQLITE_DEBUG +# define RTREE_IS_CORRUPT(X) ((X)->bCorrupt = 1) +#else +# define RTREE_IS_CORRUPT(X) +#endif + +/* +** When doing a search of an r-tree, instances of the following structure +** record intermediate results from the tree walk. +** +** The id is always a node-id. For iLevel>=1 the id is the node-id of +** the node that the RtreeSearchPoint represents. When iLevel==0, however, +** the id is of the parent node and the cell that RtreeSearchPoint +** represents is the iCell-th entry in the parent node. +*/ +struct RtreeSearchPoint { + RtreeDValue rScore; /* The score for this node. Smallest goes first. */ + sqlite3_int64 id; /* Node ID */ + u8 iLevel; /* 0=entries. 1=leaf node. 2+ for higher */ + u8 eWithin; /* PARTLY_WITHIN or FULLY_WITHIN */ + u8 iCell; /* Cell index within the node */ +}; + +/* +** The minimum number of cells allowed for a node is a third of the +** maximum. In Gutman's notation: +** +** m = M/3 +** +** If an R*-tree "Reinsert" operation is required, the same number of +** cells are removed from the overfull node and reinserted into the tree. +*/ +#define RTREE_MINCELLS(p) ((((p)->iNodeSize-4)/(p)->nBytesPerCell)/3) +#define RTREE_REINSERT(p) RTREE_MINCELLS(p) +#define RTREE_MAXCELLS 51 + +/* +** The smallest possible node-size is (512-64)==448 bytes. And the largest +** supported cell size is 48 bytes (8 byte rowid + ten 4 byte coordinates). +** Therefore all non-root nodes must contain at least 3 entries. Since +** 3^40 is greater than 2^64, an r-tree structure always has a depth of +** 40 or less. +*/ +#define RTREE_MAX_DEPTH 40 + + +/* +** Number of entries in the cursor RtreeNode cache. The first entry is +** used to cache the RtreeNode for RtreeCursor.sPoint. The remaining +** entries cache the RtreeNode for the first elements of the priority queue. +*/ +#define RTREE_CACHE_SZ 5 + +/* +** An rtree cursor object. +*/ +struct RtreeCursor { + sqlite3_vtab_cursor base; /* Base class. Must be first */ + u8 atEOF; /* True if at end of search */ + u8 bPoint; /* True if sPoint is valid */ + u8 bAuxValid; /* True if pReadAux is valid */ + int iStrategy; /* Copy of idxNum search parameter */ + int nConstraint; /* Number of entries in aConstraint */ + RtreeConstraint *aConstraint; /* Search constraints. */ + int nPointAlloc; /* Number of slots allocated for aPoint[] */ + int nPoint; /* Number of slots used in aPoint[] */ + int mxLevel; /* iLevel value for root of the tree */ + RtreeSearchPoint *aPoint; /* Priority queue for search points */ + sqlite3_stmt *pReadAux; /* Statement to read aux-data */ + RtreeSearchPoint sPoint; /* Cached next search point */ + RtreeNode *aNode[RTREE_CACHE_SZ]; /* Rtree node cache */ + u32 anQueue[RTREE_MAX_DEPTH+1]; /* Number of queued entries by iLevel */ +}; + +/* Return the Rtree of a RtreeCursor */ +#define RTREE_OF_CURSOR(X) ((Rtree*)((X)->base.pVtab)) + +/* +** A coordinate can be either a floating point number or a integer. All +** coordinates within a single R-Tree are always of the same time. +*/ +union RtreeCoord { + RtreeValue f; /* Floating point value */ + int i; /* Integer value */ + u32 u; /* Unsigned for byte-order conversions */ +}; + +/* +** The argument is an RtreeCoord. Return the value stored within the RtreeCoord +** formatted as a RtreeDValue (double or int64). This macro assumes that local +** variable pRtree points to the Rtree structure associated with the +** RtreeCoord. +*/ +#ifdef SQLITE_RTREE_INT_ONLY +# define DCOORD(coord) ((RtreeDValue)coord.i) +#else +# define DCOORD(coord) ( \ + (pRtree->eCoordType==RTREE_COORD_REAL32) ? \ + ((double)coord.f) : \ + ((double)coord.i) \ + ) +#endif + +/* +** A search constraint. +*/ +struct RtreeConstraint { + int iCoord; /* Index of constrained coordinate */ + int op; /* Constraining operation */ + union { + RtreeDValue rValue; /* Constraint value. */ + int (*xGeom)(sqlite3_rtree_geometry*,int,RtreeDValue*,int*); + int (*xQueryFunc)(sqlite3_rtree_query_info*); + } u; + sqlite3_rtree_query_info *pInfo; /* xGeom and xQueryFunc argument */ +}; + +/* Possible values for RtreeConstraint.op */ +#define RTREE_EQ 0x41 /* A */ +#define RTREE_LE 0x42 /* B */ +#define RTREE_LT 0x43 /* C */ +#define RTREE_GE 0x44 /* D */ +#define RTREE_GT 0x45 /* E */ +#define RTREE_MATCH 0x46 /* F: Old-style sqlite3_rtree_geometry_callback() */ +#define RTREE_QUERY 0x47 /* G: New-style sqlite3_rtree_query_callback() */ + +/* Special operators available only on cursors. Needs to be consecutive +** with the normal values above, but must be less than RTREE_MATCH. These +** are used in the cursor for contraints such as x=NULL (RTREE_FALSE) or +** x<'xyz' (RTREE_TRUE) */ +#define RTREE_TRUE 0x3f /* ? */ +#define RTREE_FALSE 0x40 /* @ */ + +/* +** An rtree structure node. +*/ +struct RtreeNode { + RtreeNode *pParent; /* Parent node */ + i64 iNode; /* The node number */ + int nRef; /* Number of references to this node */ + int isDirty; /* True if the node needs to be written to disk */ + u8 *zData; /* Content of the node, as should be on disk */ + RtreeNode *pNext; /* Next node in this hash collision chain */ +}; + +/* Return the number of cells in a node */ +#define NCELL(pNode) readInt16(&(pNode)->zData[2]) + +/* +** A single cell from a node, deserialized +*/ +struct RtreeCell { + i64 iRowid; /* Node or entry ID */ + RtreeCoord aCoord[RTREE_MAX_DIMENSIONS*2]; /* Bounding box coordinates */ +}; + + +/* +** This object becomes the sqlite3_user_data() for the SQL functions +** that are created by sqlite3_rtree_geometry_callback() and +** sqlite3_rtree_query_callback() and which appear on the right of MATCH +** operators in order to constrain a search. +** +** xGeom and xQueryFunc are the callback functions. Exactly one of +** xGeom and xQueryFunc fields is non-NULL, depending on whether the +** SQL function was created using sqlite3_rtree_geometry_callback() or +** sqlite3_rtree_query_callback(). +** +** This object is deleted automatically by the destructor mechanism in +** sqlite3_create_function_v2(). +*/ +struct RtreeGeomCallback { + int (*xGeom)(sqlite3_rtree_geometry*, int, RtreeDValue*, int*); + int (*xQueryFunc)(sqlite3_rtree_query_info*); + void (*xDestructor)(void*); + void *pContext; +}; + +/* +** An instance of this structure (in the form of a BLOB) is returned by +** the SQL functions that sqlite3_rtree_geometry_callback() and +** sqlite3_rtree_query_callback() create, and is read as the right-hand +** operand to the MATCH operator of an R-Tree. +*/ +struct RtreeMatchArg { + u32 iSize; /* Size of this object */ + RtreeGeomCallback cb; /* Info about the callback functions */ + int nParam; /* Number of parameters to the SQL function */ + sqlite3_value **apSqlParam; /* Original SQL parameter values */ + RtreeDValue aParam[1]; /* Values for parameters to the SQL function */ +}; + +#ifndef MAX +# define MAX(x,y) ((x) < (y) ? (y) : (x)) +#endif +#ifndef MIN +# define MIN(x,y) ((x) > (y) ? (y) : (x)) +#endif + +/* What version of GCC is being used. 0 means GCC is not being used . +** Note that the GCC_VERSION macro will also be set correctly when using +** clang, since clang works hard to be gcc compatible. So the gcc +** optimizations will also work when compiling with clang. +*/ +#ifndef GCC_VERSION +#if defined(__GNUC__) && !defined(SQLITE_DISABLE_INTRINSIC) +# define GCC_VERSION (__GNUC__*1000000+__GNUC_MINOR__*1000+__GNUC_PATCHLEVEL__) +#else +# define GCC_VERSION 0 +#endif +#endif + +/* The testcase() macro should already be defined in the amalgamation. If +** it is not, make it a no-op. +*/ +#ifndef SQLITE_AMALGAMATION +# if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_DEBUG) + unsigned int sqlite3RtreeTestcase = 0; +# define testcase(X) if( X ){ sqlite3RtreeTestcase += __LINE__; } +# else +# define testcase(X) +# endif +#endif + +/* +** Make sure that the compiler intrinsics we desire are enabled when +** compiling with an appropriate version of MSVC unless prevented by +** the SQLITE_DISABLE_INTRINSIC define. +*/ +#if !defined(SQLITE_DISABLE_INTRINSIC) +# if defined(_MSC_VER) && _MSC_VER>=1400 +# if !defined(_WIN32_WCE) +/* # include */ +# pragma intrinsic(_byteswap_ulong) +# pragma intrinsic(_byteswap_uint64) +# else +/* # include */ +# endif +# endif +#endif + +/* +** Macros to determine whether the machine is big or little endian, +** and whether or not that determination is run-time or compile-time. +** +** For best performance, an attempt is made to guess at the byte-order +** using C-preprocessor macros. If that is unsuccessful, or if +** -DSQLITE_RUNTIME_BYTEORDER=1 is set, then byte-order is determined +** at run-time. +*/ +#ifndef SQLITE_BYTEORDER +# if defined(i386) || defined(__i386__) || defined(_M_IX86) || \ + defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \ + defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \ + defined(__ARMEL__) || defined(__AARCH64EL__) || defined(_M_ARM64) +# define SQLITE_BYTEORDER 1234 +# elif defined(sparc) || defined(__ppc__) || \ + defined(__ARMEB__) || defined(__AARCH64EB__) +# define SQLITE_BYTEORDER 4321 +# else +# define SQLITE_BYTEORDER 0 +# endif +#endif + + +/* What version of MSVC is being used. 0 means MSVC is not being used */ +#ifndef MSVC_VERSION +#if defined(_MSC_VER) && !defined(SQLITE_DISABLE_INTRINSIC) +# define MSVC_VERSION _MSC_VER +#else +# define MSVC_VERSION 0 +#endif +#endif + +/* +** Functions to deserialize a 16 bit integer, 32 bit real number and +** 64 bit integer. The deserialized value is returned. +*/ +static int readInt16(u8 *p){ + return (p[0]<<8) + p[1]; +} +static void readCoord(u8 *p, RtreeCoord *pCoord){ + assert( (((sqlite3_uint64)p)&3)==0 ); /* p is always 4-byte aligned */ +#if SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300 + pCoord->u = _byteswap_ulong(*(u32*)p); +#elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000 + pCoord->u = __builtin_bswap32(*(u32*)p); +#elif SQLITE_BYTEORDER==4321 + pCoord->u = *(u32*)p; +#else + pCoord->u = ( + (((u32)p[0]) << 24) + + (((u32)p[1]) << 16) + + (((u32)p[2]) << 8) + + (((u32)p[3]) << 0) + ); +#endif +} +static i64 readInt64(u8 *p){ +#if SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300 + u64 x; + memcpy(&x, p, 8); + return (i64)_byteswap_uint64(x); +#elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000 + u64 x; + memcpy(&x, p, 8); + return (i64)__builtin_bswap64(x); +#elif SQLITE_BYTEORDER==4321 + i64 x; + memcpy(&x, p, 8); + return x; +#else + return (i64)( + (((u64)p[0]) << 56) + + (((u64)p[1]) << 48) + + (((u64)p[2]) << 40) + + (((u64)p[3]) << 32) + + (((u64)p[4]) << 24) + + (((u64)p[5]) << 16) + + (((u64)p[6]) << 8) + + (((u64)p[7]) << 0) + ); +#endif +} + +/* +** Functions to serialize a 16 bit integer, 32 bit real number and +** 64 bit integer. The value returned is the number of bytes written +** to the argument buffer (always 2, 4 and 8 respectively). +*/ +static void writeInt16(u8 *p, int i){ + p[0] = (i>> 8)&0xFF; + p[1] = (i>> 0)&0xFF; +} +static int writeCoord(u8 *p, RtreeCoord *pCoord){ + u32 i; + assert( (((sqlite3_uint64)p)&3)==0 ); /* p is always 4-byte aligned */ + assert( sizeof(RtreeCoord)==4 ); + assert( sizeof(u32)==4 ); +#if SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000 + i = __builtin_bswap32(pCoord->u); + memcpy(p, &i, 4); +#elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300 + i = _byteswap_ulong(pCoord->u); + memcpy(p, &i, 4); +#elif SQLITE_BYTEORDER==4321 + i = pCoord->u; + memcpy(p, &i, 4); +#else + i = pCoord->u; + p[0] = (i>>24)&0xFF; + p[1] = (i>>16)&0xFF; + p[2] = (i>> 8)&0xFF; + p[3] = (i>> 0)&0xFF; +#endif + return 4; +} +static int writeInt64(u8 *p, i64 i){ +#if SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000 + i = (i64)__builtin_bswap64((u64)i); + memcpy(p, &i, 8); +#elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300 + i = (i64)_byteswap_uint64((u64)i); + memcpy(p, &i, 8); +#elif SQLITE_BYTEORDER==4321 + memcpy(p, &i, 8); +#else + p[0] = (i>>56)&0xFF; + p[1] = (i>>48)&0xFF; + p[2] = (i>>40)&0xFF; + p[3] = (i>>32)&0xFF; + p[4] = (i>>24)&0xFF; + p[5] = (i>>16)&0xFF; + p[6] = (i>> 8)&0xFF; + p[7] = (i>> 0)&0xFF; +#endif + return 8; +} + +/* +** Increment the reference count of node p. +*/ +static void nodeReference(RtreeNode *p){ + if( p ){ + assert( p->nRef>0 ); + p->nRef++; + } +} + +/* +** Clear the content of node p (set all bytes to 0x00). +*/ +static void nodeZero(Rtree *pRtree, RtreeNode *p){ + memset(&p->zData[2], 0, pRtree->iNodeSize-2); + p->isDirty = 1; +} + +/* +** Given a node number iNode, return the corresponding key to use +** in the Rtree.aHash table. +*/ +static unsigned int nodeHash(i64 iNode){ + return ((unsigned)iNode) % HASHSIZE; +} + +/* +** Search the node hash table for node iNode. If found, return a pointer +** to it. Otherwise, return 0. +*/ +static RtreeNode *nodeHashLookup(Rtree *pRtree, i64 iNode){ + RtreeNode *p; + for(p=pRtree->aHash[nodeHash(iNode)]; p && p->iNode!=iNode; p=p->pNext); + return p; +} + +/* +** Add node pNode to the node hash table. +*/ +static void nodeHashInsert(Rtree *pRtree, RtreeNode *pNode){ + int iHash; + assert( pNode->pNext==0 ); + iHash = nodeHash(pNode->iNode); + pNode->pNext = pRtree->aHash[iHash]; + pRtree->aHash[iHash] = pNode; +} + +/* +** Remove node pNode from the node hash table. +*/ +static void nodeHashDelete(Rtree *pRtree, RtreeNode *pNode){ + RtreeNode **pp; + if( pNode->iNode!=0 ){ + pp = &pRtree->aHash[nodeHash(pNode->iNode)]; + for( ; (*pp)!=pNode; pp = &(*pp)->pNext){ assert(*pp); } + *pp = pNode->pNext; + pNode->pNext = 0; + } +} + +/* +** Allocate and return new r-tree node. Initially, (RtreeNode.iNode==0), +** indicating that node has not yet been assigned a node number. It is +** assigned a node number when nodeWrite() is called to write the +** node contents out to the database. +*/ +static RtreeNode *nodeNew(Rtree *pRtree, RtreeNode *pParent){ + RtreeNode *pNode; + pNode = (RtreeNode *)sqlite3_malloc64(sizeof(RtreeNode) + pRtree->iNodeSize); + if( pNode ){ + memset(pNode, 0, sizeof(RtreeNode) + pRtree->iNodeSize); + pNode->zData = (u8 *)&pNode[1]; + pNode->nRef = 1; + pRtree->nNodeRef++; + pNode->pParent = pParent; + pNode->isDirty = 1; + nodeReference(pParent); + } + return pNode; +} + +/* +** Clear the Rtree.pNodeBlob object +*/ +static void nodeBlobReset(Rtree *pRtree){ + if( pRtree->pNodeBlob && pRtree->inWrTrans==0 && pRtree->nCursor==0 ){ + sqlite3_blob *pBlob = pRtree->pNodeBlob; + pRtree->pNodeBlob = 0; + sqlite3_blob_close(pBlob); + } +} + +/* +** Obtain a reference to an r-tree node. +*/ +static int nodeAcquire( + Rtree *pRtree, /* R-tree structure */ + i64 iNode, /* Node number to load */ + RtreeNode *pParent, /* Either the parent node or NULL */ + RtreeNode **ppNode /* OUT: Acquired node */ +){ + int rc = SQLITE_OK; + RtreeNode *pNode = 0; + + /* Check if the requested node is already in the hash table. If so, + ** increase its reference count and return it. + */ + if( (pNode = nodeHashLookup(pRtree, iNode))!=0 ){ + if( pParent && pParent!=pNode->pParent ){ + RTREE_IS_CORRUPT(pRtree); + return SQLITE_CORRUPT_VTAB; + } + pNode->nRef++; + *ppNode = pNode; + return SQLITE_OK; + } + + if( pRtree->pNodeBlob ){ + sqlite3_blob *pBlob = pRtree->pNodeBlob; + pRtree->pNodeBlob = 0; + rc = sqlite3_blob_reopen(pBlob, iNode); + pRtree->pNodeBlob = pBlob; + if( rc ){ + nodeBlobReset(pRtree); + if( rc==SQLITE_NOMEM ) return SQLITE_NOMEM; + } + } + if( pRtree->pNodeBlob==0 ){ + char *zTab = sqlite3_mprintf("%s_node", pRtree->zName); + if( zTab==0 ) return SQLITE_NOMEM; + rc = sqlite3_blob_open(pRtree->db, pRtree->zDb, zTab, "data", iNode, 0, + &pRtree->pNodeBlob); + sqlite3_free(zTab); + } + if( rc ){ + nodeBlobReset(pRtree); + *ppNode = 0; + /* If unable to open an sqlite3_blob on the desired row, that can only + ** be because the shadow tables hold erroneous data. */ + if( rc==SQLITE_ERROR ){ + rc = SQLITE_CORRUPT_VTAB; + RTREE_IS_CORRUPT(pRtree); + } + }else if( pRtree->iNodeSize==sqlite3_blob_bytes(pRtree->pNodeBlob) ){ + pNode = (RtreeNode *)sqlite3_malloc64(sizeof(RtreeNode)+pRtree->iNodeSize); + if( !pNode ){ + rc = SQLITE_NOMEM; + }else{ + pNode->pParent = pParent; + pNode->zData = (u8 *)&pNode[1]; + pNode->nRef = 1; + pRtree->nNodeRef++; + pNode->iNode = iNode; + pNode->isDirty = 0; + pNode->pNext = 0; + rc = sqlite3_blob_read(pRtree->pNodeBlob, pNode->zData, + pRtree->iNodeSize, 0); + } + } + + /* If the root node was just loaded, set pRtree->iDepth to the height + ** of the r-tree structure. A height of zero means all data is stored on + ** the root node. A height of one means the children of the root node + ** are the leaves, and so on. If the depth as specified on the root node + ** is greater than RTREE_MAX_DEPTH, the r-tree structure must be corrupt. + */ + if( rc==SQLITE_OK && pNode && iNode==1 ){ + pRtree->iDepth = readInt16(pNode->zData); + if( pRtree->iDepth>RTREE_MAX_DEPTH ){ + rc = SQLITE_CORRUPT_VTAB; + RTREE_IS_CORRUPT(pRtree); + } + } + + /* If no error has occurred so far, check if the "number of entries" + ** field on the node is too large. If so, set the return code to + ** SQLITE_CORRUPT_VTAB. + */ + if( pNode && rc==SQLITE_OK ){ + if( NCELL(pNode)>((pRtree->iNodeSize-4)/pRtree->nBytesPerCell) ){ + rc = SQLITE_CORRUPT_VTAB; + RTREE_IS_CORRUPT(pRtree); + } + } + + if( rc==SQLITE_OK ){ + if( pNode!=0 ){ + nodeReference(pParent); + nodeHashInsert(pRtree, pNode); + }else{ + rc = SQLITE_CORRUPT_VTAB; + RTREE_IS_CORRUPT(pRtree); + } + *ppNode = pNode; + }else{ + if( pNode ){ + pRtree->nNodeRef--; + sqlite3_free(pNode); + } + *ppNode = 0; + } + + return rc; +} + +/* +** Overwrite cell iCell of node pNode with the contents of pCell. +*/ +static void nodeOverwriteCell( + Rtree *pRtree, /* The overall R-Tree */ + RtreeNode *pNode, /* The node into which the cell is to be written */ + RtreeCell *pCell, /* The cell to write */ + int iCell /* Index into pNode into which pCell is written */ +){ + int ii; + u8 *p = &pNode->zData[4 + pRtree->nBytesPerCell*iCell]; + p += writeInt64(p, pCell->iRowid); + for(ii=0; iinDim2; ii++){ + p += writeCoord(p, &pCell->aCoord[ii]); + } + pNode->isDirty = 1; +} + +/* +** Remove the cell with index iCell from node pNode. +*/ +static void nodeDeleteCell(Rtree *pRtree, RtreeNode *pNode, int iCell){ + u8 *pDst = &pNode->zData[4 + pRtree->nBytesPerCell*iCell]; + u8 *pSrc = &pDst[pRtree->nBytesPerCell]; + int nByte = (NCELL(pNode) - iCell - 1) * pRtree->nBytesPerCell; + memmove(pDst, pSrc, nByte); + writeInt16(&pNode->zData[2], NCELL(pNode)-1); + pNode->isDirty = 1; +} + +/* +** Insert the contents of cell pCell into node pNode. If the insert +** is successful, return SQLITE_OK. +** +** If there is not enough free space in pNode, return SQLITE_FULL. +*/ +static int nodeInsertCell( + Rtree *pRtree, /* The overall R-Tree */ + RtreeNode *pNode, /* Write new cell into this node */ + RtreeCell *pCell /* The cell to be inserted */ +){ + int nCell; /* Current number of cells in pNode */ + int nMaxCell; /* Maximum number of cells for pNode */ + + nMaxCell = (pRtree->iNodeSize-4)/pRtree->nBytesPerCell; + nCell = NCELL(pNode); + + assert( nCell<=nMaxCell ); + if( nCellzData[2], nCell+1); + pNode->isDirty = 1; + } + + return (nCell==nMaxCell); +} + +/* +** If the node is dirty, write it out to the database. +*/ +static int nodeWrite(Rtree *pRtree, RtreeNode *pNode){ + int rc = SQLITE_OK; + if( pNode->isDirty ){ + sqlite3_stmt *p = pRtree->pWriteNode; + if( pNode->iNode ){ + sqlite3_bind_int64(p, 1, pNode->iNode); + }else{ + sqlite3_bind_null(p, 1); + } + sqlite3_bind_blob(p, 2, pNode->zData, pRtree->iNodeSize, SQLITE_STATIC); + sqlite3_step(p); + pNode->isDirty = 0; + rc = sqlite3_reset(p); + sqlite3_bind_null(p, 2); + if( pNode->iNode==0 && rc==SQLITE_OK ){ + pNode->iNode = sqlite3_last_insert_rowid(pRtree->db); + nodeHashInsert(pRtree, pNode); + } + } + return rc; +} + +/* +** Release a reference to a node. If the node is dirty and the reference +** count drops to zero, the node data is written to the database. +*/ +static int nodeRelease(Rtree *pRtree, RtreeNode *pNode){ + int rc = SQLITE_OK; + if( pNode ){ + assert( pNode->nRef>0 ); + assert( pRtree->nNodeRef>0 ); + pNode->nRef--; + if( pNode->nRef==0 ){ + pRtree->nNodeRef--; + if( pNode->iNode==1 ){ + pRtree->iDepth = -1; + } + if( pNode->pParent ){ + rc = nodeRelease(pRtree, pNode->pParent); + } + if( rc==SQLITE_OK ){ + rc = nodeWrite(pRtree, pNode); + } + nodeHashDelete(pRtree, pNode); + sqlite3_free(pNode); + } + } + return rc; +} + +/* +** Return the 64-bit integer value associated with cell iCell of +** node pNode. If pNode is a leaf node, this is a rowid. If it is +** an internal node, then the 64-bit integer is a child page number. +*/ +static i64 nodeGetRowid( + Rtree *pRtree, /* The overall R-Tree */ + RtreeNode *pNode, /* The node from which to extract the ID */ + int iCell /* The cell index from which to extract the ID */ +){ + assert( iCellzData[4 + pRtree->nBytesPerCell*iCell]); +} + +/* +** Return coordinate iCoord from cell iCell in node pNode. +*/ +static void nodeGetCoord( + Rtree *pRtree, /* The overall R-Tree */ + RtreeNode *pNode, /* The node from which to extract a coordinate */ + int iCell, /* The index of the cell within the node */ + int iCoord, /* Which coordinate to extract */ + RtreeCoord *pCoord /* OUT: Space to write result to */ +){ + readCoord(&pNode->zData[12 + pRtree->nBytesPerCell*iCell + 4*iCoord], pCoord); +} + +/* +** Deserialize cell iCell of node pNode. Populate the structure pointed +** to by pCell with the results. +*/ +static void nodeGetCell( + Rtree *pRtree, /* The overall R-Tree */ + RtreeNode *pNode, /* The node containing the cell to be read */ + int iCell, /* Index of the cell within the node */ + RtreeCell *pCell /* OUT: Write the cell contents here */ +){ + u8 *pData; + RtreeCoord *pCoord; + int ii = 0; + pCell->iRowid = nodeGetRowid(pRtree, pNode, iCell); + pData = pNode->zData + (12 + pRtree->nBytesPerCell*iCell); + pCoord = pCell->aCoord; + do{ + readCoord(pData, &pCoord[ii]); + readCoord(pData+4, &pCoord[ii+1]); + pData += 8; + ii += 2; + }while( iinDim2 ); +} + + +/* Forward declaration for the function that does the work of +** the virtual table module xCreate() and xConnect() methods. +*/ +static int rtreeInit( + sqlite3 *, void *, int, const char *const*, sqlite3_vtab **, char **, int +); + +/* +** Rtree virtual table module xCreate method. +*/ +static int rtreeCreate( + sqlite3 *db, + void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVtab, + char **pzErr +){ + return rtreeInit(db, pAux, argc, argv, ppVtab, pzErr, 1); +} + +/* +** Rtree virtual table module xConnect method. +*/ +static int rtreeConnect( + sqlite3 *db, + void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVtab, + char **pzErr +){ + return rtreeInit(db, pAux, argc, argv, ppVtab, pzErr, 0); +} + +/* +** Increment the r-tree reference count. +*/ +static void rtreeReference(Rtree *pRtree){ + pRtree->nBusy++; +} + +/* +** Decrement the r-tree reference count. When the reference count reaches +** zero the structure is deleted. +*/ +static void rtreeRelease(Rtree *pRtree){ + pRtree->nBusy--; + if( pRtree->nBusy==0 ){ + pRtree->inWrTrans = 0; + assert( pRtree->nCursor==0 ); + nodeBlobReset(pRtree); + assert( pRtree->nNodeRef==0 || pRtree->bCorrupt ); + sqlite3_finalize(pRtree->pWriteNode); + sqlite3_finalize(pRtree->pDeleteNode); + sqlite3_finalize(pRtree->pReadRowid); + sqlite3_finalize(pRtree->pWriteRowid); + sqlite3_finalize(pRtree->pDeleteRowid); + sqlite3_finalize(pRtree->pReadParent); + sqlite3_finalize(pRtree->pWriteParent); + sqlite3_finalize(pRtree->pDeleteParent); + sqlite3_finalize(pRtree->pWriteAux); + sqlite3_free(pRtree->zReadAuxSql); + sqlite3_free(pRtree); + } +} + +/* +** Rtree virtual table module xDisconnect method. +*/ +static int rtreeDisconnect(sqlite3_vtab *pVtab){ + rtreeRelease((Rtree *)pVtab); + return SQLITE_OK; +} + +/* +** Rtree virtual table module xDestroy method. +*/ +static int rtreeDestroy(sqlite3_vtab *pVtab){ + Rtree *pRtree = (Rtree *)pVtab; + int rc; + char *zCreate = sqlite3_mprintf( + "DROP TABLE '%q'.'%q_node';" + "DROP TABLE '%q'.'%q_rowid';" + "DROP TABLE '%q'.'%q_parent';", + pRtree->zDb, pRtree->zName, + pRtree->zDb, pRtree->zName, + pRtree->zDb, pRtree->zName + ); + if( !zCreate ){ + rc = SQLITE_NOMEM; + }else{ + nodeBlobReset(pRtree); + rc = sqlite3_exec(pRtree->db, zCreate, 0, 0, 0); + sqlite3_free(zCreate); + } + if( rc==SQLITE_OK ){ + rtreeRelease(pRtree); + } + + return rc; +} + +/* +** Rtree virtual table module xOpen method. +*/ +static int rtreeOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){ + int rc = SQLITE_NOMEM; + Rtree *pRtree = (Rtree *)pVTab; + RtreeCursor *pCsr; + + pCsr = (RtreeCursor *)sqlite3_malloc64(sizeof(RtreeCursor)); + if( pCsr ){ + memset(pCsr, 0, sizeof(RtreeCursor)); + pCsr->base.pVtab = pVTab; + rc = SQLITE_OK; + pRtree->nCursor++; + } + *ppCursor = (sqlite3_vtab_cursor *)pCsr; + + return rc; +} + + +/* +** Reset a cursor back to its initial state. +*/ +static void resetCursor(RtreeCursor *pCsr){ + Rtree *pRtree = (Rtree *)(pCsr->base.pVtab); + int ii; + sqlite3_stmt *pStmt; + if( pCsr->aConstraint ){ + int i; /* Used to iterate through constraint array */ + for(i=0; inConstraint; i++){ + sqlite3_rtree_query_info *pInfo = pCsr->aConstraint[i].pInfo; + if( pInfo ){ + if( pInfo->xDelUser ) pInfo->xDelUser(pInfo->pUser); + sqlite3_free(pInfo); + } + } + sqlite3_free(pCsr->aConstraint); + pCsr->aConstraint = 0; + } + for(ii=0; iiaNode[ii]); + sqlite3_free(pCsr->aPoint); + pStmt = pCsr->pReadAux; + memset(pCsr, 0, sizeof(RtreeCursor)); + pCsr->base.pVtab = (sqlite3_vtab*)pRtree; + pCsr->pReadAux = pStmt; + +} + +/* +** Rtree virtual table module xClose method. +*/ +static int rtreeClose(sqlite3_vtab_cursor *cur){ + Rtree *pRtree = (Rtree *)(cur->pVtab); + RtreeCursor *pCsr = (RtreeCursor *)cur; + assert( pRtree->nCursor>0 ); + resetCursor(pCsr); + sqlite3_finalize(pCsr->pReadAux); + sqlite3_free(pCsr); + pRtree->nCursor--; + nodeBlobReset(pRtree); + return SQLITE_OK; +} + +/* +** Rtree virtual table module xEof method. +** +** Return non-zero if the cursor does not currently point to a valid +** record (i.e if the scan has finished), or zero otherwise. +*/ +static int rtreeEof(sqlite3_vtab_cursor *cur){ + RtreeCursor *pCsr = (RtreeCursor *)cur; + return pCsr->atEOF; +} + +/* +** Convert raw bits from the on-disk RTree record into a coordinate value. +** The on-disk format is big-endian and needs to be converted for little- +** endian platforms. The on-disk record stores integer coordinates if +** eInt is true and it stores 32-bit floating point records if eInt is +** false. a[] is the four bytes of the on-disk record to be decoded. +** Store the results in "r". +** +** There are five versions of this macro. The last one is generic. The +** other four are various architectures-specific optimizations. +*/ +#if SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300 +#define RTREE_DECODE_COORD(eInt, a, r) { \ + RtreeCoord c; /* Coordinate decoded */ \ + c.u = _byteswap_ulong(*(u32*)a); \ + r = eInt ? (sqlite3_rtree_dbl)c.i : (sqlite3_rtree_dbl)c.f; \ +} +#elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000 +#define RTREE_DECODE_COORD(eInt, a, r) { \ + RtreeCoord c; /* Coordinate decoded */ \ + c.u = __builtin_bswap32(*(u32*)a); \ + r = eInt ? (sqlite3_rtree_dbl)c.i : (sqlite3_rtree_dbl)c.f; \ +} +#elif SQLITE_BYTEORDER==1234 +#define RTREE_DECODE_COORD(eInt, a, r) { \ + RtreeCoord c; /* Coordinate decoded */ \ + memcpy(&c.u,a,4); \ + c.u = ((c.u>>24)&0xff)|((c.u>>8)&0xff00)| \ + ((c.u&0xff)<<24)|((c.u&0xff00)<<8); \ + r = eInt ? (sqlite3_rtree_dbl)c.i : (sqlite3_rtree_dbl)c.f; \ +} +#elif SQLITE_BYTEORDER==4321 +#define RTREE_DECODE_COORD(eInt, a, r) { \ + RtreeCoord c; /* Coordinate decoded */ \ + memcpy(&c.u,a,4); \ + r = eInt ? (sqlite3_rtree_dbl)c.i : (sqlite3_rtree_dbl)c.f; \ +} +#else +#define RTREE_DECODE_COORD(eInt, a, r) { \ + RtreeCoord c; /* Coordinate decoded */ \ + c.u = ((u32)a[0]<<24) + ((u32)a[1]<<16) \ + +((u32)a[2]<<8) + a[3]; \ + r = eInt ? (sqlite3_rtree_dbl)c.i : (sqlite3_rtree_dbl)c.f; \ +} +#endif + +/* +** Check the RTree node or entry given by pCellData and p against the MATCH +** constraint pConstraint. +*/ +static int rtreeCallbackConstraint( + RtreeConstraint *pConstraint, /* The constraint to test */ + int eInt, /* True if RTree holding integer coordinates */ + u8 *pCellData, /* Raw cell content */ + RtreeSearchPoint *pSearch, /* Container of this cell */ + sqlite3_rtree_dbl *prScore, /* OUT: score for the cell */ + int *peWithin /* OUT: visibility of the cell */ +){ + sqlite3_rtree_query_info *pInfo = pConstraint->pInfo; /* Callback info */ + int nCoord = pInfo->nCoord; /* No. of coordinates */ + int rc; /* Callback return code */ + RtreeCoord c; /* Translator union */ + sqlite3_rtree_dbl aCoord[RTREE_MAX_DIMENSIONS*2]; /* Decoded coordinates */ + + assert( pConstraint->op==RTREE_MATCH || pConstraint->op==RTREE_QUERY ); + assert( nCoord==2 || nCoord==4 || nCoord==6 || nCoord==8 || nCoord==10 ); + + if( pConstraint->op==RTREE_QUERY && pSearch->iLevel==1 ){ + pInfo->iRowid = readInt64(pCellData); + } + pCellData += 8; +#ifndef SQLITE_RTREE_INT_ONLY + if( eInt==0 ){ + switch( nCoord ){ + case 10: readCoord(pCellData+36, &c); aCoord[9] = c.f; + readCoord(pCellData+32, &c); aCoord[8] = c.f; + case 8: readCoord(pCellData+28, &c); aCoord[7] = c.f; + readCoord(pCellData+24, &c); aCoord[6] = c.f; + case 6: readCoord(pCellData+20, &c); aCoord[5] = c.f; + readCoord(pCellData+16, &c); aCoord[4] = c.f; + case 4: readCoord(pCellData+12, &c); aCoord[3] = c.f; + readCoord(pCellData+8, &c); aCoord[2] = c.f; + default: readCoord(pCellData+4, &c); aCoord[1] = c.f; + readCoord(pCellData, &c); aCoord[0] = c.f; + } + }else +#endif + { + switch( nCoord ){ + case 10: readCoord(pCellData+36, &c); aCoord[9] = c.i; + readCoord(pCellData+32, &c); aCoord[8] = c.i; + case 8: readCoord(pCellData+28, &c); aCoord[7] = c.i; + readCoord(pCellData+24, &c); aCoord[6] = c.i; + case 6: readCoord(pCellData+20, &c); aCoord[5] = c.i; + readCoord(pCellData+16, &c); aCoord[4] = c.i; + case 4: readCoord(pCellData+12, &c); aCoord[3] = c.i; + readCoord(pCellData+8, &c); aCoord[2] = c.i; + default: readCoord(pCellData+4, &c); aCoord[1] = c.i; + readCoord(pCellData, &c); aCoord[0] = c.i; + } + } + if( pConstraint->op==RTREE_MATCH ){ + int eWithin = 0; + rc = pConstraint->u.xGeom((sqlite3_rtree_geometry*)pInfo, + nCoord, aCoord, &eWithin); + if( eWithin==0 ) *peWithin = NOT_WITHIN; + *prScore = RTREE_ZERO; + }else{ + pInfo->aCoord = aCoord; + pInfo->iLevel = pSearch->iLevel - 1; + pInfo->rScore = pInfo->rParentScore = pSearch->rScore; + pInfo->eWithin = pInfo->eParentWithin = pSearch->eWithin; + rc = pConstraint->u.xQueryFunc(pInfo); + if( pInfo->eWithin<*peWithin ) *peWithin = pInfo->eWithin; + if( pInfo->rScore<*prScore || *prScorerScore; + } + } + return rc; +} + +/* +** Check the internal RTree node given by pCellData against constraint p. +** If this constraint cannot be satisfied by any child within the node, +** set *peWithin to NOT_WITHIN. +*/ +static void rtreeNonleafConstraint( + RtreeConstraint *p, /* The constraint to test */ + int eInt, /* True if RTree holds integer coordinates */ + u8 *pCellData, /* Raw cell content as appears on disk */ + int *peWithin /* Adjust downward, as appropriate */ +){ + sqlite3_rtree_dbl val; /* Coordinate value convert to a double */ + + /* p->iCoord might point to either a lower or upper bound coordinate + ** in a coordinate pair. But make pCellData point to the lower bound. + */ + pCellData += 8 + 4*(p->iCoord&0xfe); + + assert(p->op==RTREE_LE || p->op==RTREE_LT || p->op==RTREE_GE + || p->op==RTREE_GT || p->op==RTREE_EQ || p->op==RTREE_TRUE + || p->op==RTREE_FALSE ); + assert( (((sqlite3_uint64)pCellData)&3)==0 ); /* 4-byte aligned */ + switch( p->op ){ + case RTREE_TRUE: return; /* Always satisfied */ + case RTREE_FALSE: break; /* Never satisfied */ + case RTREE_EQ: + RTREE_DECODE_COORD(eInt, pCellData, val); + /* val now holds the lower bound of the coordinate pair */ + if( p->u.rValue>=val ){ + pCellData += 4; + RTREE_DECODE_COORD(eInt, pCellData, val); + /* val now holds the upper bound of the coordinate pair */ + if( p->u.rValue<=val ) return; + } + break; + case RTREE_LE: + case RTREE_LT: + RTREE_DECODE_COORD(eInt, pCellData, val); + /* val now holds the lower bound of the coordinate pair */ + if( p->u.rValue>=val ) return; + break; + + default: + pCellData += 4; + RTREE_DECODE_COORD(eInt, pCellData, val); + /* val now holds the upper bound of the coordinate pair */ + if( p->u.rValue<=val ) return; + break; + } + *peWithin = NOT_WITHIN; +} + +/* +** Check the leaf RTree cell given by pCellData against constraint p. +** If this constraint is not satisfied, set *peWithin to NOT_WITHIN. +** If the constraint is satisfied, leave *peWithin unchanged. +** +** The constraint is of the form: xN op $val +** +** The op is given by p->op. The xN is p->iCoord-th coordinate in +** pCellData. $val is given by p->u.rValue. +*/ +static void rtreeLeafConstraint( + RtreeConstraint *p, /* The constraint to test */ + int eInt, /* True if RTree holds integer coordinates */ + u8 *pCellData, /* Raw cell content as appears on disk */ + int *peWithin /* Adjust downward, as appropriate */ +){ + RtreeDValue xN; /* Coordinate value converted to a double */ + + assert(p->op==RTREE_LE || p->op==RTREE_LT || p->op==RTREE_GE + || p->op==RTREE_GT || p->op==RTREE_EQ || p->op==RTREE_TRUE + || p->op==RTREE_FALSE ); + pCellData += 8 + p->iCoord*4; + assert( (((sqlite3_uint64)pCellData)&3)==0 ); /* 4-byte aligned */ + RTREE_DECODE_COORD(eInt, pCellData, xN); + switch( p->op ){ + case RTREE_TRUE: return; /* Always satisfied */ + case RTREE_FALSE: break; /* Never satisfied */ + case RTREE_LE: if( xN <= p->u.rValue ) return; break; + case RTREE_LT: if( xN < p->u.rValue ) return; break; + case RTREE_GE: if( xN >= p->u.rValue ) return; break; + case RTREE_GT: if( xN > p->u.rValue ) return; break; + default: if( xN == p->u.rValue ) return; break; + } + *peWithin = NOT_WITHIN; +} + +/* +** One of the cells in node pNode is guaranteed to have a 64-bit +** integer value equal to iRowid. Return the index of this cell. +*/ +static int nodeRowidIndex( + Rtree *pRtree, + RtreeNode *pNode, + i64 iRowid, + int *piIndex +){ + int ii; + int nCell = NCELL(pNode); + assert( nCell<200 ); + for(ii=0; iipParent; + if( ALWAYS(pParent) ){ + return nodeRowidIndex(pRtree, pParent, pNode->iNode, piIndex); + }else{ + *piIndex = -1; + return SQLITE_OK; + } +} + +/* +** Compare two search points. Return negative, zero, or positive if the first +** is less than, equal to, or greater than the second. +** +** The rScore is the primary key. Smaller rScore values come first. +** If the rScore is a tie, then use iLevel as the tie breaker with smaller +** iLevel values coming first. In this way, if rScore is the same for all +** SearchPoints, then iLevel becomes the deciding factor and the result +** is a depth-first search, which is the desired default behavior. +*/ +static int rtreeSearchPointCompare( + const RtreeSearchPoint *pA, + const RtreeSearchPoint *pB +){ + if( pA->rScorerScore ) return -1; + if( pA->rScore>pB->rScore ) return +1; + if( pA->iLeveliLevel ) return -1; + if( pA->iLevel>pB->iLevel ) return +1; + return 0; +} + +/* +** Interchange two search points in a cursor. +*/ +static void rtreeSearchPointSwap(RtreeCursor *p, int i, int j){ + RtreeSearchPoint t = p->aPoint[i]; + assert( iaPoint[i] = p->aPoint[j]; + p->aPoint[j] = t; + i++; j++; + if( i=RTREE_CACHE_SZ ){ + nodeRelease(RTREE_OF_CURSOR(p), p->aNode[i]); + p->aNode[i] = 0; + }else{ + RtreeNode *pTemp = p->aNode[i]; + p->aNode[i] = p->aNode[j]; + p->aNode[j] = pTemp; + } + } +} + +/* +** Return the search point with the lowest current score. +*/ +static RtreeSearchPoint *rtreeSearchPointFirst(RtreeCursor *pCur){ + return pCur->bPoint ? &pCur->sPoint : pCur->nPoint ? pCur->aPoint : 0; +} + +/* +** Get the RtreeNode for the search point with the lowest score. +*/ +static RtreeNode *rtreeNodeOfFirstSearchPoint(RtreeCursor *pCur, int *pRC){ + sqlite3_int64 id; + int ii = 1 - pCur->bPoint; + assert( ii==0 || ii==1 ); + assert( pCur->bPoint || pCur->nPoint ); + if( pCur->aNode[ii]==0 ){ + assert( pRC!=0 ); + id = ii ? pCur->aPoint[0].id : pCur->sPoint.id; + *pRC = nodeAcquire(RTREE_OF_CURSOR(pCur), id, 0, &pCur->aNode[ii]); + } + return pCur->aNode[ii]; +} + +/* +** Push a new element onto the priority queue +*/ +static RtreeSearchPoint *rtreeEnqueue( + RtreeCursor *pCur, /* The cursor */ + RtreeDValue rScore, /* Score for the new search point */ + u8 iLevel /* Level for the new search point */ +){ + int i, j; + RtreeSearchPoint *pNew; + if( pCur->nPoint>=pCur->nPointAlloc ){ + int nNew = pCur->nPointAlloc*2 + 8; + pNew = sqlite3_realloc64(pCur->aPoint, nNew*sizeof(pCur->aPoint[0])); + if( pNew==0 ) return 0; + pCur->aPoint = pNew; + pCur->nPointAlloc = nNew; + } + i = pCur->nPoint++; + pNew = pCur->aPoint + i; + pNew->rScore = rScore; + pNew->iLevel = iLevel; + assert( iLevel<=RTREE_MAX_DEPTH ); + while( i>0 ){ + RtreeSearchPoint *pParent; + j = (i-1)/2; + pParent = pCur->aPoint + j; + if( rtreeSearchPointCompare(pNew, pParent)>=0 ) break; + rtreeSearchPointSwap(pCur, j, i); + i = j; + pNew = pParent; + } + return pNew; +} + +/* +** Allocate a new RtreeSearchPoint and return a pointer to it. Return +** NULL if malloc fails. +*/ +static RtreeSearchPoint *rtreeSearchPointNew( + RtreeCursor *pCur, /* The cursor */ + RtreeDValue rScore, /* Score for the new search point */ + u8 iLevel /* Level for the new search point */ +){ + RtreeSearchPoint *pNew, *pFirst; + pFirst = rtreeSearchPointFirst(pCur); + pCur->anQueue[iLevel]++; + if( pFirst==0 + || pFirst->rScore>rScore + || (pFirst->rScore==rScore && pFirst->iLevel>iLevel) + ){ + if( pCur->bPoint ){ + int ii; + pNew = rtreeEnqueue(pCur, rScore, iLevel); + if( pNew==0 ) return 0; + ii = (int)(pNew - pCur->aPoint) + 1; + assert( ii==1 ); + if( ALWAYS(iiaNode[ii]==0 ); + pCur->aNode[ii] = pCur->aNode[0]; + }else{ + nodeRelease(RTREE_OF_CURSOR(pCur), pCur->aNode[0]); + } + pCur->aNode[0] = 0; + *pNew = pCur->sPoint; + } + pCur->sPoint.rScore = rScore; + pCur->sPoint.iLevel = iLevel; + pCur->bPoint = 1; + return &pCur->sPoint; + }else{ + return rtreeEnqueue(pCur, rScore, iLevel); + } +} + +#if 0 +/* Tracing routines for the RtreeSearchPoint queue */ +static void tracePoint(RtreeSearchPoint *p, int idx, RtreeCursor *pCur){ + if( idx<0 ){ printf(" s"); }else{ printf("%2d", idx); } + printf(" %d.%05lld.%02d %g %d", + p->iLevel, p->id, p->iCell, p->rScore, p->eWithin + ); + idx++; + if( idxaNode[idx]); + }else{ + printf("\n"); + } +} +static void traceQueue(RtreeCursor *pCur, const char *zPrefix){ + int ii; + printf("=== %9s ", zPrefix); + if( pCur->bPoint ){ + tracePoint(&pCur->sPoint, -1, pCur); + } + for(ii=0; iinPoint; ii++){ + if( ii>0 || pCur->bPoint ) printf(" "); + tracePoint(&pCur->aPoint[ii], ii, pCur); + } +} +# define RTREE_QUEUE_TRACE(A,B) traceQueue(A,B) +#else +# define RTREE_QUEUE_TRACE(A,B) /* no-op */ +#endif + +/* Remove the search point with the lowest current score. +*/ +static void rtreeSearchPointPop(RtreeCursor *p){ + int i, j, k, n; + i = 1 - p->bPoint; + assert( i==0 || i==1 ); + if( p->aNode[i] ){ + nodeRelease(RTREE_OF_CURSOR(p), p->aNode[i]); + p->aNode[i] = 0; + } + if( p->bPoint ){ + p->anQueue[p->sPoint.iLevel]--; + p->bPoint = 0; + }else if( ALWAYS(p->nPoint) ){ + p->anQueue[p->aPoint[0].iLevel]--; + n = --p->nPoint; + p->aPoint[0] = p->aPoint[n]; + if( naNode[1] = p->aNode[n+1]; + p->aNode[n+1] = 0; + } + i = 0; + while( (j = i*2+1)aPoint[k], &p->aPoint[j])<0 ){ + if( rtreeSearchPointCompare(&p->aPoint[k], &p->aPoint[i])<0 ){ + rtreeSearchPointSwap(p, i, k); + i = k; + }else{ + break; + } + }else{ + if( rtreeSearchPointCompare(&p->aPoint[j], &p->aPoint[i])<0 ){ + rtreeSearchPointSwap(p, i, j); + i = j; + }else{ + break; + } + } + } + } +} + + +/* +** Continue the search on cursor pCur until the front of the queue +** contains an entry suitable for returning as a result-set row, +** or until the RtreeSearchPoint queue is empty, indicating that the +** query has completed. +*/ +static int rtreeStepToLeaf(RtreeCursor *pCur){ + RtreeSearchPoint *p; + Rtree *pRtree = RTREE_OF_CURSOR(pCur); + RtreeNode *pNode; + int eWithin; + int rc = SQLITE_OK; + int nCell; + int nConstraint = pCur->nConstraint; + int ii; + int eInt; + RtreeSearchPoint x; + + eInt = pRtree->eCoordType==RTREE_COORD_INT32; + while( (p = rtreeSearchPointFirst(pCur))!=0 && p->iLevel>0 ){ + u8 *pCellData; + pNode = rtreeNodeOfFirstSearchPoint(pCur, &rc); + if( rc ) return rc; + nCell = NCELL(pNode); + assert( nCell<200 ); + pCellData = pNode->zData + (4+pRtree->nBytesPerCell*p->iCell); + while( p->iCellaConstraint + ii; + if( pConstraint->op>=RTREE_MATCH ){ + rc = rtreeCallbackConstraint(pConstraint, eInt, pCellData, p, + &rScore, &eWithin); + if( rc ) return rc; + }else if( p->iLevel==1 ){ + rtreeLeafConstraint(pConstraint, eInt, pCellData, &eWithin); + }else{ + rtreeNonleafConstraint(pConstraint, eInt, pCellData, &eWithin); + } + if( eWithin==NOT_WITHIN ){ + p->iCell++; + pCellData += pRtree->nBytesPerCell; + break; + } + } + if( eWithin==NOT_WITHIN ) continue; + p->iCell++; + x.iLevel = p->iLevel - 1; + if( x.iLevel ){ + x.id = readInt64(pCellData); + for(ii=0; iinPoint; ii++){ + if( pCur->aPoint[ii].id==x.id ){ + RTREE_IS_CORRUPT(pRtree); + return SQLITE_CORRUPT_VTAB; + } + } + x.iCell = 0; + }else{ + x.id = p->id; + x.iCell = p->iCell - 1; + } + if( p->iCell>=nCell ){ + RTREE_QUEUE_TRACE(pCur, "POP-S:"); + rtreeSearchPointPop(pCur); + } + if( rScoreeWithin = (u8)eWithin; + p->id = x.id; + p->iCell = x.iCell; + RTREE_QUEUE_TRACE(pCur, "PUSH-S:"); + break; + } + if( p->iCell>=nCell ){ + RTREE_QUEUE_TRACE(pCur, "POP-Se:"); + rtreeSearchPointPop(pCur); + } + } + pCur->atEOF = p==0; + return SQLITE_OK; +} + +/* +** Rtree virtual table module xNext method. +*/ +static int rtreeNext(sqlite3_vtab_cursor *pVtabCursor){ + RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor; + int rc = SQLITE_OK; + + /* Move to the next entry that matches the configured constraints. */ + RTREE_QUEUE_TRACE(pCsr, "POP-Nx:"); + if( pCsr->bAuxValid ){ + pCsr->bAuxValid = 0; + sqlite3_reset(pCsr->pReadAux); + } + rtreeSearchPointPop(pCsr); + rc = rtreeStepToLeaf(pCsr); + return rc; +} + +/* +** Rtree virtual table module xRowid method. +*/ +static int rtreeRowid(sqlite3_vtab_cursor *pVtabCursor, sqlite_int64 *pRowid){ + RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor; + RtreeSearchPoint *p = rtreeSearchPointFirst(pCsr); + int rc = SQLITE_OK; + RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc); + if( rc==SQLITE_OK && ALWAYS(p) ){ + *pRowid = nodeGetRowid(RTREE_OF_CURSOR(pCsr), pNode, p->iCell); + } + return rc; +} + +/* +** Rtree virtual table module xColumn method. +*/ +static int rtreeColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){ + Rtree *pRtree = (Rtree *)cur->pVtab; + RtreeCursor *pCsr = (RtreeCursor *)cur; + RtreeSearchPoint *p = rtreeSearchPointFirst(pCsr); + RtreeCoord c; + int rc = SQLITE_OK; + RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc); + + if( rc ) return rc; + if( NEVER(p==0) ) return SQLITE_OK; + if( i==0 ){ + sqlite3_result_int64(ctx, nodeGetRowid(pRtree, pNode, p->iCell)); + }else if( i<=pRtree->nDim2 ){ + nodeGetCoord(pRtree, pNode, p->iCell, i-1, &c); +#ifndef SQLITE_RTREE_INT_ONLY + if( pRtree->eCoordType==RTREE_COORD_REAL32 ){ + sqlite3_result_double(ctx, c.f); + }else +#endif + { + assert( pRtree->eCoordType==RTREE_COORD_INT32 ); + sqlite3_result_int(ctx, c.i); + } + }else{ + if( !pCsr->bAuxValid ){ + if( pCsr->pReadAux==0 ){ + rc = sqlite3_prepare_v3(pRtree->db, pRtree->zReadAuxSql, -1, 0, + &pCsr->pReadAux, 0); + if( rc ) return rc; + } + sqlite3_bind_int64(pCsr->pReadAux, 1, + nodeGetRowid(pRtree, pNode, p->iCell)); + rc = sqlite3_step(pCsr->pReadAux); + if( rc==SQLITE_ROW ){ + pCsr->bAuxValid = 1; + }else{ + sqlite3_reset(pCsr->pReadAux); + if( rc==SQLITE_DONE ) rc = SQLITE_OK; + return rc; + } + } + sqlite3_result_value(ctx, + sqlite3_column_value(pCsr->pReadAux, i - pRtree->nDim2 + 1)); + } + return SQLITE_OK; +} + +/* +** Use nodeAcquire() to obtain the leaf node containing the record with +** rowid iRowid. If successful, set *ppLeaf to point to the node and +** return SQLITE_OK. If there is no such record in the table, set +** *ppLeaf to 0 and return SQLITE_OK. If an error occurs, set *ppLeaf +** to zero and return an SQLite error code. +*/ +static int findLeafNode( + Rtree *pRtree, /* RTree to search */ + i64 iRowid, /* The rowid searching for */ + RtreeNode **ppLeaf, /* Write the node here */ + sqlite3_int64 *piNode /* Write the node-id here */ +){ + int rc; + *ppLeaf = 0; + sqlite3_bind_int64(pRtree->pReadRowid, 1, iRowid); + if( sqlite3_step(pRtree->pReadRowid)==SQLITE_ROW ){ + i64 iNode = sqlite3_column_int64(pRtree->pReadRowid, 0); + if( piNode ) *piNode = iNode; + rc = nodeAcquire(pRtree, iNode, 0, ppLeaf); + sqlite3_reset(pRtree->pReadRowid); + }else{ + rc = sqlite3_reset(pRtree->pReadRowid); + } + return rc; +} + +/* +** This function is called to configure the RtreeConstraint object passed +** as the second argument for a MATCH constraint. The value passed as the +** first argument to this function is the right-hand operand to the MATCH +** operator. +*/ +static int deserializeGeometry(sqlite3_value *pValue, RtreeConstraint *pCons){ + RtreeMatchArg *pBlob, *pSrc; /* BLOB returned by geometry function */ + sqlite3_rtree_query_info *pInfo; /* Callback information */ + + pSrc = sqlite3_value_pointer(pValue, "RtreeMatchArg"); + if( pSrc==0 ) return SQLITE_ERROR; + pInfo = (sqlite3_rtree_query_info*) + sqlite3_malloc64( sizeof(*pInfo)+pSrc->iSize ); + if( !pInfo ) return SQLITE_NOMEM; + memset(pInfo, 0, sizeof(*pInfo)); + pBlob = (RtreeMatchArg*)&pInfo[1]; + memcpy(pBlob, pSrc, pSrc->iSize); + pInfo->pContext = pBlob->cb.pContext; + pInfo->nParam = pBlob->nParam; + pInfo->aParam = pBlob->aParam; + pInfo->apSqlParam = pBlob->apSqlParam; + + if( pBlob->cb.xGeom ){ + pCons->u.xGeom = pBlob->cb.xGeom; + }else{ + pCons->op = RTREE_QUERY; + pCons->u.xQueryFunc = pBlob->cb.xQueryFunc; + } + pCons->pInfo = pInfo; + return SQLITE_OK; +} + +/* +** Rtree virtual table module xFilter method. +*/ +static int rtreeFilter( + sqlite3_vtab_cursor *pVtabCursor, + int idxNum, const char *idxStr, + int argc, sqlite3_value **argv +){ + Rtree *pRtree = (Rtree *)pVtabCursor->pVtab; + RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor; + RtreeNode *pRoot = 0; + int ii; + int rc = SQLITE_OK; + int iCell = 0; + + rtreeReference(pRtree); + + /* Reset the cursor to the same state as rtreeOpen() leaves it in. */ + resetCursor(pCsr); + + pCsr->iStrategy = idxNum; + if( idxNum==1 ){ + /* Special case - lookup by rowid. */ + RtreeNode *pLeaf; /* Leaf on which the required cell resides */ + RtreeSearchPoint *p; /* Search point for the leaf */ + i64 iRowid = sqlite3_value_int64(argv[0]); + i64 iNode = 0; + int eType = sqlite3_value_numeric_type(argv[0]); + if( eType==SQLITE_INTEGER + || (eType==SQLITE_FLOAT && sqlite3_value_double(argv[0])==iRowid) + ){ + rc = findLeafNode(pRtree, iRowid, &pLeaf, &iNode); + }else{ + rc = SQLITE_OK; + pLeaf = 0; + } + if( rc==SQLITE_OK && pLeaf!=0 ){ + p = rtreeSearchPointNew(pCsr, RTREE_ZERO, 0); + assert( p!=0 ); /* Always returns pCsr->sPoint */ + pCsr->aNode[0] = pLeaf; + p->id = iNode; + p->eWithin = PARTLY_WITHIN; + rc = nodeRowidIndex(pRtree, pLeaf, iRowid, &iCell); + p->iCell = (u8)iCell; + RTREE_QUEUE_TRACE(pCsr, "PUSH-F1:"); + }else{ + pCsr->atEOF = 1; + } + }else{ + /* Normal case - r-tree scan. Set up the RtreeCursor.aConstraint array + ** with the configured constraints. + */ + rc = nodeAcquire(pRtree, 1, 0, &pRoot); + if( rc==SQLITE_OK && argc>0 ){ + pCsr->aConstraint = sqlite3_malloc64(sizeof(RtreeConstraint)*argc); + pCsr->nConstraint = argc; + if( !pCsr->aConstraint ){ + rc = SQLITE_NOMEM; + }else{ + memset(pCsr->aConstraint, 0, sizeof(RtreeConstraint)*argc); + memset(pCsr->anQueue, 0, sizeof(u32)*(pRtree->iDepth + 1)); + assert( (idxStr==0 && argc==0) + || (idxStr && (int)strlen(idxStr)==argc*2) ); + for(ii=0; iiaConstraint[ii]; + int eType = sqlite3_value_numeric_type(argv[ii]); + p->op = idxStr[ii*2]; + p->iCoord = idxStr[ii*2+1]-'0'; + if( p->op>=RTREE_MATCH ){ + /* A MATCH operator. The right-hand-side must be a blob that + ** can be cast into an RtreeMatchArg object. One created using + ** an sqlite3_rtree_geometry_callback() SQL user function. + */ + rc = deserializeGeometry(argv[ii], p); + if( rc!=SQLITE_OK ){ + break; + } + p->pInfo->nCoord = pRtree->nDim2; + p->pInfo->anQueue = pCsr->anQueue; + p->pInfo->mxLevel = pRtree->iDepth + 1; + }else if( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT ){ +#ifdef SQLITE_RTREE_INT_ONLY + p->u.rValue = sqlite3_value_int64(argv[ii]); +#else + p->u.rValue = sqlite3_value_double(argv[ii]); +#endif + }else{ + p->u.rValue = RTREE_ZERO; + if( eType==SQLITE_NULL ){ + p->op = RTREE_FALSE; + }else if( p->op==RTREE_LT || p->op==RTREE_LE ){ + p->op = RTREE_TRUE; + }else{ + p->op = RTREE_FALSE; + } + } + } + } + } + if( rc==SQLITE_OK ){ + RtreeSearchPoint *pNew; + assert( pCsr->bPoint==0 ); /* Due to the resetCursor() call above */ + pNew = rtreeSearchPointNew(pCsr, RTREE_ZERO, (u8)(pRtree->iDepth+1)); + if( NEVER(pNew==0) ){ /* Because pCsr->bPoint was FALSE */ + return SQLITE_NOMEM; + } + pNew->id = 1; + pNew->iCell = 0; + pNew->eWithin = PARTLY_WITHIN; + assert( pCsr->bPoint==1 ); + pCsr->aNode[0] = pRoot; + pRoot = 0; + RTREE_QUEUE_TRACE(pCsr, "PUSH-Fm:"); + rc = rtreeStepToLeaf(pCsr); + } + } + + nodeRelease(pRtree, pRoot); + rtreeRelease(pRtree); + return rc; +} + +/* +** Rtree virtual table module xBestIndex method. There are three +** table scan strategies to choose from (in order from most to +** least desirable): +** +** idxNum idxStr Strategy +** ------------------------------------------------ +** 1 Unused Direct lookup by rowid. +** 2 See below R-tree query or full-table scan. +** ------------------------------------------------ +** +** If strategy 1 is used, then idxStr is not meaningful. If strategy +** 2 is used, idxStr is formatted to contain 2 bytes for each +** constraint used. The first two bytes of idxStr correspond to +** the constraint in sqlite3_index_info.aConstraintUsage[] with +** (argvIndex==1) etc. +** +** The first of each pair of bytes in idxStr identifies the constraint +** operator as follows: +** +** Operator Byte Value +** ---------------------- +** = 0x41 ('A') +** <= 0x42 ('B') +** < 0x43 ('C') +** >= 0x44 ('D') +** > 0x45 ('E') +** MATCH 0x46 ('F') +** ---------------------- +** +** The second of each pair of bytes identifies the coordinate column +** to which the constraint applies. The leftmost coordinate column +** is 'a', the second from the left 'b' etc. +*/ +static int rtreeBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){ + Rtree *pRtree = (Rtree*)tab; + int rc = SQLITE_OK; + int ii; + int bMatch = 0; /* True if there exists a MATCH constraint */ + i64 nRow; /* Estimated rows returned by this scan */ + + int iIdx = 0; + char zIdxStr[RTREE_MAX_DIMENSIONS*8+1]; + memset(zIdxStr, 0, sizeof(zIdxStr)); + + /* Check if there exists a MATCH constraint - even an unusable one. If there + ** is, do not consider the lookup-by-rowid plan as using such a plan would + ** require the VDBE to evaluate the MATCH constraint, which is not currently + ** possible. */ + for(ii=0; iinConstraint; ii++){ + if( pIdxInfo->aConstraint[ii].op==SQLITE_INDEX_CONSTRAINT_MATCH ){ + bMatch = 1; + } + } + + assert( pIdxInfo->idxStr==0 ); + for(ii=0; iinConstraint && iIdx<(int)(sizeof(zIdxStr)-1); ii++){ + struct sqlite3_index_constraint *p = &pIdxInfo->aConstraint[ii]; + + if( bMatch==0 && p->usable + && p->iColumn<=0 && p->op==SQLITE_INDEX_CONSTRAINT_EQ + ){ + /* We have an equality constraint on the rowid. Use strategy 1. */ + int jj; + for(jj=0; jjaConstraintUsage[jj].argvIndex = 0; + pIdxInfo->aConstraintUsage[jj].omit = 0; + } + pIdxInfo->idxNum = 1; + pIdxInfo->aConstraintUsage[ii].argvIndex = 1; + pIdxInfo->aConstraintUsage[jj].omit = 1; + + /* This strategy involves a two rowid lookups on an B-Tree structures + ** and then a linear search of an R-Tree node. This should be + ** considered almost as quick as a direct rowid lookup (for which + ** sqlite uses an internal cost of 0.0). It is expected to return + ** a single row. + */ + pIdxInfo->estimatedCost = 30.0; + pIdxInfo->estimatedRows = 1; + pIdxInfo->idxFlags = SQLITE_INDEX_SCAN_UNIQUE; + return SQLITE_OK; + } + + if( p->usable + && ((p->iColumn>0 && p->iColumn<=pRtree->nDim2) + || p->op==SQLITE_INDEX_CONSTRAINT_MATCH) + ){ + u8 op; + switch( p->op ){ + case SQLITE_INDEX_CONSTRAINT_EQ: op = RTREE_EQ; break; + case SQLITE_INDEX_CONSTRAINT_GT: op = RTREE_GT; break; + case SQLITE_INDEX_CONSTRAINT_LE: op = RTREE_LE; break; + case SQLITE_INDEX_CONSTRAINT_LT: op = RTREE_LT; break; + case SQLITE_INDEX_CONSTRAINT_GE: op = RTREE_GE; break; + case SQLITE_INDEX_CONSTRAINT_MATCH: op = RTREE_MATCH; break; + default: op = 0; break; + } + if( op ){ + zIdxStr[iIdx++] = op; + zIdxStr[iIdx++] = (char)(p->iColumn - 1 + '0'); + pIdxInfo->aConstraintUsage[ii].argvIndex = (iIdx/2); + pIdxInfo->aConstraintUsage[ii].omit = 1; + } + } + } + + pIdxInfo->idxNum = 2; + pIdxInfo->needToFreeIdxStr = 1; + if( iIdx>0 && 0==(pIdxInfo->idxStr = sqlite3_mprintf("%s", zIdxStr)) ){ + return SQLITE_NOMEM; + } + + nRow = pRtree->nRowEst >> (iIdx/2); + pIdxInfo->estimatedCost = (double)6.0 * (double)nRow; + pIdxInfo->estimatedRows = nRow; + + return rc; +} + +/* +** Return the N-dimensional volumn of the cell stored in *p. +*/ +static RtreeDValue cellArea(Rtree *pRtree, RtreeCell *p){ + RtreeDValue area = (RtreeDValue)1; + assert( pRtree->nDim>=1 && pRtree->nDim<=5 ); +#ifndef SQLITE_RTREE_INT_ONLY + if( pRtree->eCoordType==RTREE_COORD_REAL32 ){ + switch( pRtree->nDim ){ + case 5: area = p->aCoord[9].f - p->aCoord[8].f; + case 4: area *= p->aCoord[7].f - p->aCoord[6].f; + case 3: area *= p->aCoord[5].f - p->aCoord[4].f; + case 2: area *= p->aCoord[3].f - p->aCoord[2].f; + default: area *= p->aCoord[1].f - p->aCoord[0].f; + } + }else +#endif + { + switch( pRtree->nDim ){ + case 5: area = (i64)p->aCoord[9].i - (i64)p->aCoord[8].i; + case 4: area *= (i64)p->aCoord[7].i - (i64)p->aCoord[6].i; + case 3: area *= (i64)p->aCoord[5].i - (i64)p->aCoord[4].i; + case 2: area *= (i64)p->aCoord[3].i - (i64)p->aCoord[2].i; + default: area *= (i64)p->aCoord[1].i - (i64)p->aCoord[0].i; + } + } + return area; +} + +/* +** Return the margin length of cell p. The margin length is the sum +** of the objects size in each dimension. +*/ +static RtreeDValue cellMargin(Rtree *pRtree, RtreeCell *p){ + RtreeDValue margin = 0; + int ii = pRtree->nDim2 - 2; + do{ + margin += (DCOORD(p->aCoord[ii+1]) - DCOORD(p->aCoord[ii])); + ii -= 2; + }while( ii>=0 ); + return margin; +} + +/* +** Store the union of cells p1 and p2 in p1. +*/ +static void cellUnion(Rtree *pRtree, RtreeCell *p1, RtreeCell *p2){ + int ii = 0; + if( pRtree->eCoordType==RTREE_COORD_REAL32 ){ + do{ + p1->aCoord[ii].f = MIN(p1->aCoord[ii].f, p2->aCoord[ii].f); + p1->aCoord[ii+1].f = MAX(p1->aCoord[ii+1].f, p2->aCoord[ii+1].f); + ii += 2; + }while( iinDim2 ); + }else{ + do{ + p1->aCoord[ii].i = MIN(p1->aCoord[ii].i, p2->aCoord[ii].i); + p1->aCoord[ii+1].i = MAX(p1->aCoord[ii+1].i, p2->aCoord[ii+1].i); + ii += 2; + }while( iinDim2 ); + } +} + +/* +** Return true if the area covered by p2 is a subset of the area covered +** by p1. False otherwise. +*/ +static int cellContains(Rtree *pRtree, RtreeCell *p1, RtreeCell *p2){ + int ii; + int isInt = (pRtree->eCoordType==RTREE_COORD_INT32); + for(ii=0; iinDim2; ii+=2){ + RtreeCoord *a1 = &p1->aCoord[ii]; + RtreeCoord *a2 = &p2->aCoord[ii]; + if( (!isInt && (a2[0].fa1[1].f)) + || ( isInt && (a2[0].ia1[1].i)) + ){ + return 0; + } + } + return 1; +} + +/* +** Return the amount cell p would grow by if it were unioned with pCell. +*/ +static RtreeDValue cellGrowth(Rtree *pRtree, RtreeCell *p, RtreeCell *pCell){ + RtreeDValue area; + RtreeCell cell; + memcpy(&cell, p, sizeof(RtreeCell)); + area = cellArea(pRtree, &cell); + cellUnion(pRtree, &cell, pCell); + return (cellArea(pRtree, &cell)-area); +} + +static RtreeDValue cellOverlap( + Rtree *pRtree, + RtreeCell *p, + RtreeCell *aCell, + int nCell +){ + int ii; + RtreeDValue overlap = RTREE_ZERO; + for(ii=0; iinDim2; jj+=2){ + RtreeDValue x1, x2; + x1 = MAX(DCOORD(p->aCoord[jj]), DCOORD(aCell[ii].aCoord[jj])); + x2 = MIN(DCOORD(p->aCoord[jj+1]), DCOORD(aCell[ii].aCoord[jj+1])); + if( x2iDepth-iHeight); ii++){ + int iCell; + sqlite3_int64 iBest = 0; + + RtreeDValue fMinGrowth = RTREE_ZERO; + RtreeDValue fMinArea = RTREE_ZERO; + + int nCell = NCELL(pNode); + RtreeCell cell; + RtreeNode *pChild = 0; + + RtreeCell *aCell = 0; + + /* Select the child node which will be enlarged the least if pCell + ** is inserted into it. Resolve ties by choosing the entry with + ** the smallest area. + */ + for(iCell=0; iCellpParent ){ + RtreeNode *pParent = p->pParent; + RtreeCell cell; + int iCell; + + cnt++; + if( NEVER(cnt>100) ){ + RTREE_IS_CORRUPT(pRtree); + return SQLITE_CORRUPT_VTAB; + } + rc = nodeParentIndex(pRtree, p, &iCell); + if( NEVER(rc!=SQLITE_OK) ){ + RTREE_IS_CORRUPT(pRtree); + return SQLITE_CORRUPT_VTAB; + } + + nodeGetCell(pRtree, pParent, iCell, &cell); + if( !cellContains(pRtree, &cell, pCell) ){ + cellUnion(pRtree, &cell, pCell); + nodeOverwriteCell(pRtree, pParent, &cell, iCell); + } + + p = pParent; + } + return SQLITE_OK; +} + +/* +** Write mapping (iRowid->iNode) to the _rowid table. +*/ +static int rowidWrite(Rtree *pRtree, sqlite3_int64 iRowid, sqlite3_int64 iNode){ + sqlite3_bind_int64(pRtree->pWriteRowid, 1, iRowid); + sqlite3_bind_int64(pRtree->pWriteRowid, 2, iNode); + sqlite3_step(pRtree->pWriteRowid); + return sqlite3_reset(pRtree->pWriteRowid); +} + +/* +** Write mapping (iNode->iPar) to the _parent table. +*/ +static int parentWrite(Rtree *pRtree, sqlite3_int64 iNode, sqlite3_int64 iPar){ + sqlite3_bind_int64(pRtree->pWriteParent, 1, iNode); + sqlite3_bind_int64(pRtree->pWriteParent, 2, iPar); + sqlite3_step(pRtree->pWriteParent); + return sqlite3_reset(pRtree->pWriteParent); +} + +static int rtreeInsertCell(Rtree *, RtreeNode *, RtreeCell *, int); + + +/* +** Arguments aIdx, aDistance and aSpare all point to arrays of size +** nIdx. The aIdx array contains the set of integers from 0 to +** (nIdx-1) in no particular order. This function sorts the values +** in aIdx according to the indexed values in aDistance. For +** example, assuming the inputs: +** +** aIdx = { 0, 1, 2, 3 } +** aDistance = { 5.0, 2.0, 7.0, 6.0 } +** +** this function sets the aIdx array to contain: +** +** aIdx = { 0, 1, 2, 3 } +** +** The aSpare array is used as temporary working space by the +** sorting algorithm. +*/ +static void SortByDistance( + int *aIdx, + int nIdx, + RtreeDValue *aDistance, + int *aSpare +){ + if( nIdx>1 ){ + int iLeft = 0; + int iRight = 0; + + int nLeft = nIdx/2; + int nRight = nIdx-nLeft; + int *aLeft = aIdx; + int *aRight = &aIdx[nLeft]; + + SortByDistance(aLeft, nLeft, aDistance, aSpare); + SortByDistance(aRight, nRight, aDistance, aSpare); + + memcpy(aSpare, aLeft, sizeof(int)*nLeft); + aLeft = aSpare; + + while( iLeft1 ){ + + int iLeft = 0; + int iRight = 0; + + int nLeft = nIdx/2; + int nRight = nIdx-nLeft; + int *aLeft = aIdx; + int *aRight = &aIdx[nLeft]; + + SortByDimension(pRtree, aLeft, nLeft, iDim, aCell, aSpare); + SortByDimension(pRtree, aRight, nRight, iDim, aCell, aSpare); + + memcpy(aSpare, aLeft, sizeof(int)*nLeft); + aLeft = aSpare; + while( iLeftnDim+1)*(sizeof(int*)+nCell*sizeof(int)); + + aaSorted = (int **)sqlite3_malloc64(nByte); + if( !aaSorted ){ + return SQLITE_NOMEM; + } + + aSpare = &((int *)&aaSorted[pRtree->nDim])[pRtree->nDim*nCell]; + memset(aaSorted, 0, nByte); + for(ii=0; iinDim; ii++){ + int jj; + aaSorted[ii] = &((int *)&aaSorted[pRtree->nDim])[ii*nCell]; + for(jj=0; jjnDim; ii++){ + RtreeDValue margin = RTREE_ZERO; + RtreeDValue fBestOverlap = RTREE_ZERO; + RtreeDValue fBestArea = RTREE_ZERO; + int iBestLeft = 0; + int nLeft; + + for( + nLeft=RTREE_MINCELLS(pRtree); + nLeft<=(nCell-RTREE_MINCELLS(pRtree)); + nLeft++ + ){ + RtreeCell left; + RtreeCell right; + int kk; + RtreeDValue overlap; + RtreeDValue area; + + memcpy(&left, &aCell[aaSorted[ii][0]], sizeof(RtreeCell)); + memcpy(&right, &aCell[aaSorted[ii][nCell-1]], sizeof(RtreeCell)); + for(kk=1; kk<(nCell-1); kk++){ + if( kk0 ){ + RtreeNode *pChild = nodeHashLookup(pRtree, iRowid); + RtreeNode *p; + for(p=pNode; p; p=p->pParent){ + if( p==pChild ) return SQLITE_CORRUPT_VTAB; + } + if( pChild ){ + nodeRelease(pRtree, pChild->pParent); + nodeReference(pNode); + pChild->pParent = pNode; + } + } + if( NEVER(pNode==0) ) return SQLITE_ERROR; + return xSetMapping(pRtree, iRowid, pNode->iNode); +} + +static int SplitNode( + Rtree *pRtree, + RtreeNode *pNode, + RtreeCell *pCell, + int iHeight +){ + int i; + int newCellIsRight = 0; + + int rc = SQLITE_OK; + int nCell = NCELL(pNode); + RtreeCell *aCell; + int *aiUsed; + + RtreeNode *pLeft = 0; + RtreeNode *pRight = 0; + + RtreeCell leftbbox; + RtreeCell rightbbox; + + /* Allocate an array and populate it with a copy of pCell and + ** all cells from node pLeft. Then zero the original node. + */ + aCell = sqlite3_malloc64((sizeof(RtreeCell)+sizeof(int))*(nCell+1)); + if( !aCell ){ + rc = SQLITE_NOMEM; + goto splitnode_out; + } + aiUsed = (int *)&aCell[nCell+1]; + memset(aiUsed, 0, sizeof(int)*(nCell+1)); + for(i=0; iiNode==1 ){ + pRight = nodeNew(pRtree, pNode); + pLeft = nodeNew(pRtree, pNode); + pRtree->iDepth++; + pNode->isDirty = 1; + writeInt16(pNode->zData, pRtree->iDepth); + }else{ + pLeft = pNode; + pRight = nodeNew(pRtree, pLeft->pParent); + pLeft->nRef++; + } + + if( !pLeft || !pRight ){ + rc = SQLITE_NOMEM; + goto splitnode_out; + } + + memset(pLeft->zData, 0, pRtree->iNodeSize); + memset(pRight->zData, 0, pRtree->iNodeSize); + + rc = splitNodeStartree(pRtree, aCell, nCell, pLeft, pRight, + &leftbbox, &rightbbox); + if( rc!=SQLITE_OK ){ + goto splitnode_out; + } + + /* Ensure both child nodes have node numbers assigned to them by calling + ** nodeWrite(). Node pRight always needs a node number, as it was created + ** by nodeNew() above. But node pLeft sometimes already has a node number. + ** In this case avoid the all to nodeWrite(). + */ + if( SQLITE_OK!=(rc = nodeWrite(pRtree, pRight)) + || (0==pLeft->iNode && SQLITE_OK!=(rc = nodeWrite(pRtree, pLeft))) + ){ + goto splitnode_out; + } + + rightbbox.iRowid = pRight->iNode; + leftbbox.iRowid = pLeft->iNode; + + if( pNode->iNode==1 ){ + rc = rtreeInsertCell(pRtree, pLeft->pParent, &leftbbox, iHeight+1); + if( rc!=SQLITE_OK ){ + goto splitnode_out; + } + }else{ + RtreeNode *pParent = pLeft->pParent; + int iCell; + rc = nodeParentIndex(pRtree, pLeft, &iCell); + if( ALWAYS(rc==SQLITE_OK) ){ + nodeOverwriteCell(pRtree, pParent, &leftbbox, iCell); + rc = AdjustTree(pRtree, pParent, &leftbbox); + assert( rc==SQLITE_OK ); + } + if( NEVER(rc!=SQLITE_OK) ){ + goto splitnode_out; + } + } + if( (rc = rtreeInsertCell(pRtree, pRight->pParent, &rightbbox, iHeight+1)) ){ + goto splitnode_out; + } + + for(i=0; iiRowid ){ + newCellIsRight = 1; + } + if( rc!=SQLITE_OK ){ + goto splitnode_out; + } + } + if( pNode->iNode==1 ){ + for(i=0; iiRowid, pLeft, iHeight); + } + + if( rc==SQLITE_OK ){ + rc = nodeRelease(pRtree, pRight); + pRight = 0; + } + if( rc==SQLITE_OK ){ + rc = nodeRelease(pRtree, pLeft); + pLeft = 0; + } + +splitnode_out: + nodeRelease(pRtree, pRight); + nodeRelease(pRtree, pLeft); + sqlite3_free(aCell); + return rc; +} + +/* +** If node pLeaf is not the root of the r-tree and its pParent pointer is +** still NULL, load all ancestor nodes of pLeaf into memory and populate +** the pLeaf->pParent chain all the way up to the root node. +** +** This operation is required when a row is deleted (or updated - an update +** is implemented as a delete followed by an insert). SQLite provides the +** rowid of the row to delete, which can be used to find the leaf on which +** the entry resides (argument pLeaf). Once the leaf is located, this +** function is called to determine its ancestry. +*/ +static int fixLeafParent(Rtree *pRtree, RtreeNode *pLeaf){ + int rc = SQLITE_OK; + RtreeNode *pChild = pLeaf; + while( rc==SQLITE_OK && pChild->iNode!=1 && pChild->pParent==0 ){ + int rc2 = SQLITE_OK; /* sqlite3_reset() return code */ + sqlite3_bind_int64(pRtree->pReadParent, 1, pChild->iNode); + rc = sqlite3_step(pRtree->pReadParent); + if( rc==SQLITE_ROW ){ + RtreeNode *pTest; /* Used to test for reference loops */ + i64 iNode; /* Node number of parent node */ + + /* Before setting pChild->pParent, test that we are not creating a + ** loop of references (as we would if, say, pChild==pParent). We don't + ** want to do this as it leads to a memory leak when trying to delete + ** the referenced counted node structures. + */ + iNode = sqlite3_column_int64(pRtree->pReadParent, 0); + for(pTest=pLeaf; pTest && pTest->iNode!=iNode; pTest=pTest->pParent); + if( pTest==0 ){ + rc2 = nodeAcquire(pRtree, iNode, 0, &pChild->pParent); + } + } + rc = sqlite3_reset(pRtree->pReadParent); + if( rc==SQLITE_OK ) rc = rc2; + if( rc==SQLITE_OK && !pChild->pParent ){ + RTREE_IS_CORRUPT(pRtree); + rc = SQLITE_CORRUPT_VTAB; + } + pChild = pChild->pParent; + } + return rc; +} + +static int deleteCell(Rtree *, RtreeNode *, int, int); + +static int removeNode(Rtree *pRtree, RtreeNode *pNode, int iHeight){ + int rc; + int rc2; + RtreeNode *pParent = 0; + int iCell; + + assert( pNode->nRef==1 ); + + /* Remove the entry in the parent cell. */ + rc = nodeParentIndex(pRtree, pNode, &iCell); + if( rc==SQLITE_OK ){ + pParent = pNode->pParent; + pNode->pParent = 0; + rc = deleteCell(pRtree, pParent, iCell, iHeight+1); + testcase( rc!=SQLITE_OK ); + } + rc2 = nodeRelease(pRtree, pParent); + if( rc==SQLITE_OK ){ + rc = rc2; + } + if( rc!=SQLITE_OK ){ + return rc; + } + + /* Remove the xxx_node entry. */ + sqlite3_bind_int64(pRtree->pDeleteNode, 1, pNode->iNode); + sqlite3_step(pRtree->pDeleteNode); + if( SQLITE_OK!=(rc = sqlite3_reset(pRtree->pDeleteNode)) ){ + return rc; + } + + /* Remove the xxx_parent entry. */ + sqlite3_bind_int64(pRtree->pDeleteParent, 1, pNode->iNode); + sqlite3_step(pRtree->pDeleteParent); + if( SQLITE_OK!=(rc = sqlite3_reset(pRtree->pDeleteParent)) ){ + return rc; + } + + /* Remove the node from the in-memory hash table and link it into + ** the Rtree.pDeleted list. Its contents will be re-inserted later on. + */ + nodeHashDelete(pRtree, pNode); + pNode->iNode = iHeight; + pNode->pNext = pRtree->pDeleted; + pNode->nRef++; + pRtree->pDeleted = pNode; + + return SQLITE_OK; +} + +static int fixBoundingBox(Rtree *pRtree, RtreeNode *pNode){ + RtreeNode *pParent = pNode->pParent; + int rc = SQLITE_OK; + if( pParent ){ + int ii; + int nCell = NCELL(pNode); + RtreeCell box; /* Bounding box for pNode */ + nodeGetCell(pRtree, pNode, 0, &box); + for(ii=1; iiiNode; + rc = nodeParentIndex(pRtree, pNode, &ii); + if( rc==SQLITE_OK ){ + nodeOverwriteCell(pRtree, pParent, &box, ii); + rc = fixBoundingBox(pRtree, pParent); + } + } + return rc; +} + +/* +** Delete the cell at index iCell of node pNode. After removing the +** cell, adjust the r-tree data structure if required. +*/ +static int deleteCell(Rtree *pRtree, RtreeNode *pNode, int iCell, int iHeight){ + RtreeNode *pParent; + int rc; + + if( SQLITE_OK!=(rc = fixLeafParent(pRtree, pNode)) ){ + return rc; + } + + /* Remove the cell from the node. This call just moves bytes around + ** the in-memory node image, so it cannot fail. + */ + nodeDeleteCell(pRtree, pNode, iCell); + + /* If the node is not the tree root and now has less than the minimum + ** number of cells, remove it from the tree. Otherwise, update the + ** cell in the parent node so that it tightly contains the updated + ** node. + */ + pParent = pNode->pParent; + assert( pParent || pNode->iNode==1 ); + if( pParent ){ + if( NCELL(pNode)nDim; iDim++){ + aCenterCoord[iDim] += DCOORD(aCell[ii].aCoord[iDim*2]); + aCenterCoord[iDim] += DCOORD(aCell[ii].aCoord[iDim*2+1]); + } + } + for(iDim=0; iDimnDim; iDim++){ + aCenterCoord[iDim] = (aCenterCoord[iDim]/(nCell*(RtreeDValue)2)); + } + + for(ii=0; iinDim; iDim++){ + RtreeDValue coord = (DCOORD(aCell[ii].aCoord[iDim*2+1]) - + DCOORD(aCell[ii].aCoord[iDim*2])); + aDistance[ii] += (coord-aCenterCoord[iDim])*(coord-aCenterCoord[iDim]); + } + } + + SortByDistance(aOrder, nCell, aDistance, aSpare); + nodeZero(pRtree, pNode); + + for(ii=0; rc==SQLITE_OK && ii<(nCell-(RTREE_MINCELLS(pRtree)+1)); ii++){ + RtreeCell *p = &aCell[aOrder[ii]]; + nodeInsertCell(pRtree, pNode, p); + if( p->iRowid==pCell->iRowid ){ + if( iHeight==0 ){ + rc = rowidWrite(pRtree, p->iRowid, pNode->iNode); + }else{ + rc = parentWrite(pRtree, p->iRowid, pNode->iNode); + } + } + } + if( rc==SQLITE_OK ){ + rc = fixBoundingBox(pRtree, pNode); + } + for(; rc==SQLITE_OK && iiiNode currently contains + ** the height of the sub-tree headed by the cell. + */ + RtreeNode *pInsert; + RtreeCell *p = &aCell[aOrder[ii]]; + rc = ChooseLeaf(pRtree, p, iHeight, &pInsert); + if( rc==SQLITE_OK ){ + int rc2; + rc = rtreeInsertCell(pRtree, pInsert, p, iHeight); + rc2 = nodeRelease(pRtree, pInsert); + if( rc==SQLITE_OK ){ + rc = rc2; + } + } + } + + sqlite3_free(aCell); + return rc; +} + +/* +** Insert cell pCell into node pNode. Node pNode is the head of a +** subtree iHeight high (leaf nodes have iHeight==0). +*/ +static int rtreeInsertCell( + Rtree *pRtree, + RtreeNode *pNode, + RtreeCell *pCell, + int iHeight +){ + int rc = SQLITE_OK; + if( iHeight>0 ){ + RtreeNode *pChild = nodeHashLookup(pRtree, pCell->iRowid); + if( pChild ){ + nodeRelease(pRtree, pChild->pParent); + nodeReference(pNode); + pChild->pParent = pNode; + } + } + if( nodeInsertCell(pRtree, pNode, pCell) ){ + if( iHeight<=pRtree->iReinsertHeight || pNode->iNode==1){ + rc = SplitNode(pRtree, pNode, pCell, iHeight); + }else{ + pRtree->iReinsertHeight = iHeight; + rc = Reinsert(pRtree, pNode, pCell, iHeight); + } + }else{ + rc = AdjustTree(pRtree, pNode, pCell); + if( ALWAYS(rc==SQLITE_OK) ){ + if( iHeight==0 ){ + rc = rowidWrite(pRtree, pCell->iRowid, pNode->iNode); + }else{ + rc = parentWrite(pRtree, pCell->iRowid, pNode->iNode); + } + } + } + return rc; +} + +static int reinsertNodeContent(Rtree *pRtree, RtreeNode *pNode){ + int ii; + int rc = SQLITE_OK; + int nCell = NCELL(pNode); + + for(ii=0; rc==SQLITE_OK && iiiNode currently contains + ** the height of the sub-tree headed by the cell. + */ + rc = ChooseLeaf(pRtree, &cell, (int)pNode->iNode, &pInsert); + if( rc==SQLITE_OK ){ + int rc2; + rc = rtreeInsertCell(pRtree, pInsert, &cell, (int)pNode->iNode); + rc2 = nodeRelease(pRtree, pInsert); + if( rc==SQLITE_OK ){ + rc = rc2; + } + } + } + return rc; +} + +/* +** Select a currently unused rowid for a new r-tree record. +*/ +static int rtreeNewRowid(Rtree *pRtree, i64 *piRowid){ + int rc; + sqlite3_bind_null(pRtree->pWriteRowid, 1); + sqlite3_bind_null(pRtree->pWriteRowid, 2); + sqlite3_step(pRtree->pWriteRowid); + rc = sqlite3_reset(pRtree->pWriteRowid); + *piRowid = sqlite3_last_insert_rowid(pRtree->db); + return rc; +} + +/* +** Remove the entry with rowid=iDelete from the r-tree structure. +*/ +static int rtreeDeleteRowid(Rtree *pRtree, sqlite3_int64 iDelete){ + int rc; /* Return code */ + RtreeNode *pLeaf = 0; /* Leaf node containing record iDelete */ + int iCell; /* Index of iDelete cell in pLeaf */ + RtreeNode *pRoot = 0; /* Root node of rtree structure */ + + + /* Obtain a reference to the root node to initialize Rtree.iDepth */ + rc = nodeAcquire(pRtree, 1, 0, &pRoot); + + /* Obtain a reference to the leaf node that contains the entry + ** about to be deleted. + */ + if( rc==SQLITE_OK ){ + rc = findLeafNode(pRtree, iDelete, &pLeaf, 0); + } + +#ifdef CORRUPT_DB + assert( pLeaf!=0 || rc!=SQLITE_OK || CORRUPT_DB ); +#endif + + /* Delete the cell in question from the leaf node. */ + if( rc==SQLITE_OK && pLeaf ){ + int rc2; + rc = nodeRowidIndex(pRtree, pLeaf, iDelete, &iCell); + if( rc==SQLITE_OK ){ + rc = deleteCell(pRtree, pLeaf, iCell, 0); + } + rc2 = nodeRelease(pRtree, pLeaf); + if( rc==SQLITE_OK ){ + rc = rc2; + } + } + + /* Delete the corresponding entry in the _rowid table. */ + if( rc==SQLITE_OK ){ + sqlite3_bind_int64(pRtree->pDeleteRowid, 1, iDelete); + sqlite3_step(pRtree->pDeleteRowid); + rc = sqlite3_reset(pRtree->pDeleteRowid); + } + + /* Check if the root node now has exactly one child. If so, remove + ** it, schedule the contents of the child for reinsertion and + ** reduce the tree height by one. + ** + ** This is equivalent to copying the contents of the child into + ** the root node (the operation that Gutman's paper says to perform + ** in this scenario). + */ + if( rc==SQLITE_OK && pRtree->iDepth>0 && NCELL(pRoot)==1 ){ + int rc2; + RtreeNode *pChild = 0; + i64 iChild = nodeGetRowid(pRtree, pRoot, 0); + rc = nodeAcquire(pRtree, iChild, pRoot, &pChild); /* tag-20210916a */ + if( rc==SQLITE_OK ){ + rc = removeNode(pRtree, pChild, pRtree->iDepth-1); + } + rc2 = nodeRelease(pRtree, pChild); + if( rc==SQLITE_OK ) rc = rc2; + if( rc==SQLITE_OK ){ + pRtree->iDepth--; + writeInt16(pRoot->zData, pRtree->iDepth); + pRoot->isDirty = 1; + } + } + + /* Re-insert the contents of any underfull nodes removed from the tree. */ + for(pLeaf=pRtree->pDeleted; pLeaf; pLeaf=pRtree->pDeleted){ + if( rc==SQLITE_OK ){ + rc = reinsertNodeContent(pRtree, pLeaf); + } + pRtree->pDeleted = pLeaf->pNext; + pRtree->nNodeRef--; + sqlite3_free(pLeaf); + } + + /* Release the reference to the root node. */ + if( rc==SQLITE_OK ){ + rc = nodeRelease(pRtree, pRoot); + }else{ + nodeRelease(pRtree, pRoot); + } + + return rc; +} + +/* +** Rounding constants for float->double conversion. +*/ +#define RNDTOWARDS (1.0 - 1.0/8388608.0) /* Round towards zero */ +#define RNDAWAY (1.0 + 1.0/8388608.0) /* Round away from zero */ + +#if !defined(SQLITE_RTREE_INT_ONLY) +/* +** Convert an sqlite3_value into an RtreeValue (presumably a float) +** while taking care to round toward negative or positive, respectively. +*/ +static RtreeValue rtreeValueDown(sqlite3_value *v){ + double d = sqlite3_value_double(v); + float f = (float)d; + if( f>d ){ + f = (float)(d*(d<0 ? RNDAWAY : RNDTOWARDS)); + } + return f; +} +static RtreeValue rtreeValueUp(sqlite3_value *v){ + double d = sqlite3_value_double(v); + float f = (float)d; + if( fbase.zErrMsg) to an appropriate value and returns +** SQLITE_CONSTRAINT. +** +** Parameter iCol is the index of the leftmost column involved in the +** constraint failure. If it is 0, then the constraint that failed is +** the unique constraint on the id column. Otherwise, it is the rtree +** (c1<=c2) constraint on columns iCol and iCol+1 that has failed. +** +** If an OOM occurs, SQLITE_NOMEM is returned instead of SQLITE_CONSTRAINT. +*/ +static int rtreeConstraintError(Rtree *pRtree, int iCol){ + sqlite3_stmt *pStmt = 0; + char *zSql; + int rc; + + assert( iCol==0 || iCol%2 ); + zSql = sqlite3_mprintf("SELECT * FROM %Q.%Q", pRtree->zDb, pRtree->zName); + if( zSql ){ + rc = sqlite3_prepare_v2(pRtree->db, zSql, -1, &pStmt, 0); + }else{ + rc = SQLITE_NOMEM; + } + sqlite3_free(zSql); + + if( rc==SQLITE_OK ){ + if( iCol==0 ){ + const char *zCol = sqlite3_column_name(pStmt, 0); + pRtree->base.zErrMsg = sqlite3_mprintf( + "UNIQUE constraint failed: %s.%s", pRtree->zName, zCol + ); + }else{ + const char *zCol1 = sqlite3_column_name(pStmt, iCol); + const char *zCol2 = sqlite3_column_name(pStmt, iCol+1); + pRtree->base.zErrMsg = sqlite3_mprintf( + "rtree constraint failed: %s.(%s<=%s)", pRtree->zName, zCol1, zCol2 + ); + } + } + + sqlite3_finalize(pStmt); + return (rc==SQLITE_OK ? SQLITE_CONSTRAINT : rc); +} + + + +/* +** The xUpdate method for rtree module virtual tables. +*/ +static int rtreeUpdate( + sqlite3_vtab *pVtab, + int nData, + sqlite3_value **aData, + sqlite_int64 *pRowid +){ + Rtree *pRtree = (Rtree *)pVtab; + int rc = SQLITE_OK; + RtreeCell cell; /* New cell to insert if nData>1 */ + int bHaveRowid = 0; /* Set to 1 after new rowid is determined */ + + if( pRtree->nNodeRef ){ + /* Unable to write to the btree while another cursor is reading from it, + ** since the write might do a rebalance which would disrupt the read + ** cursor. */ + return SQLITE_LOCKED_VTAB; + } + rtreeReference(pRtree); + assert(nData>=1); + + memset(&cell, 0, sizeof(cell)); + + /* Constraint handling. A write operation on an r-tree table may return + ** SQLITE_CONSTRAINT for two reasons: + ** + ** 1. A duplicate rowid value, or + ** 2. The supplied data violates the "x2>=x1" constraint. + ** + ** In the first case, if the conflict-handling mode is REPLACE, then + ** the conflicting row can be removed before proceeding. In the second + ** case, SQLITE_CONSTRAINT must be returned regardless of the + ** conflict-handling mode specified by the user. + */ + if( nData>1 ){ + int ii; + int nn = nData - 4; + + if( nn > pRtree->nDim2 ) nn = pRtree->nDim2; + /* Populate the cell.aCoord[] array. The first coordinate is aData[3]. + ** + ** NB: nData can only be less than nDim*2+3 if the rtree is mis-declared + ** with "column" that are interpreted as table constraints. + ** Example: CREATE VIRTUAL TABLE bad USING rtree(x,y,CHECK(y>5)); + ** This problem was discovered after years of use, so we silently ignore + ** these kinds of misdeclared tables to avoid breaking any legacy. + */ + +#ifndef SQLITE_RTREE_INT_ONLY + if( pRtree->eCoordType==RTREE_COORD_REAL32 ){ + for(ii=0; iicell.aCoord[ii+1].f ){ + rc = rtreeConstraintError(pRtree, ii+1); + goto constraint; + } + } + }else +#endif + { + for(ii=0; iicell.aCoord[ii+1].i ){ + rc = rtreeConstraintError(pRtree, ii+1); + goto constraint; + } + } + } + + /* If a rowid value was supplied, check if it is already present in + ** the table. If so, the constraint has failed. */ + if( sqlite3_value_type(aData[2])!=SQLITE_NULL ){ + cell.iRowid = sqlite3_value_int64(aData[2]); + if( sqlite3_value_type(aData[0])==SQLITE_NULL + || sqlite3_value_int64(aData[0])!=cell.iRowid + ){ + int steprc; + sqlite3_bind_int64(pRtree->pReadRowid, 1, cell.iRowid); + steprc = sqlite3_step(pRtree->pReadRowid); + rc = sqlite3_reset(pRtree->pReadRowid); + if( SQLITE_ROW==steprc ){ + if( sqlite3_vtab_on_conflict(pRtree->db)==SQLITE_REPLACE ){ + rc = rtreeDeleteRowid(pRtree, cell.iRowid); + }else{ + rc = rtreeConstraintError(pRtree, 0); + goto constraint; + } + } + } + bHaveRowid = 1; + } + } + + /* If aData[0] is not an SQL NULL value, it is the rowid of a + ** record to delete from the r-tree table. The following block does + ** just that. + */ + if( sqlite3_value_type(aData[0])!=SQLITE_NULL ){ + rc = rtreeDeleteRowid(pRtree, sqlite3_value_int64(aData[0])); + } + + /* If the aData[] array contains more than one element, elements + ** (aData[2]..aData[argc-1]) contain a new record to insert into + ** the r-tree structure. + */ + if( rc==SQLITE_OK && nData>1 ){ + /* Insert the new record into the r-tree */ + RtreeNode *pLeaf = 0; + + /* Figure out the rowid of the new row. */ + if( bHaveRowid==0 ){ + rc = rtreeNewRowid(pRtree, &cell.iRowid); + } + *pRowid = cell.iRowid; + + if( rc==SQLITE_OK ){ + rc = ChooseLeaf(pRtree, &cell, 0, &pLeaf); + } + if( rc==SQLITE_OK ){ + int rc2; + pRtree->iReinsertHeight = -1; + rc = rtreeInsertCell(pRtree, pLeaf, &cell, 0); + rc2 = nodeRelease(pRtree, pLeaf); + if( rc==SQLITE_OK ){ + rc = rc2; + } + } + if( rc==SQLITE_OK && pRtree->nAux ){ + sqlite3_stmt *pUp = pRtree->pWriteAux; + int jj; + sqlite3_bind_int64(pUp, 1, *pRowid); + for(jj=0; jjnAux; jj++){ + sqlite3_bind_value(pUp, jj+2, aData[pRtree->nDim2+3+jj]); + } + sqlite3_step(pUp); + rc = sqlite3_reset(pUp); + } + } + +constraint: + rtreeRelease(pRtree); + return rc; +} + +/* +** Called when a transaction starts. +*/ +static int rtreeBeginTransaction(sqlite3_vtab *pVtab){ + Rtree *pRtree = (Rtree *)pVtab; + assert( pRtree->inWrTrans==0 ); + pRtree->inWrTrans++; + return SQLITE_OK; +} + +/* +** Called when a transaction completes (either by COMMIT or ROLLBACK). +** The sqlite3_blob object should be released at this point. +*/ +static int rtreeEndTransaction(sqlite3_vtab *pVtab){ + Rtree *pRtree = (Rtree *)pVtab; + pRtree->inWrTrans = 0; + nodeBlobReset(pRtree); + return SQLITE_OK; +} + +/* +** The xRename method for rtree module virtual tables. +*/ +static int rtreeRename(sqlite3_vtab *pVtab, const char *zNewName){ + Rtree *pRtree = (Rtree *)pVtab; + int rc = SQLITE_NOMEM; + char *zSql = sqlite3_mprintf( + "ALTER TABLE %Q.'%q_node' RENAME TO \"%w_node\";" + "ALTER TABLE %Q.'%q_parent' RENAME TO \"%w_parent\";" + "ALTER TABLE %Q.'%q_rowid' RENAME TO \"%w_rowid\";" + , pRtree->zDb, pRtree->zName, zNewName + , pRtree->zDb, pRtree->zName, zNewName + , pRtree->zDb, pRtree->zName, zNewName + ); + if( zSql ){ + nodeBlobReset(pRtree); + rc = sqlite3_exec(pRtree->db, zSql, 0, 0, 0); + sqlite3_free(zSql); + } + return rc; +} + +/* +** The xSavepoint method. +** +** This module does not need to do anything to support savepoints. However, +** it uses this hook to close any open blob handle. This is done because a +** DROP TABLE command - which fortunately always opens a savepoint - cannot +** succeed if there are any open blob handles. i.e. if the blob handle were +** not closed here, the following would fail: +** +** BEGIN; +** INSERT INTO rtree... +** DROP TABLE ; -- Would fail with SQLITE_LOCKED +** COMMIT; +*/ +static int rtreeSavepoint(sqlite3_vtab *pVtab, int iSavepoint){ + Rtree *pRtree = (Rtree *)pVtab; + u8 iwt = pRtree->inWrTrans; + UNUSED_PARAMETER(iSavepoint); + pRtree->inWrTrans = 0; + nodeBlobReset(pRtree); + pRtree->inWrTrans = iwt; + return SQLITE_OK; +} + +/* +** This function populates the pRtree->nRowEst variable with an estimate +** of the number of rows in the virtual table. If possible, this is based +** on sqlite_stat1 data. Otherwise, use RTREE_DEFAULT_ROWEST. +*/ +static int rtreeQueryStat1(sqlite3 *db, Rtree *pRtree){ + const char *zFmt = "SELECT stat FROM %Q.sqlite_stat1 WHERE tbl = '%q_rowid'"; + char *zSql; + sqlite3_stmt *p; + int rc; + i64 nRow = RTREE_MIN_ROWEST; + + rc = sqlite3_table_column_metadata( + db, pRtree->zDb, "sqlite_stat1",0,0,0,0,0,0 + ); + if( rc!=SQLITE_OK ){ + pRtree->nRowEst = RTREE_DEFAULT_ROWEST; + return rc==SQLITE_ERROR ? SQLITE_OK : rc; + } + zSql = sqlite3_mprintf(zFmt, pRtree->zDb, pRtree->zName); + if( zSql==0 ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare_v2(db, zSql, -1, &p, 0); + if( rc==SQLITE_OK ){ + if( sqlite3_step(p)==SQLITE_ROW ) nRow = sqlite3_column_int64(p, 0); + rc = sqlite3_finalize(p); + } + sqlite3_free(zSql); + } + pRtree->nRowEst = MAX(nRow, RTREE_MIN_ROWEST); + return rc; +} + + +/* +** Return true if zName is the extension on one of the shadow tables used +** by this module. +*/ +static int rtreeShadowName(const char *zName){ + static const char *azName[] = { + "node", "parent", "rowid" + }; + unsigned int i; + for(i=0; idb = db; + + if( isCreate ){ + char *zCreate; + sqlite3_str *p = sqlite3_str_new(db); + int ii; + sqlite3_str_appendf(p, + "CREATE TABLE \"%w\".\"%w_rowid\"(rowid INTEGER PRIMARY KEY,nodeno", + zDb, zPrefix); + for(ii=0; iinAux; ii++){ + sqlite3_str_appendf(p,",a%d",ii); + } + sqlite3_str_appendf(p, + ");CREATE TABLE \"%w\".\"%w_node\"(nodeno INTEGER PRIMARY KEY,data);", + zDb, zPrefix); + sqlite3_str_appendf(p, + "CREATE TABLE \"%w\".\"%w_parent\"(nodeno INTEGER PRIMARY KEY,parentnode);", + zDb, zPrefix); + sqlite3_str_appendf(p, + "INSERT INTO \"%w\".\"%w_node\"VALUES(1,zeroblob(%d))", + zDb, zPrefix, pRtree->iNodeSize); + zCreate = sqlite3_str_finish(p); + if( !zCreate ){ + return SQLITE_NOMEM; + } + rc = sqlite3_exec(db, zCreate, 0, 0, 0); + sqlite3_free(zCreate); + if( rc!=SQLITE_OK ){ + return rc; + } + } + + appStmt[0] = &pRtree->pWriteNode; + appStmt[1] = &pRtree->pDeleteNode; + appStmt[2] = &pRtree->pReadRowid; + appStmt[3] = &pRtree->pWriteRowid; + appStmt[4] = &pRtree->pDeleteRowid; + appStmt[5] = &pRtree->pReadParent; + appStmt[6] = &pRtree->pWriteParent; + appStmt[7] = &pRtree->pDeleteParent; + + rc = rtreeQueryStat1(db, pRtree); + for(i=0; inAux==0 ){ + zFormat = azSql[i]; + }else { + /* An UPSERT is very slightly slower than REPLACE, but it is needed + ** if there are auxiliary columns */ + zFormat = "INSERT INTO\"%w\".\"%w_rowid\"(rowid,nodeno)VALUES(?1,?2)" + "ON CONFLICT(rowid)DO UPDATE SET nodeno=excluded.nodeno"; + } + zSql = sqlite3_mprintf(zFormat, zDb, zPrefix); + if( zSql ){ + rc = sqlite3_prepare_v3(db, zSql, -1, f, appStmt[i], 0); + }else{ + rc = SQLITE_NOMEM; + } + sqlite3_free(zSql); + } + if( pRtree->nAux ){ + pRtree->zReadAuxSql = sqlite3_mprintf( + "SELECT * FROM \"%w\".\"%w_rowid\" WHERE rowid=?1", + zDb, zPrefix); + if( pRtree->zReadAuxSql==0 ){ + rc = SQLITE_NOMEM; + }else{ + sqlite3_str *p = sqlite3_str_new(db); + int ii; + char *zSql; + sqlite3_str_appendf(p, "UPDATE \"%w\".\"%w_rowid\"SET ", zDb, zPrefix); + for(ii=0; iinAux; ii++){ + if( ii ) sqlite3_str_append(p, ",", 1); +#ifdef SQLITE_ENABLE_GEOPOLY + if( iinAuxNotNull ){ + sqlite3_str_appendf(p,"a%d=coalesce(?%d,a%d)",ii,ii+2,ii); + }else +#endif + { + sqlite3_str_appendf(p,"a%d=?%d",ii,ii+2); + } + } + sqlite3_str_appendf(p, " WHERE rowid=?1"); + zSql = sqlite3_str_finish(p); + if( zSql==0 ){ + rc = SQLITE_NOMEM; + }else{ + rc = sqlite3_prepare_v3(db, zSql, -1, f, &pRtree->pWriteAux, 0); + sqlite3_free(zSql); + } + } + } + + return rc; +} + +/* +** The second argument to this function contains the text of an SQL statement +** that returns a single integer value. The statement is compiled and executed +** using database connection db. If successful, the integer value returned +** is written to *piVal and SQLITE_OK returned. Otherwise, an SQLite error +** code is returned and the value of *piVal after returning is not defined. +*/ +static int getIntFromStmt(sqlite3 *db, const char *zSql, int *piVal){ + int rc = SQLITE_NOMEM; + if( zSql ){ + sqlite3_stmt *pStmt = 0; + rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); + if( rc==SQLITE_OK ){ + if( SQLITE_ROW==sqlite3_step(pStmt) ){ + *piVal = sqlite3_column_int(pStmt, 0); + } + rc = sqlite3_finalize(pStmt); + } + } + return rc; +} + +/* +** This function is called from within the xConnect() or xCreate() method to +** determine the node-size used by the rtree table being created or connected +** to. If successful, pRtree->iNodeSize is populated and SQLITE_OK returned. +** Otherwise, an SQLite error code is returned. +** +** If this function is being called as part of an xConnect(), then the rtree +** table already exists. In this case the node-size is determined by inspecting +** the root node of the tree. +** +** Otherwise, for an xCreate(), use 64 bytes less than the database page-size. +** This ensures that each node is stored on a single database page. If the +** database page-size is so large that more than RTREE_MAXCELLS entries +** would fit in a single node, use a smaller node-size. +*/ +static int getNodeSize( + sqlite3 *db, /* Database handle */ + Rtree *pRtree, /* Rtree handle */ + int isCreate, /* True for xCreate, false for xConnect */ + char **pzErr /* OUT: Error message, if any */ +){ + int rc; + char *zSql; + if( isCreate ){ + int iPageSize = 0; + zSql = sqlite3_mprintf("PRAGMA %Q.page_size", pRtree->zDb); + rc = getIntFromStmt(db, zSql, &iPageSize); + if( rc==SQLITE_OK ){ + pRtree->iNodeSize = iPageSize-64; + if( (4+pRtree->nBytesPerCell*RTREE_MAXCELLS)iNodeSize ){ + pRtree->iNodeSize = 4+pRtree->nBytesPerCell*RTREE_MAXCELLS; + } + }else{ + *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + } + }else{ + zSql = sqlite3_mprintf( + "SELECT length(data) FROM '%q'.'%q_node' WHERE nodeno = 1", + pRtree->zDb, pRtree->zName + ); + rc = getIntFromStmt(db, zSql, &pRtree->iNodeSize); + if( rc!=SQLITE_OK ){ + *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + }else if( pRtree->iNodeSize<(512-64) ){ + rc = SQLITE_CORRUPT_VTAB; + RTREE_IS_CORRUPT(pRtree); + *pzErr = sqlite3_mprintf("undersize RTree blobs in \"%q_node\"", + pRtree->zName); + } + } + + sqlite3_free(zSql); + return rc; +} + +/* +** Return the length of a token +*/ +static int rtreeTokenLength(const char *z){ + int dummy = 0; + return sqlite3GetToken((const unsigned char*)z,&dummy); +} + +/* +** This function is the implementation of both the xConnect and xCreate +** methods of the r-tree virtual table. +** +** argv[0] -> module name +** argv[1] -> database name +** argv[2] -> table name +** argv[...] -> column names... +*/ +static int rtreeInit( + sqlite3 *db, /* Database connection */ + void *pAux, /* One of the RTREE_COORD_* constants */ + int argc, const char *const*argv, /* Parameters to CREATE TABLE statement */ + sqlite3_vtab **ppVtab, /* OUT: New virtual table */ + char **pzErr, /* OUT: Error message, if any */ + int isCreate /* True for xCreate, false for xConnect */ +){ + int rc = SQLITE_OK; + Rtree *pRtree; + int nDb; /* Length of string argv[1] */ + int nName; /* Length of string argv[2] */ + int eCoordType = (pAux ? RTREE_COORD_INT32 : RTREE_COORD_REAL32); + sqlite3_str *pSql; + char *zSql; + int ii = 4; + int iErr; + + const char *aErrMsg[] = { + 0, /* 0 */ + "Wrong number of columns for an rtree table", /* 1 */ + "Too few columns for an rtree table", /* 2 */ + "Too many columns for an rtree table", /* 3 */ + "Auxiliary rtree columns must be last" /* 4 */ + }; + + assert( RTREE_MAX_AUX_COLUMN<256 ); /* Aux columns counted by a u8 */ + if( argc<6 || argc>RTREE_MAX_AUX_COLUMN+3 ){ + *pzErr = sqlite3_mprintf("%s", aErrMsg[2 + (argc>=6)]); + return SQLITE_ERROR; + } + + sqlite3_vtab_config(db, SQLITE_VTAB_CONSTRAINT_SUPPORT, 1); + + /* Allocate the sqlite3_vtab structure */ + nDb = (int)strlen(argv[1]); + nName = (int)strlen(argv[2]); + pRtree = (Rtree *)sqlite3_malloc64(sizeof(Rtree)+nDb+nName+2); + if( !pRtree ){ + return SQLITE_NOMEM; + } + memset(pRtree, 0, sizeof(Rtree)+nDb+nName+2); + pRtree->nBusy = 1; + pRtree->base.pModule = &rtreeModule; + pRtree->zDb = (char *)&pRtree[1]; + pRtree->zName = &pRtree->zDb[nDb+1]; + pRtree->eCoordType = (u8)eCoordType; + memcpy(pRtree->zDb, argv[1], nDb); + memcpy(pRtree->zName, argv[2], nName); + + + /* Create/Connect to the underlying relational database schema. If + ** that is successful, call sqlite3_declare_vtab() to configure + ** the r-tree table schema. + */ + pSql = sqlite3_str_new(db); + sqlite3_str_appendf(pSql, "CREATE TABLE x(%.*s INT", + rtreeTokenLength(argv[3]), argv[3]); + for(ii=4; iinAux++; + sqlite3_str_appendf(pSql, ",%.*s", rtreeTokenLength(zArg+1), zArg+1); + }else if( pRtree->nAux>0 ){ + break; + }else{ + static const char *azFormat[] = {",%.*s REAL", ",%.*s INT"}; + pRtree->nDim2++; + sqlite3_str_appendf(pSql, azFormat[eCoordType], + rtreeTokenLength(zArg), zArg); + } + } + sqlite3_str_appendf(pSql, ");"); + zSql = sqlite3_str_finish(pSql); + if( !zSql ){ + rc = SQLITE_NOMEM; + }else if( iinDim = pRtree->nDim2/2; + if( pRtree->nDim<1 ){ + iErr = 2; + }else if( pRtree->nDim2>RTREE_MAX_DIMENSIONS*2 ){ + iErr = 3; + }else if( pRtree->nDim2 % 2 ){ + iErr = 1; + }else{ + iErr = 0; + } + if( iErr ){ + *pzErr = sqlite3_mprintf("%s", aErrMsg[iErr]); + goto rtreeInit_fail; + } + pRtree->nBytesPerCell = 8 + pRtree->nDim2*4; + + /* Figure out the node size to use. */ + rc = getNodeSize(db, pRtree, isCreate, pzErr); + if( rc ) goto rtreeInit_fail; + rc = rtreeSqlInit(pRtree, db, argv[1], argv[2], isCreate); + if( rc ){ + *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + goto rtreeInit_fail; + } + + *ppVtab = (sqlite3_vtab *)pRtree; + return SQLITE_OK; + +rtreeInit_fail: + if( rc==SQLITE_OK ) rc = SQLITE_ERROR; + assert( *ppVtab==0 ); + assert( pRtree->nBusy==1 ); + rtreeRelease(pRtree); + return rc; +} + + +/* +** Implementation of a scalar function that decodes r-tree nodes to +** human readable strings. This can be used for debugging and analysis. +** +** The scalar function takes two arguments: (1) the number of dimensions +** to the rtree (between 1 and 5, inclusive) and (2) a blob of data containing +** an r-tree node. For a two-dimensional r-tree structure called "rt", to +** deserialize all nodes, a statement like: +** +** SELECT rtreenode(2, data) FROM rt_node; +** +** The human readable string takes the form of a Tcl list with one +** entry for each cell in the r-tree node. Each entry is itself a +** list, containing the 8-byte rowid/pageno followed by the +** *2 coordinates. +*/ +static void rtreenode(sqlite3_context *ctx, int nArg, sqlite3_value **apArg){ + RtreeNode node; + Rtree tree; + int ii; + int nData; + int errCode; + sqlite3_str *pOut; + + UNUSED_PARAMETER(nArg); + memset(&node, 0, sizeof(RtreeNode)); + memset(&tree, 0, sizeof(Rtree)); + tree.nDim = (u8)sqlite3_value_int(apArg[0]); + if( tree.nDim<1 || tree.nDim>5 ) return; + tree.nDim2 = tree.nDim*2; + tree.nBytesPerCell = 8 + 8 * tree.nDim; + node.zData = (u8 *)sqlite3_value_blob(apArg[1]); + if( node.zData==0 ) return; + nData = sqlite3_value_bytes(apArg[1]); + if( nData<4 ) return; + if( nData0 ) sqlite3_str_append(pOut, " ", 1); + sqlite3_str_appendf(pOut, "{%lld", cell.iRowid); + for(jj=0; jjrc==SQLITE_OK ) pCheck->rc = rc; +} + +/* +** The second and subsequent arguments to this function are a format string +** and printf style arguments. This function formats the string and attempts +** to compile it as an SQL statement. +** +** If successful, a pointer to the new SQL statement is returned. Otherwise, +** NULL is returned and an error code left in RtreeCheck.rc. +*/ +static sqlite3_stmt *rtreeCheckPrepare( + RtreeCheck *pCheck, /* RtreeCheck object */ + const char *zFmt, ... /* Format string and trailing args */ +){ + va_list ap; + char *z; + sqlite3_stmt *pRet = 0; + + va_start(ap, zFmt); + z = sqlite3_vmprintf(zFmt, ap); + + if( pCheck->rc==SQLITE_OK ){ + if( z==0 ){ + pCheck->rc = SQLITE_NOMEM; + }else{ + pCheck->rc = sqlite3_prepare_v2(pCheck->db, z, -1, &pRet, 0); + } + } + + sqlite3_free(z); + va_end(ap); + return pRet; +} + +/* +** The second and subsequent arguments to this function are a printf() +** style format string and arguments. This function formats the string and +** appends it to the report being accumuated in pCheck. +*/ +static void rtreeCheckAppendMsg(RtreeCheck *pCheck, const char *zFmt, ...){ + va_list ap; + va_start(ap, zFmt); + if( pCheck->rc==SQLITE_OK && pCheck->nErrrc = SQLITE_NOMEM; + }else{ + pCheck->zReport = sqlite3_mprintf("%z%s%z", + pCheck->zReport, (pCheck->zReport ? "\n" : ""), z + ); + if( pCheck->zReport==0 ){ + pCheck->rc = SQLITE_NOMEM; + } + } + pCheck->nErr++; + } + va_end(ap); +} + +/* +** This function is a no-op if there is already an error code stored +** in the RtreeCheck object indicated by the first argument. NULL is +** returned in this case. +** +** Otherwise, the contents of rtree table node iNode are loaded from +** the database and copied into a buffer obtained from sqlite3_malloc(). +** If no error occurs, a pointer to the buffer is returned and (*pnNode) +** is set to the size of the buffer in bytes. +** +** Or, if an error does occur, NULL is returned and an error code left +** in the RtreeCheck object. The final value of *pnNode is undefined in +** this case. +*/ +static u8 *rtreeCheckGetNode(RtreeCheck *pCheck, i64 iNode, int *pnNode){ + u8 *pRet = 0; /* Return value */ + + if( pCheck->rc==SQLITE_OK && pCheck->pGetNode==0 ){ + pCheck->pGetNode = rtreeCheckPrepare(pCheck, + "SELECT data FROM %Q.'%q_node' WHERE nodeno=?", + pCheck->zDb, pCheck->zTab + ); + } + + if( pCheck->rc==SQLITE_OK ){ + sqlite3_bind_int64(pCheck->pGetNode, 1, iNode); + if( sqlite3_step(pCheck->pGetNode)==SQLITE_ROW ){ + int nNode = sqlite3_column_bytes(pCheck->pGetNode, 0); + const u8 *pNode = (const u8*)sqlite3_column_blob(pCheck->pGetNode, 0); + pRet = sqlite3_malloc64(nNode); + if( pRet==0 ){ + pCheck->rc = SQLITE_NOMEM; + }else{ + memcpy(pRet, pNode, nNode); + *pnNode = nNode; + } + } + rtreeCheckReset(pCheck, pCheck->pGetNode); + if( pCheck->rc==SQLITE_OK && pRet==0 ){ + rtreeCheckAppendMsg(pCheck, "Node %lld missing from database", iNode); + } + } + + return pRet; +} + +/* +** This function is used to check that the %_parent (if bLeaf==0) or %_rowid +** (if bLeaf==1) table contains a specified entry. The schemas of the +** two tables are: +** +** CREATE TABLE %_parent(nodeno INTEGER PRIMARY KEY, parentnode INTEGER) +** CREATE TABLE %_rowid(rowid INTEGER PRIMARY KEY, nodeno INTEGER, ...) +** +** In both cases, this function checks that there exists an entry with +** IPK value iKey and the second column set to iVal. +** +*/ +static void rtreeCheckMapping( + RtreeCheck *pCheck, /* RtreeCheck object */ + int bLeaf, /* True for a leaf cell, false for interior */ + i64 iKey, /* Key for mapping */ + i64 iVal /* Expected value for mapping */ +){ + int rc; + sqlite3_stmt *pStmt; + const char *azSql[2] = { + "SELECT parentnode FROM %Q.'%q_parent' WHERE nodeno=?1", + "SELECT nodeno FROM %Q.'%q_rowid' WHERE rowid=?1" + }; + + assert( bLeaf==0 || bLeaf==1 ); + if( pCheck->aCheckMapping[bLeaf]==0 ){ + pCheck->aCheckMapping[bLeaf] = rtreeCheckPrepare(pCheck, + azSql[bLeaf], pCheck->zDb, pCheck->zTab + ); + } + if( pCheck->rc!=SQLITE_OK ) return; + + pStmt = pCheck->aCheckMapping[bLeaf]; + sqlite3_bind_int64(pStmt, 1, iKey); + rc = sqlite3_step(pStmt); + if( rc==SQLITE_DONE ){ + rtreeCheckAppendMsg(pCheck, "Mapping (%lld -> %lld) missing from %s table", + iKey, iVal, (bLeaf ? "%_rowid" : "%_parent") + ); + }else if( rc==SQLITE_ROW ){ + i64 ii = sqlite3_column_int64(pStmt, 0); + if( ii!=iVal ){ + rtreeCheckAppendMsg(pCheck, + "Found (%lld -> %lld) in %s table, expected (%lld -> %lld)", + iKey, ii, (bLeaf ? "%_rowid" : "%_parent"), iKey, iVal + ); + } + } + rtreeCheckReset(pCheck, pStmt); +} + +/* +** Argument pCell points to an array of coordinates stored on an rtree page. +** This function checks that the coordinates are internally consistent (no +** x1>x2 conditions) and adds an error message to the RtreeCheck object +** if they are not. +** +** Additionally, if pParent is not NULL, then it is assumed to point to +** the array of coordinates on the parent page that bound the page +** containing pCell. In this case it is also verified that the two +** sets of coordinates are mutually consistent and an error message added +** to the RtreeCheck object if they are not. +*/ +static void rtreeCheckCellCoord( + RtreeCheck *pCheck, + i64 iNode, /* Node id to use in error messages */ + int iCell, /* Cell number to use in error messages */ + u8 *pCell, /* Pointer to cell coordinates */ + u8 *pParent /* Pointer to parent coordinates */ +){ + RtreeCoord c1, c2; + RtreeCoord p1, p2; + int i; + + for(i=0; inDim; i++){ + readCoord(&pCell[4*2*i], &c1); + readCoord(&pCell[4*(2*i + 1)], &c2); + + /* printf("%e, %e\n", c1.u.f, c2.u.f); */ + if( pCheck->bInt ? c1.i>c2.i : c1.f>c2.f ){ + rtreeCheckAppendMsg(pCheck, + "Dimension %d of cell %d on node %lld is corrupt", i, iCell, iNode + ); + } + + if( pParent ){ + readCoord(&pParent[4*2*i], &p1); + readCoord(&pParent[4*(2*i + 1)], &p2); + + if( (pCheck->bInt ? c1.ibInt ? c2.i>p2.i : c2.f>p2.f) + ){ + rtreeCheckAppendMsg(pCheck, + "Dimension %d of cell %d on node %lld is corrupt relative to parent" + , i, iCell, iNode + ); + } + } + } +} + +/* +** Run rtreecheck() checks on node iNode, which is at depth iDepth within +** the r-tree structure. Argument aParent points to the array of coordinates +** that bound node iNode on the parent node. +** +** If any problems are discovered, an error message is appended to the +** report accumulated in the RtreeCheck object. +*/ +static void rtreeCheckNode( + RtreeCheck *pCheck, + int iDepth, /* Depth of iNode (0==leaf) */ + u8 *aParent, /* Buffer containing parent coords */ + i64 iNode /* Node to check */ +){ + u8 *aNode = 0; + int nNode = 0; + + assert( iNode==1 || aParent!=0 ); + assert( pCheck->nDim>0 ); + + aNode = rtreeCheckGetNode(pCheck, iNode, &nNode); + if( aNode ){ + if( nNode<4 ){ + rtreeCheckAppendMsg(pCheck, + "Node %lld is too small (%d bytes)", iNode, nNode + ); + }else{ + int nCell; /* Number of cells on page */ + int i; /* Used to iterate through cells */ + if( aParent==0 ){ + iDepth = readInt16(aNode); + if( iDepth>RTREE_MAX_DEPTH ){ + rtreeCheckAppendMsg(pCheck, "Rtree depth out of range (%d)", iDepth); + sqlite3_free(aNode); + return; + } + } + nCell = readInt16(&aNode[2]); + if( (4 + nCell*(8 + pCheck->nDim*2*4))>nNode ){ + rtreeCheckAppendMsg(pCheck, + "Node %lld is too small for cell count of %d (%d bytes)", + iNode, nCell, nNode + ); + }else{ + for(i=0; inDim*2*4)]; + i64 iVal = readInt64(pCell); + rtreeCheckCellCoord(pCheck, iNode, i, &pCell[8], aParent); + + if( iDepth>0 ){ + rtreeCheckMapping(pCheck, 0, iVal, iNode); + rtreeCheckNode(pCheck, iDepth-1, &pCell[8], iVal); + pCheck->nNonLeaf++; + }else{ + rtreeCheckMapping(pCheck, 1, iVal, iNode); + pCheck->nLeaf++; + } + } + } + } + sqlite3_free(aNode); + } +} + +/* +** The second argument to this function must be either "_rowid" or +** "_parent". This function checks that the number of entries in the +** %_rowid or %_parent table is exactly nExpect. If not, it adds +** an error message to the report in the RtreeCheck object indicated +** by the first argument. +*/ +static void rtreeCheckCount(RtreeCheck *pCheck, const char *zTbl, i64 nExpect){ + if( pCheck->rc==SQLITE_OK ){ + sqlite3_stmt *pCount; + pCount = rtreeCheckPrepare(pCheck, "SELECT count(*) FROM %Q.'%q%s'", + pCheck->zDb, pCheck->zTab, zTbl + ); + if( pCount ){ + if( sqlite3_step(pCount)==SQLITE_ROW ){ + i64 nActual = sqlite3_column_int64(pCount, 0); + if( nActual!=nExpect ){ + rtreeCheckAppendMsg(pCheck, "Wrong number of entries in %%%s table" + " - expected %lld, actual %lld" , zTbl, nExpect, nActual + ); + } + } + pCheck->rc = sqlite3_finalize(pCount); + } + } +} + +/* +** This function does the bulk of the work for the rtree integrity-check. +** It is called by rtreecheck(), which is the SQL function implementation. +*/ +static int rtreeCheckTable( + sqlite3 *db, /* Database handle to access db through */ + const char *zDb, /* Name of db ("main", "temp" etc.) */ + const char *zTab, /* Name of rtree table to check */ + char **pzReport /* OUT: sqlite3_malloc'd report text */ +){ + RtreeCheck check; /* Common context for various routines */ + sqlite3_stmt *pStmt = 0; /* Used to find column count of rtree table */ + int bEnd = 0; /* True if transaction should be closed */ + int nAux = 0; /* Number of extra columns. */ + + /* Initialize the context object */ + memset(&check, 0, sizeof(check)); + check.db = db; + check.zDb = zDb; + check.zTab = zTab; + + /* If there is not already an open transaction, open one now. This is + ** to ensure that the queries run as part of this integrity-check operate + ** on a consistent snapshot. */ + if( sqlite3_get_autocommit(db) ){ + check.rc = sqlite3_exec(db, "BEGIN", 0, 0, 0); + bEnd = 1; + } + + /* Find the number of auxiliary columns */ + if( check.rc==SQLITE_OK ){ + pStmt = rtreeCheckPrepare(&check, "SELECT * FROM %Q.'%q_rowid'", zDb, zTab); + if( pStmt ){ + nAux = sqlite3_column_count(pStmt) - 2; + sqlite3_finalize(pStmt); + }else + if( check.rc!=SQLITE_NOMEM ){ + check.rc = SQLITE_OK; + } + } + + /* Find number of dimensions in the rtree table. */ + pStmt = rtreeCheckPrepare(&check, "SELECT * FROM %Q.%Q", zDb, zTab); + if( pStmt ){ + int rc; + check.nDim = (sqlite3_column_count(pStmt) - 1 - nAux) / 2; + if( check.nDim<1 ){ + rtreeCheckAppendMsg(&check, "Schema corrupt or not an rtree"); + }else if( SQLITE_ROW==sqlite3_step(pStmt) ){ + check.bInt = (sqlite3_column_type(pStmt, 1)==SQLITE_INTEGER); + } + rc = sqlite3_finalize(pStmt); + if( rc!=SQLITE_CORRUPT ) check.rc = rc; + } + + /* Do the actual integrity-check */ + if( check.nDim>=1 ){ + if( check.rc==SQLITE_OK ){ + rtreeCheckNode(&check, 0, 0, 1); + } + rtreeCheckCount(&check, "_rowid", check.nLeaf); + rtreeCheckCount(&check, "_parent", check.nNonLeaf); + } + + /* Finalize SQL statements used by the integrity-check */ + sqlite3_finalize(check.pGetNode); + sqlite3_finalize(check.aCheckMapping[0]); + sqlite3_finalize(check.aCheckMapping[1]); + + /* If one was opened, close the transaction */ + if( bEnd ){ + int rc = sqlite3_exec(db, "END", 0, 0, 0); + if( check.rc==SQLITE_OK ) check.rc = rc; + } + *pzReport = check.zReport; + return check.rc; +} + +/* +** Usage: +** +** rtreecheck(); +** rtreecheck(, ); +** +** Invoking this SQL function runs an integrity-check on the named rtree +** table. The integrity-check verifies the following: +** +** 1. For each cell in the r-tree structure (%_node table), that: +** +** a) for each dimension, (coord1 <= coord2). +** +** b) unless the cell is on the root node, that the cell is bounded +** by the parent cell on the parent node. +** +** c) for leaf nodes, that there is an entry in the %_rowid +** table corresponding to the cell's rowid value that +** points to the correct node. +** +** d) for cells on non-leaf nodes, that there is an entry in the +** %_parent table mapping from the cell's child node to the +** node that it resides on. +** +** 2. That there are the same number of entries in the %_rowid table +** as there are leaf cells in the r-tree structure, and that there +** is a leaf cell that corresponds to each entry in the %_rowid table. +** +** 3. That there are the same number of entries in the %_parent table +** as there are non-leaf cells in the r-tree structure, and that +** there is a non-leaf cell that corresponds to each entry in the +** %_parent table. +*/ +static void rtreecheck( + sqlite3_context *ctx, + int nArg, + sqlite3_value **apArg +){ + if( nArg!=1 && nArg!=2 ){ + sqlite3_result_error(ctx, + "wrong number of arguments to function rtreecheck()", -1 + ); + }else{ + int rc; + char *zReport = 0; + const char *zDb = (const char*)sqlite3_value_text(apArg[0]); + const char *zTab; + if( nArg==1 ){ + zTab = zDb; + zDb = "main"; + }else{ + zTab = (const char*)sqlite3_value_text(apArg[1]); + } + rc = rtreeCheckTable(sqlite3_context_db_handle(ctx), zDb, zTab, &zReport); + if( rc==SQLITE_OK ){ + sqlite3_result_text(ctx, zReport ? zReport : "ok", -1, SQLITE_TRANSIENT); + }else{ + sqlite3_result_error_code(ctx, rc); + } + sqlite3_free(zReport); + } +} + +/* Conditionally include the geopoly code */ +#ifdef SQLITE_ENABLE_GEOPOLY +/************** Include geopoly.c in the middle of rtree.c *******************/ +/************** Begin file geopoly.c *****************************************/ +/* +** 2018-05-25 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file implements an alternative R-Tree virtual table that +** uses polygons to express the boundaries of 2-dimensional objects. +** +** This file is #include-ed onto the end of "rtree.c" so that it has +** access to all of the R-Tree internals. +*/ +/* #include */ + +/* Enable -DGEOPOLY_ENABLE_DEBUG for debugging facilities */ +#ifdef GEOPOLY_ENABLE_DEBUG + static int geo_debug = 0; +# define GEODEBUG(X) if(geo_debug)printf X +#else +# define GEODEBUG(X) +#endif + +/* Character class routines */ +#ifdef sqlite3Isdigit + /* Use the SQLite core versions if this routine is part of the + ** SQLite amalgamation */ +# define safe_isdigit(x) sqlite3Isdigit(x) +# define safe_isalnum(x) sqlite3Isalnum(x) +# define safe_isxdigit(x) sqlite3Isxdigit(x) +#else + /* Use the standard library for separate compilation */ +#include /* amalgamator: keep */ +# define safe_isdigit(x) isdigit((unsigned char)(x)) +# define safe_isalnum(x) isalnum((unsigned char)(x)) +# define safe_isxdigit(x) isxdigit((unsigned char)(x)) +#endif + +#ifndef JSON_NULL /* The following stuff repeats things found in json1 */ +/* +** Growing our own isspace() routine this way is twice as fast as +** the library isspace() function. +*/ +static const char geopolyIsSpace[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +}; +#define fast_isspace(x) (geopolyIsSpace[(unsigned char)x]) +#endif /* JSON NULL - back to original code */ + +/* Compiler and version */ +#ifndef GCC_VERSION +#if defined(__GNUC__) && !defined(SQLITE_DISABLE_INTRINSIC) +# define GCC_VERSION (__GNUC__*1000000+__GNUC_MINOR__*1000+__GNUC_PATCHLEVEL__) +#else +# define GCC_VERSION 0 +#endif +#endif +#ifndef MSVC_VERSION +#if defined(_MSC_VER) && !defined(SQLITE_DISABLE_INTRINSIC) +# define MSVC_VERSION _MSC_VER +#else +# define MSVC_VERSION 0 +#endif +#endif + +/* Datatype for coordinates +*/ +typedef float GeoCoord; + +/* +** Internal representation of a polygon. +** +** The polygon consists of a sequence of vertexes. There is a line +** segment between each pair of vertexes, and one final segment from +** the last vertex back to the first. (This differs from the GeoJSON +** standard in which the final vertex is a repeat of the first.) +** +** The polygon follows the right-hand rule. The area to the right of +** each segment is "outside" and the area to the left is "inside". +** +** The on-disk representation consists of a 4-byte header followed by +** the values. The 4-byte header is: +** +** encoding (1 byte) 0=big-endian, 1=little-endian +** nvertex (3 bytes) Number of vertexes as a big-endian integer +** +** Enough space is allocated for 4 coordinates, to work around over-zealous +** warnings coming from some compiler (notably, clang). In reality, the size +** of each GeoPoly memory allocate is adjusted as necessary so that the +** GeoPoly.a[] array at the end is the appropriate size. +*/ +typedef struct GeoPoly GeoPoly; +struct GeoPoly { + int nVertex; /* Number of vertexes */ + unsigned char hdr[4]; /* Header for on-disk representation */ + GeoCoord a[8]; /* 2*nVertex values. X (longitude) first, then Y */ +}; + +/* The size of a memory allocation needed for a GeoPoly object sufficient +** to hold N coordinate pairs. +*/ +#define GEOPOLY_SZ(N) (sizeof(GeoPoly) + sizeof(GeoCoord)*2*((N)-4)) + +/* Macros to access coordinates of a GeoPoly. +** We have to use these macros, rather than just say p->a[i] in order +** to silence (incorrect) UBSAN warnings if the array index is too large. +*/ +#define GeoX(P,I) (((GeoCoord*)(P)->a)[(I)*2]) +#define GeoY(P,I) (((GeoCoord*)(P)->a)[(I)*2+1]) + + +/* +** State of a parse of a GeoJSON input. +*/ +typedef struct GeoParse GeoParse; +struct GeoParse { + const unsigned char *z; /* Unparsed input */ + int nVertex; /* Number of vertexes in a[] */ + int nAlloc; /* Space allocated to a[] */ + int nErr; /* Number of errors encountered */ + GeoCoord *a; /* Array of vertexes. From sqlite3_malloc64() */ +}; + +/* Do a 4-byte byte swap */ +static void geopolySwab32(unsigned char *a){ + unsigned char t = a[0]; + a[0] = a[3]; + a[3] = t; + t = a[1]; + a[1] = a[2]; + a[2] = t; +} + +/* Skip whitespace. Return the next non-whitespace character. */ +static char geopolySkipSpace(GeoParse *p){ + while( fast_isspace(p->z[0]) ) p->z++; + return p->z[0]; +} + +/* Parse out a number. Write the value into *pVal if pVal!=0. +** return non-zero on success and zero if the next token is not a number. +*/ +static int geopolyParseNumber(GeoParse *p, GeoCoord *pVal){ + char c = geopolySkipSpace(p); + const unsigned char *z = p->z; + int j = 0; + int seenDP = 0; + int seenE = 0; + if( c=='-' ){ + j = 1; + c = z[j]; + } + if( c=='0' && z[j+1]>='0' && z[j+1]<='9' ) return 0; + for(;; j++){ + c = z[j]; + if( safe_isdigit(c) ) continue; + if( c=='.' ){ + if( z[j-1]=='-' ) return 0; + if( seenDP ) return 0; + seenDP = 1; + continue; + } + if( c=='e' || c=='E' ){ + if( z[j-1]<'0' ) return 0; + if( seenE ) return -1; + seenDP = seenE = 1; + c = z[j+1]; + if( c=='+' || c=='-' ){ + j++; + c = z[j+1]; + } + if( c<'0' || c>'9' ) return 0; + continue; + } + break; + } + if( z[j-1]<'0' ) return 0; + if( pVal ){ +#ifdef SQLITE_AMALGAMATION + /* The sqlite3AtoF() routine is much much faster than atof(), if it + ** is available */ + double r; + (void)sqlite3AtoF((const char*)p->z, &r, j, SQLITE_UTF8); + *pVal = r; +#else + *pVal = (GeoCoord)atof((const char*)p->z); +#endif + } + p->z += j; + return 1; +} + +/* +** If the input is a well-formed JSON array of coordinates with at least +** four coordinates and where each coordinate is itself a two-value array, +** then convert the JSON into a GeoPoly object and return a pointer to +** that object. +** +** If any error occurs, return NULL. +*/ +static GeoPoly *geopolyParseJson(const unsigned char *z, int *pRc){ + GeoParse s; + int rc = SQLITE_OK; + memset(&s, 0, sizeof(s)); + s.z = z; + if( geopolySkipSpace(&s)=='[' ){ + s.z++; + while( geopolySkipSpace(&s)=='[' ){ + int ii = 0; + char c; + s.z++; + if( s.nVertex>=s.nAlloc ){ + GeoCoord *aNew; + s.nAlloc = s.nAlloc*2 + 16; + aNew = sqlite3_realloc64(s.a, s.nAlloc*sizeof(GeoCoord)*2 ); + if( aNew==0 ){ + rc = SQLITE_NOMEM; + s.nErr++; + break; + } + s.a = aNew; + } + while( geopolyParseNumber(&s, ii<=1 ? &s.a[s.nVertex*2+ii] : 0) ){ + ii++; + if( ii==2 ) s.nVertex++; + c = geopolySkipSpace(&s); + s.z++; + if( c==',' ) continue; + if( c==']' && ii>=2 ) break; + s.nErr++; + rc = SQLITE_ERROR; + goto parse_json_err; + } + if( geopolySkipSpace(&s)==',' ){ + s.z++; + continue; + } + break; + } + if( geopolySkipSpace(&s)==']' + && s.nVertex>=4 + && s.a[0]==s.a[s.nVertex*2-2] + && s.a[1]==s.a[s.nVertex*2-1] + && (s.z++, geopolySkipSpace(&s)==0) + ){ + GeoPoly *pOut; + int x = 1; + s.nVertex--; /* Remove the redundant vertex at the end */ + pOut = sqlite3_malloc64( GEOPOLY_SZ((sqlite3_int64)s.nVertex) ); + x = 1; + if( pOut==0 ) goto parse_json_err; + pOut->nVertex = s.nVertex; + memcpy(pOut->a, s.a, s.nVertex*2*sizeof(GeoCoord)); + pOut->hdr[0] = *(unsigned char*)&x; + pOut->hdr[1] = (s.nVertex>>16)&0xff; + pOut->hdr[2] = (s.nVertex>>8)&0xff; + pOut->hdr[3] = s.nVertex&0xff; + sqlite3_free(s.a); + if( pRc ) *pRc = SQLITE_OK; + return pOut; + }else{ + s.nErr++; + rc = SQLITE_ERROR; + } + } +parse_json_err: + if( pRc ) *pRc = rc; + sqlite3_free(s.a); + return 0; +} + +/* +** Given a function parameter, try to interpret it as a polygon, either +** in the binary format or JSON text. Compute a GeoPoly object and +** return a pointer to that object. Or if the input is not a well-formed +** polygon, put an error message in sqlite3_context and return NULL. +*/ +static GeoPoly *geopolyFuncParam( + sqlite3_context *pCtx, /* Context for error messages */ + sqlite3_value *pVal, /* The value to decode */ + int *pRc /* Write error here */ +){ + GeoPoly *p = 0; + int nByte; + testcase( pCtx==0 ); + if( sqlite3_value_type(pVal)==SQLITE_BLOB + && (nByte = sqlite3_value_bytes(pVal))>=(int)(4+6*sizeof(GeoCoord)) + ){ + const unsigned char *a = sqlite3_value_blob(pVal); + int nVertex; + if( a==0 ){ + if( pCtx ) sqlite3_result_error_nomem(pCtx); + return 0; + } + nVertex = (a[1]<<16) + (a[2]<<8) + a[3]; + if( (a[0]==0 || a[0]==1) + && (nVertex*2*sizeof(GeoCoord) + 4)==(unsigned int)nByte + ){ + p = sqlite3_malloc64( sizeof(*p) + (nVertex-1)*2*sizeof(GeoCoord) ); + if( p==0 ){ + if( pRc ) *pRc = SQLITE_NOMEM; + if( pCtx ) sqlite3_result_error_nomem(pCtx); + }else{ + int x = 1; + p->nVertex = nVertex; + memcpy(p->hdr, a, nByte); + if( a[0] != *(unsigned char*)&x ){ + int ii; + for(ii=0; iihdr[0] ^= 1; + } + } + } + if( pRc ) *pRc = SQLITE_OK; + return p; + }else if( sqlite3_value_type(pVal)==SQLITE_TEXT ){ + const unsigned char *zJson = sqlite3_value_text(pVal); + if( zJson==0 ){ + if( pRc ) *pRc = SQLITE_NOMEM; + return 0; + } + return geopolyParseJson(zJson, pRc); + }else{ + if( pRc ) *pRc = SQLITE_ERROR; + return 0; + } +} + +/* +** Implementation of the geopoly_blob(X) function. +** +** If the input is a well-formed Geopoly BLOB or JSON string +** then return the BLOB representation of the polygon. Otherwise +** return NULL. +*/ +static void geopolyBlobFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + GeoPoly *p = geopolyFuncParam(context, argv[0], 0); + (void)argc; + if( p ){ + sqlite3_result_blob(context, p->hdr, + 4+8*p->nVertex, SQLITE_TRANSIENT); + sqlite3_free(p); + } +} + +/* +** SQL function: geopoly_json(X) +** +** Interpret X as a polygon and render it as a JSON array +** of coordinates. Or, if X is not a valid polygon, return NULL. +*/ +static void geopolyJsonFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + GeoPoly *p = geopolyFuncParam(context, argv[0], 0); + (void)argc; + if( p ){ + sqlite3 *db = sqlite3_context_db_handle(context); + sqlite3_str *x = sqlite3_str_new(db); + int i; + sqlite3_str_append(x, "[", 1); + for(i=0; inVertex; i++){ + sqlite3_str_appendf(x, "[%!g,%!g],", GeoX(p,i), GeoY(p,i)); + } + sqlite3_str_appendf(x, "[%!g,%!g]]", GeoX(p,0), GeoY(p,0)); + sqlite3_result_text(context, sqlite3_str_finish(x), -1, sqlite3_free); + sqlite3_free(p); + } +} + +/* +** SQL function: geopoly_svg(X, ....) +** +** Interpret X as a polygon and render it as a SVG . +** Additional arguments are added as attributes to the . +*/ +static void geopolySvgFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + GeoPoly *p; + if( argc<1 ) return; + p = geopolyFuncParam(context, argv[0], 0); + if( p ){ + sqlite3 *db = sqlite3_context_db_handle(context); + sqlite3_str *x = sqlite3_str_new(db); + int i; + char cSep = '\''; + sqlite3_str_appendf(x, ""); + sqlite3_result_text(context, sqlite3_str_finish(x), -1, sqlite3_free); + sqlite3_free(p); + } +} + +/* +** SQL Function: geopoly_xform(poly, A, B, C, D, E, F) +** +** Transform and/or translate a polygon as follows: +** +** x1 = A*x0 + B*y0 + E +** y1 = C*x0 + D*y0 + F +** +** For a translation: +** +** geopoly_xform(poly, 1, 0, 0, 1, x-offset, y-offset) +** +** Rotate by R around the point (0,0): +** +** geopoly_xform(poly, cos(R), sin(R), -sin(R), cos(R), 0, 0) +*/ +static void geopolyXformFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + GeoPoly *p = geopolyFuncParam(context, argv[0], 0); + double A = sqlite3_value_double(argv[1]); + double B = sqlite3_value_double(argv[2]); + double C = sqlite3_value_double(argv[3]); + double D = sqlite3_value_double(argv[4]); + double E = sqlite3_value_double(argv[5]); + double F = sqlite3_value_double(argv[6]); + GeoCoord x1, y1, x0, y0; + int ii; + (void)argc; + if( p ){ + for(ii=0; iinVertex; ii++){ + x0 = GeoX(p,ii); + y0 = GeoY(p,ii); + x1 = (GeoCoord)(A*x0 + B*y0 + E); + y1 = (GeoCoord)(C*x0 + D*y0 + F); + GeoX(p,ii) = x1; + GeoY(p,ii) = y1; + } + sqlite3_result_blob(context, p->hdr, + 4+8*p->nVertex, SQLITE_TRANSIENT); + sqlite3_free(p); + } +} + +/* +** Compute the area enclosed by the polygon. +** +** This routine can also be used to detect polygons that rotate in +** the wrong direction. Polygons are suppose to be counter-clockwise (CCW). +** This routine returns a negative value for clockwise (CW) polygons. +*/ +static double geopolyArea(GeoPoly *p){ + double rArea = 0.0; + int ii; + for(ii=0; iinVertex-1; ii++){ + rArea += (GeoX(p,ii) - GeoX(p,ii+1)) /* (x0 - x1) */ + * (GeoY(p,ii) + GeoY(p,ii+1)) /* (y0 + y1) */ + * 0.5; + } + rArea += (GeoX(p,ii) - GeoX(p,0)) /* (xN - x0) */ + * (GeoY(p,ii) + GeoY(p,0)) /* (yN + y0) */ + * 0.5; + return rArea; +} + +/* +** Implementation of the geopoly_area(X) function. +** +** If the input is a well-formed Geopoly BLOB then return the area +** enclosed by the polygon. If the polygon circulates clockwise instead +** of counterclockwise (as it should) then return the negative of the +** enclosed area. Otherwise return NULL. +*/ +static void geopolyAreaFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + GeoPoly *p = geopolyFuncParam(context, argv[0], 0); + (void)argc; + if( p ){ + sqlite3_result_double(context, geopolyArea(p)); + sqlite3_free(p); + } +} + +/* +** Implementation of the geopoly_ccw(X) function. +** +** If the rotation of polygon X is clockwise (incorrect) instead of +** counter-clockwise (the correct winding order according to RFC7946) +** then reverse the order of the vertexes in polygon X. +** +** In other words, this routine returns a CCW polygon regardless of the +** winding order of its input. +** +** Use this routine to sanitize historical inputs that that sometimes +** contain polygons that wind in the wrong direction. +*/ +static void geopolyCcwFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + GeoPoly *p = geopolyFuncParam(context, argv[0], 0); + (void)argc; + if( p ){ + if( geopolyArea(p)<0.0 ){ + int ii, jj; + for(ii=1, jj=p->nVertex-1; iihdr, + 4+8*p->nVertex, SQLITE_TRANSIENT); + sqlite3_free(p); + } +} + +#define GEOPOLY_PI 3.1415926535897932385 + +/* Fast approximation for sine(X) for X between -0.5*pi and 2*pi +*/ +static double geopolySine(double r){ + assert( r>=-0.5*GEOPOLY_PI && r<=2.0*GEOPOLY_PI ); + if( r>=1.5*GEOPOLY_PI ){ + r -= 2.0*GEOPOLY_PI; + } + if( r>=0.5*GEOPOLY_PI ){ + return -geopolySine(r-GEOPOLY_PI); + }else{ + double r2 = r*r; + double r3 = r2*r; + double r5 = r3*r2; + return 0.9996949*r - 0.1656700*r3 + 0.0075134*r5; + } +} + +/* +** Function: geopoly_regular(X,Y,R,N) +** +** Construct a simple, convex, regular polygon centered at X, Y +** with circumradius R and with N sides. +*/ +static void geopolyRegularFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + double x = sqlite3_value_double(argv[0]); + double y = sqlite3_value_double(argv[1]); + double r = sqlite3_value_double(argv[2]); + int n = sqlite3_value_int(argv[3]); + int i; + GeoPoly *p; + (void)argc; + + if( n<3 || r<=0.0 ) return; + if( n>1000 ) n = 1000; + p = sqlite3_malloc64( sizeof(*p) + (n-1)*2*sizeof(GeoCoord) ); + if( p==0 ){ + sqlite3_result_error_nomem(context); + return; + } + i = 1; + p->hdr[0] = *(unsigned char*)&i; + p->hdr[1] = 0; + p->hdr[2] = (n>>8)&0xff; + p->hdr[3] = n&0xff; + for(i=0; ihdr, 4+8*n, SQLITE_TRANSIENT); + sqlite3_free(p); +} + +/* +** If pPoly is a polygon, compute its bounding box. Then: +** +** (1) if aCoord!=0 store the bounding box in aCoord, returning NULL +** (2) otherwise, compute a GeoPoly for the bounding box and return the +** new GeoPoly +** +** If pPoly is NULL but aCoord is not NULL, then compute a new GeoPoly from +** the bounding box in aCoord and return a pointer to that GeoPoly. +*/ +static GeoPoly *geopolyBBox( + sqlite3_context *context, /* For recording the error */ + sqlite3_value *pPoly, /* The polygon */ + RtreeCoord *aCoord, /* Results here */ + int *pRc /* Error code here */ +){ + GeoPoly *pOut = 0; + GeoPoly *p; + float mnX, mxX, mnY, mxY; + if( pPoly==0 && aCoord!=0 ){ + p = 0; + mnX = aCoord[0].f; + mxX = aCoord[1].f; + mnY = aCoord[2].f; + mxY = aCoord[3].f; + goto geopolyBboxFill; + }else{ + p = geopolyFuncParam(context, pPoly, pRc); + } + if( p ){ + int ii; + mnX = mxX = GeoX(p,0); + mnY = mxY = GeoY(p,0); + for(ii=1; iinVertex; ii++){ + double r = GeoX(p,ii); + if( rmxX ) mxX = (float)r; + r = GeoY(p,ii); + if( rmxY ) mxY = (float)r; + } + if( pRc ) *pRc = SQLITE_OK; + if( aCoord==0 ){ + geopolyBboxFill: + pOut = sqlite3_realloc64(p, GEOPOLY_SZ(4)); + if( pOut==0 ){ + sqlite3_free(p); + if( context ) sqlite3_result_error_nomem(context); + if( pRc ) *pRc = SQLITE_NOMEM; + return 0; + } + pOut->nVertex = 4; + ii = 1; + pOut->hdr[0] = *(unsigned char*)ⅈ + pOut->hdr[1] = 0; + pOut->hdr[2] = 0; + pOut->hdr[3] = 4; + GeoX(pOut,0) = mnX; + GeoY(pOut,0) = mnY; + GeoX(pOut,1) = mxX; + GeoY(pOut,1) = mnY; + GeoX(pOut,2) = mxX; + GeoY(pOut,2) = mxY; + GeoX(pOut,3) = mnX; + GeoY(pOut,3) = mxY; + }else{ + sqlite3_free(p); + aCoord[0].f = mnX; + aCoord[1].f = mxX; + aCoord[2].f = mnY; + aCoord[3].f = mxY; + } + }else if( aCoord ){ + memset(aCoord, 0, sizeof(RtreeCoord)*4); + } + return pOut; +} + +/* +** Implementation of the geopoly_bbox(X) SQL function. +*/ +static void geopolyBBoxFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + GeoPoly *p = geopolyBBox(context, argv[0], 0, 0); + (void)argc; + if( p ){ + sqlite3_result_blob(context, p->hdr, + 4+8*p->nVertex, SQLITE_TRANSIENT); + sqlite3_free(p); + } +} + +/* +** State vector for the geopoly_group_bbox() aggregate function. +*/ +typedef struct GeoBBox GeoBBox; +struct GeoBBox { + int isInit; + RtreeCoord a[4]; +}; + + +/* +** Implementation of the geopoly_group_bbox(X) aggregate SQL function. +*/ +static void geopolyBBoxStep( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + RtreeCoord a[4]; + int rc = SQLITE_OK; + (void)argc; + (void)geopolyBBox(context, argv[0], a, &rc); + if( rc==SQLITE_OK ){ + GeoBBox *pBBox; + pBBox = (GeoBBox*)sqlite3_aggregate_context(context, sizeof(*pBBox)); + if( pBBox==0 ) return; + if( pBBox->isInit==0 ){ + pBBox->isInit = 1; + memcpy(pBBox->a, a, sizeof(RtreeCoord)*4); + }else{ + if( a[0].f < pBBox->a[0].f ) pBBox->a[0] = a[0]; + if( a[1].f > pBBox->a[1].f ) pBBox->a[1] = a[1]; + if( a[2].f < pBBox->a[2].f ) pBBox->a[2] = a[2]; + if( a[3].f > pBBox->a[3].f ) pBBox->a[3] = a[3]; + } + } +} +static void geopolyBBoxFinal( + sqlite3_context *context +){ + GeoPoly *p; + GeoBBox *pBBox; + pBBox = (GeoBBox*)sqlite3_aggregate_context(context, 0); + if( pBBox==0 ) return; + p = geopolyBBox(context, 0, pBBox->a, 0); + if( p ){ + sqlite3_result_blob(context, p->hdr, + 4+8*p->nVertex, SQLITE_TRANSIENT); + sqlite3_free(p); + } +} + + +/* +** Determine if point (x0,y0) is beneath line segment (x1,y1)->(x2,y2). +** Returns: +** +** +2 x0,y0 is on the line segement +** +** +1 x0,y0 is beneath line segment +** +** 0 x0,y0 is not on or beneath the line segment or the line segment +** is vertical and x0,y0 is not on the line segment +** +** The left-most coordinate min(x1,x2) is not considered to be part of +** the line segment for the purposes of this analysis. +*/ +static int pointBeneathLine( + double x0, double y0, + double x1, double y1, + double x2, double y2 +){ + double y; + if( x0==x1 && y0==y1 ) return 2; + if( x1x2 ) return 0; + }else if( x1>x2 ){ + if( x0<=x2 || x0>x1 ) return 0; + }else{ + /* Vertical line segment */ + if( x0!=x1 ) return 0; + if( y0y1 && y0>y2 ) return 0; + return 2; + } + y = y1 + (y2-y1)*(x0-x1)/(x2-x1); + if( y0==y ) return 2; + if( y0nVertex-1; ii++){ + v = pointBeneathLine(x0,y0,GeoX(p1,ii), GeoY(p1,ii), + GeoX(p1,ii+1),GeoY(p1,ii+1)); + if( v==2 ) break; + cnt += v; + } + if( v!=2 ){ + v = pointBeneathLine(x0,y0,GeoX(p1,ii), GeoY(p1,ii), + GeoX(p1,0), GeoY(p1,0)); + } + if( v==2 ){ + sqlite3_result_int(context, 1); + }else if( ((v+cnt)&1)==0 ){ + sqlite3_result_int(context, 0); + }else{ + sqlite3_result_int(context, 2); + } + sqlite3_free(p1); +} + +/* Forward declaration */ +static int geopolyOverlap(GeoPoly *p1, GeoPoly *p2); + +/* +** SQL function: geopoly_within(P1,P2) +** +** Return +2 if P1 and P2 are the same polygon +** Return +1 if P2 is contained within P1 +** Return 0 if any part of P2 is on the outside of P1 +** +*/ +static void geopolyWithinFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + GeoPoly *p1 = geopolyFuncParam(context, argv[0], 0); + GeoPoly *p2 = geopolyFuncParam(context, argv[1], 0); + (void)argc; + if( p1 && p2 ){ + int x = geopolyOverlap(p1, p2); + if( x<0 ){ + sqlite3_result_error_nomem(context); + }else{ + sqlite3_result_int(context, x==2 ? 1 : x==4 ? 2 : 0); + } + } + sqlite3_free(p1); + sqlite3_free(p2); +} + +/* Objects used by the overlap algorihm. */ +typedef struct GeoEvent GeoEvent; +typedef struct GeoSegment GeoSegment; +typedef struct GeoOverlap GeoOverlap; +struct GeoEvent { + double x; /* X coordinate at which event occurs */ + int eType; /* 0 for ADD, 1 for REMOVE */ + GeoSegment *pSeg; /* The segment to be added or removed */ + GeoEvent *pNext; /* Next event in the sorted list */ +}; +struct GeoSegment { + double C, B; /* y = C*x + B */ + double y; /* Current y value */ + float y0; /* Initial y value */ + unsigned char side; /* 1 for p1, 2 for p2 */ + unsigned int idx; /* Which segment within the side */ + GeoSegment *pNext; /* Next segment in a list sorted by y */ +}; +struct GeoOverlap { + GeoEvent *aEvent; /* Array of all events */ + GeoSegment *aSegment; /* Array of all segments */ + int nEvent; /* Number of events */ + int nSegment; /* Number of segments */ +}; + +/* +** Add a single segment and its associated events. +*/ +static void geopolyAddOneSegment( + GeoOverlap *p, + GeoCoord x0, + GeoCoord y0, + GeoCoord x1, + GeoCoord y1, + unsigned char side, + unsigned int idx +){ + GeoSegment *pSeg; + GeoEvent *pEvent; + if( x0==x1 ) return; /* Ignore vertical segments */ + if( x0>x1 ){ + GeoCoord t = x0; + x0 = x1; + x1 = t; + t = y0; + y0 = y1; + y1 = t; + } + pSeg = p->aSegment + p->nSegment; + p->nSegment++; + pSeg->C = (y1-y0)/(x1-x0); + pSeg->B = y1 - x1*pSeg->C; + pSeg->y0 = y0; + pSeg->side = side; + pSeg->idx = idx; + pEvent = p->aEvent + p->nEvent; + p->nEvent++; + pEvent->x = x0; + pEvent->eType = 0; + pEvent->pSeg = pSeg; + pEvent = p->aEvent + p->nEvent; + p->nEvent++; + pEvent->x = x1; + pEvent->eType = 1; + pEvent->pSeg = pSeg; +} + + + +/* +** Insert all segments and events for polygon pPoly. +*/ +static void geopolyAddSegments( + GeoOverlap *p, /* Add segments to this Overlap object */ + GeoPoly *pPoly, /* Take all segments from this polygon */ + unsigned char side /* The side of pPoly */ +){ + unsigned int i; + GeoCoord *x; + for(i=0; i<(unsigned)pPoly->nVertex-1; i++){ + x = &GeoX(pPoly,i); + geopolyAddOneSegment(p, x[0], x[1], x[2], x[3], side, i); + } + x = &GeoX(pPoly,i); + geopolyAddOneSegment(p, x[0], x[1], pPoly->a[0], pPoly->a[1], side, i); +} + +/* +** Merge two lists of sorted events by X coordinate +*/ +static GeoEvent *geopolyEventMerge(GeoEvent *pLeft, GeoEvent *pRight){ + GeoEvent head, *pLast; + head.pNext = 0; + pLast = &head; + while( pRight && pLeft ){ + if( pRight->x <= pLeft->x ){ + pLast->pNext = pRight; + pLast = pRight; + pRight = pRight->pNext; + }else{ + pLast->pNext = pLeft; + pLast = pLeft; + pLeft = pLeft->pNext; + } + } + pLast->pNext = pRight ? pRight : pLeft; + return head.pNext; +} + +/* +** Sort an array of nEvent event objects into a list. +*/ +static GeoEvent *geopolySortEventsByX(GeoEvent *aEvent, int nEvent){ + int mx = 0; + int i, j; + GeoEvent *p; + GeoEvent *a[50]; + for(i=0; ipNext = 0; + for(j=0; j=mx ) mx = j+1; + } + p = 0; + for(i=0; iy - pLeft->y; + if( r==0.0 ) r = pRight->C - pLeft->C; + if( r<0.0 ){ + pLast->pNext = pRight; + pLast = pRight; + pRight = pRight->pNext; + }else{ + pLast->pNext = pLeft; + pLast = pLeft; + pLeft = pLeft->pNext; + } + } + pLast->pNext = pRight ? pRight : pLeft; + return head.pNext; +} + +/* +** Sort a list of GeoSegments in order of increasing Y and in the event of +** a tie, increasing C (slope). +*/ +static GeoSegment *geopolySortSegmentsByYAndC(GeoSegment *pList){ + int mx = 0; + int i; + GeoSegment *p; + GeoSegment *a[50]; + while( pList ){ + p = pList; + pList = pList->pNext; + p->pNext = 0; + for(i=0; i=mx ) mx = i+1; + } + p = 0; + for(i=0; inVertex + p2->nVertex + 2; + GeoOverlap *p; + sqlite3_int64 nByte; + GeoEvent *pThisEvent; + double rX; + int rc = 0; + int needSort = 0; + GeoSegment *pActive = 0; + GeoSegment *pSeg; + unsigned char aOverlap[4]; + + nByte = sizeof(GeoEvent)*nVertex*2 + + sizeof(GeoSegment)*nVertex + + sizeof(GeoOverlap); + p = sqlite3_malloc64( nByte ); + if( p==0 ) return -1; + p->aEvent = (GeoEvent*)&p[1]; + p->aSegment = (GeoSegment*)&p->aEvent[nVertex*2]; + p->nEvent = p->nSegment = 0; + geopolyAddSegments(p, p1, 1); + geopolyAddSegments(p, p2, 2); + pThisEvent = geopolySortEventsByX(p->aEvent, p->nEvent); + rX = pThisEvent && pThisEvent->x==0.0 ? -1.0 : 0.0; + memset(aOverlap, 0, sizeof(aOverlap)); + while( pThisEvent ){ + if( pThisEvent->x!=rX ){ + GeoSegment *pPrev = 0; + int iMask = 0; + GEODEBUG(("Distinct X: %g\n", pThisEvent->x)); + rX = pThisEvent->x; + if( needSort ){ + GEODEBUG(("SORT\n")); + pActive = geopolySortSegmentsByYAndC(pActive); + needSort = 0; + } + for(pSeg=pActive; pSeg; pSeg=pSeg->pNext){ + if( pPrev ){ + if( pPrev->y!=pSeg->y ){ + GEODEBUG(("MASK: %d\n", iMask)); + aOverlap[iMask] = 1; + } + } + iMask ^= pSeg->side; + pPrev = pSeg; + } + pPrev = 0; + for(pSeg=pActive; pSeg; pSeg=pSeg->pNext){ + double y = pSeg->C*rX + pSeg->B; + GEODEBUG(("Segment %d.%d %g->%g\n", pSeg->side, pSeg->idx, pSeg->y, y)); + pSeg->y = y; + if( pPrev ){ + if( pPrev->y>pSeg->y && pPrev->side!=pSeg->side ){ + rc = 1; + GEODEBUG(("Crossing: %d.%d and %d.%d\n", + pPrev->side, pPrev->idx, + pSeg->side, pSeg->idx)); + goto geopolyOverlapDone; + }else if( pPrev->y!=pSeg->y ){ + GEODEBUG(("MASK: %d\n", iMask)); + aOverlap[iMask] = 1; + } + } + iMask ^= pSeg->side; + pPrev = pSeg; + } + } + GEODEBUG(("%s %d.%d C=%g B=%g\n", + pThisEvent->eType ? "RM " : "ADD", + pThisEvent->pSeg->side, pThisEvent->pSeg->idx, + pThisEvent->pSeg->C, + pThisEvent->pSeg->B)); + if( pThisEvent->eType==0 ){ + /* Add a segment */ + pSeg = pThisEvent->pSeg; + pSeg->y = pSeg->y0; + pSeg->pNext = pActive; + pActive = pSeg; + needSort = 1; + }else{ + /* Remove a segment */ + if( pActive==pThisEvent->pSeg ){ + pActive = ALWAYS(pActive) ? pActive->pNext : 0; + }else{ + for(pSeg=pActive; pSeg; pSeg=pSeg->pNext){ + if( pSeg->pNext==pThisEvent->pSeg ){ + pSeg->pNext = ALWAYS(pSeg->pNext) ? pSeg->pNext->pNext : 0; + break; + } + } + } + } + pThisEvent = pThisEvent->pNext; + } + if( aOverlap[3]==0 ){ + rc = 0; + }else if( aOverlap[1]!=0 && aOverlap[2]==0 ){ + rc = 3; + }else if( aOverlap[1]==0 && aOverlap[2]!=0 ){ + rc = 2; + }else if( aOverlap[1]==0 && aOverlap[2]==0 ){ + rc = 4; + }else{ + rc = 1; + } + +geopolyOverlapDone: + sqlite3_free(p); + return rc; +} + +/* +** SQL function: geopoly_overlap(P1,P2) +** +** Determine whether or not P1 and P2 overlap. Return value: +** +** 0 The two polygons are disjoint +** 1 They overlap +** 2 P1 is completely contained within P2 +** 3 P2 is completely contained within P1 +** 4 P1 and P2 are the same polygon +** NULL Either P1 or P2 or both are not valid polygons +*/ +static void geopolyOverlapFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + GeoPoly *p1 = geopolyFuncParam(context, argv[0], 0); + GeoPoly *p2 = geopolyFuncParam(context, argv[1], 0); + (void)argc; + if( p1 && p2 ){ + int x = geopolyOverlap(p1, p2); + if( x<0 ){ + sqlite3_result_error_nomem(context); + }else{ + sqlite3_result_int(context, x); + } + } + sqlite3_free(p1); + sqlite3_free(p2); +} + +/* +** Enable or disable debugging output +*/ +static void geopolyDebugFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + (void)context; + (void)argc; +#ifdef GEOPOLY_ENABLE_DEBUG + geo_debug = sqlite3_value_int(argv[0]); +#else + (void)argv; +#endif +} + +/* +** This function is the implementation of both the xConnect and xCreate +** methods of the geopoly virtual table. +** +** argv[0] -> module name +** argv[1] -> database name +** argv[2] -> table name +** argv[...] -> column names... +*/ +static int geopolyInit( + sqlite3 *db, /* Database connection */ + void *pAux, /* One of the RTREE_COORD_* constants */ + int argc, const char *const*argv, /* Parameters to CREATE TABLE statement */ + sqlite3_vtab **ppVtab, /* OUT: New virtual table */ + char **pzErr, /* OUT: Error message, if any */ + int isCreate /* True for xCreate, false for xConnect */ +){ + int rc = SQLITE_OK; + Rtree *pRtree; + sqlite3_int64 nDb; /* Length of string argv[1] */ + sqlite3_int64 nName; /* Length of string argv[2] */ + sqlite3_str *pSql; + char *zSql; + int ii; + (void)pAux; + + sqlite3_vtab_config(db, SQLITE_VTAB_CONSTRAINT_SUPPORT, 1); + + /* Allocate the sqlite3_vtab structure */ + nDb = strlen(argv[1]); + nName = strlen(argv[2]); + pRtree = (Rtree *)sqlite3_malloc64(sizeof(Rtree)+nDb+nName+2); + if( !pRtree ){ + return SQLITE_NOMEM; + } + memset(pRtree, 0, sizeof(Rtree)+nDb+nName+2); + pRtree->nBusy = 1; + pRtree->base.pModule = &rtreeModule; + pRtree->zDb = (char *)&pRtree[1]; + pRtree->zName = &pRtree->zDb[nDb+1]; + pRtree->eCoordType = RTREE_COORD_REAL32; + pRtree->nDim = 2; + pRtree->nDim2 = 4; + memcpy(pRtree->zDb, argv[1], nDb); + memcpy(pRtree->zName, argv[2], nName); + + + /* Create/Connect to the underlying relational database schema. If + ** that is successful, call sqlite3_declare_vtab() to configure + ** the r-tree table schema. + */ + pSql = sqlite3_str_new(db); + sqlite3_str_appendf(pSql, "CREATE TABLE x(_shape"); + pRtree->nAux = 1; /* Add one for _shape */ + pRtree->nAuxNotNull = 1; /* The _shape column is always not-null */ + for(ii=3; iinAux++; + sqlite3_str_appendf(pSql, ",%s", argv[ii]); + } + sqlite3_str_appendf(pSql, ");"); + zSql = sqlite3_str_finish(pSql); + if( !zSql ){ + rc = SQLITE_NOMEM; + }else if( SQLITE_OK!=(rc = sqlite3_declare_vtab(db, zSql)) ){ + *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + } + sqlite3_free(zSql); + if( rc ) goto geopolyInit_fail; + pRtree->nBytesPerCell = 8 + pRtree->nDim2*4; + + /* Figure out the node size to use. */ + rc = getNodeSize(db, pRtree, isCreate, pzErr); + if( rc ) goto geopolyInit_fail; + rc = rtreeSqlInit(pRtree, db, argv[1], argv[2], isCreate); + if( rc ){ + *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + goto geopolyInit_fail; + } + + *ppVtab = (sqlite3_vtab *)pRtree; + return SQLITE_OK; + +geopolyInit_fail: + if( rc==SQLITE_OK ) rc = SQLITE_ERROR; + assert( *ppVtab==0 ); + assert( pRtree->nBusy==1 ); + rtreeRelease(pRtree); + return rc; +} + + +/* +** GEOPOLY virtual table module xCreate method. +*/ +static int geopolyCreate( + sqlite3 *db, + void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVtab, + char **pzErr +){ + return geopolyInit(db, pAux, argc, argv, ppVtab, pzErr, 1); +} + +/* +** GEOPOLY virtual table module xConnect method. +*/ +static int geopolyConnect( + sqlite3 *db, + void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVtab, + char **pzErr +){ + return geopolyInit(db, pAux, argc, argv, ppVtab, pzErr, 0); +} + + +/* +** GEOPOLY virtual table module xFilter method. +** +** Query plans: +** +** 1 rowid lookup +** 2 search for objects overlapping the same bounding box +** that contains polygon argv[0] +** 3 search for objects overlapping the same bounding box +** that contains polygon argv[0] +** 4 full table scan +*/ +static int geopolyFilter( + sqlite3_vtab_cursor *pVtabCursor, /* The cursor to initialize */ + int idxNum, /* Query plan */ + const char *idxStr, /* Not Used */ + int argc, sqlite3_value **argv /* Parameters to the query plan */ +){ + Rtree *pRtree = (Rtree *)pVtabCursor->pVtab; + RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor; + RtreeNode *pRoot = 0; + int rc = SQLITE_OK; + int iCell = 0; + (void)idxStr; + + rtreeReference(pRtree); + + /* Reset the cursor to the same state as rtreeOpen() leaves it in. */ + resetCursor(pCsr); + + pCsr->iStrategy = idxNum; + if( idxNum==1 ){ + /* Special case - lookup by rowid. */ + RtreeNode *pLeaf; /* Leaf on which the required cell resides */ + RtreeSearchPoint *p; /* Search point for the leaf */ + i64 iRowid = sqlite3_value_int64(argv[0]); + i64 iNode = 0; + rc = findLeafNode(pRtree, iRowid, &pLeaf, &iNode); + if( rc==SQLITE_OK && pLeaf!=0 ){ + p = rtreeSearchPointNew(pCsr, RTREE_ZERO, 0); + assert( p!=0 ); /* Always returns pCsr->sPoint */ + pCsr->aNode[0] = pLeaf; + p->id = iNode; + p->eWithin = PARTLY_WITHIN; + rc = nodeRowidIndex(pRtree, pLeaf, iRowid, &iCell); + p->iCell = (u8)iCell; + RTREE_QUEUE_TRACE(pCsr, "PUSH-F1:"); + }else{ + pCsr->atEOF = 1; + } + }else{ + /* Normal case - r-tree scan. Set up the RtreeCursor.aConstraint array + ** with the configured constraints. + */ + rc = nodeAcquire(pRtree, 1, 0, &pRoot); + if( rc==SQLITE_OK && idxNum<=3 ){ + RtreeCoord bbox[4]; + RtreeConstraint *p; + assert( argc==1 ); + assert( argv[0]!=0 ); + geopolyBBox(0, argv[0], bbox, &rc); + if( rc ){ + goto geopoly_filter_end; + } + pCsr->aConstraint = p = sqlite3_malloc(sizeof(RtreeConstraint)*4); + pCsr->nConstraint = 4; + if( p==0 ){ + rc = SQLITE_NOMEM; + }else{ + memset(pCsr->aConstraint, 0, sizeof(RtreeConstraint)*4); + memset(pCsr->anQueue, 0, sizeof(u32)*(pRtree->iDepth + 1)); + if( idxNum==2 ){ + /* Overlap query */ + p->op = 'B'; + p->iCoord = 0; + p->u.rValue = bbox[1].f; + p++; + p->op = 'D'; + p->iCoord = 1; + p->u.rValue = bbox[0].f; + p++; + p->op = 'B'; + p->iCoord = 2; + p->u.rValue = bbox[3].f; + p++; + p->op = 'D'; + p->iCoord = 3; + p->u.rValue = bbox[2].f; + }else{ + /* Within query */ + p->op = 'D'; + p->iCoord = 0; + p->u.rValue = bbox[0].f; + p++; + p->op = 'B'; + p->iCoord = 1; + p->u.rValue = bbox[1].f; + p++; + p->op = 'D'; + p->iCoord = 2; + p->u.rValue = bbox[2].f; + p++; + p->op = 'B'; + p->iCoord = 3; + p->u.rValue = bbox[3].f; + } + } + } + if( rc==SQLITE_OK ){ + RtreeSearchPoint *pNew; + pNew = rtreeSearchPointNew(pCsr, RTREE_ZERO, (u8)(pRtree->iDepth+1)); + if( pNew==0 ){ + rc = SQLITE_NOMEM; + goto geopoly_filter_end; + } + pNew->id = 1; + pNew->iCell = 0; + pNew->eWithin = PARTLY_WITHIN; + assert( pCsr->bPoint==1 ); + pCsr->aNode[0] = pRoot; + pRoot = 0; + RTREE_QUEUE_TRACE(pCsr, "PUSH-Fm:"); + rc = rtreeStepToLeaf(pCsr); + } + } + +geopoly_filter_end: + nodeRelease(pRtree, pRoot); + rtreeRelease(pRtree); + return rc; +} + +/* +** Rtree virtual table module xBestIndex method. There are three +** table scan strategies to choose from (in order from most to +** least desirable): +** +** idxNum idxStr Strategy +** ------------------------------------------------ +** 1 "rowid" Direct lookup by rowid. +** 2 "rtree" R-tree overlap query using geopoly_overlap() +** 3 "rtree" R-tree within query using geopoly_within() +** 4 "fullscan" full-table scan. +** ------------------------------------------------ +*/ +static int geopolyBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){ + int ii; + int iRowidTerm = -1; + int iFuncTerm = -1; + int idxNum = 0; + (void)tab; + + for(ii=0; iinConstraint; ii++){ + struct sqlite3_index_constraint *p = &pIdxInfo->aConstraint[ii]; + if( !p->usable ) continue; + if( p->iColumn<0 && p->op==SQLITE_INDEX_CONSTRAINT_EQ ){ + iRowidTerm = ii; + break; + } + if( p->iColumn==0 && p->op>=SQLITE_INDEX_CONSTRAINT_FUNCTION ){ + /* p->op==SQLITE_INDEX_CONSTRAINT_FUNCTION for geopoly_overlap() + ** p->op==(SQLITE_INDEX_CONTRAINT_FUNCTION+1) for geopoly_within(). + ** See geopolyFindFunction() */ + iFuncTerm = ii; + idxNum = p->op - SQLITE_INDEX_CONSTRAINT_FUNCTION + 2; + } + } + + if( iRowidTerm>=0 ){ + pIdxInfo->idxNum = 1; + pIdxInfo->idxStr = "rowid"; + pIdxInfo->aConstraintUsage[iRowidTerm].argvIndex = 1; + pIdxInfo->aConstraintUsage[iRowidTerm].omit = 1; + pIdxInfo->estimatedCost = 30.0; + pIdxInfo->estimatedRows = 1; + pIdxInfo->idxFlags = SQLITE_INDEX_SCAN_UNIQUE; + return SQLITE_OK; + } + if( iFuncTerm>=0 ){ + pIdxInfo->idxNum = idxNum; + pIdxInfo->idxStr = "rtree"; + pIdxInfo->aConstraintUsage[iFuncTerm].argvIndex = 1; + pIdxInfo->aConstraintUsage[iFuncTerm].omit = 0; + pIdxInfo->estimatedCost = 300.0; + pIdxInfo->estimatedRows = 10; + return SQLITE_OK; + } + pIdxInfo->idxNum = 4; + pIdxInfo->idxStr = "fullscan"; + pIdxInfo->estimatedCost = 3000000.0; + pIdxInfo->estimatedRows = 100000; + return SQLITE_OK; +} + + +/* +** GEOPOLY virtual table module xColumn method. +*/ +static int geopolyColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){ + Rtree *pRtree = (Rtree *)cur->pVtab; + RtreeCursor *pCsr = (RtreeCursor *)cur; + RtreeSearchPoint *p = rtreeSearchPointFirst(pCsr); + int rc = SQLITE_OK; + RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc); + + if( rc ) return rc; + if( p==0 ) return SQLITE_OK; + if( i==0 && sqlite3_vtab_nochange(ctx) ) return SQLITE_OK; + if( i<=pRtree->nAux ){ + if( !pCsr->bAuxValid ){ + if( pCsr->pReadAux==0 ){ + rc = sqlite3_prepare_v3(pRtree->db, pRtree->zReadAuxSql, -1, 0, + &pCsr->pReadAux, 0); + if( rc ) return rc; + } + sqlite3_bind_int64(pCsr->pReadAux, 1, + nodeGetRowid(pRtree, pNode, p->iCell)); + rc = sqlite3_step(pCsr->pReadAux); + if( rc==SQLITE_ROW ){ + pCsr->bAuxValid = 1; + }else{ + sqlite3_reset(pCsr->pReadAux); + if( rc==SQLITE_DONE ) rc = SQLITE_OK; + return rc; + } + } + sqlite3_result_value(ctx, sqlite3_column_value(pCsr->pReadAux, i+2)); + } + return SQLITE_OK; +} + + +/* +** The xUpdate method for GEOPOLY module virtual tables. +** +** For DELETE: +** +** argv[0] = the rowid to be deleted +** +** For INSERT: +** +** argv[0] = SQL NULL +** argv[1] = rowid to insert, or an SQL NULL to select automatically +** argv[2] = _shape column +** argv[3] = first application-defined column.... +** +** For UPDATE: +** +** argv[0] = rowid to modify. Never NULL +** argv[1] = rowid after the change. Never NULL +** argv[2] = new value for _shape +** argv[3] = new value for first application-defined column.... +*/ +static int geopolyUpdate( + sqlite3_vtab *pVtab, + int nData, + sqlite3_value **aData, + sqlite_int64 *pRowid +){ + Rtree *pRtree = (Rtree *)pVtab; + int rc = SQLITE_OK; + RtreeCell cell; /* New cell to insert if nData>1 */ + i64 oldRowid; /* The old rowid */ + int oldRowidValid; /* True if oldRowid is valid */ + i64 newRowid; /* The new rowid */ + int newRowidValid; /* True if newRowid is valid */ + int coordChange = 0; /* Change in coordinates */ + + if( pRtree->nNodeRef ){ + /* Unable to write to the btree while another cursor is reading from it, + ** since the write might do a rebalance which would disrupt the read + ** cursor. */ + return SQLITE_LOCKED_VTAB; + } + rtreeReference(pRtree); + assert(nData>=1); + + oldRowidValid = sqlite3_value_type(aData[0])!=SQLITE_NULL;; + oldRowid = oldRowidValid ? sqlite3_value_int64(aData[0]) : 0; + newRowidValid = nData>1 && sqlite3_value_type(aData[1])!=SQLITE_NULL; + newRowid = newRowidValid ? sqlite3_value_int64(aData[1]) : 0; + cell.iRowid = newRowid; + + if( nData>1 /* not a DELETE */ + && (!oldRowidValid /* INSERT */ + || !sqlite3_value_nochange(aData[2]) /* UPDATE _shape */ + || oldRowid!=newRowid) /* Rowid change */ + ){ + assert( aData[2]!=0 ); + geopolyBBox(0, aData[2], cell.aCoord, &rc); + if( rc ){ + if( rc==SQLITE_ERROR ){ + pVtab->zErrMsg = + sqlite3_mprintf("_shape does not contain a valid polygon"); + } + goto geopoly_update_end; + } + coordChange = 1; + + /* If a rowid value was supplied, check if it is already present in + ** the table. If so, the constraint has failed. */ + if( newRowidValid && (!oldRowidValid || oldRowid!=newRowid) ){ + int steprc; + sqlite3_bind_int64(pRtree->pReadRowid, 1, cell.iRowid); + steprc = sqlite3_step(pRtree->pReadRowid); + rc = sqlite3_reset(pRtree->pReadRowid); + if( SQLITE_ROW==steprc ){ + if( sqlite3_vtab_on_conflict(pRtree->db)==SQLITE_REPLACE ){ + rc = rtreeDeleteRowid(pRtree, cell.iRowid); + }else{ + rc = rtreeConstraintError(pRtree, 0); + } + } + } + } + + /* If aData[0] is not an SQL NULL value, it is the rowid of a + ** record to delete from the r-tree table. The following block does + ** just that. + */ + if( rc==SQLITE_OK && (nData==1 || (coordChange && oldRowidValid)) ){ + rc = rtreeDeleteRowid(pRtree, oldRowid); + } + + /* If the aData[] array contains more than one element, elements + ** (aData[2]..aData[argc-1]) contain a new record to insert into + ** the r-tree structure. + */ + if( rc==SQLITE_OK && nData>1 && coordChange ){ + /* Insert the new record into the r-tree */ + RtreeNode *pLeaf = 0; + if( !newRowidValid ){ + rc = rtreeNewRowid(pRtree, &cell.iRowid); + } + *pRowid = cell.iRowid; + if( rc==SQLITE_OK ){ + rc = ChooseLeaf(pRtree, &cell, 0, &pLeaf); + } + if( rc==SQLITE_OK ){ + int rc2; + pRtree->iReinsertHeight = -1; + rc = rtreeInsertCell(pRtree, pLeaf, &cell, 0); + rc2 = nodeRelease(pRtree, pLeaf); + if( rc==SQLITE_OK ){ + rc = rc2; + } + } + } + + /* Change the data */ + if( rc==SQLITE_OK && nData>1 ){ + sqlite3_stmt *pUp = pRtree->pWriteAux; + int jj; + int nChange = 0; + sqlite3_bind_int64(pUp, 1, cell.iRowid); + assert( pRtree->nAux>=1 ); + if( sqlite3_value_nochange(aData[2]) ){ + sqlite3_bind_null(pUp, 2); + }else{ + GeoPoly *p = 0; + if( sqlite3_value_type(aData[2])==SQLITE_TEXT + && (p = geopolyFuncParam(0, aData[2], &rc))!=0 + && rc==SQLITE_OK + ){ + sqlite3_bind_blob(pUp, 2, p->hdr, 4+8*p->nVertex, SQLITE_TRANSIENT); + }else{ + sqlite3_bind_value(pUp, 2, aData[2]); + } + sqlite3_free(p); + nChange = 1; + } + for(jj=1; jjxDestructor ) pInfo->xDestructor(pInfo->pContext); + sqlite3_free(p); +} + +/* +** This routine frees the BLOB that is returned by geomCallback(). +*/ +static void rtreeMatchArgFree(void *pArg){ + int i; + RtreeMatchArg *p = (RtreeMatchArg*)pArg; + for(i=0; inParam; i++){ + sqlite3_value_free(p->apSqlParam[i]); + } + sqlite3_free(p); +} + +/* +** Each call to sqlite3_rtree_geometry_callback() or +** sqlite3_rtree_query_callback() creates an ordinary SQLite +** scalar function that is implemented by this routine. +** +** All this function does is construct an RtreeMatchArg object that +** contains the geometry-checking callback routines and a list of +** parameters to this function, then return that RtreeMatchArg object +** as a BLOB. +** +** The R-Tree MATCH operator will read the returned BLOB, deserialize +** the RtreeMatchArg object, and use the RtreeMatchArg object to figure +** out which elements of the R-Tree should be returned by the query. +*/ +static void geomCallback(sqlite3_context *ctx, int nArg, sqlite3_value **aArg){ + RtreeGeomCallback *pGeomCtx = (RtreeGeomCallback *)sqlite3_user_data(ctx); + RtreeMatchArg *pBlob; + sqlite3_int64 nBlob; + int memErr = 0; + + nBlob = sizeof(RtreeMatchArg) + (nArg-1)*sizeof(RtreeDValue) + + nArg*sizeof(sqlite3_value*); + pBlob = (RtreeMatchArg *)sqlite3_malloc64(nBlob); + if( !pBlob ){ + sqlite3_result_error_nomem(ctx); + }else{ + int i; + pBlob->iSize = nBlob; + pBlob->cb = pGeomCtx[0]; + pBlob->apSqlParam = (sqlite3_value**)&pBlob->aParam[nArg]; + pBlob->nParam = nArg; + for(i=0; iapSqlParam[i] = sqlite3_value_dup(aArg[i]); + if( pBlob->apSqlParam[i]==0 ) memErr = 1; +#ifdef SQLITE_RTREE_INT_ONLY + pBlob->aParam[i] = sqlite3_value_int64(aArg[i]); +#else + pBlob->aParam[i] = sqlite3_value_double(aArg[i]); +#endif + } + if( memErr ){ + sqlite3_result_error_nomem(ctx); + rtreeMatchArgFree(pBlob); + }else{ + sqlite3_result_pointer(ctx, pBlob, "RtreeMatchArg", rtreeMatchArgFree); + } + } +} + +/* +** Register a new geometry function for use with the r-tree MATCH operator. +*/ +SQLITE_API int sqlite3_rtree_geometry_callback( + sqlite3 *db, /* Register SQL function on this connection */ + const char *zGeom, /* Name of the new SQL function */ + int (*xGeom)(sqlite3_rtree_geometry*,int,RtreeDValue*,int*), /* Callback */ + void *pContext /* Extra data associated with the callback */ +){ + RtreeGeomCallback *pGeomCtx; /* Context object for new user-function */ + + /* Allocate and populate the context object. */ + pGeomCtx = (RtreeGeomCallback *)sqlite3_malloc(sizeof(RtreeGeomCallback)); + if( !pGeomCtx ) return SQLITE_NOMEM; + pGeomCtx->xGeom = xGeom; + pGeomCtx->xQueryFunc = 0; + pGeomCtx->xDestructor = 0; + pGeomCtx->pContext = pContext; + return sqlite3_create_function_v2(db, zGeom, -1, SQLITE_ANY, + (void *)pGeomCtx, geomCallback, 0, 0, rtreeFreeCallback + ); +} + +/* +** Register a new 2nd-generation geometry function for use with the +** r-tree MATCH operator. +*/ +SQLITE_API int sqlite3_rtree_query_callback( + sqlite3 *db, /* Register SQL function on this connection */ + const char *zQueryFunc, /* Name of new SQL function */ + int (*xQueryFunc)(sqlite3_rtree_query_info*), /* Callback */ + void *pContext, /* Extra data passed into the callback */ + void (*xDestructor)(void*) /* Destructor for the extra data */ +){ + RtreeGeomCallback *pGeomCtx; /* Context object for new user-function */ + + /* Allocate and populate the context object. */ + pGeomCtx = (RtreeGeomCallback *)sqlite3_malloc(sizeof(RtreeGeomCallback)); + if( !pGeomCtx ){ + if( xDestructor ) xDestructor(pContext); + return SQLITE_NOMEM; + } + pGeomCtx->xGeom = 0; + pGeomCtx->xQueryFunc = xQueryFunc; + pGeomCtx->xDestructor = xDestructor; + pGeomCtx->pContext = pContext; + return sqlite3_create_function_v2(db, zQueryFunc, -1, SQLITE_ANY, + (void *)pGeomCtx, geomCallback, 0, 0, rtreeFreeCallback + ); +} + +#if !SQLITE_CORE +#ifdef _WIN32 +__declspec(dllexport) +#endif +SQLITE_API int sqlite3_rtree_init( + sqlite3 *db, + char **pzErrMsg, + const sqlite3_api_routines *pApi +){ + SQLITE_EXTENSION_INIT2(pApi) + return sqlite3RtreeInit(db); +} +#endif + +#endif + +/************** End of rtree.c ***********************************************/ +/************** Begin file icu.c *********************************************/ +/* +** 2007 May 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** $Id: icu.c,v 1.7 2007/12/13 21:54:11 drh Exp $ +** +** This file implements an integration between the ICU library +** ("International Components for Unicode", an open-source library +** for handling unicode data) and SQLite. The integration uses +** ICU to provide the following to SQLite: +** +** * An implementation of the SQL regexp() function (and hence REGEXP +** operator) using the ICU uregex_XX() APIs. +** +** * Implementations of the SQL scalar upper() and lower() functions +** for case mapping. +** +** * Integration of ICU and SQLite collation sequences. +** +** * An implementation of the LIKE operator that uses ICU to +** provide case-independent matching. +*/ + +#if !defined(SQLITE_CORE) \ + || defined(SQLITE_ENABLE_ICU) \ + || defined(SQLITE_ENABLE_ICU_COLLATIONS) + +/* Include ICU headers */ +#include +#include +#include +#include + +/* #include */ + +#ifndef SQLITE_CORE +/* #include "sqlite3ext.h" */ + SQLITE_EXTENSION_INIT1 +#else +/* #include "sqlite3.h" */ +#endif + +/* +** This function is called when an ICU function called from within +** the implementation of an SQL scalar function returns an error. +** +** The scalar function context passed as the first argument is +** loaded with an error message based on the following two args. +*/ +static void icuFunctionError( + sqlite3_context *pCtx, /* SQLite scalar function context */ + const char *zName, /* Name of ICU function that failed */ + UErrorCode e /* Error code returned by ICU function */ +){ + char zBuf[128]; + sqlite3_snprintf(128, zBuf, "ICU error: %s(): %s", zName, u_errorName(e)); + zBuf[127] = '\0'; + sqlite3_result_error(pCtx, zBuf, -1); +} + +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_ICU) + +/* +** Maximum length (in bytes) of the pattern in a LIKE or GLOB +** operator. +*/ +#ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH +# define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000 +#endif + +/* +** Version of sqlite3_free() that is always a function, never a macro. +*/ +static void xFree(void *p){ + sqlite3_free(p); +} + +/* +** This lookup table is used to help decode the first byte of +** a multi-byte UTF8 character. It is copied here from SQLite source +** code file utf8.c. +*/ +static const unsigned char icuUtf8Trans1[] = { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x00, 0x00, +}; + +#define SQLITE_ICU_READ_UTF8(zIn, c) \ + c = *(zIn++); \ + if( c>=0xc0 ){ \ + c = icuUtf8Trans1[c-0xc0]; \ + while( (*zIn & 0xc0)==0x80 ){ \ + c = (c<<6) + (0x3f & *(zIn++)); \ + } \ + } + +#define SQLITE_ICU_SKIP_UTF8(zIn) \ + assert( *zIn ); \ + if( *(zIn++)>=0xc0 ){ \ + while( (*zIn & 0xc0)==0x80 ){zIn++;} \ + } + + +/* +** Compare two UTF-8 strings for equality where the first string is +** a "LIKE" expression. Return true (1) if they are the same and +** false (0) if they are different. +*/ +static int icuLikeCompare( + const uint8_t *zPattern, /* LIKE pattern */ + const uint8_t *zString, /* The UTF-8 string to compare against */ + const UChar32 uEsc /* The escape character */ +){ + static const uint32_t MATCH_ONE = (uint32_t)'_'; + static const uint32_t MATCH_ALL = (uint32_t)'%'; + + int prevEscape = 0; /* True if the previous character was uEsc */ + + while( 1 ){ + + /* Read (and consume) the next character from the input pattern. */ + uint32_t uPattern; + SQLITE_ICU_READ_UTF8(zPattern, uPattern); + if( uPattern==0 ) break; + + /* There are now 4 possibilities: + ** + ** 1. uPattern is an unescaped match-all character "%", + ** 2. uPattern is an unescaped match-one character "_", + ** 3. uPattern is an unescaped escape character, or + ** 4. uPattern is to be handled as an ordinary character + */ + if( uPattern==MATCH_ALL && !prevEscape && uPattern!=(uint32_t)uEsc ){ + /* Case 1. */ + uint8_t c; + + /* Skip any MATCH_ALL or MATCH_ONE characters that follow a + ** MATCH_ALL. For each MATCH_ONE, skip one character in the + ** test string. + */ + while( (c=*zPattern) == MATCH_ALL || c == MATCH_ONE ){ + if( c==MATCH_ONE ){ + if( *zString==0 ) return 0; + SQLITE_ICU_SKIP_UTF8(zString); + } + zPattern++; + } + + if( *zPattern==0 ) return 1; + + while( *zString ){ + if( icuLikeCompare(zPattern, zString, uEsc) ){ + return 1; + } + SQLITE_ICU_SKIP_UTF8(zString); + } + return 0; + + }else if( uPattern==MATCH_ONE && !prevEscape && uPattern!=(uint32_t)uEsc ){ + /* Case 2. */ + if( *zString==0 ) return 0; + SQLITE_ICU_SKIP_UTF8(zString); + + }else if( uPattern==(uint32_t)uEsc && !prevEscape ){ + /* Case 3. */ + prevEscape = 1; + + }else{ + /* Case 4. */ + uint32_t uString; + SQLITE_ICU_READ_UTF8(zString, uString); + uString = (uint32_t)u_foldCase((UChar32)uString, U_FOLD_CASE_DEFAULT); + uPattern = (uint32_t)u_foldCase((UChar32)uPattern, U_FOLD_CASE_DEFAULT); + if( uString!=uPattern ){ + return 0; + } + prevEscape = 0; + } + } + + return *zString==0; +} + +/* +** Implementation of the like() SQL function. This function implements +** the build-in LIKE operator. The first argument to the function is the +** pattern and the second argument is the string. So, the SQL statements: +** +** A LIKE B +** +** is implemented as like(B, A). If there is an escape character E, +** +** A LIKE B ESCAPE E +** +** is mapped to like(B, A, E). +*/ +static void icuLikeFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *zA = sqlite3_value_text(argv[0]); + const unsigned char *zB = sqlite3_value_text(argv[1]); + UChar32 uEsc = 0; + + /* Limit the length of the LIKE or GLOB pattern to avoid problems + ** of deep recursion and N*N behavior in patternCompare(). + */ + if( sqlite3_value_bytes(argv[0])>SQLITE_MAX_LIKE_PATTERN_LENGTH ){ + sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1); + return; + } + + + if( argc==3 ){ + /* The escape character string must consist of a single UTF-8 character. + ** Otherwise, return an error. + */ + int nE= sqlite3_value_bytes(argv[2]); + const unsigned char *zE = sqlite3_value_text(argv[2]); + int i = 0; + if( zE==0 ) return; + U8_NEXT(zE, i, nE, uEsc); + if( i!=nE){ + sqlite3_result_error(context, + "ESCAPE expression must be a single character", -1); + return; + } + } + + if( zA && zB ){ + sqlite3_result_int(context, icuLikeCompare(zA, zB, uEsc)); + } +} + +/* +** Function to delete compiled regexp objects. Registered as +** a destructor function with sqlite3_set_auxdata(). +*/ +static void icuRegexpDelete(void *p){ + URegularExpression *pExpr = (URegularExpression *)p; + uregex_close(pExpr); +} + +/* +** Implementation of SQLite REGEXP operator. This scalar function takes +** two arguments. The first is a regular expression pattern to compile +** the second is a string to match against that pattern. If either +** argument is an SQL NULL, then NULL Is returned. Otherwise, the result +** is 1 if the string matches the pattern, or 0 otherwise. +** +** SQLite maps the regexp() function to the regexp() operator such +** that the following two are equivalent: +** +** zString REGEXP zPattern +** regexp(zPattern, zString) +** +** Uses the following ICU regexp APIs: +** +** uregex_open() +** uregex_matches() +** uregex_close() +*/ +static void icuRegexpFunc(sqlite3_context *p, int nArg, sqlite3_value **apArg){ + UErrorCode status = U_ZERO_ERROR; + URegularExpression *pExpr; + UBool res; + const UChar *zString = sqlite3_value_text16(apArg[1]); + + (void)nArg; /* Unused parameter */ + + /* If the left hand side of the regexp operator is NULL, + ** then the result is also NULL. + */ + if( !zString ){ + return; + } + + pExpr = sqlite3_get_auxdata(p, 0); + if( !pExpr ){ + const UChar *zPattern = sqlite3_value_text16(apArg[0]); + if( !zPattern ){ + return; + } + pExpr = uregex_open(zPattern, -1, 0, 0, &status); + + if( U_SUCCESS(status) ){ + sqlite3_set_auxdata(p, 0, pExpr, icuRegexpDelete); + pExpr = sqlite3_get_auxdata(p, 0); + } + if( !pExpr ){ + icuFunctionError(p, "uregex_open", status); + return; + } + } + + /* Configure the text that the regular expression operates on. */ + uregex_setText(pExpr, zString, -1, &status); + if( !U_SUCCESS(status) ){ + icuFunctionError(p, "uregex_setText", status); + return; + } + + /* Attempt the match */ + res = uregex_matches(pExpr, 0, &status); + if( !U_SUCCESS(status) ){ + icuFunctionError(p, "uregex_matches", status); + return; + } + + /* Set the text that the regular expression operates on to a NULL + ** pointer. This is not really necessary, but it is tidier than + ** leaving the regular expression object configured with an invalid + ** pointer after this function returns. + */ + uregex_setText(pExpr, 0, 0, &status); + + /* Return 1 or 0. */ + sqlite3_result_int(p, res ? 1 : 0); +} + +/* +** Implementations of scalar functions for case mapping - upper() and +** lower(). Function upper() converts its input to upper-case (ABC). +** Function lower() converts to lower-case (abc). +** +** ICU provides two types of case mapping, "general" case mapping and +** "language specific". Refer to ICU documentation for the differences +** between the two. +** +** To utilise "general" case mapping, the upper() or lower() scalar +** functions are invoked with one argument: +** +** upper('ABC') -> 'abc' +** lower('abc') -> 'ABC' +** +** To access ICU "language specific" case mapping, upper() or lower() +** should be invoked with two arguments. The second argument is the name +** of the locale to use. Passing an empty string ("") or SQL NULL value +** as the second argument is the same as invoking the 1 argument version +** of upper() or lower(). +** +** lower('I', 'en_us') -> 'i' +** lower('I', 'tr_tr') -> '\u131' (small dotless i) +** +** http://www.icu-project.org/userguide/posix.html#case_mappings +*/ +static void icuCaseFunc16(sqlite3_context *p, int nArg, sqlite3_value **apArg){ + const UChar *zInput; /* Pointer to input string */ + UChar *zOutput = 0; /* Pointer to output buffer */ + int nInput; /* Size of utf-16 input string in bytes */ + int nOut; /* Size of output buffer in bytes */ + int cnt; + int bToUpper; /* True for toupper(), false for tolower() */ + UErrorCode status; + const char *zLocale = 0; + + assert(nArg==1 || nArg==2); + bToUpper = (sqlite3_user_data(p)!=0); + if( nArg==2 ){ + zLocale = (const char *)sqlite3_value_text(apArg[1]); + } + + zInput = sqlite3_value_text16(apArg[0]); + if( !zInput ){ + return; + } + nOut = nInput = sqlite3_value_bytes16(apArg[0]); + if( nOut==0 ){ + sqlite3_result_text16(p, "", 0, SQLITE_STATIC); + return; + } + + for(cnt=0; cnt<2; cnt++){ + UChar *zNew = sqlite3_realloc(zOutput, nOut); + if( zNew==0 ){ + sqlite3_free(zOutput); + sqlite3_result_error_nomem(p); + return; + } + zOutput = zNew; + status = U_ZERO_ERROR; + if( bToUpper ){ + nOut = 2*u_strToUpper(zOutput,nOut/2,zInput,nInput/2,zLocale,&status); + }else{ + nOut = 2*u_strToLower(zOutput,nOut/2,zInput,nInput/2,zLocale,&status); + } + + if( U_SUCCESS(status) ){ + sqlite3_result_text16(p, zOutput, nOut, xFree); + }else if( status==U_BUFFER_OVERFLOW_ERROR ){ + assert( cnt==0 ); + continue; + }else{ + icuFunctionError(p, bToUpper ? "u_strToUpper" : "u_strToLower", status); + } + return; + } + assert( 0 ); /* Unreachable */ +} + +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_ICU) */ + +/* +** Collation sequence destructor function. The pCtx argument points to +** a UCollator structure previously allocated using ucol_open(). +*/ +static void icuCollationDel(void *pCtx){ + UCollator *p = (UCollator *)pCtx; + ucol_close(p); +} + +/* +** Collation sequence comparison function. The pCtx argument points to +** a UCollator structure previously allocated using ucol_open(). +*/ +static int icuCollationColl( + void *pCtx, + int nLeft, + const void *zLeft, + int nRight, + const void *zRight +){ + UCollationResult res; + UCollator *p = (UCollator *)pCtx; + res = ucol_strcoll(p, (UChar *)zLeft, nLeft/2, (UChar *)zRight, nRight/2); + switch( res ){ + case UCOL_LESS: return -1; + case UCOL_GREATER: return +1; + case UCOL_EQUAL: return 0; + } + assert(!"Unexpected return value from ucol_strcoll()"); + return 0; +} + +/* +** Implementation of the scalar function icu_load_collation(). +** +** This scalar function is used to add ICU collation based collation +** types to an SQLite database connection. It is intended to be called +** as follows: +** +** SELECT icu_load_collation(, ); +** +** Where is a string containing an ICU locale identifier (i.e. +** "en_AU", "tr_TR" etc.) and is the name of the +** collation sequence to create. +*/ +static void icuLoadCollation( + sqlite3_context *p, + int nArg, + sqlite3_value **apArg +){ + sqlite3 *db = (sqlite3 *)sqlite3_user_data(p); + UErrorCode status = U_ZERO_ERROR; + const char *zLocale; /* Locale identifier - (eg. "jp_JP") */ + const char *zName; /* SQL Collation sequence name (eg. "japanese") */ + UCollator *pUCollator; /* ICU library collation object */ + int rc; /* Return code from sqlite3_create_collation_x() */ + + assert(nArg==2); + (void)nArg; /* Unused parameter */ + zLocale = (const char *)sqlite3_value_text(apArg[0]); + zName = (const char *)sqlite3_value_text(apArg[1]); + + if( !zLocale || !zName ){ + return; + } + + pUCollator = ucol_open(zLocale, &status); + if( !U_SUCCESS(status) ){ + icuFunctionError(p, "ucol_open", status); + return; + } + assert(p); + + rc = sqlite3_create_collation_v2(db, zName, SQLITE_UTF16, (void *)pUCollator, + icuCollationColl, icuCollationDel + ); + if( rc!=SQLITE_OK ){ + ucol_close(pUCollator); + sqlite3_result_error(p, "Error registering collation function", -1); + } +} + +/* +** Register the ICU extension functions with database db. +*/ +SQLITE_PRIVATE int sqlite3IcuInit(sqlite3 *db){ +# define SQLITEICU_EXTRAFLAGS (SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS) + static const struct IcuScalar { + const char *zName; /* Function name */ + unsigned char nArg; /* Number of arguments */ + unsigned int enc; /* Optimal text encoding */ + unsigned char iContext; /* sqlite3_user_data() context */ + void (*xFunc)(sqlite3_context*,int,sqlite3_value**); + } scalars[] = { + {"icu_load_collation",2,SQLITE_UTF8|SQLITE_DIRECTONLY,1, icuLoadCollation}, +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_ICU) + {"regexp", 2, SQLITE_ANY|SQLITEICU_EXTRAFLAGS, 0, icuRegexpFunc}, + {"lower", 1, SQLITE_UTF16|SQLITEICU_EXTRAFLAGS, 0, icuCaseFunc16}, + {"lower", 2, SQLITE_UTF16|SQLITEICU_EXTRAFLAGS, 0, icuCaseFunc16}, + {"upper", 1, SQLITE_UTF16|SQLITEICU_EXTRAFLAGS, 1, icuCaseFunc16}, + {"upper", 2, SQLITE_UTF16|SQLITEICU_EXTRAFLAGS, 1, icuCaseFunc16}, + {"lower", 1, SQLITE_UTF8|SQLITEICU_EXTRAFLAGS, 0, icuCaseFunc16}, + {"lower", 2, SQLITE_UTF8|SQLITEICU_EXTRAFLAGS, 0, icuCaseFunc16}, + {"upper", 1, SQLITE_UTF8|SQLITEICU_EXTRAFLAGS, 1, icuCaseFunc16}, + {"upper", 2, SQLITE_UTF8|SQLITEICU_EXTRAFLAGS, 1, icuCaseFunc16}, + {"like", 2, SQLITE_UTF8|SQLITEICU_EXTRAFLAGS, 0, icuLikeFunc}, + {"like", 3, SQLITE_UTF8|SQLITEICU_EXTRAFLAGS, 0, icuLikeFunc}, +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_ICU) */ + }; + int rc = SQLITE_OK; + int i; + + for(i=0; rc==SQLITE_OK && i<(int)(sizeof(scalars)/sizeof(scalars[0])); i++){ + const struct IcuScalar *p = &scalars[i]; + rc = sqlite3_create_function( + db, p->zName, p->nArg, p->enc, + p->iContext ? (void*)db : (void*)0, + p->xFunc, 0, 0 + ); + } + + return rc; +} + +#if !SQLITE_CORE +#ifdef _WIN32 +__declspec(dllexport) +#endif +SQLITE_API int sqlite3_icu_init( + sqlite3 *db, + char **pzErrMsg, + const sqlite3_api_routines *pApi +){ + SQLITE_EXTENSION_INIT2(pApi) + return sqlite3IcuInit(db); +} +#endif + +#endif + +/************** End of icu.c *************************************************/ +/************** Begin file fts3_icu.c ****************************************/ +/* +** 2007 June 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file implements a tokenizer for fts3 based on the ICU library. +*/ +/* #include "fts3Int.h" */ +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) +#ifdef SQLITE_ENABLE_ICU + +/* #include */ +/* #include */ +/* #include "fts3_tokenizer.h" */ + +#include +/* #include */ +/* #include */ +#include + +typedef struct IcuTokenizer IcuTokenizer; +typedef struct IcuCursor IcuCursor; + +struct IcuTokenizer { + sqlite3_tokenizer base; + char *zLocale; +}; + +struct IcuCursor { + sqlite3_tokenizer_cursor base; + + UBreakIterator *pIter; /* ICU break-iterator object */ + int nChar; /* Number of UChar elements in pInput */ + UChar *aChar; /* Copy of input using utf-16 encoding */ + int *aOffset; /* Offsets of each character in utf-8 input */ + + int nBuffer; + char *zBuffer; + + int iToken; +}; + +/* +** Create a new tokenizer instance. +*/ +static int icuCreate( + int argc, /* Number of entries in argv[] */ + const char * const *argv, /* Tokenizer creation arguments */ + sqlite3_tokenizer **ppTokenizer /* OUT: Created tokenizer */ +){ + IcuTokenizer *p; + int n = 0; + + if( argc>0 ){ + n = strlen(argv[0])+1; + } + p = (IcuTokenizer *)sqlite3_malloc64(sizeof(IcuTokenizer)+n); + if( !p ){ + return SQLITE_NOMEM; + } + memset(p, 0, sizeof(IcuTokenizer)); + + if( n ){ + p->zLocale = (char *)&p[1]; + memcpy(p->zLocale, argv[0], n); + } + + *ppTokenizer = (sqlite3_tokenizer *)p; + + return SQLITE_OK; +} + +/* +** Destroy a tokenizer +*/ +static int icuDestroy(sqlite3_tokenizer *pTokenizer){ + IcuTokenizer *p = (IcuTokenizer *)pTokenizer; + sqlite3_free(p); + return SQLITE_OK; +} + +/* +** Prepare to begin tokenizing a particular string. The input +** string to be tokenized is pInput[0..nBytes-1]. A cursor +** used to incrementally tokenize this string is returned in +** *ppCursor. +*/ +static int icuOpen( + sqlite3_tokenizer *pTokenizer, /* The tokenizer */ + const char *zInput, /* Input string */ + int nInput, /* Length of zInput in bytes */ + sqlite3_tokenizer_cursor **ppCursor /* OUT: Tokenization cursor */ +){ + IcuTokenizer *p = (IcuTokenizer *)pTokenizer; + IcuCursor *pCsr; + + const int32_t opt = U_FOLD_CASE_DEFAULT; + UErrorCode status = U_ZERO_ERROR; + int nChar; + + UChar32 c; + int iInput = 0; + int iOut = 0; + + *ppCursor = 0; + + if( zInput==0 ){ + nInput = 0; + zInput = ""; + }else if( nInput<0 ){ + nInput = strlen(zInput); + } + nChar = nInput+1; + pCsr = (IcuCursor *)sqlite3_malloc64( + sizeof(IcuCursor) + /* IcuCursor */ + ((nChar+3)&~3) * sizeof(UChar) + /* IcuCursor.aChar[] */ + (nChar+1) * sizeof(int) /* IcuCursor.aOffset[] */ + ); + if( !pCsr ){ + return SQLITE_NOMEM; + } + memset(pCsr, 0, sizeof(IcuCursor)); + pCsr->aChar = (UChar *)&pCsr[1]; + pCsr->aOffset = (int *)&pCsr->aChar[(nChar+3)&~3]; + + pCsr->aOffset[iOut] = iInput; + U8_NEXT(zInput, iInput, nInput, c); + while( c>0 ){ + int isError = 0; + c = u_foldCase(c, opt); + U16_APPEND(pCsr->aChar, iOut, nChar, c, isError); + if( isError ){ + sqlite3_free(pCsr); + return SQLITE_ERROR; + } + pCsr->aOffset[iOut] = iInput; + + if( iInputpIter = ubrk_open(UBRK_WORD, p->zLocale, pCsr->aChar, iOut, &status); + if( !U_SUCCESS(status) ){ + sqlite3_free(pCsr); + return SQLITE_ERROR; + } + pCsr->nChar = iOut; + + ubrk_first(pCsr->pIter); + *ppCursor = (sqlite3_tokenizer_cursor *)pCsr; + return SQLITE_OK; +} + +/* +** Close a tokenization cursor previously opened by a call to icuOpen(). +*/ +static int icuClose(sqlite3_tokenizer_cursor *pCursor){ + IcuCursor *pCsr = (IcuCursor *)pCursor; + ubrk_close(pCsr->pIter); + sqlite3_free(pCsr->zBuffer); + sqlite3_free(pCsr); + return SQLITE_OK; +} + +/* +** Extract the next token from a tokenization cursor. +*/ +static int icuNext( + sqlite3_tokenizer_cursor *pCursor, /* Cursor returned by simpleOpen */ + const char **ppToken, /* OUT: *ppToken is the token text */ + int *pnBytes, /* OUT: Number of bytes in token */ + int *piStartOffset, /* OUT: Starting offset of token */ + int *piEndOffset, /* OUT: Ending offset of token */ + int *piPosition /* OUT: Position integer of token */ +){ + IcuCursor *pCsr = (IcuCursor *)pCursor; + + int iStart = 0; + int iEnd = 0; + int nByte = 0; + + while( iStart==iEnd ){ + UChar32 c; + + iStart = ubrk_current(pCsr->pIter); + iEnd = ubrk_next(pCsr->pIter); + if( iEnd==UBRK_DONE ){ + return SQLITE_DONE; + } + + while( iStartaChar, iWhite, pCsr->nChar, c); + if( u_isspace(c) ){ + iStart = iWhite; + }else{ + break; + } + } + assert(iStart<=iEnd); + } + + do { + UErrorCode status = U_ZERO_ERROR; + if( nByte ){ + char *zNew = sqlite3_realloc(pCsr->zBuffer, nByte); + if( !zNew ){ + return SQLITE_NOMEM; + } + pCsr->zBuffer = zNew; + pCsr->nBuffer = nByte; + } + + u_strToUTF8( + pCsr->zBuffer, pCsr->nBuffer, &nByte, /* Output vars */ + &pCsr->aChar[iStart], iEnd-iStart, /* Input vars */ + &status /* Output success/failure */ + ); + } while( nByte>pCsr->nBuffer ); + + *ppToken = pCsr->zBuffer; + *pnBytes = nByte; + *piStartOffset = pCsr->aOffset[iStart]; + *piEndOffset = pCsr->aOffset[iEnd]; + *piPosition = pCsr->iToken++; + + return SQLITE_OK; +} + +/* +** The set of routines that implement the simple tokenizer +*/ +static const sqlite3_tokenizer_module icuTokenizerModule = { + 0, /* iVersion */ + icuCreate, /* xCreate */ + icuDestroy, /* xCreate */ + icuOpen, /* xOpen */ + icuClose, /* xClose */ + icuNext, /* xNext */ + 0, /* xLanguageid */ +}; + +/* +** Set *ppModule to point at the implementation of the ICU tokenizer. +*/ +SQLITE_PRIVATE void sqlite3Fts3IcuTokenizerModule( + sqlite3_tokenizer_module const**ppModule +){ + *ppModule = &icuTokenizerModule; +} + +#endif /* defined(SQLITE_ENABLE_ICU) */ +#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */ + +/************** End of fts3_icu.c ********************************************/ +/************** Begin file sqlite3rbu.c **************************************/ +/* +** 2014 August 30 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** +** OVERVIEW +** +** The RBU extension requires that the RBU update be packaged as an +** SQLite database. The tables it expects to find are described in +** sqlite3rbu.h. Essentially, for each table xyz in the target database +** that the user wishes to write to, a corresponding data_xyz table is +** created in the RBU database and populated with one row for each row to +** update, insert or delete from the target table. +** +** The update proceeds in three stages: +** +** 1) The database is updated. The modified database pages are written +** to a *-oal file. A *-oal file is just like a *-wal file, except +** that it is named "-oal" instead of "-wal". +** Because regular SQLite clients do not look for file named +** "-oal", they go on using the original database in +** rollback mode while the *-oal file is being generated. +** +** During this stage RBU does not update the database by writing +** directly to the target tables. Instead it creates "imposter" +** tables using the SQLITE_TESTCTRL_IMPOSTER interface that it uses +** to update each b-tree individually. All updates required by each +** b-tree are completed before moving on to the next, and all +** updates are done in sorted key order. +** +** 2) The "-oal" file is moved to the equivalent "-wal" +** location using a call to rename(2). Before doing this the RBU +** module takes an EXCLUSIVE lock on the database file, ensuring +** that there are no other active readers. +** +** Once the EXCLUSIVE lock is released, any other database readers +** detect the new *-wal file and read the database in wal mode. At +** this point they see the new version of the database - including +** the updates made as part of the RBU update. +** +** 3) The new *-wal file is checkpointed. This proceeds in the same way +** as a regular database checkpoint, except that a single frame is +** checkpointed each time sqlite3rbu_step() is called. If the RBU +** handle is closed before the entire *-wal file is checkpointed, +** the checkpoint progress is saved in the RBU database and the +** checkpoint can be resumed by another RBU client at some point in +** the future. +** +** POTENTIAL PROBLEMS +** +** The rename() call might not be portable. And RBU is not currently +** syncing the directory after renaming the file. +** +** When state is saved, any commit to the *-oal file and the commit to +** the RBU update database are not atomic. So if the power fails at the +** wrong moment they might get out of sync. As the main database will be +** committed before the RBU update database this will likely either just +** pass unnoticed, or result in SQLITE_CONSTRAINT errors (due to UNIQUE +** constraint violations). +** +** If some client does modify the target database mid RBU update, or some +** other error occurs, the RBU extension will keep throwing errors. It's +** not really clear how to get out of this state. The system could just +** by delete the RBU update database and *-oal file and have the device +** download the update again and start over. +** +** At present, for an UPDATE, both the new.* and old.* records are +** collected in the rbu_xyz table. And for both UPDATEs and DELETEs all +** fields are collected. This means we're probably writing a lot more +** data to disk when saving the state of an ongoing update to the RBU +** update database than is strictly necessary. +** +*/ + +/* #include */ +/* #include */ +/* #include */ + +/* #include "sqlite3.h" */ + +#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_RBU) +/************** Include sqlite3rbu.h in the middle of sqlite3rbu.c ***********/ +/************** Begin file sqlite3rbu.h **************************************/ +/* +** 2014 August 30 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains the public interface for the RBU extension. +*/ + +/* +** SUMMARY +** +** Writing a transaction containing a large number of operations on +** b-tree indexes that are collectively larger than the available cache +** memory can be very inefficient. +** +** The problem is that in order to update a b-tree, the leaf page (at least) +** containing the entry being inserted or deleted must be modified. If the +** working set of leaves is larger than the available cache memory, then a +** single leaf that is modified more than once as part of the transaction +** may be loaded from or written to the persistent media multiple times. +** Additionally, because the index updates are likely to be applied in +** random order, access to pages within the database is also likely to be in +** random order, which is itself quite inefficient. +** +** One way to improve the situation is to sort the operations on each index +** by index key before applying them to the b-tree. This leads to an IO +** pattern that resembles a single linear scan through the index b-tree, +** and all but guarantees each modified leaf page is loaded and stored +** exactly once. SQLite uses this trick to improve the performance of +** CREATE INDEX commands. This extension allows it to be used to improve +** the performance of large transactions on existing databases. +** +** Additionally, this extension allows the work involved in writing the +** large transaction to be broken down into sub-transactions performed +** sequentially by separate processes. This is useful if the system cannot +** guarantee that a single update process will run for long enough to apply +** the entire update, for example because the update is being applied on a +** mobile device that is frequently rebooted. Even after the writer process +** has committed one or more sub-transactions, other database clients continue +** to read from the original database snapshot. In other words, partially +** applied transactions are not visible to other clients. +** +** "RBU" stands for "Resumable Bulk Update". As in a large database update +** transmitted via a wireless network to a mobile device. A transaction +** applied using this extension is hence refered to as an "RBU update". +** +** +** LIMITATIONS +** +** An "RBU update" transaction is subject to the following limitations: +** +** * The transaction must consist of INSERT, UPDATE and DELETE operations +** only. +** +** * INSERT statements may not use any default values. +** +** * UPDATE and DELETE statements must identify their target rows by +** non-NULL PRIMARY KEY values. Rows with NULL values stored in PRIMARY +** KEY fields may not be updated or deleted. If the table being written +** has no PRIMARY KEY, affected rows must be identified by rowid. +** +** * UPDATE statements may not modify PRIMARY KEY columns. +** +** * No triggers will be fired. +** +** * No foreign key violations are detected or reported. +** +** * CHECK constraints are not enforced. +** +** * No constraint handling mode except for "OR ROLLBACK" is supported. +** +** +** PREPARATION +** +** An "RBU update" is stored as a separate SQLite database. A database +** containing an RBU update is an "RBU database". For each table in the +** target database to be updated, the RBU database should contain a table +** named "data_" containing the same set of columns as the +** target table, and one more - "rbu_control". The data_% table should +** have no PRIMARY KEY or UNIQUE constraints, but each column should have +** the same type as the corresponding column in the target database. +** The "rbu_control" column should have no type at all. For example, if +** the target database contains: +** +** CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c UNIQUE); +** +** Then the RBU database should contain: +** +** CREATE TABLE data_t1(a INTEGER, b TEXT, c, rbu_control); +** +** The order of the columns in the data_% table does not matter. +** +** Instead of a regular table, the RBU database may also contain virtual +** tables or views named using the data_ naming scheme. +** +** Instead of the plain data_ naming scheme, RBU database tables +** may also be named data_, where is any sequence +** of zero or more numeric characters (0-9). This can be significant because +** tables within the RBU database are always processed in order sorted by +** name. By judicious selection of the portion of the names +** of the RBU tables the user can therefore control the order in which they +** are processed. This can be useful, for example, to ensure that "external +** content" FTS4 tables are updated before their underlying content tables. +** +** If the target database table is a virtual table or a table that has no +** PRIMARY KEY declaration, the data_% table must also contain a column +** named "rbu_rowid". This column is mapped to the table's implicit primary +** key column - "rowid". Virtual tables for which the "rowid" column does +** not function like a primary key value cannot be updated using RBU. For +** example, if the target db contains either of the following: +** +** CREATE VIRTUAL TABLE x1 USING fts3(a, b); +** CREATE TABLE x1(a, b) +** +** then the RBU database should contain: +** +** CREATE TABLE data_x1(a, b, rbu_rowid, rbu_control); +** +** All non-hidden columns (i.e. all columns matched by "SELECT *") of the +** target table must be present in the input table. For virtual tables, +** hidden columns are optional - they are updated by RBU if present in +** the input table, or not otherwise. For example, to write to an fts4 +** table with a hidden languageid column such as: +** +** CREATE VIRTUAL TABLE ft1 USING fts4(a, b, languageid='langid'); +** +** Either of the following input table schemas may be used: +** +** CREATE TABLE data_ft1(a, b, langid, rbu_rowid, rbu_control); +** CREATE TABLE data_ft1(a, b, rbu_rowid, rbu_control); +** +** For each row to INSERT into the target database as part of the RBU +** update, the corresponding data_% table should contain a single record +** with the "rbu_control" column set to contain integer value 0. The +** other columns should be set to the values that make up the new record +** to insert. +** +** If the target database table has an INTEGER PRIMARY KEY, it is not +** possible to insert a NULL value into the IPK column. Attempting to +** do so results in an SQLITE_MISMATCH error. +** +** For each row to DELETE from the target database as part of the RBU +** update, the corresponding data_% table should contain a single record +** with the "rbu_control" column set to contain integer value 1. The +** real primary key values of the row to delete should be stored in the +** corresponding columns of the data_% table. The values stored in the +** other columns are not used. +** +** For each row to UPDATE from the target database as part of the RBU +** update, the corresponding data_% table should contain a single record +** with the "rbu_control" column set to contain a value of type text. +** The real primary key values identifying the row to update should be +** stored in the corresponding columns of the data_% table row, as should +** the new values of all columns being update. The text value in the +** "rbu_control" column must contain the same number of characters as +** there are columns in the target database table, and must consist entirely +** of 'x' and '.' characters (or in some special cases 'd' - see below). For +** each column that is being updated, the corresponding character is set to +** 'x'. For those that remain as they are, the corresponding character of the +** rbu_control value should be set to '.'. For example, given the tables +** above, the update statement: +** +** UPDATE t1 SET c = 'usa' WHERE a = 4; +** +** is represented by the data_t1 row created by: +** +** INSERT INTO data_t1(a, b, c, rbu_control) VALUES(4, NULL, 'usa', '..x'); +** +** Instead of an 'x' character, characters of the rbu_control value specified +** for UPDATEs may also be set to 'd'. In this case, instead of updating the +** target table with the value stored in the corresponding data_% column, the +** user-defined SQL function "rbu_delta()" is invoked and the result stored in +** the target table column. rbu_delta() is invoked with two arguments - the +** original value currently stored in the target table column and the +** value specified in the data_xxx table. +** +** For example, this row: +** +** INSERT INTO data_t1(a, b, c, rbu_control) VALUES(4, NULL, 'usa', '..d'); +** +** is similar to an UPDATE statement such as: +** +** UPDATE t1 SET c = rbu_delta(c, 'usa') WHERE a = 4; +** +** Finally, if an 'f' character appears in place of a 'd' or 's' in an +** ota_control string, the contents of the data_xxx table column is assumed +** to be a "fossil delta" - a patch to be applied to a blob value in the +** format used by the fossil source-code management system. In this case +** the existing value within the target database table must be of type BLOB. +** It is replaced by the result of applying the specified fossil delta to +** itself. +** +** If the target database table is a virtual table or a table with no PRIMARY +** KEY, the rbu_control value should not include a character corresponding +** to the rbu_rowid value. For example, this: +** +** INSERT INTO data_ft1(a, b, rbu_rowid, rbu_control) +** VALUES(NULL, 'usa', 12, '.x'); +** +** causes a result similar to: +** +** UPDATE ft1 SET b = 'usa' WHERE rowid = 12; +** +** The data_xxx tables themselves should have no PRIMARY KEY declarations. +** However, RBU is more efficient if reading the rows in from each data_xxx +** table in "rowid" order is roughly the same as reading them sorted by +** the PRIMARY KEY of the corresponding target database table. In other +** words, rows should be sorted using the destination table PRIMARY KEY +** fields before they are inserted into the data_xxx tables. +** +** USAGE +** +** The API declared below allows an application to apply an RBU update +** stored on disk to an existing target database. Essentially, the +** application: +** +** 1) Opens an RBU handle using the sqlite3rbu_open() function. +** +** 2) Registers any required virtual table modules with the database +** handle returned by sqlite3rbu_db(). Also, if required, register +** the rbu_delta() implementation. +** +** 3) Calls the sqlite3rbu_step() function one or more times on +** the new handle. Each call to sqlite3rbu_step() performs a single +** b-tree operation, so thousands of calls may be required to apply +** a complete update. +** +** 4) Calls sqlite3rbu_close() to close the RBU update handle. If +** sqlite3rbu_step() has been called enough times to completely +** apply the update to the target database, then the RBU database +** is marked as fully applied. Otherwise, the state of the RBU +** update application is saved in the RBU database for later +** resumption. +** +** See comments below for more detail on APIs. +** +** If an update is only partially applied to the target database by the +** time sqlite3rbu_close() is called, various state information is saved +** within the RBU database. This allows subsequent processes to automatically +** resume the RBU update from where it left off. +** +** To remove all RBU extension state information, returning an RBU database +** to its original contents, it is sufficient to drop all tables that begin +** with the prefix "rbu_" +** +** DATABASE LOCKING +** +** An RBU update may not be applied to a database in WAL mode. Attempting +** to do so is an error (SQLITE_ERROR). +** +** While an RBU handle is open, a SHARED lock may be held on the target +** database file. This means it is possible for other clients to read the +** database, but not to write it. +** +** If an RBU update is started and then suspended before it is completed, +** then an external client writes to the database, then attempting to resume +** the suspended RBU update is also an error (SQLITE_BUSY). +*/ + +#ifndef _SQLITE3RBU_H +#define _SQLITE3RBU_H + +/* #include "sqlite3.h" ** Required for error code definitions ** */ + +#if 0 +extern "C" { +#endif + +typedef struct sqlite3rbu sqlite3rbu; + +/* +** Open an RBU handle. +** +** Argument zTarget is the path to the target database. Argument zRbu is +** the path to the RBU database. Each call to this function must be matched +** by a call to sqlite3rbu_close(). When opening the databases, RBU passes +** the SQLITE_CONFIG_URI flag to sqlite3_open_v2(). So if either zTarget +** or zRbu begin with "file:", it will be interpreted as an SQLite +** database URI, not a regular file name. +** +** If the zState argument is passed a NULL value, the RBU extension stores +** the current state of the update (how many rows have been updated, which +** indexes are yet to be updated etc.) within the RBU database itself. This +** can be convenient, as it means that the RBU application does not need to +** organize removing a separate state file after the update is concluded. +** Or, if zState is non-NULL, it must be a path to a database file in which +** the RBU extension can store the state of the update. +** +** When resuming an RBU update, the zState argument must be passed the same +** value as when the RBU update was started. +** +** Once the RBU update is finished, the RBU extension does not +** automatically remove any zState database file, even if it created it. +** +** By default, RBU uses the default VFS to access the files on disk. To +** use a VFS other than the default, an SQLite "file:" URI containing a +** "vfs=..." option may be passed as the zTarget option. +** +** IMPORTANT NOTE FOR ZIPVFS USERS: The RBU extension works with all of +** SQLite's built-in VFSs, including the multiplexor VFS. However it does +** not work out of the box with zipvfs. Refer to the comment describing +** the zipvfs_create_vfs() API below for details on using RBU with zipvfs. +*/ +SQLITE_API sqlite3rbu *sqlite3rbu_open( + const char *zTarget, + const char *zRbu, + const char *zState +); + +/* +** Open an RBU handle to perform an RBU vacuum on database file zTarget. +** An RBU vacuum is similar to SQLite's built-in VACUUM command, except +** that it can be suspended and resumed like an RBU update. +** +** The second argument to this function identifies a database in which +** to store the state of the RBU vacuum operation if it is suspended. The +** first time sqlite3rbu_vacuum() is called, to start an RBU vacuum +** operation, the state database should either not exist or be empty +** (contain no tables). If an RBU vacuum is suspended by calling +** sqlite3rbu_close() on the RBU handle before sqlite3rbu_step() has +** returned SQLITE_DONE, the vacuum state is stored in the state database. +** The vacuum can be resumed by calling this function to open a new RBU +** handle specifying the same target and state databases. +** +** If the second argument passed to this function is NULL, then the +** name of the state database is "-vacuum", where +** is the name of the target database file. In this case, on UNIX, if the +** state database is not already present in the file-system, it is created +** with the same permissions as the target db is made. +** +** With an RBU vacuum, it is an SQLITE_MISUSE error if the name of the +** state database ends with "-vactmp". This name is reserved for internal +** use. +** +** This function does not delete the state database after an RBU vacuum +** is completed, even if it created it. However, if the call to +** sqlite3rbu_close() returns any value other than SQLITE_OK, the contents +** of the state tables within the state database are zeroed. This way, +** the next call to sqlite3rbu_vacuum() opens a handle that starts a +** new RBU vacuum operation. +** +** As with sqlite3rbu_open(), Zipvfs users should rever to the comment +** describing the sqlite3rbu_create_vfs() API function below for +** a description of the complications associated with using RBU with +** zipvfs databases. +*/ +SQLITE_API sqlite3rbu *sqlite3rbu_vacuum( + const char *zTarget, + const char *zState +); + +/* +** Configure a limit for the amount of temp space that may be used by +** the RBU handle passed as the first argument. The new limit is specified +** in bytes by the second parameter. If it is positive, the limit is updated. +** If the second parameter to this function is passed zero, then the limit +** is removed entirely. If the second parameter is negative, the limit is +** not modified (this is useful for querying the current limit). +** +** In all cases the returned value is the current limit in bytes (zero +** indicates unlimited). +** +** If the temp space limit is exceeded during operation, an SQLITE_FULL +** error is returned. +*/ +SQLITE_API sqlite3_int64 sqlite3rbu_temp_size_limit(sqlite3rbu*, sqlite3_int64); + +/* +** Return the current amount of temp file space, in bytes, currently used by +** the RBU handle passed as the only argument. +*/ +SQLITE_API sqlite3_int64 sqlite3rbu_temp_size(sqlite3rbu*); + +/* +** Internally, each RBU connection uses a separate SQLite database +** connection to access the target and rbu update databases. This +** API allows the application direct access to these database handles. +** +** The first argument passed to this function must be a valid, open, RBU +** handle. The second argument should be passed zero to access the target +** database handle, or non-zero to access the rbu update database handle. +** Accessing the underlying database handles may be useful in the +** following scenarios: +** +** * If any target tables are virtual tables, it may be necessary to +** call sqlite3_create_module() on the target database handle to +** register the required virtual table implementations. +** +** * If the data_xxx tables in the RBU source database are virtual +** tables, the application may need to call sqlite3_create_module() on +** the rbu update db handle to any required virtual table +** implementations. +** +** * If the application uses the "rbu_delta()" feature described above, +** it must use sqlite3_create_function() or similar to register the +** rbu_delta() implementation with the target database handle. +** +** If an error has occurred, either while opening or stepping the RBU object, +** this function may return NULL. The error code and message may be collected +** when sqlite3rbu_close() is called. +** +** Database handles returned by this function remain valid until the next +** call to any sqlite3rbu_xxx() function other than sqlite3rbu_db(). +*/ +SQLITE_API sqlite3 *sqlite3rbu_db(sqlite3rbu*, int bRbu); + +/* +** Do some work towards applying the RBU update to the target db. +** +** Return SQLITE_DONE if the update has been completely applied, or +** SQLITE_OK if no error occurs but there remains work to do to apply +** the RBU update. If an error does occur, some other error code is +** returned. +** +** Once a call to sqlite3rbu_step() has returned a value other than +** SQLITE_OK, all subsequent calls on the same RBU handle are no-ops +** that immediately return the same value. +*/ +SQLITE_API int sqlite3rbu_step(sqlite3rbu *pRbu); + +/* +** Force RBU to save its state to disk. +** +** If a power failure or application crash occurs during an update, following +** system recovery RBU may resume the update from the point at which the state +** was last saved. In other words, from the most recent successful call to +** sqlite3rbu_close() or this function. +** +** SQLITE_OK is returned if successful, or an SQLite error code otherwise. +*/ +SQLITE_API int sqlite3rbu_savestate(sqlite3rbu *pRbu); + +/* +** Close an RBU handle. +** +** If the RBU update has been completely applied, mark the RBU database +** as fully applied. Otherwise, assuming no error has occurred, save the +** current state of the RBU update appliation to the RBU database. +** +** If an error has already occurred as part of an sqlite3rbu_step() +** or sqlite3rbu_open() call, or if one occurs within this function, an +** SQLite error code is returned. Additionally, if pzErrmsg is not NULL, +** *pzErrmsg may be set to point to a buffer containing a utf-8 formatted +** English language error message. It is the responsibility of the caller to +** eventually free any such buffer using sqlite3_free(). +** +** Otherwise, if no error occurs, this function returns SQLITE_OK if the +** update has been partially applied, or SQLITE_DONE if it has been +** completely applied. +*/ +SQLITE_API int sqlite3rbu_close(sqlite3rbu *pRbu, char **pzErrmsg); + +/* +** Return the total number of key-value operations (inserts, deletes or +** updates) that have been performed on the target database since the +** current RBU update was started. +*/ +SQLITE_API sqlite3_int64 sqlite3rbu_progress(sqlite3rbu *pRbu); + +/* +** Obtain permyriadage (permyriadage is to 10000 as percentage is to 100) +** progress indications for the two stages of an RBU update. This API may +** be useful for driving GUI progress indicators and similar. +** +** An RBU update is divided into two stages: +** +** * Stage 1, in which changes are accumulated in an oal/wal file, and +** * Stage 2, in which the contents of the wal file are copied into the +** main database. +** +** The update is visible to non-RBU clients during stage 2. During stage 1 +** non-RBU reader clients may see the original database. +** +** If this API is called during stage 2 of the update, output variable +** (*pnOne) is set to 10000 to indicate that stage 1 has finished and (*pnTwo) +** to a value between 0 and 10000 to indicate the permyriadage progress of +** stage 2. A value of 5000 indicates that stage 2 is half finished, +** 9000 indicates that it is 90% finished, and so on. +** +** If this API is called during stage 1 of the update, output variable +** (*pnTwo) is set to 0 to indicate that stage 2 has not yet started. The +** value to which (*pnOne) is set depends on whether or not the RBU +** database contains an "rbu_count" table. The rbu_count table, if it +** exists, must contain the same columns as the following: +** +** CREATE TABLE rbu_count(tbl TEXT PRIMARY KEY, cnt INTEGER) WITHOUT ROWID; +** +** There must be one row in the table for each source (data_xxx) table within +** the RBU database. The 'tbl' column should contain the name of the source +** table. The 'cnt' column should contain the number of rows within the +** source table. +** +** If the rbu_count table is present and populated correctly and this +** API is called during stage 1, the *pnOne output variable is set to the +** permyriadage progress of the same stage. If the rbu_count table does +** not exist, then (*pnOne) is set to -1 during stage 1. If the rbu_count +** table exists but is not correctly populated, the value of the *pnOne +** output variable during stage 1 is undefined. +*/ +SQLITE_API void sqlite3rbu_bp_progress(sqlite3rbu *pRbu, int *pnOne, int*pnTwo); + +/* +** Obtain an indication as to the current stage of an RBU update or vacuum. +** This function always returns one of the SQLITE_RBU_STATE_XXX constants +** defined in this file. Return values should be interpreted as follows: +** +** SQLITE_RBU_STATE_OAL: +** RBU is currently building a *-oal file. The next call to sqlite3rbu_step() +** may either add further data to the *-oal file, or compute data that will +** be added by a subsequent call. +** +** SQLITE_RBU_STATE_MOVE: +** RBU has finished building the *-oal file. The next call to sqlite3rbu_step() +** will move the *-oal file to the equivalent *-wal path. If the current +** operation is an RBU update, then the updated version of the database +** file will become visible to ordinary SQLite clients following the next +** call to sqlite3rbu_step(). +** +** SQLITE_RBU_STATE_CHECKPOINT: +** RBU is currently performing an incremental checkpoint. The next call to +** sqlite3rbu_step() will copy a page of data from the *-wal file into +** the target database file. +** +** SQLITE_RBU_STATE_DONE: +** The RBU operation has finished. Any subsequent calls to sqlite3rbu_step() +** will immediately return SQLITE_DONE. +** +** SQLITE_RBU_STATE_ERROR: +** An error has occurred. Any subsequent calls to sqlite3rbu_step() will +** immediately return the SQLite error code associated with the error. +*/ +#define SQLITE_RBU_STATE_OAL 1 +#define SQLITE_RBU_STATE_MOVE 2 +#define SQLITE_RBU_STATE_CHECKPOINT 3 +#define SQLITE_RBU_STATE_DONE 4 +#define SQLITE_RBU_STATE_ERROR 5 + +SQLITE_API int sqlite3rbu_state(sqlite3rbu *pRbu); + +/* +** As part of applying an RBU update or performing an RBU vacuum operation, +** the system must at one point move the *-oal file to the equivalent *-wal +** path. Normally, it does this by invoking POSIX function rename(2) directly. +** Except on WINCE platforms, where it uses win32 API MoveFileW(). This +** function may be used to register a callback that the RBU module will invoke +** instead of one of these APIs. +** +** If a callback is registered with an RBU handle, it invokes it instead +** of rename(2) when it needs to move a file within the file-system. The +** first argument passed to the xRename() callback is a copy of the second +** argument (pArg) passed to this function. The second is the full path +** to the file to move and the third the full path to which it should be +** moved. The callback function should return SQLITE_OK to indicate +** success. If an error occurs, it should return an SQLite error code. +** In this case the RBU operation will be abandoned and the error returned +** to the RBU user. +** +** Passing a NULL pointer in place of the xRename argument to this function +** restores the default behaviour. +*/ +SQLITE_API void sqlite3rbu_rename_handler( + sqlite3rbu *pRbu, + void *pArg, + int (*xRename)(void *pArg, const char *zOld, const char *zNew) +); + + +/* +** Create an RBU VFS named zName that accesses the underlying file-system +** via existing VFS zParent. Or, if the zParent parameter is passed NULL, +** then the new RBU VFS uses the default system VFS to access the file-system. +** The new object is registered as a non-default VFS with SQLite before +** returning. +** +** Part of the RBU implementation uses a custom VFS object. Usually, this +** object is created and deleted automatically by RBU. +** +** The exception is for applications that also use zipvfs. In this case, +** the custom VFS must be explicitly created by the user before the RBU +** handle is opened. The RBU VFS should be installed so that the zipvfs +** VFS uses the RBU VFS, which in turn uses any other VFS layers in use +** (for example multiplexor) to access the file-system. For example, +** to assemble an RBU enabled VFS stack that uses both zipvfs and +** multiplexor (error checking omitted): +** +** // Create a VFS named "multiplex" (not the default). +** sqlite3_multiplex_initialize(0, 0); +** +** // Create an rbu VFS named "rbu" that uses multiplexor. If the +** // second argument were replaced with NULL, the "rbu" VFS would +** // access the file-system via the system default VFS, bypassing the +** // multiplexor. +** sqlite3rbu_create_vfs("rbu", "multiplex"); +** +** // Create a zipvfs VFS named "zipvfs" that uses rbu. +** zipvfs_create_vfs_v3("zipvfs", "rbu", 0, xCompressorAlgorithmDetector); +** +** // Make zipvfs the default VFS. +** sqlite3_vfs_register(sqlite3_vfs_find("zipvfs"), 1); +** +** Because the default VFS created above includes a RBU functionality, it +** may be used by RBU clients. Attempting to use RBU with a zipvfs VFS stack +** that does not include the RBU layer results in an error. +** +** The overhead of adding the "rbu" VFS to the system is negligible for +** non-RBU users. There is no harm in an application accessing the +** file-system via "rbu" all the time, even if it only uses RBU functionality +** occasionally. +*/ +SQLITE_API int sqlite3rbu_create_vfs(const char *zName, const char *zParent); + +/* +** Deregister and destroy an RBU vfs created by an earlier call to +** sqlite3rbu_create_vfs(). +** +** VFS objects are not reference counted. If a VFS object is destroyed +** before all database handles that use it have been closed, the results +** are undefined. +*/ +SQLITE_API void sqlite3rbu_destroy_vfs(const char *zName); + +#if 0 +} /* end of the 'extern "C"' block */ +#endif + +#endif /* _SQLITE3RBU_H */ + +/************** End of sqlite3rbu.h ******************************************/ +/************** Continuing where we left off in sqlite3rbu.c *****************/ + +#if defined(_WIN32_WCE) +/* #include "windows.h" */ +#endif + +/* Maximum number of prepared UPDATE statements held by this module */ +#define SQLITE_RBU_UPDATE_CACHESIZE 16 + +/* Delta checksums disabled by default. Compile with -DRBU_ENABLE_DELTA_CKSUM +** to enable checksum verification. +*/ +#ifndef RBU_ENABLE_DELTA_CKSUM +# define RBU_ENABLE_DELTA_CKSUM 0 +#endif + +/* +** Swap two objects of type TYPE. +*/ +#if !defined(SQLITE_AMALGAMATION) +# define SWAP(TYPE,A,B) {TYPE t=A; A=B; B=t;} +#endif + +/* +** Name of the URI option that causes RBU to take an exclusive lock as +** part of the incremental checkpoint operation. +*/ +#define RBU_EXCLUSIVE_CHECKPOINT "rbu_exclusive_checkpoint" + + +/* +** The rbu_state table is used to save the state of a partially applied +** update so that it can be resumed later. The table consists of integer +** keys mapped to values as follows: +** +** RBU_STATE_STAGE: +** May be set to integer values 1, 2, 4 or 5. As follows: +** 1: the *-rbu file is currently under construction. +** 2: the *-rbu file has been constructed, but not yet moved +** to the *-wal path. +** 4: the checkpoint is underway. +** 5: the rbu update has been checkpointed. +** +** RBU_STATE_TBL: +** Only valid if STAGE==1. The target database name of the table +** currently being written. +** +** RBU_STATE_IDX: +** Only valid if STAGE==1. The target database name of the index +** currently being written, or NULL if the main table is currently being +** updated. +** +** RBU_STATE_ROW: +** Only valid if STAGE==1. Number of rows already processed for the current +** table/index. +** +** RBU_STATE_PROGRESS: +** Trbul number of sqlite3rbu_step() calls made so far as part of this +** rbu update. +** +** RBU_STATE_CKPT: +** Valid if STAGE==4. The 64-bit checksum associated with the wal-index +** header created by recovering the *-wal file. This is used to detect +** cases when another client appends frames to the *-wal file in the +** middle of an incremental checkpoint (an incremental checkpoint cannot +** be continued if this happens). +** +** RBU_STATE_COOKIE: +** Valid if STAGE==1. The current change-counter cookie value in the +** target db file. +** +** RBU_STATE_OALSZ: +** Valid if STAGE==1. The size in bytes of the *-oal file. +** +** RBU_STATE_DATATBL: +** Only valid if STAGE==1. The RBU database name of the table +** currently being read. +*/ +#define RBU_STATE_STAGE 1 +#define RBU_STATE_TBL 2 +#define RBU_STATE_IDX 3 +#define RBU_STATE_ROW 4 +#define RBU_STATE_PROGRESS 5 +#define RBU_STATE_CKPT 6 +#define RBU_STATE_COOKIE 7 +#define RBU_STATE_OALSZ 8 +#define RBU_STATE_PHASEONESTEP 9 +#define RBU_STATE_DATATBL 10 + +#define RBU_STAGE_OAL 1 +#define RBU_STAGE_MOVE 2 +#define RBU_STAGE_CAPTURE 3 +#define RBU_STAGE_CKPT 4 +#define RBU_STAGE_DONE 5 + + +#define RBU_CREATE_STATE \ + "CREATE TABLE IF NOT EXISTS %s.rbu_state(k INTEGER PRIMARY KEY, v)" + +typedef struct RbuFrame RbuFrame; +typedef struct RbuObjIter RbuObjIter; +typedef struct RbuState RbuState; +typedef struct RbuSpan RbuSpan; +typedef struct rbu_vfs rbu_vfs; +typedef struct rbu_file rbu_file; +typedef struct RbuUpdateStmt RbuUpdateStmt; + +#if !defined(SQLITE_AMALGAMATION) +typedef unsigned int u32; +typedef unsigned short u16; +typedef unsigned char u8; +typedef sqlite3_int64 i64; +#endif + +/* +** These values must match the values defined in wal.c for the equivalent +** locks. These are not magic numbers as they are part of the SQLite file +** format. +*/ +#define WAL_LOCK_WRITE 0 +#define WAL_LOCK_CKPT 1 +#define WAL_LOCK_READ0 3 + +#define SQLITE_FCNTL_RBUCNT 5149216 + +/* +** A structure to store values read from the rbu_state table in memory. +*/ +struct RbuState { + int eStage; + char *zTbl; + char *zDataTbl; + char *zIdx; + i64 iWalCksum; + int nRow; + i64 nProgress; + u32 iCookie; + i64 iOalSz; + i64 nPhaseOneStep; +}; + +struct RbuUpdateStmt { + char *zMask; /* Copy of update mask used with pUpdate */ + sqlite3_stmt *pUpdate; /* Last update statement (or NULL) */ + RbuUpdateStmt *pNext; +}; + +struct RbuSpan { + const char *zSpan; + int nSpan; +}; + +/* +** An iterator of this type is used to iterate through all objects in +** the target database that require updating. For each such table, the +** iterator visits, in order: +** +** * the table itself, +** * each index of the table (zero or more points to visit), and +** * a special "cleanup table" state. +** +** abIndexed: +** If the table has no indexes on it, abIndexed is set to NULL. Otherwise, +** it points to an array of flags nTblCol elements in size. The flag is +** set for each column that is either a part of the PK or a part of an +** index. Or clear otherwise. +** +** If there are one or more partial indexes on the table, all fields of +** this array set set to 1. This is because in that case, the module has +** no way to tell which fields will be required to add and remove entries +** from the partial indexes. +** +*/ +struct RbuObjIter { + sqlite3_stmt *pTblIter; /* Iterate through tables */ + sqlite3_stmt *pIdxIter; /* Index iterator */ + int nTblCol; /* Size of azTblCol[] array */ + char **azTblCol; /* Array of unquoted target column names */ + char **azTblType; /* Array of target column types */ + int *aiSrcOrder; /* src table col -> target table col */ + u8 *abTblPk; /* Array of flags, set on target PK columns */ + u8 *abNotNull; /* Array of flags, set on NOT NULL columns */ + u8 *abIndexed; /* Array of flags, set on indexed & PK cols */ + int eType; /* Table type - an RBU_PK_XXX value */ + + /* Output variables. zTbl==0 implies EOF. */ + int bCleanup; /* True in "cleanup" state */ + const char *zTbl; /* Name of target db table */ + const char *zDataTbl; /* Name of rbu db table (or null) */ + const char *zIdx; /* Name of target db index (or null) */ + int iTnum; /* Root page of current object */ + int iPkTnum; /* If eType==EXTERNAL, root of PK index */ + int bUnique; /* Current index is unique */ + int nIndex; /* Number of aux. indexes on table zTbl */ + + /* Statements created by rbuObjIterPrepareAll() */ + int nCol; /* Number of columns in current object */ + sqlite3_stmt *pSelect; /* Source data */ + sqlite3_stmt *pInsert; /* Statement for INSERT operations */ + sqlite3_stmt *pDelete; /* Statement for DELETE ops */ + sqlite3_stmt *pTmpInsert; /* Insert into rbu_tmp_$zDataTbl */ + int nIdxCol; + RbuSpan *aIdxCol; + char *zIdxSql; + + /* Last UPDATE used (for PK b-tree updates only), or NULL. */ + RbuUpdateStmt *pRbuUpdate; +}; + +/* +** Values for RbuObjIter.eType +** +** 0: Table does not exist (error) +** 1: Table has an implicit rowid. +** 2: Table has an explicit IPK column. +** 3: Table has an external PK index. +** 4: Table is WITHOUT ROWID. +** 5: Table is a virtual table. +*/ +#define RBU_PK_NOTABLE 0 +#define RBU_PK_NONE 1 +#define RBU_PK_IPK 2 +#define RBU_PK_EXTERNAL 3 +#define RBU_PK_WITHOUT_ROWID 4 +#define RBU_PK_VTAB 5 + + +/* +** Within the RBU_STAGE_OAL stage, each call to sqlite3rbu_step() performs +** one of the following operations. +*/ +#define RBU_INSERT 1 /* Insert on a main table b-tree */ +#define RBU_DELETE 2 /* Delete a row from a main table b-tree */ +#define RBU_REPLACE 3 /* Delete and then insert a row */ +#define RBU_IDX_DELETE 4 /* Delete a row from an aux. index b-tree */ +#define RBU_IDX_INSERT 5 /* Insert on an aux. index b-tree */ + +#define RBU_UPDATE 6 /* Update a row in a main table b-tree */ + +/* +** A single step of an incremental checkpoint - frame iWalFrame of the wal +** file should be copied to page iDbPage of the database file. +*/ +struct RbuFrame { + u32 iDbPage; + u32 iWalFrame; +}; + +/* +** RBU handle. +** +** nPhaseOneStep: +** If the RBU database contains an rbu_count table, this value is set to +** a running estimate of the number of b-tree operations required to +** finish populating the *-oal file. This allows the sqlite3_bp_progress() +** API to calculate the permyriadage progress of populating the *-oal file +** using the formula: +** +** permyriadage = (10000 * nProgress) / nPhaseOneStep +** +** nPhaseOneStep is initialized to the sum of: +** +** nRow * (nIndex + 1) +** +** for all source tables in the RBU database, where nRow is the number +** of rows in the source table and nIndex the number of indexes on the +** corresponding target database table. +** +** This estimate is accurate if the RBU update consists entirely of +** INSERT operations. However, it is inaccurate if: +** +** * the RBU update contains any UPDATE operations. If the PK specified +** for an UPDATE operation does not exist in the target table, then +** no b-tree operations are required on index b-trees. Or if the +** specified PK does exist, then (nIndex*2) such operations are +** required (one delete and one insert on each index b-tree). +** +** * the RBU update contains any DELETE operations for which the specified +** PK does not exist. In this case no operations are required on index +** b-trees. +** +** * the RBU update contains REPLACE operations. These are similar to +** UPDATE operations. +** +** nPhaseOneStep is updated to account for the conditions above during the +** first pass of each source table. The updated nPhaseOneStep value is +** stored in the rbu_state table if the RBU update is suspended. +*/ +struct sqlite3rbu { + int eStage; /* Value of RBU_STATE_STAGE field */ + sqlite3 *dbMain; /* target database handle */ + sqlite3 *dbRbu; /* rbu database handle */ + char *zTarget; /* Path to target db */ + char *zRbu; /* Path to rbu db */ + char *zState; /* Path to state db (or NULL if zRbu) */ + char zStateDb[5]; /* Db name for state ("stat" or "main") */ + int rc; /* Value returned by last rbu_step() call */ + char *zErrmsg; /* Error message if rc!=SQLITE_OK */ + int nStep; /* Rows processed for current object */ + int nProgress; /* Rows processed for all objects */ + RbuObjIter objiter; /* Iterator for skipping through tbl/idx */ + const char *zVfsName; /* Name of automatically created rbu vfs */ + rbu_file *pTargetFd; /* File handle open on target db */ + int nPagePerSector; /* Pages per sector for pTargetFd */ + i64 iOalSz; + i64 nPhaseOneStep; + void *pRenameArg; + int (*xRename)(void*, const char*, const char*); + + /* The following state variables are used as part of the incremental + ** checkpoint stage (eStage==RBU_STAGE_CKPT). See comments surrounding + ** function rbuSetupCheckpoint() for details. */ + u32 iMaxFrame; /* Largest iWalFrame value in aFrame[] */ + u32 mLock; + int nFrame; /* Entries in aFrame[] array */ + int nFrameAlloc; /* Allocated size of aFrame[] array */ + RbuFrame *aFrame; + int pgsz; + u8 *aBuf; + i64 iWalCksum; + i64 szTemp; /* Current size of all temp files in use */ + i64 szTempLimit; /* Total size limit for temp files */ + + /* Used in RBU vacuum mode only */ + int nRbu; /* Number of RBU VFS in the stack */ + rbu_file *pRbuFd; /* Fd for main db of dbRbu */ +}; + +/* +** An rbu VFS is implemented using an instance of this structure. +** +** Variable pRbu is only non-NULL for automatically created RBU VFS objects. +** It is NULL for RBU VFS objects created explicitly using +** sqlite3rbu_create_vfs(). It is used to track the total amount of temp +** space used by the RBU handle. +*/ +struct rbu_vfs { + sqlite3_vfs base; /* rbu VFS shim methods */ + sqlite3_vfs *pRealVfs; /* Underlying VFS */ + sqlite3_mutex *mutex; /* Mutex to protect pMain */ + sqlite3rbu *pRbu; /* Owner RBU object */ + rbu_file *pMain; /* List of main db files */ + rbu_file *pMainRbu; /* List of main db files with pRbu!=0 */ +}; + +/* +** Each file opened by an rbu VFS is represented by an instance of +** the following structure. +** +** If this is a temporary file (pRbu!=0 && flags&DELETE_ON_CLOSE), variable +** "sz" is set to the current size of the database file. +*/ +struct rbu_file { + sqlite3_file base; /* sqlite3_file methods */ + sqlite3_file *pReal; /* Underlying file handle */ + rbu_vfs *pRbuVfs; /* Pointer to the rbu_vfs object */ + sqlite3rbu *pRbu; /* Pointer to rbu object (rbu target only) */ + i64 sz; /* Size of file in bytes (temp only) */ + + int openFlags; /* Flags this file was opened with */ + u32 iCookie; /* Cookie value for main db files */ + u8 iWriteVer; /* "write-version" value for main db files */ + u8 bNolock; /* True to fail EXCLUSIVE locks */ + + int nShm; /* Number of entries in apShm[] array */ + char **apShm; /* Array of mmap'd *-shm regions */ + char *zDel; /* Delete this when closing file */ + + const char *zWal; /* Wal filename for this main db file */ + rbu_file *pWalFd; /* Wal file descriptor for this main db */ + rbu_file *pMainNext; /* Next MAIN_DB file */ + rbu_file *pMainRbuNext; /* Next MAIN_DB file with pRbu!=0 */ +}; + +/* +** True for an RBU vacuum handle, or false otherwise. +*/ +#define rbuIsVacuum(p) ((p)->zTarget==0) + + +/************************************************************************* +** The following three functions, found below: +** +** rbuDeltaGetInt() +** rbuDeltaChecksum() +** rbuDeltaApply() +** +** are lifted from the fossil source code (http://fossil-scm.org). They +** are used to implement the scalar SQL function rbu_fossil_delta(). +*/ + +/* +** Read bytes from *pz and convert them into a positive integer. When +** finished, leave *pz pointing to the first character past the end of +** the integer. The *pLen parameter holds the length of the string +** in *pz and is decremented once for each character in the integer. +*/ +static unsigned int rbuDeltaGetInt(const char **pz, int *pLen){ + static const signed char zValue[] = { + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, + -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, 36, + -1, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, -1, -1, -1, 63, -1, + }; + unsigned int v = 0; + int c; + unsigned char *z = (unsigned char*)*pz; + unsigned char *zStart = z; + while( (c = zValue[0x7f&*(z++)])>=0 ){ + v = (v<<6) + c; + } + z--; + *pLen -= z - zStart; + *pz = (char*)z; + return v; +} + +#if RBU_ENABLE_DELTA_CKSUM +/* +** Compute a 32-bit checksum on the N-byte buffer. Return the result. +*/ +static unsigned int rbuDeltaChecksum(const char *zIn, size_t N){ + const unsigned char *z = (const unsigned char *)zIn; + unsigned sum0 = 0; + unsigned sum1 = 0; + unsigned sum2 = 0; + unsigned sum3 = 0; + while(N >= 16){ + sum0 += ((unsigned)z[0] + z[4] + z[8] + z[12]); + sum1 += ((unsigned)z[1] + z[5] + z[9] + z[13]); + sum2 += ((unsigned)z[2] + z[6] + z[10]+ z[14]); + sum3 += ((unsigned)z[3] + z[7] + z[11]+ z[15]); + z += 16; + N -= 16; + } + while(N >= 4){ + sum0 += z[0]; + sum1 += z[1]; + sum2 += z[2]; + sum3 += z[3]; + z += 4; + N -= 4; + } + sum3 += (sum2 << 8) + (sum1 << 16) + (sum0 << 24); + switch(N){ + case 3: sum3 += (z[2] << 8); + case 2: sum3 += (z[1] << 16); + case 1: sum3 += (z[0] << 24); + default: ; + } + return sum3; +} +#endif + +/* +** Apply a delta. +** +** The output buffer should be big enough to hold the whole output +** file and a NUL terminator at the end. The delta_output_size() +** routine will determine this size for you. +** +** The delta string should be null-terminated. But the delta string +** may contain embedded NUL characters (if the input and output are +** binary files) so we also have to pass in the length of the delta in +** the lenDelta parameter. +** +** This function returns the size of the output file in bytes (excluding +** the final NUL terminator character). Except, if the delta string is +** malformed or intended for use with a source file other than zSrc, +** then this routine returns -1. +** +** Refer to the delta_create() documentation above for a description +** of the delta file format. +*/ +static int rbuDeltaApply( + const char *zSrc, /* The source or pattern file */ + int lenSrc, /* Length of the source file */ + const char *zDelta, /* Delta to apply to the pattern */ + int lenDelta, /* Length of the delta */ + char *zOut /* Write the output into this preallocated buffer */ +){ + unsigned int limit; + unsigned int total = 0; +#if RBU_ENABLE_DELTA_CKSUM + char *zOrigOut = zOut; +#endif + + limit = rbuDeltaGetInt(&zDelta, &lenDelta); + if( *zDelta!='\n' ){ + /* ERROR: size integer not terminated by "\n" */ + return -1; + } + zDelta++; lenDelta--; + while( *zDelta && lenDelta>0 ){ + unsigned int cnt, ofst; + cnt = rbuDeltaGetInt(&zDelta, &lenDelta); + switch( zDelta[0] ){ + case '@': { + zDelta++; lenDelta--; + ofst = rbuDeltaGetInt(&zDelta, &lenDelta); + if( lenDelta>0 && zDelta[0]!=',' ){ + /* ERROR: copy command not terminated by ',' */ + return -1; + } + zDelta++; lenDelta--; + total += cnt; + if( total>limit ){ + /* ERROR: copy exceeds output file size */ + return -1; + } + if( (int)(ofst+cnt) > lenSrc ){ + /* ERROR: copy extends past end of input */ + return -1; + } + memcpy(zOut, &zSrc[ofst], cnt); + zOut += cnt; + break; + } + case ':': { + zDelta++; lenDelta--; + total += cnt; + if( total>limit ){ + /* ERROR: insert command gives an output larger than predicted */ + return -1; + } + if( (int)cnt>lenDelta ){ + /* ERROR: insert count exceeds size of delta */ + return -1; + } + memcpy(zOut, zDelta, cnt); + zOut += cnt; + zDelta += cnt; + lenDelta -= cnt; + break; + } + case ';': { + zDelta++; lenDelta--; + zOut[0] = 0; +#if RBU_ENABLE_DELTA_CKSUM + if( cnt!=rbuDeltaChecksum(zOrigOut, total) ){ + /* ERROR: bad checksum */ + return -1; + } +#endif + if( total!=limit ){ + /* ERROR: generated size does not match predicted size */ + return -1; + } + return total; + } + default: { + /* ERROR: unknown delta operator */ + return -1; + } + } + } + /* ERROR: unterminated delta */ + return -1; +} + +static int rbuDeltaOutputSize(const char *zDelta, int lenDelta){ + int size; + size = rbuDeltaGetInt(&zDelta, &lenDelta); + if( *zDelta!='\n' ){ + /* ERROR: size integer not terminated by "\n" */ + return -1; + } + return size; +} + +/* +** End of code taken from fossil. +*************************************************************************/ + +/* +** Implementation of SQL scalar function rbu_fossil_delta(). +** +** This function applies a fossil delta patch to a blob. Exactly two +** arguments must be passed to this function. The first is the blob to +** patch and the second the patch to apply. If no error occurs, this +** function returns the patched blob. +*/ +static void rbuFossilDeltaFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const char *aDelta; + int nDelta; + const char *aOrig; + int nOrig; + + int nOut; + int nOut2; + char *aOut; + + assert( argc==2 ); + + nOrig = sqlite3_value_bytes(argv[0]); + aOrig = (const char*)sqlite3_value_blob(argv[0]); + nDelta = sqlite3_value_bytes(argv[1]); + aDelta = (const char*)sqlite3_value_blob(argv[1]); + + /* Figure out the size of the output */ + nOut = rbuDeltaOutputSize(aDelta, nDelta); + if( nOut<0 ){ + sqlite3_result_error(context, "corrupt fossil delta", -1); + return; + } + + aOut = sqlite3_malloc(nOut+1); + if( aOut==0 ){ + sqlite3_result_error_nomem(context); + }else{ + nOut2 = rbuDeltaApply(aOrig, nOrig, aDelta, nDelta, aOut); + if( nOut2!=nOut ){ + sqlite3_free(aOut); + sqlite3_result_error(context, "corrupt fossil delta", -1); + }else{ + sqlite3_result_blob(context, aOut, nOut, sqlite3_free); + } + } +} + + +/* +** Prepare the SQL statement in buffer zSql against database handle db. +** If successful, set *ppStmt to point to the new statement and return +** SQLITE_OK. +** +** Otherwise, if an error does occur, set *ppStmt to NULL and return +** an SQLite error code. Additionally, set output variable *pzErrmsg to +** point to a buffer containing an error message. It is the responsibility +** of the caller to (eventually) free this buffer using sqlite3_free(). +*/ +static int prepareAndCollectError( + sqlite3 *db, + sqlite3_stmt **ppStmt, + char **pzErrmsg, + const char *zSql +){ + int rc = sqlite3_prepare_v2(db, zSql, -1, ppStmt, 0); + if( rc!=SQLITE_OK ){ + *pzErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + *ppStmt = 0; + } + return rc; +} + +/* +** Reset the SQL statement passed as the first argument. Return a copy +** of the value returned by sqlite3_reset(). +** +** If an error has occurred, then set *pzErrmsg to point to a buffer +** containing an error message. It is the responsibility of the caller +** to eventually free this buffer using sqlite3_free(). +*/ +static int resetAndCollectError(sqlite3_stmt *pStmt, char **pzErrmsg){ + int rc = sqlite3_reset(pStmt); + if( rc!=SQLITE_OK ){ + *pzErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(sqlite3_db_handle(pStmt))); + } + return rc; +} + +/* +** Unless it is NULL, argument zSql points to a buffer allocated using +** sqlite3_malloc containing an SQL statement. This function prepares the SQL +** statement against database db and frees the buffer. If statement +** compilation is successful, *ppStmt is set to point to the new statement +** handle and SQLITE_OK is returned. +** +** Otherwise, if an error occurs, *ppStmt is set to NULL and an error code +** returned. In this case, *pzErrmsg may also be set to point to an error +** message. It is the responsibility of the caller to free this error message +** buffer using sqlite3_free(). +** +** If argument zSql is NULL, this function assumes that an OOM has occurred. +** In this case SQLITE_NOMEM is returned and *ppStmt set to NULL. +*/ +static int prepareFreeAndCollectError( + sqlite3 *db, + sqlite3_stmt **ppStmt, + char **pzErrmsg, + char *zSql +){ + int rc; + assert( *pzErrmsg==0 ); + if( zSql==0 ){ + rc = SQLITE_NOMEM; + *ppStmt = 0; + }else{ + rc = prepareAndCollectError(db, ppStmt, pzErrmsg, zSql); + sqlite3_free(zSql); + } + return rc; +} + +/* +** Free the RbuObjIter.azTblCol[] and RbuObjIter.abTblPk[] arrays allocated +** by an earlier call to rbuObjIterCacheTableInfo(). +*/ +static void rbuObjIterFreeCols(RbuObjIter *pIter){ + int i; + for(i=0; inTblCol; i++){ + sqlite3_free(pIter->azTblCol[i]); + sqlite3_free(pIter->azTblType[i]); + } + sqlite3_free(pIter->azTblCol); + pIter->azTblCol = 0; + pIter->azTblType = 0; + pIter->aiSrcOrder = 0; + pIter->abTblPk = 0; + pIter->abNotNull = 0; + pIter->nTblCol = 0; + pIter->eType = 0; /* Invalid value */ +} + +/* +** Finalize all statements and free all allocations that are specific to +** the current object (table/index pair). +*/ +static void rbuObjIterClearStatements(RbuObjIter *pIter){ + RbuUpdateStmt *pUp; + + sqlite3_finalize(pIter->pSelect); + sqlite3_finalize(pIter->pInsert); + sqlite3_finalize(pIter->pDelete); + sqlite3_finalize(pIter->pTmpInsert); + pUp = pIter->pRbuUpdate; + while( pUp ){ + RbuUpdateStmt *pTmp = pUp->pNext; + sqlite3_finalize(pUp->pUpdate); + sqlite3_free(pUp); + pUp = pTmp; + } + sqlite3_free(pIter->aIdxCol); + sqlite3_free(pIter->zIdxSql); + + pIter->pSelect = 0; + pIter->pInsert = 0; + pIter->pDelete = 0; + pIter->pRbuUpdate = 0; + pIter->pTmpInsert = 0; + pIter->nCol = 0; + pIter->nIdxCol = 0; + pIter->aIdxCol = 0; + pIter->zIdxSql = 0; +} + +/* +** Clean up any resources allocated as part of the iterator object passed +** as the only argument. +*/ +static void rbuObjIterFinalize(RbuObjIter *pIter){ + rbuObjIterClearStatements(pIter); + sqlite3_finalize(pIter->pTblIter); + sqlite3_finalize(pIter->pIdxIter); + rbuObjIterFreeCols(pIter); + memset(pIter, 0, sizeof(RbuObjIter)); +} + +/* +** Advance the iterator to the next position. +** +** If no error occurs, SQLITE_OK is returned and the iterator is left +** pointing to the next entry. Otherwise, an error code and message is +** left in the RBU handle passed as the first argument. A copy of the +** error code is returned. +*/ +static int rbuObjIterNext(sqlite3rbu *p, RbuObjIter *pIter){ + int rc = p->rc; + if( rc==SQLITE_OK ){ + + /* Free any SQLite statements used while processing the previous object */ + rbuObjIterClearStatements(pIter); + if( pIter->zIdx==0 ){ + rc = sqlite3_exec(p->dbMain, + "DROP TRIGGER IF EXISTS temp.rbu_insert_tr;" + "DROP TRIGGER IF EXISTS temp.rbu_update1_tr;" + "DROP TRIGGER IF EXISTS temp.rbu_update2_tr;" + "DROP TRIGGER IF EXISTS temp.rbu_delete_tr;" + , 0, 0, &p->zErrmsg + ); + } + + if( rc==SQLITE_OK ){ + if( pIter->bCleanup ){ + rbuObjIterFreeCols(pIter); + pIter->bCleanup = 0; + rc = sqlite3_step(pIter->pTblIter); + if( rc!=SQLITE_ROW ){ + rc = resetAndCollectError(pIter->pTblIter, &p->zErrmsg); + pIter->zTbl = 0; + }else{ + pIter->zTbl = (const char*)sqlite3_column_text(pIter->pTblIter, 0); + pIter->zDataTbl = (const char*)sqlite3_column_text(pIter->pTblIter,1); + rc = (pIter->zDataTbl && pIter->zTbl) ? SQLITE_OK : SQLITE_NOMEM; + } + }else{ + if( pIter->zIdx==0 ){ + sqlite3_stmt *pIdx = pIter->pIdxIter; + rc = sqlite3_bind_text(pIdx, 1, pIter->zTbl, -1, SQLITE_STATIC); + } + if( rc==SQLITE_OK ){ + rc = sqlite3_step(pIter->pIdxIter); + if( rc!=SQLITE_ROW ){ + rc = resetAndCollectError(pIter->pIdxIter, &p->zErrmsg); + pIter->bCleanup = 1; + pIter->zIdx = 0; + }else{ + pIter->zIdx = (const char*)sqlite3_column_text(pIter->pIdxIter, 0); + pIter->iTnum = sqlite3_column_int(pIter->pIdxIter, 1); + pIter->bUnique = sqlite3_column_int(pIter->pIdxIter, 2); + rc = pIter->zIdx ? SQLITE_OK : SQLITE_NOMEM; + } + } + } + } + } + + if( rc!=SQLITE_OK ){ + rbuObjIterFinalize(pIter); + p->rc = rc; + } + return rc; +} + + +/* +** The implementation of the rbu_target_name() SQL function. This function +** accepts one or two arguments. The first argument is the name of a table - +** the name of a table in the RBU database. The second, if it is present, is 1 +** for a view or 0 for a table. +** +** For a non-vacuum RBU handle, if the table name matches the pattern: +** +** data[0-9]_ +** +** where is any sequence of 1 or more characters, is returned. +** Otherwise, if the only argument does not match the above pattern, an SQL +** NULL is returned. +** +** "data_t1" -> "t1" +** "data0123_t2" -> "t2" +** "dataAB_t3" -> NULL +** +** For an rbu vacuum handle, a copy of the first argument is returned if +** the second argument is either missing or 0 (not a view). +*/ +static void rbuTargetNameFunc( + sqlite3_context *pCtx, + int argc, + sqlite3_value **argv +){ + sqlite3rbu *p = sqlite3_user_data(pCtx); + const char *zIn; + assert( argc==1 || argc==2 ); + + zIn = (const char*)sqlite3_value_text(argv[0]); + if( zIn ){ + if( rbuIsVacuum(p) ){ + assert( argc==2 || argc==1 ); + if( argc==1 || 0==sqlite3_value_int(argv[1]) ){ + sqlite3_result_text(pCtx, zIn, -1, SQLITE_STATIC); + } + }else{ + if( strlen(zIn)>4 && memcmp("data", zIn, 4)==0 ){ + int i; + for(i=4; zIn[i]>='0' && zIn[i]<='9'; i++); + if( zIn[i]=='_' && zIn[i+1] ){ + sqlite3_result_text(pCtx, &zIn[i+1], -1, SQLITE_STATIC); + } + } + } + } +} + +/* +** Initialize the iterator structure passed as the second argument. +** +** If no error occurs, SQLITE_OK is returned and the iterator is left +** pointing to the first entry. Otherwise, an error code and message is +** left in the RBU handle passed as the first argument. A copy of the +** error code is returned. +*/ +static int rbuObjIterFirst(sqlite3rbu *p, RbuObjIter *pIter){ + int rc; + memset(pIter, 0, sizeof(RbuObjIter)); + + rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pTblIter, &p->zErrmsg, + sqlite3_mprintf( + "SELECT rbu_target_name(name, type='view') AS target, name " + "FROM sqlite_schema " + "WHERE type IN ('table', 'view') AND target IS NOT NULL " + " %s " + "ORDER BY name" + , rbuIsVacuum(p) ? "AND rootpage!=0 AND rootpage IS NOT NULL" : "")); + + if( rc==SQLITE_OK ){ + rc = prepareAndCollectError(p->dbMain, &pIter->pIdxIter, &p->zErrmsg, + "SELECT name, rootpage, sql IS NULL OR substr(8, 6)=='UNIQUE' " + " FROM main.sqlite_schema " + " WHERE type='index' AND tbl_name = ?" + ); + } + + pIter->bCleanup = 1; + p->rc = rc; + return rbuObjIterNext(p, pIter); +} + +/* +** This is a wrapper around "sqlite3_mprintf(zFmt, ...)". If an OOM occurs, +** an error code is stored in the RBU handle passed as the first argument. +** +** If an error has already occurred (p->rc is already set to something other +** than SQLITE_OK), then this function returns NULL without modifying the +** stored error code. In this case it still calls sqlite3_free() on any +** printf() parameters associated with %z conversions. +*/ +static char *rbuMPrintf(sqlite3rbu *p, const char *zFmt, ...){ + char *zSql = 0; + va_list ap; + va_start(ap, zFmt); + zSql = sqlite3_vmprintf(zFmt, ap); + if( p->rc==SQLITE_OK ){ + if( zSql==0 ) p->rc = SQLITE_NOMEM; + }else{ + sqlite3_free(zSql); + zSql = 0; + } + va_end(ap); + return zSql; +} + +/* +** Argument zFmt is a sqlite3_mprintf() style format string. The trailing +** arguments are the usual subsitution values. This function performs +** the printf() style substitutions and executes the result as an SQL +** statement on the RBU handles database. +** +** If an error occurs, an error code and error message is stored in the +** RBU handle. If an error has already occurred when this function is +** called, it is a no-op. +*/ +static int rbuMPrintfExec(sqlite3rbu *p, sqlite3 *db, const char *zFmt, ...){ + va_list ap; + char *zSql; + va_start(ap, zFmt); + zSql = sqlite3_vmprintf(zFmt, ap); + if( p->rc==SQLITE_OK ){ + if( zSql==0 ){ + p->rc = SQLITE_NOMEM; + }else{ + p->rc = sqlite3_exec(db, zSql, 0, 0, &p->zErrmsg); + } + } + sqlite3_free(zSql); + va_end(ap); + return p->rc; +} + +/* +** Attempt to allocate and return a pointer to a zeroed block of nByte +** bytes. +** +** If an error (i.e. an OOM condition) occurs, return NULL and leave an +** error code in the rbu handle passed as the first argument. Or, if an +** error has already occurred when this function is called, return NULL +** immediately without attempting the allocation or modifying the stored +** error code. +*/ +static void *rbuMalloc(sqlite3rbu *p, sqlite3_int64 nByte){ + void *pRet = 0; + if( p->rc==SQLITE_OK ){ + assert( nByte>0 ); + pRet = sqlite3_malloc64(nByte); + if( pRet==0 ){ + p->rc = SQLITE_NOMEM; + }else{ + memset(pRet, 0, nByte); + } + } + return pRet; +} + + +/* +** Allocate and zero the pIter->azTblCol[] and abTblPk[] arrays so that +** there is room for at least nCol elements. If an OOM occurs, store an +** error code in the RBU handle passed as the first argument. +*/ +static void rbuAllocateIterArrays(sqlite3rbu *p, RbuObjIter *pIter, int nCol){ + sqlite3_int64 nByte = (2*sizeof(char*) + sizeof(int) + 3*sizeof(u8)) * nCol; + char **azNew; + + azNew = (char**)rbuMalloc(p, nByte); + if( azNew ){ + pIter->azTblCol = azNew; + pIter->azTblType = &azNew[nCol]; + pIter->aiSrcOrder = (int*)&pIter->azTblType[nCol]; + pIter->abTblPk = (u8*)&pIter->aiSrcOrder[nCol]; + pIter->abNotNull = (u8*)&pIter->abTblPk[nCol]; + pIter->abIndexed = (u8*)&pIter->abNotNull[nCol]; + } +} + +/* +** The first argument must be a nul-terminated string. This function +** returns a copy of the string in memory obtained from sqlite3_malloc(). +** It is the responsibility of the caller to eventually free this memory +** using sqlite3_free(). +** +** If an OOM condition is encountered when attempting to allocate memory, +** output variable (*pRc) is set to SQLITE_NOMEM before returning. Otherwise, +** if the allocation succeeds, (*pRc) is left unchanged. +*/ +static char *rbuStrndup(const char *zStr, int *pRc){ + char *zRet = 0; + + if( *pRc==SQLITE_OK ){ + if( zStr ){ + size_t nCopy = strlen(zStr) + 1; + zRet = (char*)sqlite3_malloc64(nCopy); + if( zRet ){ + memcpy(zRet, zStr, nCopy); + }else{ + *pRc = SQLITE_NOMEM; + } + } + } + + return zRet; +} + +/* +** Finalize the statement passed as the second argument. +** +** If the sqlite3_finalize() call indicates that an error occurs, and the +** rbu handle error code is not already set, set the error code and error +** message accordingly. +*/ +static void rbuFinalize(sqlite3rbu *p, sqlite3_stmt *pStmt){ + sqlite3 *db = sqlite3_db_handle(pStmt); + int rc = sqlite3_finalize(pStmt); + if( p->rc==SQLITE_OK && rc!=SQLITE_OK ){ + p->rc = rc; + p->zErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + } +} + +/* Determine the type of a table. +** +** peType is of type (int*), a pointer to an output parameter of type +** (int). This call sets the output parameter as follows, depending +** on the type of the table specified by parameters dbName and zTbl. +** +** RBU_PK_NOTABLE: No such table. +** RBU_PK_NONE: Table has an implicit rowid. +** RBU_PK_IPK: Table has an explicit IPK column. +** RBU_PK_EXTERNAL: Table has an external PK index. +** RBU_PK_WITHOUT_ROWID: Table is WITHOUT ROWID. +** RBU_PK_VTAB: Table is a virtual table. +** +** Argument *piPk is also of type (int*), and also points to an output +** parameter. Unless the table has an external primary key index +** (i.e. unless *peType is set to 3), then *piPk is set to zero. Or, +** if the table does have an external primary key index, then *piPk +** is set to the root page number of the primary key index before +** returning. +** +** ALGORITHM: +** +** if( no entry exists in sqlite_schema ){ +** return RBU_PK_NOTABLE +** }else if( sql for the entry starts with "CREATE VIRTUAL" ){ +** return RBU_PK_VTAB +** }else if( "PRAGMA index_list()" for the table contains a "pk" index ){ +** if( the index that is the pk exists in sqlite_schema ){ +** *piPK = rootpage of that index. +** return RBU_PK_EXTERNAL +** }else{ +** return RBU_PK_WITHOUT_ROWID +** } +** }else if( "PRAGMA table_info()" lists one or more "pk" columns ){ +** return RBU_PK_IPK +** }else{ +** return RBU_PK_NONE +** } +*/ +static void rbuTableType( + sqlite3rbu *p, + const char *zTab, + int *peType, + int *piTnum, + int *piPk +){ + /* + ** 0) SELECT count(*) FROM sqlite_schema where name=%Q AND IsVirtual(%Q) + ** 1) PRAGMA index_list = ? + ** 2) SELECT count(*) FROM sqlite_schema where name=%Q + ** 3) PRAGMA table_info = ? + */ + sqlite3_stmt *aStmt[4] = {0, 0, 0, 0}; + + *peType = RBU_PK_NOTABLE; + *piPk = 0; + + assert( p->rc==SQLITE_OK ); + p->rc = prepareFreeAndCollectError(p->dbMain, &aStmt[0], &p->zErrmsg, + sqlite3_mprintf( + "SELECT " + " (sql COLLATE nocase BETWEEN 'CREATE VIRTUAL' AND 'CREATE VIRTUAM')," + " rootpage" + " FROM sqlite_schema" + " WHERE name=%Q", zTab + )); + if( p->rc!=SQLITE_OK || sqlite3_step(aStmt[0])!=SQLITE_ROW ){ + /* Either an error, or no such table. */ + goto rbuTableType_end; + } + if( sqlite3_column_int(aStmt[0], 0) ){ + *peType = RBU_PK_VTAB; /* virtual table */ + goto rbuTableType_end; + } + *piTnum = sqlite3_column_int(aStmt[0], 1); + + p->rc = prepareFreeAndCollectError(p->dbMain, &aStmt[1], &p->zErrmsg, + sqlite3_mprintf("PRAGMA index_list=%Q",zTab) + ); + if( p->rc ) goto rbuTableType_end; + while( sqlite3_step(aStmt[1])==SQLITE_ROW ){ + const u8 *zOrig = sqlite3_column_text(aStmt[1], 3); + const u8 *zIdx = sqlite3_column_text(aStmt[1], 1); + if( zOrig && zIdx && zOrig[0]=='p' ){ + p->rc = prepareFreeAndCollectError(p->dbMain, &aStmt[2], &p->zErrmsg, + sqlite3_mprintf( + "SELECT rootpage FROM sqlite_schema WHERE name = %Q", zIdx + )); + if( p->rc==SQLITE_OK ){ + if( sqlite3_step(aStmt[2])==SQLITE_ROW ){ + *piPk = sqlite3_column_int(aStmt[2], 0); + *peType = RBU_PK_EXTERNAL; + }else{ + *peType = RBU_PK_WITHOUT_ROWID; + } + } + goto rbuTableType_end; + } + } + + p->rc = prepareFreeAndCollectError(p->dbMain, &aStmt[3], &p->zErrmsg, + sqlite3_mprintf("PRAGMA table_info=%Q",zTab) + ); + if( p->rc==SQLITE_OK ){ + while( sqlite3_step(aStmt[3])==SQLITE_ROW ){ + if( sqlite3_column_int(aStmt[3],5)>0 ){ + *peType = RBU_PK_IPK; /* explicit IPK column */ + goto rbuTableType_end; + } + } + *peType = RBU_PK_NONE; + } + +rbuTableType_end: { + unsigned int i; + for(i=0; iabIndexed[] array. +*/ +static void rbuObjIterCacheIndexedCols(sqlite3rbu *p, RbuObjIter *pIter){ + sqlite3_stmt *pList = 0; + int bIndex = 0; + + if( p->rc==SQLITE_OK ){ + memcpy(pIter->abIndexed, pIter->abTblPk, sizeof(u8)*pIter->nTblCol); + p->rc = prepareFreeAndCollectError(p->dbMain, &pList, &p->zErrmsg, + sqlite3_mprintf("PRAGMA main.index_list = %Q", pIter->zTbl) + ); + } + + pIter->nIndex = 0; + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pList) ){ + const char *zIdx = (const char*)sqlite3_column_text(pList, 1); + int bPartial = sqlite3_column_int(pList, 4); + sqlite3_stmt *pXInfo = 0; + if( zIdx==0 ) break; + if( bPartial ){ + memset(pIter->abIndexed, 0x01, sizeof(u8)*pIter->nTblCol); + } + p->rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg, + sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", zIdx) + ); + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){ + int iCid = sqlite3_column_int(pXInfo, 1); + if( iCid>=0 ) pIter->abIndexed[iCid] = 1; + if( iCid==-2 ){ + memset(pIter->abIndexed, 0x01, sizeof(u8)*pIter->nTblCol); + } + } + rbuFinalize(p, pXInfo); + bIndex = 1; + pIter->nIndex++; + } + + if( pIter->eType==RBU_PK_WITHOUT_ROWID ){ + /* "PRAGMA index_list" includes the main PK b-tree */ + pIter->nIndex--; + } + + rbuFinalize(p, pList); + if( bIndex==0 ) pIter->abIndexed = 0; +} + + +/* +** If they are not already populated, populate the pIter->azTblCol[], +** pIter->abTblPk[], pIter->nTblCol and pIter->bRowid variables according to +** the table (not index) that the iterator currently points to. +** +** Return SQLITE_OK if successful, or an SQLite error code otherwise. If +** an error does occur, an error code and error message are also left in +** the RBU handle. +*/ +static int rbuObjIterCacheTableInfo(sqlite3rbu *p, RbuObjIter *pIter){ + if( pIter->azTblCol==0 ){ + sqlite3_stmt *pStmt = 0; + int nCol = 0; + int i; /* for() loop iterator variable */ + int bRbuRowid = 0; /* If input table has column "rbu_rowid" */ + int iOrder = 0; + int iTnum = 0; + + /* Figure out the type of table this step will deal with. */ + assert( pIter->eType==0 ); + rbuTableType(p, pIter->zTbl, &pIter->eType, &iTnum, &pIter->iPkTnum); + if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_NOTABLE ){ + p->rc = SQLITE_ERROR; + p->zErrmsg = sqlite3_mprintf("no such table: %s", pIter->zTbl); + } + if( p->rc ) return p->rc; + if( pIter->zIdx==0 ) pIter->iTnum = iTnum; + + assert( pIter->eType==RBU_PK_NONE || pIter->eType==RBU_PK_IPK + || pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_WITHOUT_ROWID + || pIter->eType==RBU_PK_VTAB + ); + + /* Populate the azTblCol[] and nTblCol variables based on the columns + ** of the input table. Ignore any input table columns that begin with + ** "rbu_". */ + p->rc = prepareFreeAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg, + sqlite3_mprintf("SELECT * FROM '%q'", pIter->zDataTbl) + ); + if( p->rc==SQLITE_OK ){ + nCol = sqlite3_column_count(pStmt); + rbuAllocateIterArrays(p, pIter, nCol); + } + for(i=0; p->rc==SQLITE_OK && irc); + pIter->aiSrcOrder[pIter->nTblCol] = pIter->nTblCol; + pIter->azTblCol[pIter->nTblCol++] = zCopy; + } + else if( 0==sqlite3_stricmp("rbu_rowid", zName) ){ + bRbuRowid = 1; + } + } + sqlite3_finalize(pStmt); + pStmt = 0; + + if( p->rc==SQLITE_OK + && rbuIsVacuum(p)==0 + && bRbuRowid!=(pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE) + ){ + p->rc = SQLITE_ERROR; + p->zErrmsg = sqlite3_mprintf( + "table %q %s rbu_rowid column", pIter->zDataTbl, + (bRbuRowid ? "may not have" : "requires") + ); + } + + /* Check that all non-HIDDEN columns in the destination table are also + ** present in the input table. Populate the abTblPk[], azTblType[] and + ** aiTblOrder[] arrays at the same time. */ + if( p->rc==SQLITE_OK ){ + p->rc = prepareFreeAndCollectError(p->dbMain, &pStmt, &p->zErrmsg, + sqlite3_mprintf("PRAGMA table_info(%Q)", pIter->zTbl) + ); + } + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ + const char *zName = (const char*)sqlite3_column_text(pStmt, 1); + if( zName==0 ) break; /* An OOM - finalize() below returns S_NOMEM */ + for(i=iOrder; inTblCol; i++){ + if( 0==strcmp(zName, pIter->azTblCol[i]) ) break; + } + if( i==pIter->nTblCol ){ + p->rc = SQLITE_ERROR; + p->zErrmsg = sqlite3_mprintf("column missing from %q: %s", + pIter->zDataTbl, zName + ); + }else{ + int iPk = sqlite3_column_int(pStmt, 5); + int bNotNull = sqlite3_column_int(pStmt, 3); + const char *zType = (const char*)sqlite3_column_text(pStmt, 2); + + if( i!=iOrder ){ + SWAP(int, pIter->aiSrcOrder[i], pIter->aiSrcOrder[iOrder]); + SWAP(char*, pIter->azTblCol[i], pIter->azTblCol[iOrder]); + } + + pIter->azTblType[iOrder] = rbuStrndup(zType, &p->rc); + assert( iPk>=0 ); + pIter->abTblPk[iOrder] = (u8)iPk; + pIter->abNotNull[iOrder] = (u8)bNotNull || (iPk!=0); + iOrder++; + } + } + + rbuFinalize(p, pStmt); + rbuObjIterCacheIndexedCols(p, pIter); + assert( pIter->eType!=RBU_PK_VTAB || pIter->abIndexed==0 ); + assert( pIter->eType!=RBU_PK_VTAB || pIter->nIndex==0 ); + } + + return p->rc; +} + +/* +** This function constructs and returns a pointer to a nul-terminated +** string containing some SQL clause or list based on one or more of the +** column names currently stored in the pIter->azTblCol[] array. +*/ +static char *rbuObjIterGetCollist( + sqlite3rbu *p, /* RBU object */ + RbuObjIter *pIter /* Object iterator for column names */ +){ + char *zList = 0; + const char *zSep = ""; + int i; + for(i=0; inTblCol; i++){ + const char *z = pIter->azTblCol[i]; + zList = rbuMPrintf(p, "%z%s\"%w\"", zList, zSep, z); + zSep = ", "; + } + return zList; +} + +/* +** Return a comma separated list of the quoted PRIMARY KEY column names, +** in order, for the current table. Before each column name, add the text +** zPre. After each column name, add the zPost text. Use zSeparator as +** the separator text (usually ", "). +*/ +static char *rbuObjIterGetPkList( + sqlite3rbu *p, /* RBU object */ + RbuObjIter *pIter, /* Object iterator for column names */ + const char *zPre, /* Before each quoted column name */ + const char *zSeparator, /* Separator to use between columns */ + const char *zPost /* After each quoted column name */ +){ + int iPk = 1; + char *zRet = 0; + const char *zSep = ""; + while( 1 ){ + int i; + for(i=0; inTblCol; i++){ + if( (int)pIter->abTblPk[i]==iPk ){ + const char *zCol = pIter->azTblCol[i]; + zRet = rbuMPrintf(p, "%z%s%s\"%w\"%s", zRet, zSep, zPre, zCol, zPost); + zSep = zSeparator; + break; + } + } + if( i==pIter->nTblCol ) break; + iPk++; + } + return zRet; +} + +/* +** This function is called as part of restarting an RBU vacuum within +** stage 1 of the process (while the *-oal file is being built) while +** updating a table (not an index). The table may be a rowid table or +** a WITHOUT ROWID table. It queries the target database to find the +** largest key that has already been written to the target table and +** constructs a WHERE clause that can be used to extract the remaining +** rows from the source table. For a rowid table, the WHERE clause +** is of the form: +** +** "WHERE _rowid_ > ?" +** +** and for WITHOUT ROWID tables: +** +** "WHERE (key1, key2) > (?, ?)" +** +** Instead of "?" placeholders, the actual WHERE clauses created by +** this function contain literal SQL values. +*/ +static char *rbuVacuumTableStart( + sqlite3rbu *p, /* RBU handle */ + RbuObjIter *pIter, /* RBU iterator object */ + int bRowid, /* True for a rowid table */ + const char *zWrite /* Target table name prefix */ +){ + sqlite3_stmt *pMax = 0; + char *zRet = 0; + if( bRowid ){ + p->rc = prepareFreeAndCollectError(p->dbMain, &pMax, &p->zErrmsg, + sqlite3_mprintf( + "SELECT max(_rowid_) FROM \"%s%w\"", zWrite, pIter->zTbl + ) + ); + if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pMax) ){ + sqlite3_int64 iMax = sqlite3_column_int64(pMax, 0); + zRet = rbuMPrintf(p, " WHERE _rowid_ > %lld ", iMax); + } + rbuFinalize(p, pMax); + }else{ + char *zOrder = rbuObjIterGetPkList(p, pIter, "", ", ", " DESC"); + char *zSelect = rbuObjIterGetPkList(p, pIter, "quote(", "||','||", ")"); + char *zList = rbuObjIterGetPkList(p, pIter, "", ", ", ""); + + if( p->rc==SQLITE_OK ){ + p->rc = prepareFreeAndCollectError(p->dbMain, &pMax, &p->zErrmsg, + sqlite3_mprintf( + "SELECT %s FROM \"%s%w\" ORDER BY %s LIMIT 1", + zSelect, zWrite, pIter->zTbl, zOrder + ) + ); + if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pMax) ){ + const char *zVal = (const char*)sqlite3_column_text(pMax, 0); + zRet = rbuMPrintf(p, " WHERE (%s) > (%s) ", zList, zVal); + } + rbuFinalize(p, pMax); + } + + sqlite3_free(zOrder); + sqlite3_free(zSelect); + sqlite3_free(zList); + } + return zRet; +} + +/* +** This function is called as part of restating an RBU vacuum when the +** current operation is writing content to an index. If possible, it +** queries the target index b-tree for the largest key already written to +** it, then composes and returns an expression that can be used in a WHERE +** clause to select the remaining required rows from the source table. +** It is only possible to return such an expression if: +** +** * The index contains no DESC columns, and +** * The last key written to the index before the operation was +** suspended does not contain any NULL values. +** +** The expression is of the form: +** +** (index-field1, index-field2, ...) > (?, ?, ...) +** +** except that the "?" placeholders are replaced with literal values. +** +** If the expression cannot be created, NULL is returned. In this case, +** the caller has to use an OFFSET clause to extract only the required +** rows from the sourct table, just as it does for an RBU update operation. +*/ +static char *rbuVacuumIndexStart( + sqlite3rbu *p, /* RBU handle */ + RbuObjIter *pIter /* RBU iterator object */ +){ + char *zOrder = 0; + char *zLhs = 0; + char *zSelect = 0; + char *zVector = 0; + char *zRet = 0; + int bFailed = 0; + const char *zSep = ""; + int iCol = 0; + sqlite3_stmt *pXInfo = 0; + + p->rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg, + sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", pIter->zIdx) + ); + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){ + int iCid = sqlite3_column_int(pXInfo, 1); + const char *zCollate = (const char*)sqlite3_column_text(pXInfo, 4); + const char *zCol; + if( sqlite3_column_int(pXInfo, 3) ){ + bFailed = 1; + break; + } + + if( iCid<0 ){ + if( pIter->eType==RBU_PK_IPK ){ + int i; + for(i=0; pIter->abTblPk[i]==0; i++); + assert( inTblCol ); + zCol = pIter->azTblCol[i]; + }else{ + zCol = "_rowid_"; + } + }else{ + zCol = pIter->azTblCol[iCid]; + } + + zLhs = rbuMPrintf(p, "%z%s \"%w\" COLLATE %Q", + zLhs, zSep, zCol, zCollate + ); + zOrder = rbuMPrintf(p, "%z%s \"rbu_imp_%d%w\" COLLATE %Q DESC", + zOrder, zSep, iCol, zCol, zCollate + ); + zSelect = rbuMPrintf(p, "%z%s quote(\"rbu_imp_%d%w\")", + zSelect, zSep, iCol, zCol + ); + zSep = ", "; + iCol++; + } + rbuFinalize(p, pXInfo); + if( bFailed ) goto index_start_out; + + if( p->rc==SQLITE_OK ){ + sqlite3_stmt *pSel = 0; + + p->rc = prepareFreeAndCollectError(p->dbMain, &pSel, &p->zErrmsg, + sqlite3_mprintf("SELECT %s FROM \"rbu_imp_%w\" ORDER BY %s LIMIT 1", + zSelect, pIter->zTbl, zOrder + ) + ); + if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSel) ){ + zSep = ""; + for(iCol=0; iColnCol; iCol++){ + const char *zQuoted = (const char*)sqlite3_column_text(pSel, iCol); + if( zQuoted==0 ){ + p->rc = SQLITE_NOMEM; + }else if( zQuoted[0]=='N' ){ + bFailed = 1; + break; + } + zVector = rbuMPrintf(p, "%z%s%s", zVector, zSep, zQuoted); + zSep = ", "; + } + + if( !bFailed ){ + zRet = rbuMPrintf(p, "(%s) > (%s)", zLhs, zVector); + } + } + rbuFinalize(p, pSel); + } + + index_start_out: + sqlite3_free(zOrder); + sqlite3_free(zSelect); + sqlite3_free(zVector); + sqlite3_free(zLhs); + return zRet; +} + +/* +** This function is used to create a SELECT list (the list of SQL +** expressions that follows a SELECT keyword) for a SELECT statement +** used to read from an data_xxx or rbu_tmp_xxx table while updating the +** index object currently indicated by the iterator object passed as the +** second argument. A "PRAGMA index_xinfo = " statement is used +** to obtain the required information. +** +** If the index is of the following form: +** +** CREATE INDEX i1 ON t1(c, b COLLATE nocase); +** +** and "t1" is a table with an explicit INTEGER PRIMARY KEY column +** "ipk", the returned string is: +** +** "`c` COLLATE 'BINARY', `b` COLLATE 'NOCASE', `ipk` COLLATE 'BINARY'" +** +** As well as the returned string, three other malloc'd strings are +** returned via output parameters. As follows: +** +** pzImposterCols: ... +** pzImposterPk: ... +** pzWhere: ... +*/ +static char *rbuObjIterGetIndexCols( + sqlite3rbu *p, /* RBU object */ + RbuObjIter *pIter, /* Object iterator for column names */ + char **pzImposterCols, /* OUT: Columns for imposter table */ + char **pzImposterPk, /* OUT: Imposter PK clause */ + char **pzWhere, /* OUT: WHERE clause */ + int *pnBind /* OUT: Trbul number of columns */ +){ + int rc = p->rc; /* Error code */ + int rc2; /* sqlite3_finalize() return code */ + char *zRet = 0; /* String to return */ + char *zImpCols = 0; /* String to return via *pzImposterCols */ + char *zImpPK = 0; /* String to return via *pzImposterPK */ + char *zWhere = 0; /* String to return via *pzWhere */ + int nBind = 0; /* Value to return via *pnBind */ + const char *zCom = ""; /* Set to ", " later on */ + const char *zAnd = ""; /* Set to " AND " later on */ + sqlite3_stmt *pXInfo = 0; /* PRAGMA index_xinfo = ? */ + + if( rc==SQLITE_OK ){ + assert( p->zErrmsg==0 ); + rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg, + sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", pIter->zIdx) + ); + } + + while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){ + int iCid = sqlite3_column_int(pXInfo, 1); + int bDesc = sqlite3_column_int(pXInfo, 3); + const char *zCollate = (const char*)sqlite3_column_text(pXInfo, 4); + const char *zCol = 0; + const char *zType; + + if( iCid==-2 ){ + int iSeq = sqlite3_column_int(pXInfo, 0); + zRet = sqlite3_mprintf("%z%s(%.*s) COLLATE %Q", zRet, zCom, + pIter->aIdxCol[iSeq].nSpan, pIter->aIdxCol[iSeq].zSpan, zCollate + ); + zType = ""; + }else { + if( iCid<0 ){ + /* An integer primary key. If the table has an explicit IPK, use + ** its name. Otherwise, use "rbu_rowid". */ + if( pIter->eType==RBU_PK_IPK ){ + int i; + for(i=0; pIter->abTblPk[i]==0; i++); + assert( inTblCol ); + zCol = pIter->azTblCol[i]; + }else if( rbuIsVacuum(p) ){ + zCol = "_rowid_"; + }else{ + zCol = "rbu_rowid"; + } + zType = "INTEGER"; + }else{ + zCol = pIter->azTblCol[iCid]; + zType = pIter->azTblType[iCid]; + } + zRet = sqlite3_mprintf("%z%s\"%w\" COLLATE %Q", zRet, zCom,zCol,zCollate); + } + + if( pIter->bUnique==0 || sqlite3_column_int(pXInfo, 5) ){ + const char *zOrder = (bDesc ? " DESC" : ""); + zImpPK = sqlite3_mprintf("%z%s\"rbu_imp_%d%w\"%s", + zImpPK, zCom, nBind, zCol, zOrder + ); + } + zImpCols = sqlite3_mprintf("%z%s\"rbu_imp_%d%w\" %s COLLATE %Q", + zImpCols, zCom, nBind, zCol, zType, zCollate + ); + zWhere = sqlite3_mprintf( + "%z%s\"rbu_imp_%d%w\" IS ?", zWhere, zAnd, nBind, zCol + ); + if( zRet==0 || zImpPK==0 || zImpCols==0 || zWhere==0 ) rc = SQLITE_NOMEM; + zCom = ", "; + zAnd = " AND "; + nBind++; + } + + rc2 = sqlite3_finalize(pXInfo); + if( rc==SQLITE_OK ) rc = rc2; + + if( rc!=SQLITE_OK ){ + sqlite3_free(zRet); + sqlite3_free(zImpCols); + sqlite3_free(zImpPK); + sqlite3_free(zWhere); + zRet = 0; + zImpCols = 0; + zImpPK = 0; + zWhere = 0; + p->rc = rc; + } + + *pzImposterCols = zImpCols; + *pzImposterPk = zImpPK; + *pzWhere = zWhere; + *pnBind = nBind; + return zRet; +} + +/* +** Assuming the current table columns are "a", "b" and "c", and the zObj +** paramter is passed "old", return a string of the form: +** +** "old.a, old.b, old.b" +** +** With the column names escaped. +** +** For tables with implicit rowids - RBU_PK_EXTERNAL and RBU_PK_NONE, append +** the text ", old._rowid_" to the returned value. +*/ +static char *rbuObjIterGetOldlist( + sqlite3rbu *p, + RbuObjIter *pIter, + const char *zObj +){ + char *zList = 0; + if( p->rc==SQLITE_OK && pIter->abIndexed ){ + const char *zS = ""; + int i; + for(i=0; inTblCol; i++){ + if( pIter->abIndexed[i] ){ + const char *zCol = pIter->azTblCol[i]; + zList = sqlite3_mprintf("%z%s%s.\"%w\"", zList, zS, zObj, zCol); + }else{ + zList = sqlite3_mprintf("%z%sNULL", zList, zS); + } + zS = ", "; + if( zList==0 ){ + p->rc = SQLITE_NOMEM; + break; + } + } + + /* For a table with implicit rowids, append "old._rowid_" to the list. */ + if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){ + zList = rbuMPrintf(p, "%z, %s._rowid_", zList, zObj); + } + } + return zList; +} + +/* +** Return an expression that can be used in a WHERE clause to match the +** primary key of the current table. For example, if the table is: +** +** CREATE TABLE t1(a, b, c, PRIMARY KEY(b, c)); +** +** Return the string: +** +** "b = ?1 AND c = ?2" +*/ +static char *rbuObjIterGetWhere( + sqlite3rbu *p, + RbuObjIter *pIter +){ + char *zList = 0; + if( pIter->eType==RBU_PK_VTAB || pIter->eType==RBU_PK_NONE ){ + zList = rbuMPrintf(p, "_rowid_ = ?%d", pIter->nTblCol+1); + }else if( pIter->eType==RBU_PK_EXTERNAL ){ + const char *zSep = ""; + int i; + for(i=0; inTblCol; i++){ + if( pIter->abTblPk[i] ){ + zList = rbuMPrintf(p, "%z%sc%d=?%d", zList, zSep, i, i+1); + zSep = " AND "; + } + } + zList = rbuMPrintf(p, + "_rowid_ = (SELECT id FROM rbu_imposter2 WHERE %z)", zList + ); + + }else{ + const char *zSep = ""; + int i; + for(i=0; inTblCol; i++){ + if( pIter->abTblPk[i] ){ + const char *zCol = pIter->azTblCol[i]; + zList = rbuMPrintf(p, "%z%s\"%w\"=?%d", zList, zSep, zCol, i+1); + zSep = " AND "; + } + } + } + return zList; +} + +/* +** The SELECT statement iterating through the keys for the current object +** (p->objiter.pSelect) currently points to a valid row. However, there +** is something wrong with the rbu_control value in the rbu_control value +** stored in the (p->nCol+1)'th column. Set the error code and error message +** of the RBU handle to something reflecting this. +*/ +static void rbuBadControlError(sqlite3rbu *p){ + p->rc = SQLITE_ERROR; + p->zErrmsg = sqlite3_mprintf("invalid rbu_control value"); +} + + +/* +** Return a nul-terminated string containing the comma separated list of +** assignments that should be included following the "SET" keyword of +** an UPDATE statement used to update the table object that the iterator +** passed as the second argument currently points to if the rbu_control +** column of the data_xxx table entry is set to zMask. +** +** The memory for the returned string is obtained from sqlite3_malloc(). +** It is the responsibility of the caller to eventually free it using +** sqlite3_free(). +** +** If an OOM error is encountered when allocating space for the new +** string, an error code is left in the rbu handle passed as the first +** argument and NULL is returned. Or, if an error has already occurred +** when this function is called, NULL is returned immediately, without +** attempting the allocation or modifying the stored error code. +*/ +static char *rbuObjIterGetSetlist( + sqlite3rbu *p, + RbuObjIter *pIter, + const char *zMask +){ + char *zList = 0; + if( p->rc==SQLITE_OK ){ + int i; + + if( (int)strlen(zMask)!=pIter->nTblCol ){ + rbuBadControlError(p); + }else{ + const char *zSep = ""; + for(i=0; inTblCol; i++){ + char c = zMask[pIter->aiSrcOrder[i]]; + if( c=='x' ){ + zList = rbuMPrintf(p, "%z%s\"%w\"=?%d", + zList, zSep, pIter->azTblCol[i], i+1 + ); + zSep = ", "; + } + else if( c=='d' ){ + zList = rbuMPrintf(p, "%z%s\"%w\"=rbu_delta(\"%w\", ?%d)", + zList, zSep, pIter->azTblCol[i], pIter->azTblCol[i], i+1 + ); + zSep = ", "; + } + else if( c=='f' ){ + zList = rbuMPrintf(p, "%z%s\"%w\"=rbu_fossil_delta(\"%w\", ?%d)", + zList, zSep, pIter->azTblCol[i], pIter->azTblCol[i], i+1 + ); + zSep = ", "; + } + } + } + } + return zList; +} + +/* +** Return a nul-terminated string consisting of nByte comma separated +** "?" expressions. For example, if nByte is 3, return a pointer to +** a buffer containing the string "?,?,?". +** +** The memory for the returned string is obtained from sqlite3_malloc(). +** It is the responsibility of the caller to eventually free it using +** sqlite3_free(). +** +** If an OOM error is encountered when allocating space for the new +** string, an error code is left in the rbu handle passed as the first +** argument and NULL is returned. Or, if an error has already occurred +** when this function is called, NULL is returned immediately, without +** attempting the allocation or modifying the stored error code. +*/ +static char *rbuObjIterGetBindlist(sqlite3rbu *p, int nBind){ + char *zRet = 0; + sqlite3_int64 nByte = 2*(sqlite3_int64)nBind + 1; + + zRet = (char*)rbuMalloc(p, nByte); + if( zRet ){ + int i; + for(i=0; izIdx==0 ); + if( p->rc==SQLITE_OK ){ + const char *zSep = "PRIMARY KEY("; + sqlite3_stmt *pXList = 0; /* PRAGMA index_list = (pIter->zTbl) */ + sqlite3_stmt *pXInfo = 0; /* PRAGMA index_xinfo = */ + + p->rc = prepareFreeAndCollectError(p->dbMain, &pXList, &p->zErrmsg, + sqlite3_mprintf("PRAGMA main.index_list = %Q", pIter->zTbl) + ); + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXList) ){ + const char *zOrig = (const char*)sqlite3_column_text(pXList,3); + if( zOrig && strcmp(zOrig, "pk")==0 ){ + const char *zIdx = (const char*)sqlite3_column_text(pXList,1); + if( zIdx ){ + p->rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg, + sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", zIdx) + ); + } + break; + } + } + rbuFinalize(p, pXList); + + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){ + if( sqlite3_column_int(pXInfo, 5) ){ + /* int iCid = sqlite3_column_int(pXInfo, 0); */ + const char *zCol = (const char*)sqlite3_column_text(pXInfo, 2); + const char *zDesc = sqlite3_column_int(pXInfo, 3) ? " DESC" : ""; + z = rbuMPrintf(p, "%z%s\"%w\"%s", z, zSep, zCol, zDesc); + zSep = ", "; + } + } + z = rbuMPrintf(p, "%z)", z); + rbuFinalize(p, pXInfo); + } + return z; +} + +/* +** This function creates the second imposter table used when writing to +** a table b-tree where the table has an external primary key. If the +** iterator passed as the second argument does not currently point to +** a table (not index) with an external primary key, this function is a +** no-op. +** +** Assuming the iterator does point to a table with an external PK, this +** function creates a WITHOUT ROWID imposter table named "rbu_imposter2" +** used to access that PK index. For example, if the target table is +** declared as follows: +** +** CREATE TABLE t1(a, b TEXT, c REAL, PRIMARY KEY(b, c)); +** +** then the imposter table schema is: +** +** CREATE TABLE rbu_imposter2(c1 TEXT, c2 REAL, id INTEGER) WITHOUT ROWID; +** +*/ +static void rbuCreateImposterTable2(sqlite3rbu *p, RbuObjIter *pIter){ + if( p->rc==SQLITE_OK && pIter->eType==RBU_PK_EXTERNAL ){ + int tnum = pIter->iPkTnum; /* Root page of PK index */ + sqlite3_stmt *pQuery = 0; /* SELECT name ... WHERE rootpage = $tnum */ + const char *zIdx = 0; /* Name of PK index */ + sqlite3_stmt *pXInfo = 0; /* PRAGMA main.index_xinfo = $zIdx */ + const char *zComma = ""; + char *zCols = 0; /* Used to build up list of table cols */ + char *zPk = 0; /* Used to build up table PK declaration */ + + /* Figure out the name of the primary key index for the current table. + ** This is needed for the argument to "PRAGMA index_xinfo". Set + ** zIdx to point to a nul-terminated string containing this name. */ + p->rc = prepareAndCollectError(p->dbMain, &pQuery, &p->zErrmsg, + "SELECT name FROM sqlite_schema WHERE rootpage = ?" + ); + if( p->rc==SQLITE_OK ){ + sqlite3_bind_int(pQuery, 1, tnum); + if( SQLITE_ROW==sqlite3_step(pQuery) ){ + zIdx = (const char*)sqlite3_column_text(pQuery, 0); + } + } + if( zIdx ){ + p->rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg, + sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", zIdx) + ); + } + rbuFinalize(p, pQuery); + + while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){ + int bKey = sqlite3_column_int(pXInfo, 5); + if( bKey ){ + int iCid = sqlite3_column_int(pXInfo, 1); + int bDesc = sqlite3_column_int(pXInfo, 3); + const char *zCollate = (const char*)sqlite3_column_text(pXInfo, 4); + zCols = rbuMPrintf(p, "%z%sc%d %s COLLATE %Q", zCols, zComma, + iCid, pIter->azTblType[iCid], zCollate + ); + zPk = rbuMPrintf(p, "%z%sc%d%s", zPk, zComma, iCid, bDesc?" DESC":""); + zComma = ", "; + } + } + zCols = rbuMPrintf(p, "%z, id INTEGER", zCols); + rbuFinalize(p, pXInfo); + + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 1, tnum); + rbuMPrintfExec(p, p->dbMain, + "CREATE TABLE rbu_imposter2(%z, PRIMARY KEY(%z)) WITHOUT ROWID", + zCols, zPk + ); + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 0); + } +} + +/* +** If an error has already occurred when this function is called, it +** immediately returns zero (without doing any work). Or, if an error +** occurs during the execution of this function, it sets the error code +** in the sqlite3rbu object indicated by the first argument and returns +** zero. +** +** The iterator passed as the second argument is guaranteed to point to +** a table (not an index) when this function is called. This function +** attempts to create any imposter table required to write to the main +** table b-tree of the table before returning. Non-zero is returned if +** an imposter table are created, or zero otherwise. +** +** An imposter table is required in all cases except RBU_PK_VTAB. Only +** virtual tables are written to directly. The imposter table has the +** same schema as the actual target table (less any UNIQUE constraints). +** More precisely, the "same schema" means the same columns, types, +** collation sequences. For tables that do not have an external PRIMARY +** KEY, it also means the same PRIMARY KEY declaration. +*/ +static void rbuCreateImposterTable(sqlite3rbu *p, RbuObjIter *pIter){ + if( p->rc==SQLITE_OK && pIter->eType!=RBU_PK_VTAB ){ + int tnum = pIter->iTnum; + const char *zComma = ""; + char *zSql = 0; + int iCol; + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 1); + + for(iCol=0; p->rc==SQLITE_OK && iColnTblCol; iCol++){ + const char *zPk = ""; + const char *zCol = pIter->azTblCol[iCol]; + const char *zColl = 0; + + p->rc = sqlite3_table_column_metadata( + p->dbMain, "main", pIter->zTbl, zCol, 0, &zColl, 0, 0, 0 + ); + + if( pIter->eType==RBU_PK_IPK && pIter->abTblPk[iCol] ){ + /* If the target table column is an "INTEGER PRIMARY KEY", add + ** "PRIMARY KEY" to the imposter table column declaration. */ + zPk = "PRIMARY KEY "; + } + zSql = rbuMPrintf(p, "%z%s\"%w\" %s %sCOLLATE %Q%s", + zSql, zComma, zCol, pIter->azTblType[iCol], zPk, zColl, + (pIter->abNotNull[iCol] ? " NOT NULL" : "") + ); + zComma = ", "; + } + + if( pIter->eType==RBU_PK_WITHOUT_ROWID ){ + char *zPk = rbuWithoutRowidPK(p, pIter); + if( zPk ){ + zSql = rbuMPrintf(p, "%z, %z", zSql, zPk); + } + } + + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 1, tnum); + rbuMPrintfExec(p, p->dbMain, "CREATE TABLE \"rbu_imp_%w\"(%z)%s", + pIter->zTbl, zSql, + (pIter->eType==RBU_PK_WITHOUT_ROWID ? " WITHOUT ROWID" : "") + ); + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 0); + } +} + +/* +** Prepare a statement used to insert rows into the "rbu_tmp_xxx" table. +** Specifically a statement of the form: +** +** INSERT INTO rbu_tmp_xxx VALUES(?, ?, ? ...); +** +** The number of bound variables is equal to the number of columns in +** the target table, plus one (for the rbu_control column), plus one more +** (for the rbu_rowid column) if the target table is an implicit IPK or +** virtual table. +*/ +static void rbuObjIterPrepareTmpInsert( + sqlite3rbu *p, + RbuObjIter *pIter, + const char *zCollist, + const char *zRbuRowid +){ + int bRbuRowid = (pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE); + char *zBind = rbuObjIterGetBindlist(p, pIter->nTblCol + 1 + bRbuRowid); + if( zBind ){ + assert( pIter->pTmpInsert==0 ); + p->rc = prepareFreeAndCollectError( + p->dbRbu, &pIter->pTmpInsert, &p->zErrmsg, sqlite3_mprintf( + "INSERT INTO %s.'rbu_tmp_%q'(rbu_control,%s%s) VALUES(%z)", + p->zStateDb, pIter->zDataTbl, zCollist, zRbuRowid, zBind + )); + } +} + +static void rbuTmpInsertFunc( + sqlite3_context *pCtx, + int nVal, + sqlite3_value **apVal +){ + sqlite3rbu *p = sqlite3_user_data(pCtx); + int rc = SQLITE_OK; + int i; + + assert( sqlite3_value_int(apVal[0])!=0 + || p->objiter.eType==RBU_PK_EXTERNAL + || p->objiter.eType==RBU_PK_NONE + ); + if( sqlite3_value_int(apVal[0])!=0 ){ + p->nPhaseOneStep += p->objiter.nIndex; + } + + for(i=0; rc==SQLITE_OK && iobjiter.pTmpInsert, i+1, apVal[i]); + } + if( rc==SQLITE_OK ){ + sqlite3_step(p->objiter.pTmpInsert); + rc = sqlite3_reset(p->objiter.pTmpInsert); + } + + if( rc!=SQLITE_OK ){ + sqlite3_result_error_code(pCtx, rc); + } +} + +static char *rbuObjIterGetIndexWhere(sqlite3rbu *p, RbuObjIter *pIter){ + sqlite3_stmt *pStmt = 0; + int rc = p->rc; + char *zRet = 0; + + assert( pIter->zIdxSql==0 && pIter->nIdxCol==0 && pIter->aIdxCol==0 ); + + if( rc==SQLITE_OK ){ + rc = prepareAndCollectError(p->dbMain, &pStmt, &p->zErrmsg, + "SELECT trim(sql) FROM sqlite_schema WHERE type='index' AND name=?" + ); + } + if( rc==SQLITE_OK ){ + int rc2; + rc = sqlite3_bind_text(pStmt, 1, pIter->zIdx, -1, SQLITE_STATIC); + if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ + char *zSql = (char*)sqlite3_column_text(pStmt, 0); + if( zSql ){ + pIter->zIdxSql = zSql = rbuStrndup(zSql, &rc); + } + if( zSql ){ + int nParen = 0; /* Number of open parenthesis */ + int i; + int iIdxCol = 0; + int nIdxAlloc = 0; + for(i=0; zSql[i]; i++){ + char c = zSql[i]; + + /* If necessary, grow the pIter->aIdxCol[] array */ + if( iIdxCol==nIdxAlloc ){ + RbuSpan *aIdxCol = (RbuSpan*)sqlite3_realloc( + pIter->aIdxCol, (nIdxAlloc+16)*sizeof(RbuSpan) + ); + if( aIdxCol==0 ){ + rc = SQLITE_NOMEM; + break; + } + pIter->aIdxCol = aIdxCol; + nIdxAlloc += 16; + } + + if( c=='(' ){ + if( nParen==0 ){ + assert( iIdxCol==0 ); + pIter->aIdxCol[0].zSpan = &zSql[i+1]; + } + nParen++; + } + else if( c==')' ){ + nParen--; + if( nParen==0 ){ + int nSpan = &zSql[i] - pIter->aIdxCol[iIdxCol].zSpan; + pIter->aIdxCol[iIdxCol++].nSpan = nSpan; + i++; + break; + } + }else if( c==',' && nParen==1 ){ + int nSpan = &zSql[i] - pIter->aIdxCol[iIdxCol].zSpan; + pIter->aIdxCol[iIdxCol++].nSpan = nSpan; + pIter->aIdxCol[iIdxCol].zSpan = &zSql[i+1]; + }else if( c=='"' || c=='\'' || c=='`' ){ + for(i++; 1; i++){ + if( zSql[i]==c ){ + if( zSql[i+1]!=c ) break; + i++; + } + } + }else if( c=='[' ){ + for(i++; 1; i++){ + if( zSql[i]==']' ) break; + } + }else if( c=='-' && zSql[i+1]=='-' ){ + for(i=i+2; zSql[i] && zSql[i]!='\n'; i++); + if( zSql[i]=='\0' ) break; + }else if( c=='/' && zSql[i+1]=='*' ){ + for(i=i+2; zSql[i] && (zSql[i]!='*' || zSql[i+1]!='/'); i++); + if( zSql[i]=='\0' ) break; + i++; + } + } + if( zSql[i] ){ + zRet = rbuStrndup(&zSql[i], &rc); + } + pIter->nIdxCol = iIdxCol; + } + } + + rc2 = sqlite3_finalize(pStmt); + if( rc==SQLITE_OK ) rc = rc2; + } + + p->rc = rc; + return zRet; +} + +/* +** Ensure that the SQLite statement handles required to update the +** target database object currently indicated by the iterator passed +** as the second argument are available. +*/ +static int rbuObjIterPrepareAll( + sqlite3rbu *p, + RbuObjIter *pIter, + int nOffset /* Add "LIMIT -1 OFFSET $nOffset" to SELECT */ +){ + assert( pIter->bCleanup==0 ); + if( pIter->pSelect==0 && rbuObjIterCacheTableInfo(p, pIter)==SQLITE_OK ){ + const int tnum = pIter->iTnum; + char *zCollist = 0; /* List of indexed columns */ + char **pz = &p->zErrmsg; + const char *zIdx = pIter->zIdx; + char *zLimit = 0; + + if( nOffset ){ + zLimit = sqlite3_mprintf(" LIMIT -1 OFFSET %d", nOffset); + if( !zLimit ) p->rc = SQLITE_NOMEM; + } + + if( zIdx ){ + const char *zTbl = pIter->zTbl; + char *zImposterCols = 0; /* Columns for imposter table */ + char *zImposterPK = 0; /* Primary key declaration for imposter */ + char *zWhere = 0; /* WHERE clause on PK columns */ + char *zBind = 0; + char *zPart = 0; + int nBind = 0; + + assert( pIter->eType!=RBU_PK_VTAB ); + zPart = rbuObjIterGetIndexWhere(p, pIter); + zCollist = rbuObjIterGetIndexCols( + p, pIter, &zImposterCols, &zImposterPK, &zWhere, &nBind + ); + zBind = rbuObjIterGetBindlist(p, nBind); + + /* Create the imposter table used to write to this index. */ + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 1); + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 1,tnum); + rbuMPrintfExec(p, p->dbMain, + "CREATE TABLE \"rbu_imp_%w\"( %s, PRIMARY KEY( %s ) ) WITHOUT ROWID", + zTbl, zImposterCols, zImposterPK + ); + sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, p->dbMain, "main", 0, 0); + + /* Create the statement to insert index entries */ + pIter->nCol = nBind; + if( p->rc==SQLITE_OK ){ + p->rc = prepareFreeAndCollectError( + p->dbMain, &pIter->pInsert, &p->zErrmsg, + sqlite3_mprintf("INSERT INTO \"rbu_imp_%w\" VALUES(%s)", zTbl, zBind) + ); + } + + /* And to delete index entries */ + if( rbuIsVacuum(p)==0 && p->rc==SQLITE_OK ){ + p->rc = prepareFreeAndCollectError( + p->dbMain, &pIter->pDelete, &p->zErrmsg, + sqlite3_mprintf("DELETE FROM \"rbu_imp_%w\" WHERE %s", zTbl, zWhere) + ); + } + + /* Create the SELECT statement to read keys in sorted order */ + if( p->rc==SQLITE_OK ){ + char *zSql; + if( rbuIsVacuum(p) ){ + char *zStart = 0; + if( nOffset ){ + zStart = rbuVacuumIndexStart(p, pIter); + if( zStart ){ + sqlite3_free(zLimit); + zLimit = 0; + } + } + + zSql = sqlite3_mprintf( + "SELECT %s, 0 AS rbu_control FROM '%q' %s %s %s ORDER BY %s%s", + zCollist, + pIter->zDataTbl, + zPart, + (zStart ? (zPart ? "AND" : "WHERE") : ""), zStart, + zCollist, zLimit + ); + sqlite3_free(zStart); + }else + + if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){ + zSql = sqlite3_mprintf( + "SELECT %s, rbu_control FROM %s.'rbu_tmp_%q' %s ORDER BY %s%s", + zCollist, p->zStateDb, pIter->zDataTbl, + zPart, zCollist, zLimit + ); + }else{ + zSql = sqlite3_mprintf( + "SELECT %s, rbu_control FROM %s.'rbu_tmp_%q' %s " + "UNION ALL " + "SELECT %s, rbu_control FROM '%q' " + "%s %s typeof(rbu_control)='integer' AND rbu_control!=1 " + "ORDER BY %s%s", + zCollist, p->zStateDb, pIter->zDataTbl, zPart, + zCollist, pIter->zDataTbl, + zPart, + (zPart ? "AND" : "WHERE"), + zCollist, zLimit + ); + } + if( p->rc==SQLITE_OK ){ + p->rc = prepareFreeAndCollectError(p->dbRbu,&pIter->pSelect,pz,zSql); + }else{ + sqlite3_free(zSql); + } + } + + sqlite3_free(zImposterCols); + sqlite3_free(zImposterPK); + sqlite3_free(zWhere); + sqlite3_free(zBind); + sqlite3_free(zPart); + }else{ + int bRbuRowid = (pIter->eType==RBU_PK_VTAB) + ||(pIter->eType==RBU_PK_NONE) + ||(pIter->eType==RBU_PK_EXTERNAL && rbuIsVacuum(p)); + const char *zTbl = pIter->zTbl; /* Table this step applies to */ + const char *zWrite; /* Imposter table name */ + + char *zBindings = rbuObjIterGetBindlist(p, pIter->nTblCol + bRbuRowid); + char *zWhere = rbuObjIterGetWhere(p, pIter); + char *zOldlist = rbuObjIterGetOldlist(p, pIter, "old"); + char *zNewlist = rbuObjIterGetOldlist(p, pIter, "new"); + + zCollist = rbuObjIterGetCollist(p, pIter); + pIter->nCol = pIter->nTblCol; + + /* Create the imposter table or tables (if required). */ + rbuCreateImposterTable(p, pIter); + rbuCreateImposterTable2(p, pIter); + zWrite = (pIter->eType==RBU_PK_VTAB ? "" : "rbu_imp_"); + + /* Create the INSERT statement to write to the target PK b-tree */ + if( p->rc==SQLITE_OK ){ + p->rc = prepareFreeAndCollectError(p->dbMain, &pIter->pInsert, pz, + sqlite3_mprintf( + "INSERT INTO \"%s%w\"(%s%s) VALUES(%s)", + zWrite, zTbl, zCollist, (bRbuRowid ? ", _rowid_" : ""), zBindings + ) + ); + } + + /* Create the DELETE statement to write to the target PK b-tree. + ** Because it only performs INSERT operations, this is not required for + ** an rbu vacuum handle. */ + if( rbuIsVacuum(p)==0 && p->rc==SQLITE_OK ){ + p->rc = prepareFreeAndCollectError(p->dbMain, &pIter->pDelete, pz, + sqlite3_mprintf( + "DELETE FROM \"%s%w\" WHERE %s", zWrite, zTbl, zWhere + ) + ); + } + + if( rbuIsVacuum(p)==0 && pIter->abIndexed ){ + const char *zRbuRowid = ""; + if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){ + zRbuRowid = ", rbu_rowid"; + } + + /* Create the rbu_tmp_xxx table and the triggers to populate it. */ + rbuMPrintfExec(p, p->dbRbu, + "CREATE TABLE IF NOT EXISTS %s.'rbu_tmp_%q' AS " + "SELECT *%s FROM '%q' WHERE 0;" + , p->zStateDb, pIter->zDataTbl + , (pIter->eType==RBU_PK_EXTERNAL ? ", 0 AS rbu_rowid" : "") + , pIter->zDataTbl + ); + + rbuMPrintfExec(p, p->dbMain, + "CREATE TEMP TRIGGER rbu_delete_tr BEFORE DELETE ON \"%s%w\" " + "BEGIN " + " SELECT rbu_tmp_insert(3, %s);" + "END;" + + "CREATE TEMP TRIGGER rbu_update1_tr BEFORE UPDATE ON \"%s%w\" " + "BEGIN " + " SELECT rbu_tmp_insert(3, %s);" + "END;" + + "CREATE TEMP TRIGGER rbu_update2_tr AFTER UPDATE ON \"%s%w\" " + "BEGIN " + " SELECT rbu_tmp_insert(4, %s);" + "END;", + zWrite, zTbl, zOldlist, + zWrite, zTbl, zOldlist, + zWrite, zTbl, zNewlist + ); + + if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){ + rbuMPrintfExec(p, p->dbMain, + "CREATE TEMP TRIGGER rbu_insert_tr AFTER INSERT ON \"%s%w\" " + "BEGIN " + " SELECT rbu_tmp_insert(0, %s);" + "END;", + zWrite, zTbl, zNewlist + ); + } + + rbuObjIterPrepareTmpInsert(p, pIter, zCollist, zRbuRowid); + } + + /* Create the SELECT statement to read keys from data_xxx */ + if( p->rc==SQLITE_OK ){ + const char *zRbuRowid = ""; + char *zStart = 0; + char *zOrder = 0; + if( bRbuRowid ){ + zRbuRowid = rbuIsVacuum(p) ? ",_rowid_ " : ",rbu_rowid"; + } + + if( rbuIsVacuum(p) ){ + if( nOffset ){ + zStart = rbuVacuumTableStart(p, pIter, bRbuRowid, zWrite); + if( zStart ){ + sqlite3_free(zLimit); + zLimit = 0; + } + } + if( bRbuRowid ){ + zOrder = rbuMPrintf(p, "_rowid_"); + }else{ + zOrder = rbuObjIterGetPkList(p, pIter, "", ", ", ""); + } + } + + if( p->rc==SQLITE_OK ){ + p->rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pSelect, pz, + sqlite3_mprintf( + "SELECT %s,%s rbu_control%s FROM '%q'%s %s %s %s", + zCollist, + (rbuIsVacuum(p) ? "0 AS " : ""), + zRbuRowid, + pIter->zDataTbl, (zStart ? zStart : ""), + (zOrder ? "ORDER BY" : ""), zOrder, + zLimit + ) + ); + } + sqlite3_free(zStart); + sqlite3_free(zOrder); + } + + sqlite3_free(zWhere); + sqlite3_free(zOldlist); + sqlite3_free(zNewlist); + sqlite3_free(zBindings); + } + sqlite3_free(zCollist); + sqlite3_free(zLimit); + } + + return p->rc; +} + +/* +** Set output variable *ppStmt to point to an UPDATE statement that may +** be used to update the imposter table for the main table b-tree of the +** table object that pIter currently points to, assuming that the +** rbu_control column of the data_xyz table contains zMask. +** +** If the zMask string does not specify any columns to update, then this +** is not an error. Output variable *ppStmt is set to NULL in this case. +*/ +static int rbuGetUpdateStmt( + sqlite3rbu *p, /* RBU handle */ + RbuObjIter *pIter, /* Object iterator */ + const char *zMask, /* rbu_control value ('x.x.') */ + sqlite3_stmt **ppStmt /* OUT: UPDATE statement handle */ +){ + RbuUpdateStmt **pp; + RbuUpdateStmt *pUp = 0; + int nUp = 0; + + /* In case an error occurs */ + *ppStmt = 0; + + /* Search for an existing statement. If one is found, shift it to the front + ** of the LRU queue and return immediately. Otherwise, leave nUp pointing + ** to the number of statements currently in the cache and pUp to the + ** last object in the list. */ + for(pp=&pIter->pRbuUpdate; *pp; pp=&((*pp)->pNext)){ + pUp = *pp; + if( strcmp(pUp->zMask, zMask)==0 ){ + *pp = pUp->pNext; + pUp->pNext = pIter->pRbuUpdate; + pIter->pRbuUpdate = pUp; + *ppStmt = pUp->pUpdate; + return SQLITE_OK; + } + nUp++; + } + assert( pUp==0 || pUp->pNext==0 ); + + if( nUp>=SQLITE_RBU_UPDATE_CACHESIZE ){ + for(pp=&pIter->pRbuUpdate; *pp!=pUp; pp=&((*pp)->pNext)); + *pp = 0; + sqlite3_finalize(pUp->pUpdate); + pUp->pUpdate = 0; + }else{ + pUp = (RbuUpdateStmt*)rbuMalloc(p, sizeof(RbuUpdateStmt)+pIter->nTblCol+1); + } + + if( pUp ){ + char *zWhere = rbuObjIterGetWhere(p, pIter); + char *zSet = rbuObjIterGetSetlist(p, pIter, zMask); + char *zUpdate = 0; + + pUp->zMask = (char*)&pUp[1]; + memcpy(pUp->zMask, zMask, pIter->nTblCol); + pUp->pNext = pIter->pRbuUpdate; + pIter->pRbuUpdate = pUp; + + if( zSet ){ + const char *zPrefix = ""; + + if( pIter->eType!=RBU_PK_VTAB ) zPrefix = "rbu_imp_"; + zUpdate = sqlite3_mprintf("UPDATE \"%s%w\" SET %s WHERE %s", + zPrefix, pIter->zTbl, zSet, zWhere + ); + p->rc = prepareFreeAndCollectError( + p->dbMain, &pUp->pUpdate, &p->zErrmsg, zUpdate + ); + *ppStmt = pUp->pUpdate; + } + sqlite3_free(zWhere); + sqlite3_free(zSet); + } + + return p->rc; +} + +static sqlite3 *rbuOpenDbhandle( + sqlite3rbu *p, + const char *zName, + int bUseVfs +){ + sqlite3 *db = 0; + if( p->rc==SQLITE_OK ){ + const int flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_URI; + p->rc = sqlite3_open_v2(zName, &db, flags, bUseVfs ? p->zVfsName : 0); + if( p->rc ){ + p->zErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(db)); + sqlite3_close(db); + db = 0; + } + } + return db; +} + +/* +** Free an RbuState object allocated by rbuLoadState(). +*/ +static void rbuFreeState(RbuState *p){ + if( p ){ + sqlite3_free(p->zTbl); + sqlite3_free(p->zDataTbl); + sqlite3_free(p->zIdx); + sqlite3_free(p); + } +} + +/* +** Allocate an RbuState object and load the contents of the rbu_state +** table into it. Return a pointer to the new object. It is the +** responsibility of the caller to eventually free the object using +** sqlite3_free(). +** +** If an error occurs, leave an error code and message in the rbu handle +** and return NULL. +*/ +static RbuState *rbuLoadState(sqlite3rbu *p){ + RbuState *pRet = 0; + sqlite3_stmt *pStmt = 0; + int rc; + int rc2; + + pRet = (RbuState*)rbuMalloc(p, sizeof(RbuState)); + if( pRet==0 ) return 0; + + rc = prepareFreeAndCollectError(p->dbRbu, &pStmt, &p->zErrmsg, + sqlite3_mprintf("SELECT k, v FROM %s.rbu_state", p->zStateDb) + ); + while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ + switch( sqlite3_column_int(pStmt, 0) ){ + case RBU_STATE_STAGE: + pRet->eStage = sqlite3_column_int(pStmt, 1); + if( pRet->eStage!=RBU_STAGE_OAL + && pRet->eStage!=RBU_STAGE_MOVE + && pRet->eStage!=RBU_STAGE_CKPT + ){ + p->rc = SQLITE_CORRUPT; + } + break; + + case RBU_STATE_TBL: + pRet->zTbl = rbuStrndup((char*)sqlite3_column_text(pStmt, 1), &rc); + break; + + case RBU_STATE_IDX: + pRet->zIdx = rbuStrndup((char*)sqlite3_column_text(pStmt, 1), &rc); + break; + + case RBU_STATE_ROW: + pRet->nRow = sqlite3_column_int(pStmt, 1); + break; + + case RBU_STATE_PROGRESS: + pRet->nProgress = sqlite3_column_int64(pStmt, 1); + break; + + case RBU_STATE_CKPT: + pRet->iWalCksum = sqlite3_column_int64(pStmt, 1); + break; + + case RBU_STATE_COOKIE: + pRet->iCookie = (u32)sqlite3_column_int64(pStmt, 1); + break; + + case RBU_STATE_OALSZ: + pRet->iOalSz = sqlite3_column_int64(pStmt, 1); + break; + + case RBU_STATE_PHASEONESTEP: + pRet->nPhaseOneStep = sqlite3_column_int64(pStmt, 1); + break; + + case RBU_STATE_DATATBL: + pRet->zDataTbl = rbuStrndup((char*)sqlite3_column_text(pStmt, 1), &rc); + break; + + default: + rc = SQLITE_CORRUPT; + break; + } + } + rc2 = sqlite3_finalize(pStmt); + if( rc==SQLITE_OK ) rc = rc2; + + p->rc = rc; + return pRet; +} + + +/* +** Open the database handle and attach the RBU database as "rbu". If an +** error occurs, leave an error code and message in the RBU handle. +** +** If argument dbMain is not NULL, then it is a database handle already +** open on the target database. Use this handle instead of opening a new +** one. +*/ +static void rbuOpenDatabase(sqlite3rbu *p, sqlite3 *dbMain, int *pbRetry){ + assert( p->rc || (p->dbMain==0 && p->dbRbu==0) ); + assert( p->rc || rbuIsVacuum(p) || p->zTarget!=0 ); + assert( dbMain==0 || rbuIsVacuum(p)==0 ); + + /* Open the RBU database */ + p->dbRbu = rbuOpenDbhandle(p, p->zRbu, 1); + p->dbMain = dbMain; + + if( p->rc==SQLITE_OK && rbuIsVacuum(p) ){ + sqlite3_file_control(p->dbRbu, "main", SQLITE_FCNTL_RBUCNT, (void*)p); + if( p->zState==0 ){ + const char *zFile = sqlite3_db_filename(p->dbRbu, "main"); + p->zState = rbuMPrintf(p, "file:///%s-vacuum?modeof=%s", zFile, zFile); + } + } + + /* If using separate RBU and state databases, attach the state database to + ** the RBU db handle now. */ + if( p->zState ){ + rbuMPrintfExec(p, p->dbRbu, "ATTACH %Q AS stat", p->zState); + memcpy(p->zStateDb, "stat", 4); + }else{ + memcpy(p->zStateDb, "main", 4); + } + +#if 0 + if( p->rc==SQLITE_OK && rbuIsVacuum(p) ){ + p->rc = sqlite3_exec(p->dbRbu, "BEGIN", 0, 0, 0); + } +#endif + + /* If it has not already been created, create the rbu_state table */ + rbuMPrintfExec(p, p->dbRbu, RBU_CREATE_STATE, p->zStateDb); + +#if 0 + if( rbuIsVacuum(p) ){ + if( p->rc==SQLITE_OK ){ + int rc2; + int bOk = 0; + sqlite3_stmt *pCnt = 0; + p->rc = prepareAndCollectError(p->dbRbu, &pCnt, &p->zErrmsg, + "SELECT count(*) FROM stat.sqlite_schema" + ); + if( p->rc==SQLITE_OK + && sqlite3_step(pCnt)==SQLITE_ROW + && 1==sqlite3_column_int(pCnt, 0) + ){ + bOk = 1; + } + rc2 = sqlite3_finalize(pCnt); + if( p->rc==SQLITE_OK ) p->rc = rc2; + + if( p->rc==SQLITE_OK && bOk==0 ){ + p->rc = SQLITE_ERROR; + p->zErrmsg = sqlite3_mprintf("invalid state database"); + } + + if( p->rc==SQLITE_OK ){ + p->rc = sqlite3_exec(p->dbRbu, "COMMIT", 0, 0, 0); + } + } + } +#endif + + if( p->rc==SQLITE_OK && rbuIsVacuum(p) ){ + int bOpen = 0; + int rc; + p->nRbu = 0; + p->pRbuFd = 0; + rc = sqlite3_file_control(p->dbRbu, "main", SQLITE_FCNTL_RBUCNT, (void*)p); + if( rc!=SQLITE_NOTFOUND ) p->rc = rc; + if( p->eStage>=RBU_STAGE_MOVE ){ + bOpen = 1; + }else{ + RbuState *pState = rbuLoadState(p); + if( pState ){ + bOpen = (pState->eStage>=RBU_STAGE_MOVE); + rbuFreeState(pState); + } + } + if( bOpen ) p->dbMain = rbuOpenDbhandle(p, p->zRbu, p->nRbu<=1); + } + + p->eStage = 0; + if( p->rc==SQLITE_OK && p->dbMain==0 ){ + if( !rbuIsVacuum(p) ){ + p->dbMain = rbuOpenDbhandle(p, p->zTarget, 1); + }else if( p->pRbuFd->pWalFd ){ + if( pbRetry ){ + p->pRbuFd->bNolock = 0; + sqlite3_close(p->dbRbu); + sqlite3_close(p->dbMain); + p->dbMain = 0; + p->dbRbu = 0; + *pbRetry = 1; + return; + } + p->rc = SQLITE_ERROR; + p->zErrmsg = sqlite3_mprintf("cannot vacuum wal mode database"); + }else{ + char *zTarget; + char *zExtra = 0; + if( strlen(p->zRbu)>=5 && 0==memcmp("file:", p->zRbu, 5) ){ + zExtra = &p->zRbu[5]; + while( *zExtra ){ + if( *zExtra++=='?' ) break; + } + if( *zExtra=='\0' ) zExtra = 0; + } + + zTarget = sqlite3_mprintf("file:%s-vactmp?rbu_memory=1%s%s", + sqlite3_db_filename(p->dbRbu, "main"), + (zExtra==0 ? "" : "&"), (zExtra==0 ? "" : zExtra) + ); + + if( zTarget==0 ){ + p->rc = SQLITE_NOMEM; + return; + } + p->dbMain = rbuOpenDbhandle(p, zTarget, p->nRbu<=1); + sqlite3_free(zTarget); + } + } + + if( p->rc==SQLITE_OK ){ + p->rc = sqlite3_create_function(p->dbMain, + "rbu_tmp_insert", -1, SQLITE_UTF8, (void*)p, rbuTmpInsertFunc, 0, 0 + ); + } + + if( p->rc==SQLITE_OK ){ + p->rc = sqlite3_create_function(p->dbMain, + "rbu_fossil_delta", 2, SQLITE_UTF8, 0, rbuFossilDeltaFunc, 0, 0 + ); + } + + if( p->rc==SQLITE_OK ){ + p->rc = sqlite3_create_function(p->dbRbu, + "rbu_target_name", -1, SQLITE_UTF8, (void*)p, rbuTargetNameFunc, 0, 0 + ); + } + + if( p->rc==SQLITE_OK ){ + p->rc = sqlite3_file_control(p->dbMain, "main", SQLITE_FCNTL_RBU, (void*)p); + } + rbuMPrintfExec(p, p->dbMain, "SELECT * FROM sqlite_schema"); + + /* Mark the database file just opened as an RBU target database. If + ** this call returns SQLITE_NOTFOUND, then the RBU vfs is not in use. + ** This is an error. */ + if( p->rc==SQLITE_OK ){ + p->rc = sqlite3_file_control(p->dbMain, "main", SQLITE_FCNTL_RBU, (void*)p); + } + + if( p->rc==SQLITE_NOTFOUND ){ + p->rc = SQLITE_ERROR; + p->zErrmsg = sqlite3_mprintf("rbu vfs not found"); + } +} + +/* +** This routine is a copy of the sqlite3FileSuffix3() routine from the core. +** It is a no-op unless SQLITE_ENABLE_8_3_NAMES is defined. +** +** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database +** filename in zBaseFilename is a URI with the "8_3_names=1" parameter and +** if filename in z[] has a suffix (a.k.a. "extension") that is longer than +** three characters, then shorten the suffix on z[] to be the last three +** characters of the original suffix. +** +** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always +** do the suffix shortening regardless of URI parameter. +** +** Examples: +** +** test.db-journal => test.nal +** test.db-wal => test.wal +** test.db-shm => test.shm +** test.db-mj7f3319fa => test.9fa +*/ +static void rbuFileSuffix3(const char *zBase, char *z){ +#ifdef SQLITE_ENABLE_8_3_NAMES +#if SQLITE_ENABLE_8_3_NAMES<2 + if( sqlite3_uri_boolean(zBase, "8_3_names", 0) ) +#endif + { + int i, sz; + sz = (int)strlen(z)&0xffffff; + for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){} + if( z[i]=='.' && sz>i+4 ) memmove(&z[i+1], &z[sz-3], 4); + } +#endif +} + +/* +** Return the current wal-index header checksum for the target database +** as a 64-bit integer. +** +** The checksum is store in the first page of xShmMap memory as an 8-byte +** blob starting at byte offset 40. +*/ +static i64 rbuShmChecksum(sqlite3rbu *p){ + i64 iRet = 0; + if( p->rc==SQLITE_OK ){ + sqlite3_file *pDb = p->pTargetFd->pReal; + u32 volatile *ptr; + p->rc = pDb->pMethods->xShmMap(pDb, 0, 32*1024, 0, (void volatile**)&ptr); + if( p->rc==SQLITE_OK ){ + iRet = ((i64)ptr[10] << 32) + ptr[11]; + } + } + return iRet; +} + +/* +** This function is called as part of initializing or reinitializing an +** incremental checkpoint. +** +** It populates the sqlite3rbu.aFrame[] array with the set of +** (wal frame -> db page) copy operations required to checkpoint the +** current wal file, and obtains the set of shm locks required to safely +** perform the copy operations directly on the file-system. +** +** If argument pState is not NULL, then the incremental checkpoint is +** being resumed. In this case, if the checksum of the wal-index-header +** following recovery is not the same as the checksum saved in the RbuState +** object, then the rbu handle is set to DONE state. This occurs if some +** other client appends a transaction to the wal file in the middle of +** an incremental checkpoint. +*/ +static void rbuSetupCheckpoint(sqlite3rbu *p, RbuState *pState){ + + /* If pState is NULL, then the wal file may not have been opened and + ** recovered. Running a read-statement here to ensure that doing so + ** does not interfere with the "capture" process below. */ + if( pState==0 ){ + p->eStage = 0; + if( p->rc==SQLITE_OK ){ + p->rc = sqlite3_exec(p->dbMain, "SELECT * FROM sqlite_schema", 0, 0, 0); + } + } + + /* Assuming no error has occurred, run a "restart" checkpoint with the + ** sqlite3rbu.eStage variable set to CAPTURE. This turns on the following + ** special behaviour in the rbu VFS: + ** + ** * If the exclusive shm WRITER or READ0 lock cannot be obtained, + ** the checkpoint fails with SQLITE_BUSY (normally SQLite would + ** proceed with running a passive checkpoint instead of failing). + ** + ** * Attempts to read from the *-wal file or write to the database file + ** do not perform any IO. Instead, the frame/page combinations that + ** would be read/written are recorded in the sqlite3rbu.aFrame[] + ** array. + ** + ** * Calls to xShmLock(UNLOCK) to release the exclusive shm WRITER, + ** READ0 and CHECKPOINT locks taken as part of the checkpoint are + ** no-ops. These locks will not be released until the connection + ** is closed. + ** + ** * Attempting to xSync() the database file causes an SQLITE_NOTICE + ** error. + ** + ** As a result, unless an error (i.e. OOM or SQLITE_BUSY) occurs, the + ** checkpoint below fails with SQLITE_NOTICE, and leaves the aFrame[] + ** array populated with a set of (frame -> page) mappings. Because the + ** WRITER, CHECKPOINT and READ0 locks are still held, it is safe to copy + ** data from the wal file into the database file according to the + ** contents of aFrame[]. + */ + if( p->rc==SQLITE_OK ){ + int rc2; + p->eStage = RBU_STAGE_CAPTURE; + rc2 = sqlite3_exec(p->dbMain, "PRAGMA main.wal_checkpoint=restart", 0, 0,0); + if( rc2!=SQLITE_NOTICE ) p->rc = rc2; + } + + if( p->rc==SQLITE_OK && p->nFrame>0 ){ + p->eStage = RBU_STAGE_CKPT; + p->nStep = (pState ? pState->nRow : 0); + p->aBuf = rbuMalloc(p, p->pgsz); + p->iWalCksum = rbuShmChecksum(p); + } + + if( p->rc==SQLITE_OK ){ + if( p->nFrame==0 || (pState && pState->iWalCksum!=p->iWalCksum) ){ + p->rc = SQLITE_DONE; + p->eStage = RBU_STAGE_DONE; + }else{ + int nSectorSize; + sqlite3_file *pDb = p->pTargetFd->pReal; + sqlite3_file *pWal = p->pTargetFd->pWalFd->pReal; + assert( p->nPagePerSector==0 ); + nSectorSize = pDb->pMethods->xSectorSize(pDb); + if( nSectorSize>p->pgsz ){ + p->nPagePerSector = nSectorSize / p->pgsz; + }else{ + p->nPagePerSector = 1; + } + + /* Call xSync() on the wal file. This causes SQLite to sync the + ** directory in which the target database and the wal file reside, in + ** case it has not been synced since the rename() call in + ** rbuMoveOalFile(). */ + p->rc = pWal->pMethods->xSync(pWal, SQLITE_SYNC_NORMAL); + } + } +} + +/* +** Called when iAmt bytes are read from offset iOff of the wal file while +** the rbu object is in capture mode. Record the frame number of the frame +** being read in the aFrame[] array. +*/ +static int rbuCaptureWalRead(sqlite3rbu *pRbu, i64 iOff, int iAmt){ + const u32 mReq = (1<mLock!=mReq ){ + pRbu->rc = SQLITE_BUSY; + return SQLITE_NOTICE_RBU; + } + + pRbu->pgsz = iAmt; + if( pRbu->nFrame==pRbu->nFrameAlloc ){ + int nNew = (pRbu->nFrameAlloc ? pRbu->nFrameAlloc : 64) * 2; + RbuFrame *aNew; + aNew = (RbuFrame*)sqlite3_realloc64(pRbu->aFrame, nNew * sizeof(RbuFrame)); + if( aNew==0 ) return SQLITE_NOMEM; + pRbu->aFrame = aNew; + pRbu->nFrameAlloc = nNew; + } + + iFrame = (u32)((iOff-32) / (i64)(iAmt+24)) + 1; + if( pRbu->iMaxFrame